tbftss/src/battle/ai.c

1165 lines
22 KiB
C
Raw Normal View History

2015-10-20 13:51:49 +02:00
/*
Copyright (C) 2015-2019,2022 Parallel Realities
2015-10-20 13:51:49 +02:00
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "../common.h"
2022-07-31 11:43:20 +02:00
#include "../battle/bullets.h"
2022-07-31 11:43:20 +02:00
#include "../battle/fighters.h"
#include "../battle/hud.h"
2022-07-31 11:43:20 +02:00
#include "../battle/mine.h"
#include "../battle/quadtree.h"
#include "../battle/script.h"
2022-07-31 11:43:20 +02:00
#include "../system/util.h"
#include "ai.h"
2022-07-31 11:43:20 +02:00
#define AI_EVADE 0
#define AI_FALLBACK 1
#define AI_HUNT 2
#define TURN_SPEED 4
#define TURN_THRESHOLD 2
2022-07-31 11:43:20 +02:00
extern Battle battle;
extern Colors colors;
extern Dev dev;
extern Entity *player;
extern Entity *self;
2015-10-20 13:51:49 +02:00
2015-12-14 09:15:41 +01:00
static void faceTarget(Entity *e);
2022-07-31 11:43:20 +02:00
static int isInFOV(Entity *e, int fov);
2015-10-20 13:51:49 +02:00
static void preAttack(void);
static void huntTarget(void);
static void huntAndAttackTarget(void);
2015-12-24 22:42:26 +01:00
static void moveToTargetLocation(void);
2015-10-20 13:51:49 +02:00
static void nextAction(void);
static void findTarget(void);
2022-07-31 11:43:20 +02:00
static int hasClearShot(void);
static void fallback(void);
2015-10-20 13:51:49 +02:00
static void moveToPlayer(void);
2022-07-31 11:43:20 +02:00
static int canAttack(Entity *e);
static int selectWeapon(int type);
static int nearJumpgate(void);
static void moveToJumpgate(void);
2022-07-31 11:43:20 +02:00
static int nearEnemies(void);
static int nearItems(void);
static int nearMines(void);
static void moveToItem(void);
2022-07-31 11:43:20 +02:00
static int nearTowableCraft(void);
static void moveToTowableCraft(void);
2022-07-31 11:43:20 +02:00
static int lookForPlayer(void);
static int lookForLeader(void);
static void fleeEnemies(void);
2022-07-31 11:43:20 +02:00
static int isRetreating(void);
static int getActionChance(int type);
2015-11-15 14:26:34 +01:00
static void doFighterAI(void);
2015-12-10 11:16:27 +01:00
static void doGunAI(void);
2015-12-18 13:02:01 +01:00
static void moveToLeader(void);
2015-12-24 22:42:26 +01:00
static void wander(void);
static void doWander(void);
2022-07-31 11:43:20 +02:00
static int selectWeaponForTarget(Entity *e);
2016-04-01 15:19:03 +02:00
static void deployMine(void);
2022-07-31 11:43:20 +02:00
static int isSurrendering(void);
static void doSurrender(void);
static void fleeWithinBattleArea(int x, int y, int numEnemies);
2022-07-31 11:43:20 +02:00
static int evadeNonKillTargets(void);
2015-10-20 13:51:49 +02:00
void doAI(void)
2015-11-15 14:26:34 +01:00
{
2016-04-01 15:19:03 +02:00
if (self->aiFlags & AIF_DROPS_MINES)
{
deployMine();
}
2019-11-07 09:13:57 +01:00
if ((self->aiFlags & AIF_SURRENDERS) && (battle.stats[STAT_TIME] % 6 == 0) && isSurrendering())
{
return;
}
2019-11-07 09:13:57 +01:00
if ((self->aiFlags & (AIF_AVOIDS_COMBAT | AIF_EVADE)) && nearEnemies())
2015-11-15 14:26:34 +01:00
{
return;
2015-11-15 14:26:34 +01:00
}
2019-11-07 09:13:57 +01:00
if ((self->aiFlags & AIF_DEFENSIVE) && rand() % 10 && nearEnemies())
{
return;
}
2019-11-07 09:13:57 +01:00
2016-04-01 12:40:09 +02:00
if (nearMines())
{
return;
}
2019-11-07 09:13:57 +01:00
if ((self->aiFlags & AIF_GOAL_JUMPGATE) && nearJumpgate())
{
2016-03-13 11:52:12 +01:00
/* near jumpgate, but you might decide to continue to fight, anyway */
if ((self->aiFlags & AIF_COVERS_RETREAT) && rand() % 3)
{
return;
}
}
2019-11-07 09:13:57 +01:00
if ((self->aiFlags & AIF_COLLECTS_ITEMS) && nearItems())
{
return;
}
2019-11-07 09:13:57 +01:00
if (self->aiFlags & AIF_TOWS)
{
if (!self->towing && nearTowableCraft())
{
return;
}
}
2019-11-07 09:13:57 +01:00
2015-11-21 18:37:23 +01:00
if ((self->aiFlags & AIF_RETREATS) && (battle.stats[STAT_TIME] % 60 == 0) && isRetreating())
{
return;
}
2019-11-07 09:13:57 +01:00
if (!(self->aiFlags & AIF_AVOIDS_COMBAT))
2015-11-15 14:26:34 +01:00
{
if (self->speed)
2015-12-10 11:16:27 +01:00
{
doFighterAI();
}
else
{
doGunAI();
}
2019-11-07 09:13:57 +01:00
return;
2015-11-15 14:26:34 +01:00
}
2019-11-07 09:13:57 +01:00
if (self->aiFlags & AIF_MOVES_TO_LEADER && lookForLeader())
{
return;
}
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
if ((self->aiFlags & (AIF_FOLLOWS_PLAYER | AIF_MOVES_TO_PLAYER)) && lookForPlayer())
{
return;
}
2019-11-07 09:13:57 +01:00
2015-12-24 22:42:26 +01:00
if (self->aiFlags & AIF_WANDERS)
{
doWander();
return;
2015-12-24 22:42:26 +01:00
}
2019-11-07 09:13:57 +01:00
/* no idea - just stay where you are */
applyFighterBrakes();
2015-11-15 14:26:34 +01:00
}
static void doFighterAI(void)
2015-10-20 13:51:49 +02:00
{
int r;
2019-11-07 09:13:57 +01:00
2015-11-14 14:03:57 +01:00
/* don't hold a grudge against current target */
2015-11-20 23:52:48 +01:00
if ((self->target != NULL && self->target->health <= 0) || rand() % 5 == 0)
{
2015-11-15 14:26:34 +01:00
self->action = doAI;
self->target = NULL;
}
2015-10-29 17:18:41 +01:00
2016-05-15 09:19:26 +02:00
if (!self->target || (self->target->systemPower <= 0 && (self->target->flags & EF_MUST_DISABLE)))
2015-10-20 13:51:49 +02:00
{
findTarget();
2019-11-07 09:13:57 +01:00
2015-12-10 11:16:27 +01:00
if (!self->target)
2015-10-20 13:51:49 +02:00
{
if (!evadeNonKillTargets())
2015-12-18 13:02:01 +01:00
{
/* move to leader and wander take priority over move to player */
if (self->aiFlags & AIF_MOVES_TO_LEADER)
2015-12-18 13:02:01 +01:00
{
if (!lookForLeader())
{
if (self->aiFlags & AIF_MOVES_TO_PLAYER && player->alive == ALIVE_ALIVE)
{
moveToPlayer();
}
else
{
applyFighterBrakes();
}
}
2015-12-18 13:02:01 +01:00
}
else if (self->aiFlags & AIF_WANDERS)
{
doWander();
}
else if (self->aiFlags & AIF_MOVES_TO_PLAYER && player->alive == ALIVE_ALIVE)
{
moveToPlayer();
}
else
{
applyFighterBrakes();
}
2015-10-20 13:51:49 +02:00
}
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
return;
}
}
2019-11-07 09:13:57 +01:00
/* don't start dodging, etc., if you're far from your target */
if (getDistance(self->x, self->y, self->target->x, self->target->y) > SCREEN_WIDTH)
{
self->action = huntTarget;
self->aiActionTime = FPS * 2;
return;
}
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
/* if your target is disabled, just shoot it..! */
r = (self->target->flags & EF_DISABLED) ? 100 : rand() % 100;
2019-11-07 09:13:57 +01:00
if (r <= getActionChance(AI_EVADE))
2015-10-20 13:51:49 +02:00
{
self->targetLocation.x = self->target->x + (rand() % 250 - rand() % 250);
self->targetLocation.y = self->target->y + (rand() % 250 - rand() % 250);
2015-12-24 22:42:26 +01:00
self->action = moveToTargetLocation;
2015-11-20 23:52:48 +01:00
self->aiActionTime = FPS;
2015-10-20 13:51:49 +02:00
}
else if (r <= getActionChance(AI_FALLBACK))
2015-10-20 13:51:49 +02:00
{
self->action = fallback;
self->aiActionTime = FPS * 2;
2015-10-20 13:51:49 +02:00
}
2015-11-15 14:26:34 +01:00
else if (r <= getActionChance(AI_HUNT))
2015-10-20 13:51:49 +02:00
{
self->action = huntTarget;
self->aiActionTime = FPS * 2;
}
else
{
self->action = huntAndAttackTarget;
self->aiActionTime = FPS * 3;
2015-10-20 13:51:49 +02:00
}
}
2015-12-10 11:16:27 +01:00
static void doGunAI(void)
{
int r;
2019-11-07 09:13:57 +01:00
2015-12-10 11:16:27 +01:00
/* don't hold a grudge against current target */
if ((self->target != NULL && self->target->health <= 0) || rand() % 5 == 0)
{
self->action = doAI;
self->target = NULL;
}
if (!self->target || self->target->systemPower <= 0)
{
findTarget();
2019-11-07 09:13:57 +01:00
2015-12-10 11:16:27 +01:00
if (!self->target)
{
return;
}
}
2019-11-07 09:13:57 +01:00
2015-12-10 11:16:27 +01:00
r = rand() % 100;
2019-11-07 09:13:57 +01:00
2015-12-10 11:16:27 +01:00
if (r <= 50)
{
self->action = huntTarget;
self->aiActionTime = FPS * 3;
}
else
{
self->action = huntAndAttackTarget;
self->aiActionTime = FPS;
}
}
2015-11-15 14:26:34 +01:00
static int getActionChance(int type)
{
switch (type)
{
case AI_EVADE:
return 25 - (self->aiAggression * 4);
2019-11-07 09:13:57 +01:00
case AI_FALLBACK:
return 55 - (self->aiAggression * 4);
2019-11-07 09:13:57 +01:00
2015-11-15 14:26:34 +01:00
case AI_HUNT:
return 85 - (self->aiAggression * 4);
2015-11-15 14:26:34 +01:00
}
2019-11-07 09:13:57 +01:00
2015-11-15 14:26:34 +01:00
return 100;
}
2015-10-20 13:51:49 +02:00
static void huntTarget(void)
{
faceTarget(self->target);
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
applyFighterThrust();
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
nextAction();
}
static void huntAndAttackTarget(void)
{
int dist = getDistance(self->x, self->y, self->target->x, self->target->y);
int range = self->aiFlags & AIF_LONG_RANGE_FIRE ? (SCREEN_WIDTH * 1.5) : SCREEN_HEIGHT;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
faceTarget(self->target);
2019-11-07 09:13:57 +01:00
if (dist <= range && hasClearShot())
2015-10-20 13:51:49 +02:00
{
preAttack();
}
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
if (dist <= 250)
{
applyFighterBrakes();
}
else
{
applyFighterThrust();
}
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
nextAction();
}
static void findTarget(void)
{
2022-07-31 11:43:20 +02:00
int i;
Entity *e, **candidates;
unsigned int dist, closest;
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
dist = closest = (battle.isEpic || (self->aiFlags & AIF_UNLIMITED_RANGE)) ? MAX_TARGET_RANGE : SCREEN_WIDTH;
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
candidates = getAllEntsInRadius(self->x, self->y, dist, self);
2019-11-07 09:13:57 +01:00
self->target = NULL;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (i = 0, e = candidates[i]; e != NULL; e = candidates[++i])
2015-10-20 13:51:49 +02:00
{
if (canAttack(e) && selectWeaponForTarget(e))
2015-10-20 13:51:49 +02:00
{
2015-11-14 14:03:57 +01:00
dist = getDistance(self->x, self->y, e->x, e->y);
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
if (dist < closest)
{
self->target = e;
closest = dist;
2015-10-20 13:51:49 +02:00
}
}
}
}
2015-12-14 09:15:41 +01:00
static int canAttack(Entity *e)
{
if (!e->active || e->side == self->side || e->health <= 0 || (e->flags & EF_AI_IGNORE))
2016-03-29 08:09:26 +02:00
{
return 0;
}
2019-11-07 09:13:57 +01:00
2016-03-29 08:09:26 +02:00
if (!(e->flags & EF_TAKES_DAMAGE))
{
return 0;
}
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
if (!(self->aiFlags & AIF_ASSASSIN))
{
2016-05-15 09:19:26 +02:00
if (e->flags & EF_MUST_DISABLE)
{
2016-05-15 09:19:26 +02:00
return e->systemPower > 0;
}
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
if (!(e->flags & EF_AI_TARGET))
{
if (e->aiFlags & (AIF_AVOIDS_COMBAT | AIF_EVADE) || e->flags & EF_SECONDARY_TARGET)
{
return !(rand() % 5);
}
}
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
/* low chance of attacking something else */
if ((self->aiFlags & AIF_TARGET_FOCUS) && (!(e->flags & EF_AI_TARGET)))
{
return !(rand() % 100);
}
2016-03-29 23:45:46 +02:00
}
2019-11-07 09:13:57 +01:00
return 1;
2016-03-29 08:09:26 +02:00
}
static int selectWeaponForTarget(Entity *e)
{
self->selectedGunType = self->guns[0].type;
2019-11-07 09:13:57 +01:00
/* if you're an assassin, just kill the target */
2016-04-19 13:50:27 +02:00
if (!(self->aiFlags & AIF_ASSASSIN))
{
if (e->flags & EF_MUST_DISABLE)
{
2016-05-15 09:19:26 +02:00
return selectWeapon(BT_MAG);
}
2019-11-07 09:13:57 +01:00
if (e->flags & EF_NO_KILL)
{
if (!(e->flags & EF_DISABLED))
{
return selectWeapon(BT_LASER) || selectWeapon(BT_MAG);
}
2019-11-07 09:13:57 +01:00
return 0;
}
}
2019-11-07 09:13:57 +01:00
2015-12-14 09:15:41 +01:00
if (e->shield > 0)
{
selectWeapon(BT_LASER);
}
2019-11-07 09:13:57 +01:00
return 1;
}
static int selectWeapon(int type)
{
int i;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (i = 0; i < MAX_FIGHTER_GUNS; i++)
{
if (self->guns[i].type == type)
{
self->selectedGunType = type;
return 1;
}
}
2019-11-07 09:13:57 +01:00
return 0;
}
2015-12-14 09:15:41 +01:00
static void faceTarget(Entity *e)
2015-10-20 13:51:49 +02:00
{
int dir;
2015-12-14 09:15:41 +01:00
int wantedAngle = getAngle(self->x, self->y, e->x, e->y);
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
wantedAngle %= 360;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
if (fabs(wantedAngle - self->angle) > TURN_THRESHOLD)
{
dir = ((int)(wantedAngle - self->angle + 360)) % 360 > 180 ? -1 : 1;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
self->angle += dir * TURN_SPEED;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
self->angle = mod(self->angle, 360);
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
applyFighterBrakes();
}
}
2015-12-14 09:15:41 +01:00
static int isInFOV(Entity *e, int fov)
2015-10-20 13:51:49 +02:00
{
int angle, a, b;
a = mod(self->angle - fov, 360);
b = mod(self->angle + fov, 360);
2015-12-14 09:15:41 +01:00
angle = getAngle(self->x, self->y, e->x, e->y);
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
return (a < b) ? (a <= angle && angle <= b) : (a <= angle || angle <= b);
}
static int hasClearShot(void)
{
2022-07-31 11:43:20 +02:00
int dist;
Entity *e;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
if (isInFOV(self->target, 4))
{
dist = getDistance(self->x, self->y, self->target->x, self->target->y);
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (e = battle.entityHead.next; e != NULL; e = e->next)
2015-10-20 13:51:49 +02:00
{
2015-12-10 11:16:27 +01:00
if (self->owner != NULL && self->owner == e->owner)
{
continue;
}
2019-11-07 09:13:57 +01:00
if (e->active && e != self && e != self->owner && e != self->target && (getDistance(self->x, self->y, e->x, e->y) < dist))
2015-10-20 13:51:49 +02:00
{
if (isInFOV(e, 8))
2015-10-20 13:51:49 +02:00
{
return 0;
}
}
}
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
return 1;
}
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
return 0;
}
static void preAttack(void)
{
if (!self->reload && !dev.noAIWeapons)
2015-10-20 13:51:49 +02:00
{
2015-11-22 09:17:29 +01:00
if (!(self->aiFlags & AIF_MISSILE_BOAT))
2015-10-30 22:55:01 +01:00
{
2015-11-22 09:17:29 +01:00
/* force weapon selection, otherwise we'll keep using lasers / mag */
2016-03-29 08:09:26 +02:00
selectWeaponForTarget(self->target);
2019-11-07 09:13:57 +01:00
2015-11-22 09:17:29 +01:00
if (self->guns[0].type && (self->missiles == 0 || rand() % 50 > 0))
{
fireGuns(self);
2015-11-22 09:17:29 +01:00
}
2022-07-31 11:43:20 +02:00
else if (self->missiles && (!(self->target->flags & (EF_NO_KILL | EF_MUST_DISABLE | EF_FRIENDLY_HEALTH_BAR))) && getDistance(self->x, self->y, self->target->x, self->target->y) >= 350)
2015-11-22 09:17:29 +01:00
{
fireMissile(self);
2019-11-07 09:13:57 +01:00
self->action = doAI;
2015-11-22 09:17:29 +01:00
}
2015-10-30 22:55:01 +01:00
}
else if (!(self->target->flags & EF_NO_KILL))
2015-10-30 22:55:01 +01:00
{
2015-11-22 09:17:29 +01:00
fireRocket(self);
2019-11-07 09:13:57 +01:00
2015-11-22 09:17:29 +01:00
/* don't constantly fire rockets like normal guns */
if (rand() % 3)
2015-11-22 09:17:29 +01:00
{
self->action = doAI;
}
2015-10-30 22:55:01 +01:00
}
2015-10-20 13:51:49 +02:00
}
}
static void turnToFace(int wantedAngle)
2015-10-20 13:51:49 +02:00
{
int dir;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
wantedAngle %= 360;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
if (fabs(wantedAngle - self->angle) > TURN_THRESHOLD)
{
dir = ((int)(wantedAngle - self->angle + 360)) % 360 > 180 ? -1 : 1;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
self->angle += dir * TURN_SPEED;
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
self->angle = mod(self->angle, 360);
}
}
static void turnAndFly(int wantedAngle)
{
turnToFace(wantedAngle);
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
applyFighterThrust();
nextAction();
}
2015-12-24 22:42:26 +01:00
static void moveToTargetLocation(void)
{
2015-11-20 23:52:48 +01:00
int wantedAngle = getAngle(self->x, self->y, self->targetLocation.x, self->targetLocation.y);
2019-11-07 09:13:57 +01:00
turnAndFly(wantedAngle);
}
static void fallback(void)
{
int wantedAngle = 180 + getAngle(self->x, self->y, self->target->x, self->target->y);
2019-11-07 09:13:57 +01:00
turnAndFly(wantedAngle);
}
2015-11-15 14:26:34 +01:00
static void nextAction(void)
{
if (--self->aiActionTime <= 0)
{
self->action = doAI;
}
}
2015-11-21 18:37:23 +01:00
static int isRetreating(void)
{
2015-11-22 14:06:19 +01:00
float chance;
2019-11-07 09:13:57 +01:00
2015-11-21 18:37:23 +01:00
if (!(self->flags & EF_RETREATING))
{
2015-11-22 14:06:19 +01:00
if (battle.numInitialEnemies > 0)
2015-11-21 18:37:23 +01:00
{
2015-11-22 14:06:19 +01:00
chance = battle.numEnemies;
chance /= battle.numInitialEnemies;
chance *= 256;
2019-11-07 09:13:57 +01:00
2015-11-22 14:06:19 +01:00
if (battle.numEnemies > 0 && rand() % 100 > chance)
{
self->flags |= EF_RETREATING;
2019-11-07 09:13:57 +01:00
2015-11-22 14:06:19 +01:00
self->aiFlags |= AIF_AVOIDS_COMBAT;
self->aiFlags |= AIF_UNLIMITED_RANGE;
self->aiFlags |= AIF_GOAL_JUMPGATE;
2019-11-07 09:13:57 +01:00
2016-02-28 14:45:17 +01:00
addHudMessage(colors.red, _("%s is retreating!"), self->name);
2019-11-07 09:13:57 +01:00
2015-11-22 14:06:19 +01:00
return 1;
}
2015-11-21 18:37:23 +01:00
}
}
2019-11-07 09:13:57 +01:00
2015-11-21 18:37:23 +01:00
return self->flags & EF_RETREATING;
}
static int isSurrendering(void)
{
float chance;
2019-11-07 09:13:57 +01:00
if (!(self->aiFlags & AIF_SURRENDERED))
{
if (self->health < self->maxHealth)
{
chance = self->health;
chance /= self->maxHealth;
chance *= 100;
2019-11-07 09:13:57 +01:00
if (rand() % 100 > chance)
{
self->aiActionTime = FPS * 3;
2019-11-07 09:13:57 +01:00
self->aiFlags |= AIF_AVOIDS_COMBAT;
self->aiFlags |= AIF_SURRENDERING;
self->aiFlags &= ~AIF_SURRENDERS;
2019-11-07 09:13:57 +01:00
self->flags |= EF_MUST_DISABLE;
self->flags |= EF_MISSION_TARGET;
2019-11-07 09:13:57 +01:00
2016-06-02 10:49:28 +02:00
nearEnemies();
2019-11-07 09:13:57 +01:00
self->action = doSurrender;
2019-11-07 09:13:57 +01:00
battle.stats[STAT_ENEMIES_SURRENDERED]++;
2019-11-07 09:13:57 +01:00
runScriptFunction("ENEMIES_SURRENDERED %d", battle.stats[STAT_ENEMIES_SURRENDERED]);
2019-11-07 09:13:57 +01:00
addHudMessage(colors.white, _("%s has surrendered"), self->name);
2019-11-07 09:13:57 +01:00
return 1;
}
}
}
2019-11-07 09:13:57 +01:00
return 0;
}
static void doSurrender(void)
{
if (--self->aiActionTime <= 0)
{
self->aiFlags &= ~AIF_SURRENDERING;
self->aiFlags |= AIF_SURRENDERED;
self->speed = 1.5;
2019-11-07 09:13:57 +01:00
nextAction();
}
}
2015-11-15 14:26:34 +01:00
static int nearEnemies(void)
{
2022-07-31 11:43:20 +02:00
int i, numEnemies, x, y;
2015-11-15 14:26:34 +01:00
Entity *e, **candidates;
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
candidates = getAllEntsInRadius(self->x, self->y, SCREEN_WIDTH, self);
2019-11-07 09:13:57 +01:00
2015-11-15 14:26:34 +01:00
self->target = NULL;
x = y = 0;
2019-11-07 09:13:57 +01:00
2015-11-15 14:26:34 +01:00
numEnemies = 0;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (i = 0, e = candidates[i]; e != NULL; e = candidates[++i])
2015-11-15 14:26:34 +01:00
{
if ((e->flags & EF_TAKES_DAMAGE) && e->side != SIDE_NONE && e->side != self->side && !(e->flags & EF_DISABLED))
2015-11-15 14:26:34 +01:00
{
2016-03-29 23:45:46 +02:00
if ((self->aiFlags & AIF_TARGET_FOCUS) && (e->flags & EF_AI_TARGET))
{
continue;
}
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
if (getDistance(e->x, e->y, self->x, self->y) <= SCREEN_WIDTH)
{
x += e->x;
y += e->y;
numEnemies++;
}
2015-11-15 14:26:34 +01:00
}
}
2019-11-07 09:13:57 +01:00
2015-11-15 14:26:34 +01:00
if (numEnemies)
{
fleeWithinBattleArea(x, y, numEnemies);
2019-11-07 09:13:57 +01:00
return 1;
}
2019-11-07 09:13:57 +01:00
return 0;
}
static int evadeNonKillTargets(void)
{
2022-07-31 11:43:20 +02:00
int i, numEnemies, x, y;
Entity *e, **candidates;
2019-11-07 09:13:57 +01:00
candidates = getAllEntsInRadius(self->x, self->y, SCREEN_WIDTH, self);
2019-11-07 09:13:57 +01:00
self->target = NULL;
x = y = 0;
2019-11-07 09:13:57 +01:00
numEnemies = 0;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (i = 0, e = candidates[i]; e != NULL; e = candidates[++i])
{
if ((e->flags & EF_TAKES_DAMAGE) && e->side != SIDE_NONE && e->side != self->side && (!(e->flags & EF_DISABLED)))
{
if (getDistance(e->x, e->y, self->x, self->y) <= SCREEN_WIDTH)
{
x += e->x;
y += e->y;
numEnemies++;
}
}
}
2019-11-07 09:13:57 +01:00
if (numEnemies)
{
fleeWithinBattleArea(x, y, numEnemies);
2019-11-07 09:13:57 +01:00
2016-04-01 12:40:09 +02:00
return 1;
}
2019-11-07 09:13:57 +01:00
2016-04-01 12:40:09 +02:00
return 0;
}
static void fleeWithinBattleArea(int x, int y, int numEnemies)
{
self->targetLocation.x = x;
self->targetLocation.y = y;
2019-11-07 09:13:57 +01:00
self->targetLocation.x /= numEnemies;
self->targetLocation.y /= numEnemies;
2019-11-07 09:13:57 +01:00
/* dodge slightly */
self->targetLocation.x += (rand() % 100 - rand() % 100);
self->targetLocation.y += (rand() % 100 - rand() % 100);
2019-11-07 09:13:57 +01:00
self->aiActionTime = FPS * 2;
2019-11-07 09:13:57 +01:00
2016-06-02 12:20:18 +02:00
if (self->targetLocation.x < SCREEN_WIDTH)
{
2016-06-02 12:20:18 +02:00
self->targetLocation.x = -SCREEN_WIDTH;
}
2019-11-07 09:13:57 +01:00
2016-06-02 12:20:18 +02:00
if (self->targetLocation.x >= BATTLE_AREA_WIDTH - SCREEN_WIDTH)
{
2016-06-02 12:20:18 +02:00
self->targetLocation.x = BATTLE_AREA_WIDTH;
}
2019-11-07 09:13:57 +01:00
2016-06-02 12:20:18 +02:00
if (self->targetLocation.y < SCREEN_HEIGHT)
{
self->targetLocation.y = -SCREEN_HEIGHT;
}
2019-11-07 09:13:57 +01:00
2016-06-02 12:20:18 +02:00
if (self->targetLocation.y >= BATTLE_AREA_HEIGHT - SCREEN_HEIGHT)
{
self->targetLocation.y = BATTLE_AREA_HEIGHT;
}
2019-11-07 09:13:57 +01:00
self->action = fleeEnemies;
}
2016-04-01 15:19:03 +02:00
static void deployMine(void)
{
Entity *mine;
2019-11-07 09:13:57 +01:00
2016-04-01 18:02:56 +02:00
if (!self->reload && self->thrust > 0)
2016-04-01 15:19:03 +02:00
{
2016-04-20 10:38:29 +02:00
mine = spawnMine(ET_MINE);
2016-04-01 15:19:03 +02:00
mine->x = self->x;
mine->y = self->y;
2016-04-01 18:02:56 +02:00
mine->dx = rand() % 20 - rand() % 20;
mine->dx *= 0.1;
mine->dy = rand() % 20 - rand() % 20;
mine->dy *= 0.1;
2016-04-01 15:19:03 +02:00
mine->side = self->side;
2019-11-07 09:13:57 +01:00
2016-04-01 18:02:56 +02:00
self->reload = rand() % (FPS * 3);
2016-04-01 15:19:03 +02:00
}
}
2016-04-01 12:40:09 +02:00
static int nearMines(void)
{
2022-07-31 11:43:20 +02:00
int i, numMines, x, y;
2016-04-01 12:40:09 +02:00
Entity *e, **candidates;
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
candidates = getAllEntsInRadius(self->x, self->y, SCREEN_HEIGHT, self);
2019-11-07 09:13:57 +01:00
x = y = 0;
2019-11-07 09:13:57 +01:00
2016-04-01 12:40:09 +02:00
numMines = 0;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (i = 0, e = candidates[i]; e != NULL; e = candidates[++i])
2016-04-01 12:40:09 +02:00
{
2016-05-15 09:19:26 +02:00
if (e->side != self->side && e->type == ET_MINE && getDistance(e->x, e->y, self->x, self->y) <= SCREEN_HEIGHT)
2016-04-01 12:40:09 +02:00
{
x += e->x;
y += e->y;
2016-04-01 12:40:09 +02:00
numMines++;
}
}
2019-11-07 09:13:57 +01:00
2016-04-01 12:40:09 +02:00
if (numMines)
{
fleeWithinBattleArea(x, y, numMines);
2019-11-07 09:13:57 +01:00
2015-11-15 14:26:34 +01:00
return 1;
}
2019-11-07 09:13:57 +01:00
2015-11-15 14:26:34 +01:00
return 0;
}
static void fleeEnemies(void)
2015-10-29 17:18:41 +01:00
{
2015-11-15 14:26:34 +01:00
int wantedAngle = 180 + getAngle(self->x, self->y, self->targetLocation.x, self->targetLocation.y);
2019-11-07 09:13:57 +01:00
turnAndFly(wantedAngle);
2019-11-07 09:13:57 +01:00
2015-11-21 18:37:23 +01:00
nextAction();
2015-10-20 13:51:49 +02:00
}
static void moveToPlayer(void)
{
int wantedAngle;
2015-10-20 13:51:49 +02:00
int dist = getDistance(self->x, self->y, player->x, player->y);
2019-11-07 09:13:57 +01:00
if (dist <= 250)
2015-10-20 13:51:49 +02:00
{
if (player->thrust > 0.1)
{
2016-05-15 09:19:26 +02:00
wantedAngle = getAngle(player->x, player->y, player->x + (player->dx * 1000), player->y + (player->dy * 1000));
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
turnToFace(wantedAngle);
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
if (self->thrust > player->thrust)
{
2016-05-15 09:19:26 +02:00
applyFighterBrakes();
}
else
{
applyFighterThrust();
}
}
else
{
applyFighterBrakes();
}
2015-10-20 13:51:49 +02:00
}
else
{
faceTarget(player);
2019-11-07 09:13:57 +01:00
2015-10-20 13:51:49 +02:00
applyFighterThrust();
}
}
static int nearJumpgate(void)
{
2015-11-20 23:52:48 +01:00
int dist;
2019-11-07 09:13:57 +01:00
self->target = NULL;
2019-11-07 09:13:57 +01:00
if (battle.jumpgate)
{
dist = getDistance(self->x, self->y, battle.jumpgate->x, battle.jumpgate->y);
2019-11-07 09:13:57 +01:00
2015-11-20 23:52:48 +01:00
if (dist <= 2000 || self->aiFlags & AIF_UNLIMITED_RANGE)
{
self->target = battle.jumpgate;
self->action = moveToJumpgate;
self->aiActionTime = (!self->towing) ? FPS / 2 : FPS * 2;
}
}
2019-11-07 09:13:57 +01:00
return self->target != NULL;
}
static void moveToJumpgate(void)
{
2016-05-15 09:19:26 +02:00
self->target = battle.jumpgate;
2019-11-07 09:13:57 +01:00
faceTarget(self->target);
2019-11-07 09:13:57 +01:00
applyFighterThrust();
2019-11-07 09:13:57 +01:00
2015-11-21 18:37:23 +01:00
nextAction();
}
static int nearItems(void)
{
2022-07-31 11:43:20 +02:00
int i;
long closest, distance;
Entity *e, **candidates;
2019-11-07 09:13:57 +01:00
closest = MAX_TARGET_RANGE;
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
candidates = getAllEntsInRadius(self->x, self->y, SCREEN_WIDTH / 2, self);
2019-11-07 09:13:57 +01:00
self->target = NULL;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (i = 0, e = candidates[i]; e != NULL; e = candidates[++i])
{
if (e->type == ET_ITEM)
{
distance = getDistance(self->x, self->y, e->x, e->y);
2019-11-07 09:13:57 +01:00
if (distance < closest)
{
self->target = e;
closest = distance;
}
}
}
2019-11-07 09:13:57 +01:00
if (self->target != NULL)
{
self->action = moveToItem;
2015-11-21 18:37:23 +01:00
self->aiActionTime = FPS / 2;
}
2019-11-07 09:13:57 +01:00
return self->target != NULL;
}
static void moveToItem(void)
{
if (self->target->alive == ALIVE_ALIVE)
{
faceTarget(self->target);
applyFighterThrust();
return;
}
2019-11-07 09:13:57 +01:00
self->target = NULL;
self->action = doAI;
}
static int nearTowableCraft(void)
{
2022-07-31 11:43:20 +02:00
int i;
long closest, dist;
2015-11-11 20:15:41 +01:00
Entity *e, **candidates;
2019-11-07 09:13:57 +01:00
dist = closest = (battle.isEpic || (self->aiFlags & AIF_UNLIMITED_RANGE)) ? MAX_TARGET_RANGE : 2000;
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
candidates = getAllEntsInRadius(self->x, self->y, dist, self);
2019-11-07 09:13:57 +01:00
self->target = NULL;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (i = 0, e = candidates[i]; e != NULL; e = candidates[++i])
{
2022-07-31 11:43:20 +02:00
if (!e->owner && (e->flags & (EF_DISABLED | EF_MISSION_TARGET)) == (EF_DISABLED | EF_MISSION_TARGET) && (e->flags & EF_ROPED_ATTACHED) == 0)
{
dist = getDistance(self->x, self->y, e->x, e->y);
2019-11-07 09:13:57 +01:00
if (dist < closest)
{
self->target = e;
closest = dist;
}
}
}
2019-11-07 09:13:57 +01:00
if (self->target != NULL)
{
self->action = moveToTowableCraft;
2015-11-21 18:37:23 +01:00
self->aiActionTime = FPS / 2;
}
2019-11-07 09:13:57 +01:00
return self->target != NULL;
}
static void moveToTowableCraft(void)
{
faceTarget(self->target);
2019-11-07 09:13:57 +01:00
applyFighterThrust();
2019-11-07 09:13:57 +01:00
nextAction();
}
static int lookForPlayer(void)
{
2015-11-28 15:33:05 +01:00
int range = (self->aiFlags & AIF_MOVES_TO_PLAYER) ? MAX_TARGET_RANGE : 2000;
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
if (player->alive == ALIVE_ALIVE && getDistance(self->x, self->y, player->x, player->y) < range)
{
moveToPlayer();
return 1;
}
2019-11-07 09:13:57 +01:00
return 0;
}
2015-12-18 13:02:01 +01:00
static int lookForLeader(void)
{
2022-07-31 11:43:20 +02:00
long closest, distance;
2015-12-18 13:02:01 +01:00
Entity *e;
2019-11-07 09:13:57 +01:00
2015-12-18 13:02:01 +01:00
self->leader = NULL;
closest = 0;
2019-11-07 09:13:57 +01:00
2022-07-31 11:43:20 +02:00
for (e = battle.entityHead.next; e != NULL; e = e->next)
2015-12-18 13:02:01 +01:00
{
if (e->active && e->flags & EF_AI_LEADER && e->side == self->side)
2015-12-18 13:02:01 +01:00
{
distance = getDistance(self->x, self->y, e->x, e->y);
2019-11-07 09:13:57 +01:00
if (!closest || distance < closest)
2015-12-18 13:02:01 +01:00
{
self->leader = e;
closest = distance;
}
}
}
2019-11-07 09:13:57 +01:00
2015-12-18 13:02:01 +01:00
if (self->leader)
{
2015-12-30 19:44:48 +01:00
self->aiActionTime = FPS;
self->action = moveToLeader;
2016-04-15 12:31:11 +02:00
self->aiActionTime = FPS + (rand() % FPS);
2015-12-18 13:02:01 +01:00
return 1;
}
2019-11-07 09:13:57 +01:00
2015-12-18 13:02:01 +01:00
return 0;
}
static void moveToLeader(void)
{
int wantedAngle;
2015-12-18 13:02:01 +01:00
int dist = getDistance(self->x, self->y, self->leader->x, self->leader->y);
2019-11-07 09:13:57 +01:00
2016-04-08 19:41:51 +02:00
if (dist <= ((self->leader->type != ET_CAPITAL_SHIP) ? 350 : 550))
2015-12-18 13:02:01 +01:00
{
if (self->leader->thrust > 0.1)
{
2016-03-16 07:53:20 +01:00
wantedAngle = getAngle(self->leader->x, self->leader->y, self->leader->x + (self->leader->dx * 1000), self->leader->y + (self->leader->dy * 1000));
2019-11-07 09:13:57 +01:00
turnToFace(wantedAngle);
2019-11-07 09:13:57 +01:00
2016-05-15 09:19:26 +02:00
if (self->thrust > self->leader->thrust)
{
2016-05-15 09:19:26 +02:00
applyFighterBrakes();
}
else
{
applyFighterThrust();
}
}
else
{
applyFighterBrakes();
}
2015-12-18 13:02:01 +01:00
}
else
{
faceTarget(self->leader);
2019-11-07 09:13:57 +01:00
2015-12-18 13:02:01 +01:00
applyFighterThrust();
}
2019-11-07 09:13:57 +01:00
2015-12-30 19:44:48 +01:00
nextAction();
2015-12-18 13:02:01 +01:00
}
2015-12-24 22:42:26 +01:00
static void doWander(void)
{
2016-02-21 08:48:22 +01:00
self->targetLocation.x = 500 + (rand() % (BATTLE_AREA_WIDTH - 1000));
self->targetLocation.y = 500 + (rand() % (BATTLE_AREA_HEIGHT - 1000));
2019-11-07 09:13:57 +01:00
2015-12-24 22:42:26 +01:00
self->aiActionTime = FPS * 15;
2019-11-07 09:13:57 +01:00
2015-12-30 19:44:48 +01:00
self->action = wander;
2015-12-24 22:42:26 +01:00
}
static void wander(void)
{
moveToTargetLocation();
2019-11-07 09:13:57 +01:00
if (nearEnemies() || getDistance(self->x, self->y, self->targetLocation.x, self->targetLocation.y) <= 100)
2015-12-24 22:42:26 +01:00
{
self->aiActionTime = 0;
}
}
/*
* Used only for the optional missions, in Pandoran-controlled space. We can therefore hardcode the response.
*/
void checkSuspicionLevel(void)
{
long distance;
2019-11-07 09:13:57 +01:00
2016-05-20 10:51:34 +02:00
if (battle.status == MS_IN_PROGRESS && player->side != SIDE_ALLIES)
{
battle.suspicionCoolOff = MAX(battle.suspicionCoolOff - 1, 0);
2019-11-07 09:13:57 +01:00
distance = getDistance(self->x, self->y, player->x, player->y);
2019-11-07 09:13:57 +01:00
/* raise if player is too far away and there are no enemies */
if (battle.suspicionCoolOff == 0 && battle.numEnemies == 0 && distance > SCREEN_HEIGHT)
{
battle.suspicionLevel++;
}
2019-11-07 09:13:57 +01:00
/* raise if there are enemies around, lower if none and player is close to leader */
if (battle.stats[STAT_TIME] % 5 == 0)
{
if (battle.numEnemies > 0)
{
battle.suspicionLevel++;
battle.suspicionCoolOff = FPS * 30;
}
else if (distance <= SCREEN_HEIGHT / 2)
{
battle.suspicionLevel--;
}
}
}
2015-12-24 22:42:26 +01:00
}
2016-05-20 10:51:34 +02:00
/* only used in final optional mission */
void checkZackariaSuspicionLevel(void)
{
if (battle.zackariaSuspicionLevel < MAX_ZAK_SUSPICION_LEVEL)
{
if (getDistance(self->x, self->y, player->x, player->y) < SCREEN_HEIGHT)
{
if (++battle.zackariaSuspicionLevel >= MAX_ZAK_SUSPICION_LEVEL)
{
runScriptFunction("Zackaria");
2019-11-07 09:13:57 +01:00
2016-05-20 10:51:34 +02:00
battle.unwinnable = 1;
2019-11-07 09:13:57 +01:00
2016-05-20 10:51:34 +02:00
battle.hasSuspicionLevel = 0;
2019-11-07 09:13:57 +01:00
2016-05-20 10:51:34 +02:00
self->thrust = self->speed = 0;
}
}
}
}