zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-13 07:57:52 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Moved bot specific functions into DBot.

Browse source
This commit is contained in:
ChillyDoom 2014-11-29 17:03:58 +00:00
parent a67ac5d940
commit e7da849f77
6 changed files with 335 additions and 351 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/b_bot.cpp
View file

@ -66,7 +66,7 @@ void DBot::Serialize (FArchive &arc)
arc << savedyaw arc << savedyaw
<< savedpitch; << savedpitch;
} }
else if (SaveVersion >= 4516) else
{ {
arc << player; arc << player;
} }
@ -105,7 +105,7 @@ void DBot::Tick ()
BotThinkCycles.Clock(); BotThinkCycles.Clock();
bglobal.m_Thinking = true; bglobal.m_Thinking = true;
bglobal.Think (player->mo, &netcmds[player - players][((gametic + 1)/ticdup)%BACKUPTICS]); Think ();
bglobal.m_Thinking = false; bglobal.m_Thinking = false;
BotThinkCycles.Unclock(); BotThinkCycles.Unclock();
} }

71
src/b_bot.h
View file

@ -89,7 +89,7 @@ public:
void ClearPlayer (int playernum, bool keepTeam); void ClearPlayer (int playernum, bool keepTeam);
//(B_Game.c) //(b_game.cpp)
void Main (); void Main ();
void Init (); void Init ();
void End(); void End();
@ -99,23 +99,16 @@ public:
bool LoadBots (); bool LoadBots ();
void ForgetBots (); void ForgetBots ();
//(B_Func.c) //(b_func.cpp)
bool Check_LOS (AActor *mobj1, AActor *mobj2, angle_t vangle);
void StartTravel (); void StartTravel ();
void FinishTravel (); void FinishTravel ();
bool IsLeader (player_t *player);
void SetBodyAt (fixed_t x, fixed_t y, fixed_t z, int hostnum);
fixed_t FakeFire (AActor *source, AActor *dest, ticcmd_t *cmd);
bool SafeCheckPosition (AActor *actor, fixed_t x, fixed_t y, FCheckPosition &tm);
//(B_Think.c) //(b_move.cpp)
void Think (AActor *actor, ticcmd_t *cmd);
void WhatToGet (AActor *actor, AActor *item);
//(B_move.c)
void Roam (AActor *actor, ticcmd_t *cmd);
bool Move (AActor *actor, ticcmd_t *cmd);
bool TryWalk (AActor *actor, ticcmd_t *cmd);
void NewChaseDir (AActor *actor, ticcmd_t *cmd);
bool CleanAhead (AActor *thing, fixed_t x, fixed_t y, ticcmd_t *cmd); bool CleanAhead (AActor *thing, fixed_t x, fixed_t y, ticcmd_t *cmd);
void TurnToAng (AActor *actor);
void Pitch (AActor *actor, AActor *target);
bool IsDangerous (sector_t *sec); bool IsDangerous (sector_t *sec);
TArray<FString> getspawned; //Array of bots (their names) which should be spawned when starting a game. TArray<FString> getspawned; //Array of bots (their names) which should be spawned when starting a game.
@ -132,24 +125,9 @@ public:
bool m_Thinking; bool m_Thinking;
private: private:
//(B_Game.c) //(b_game.cpp)
bool DoAddBot (BYTE *info, botskill_t skill); bool DoAddBot (BYTE *info, botskill_t skill);
//(B_Func.c)
bool Reachable (AActor *actor, AActor *target);
void Dofire (AActor *actor, ticcmd_t *cmd);
bool IsLeader (player_t *player);
AActor *Choose_Mate (AActor *bot);
AActor *Find_enemy (AActor *bot);
void SetBodyAt (fixed_t x, fixed_t y, fixed_t z, int hostnum);
fixed_t FakeFire (AActor *source, AActor *dest, ticcmd_t *cmd);
angle_t FireRox (AActor *bot, AActor *enemy, ticcmd_t *cmd);
bool SafeCheckPosition (AActor *actor, fixed_t x, fixed_t y, FCheckPosition &tm);
//(B_Think.c)
void ThinkForMove (AActor *actor, ticcmd_t *cmd);
void Set_enemy (AActor *actor);
protected: protected:
bool ctf; bool ctf;
int loaded_bots; int loaded_bots;
@ -168,13 +146,17 @@ public:
void Serialize (FArchive &arc); void Serialize (FArchive &arc);
void Tick (); void Tick ();
//(b_think.cpp)
void WhatToGet (AActor *item);
//(b_func.cpp)
bool Check_LOS (AActor *to, angle_t vangle);
player_t *player; player_t *player;
angle_t angle; // The wanted angle that the bot try to get every tic. angle_t angle; // The wanted angle that the bot try to get every tic.
// (used to get a smooth view movement) // (used to get a smooth view movement)
TObjPtr<AActor> dest; // Move Destination. TObjPtr<AActor> dest; // Move Destination.
TObjPtr<AActor> prev; // Previous move destination. TObjPtr<AActor> prev; // Previous move destination.
TObjPtr<AActor> enemy; // The dead meat. TObjPtr<AActor> enemy; // The dead meat.
TObjPtr<AActor> missile; // A threatening missile that needs to be avoided. TObjPtr<AActor> missile; // A threatening missile that needs to be avoided.
TObjPtr<AActor> mate; // Friend (used for grouping in teamplay or coop). TObjPtr<AActor> mate; // Friend (used for grouping in teamplay or coop).
@ -204,6 +186,27 @@ public:
fixed_t oldx; fixed_t oldx;
fixed_t oldy; fixed_t oldy;
private:
//(B_think.cpp)
void Think ();
void ThinkForMove (ticcmd_t *cmd);
void Set_enemy ();
//(B_func.cpp)
bool Reachable (AActor *target);
void Dofire (ticcmd_t *cmd);
AActor *Choose_Mate ();
AActor *Find_enemy ();
angle_t FireRox (AActor *enemy, ticcmd_t *cmd);
//(b_move.cpp)
void Roam (ticcmd_t *cmd);
bool Move (ticcmd_t *cmd);
bool TryWalk (ticcmd_t *cmd);
void NewChaseDir (ticcmd_t *cmd);
void TurnToAng ();
void Pitch (AActor *target);
}; };
@ -220,7 +223,3 @@ EXTERN_CVAR (Bool, bot_watersplash)
EXTERN_CVAR (Bool, bot_chat) EXTERN_CVAR (Bool, bot_chat)
#endif // __B_BOT_H__ #endif // __B_BOT_H__

200
src/b_func.cpp
View file

@ -24,24 +24,23 @@
static FRandom pr_botdofire ("BotDoFire"); static FRandom pr_botdofire ("BotDoFire");
//Checks TRUE reachability from //Checks TRUE reachability from bot to a looker.
//one looker to another. First mobj (looker) is looker. bool DBot::Reachable (AActor *rtarget)
bool FCajunMaster::Reachable (AActor *looker, AActor *rtarget)
{ {
if (looker == rtarget) if (player->mo == rtarget)
return false; return false;
if ((rtarget->Sector->ceilingplane.ZatPoint (rtarget->x, rtarget->y) - if ((rtarget->Sector->ceilingplane.ZatPoint (rtarget->x, rtarget->y) -
rtarget->Sector->floorplane.ZatPoint (rtarget->x, rtarget->y)) rtarget->Sector->floorplane.ZatPoint (rtarget->x, rtarget->y))
< looker->height) //Where rtarget is, looker can't be. < player->mo->height) //Where rtarget is, player->mo can't be.
return false; return false;
sector_t *last_s = looker->Sector; sector_t *last_s = player->mo->Sector;
fixed_t last_z = last_s->floorplane.ZatPoint (looker->x, looker->y); fixed_t last_z = last_s->floorplane.ZatPoint (player->mo->x, player->mo->y);
fixed_t estimated_dist = P_AproxDistance (looker->x - rtarget->x, looker->y - rtarget->y); fixed_t estimated_dist = P_AproxDistance (player->mo->x - rtarget->x, player->mo->y - rtarget->y);
bool reachable = true; bool reachable = true;
FPathTraverse it(looker->x+looker->velx, looker->y+looker->vely, rtarget->x, rtarget->y, PT_ADDLINES|PT_ADDTHINGS); FPathTraverse it(player->mo->x+player->mo->velx, player->mo->y+player->mo->vely, rtarget->x, rtarget->y, PT_ADDLINES|PT_ADDTHINGS);
intercept_t *in; intercept_t *in;
while ((in = it.Next())) while ((in = it.Next()))
{ {
@ -55,8 +54,8 @@ bool FCajunMaster::Reachable (AActor *looker, AActor *rtarget)
frac = in->frac - FixedDiv (4*FRACUNIT, MAX_TRAVERSE_DIST); frac = in->frac - FixedDiv (4*FRACUNIT, MAX_TRAVERSE_DIST);
dist = FixedMul (frac, MAX_TRAVERSE_DIST); dist = FixedMul (frac, MAX_TRAVERSE_DIST);
hitx = it.Trace().x + FixedMul (looker->velx, frac); hitx = it.Trace().x + FixedMul (player->mo->velx, frac);
hity = it.Trace().y + FixedMul (looker->vely, frac); hity = it.Trace().y + FixedMul (player->mo->vely, frac);
if (in->isaline) if (in->isaline)
{ {
@ -76,7 +75,7 @@ bool FCajunMaster::Reachable (AActor *looker, AActor *rtarget)
if (!bglobal.IsDangerous (s) && //Any nukage/lava? if (!bglobal.IsDangerous (s) && //Any nukage/lava?
(floorheight <= (last_z+MAXMOVEHEIGHT) (floorheight <= (last_z+MAXMOVEHEIGHT)
&& ((ceilingheight == floorheight && line->special) && ((ceilingheight == floorheight && line->special)
|| (ceilingheight - floorheight) >= looker->height))) //Does it fit? || (ceilingheight - floorheight) >= player->mo->height))) //Does it fit?
{ {
last_z = floorheight; last_z = floorheight;
last_s = s; last_s = s;
@ -95,7 +94,7 @@ bool FCajunMaster::Reachable (AActor *looker, AActor *rtarget)
} }
thing = in->d.thing; thing = in->d.thing;
if (thing == looker) //Can't reach self in this case. if (thing == player->mo) //Can't reach self in this case.
continue; continue;
if (thing == rtarget && (rtarget->Sector->floorplane.ZatPoint (rtarget->x, rtarget->y) <= (last_z+MAXMOVEHEIGHT))) if (thing == rtarget && (rtarget->Sector->floorplane.ZatPoint (rtarget->x, rtarget->y) <= (last_z+MAXMOVEHEIGHT)))
{ {
@ -115,16 +114,16 @@ bool FCajunMaster::Reachable (AActor *looker, AActor *rtarget)
//if these conditions are true, the function returns true. //if these conditions are true, the function returns true.
//GOOD TO KNOW is that the player's view angle //GOOD TO KNOW is that the player's view angle
//in doom is 90 degrees infront. //in doom is 90 degrees infront.
bool FCajunMaster::Check_LOS (AActor *from, AActor *to, angle_t vangle) bool DBot::Check_LOS (AActor *to, angle_t vangle)
{ {
if (!P_CheckSight (from, to, SF_SEEPASTBLOCKEVERYTHING)) if (!P_CheckSight (player->mo, to, SF_SEEPASTBLOCKEVERYTHING))
return false; // out of sight return false; // out of sight
if (vangle == ANGLE_MAX) if (vangle == ANGLE_MAX)
return true; return true;
if (vangle == 0) if (vangle == 0)
return false; //Looker seems to be blind. return false; //Looker seems to be blind.
return (angle_t)abs (R_PointToAngle2 (from->x, from->y, to->x, to->y) - from->angle) <= vangle/2; return (angle_t)abs (R_PointToAngle2 (player->mo->x, player->mo->y, to->x, to->y) - player->mo->angle) <= vangle/2;
} }
//------------------------------------- //-------------------------------------
@ -132,7 +131,7 @@ bool FCajunMaster::Check_LOS (AActor *from, AActor *to, angle_t vangle)
//------------------------------------- //-------------------------------------
//The bot will check if it's time to fire //The bot will check if it's time to fire
//and do so if that is the case. //and do so if that is the case.
void FCajunMaster::Dofire (AActor *actor, ticcmd_t *cmd) void DBot::Dofire (ticcmd_t *cmd)
{ {
bool no_fire; //used to prevent bot from pumping rockets into nearby walls. bool no_fire; //used to prevent bot from pumping rockets into nearby walls.
int aiming_penalty=0; //For shooting at shading target, if screen is red, MAKEME: When screen red. int aiming_penalty=0; //For shooting at shading target, if screen is red, MAKEME: When screen red.
@ -140,49 +139,48 @@ void FCajunMaster::Dofire (AActor *actor, ticcmd_t *cmd)
fixed_t dist; fixed_t dist;
angle_t an; angle_t an;
int m; int m;
AActor *enemy = actor->player->Bot->enemy;
if (!enemy || !(enemy->flags & MF_SHOOTABLE) || enemy->health <= 0) if (!enemy || !(enemy->flags & MF_SHOOTABLE) || enemy->health <= 0)
return; return;
if (actor->player->ReadyWeapon == NULL) if (player->ReadyWeapon == NULL)
return; return;
if (actor->player->damagecount > actor->player->Bot->skill.isp) if (player->damagecount > skill.isp)
{ {
actor->player->Bot->first_shot = true; first_shot = true;
return; return;
} }
//Reaction skill thing. //Reaction skill thing.
if (actor->player->Bot->first_shot && if (first_shot &&
!(actor->player->ReadyWeapon->WeaponFlags & WIF_BOT_REACTION_SKILL_THING)) !(player->ReadyWeapon->WeaponFlags & WIF_BOT_REACTION_SKILL_THING))
{ {
actor->player->Bot->t_react = (100-actor->player->Bot->skill.reaction+1)/((pr_botdofire()%3)+3); t_react = (100-skill.reaction+1)/((pr_botdofire()%3)+3);
} }
actor->player->Bot->first_shot = false; first_shot = false;
if (actor->player->Bot->t_react) if (t_react)
return; return;
//MAKEME: Decrease the rocket suicides even more. //MAKEME: Decrease the rocket suicides even more.
no_fire = true; no_fire = true;
//actor->player->angle = R_PointToAngle2(actor->x, actor->y, actor->player->enemy->x, actor->player->enemy->y); //angle = R_PointToAngle2(player->mo->x, player->mo->y, player->enemy->x, player->enemy->y);
//Distance to enemy. //Distance to enemy.
dist = P_AproxDistance ((actor->x + actor->velx) - (enemy->x + enemy->velx), dist = P_AproxDistance ((player->mo->x + player->mo->velx) - (enemy->x + enemy->velx),
(actor->y + actor->vely) - (enemy->y + enemy->vely)); (player->mo->y + player->mo->vely) - (enemy->y + enemy->vely));
//FIRE EACH TYPE OF WEAPON DIFFERENT: Here should all the different weapons go. //FIRE EACH TYPE OF WEAPON DIFFERENT: Here should all the different weapons go.
if (actor->player->ReadyWeapon->WeaponFlags & WIF_MELEEWEAPON) if (player->ReadyWeapon->WeaponFlags & WIF_MELEEWEAPON)
{ {
if ((actor->player->ReadyWeapon->ProjectileType != NULL)) if ((player->ReadyWeapon->ProjectileType != NULL))
{ {
if (actor->player->ReadyWeapon->CheckAmmo (AWeapon::PrimaryFire, false, true)) if (player->ReadyWeapon->CheckAmmo (AWeapon::PrimaryFire, false, true))
{ {
// This weapon can fire a projectile and has enough ammo to do so // This weapon can fire a projectile and has enough ammo to do so
goto shootmissile; goto shootmissile;
} }
else if (!(actor->player->ReadyWeapon->WeaponFlags & WIF_AMMO_OPTIONAL)) else if (!(player->ReadyWeapon->WeaponFlags & WIF_AMMO_OPTIONAL))
{ {
// Ammo is required, so don't shoot. This is for weapons that shoot // Ammo is required, so don't shoot. This is for weapons that shoot
// missiles that die at close range, such as the powered-up Phoneix Rod. // missiles that die at close range, such as the powered-up Phoneix Rod.
@ -195,51 +193,51 @@ void FCajunMaster::Dofire (AActor *actor, ticcmd_t *cmd)
no_fire = (dist > (MELEERANGE*4)); no_fire = (dist > (MELEERANGE*4));
} }
} }
else if (actor->player->ReadyWeapon->WeaponFlags & WIF_BOT_BFG) else if (player->ReadyWeapon->WeaponFlags & WIF_BOT_BFG)
{ {
//MAKEME: This should be smarter. //MAKEME: This should be smarter.
if ((pr_botdofire()%200)<=actor->player->Bot->skill.reaction) if ((pr_botdofire()%200)<=skill.reaction)
if(Check_LOS(actor, actor->player->Bot->enemy, SHOOTFOV)) if(Check_LOS(enemy, SHOOTFOV))
no_fire = false; no_fire = false;
} }
else if (actor->player->ReadyWeapon->ProjectileType != NULL) else if (player->ReadyWeapon->ProjectileType != NULL)
{ {
if (actor->player->ReadyWeapon->WeaponFlags & WIF_BOT_EXPLOSIVE) if (player->ReadyWeapon->WeaponFlags & WIF_BOT_EXPLOSIVE)
{ {
//Special rules for RL //Special rules for RL
an = FireRox (actor, enemy, cmd); an = FireRox (enemy, cmd);
if(an) if(an)
{ {
actor->player->Bot->angle = an; angle = an;
//have to be somewhat precise. to avoid suicide. //have to be somewhat precise. to avoid suicide.
if (abs (actor->player->Bot->angle - actor->angle) < 12*ANGLE_1) if (abs (angle - player->mo->angle) < 12*ANGLE_1)
{ {
actor->player->Bot->t_rocket = 9; t_rocket = 9;
no_fire = false; no_fire = false;
} }
} }
} }
// prediction aiming // prediction aiming
shootmissile: shootmissile:
dist = P_AproxDistance (actor->x - enemy->x, actor->y - enemy->y); dist = P_AproxDistance (player->mo->x - enemy->x, player->mo->y - enemy->y);
m = dist / GetDefaultByType (actor->player->ReadyWeapon->ProjectileType)->Speed; m = dist / GetDefaultByType (player->ReadyWeapon->ProjectileType)->Speed;
SetBodyAt (enemy->x + enemy->velx*m*2, enemy->y + enemy->vely*m*2, enemy->z, 1); bglobal.SetBodyAt (enemy->x + enemy->velx*m*2, enemy->y + enemy->vely*m*2, enemy->z, 1);
actor->player->Bot->angle = R_PointToAngle2 (actor->x, actor->y, body1->x, body1->y); angle = R_PointToAngle2 (player->mo->x, player->mo->y, bglobal.body1->x, bglobal.body1->y);
if (Check_LOS (actor, enemy, SHOOTFOV)) if (Check_LOS (enemy, SHOOTFOV))
no_fire = false; no_fire = false;
} }
else else
{ {
//Other weapons, mostly instant hit stuff. //Other weapons, mostly instant hit stuff.
actor->player->Bot->angle = R_PointToAngle2 (actor->x, actor->y, enemy->x, enemy->y); angle = R_PointToAngle2 (player->mo->x, player->mo->y, enemy->x, enemy->y);
aiming_penalty = 0; aiming_penalty = 0;
if (enemy->flags & MF_SHADOW) if (enemy->flags & MF_SHADOW)
aiming_penalty += (pr_botdofire()%25)+10; aiming_penalty += (pr_botdofire()%25)+10;
if (enemy->Sector->lightlevel<WHATS_DARK/* && !(actor->player->powers & PW_INFRARED)*/) if (enemy->Sector->lightlevel<WHATS_DARK/* && !(player->powers & PW_INFRARED)*/)
aiming_penalty += pr_botdofire()%40;//Dark aiming_penalty += pr_botdofire()%40;//Dark
if (actor->player->damagecount) if (player->damagecount)
aiming_penalty += actor->player->damagecount; //Blood in face makes it hard to aim aiming_penalty += player->damagecount; //Blood in face makes it hard to aim
aiming_value = actor->player->Bot->skill.aiming - aiming_penalty; aiming_value = skill.aiming - aiming_penalty;
if (aiming_value <= 0) if (aiming_value <= 0)
aiming_value = 1; aiming_value = 1;
m = ((SHOOTFOV/2)-(aiming_value*SHOOTFOV/200)); //Higher skill is more accurate m = ((SHOOTFOV/2)-(aiming_value*SHOOTFOV/200)); //Higher skill is more accurate
@ -248,18 +246,18 @@ shootmissile:
if (m) if (m)
{ {
if (actor->player->Bot->increase) if (increase)
actor->player->Bot->angle += m; angle += m;
else else
actor->player->Bot->angle -= m; angle -= m;
} }
if (abs (actor->player->Bot->angle - actor->angle) < 4*ANGLE_1) if (abs (angle - player->mo->angle) < 4*ANGLE_1)
{ {
actor->player->Bot->increase = !actor->player->Bot->increase; increase = !increase;
} }
if (Check_LOS (actor, enemy, (SHOOTFOV/2))) if (Check_LOS (enemy, (SHOOTFOV/2)))
no_fire = false; no_fire = false;
} }
if (!no_fire) //If going to fire weapon if (!no_fire) //If going to fire weapon
@ -267,7 +265,7 @@ shootmissile:
cmd->ucmd.buttons |= BT_ATTACK; cmd->ucmd.buttons |= BT_ATTACK;
} }
//Prevents bot from jerking, when firing automatic things with low skill. //Prevents bot from jerking, when firing automatic things with low skill.
//actor->angle = R_PointToAngle2(actor->x, actor->y, actor->player->enemy->x, actor->player->enemy->y); //player->mo->angle = R_PointToAngle2(player->mo->x, player->mo->y, player->enemy->x, player->enemy->y);
} }
bool FCajunMaster::IsLeader (player_t *player) bool FCajunMaster::IsLeader (player_t *player)
@ -287,7 +285,7 @@ bool FCajunMaster::IsLeader (player_t *player)
//This function is called every //This function is called every
//tick (for each bot) to set //tick (for each bot) to set
//the mate (teammate coop mate). //the mate (teammate coop mate).
AActor *FCajunMaster::Choose_Mate (AActor *bot) AActor *DBot::Choose_Mate ()
{ {
int count; int count;
fixed_t closest_dist, test; fixed_t closest_dist, test;
@ -295,20 +293,20 @@ AActor *FCajunMaster::Choose_Mate (AActor *bot)
AActor *observer; AActor *observer;
//is mate alive? //is mate alive?
if (bot->player->Bot->mate) if (mate)
{ {
if (bot->player->Bot->mate->health <= 0) if (mate->health <= 0)
bot->player->Bot->mate = NULL; mate = NULL;
else else
bot->player->Bot->last_mate = bot->player->Bot->mate; last_mate = mate;
} }
if (bot->player->Bot->mate) //Still is.. if (mate) //Still is..
return bot->player->Bot->mate; return mate;
//Check old_mates status. //Check old_mates status.
if (bot->player->Bot->last_mate) if (last_mate)
if (bot->player->Bot->last_mate->health <= 0) if (last_mate->health <= 0)
bot->player->Bot->last_mate = NULL; last_mate = NULL;
target = NULL; target = NULL;
closest_dist = FIXED_MAX; closest_dist = FIXED_MAX;
@ -324,17 +322,17 @@ AActor *FCajunMaster::Choose_Mate (AActor *bot)
if (playeringame[count] if (playeringame[count]
&& client->mo && client->mo
&& bot != client->mo && player->mo != client->mo
&& (bot->IsTeammate (client->mo) || !deathmatch) && (player->mo->IsTeammate (client->mo) || !deathmatch)
&& client->mo->health > 0 && client->mo->health > 0
&& client->mo != observer && client->mo != observer
&& ((bot->health/2) <= client->mo->health || !deathmatch) && ((player->mo->health/2) <= client->mo->health || !deathmatch)
&& !IsLeader(client)) //taken? && !bglobal.IsLeader(client)) //taken?
{ {
if (P_CheckSight (bot, client->mo, SF_IGNOREVISIBILITY)) if (P_CheckSight (player->mo, client->mo, SF_IGNOREVISIBILITY))
{ {
test = P_AproxDistance (client->mo->x - bot->x, test = P_AproxDistance (client->mo->x - player->mo->x,
client->mo->y - bot->y); client->mo->y - player->mo->y);
if (test < closest_dist) if (test < closest_dist)
{ {
@ -347,15 +345,15 @@ AActor *FCajunMaster::Choose_Mate (AActor *bot)
/* /*
//Make a introducing to mate. //Make a introducing to mate.
if(target && target!=bot->player->last_mate) if(target && target!=last_mate)
{ {
if((P_Random()%(200*bglobal.botnum))<3) if((P_Random()%(200*bglobal.botnum))<3)
{ {
bot->player->chat = c_teamup; chat = c_teamup;
if(target->bot) if(target->bot)
strcpy(bot->player->c_target, botsingame[target->bot_id]); strcpy(c_target, botsingame[target->bot_id]);
else if(target->player) else if(target->player)
strcpy(bot->player->c_target, player_names[target->play_id]); strcpy(c_target, player_names[target->play_id]);
} }
} }
*/ */
@ -365,7 +363,7 @@ AActor *FCajunMaster::Choose_Mate (AActor *bot)
} }
//MAKEME: Make this a smart decision //MAKEME: Make this a smart decision
AActor *FCajunMaster::Find_enemy (AActor *bot) AActor *DBot::Find_enemy ()
{ {
int count; int count;
fixed_t closest_dist, temp; //To target. fixed_t closest_dist, temp; //To target.
@ -375,15 +373,15 @@ AActor *FCajunMaster::Find_enemy (AActor *bot)
if (!deathmatch) if (!deathmatch)
{ // [RH] Take advantage of the Heretic/Hexen code to be a little smarter { // [RH] Take advantage of the Heretic/Hexen code to be a little smarter
return P_RoughMonsterSearch (bot, 20); return P_RoughMonsterSearch (player->mo, 20);
} }
//Note: It's hard to ambush a bot who is not alone //Note: It's hard to ambush a bot who is not alone
if (bot->player->Bot->allround || bot->player->Bot->mate) if (allround || mate)
vangle = ANGLE_MAX; vangle = ANGLE_MAX;
else else
vangle = ENEMY_SCAN_FOV; vangle = ENEMY_SCAN_FOV;
bot->player->Bot->allround = false; allround = false;
target = NULL; target = NULL;
closest_dist = FIXED_MAX; closest_dist = FIXED_MAX;
@ -396,21 +394,21 @@ AActor *FCajunMaster::Find_enemy (AActor *bot)
{ {
player_t *client = &players[count]; player_t *client = &players[count];
if (playeringame[count] if (playeringame[count]
&& !bot->IsTeammate (client->mo) && !player->mo->IsTeammate (client->mo)
&& client->mo != observer && client->mo != observer
&& client->mo->health > 0 && client->mo->health > 0
&& bot != client->mo) && player->mo != client->mo)
{ {
if (Check_LOS (bot, client->mo, vangle)) //Here's a strange one, when bot is standing still, the P_CheckSight within Check_LOS almost always returns false. tought it should be the same checksight as below but.. (below works) something must be fuckin wierd screded up. if (Check_LOS (client->mo, vangle)) //Here's a strange one, when bot is standing still, the P_CheckSight within Check_LOS almost always returns false. tought it should be the same checksight as below but.. (below works) something must be fuckin wierd screded up.
//if(P_CheckSight(bot, players[count].mo)) //if(P_CheckSight(player->mo, players[count].mo))
{ {
temp = P_AproxDistance (client->mo->x - bot->x, temp = P_AproxDistance (client->mo->x - player->mo->x,
client->mo->y - bot->y); client->mo->y - player->mo->y);
//Too dark? //Too dark?
if (temp > DARK_DIST && if (temp > DARK_DIST &&
client->mo->Sector->lightlevel < WHATS_DARK /*&& client->mo->Sector->lightlevel < WHATS_DARK /*&&
bot->player->Powers & PW_INFRARED*/) player->Powers & PW_INFRARED*/)
continue; continue;
if (temp < closest_dist) if (temp < closest_dist)
@ -494,16 +492,16 @@ fixed_t FCajunMaster::FakeFire (AActor *source, AActor *dest, ticcmd_t *cmd)
return dist; return dist;
} }
angle_t FCajunMaster::FireRox (AActor *bot, AActor *enemy, ticcmd_t *cmd) angle_t DBot::FireRox (AActor *enemy, ticcmd_t *cmd)
{ {
fixed_t dist; fixed_t dist;
angle_t ang; angle_t ang;
AActor *actor; AActor *actor;
int m; int m;
SetBodyAt (bot->x + FixedMul(bot->velx, 5*FRACUNIT), bglobal.SetBodyAt (player->mo->x + FixedMul(player->mo->velx, 5*FRACUNIT),
bot->y + FixedMul(bot->vely, 5*FRACUNIT), player->mo->y + FixedMul(player->mo->vely, 5*FRACUNIT),
bot->z + (bot->height / 2), 2); player->mo->z + (player->mo->height / 2), 2);
actor = bglobal.body2; actor = bglobal.body2;
@ -513,16 +511,16 @@ angle_t FCajunMaster::FireRox (AActor *bot, AActor *enemy, ticcmd_t *cmd)
//Predict. //Predict.
m = (((dist+1)/FRACUNIT) / GetDefaultByName("Rocket")->Speed); m = (((dist+1)/FRACUNIT) / GetDefaultByName("Rocket")->Speed);
SetBodyAt (enemy->x + FixedMul(enemy->velx, (m+2*FRACUNIT)), bglobal.SetBodyAt (enemy->x + FixedMul(enemy->velx, (m+2*FRACUNIT)),
enemy->y + FixedMul(enemy->vely, (m+2*FRACUNIT)), ONFLOORZ, 1); enemy->y + FixedMul(enemy->vely, (m+2*FRACUNIT)), ONFLOORZ, 1);
dist = P_AproxDistance(actor->x-bglobal.body1->x, actor->y-bglobal.body1->y); dist = P_AproxDistance(actor->x-bglobal.body1->x, actor->y-bglobal.body1->y);
//try the predicted location //try the predicted location
if (P_CheckSight (actor, bglobal.body1, SF_IGNOREVISIBILITY)) //See the predicted location, so give a test missile if (P_CheckSight (actor, bglobal.body1, SF_IGNOREVISIBILITY)) //See the predicted location, so give a test missile
{ {
FCheckPosition tm; FCheckPosition tm;
if (SafeCheckPosition (bot, actor->x, actor->y, tm)) if (bglobal.SafeCheckPosition (player->mo, actor->x, actor->y, tm))
{ {
if (FakeFire (actor, bglobal.body1, cmd) >= SAFE_SELF_MISDIST) if (bglobal.FakeFire (actor, bglobal.body1, cmd) >= SAFE_SELF_MISDIST)
{ {
ang = R_PointToAngle2 (actor->x, actor->y, bglobal.body1->x, bglobal.body1->y); ang = R_PointToAngle2 (actor->x, actor->y, bglobal.body1->x, bglobal.body1->y);
return ang; return ang;
@ -532,9 +530,9 @@ angle_t FCajunMaster::FireRox (AActor *bot, AActor *enemy, ticcmd_t *cmd)
//Try fire straight. //Try fire straight.
if (P_CheckSight (actor, enemy, 0)) if (P_CheckSight (actor, enemy, 0))
{ {
if (FakeFire (bot, enemy, cmd) >= SAFE_SELF_MISDIST) if (bglobal.FakeFire (player->mo, enemy, cmd) >= SAFE_SELF_MISDIST)
{ {
ang = R_PointToAngle2(bot->x, bot->y, enemy->x, enemy->y); ang = R_PointToAngle2(player->mo->x, player->mo->y, enemy->x, enemy->y);
return ang; return ang;
} }
} }

123
src/b_move.cpp
View file

@ -27,57 +27,57 @@ static FRandom pr_botnewchasedir ("BotNewChaseDir");
extern dirtype_t opposite[9]; extern dirtype_t opposite[9];
extern dirtype_t diags[4]; extern dirtype_t diags[4];
//Called while the bot moves after its player->dest mobj //Called while the bot moves after its dest mobj
//which can be a weapon/enemy/item whatever. //which can be a weapon/enemy/item whatever.
void FCajunMaster::Roam (AActor *actor, ticcmd_t *cmd) void DBot::Roam (ticcmd_t *cmd)
{ {
int delta; int delta;
if (Reachable(actor, actor->player->Bot->dest)) if (Reachable(dest))
{ // Straight towards it. { // Straight towards it.
actor->player->Bot->angle = R_PointToAngle2(actor->x, actor->y, actor->player->Bot->dest->x, actor->player->Bot->dest->y); angle = R_PointToAngle2(player->mo->x, player->mo->y, dest->x, dest->y);
} }
else if (actor->movedir < 8) // turn towards movement direction if not there yet else if (player->mo->movedir < 8) // turn towards movement direction if not there yet
{ {
actor->player->Bot->angle &= (angle_t)(7<<29); angle &= (angle_t)(7<<29);
delta = actor->player->Bot->angle - (actor->movedir << 29); delta = angle - (player->mo->movedir << 29);
if (delta > 0) if (delta > 0)
actor->player->Bot->angle -= ANG45; angle -= ANG45;
else if (delta < 0) else if (delta < 0)
actor->player->Bot->angle += ANG45; angle += ANG45;
} }
// chase towards destination. // chase towards destination.
if (--actor->movecount < 0 || !Move (actor, cmd)) if (--player->mo->movecount < 0 || !Move (cmd))
{ {
NewChaseDir (actor, cmd); NewChaseDir (cmd);
} }
} }
bool FCajunMaster::Move (AActor *actor, ticcmd_t *cmd) bool DBot::Move (ticcmd_t *cmd)
{ {
fixed_t tryx, tryy; fixed_t tryx, tryy;
bool try_ok; bool try_ok;
int good; int good;
if (actor->movedir == DI_NODIR) if (player->mo->movedir == DI_NODIR)
return false; return false;
if ((unsigned)actor->movedir >= 8) if ((unsigned)player->mo->movedir >= 8)
I_Error ("Weird bot movedir!"); I_Error ("Weird bot movedir!");
tryx = actor->x + 8*xspeed[actor->movedir]; tryx = player->mo->x + 8*xspeed[player->mo->movedir];
tryy = actor->y + 8*yspeed[actor->movedir]; tryy = player->mo->y + 8*yspeed[player->mo->movedir];
try_ok = CleanAhead (actor, tryx, tryy, cmd); try_ok = bglobal.CleanAhead (player->mo, tryx, tryy, cmd);
if (!try_ok) //Anything blocking that could be opened etc.. if (!try_ok) //Anything blocking that could be opened etc..
{ {
if (!spechit.Size ()) if (!spechit.Size ())
return false; return false;
actor->movedir = DI_NODIR; player->mo->movedir = DI_NODIR;
good = 0; good = 0;
line_t *ld; line_t *ld;
@ -86,16 +86,16 @@ bool FCajunMaster::Move (AActor *actor, ticcmd_t *cmd)
{ {
bool tryit = true; bool tryit = true;
if (ld->special == Door_LockedRaise && !P_CheckKeys (actor, ld->args[3], false)) if (ld->special == Door_LockedRaise && !P_CheckKeys (player->mo, ld->args[3], false))
tryit = false; tryit = false;
else if (ld->special == Generic_Door && !P_CheckKeys (actor, ld->args[4], false)) else if (ld->special == Generic_Door && !P_CheckKeys (player->mo, ld->args[4], false))
tryit = false; tryit = false;
if (tryit && if (tryit &&
(P_TestActivateLine (ld, actor, 0, SPAC_Use) || (P_TestActivateLine (ld, player->mo, 0, SPAC_Use) ||
P_TestActivateLine (ld, actor, 0, SPAC_Push))) P_TestActivateLine (ld, player->mo, 0, SPAC_Push)))
{ {
good |= ld == actor->BlockingLine ? 1 : 2; good |= ld == player->mo->BlockingLine ? 1 : 2;
} }
} }
if (good && ((pr_botopendoor() >= 203) ^ (good & 1))) if (good && ((pr_botopendoor() >= 203) ^ (good & 1)))
@ -113,16 +113,16 @@ bool FCajunMaster::Move (AActor *actor, ticcmd_t *cmd)
return true; return true;
} }
bool FCajunMaster::TryWalk (AActor *actor, ticcmd_t *cmd) bool DBot::TryWalk (ticcmd_t *cmd)
{ {
if (!Move (actor, cmd)) if (!Move (cmd))
return false; return false;
actor->movecount = pr_bottrywalk() & 60; player->mo->movecount = pr_bottrywalk() & 60;
return true; return true;
} }
void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd) void DBot::NewChaseDir (ticcmd_t *cmd)
{ {
fixed_t deltax; fixed_t deltax;
fixed_t deltay; fixed_t deltay;
@ -134,7 +134,7 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
dirtype_t turnaround; dirtype_t turnaround;
if (!actor->player->Bot->dest) if (!dest)
{ {
#ifndef BOT_RELEASE_COMPILE #ifndef BOT_RELEASE_COMPILE
Printf ("Bot tried move without destination\n"); Printf ("Bot tried move without destination\n");
@ -142,11 +142,11 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
return; return;
} }
olddir = (dirtype_t)actor->movedir; olddir = (dirtype_t)player->mo->movedir;
turnaround = opposite[olddir]; turnaround = opposite[olddir];
deltax = actor->player->Bot->dest->x - actor->x; deltax = dest->x - player->mo->x;
deltay = actor->player->Bot->dest->y - actor->y; deltay = dest->y - player->mo->y;
if (deltax > 10*FRACUNIT) if (deltax > 10*FRACUNIT)
d[1] = DI_EAST; d[1] = DI_EAST;
@ -165,8 +165,8 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
// try direct route // try direct route
if (d[1] != DI_NODIR && d[2] != DI_NODIR) if (d[1] != DI_NODIR && d[2] != DI_NODIR)
{ {
actor->movedir = diags[((deltay<0)<<1)+(deltax>0)]; player->mo->movedir = diags[((deltay<0)<<1)+(deltax>0)];
if (actor->movedir != turnaround && TryWalk(actor, cmd)) if (player->mo->movedir != turnaround && TryWalk(cmd))
return; return;
} }
@ -186,16 +186,16 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
if (d[1]!=DI_NODIR) if (d[1]!=DI_NODIR)
{ {
actor->movedir = d[1]; player->mo->movedir = d[1];
if (TryWalk (actor, cmd)) if (TryWalk (cmd))
return; return;
} }
if (d[2]!=DI_NODIR) if (d[2]!=DI_NODIR)
{ {
actor->movedir = d[2]; player->mo->movedir = d[2];
if (TryWalk(actor, cmd)) if (TryWalk(cmd))
return; return;
} }
@ -203,9 +203,9 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
// so pick another direction. // so pick another direction.
if (olddir!=DI_NODIR) if (olddir!=DI_NODIR)
{ {
actor->movedir = olddir; player->mo->movedir = olddir;
if (TryWalk(actor, cmd)) if (TryWalk(cmd))
return; return;
} }
@ -218,9 +218,9 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
{ {
if (tdir!=turnaround) if (tdir!=turnaround)
{ {
actor->movedir = tdir; player->mo->movedir = tdir;
if (TryWalk(actor, cmd)) if (TryWalk(cmd))
return; return;
} }
} }
@ -233,9 +233,9 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
{ {
if (tdir!=turnaround) if (tdir!=turnaround)
{ {
actor->movedir = tdir; player->mo->movedir = tdir;
if (TryWalk(actor, cmd)) if (TryWalk(cmd))
return; return;
} }
} }
@ -243,12 +243,12 @@ void FCajunMaster::NewChaseDir (AActor *actor, ticcmd_t *cmd)
if (turnaround != DI_NODIR) if (turnaround != DI_NODIR)
{ {
actor->movedir = turnaround; player->mo->movedir = turnaround;
if (TryWalk(actor, cmd)) if (TryWalk(cmd))
return; return;
} }
actor->movedir = DI_NODIR; // can not move player->mo->movedir = DI_NODIR; // can not move
} }
@ -307,48 +307,48 @@ bool FCajunMaster::CleanAhead (AActor *thing, fixed_t x, fixed_t y, ticcmd_t *cm
#define MAXTURN (15*ANGLE_1) //Max degrees turned in one tic. Lower is smother but may cause the bot not getting where it should = crash #define MAXTURN (15*ANGLE_1) //Max degrees turned in one tic. Lower is smother but may cause the bot not getting where it should = crash
#define TURNSENS 3 //Higher is smoother but slower turn. #define TURNSENS 3 //Higher is smoother but slower turn.
void FCajunMaster::TurnToAng (AActor *actor) void DBot::TurnToAng ()
{ {
int maxturn = MAXTURN; int maxturn = MAXTURN;
if (actor->player->ReadyWeapon != NULL) if (player->ReadyWeapon != NULL)
{ {
if (actor->player->ReadyWeapon->WeaponFlags & WIF_BOT_EXPLOSIVE) if (player->ReadyWeapon->WeaponFlags & WIF_BOT_EXPLOSIVE)
{ {
if (actor->player->Bot->t_roam && !actor->player->Bot->missile) if (t_roam && !missile)
{ //Keep angle that where when shot where decided. { //Keep angle that where when shot where decided.
return; return;
} }
} }
if(actor->player->Bot->enemy) if(enemy)
if(!actor->player->Bot->dest) //happens when running after item in combat situations, or normal, prevents weak turns if(!dest) //happens when running after item in combat situations, or normal, prevents weak turns
if(actor->player->ReadyWeapon->ProjectileType == NULL && !(actor->player->ReadyWeapon->WeaponFlags & WIF_MELEEWEAPON)) if(player->ReadyWeapon->ProjectileType == NULL && !(player->ReadyWeapon->WeaponFlags & WIF_MELEEWEAPON))
if(Check_LOS(actor, actor->player->Bot->enemy, SHOOTFOV+5*ANGLE_1)) if(Check_LOS(enemy, SHOOTFOV+5*ANGLE_1))
maxturn = 3; maxturn = 3;
} }
int distance = actor->player->Bot->angle - actor->angle; int distance = angle - player->mo->angle;
if (abs (distance) < OKAYRANGE && !actor->player->Bot->enemy) if (abs (distance) < OKAYRANGE && !enemy)
return; return;
distance /= TURNSENS; distance /= TURNSENS;
if (abs (distance) > maxturn) if (abs (distance) > maxturn)
distance = distance < 0 ? -maxturn : maxturn; distance = distance < 0 ? -maxturn : maxturn;
actor->angle += distance; player->mo->angle += distance;
} }
void FCajunMaster::Pitch (AActor *actor, AActor *target) void DBot::Pitch (AActor *target)
{ {
double aim; double aim;
double diff; double diff;
diff = target->z - actor->z; diff = target->z - player->mo->z;
aim = atan (diff / (double)P_AproxDistance (actor->x - target->x, actor->y - target->y)); aim = atan (diff / (double)P_AproxDistance (player->mo->x - target->x, player->mo->y - target->y));
actor->pitch = -(int)(aim * ANGLE_180/M_PI); player->mo->pitch = -(int)(aim * ANGLE_180/M_PI);
} }
//Checks if a sector is dangerous. //Checks if a sector is dangerous.
@ -371,4 +371,3 @@ bool FCajunMaster::IsDangerous (sector_t *sec)
|| special == Damage_InstantDeath || special == Damage_InstantDeath
|| special == sDamage_SuperHellslime; || special == sDamage_SuperHellslime;
} }

284
src/b_think.cpp
View file

@ -24,47 +24,49 @@ static FRandom pr_botmove ("BotMove");
//This function is called each tic for each bot, //This function is called each tic for each bot,
//so this is what the bot does. //so this is what the bot does.
void FCajunMaster::Think (AActor *actor, ticcmd_t *cmd) void DBot::Think ()
{ {
ticcmd_t *cmd = &netcmds[player - players][((gametic + 1)/ticdup)%BACKUPTICS];
memset (cmd, 0, sizeof(*cmd)); memset (cmd, 0, sizeof(*cmd));
if (actor->player->Bot->enemy && actor->player->Bot->enemy->health <= 0) if (enemy && enemy->health <= 0)
actor->player->Bot->enemy = NULL; enemy = NULL;
if (actor->health > 0) //Still alive if (player->mo->health > 0) //Still alive
{ {
if (teamplay || !deathmatch) if (teamplay || !deathmatch)
actor->player->Bot->mate = Choose_Mate (actor); mate = Choose_Mate ();
angle_t oldyaw = actor->angle; angle_t oldyaw = player->mo->angle;
int oldpitch = actor->pitch; int oldpitch = player->mo->pitch;
Set_enemy (actor); Set_enemy ();
ThinkForMove (actor, cmd); ThinkForMove (cmd);
TurnToAng (actor); TurnToAng ();
cmd->ucmd.yaw = (short)((actor->angle - oldyaw) >> 16) / ticdup; cmd->ucmd.yaw = (short)((player->mo->angle - oldyaw) >> 16) / ticdup;
cmd->ucmd.pitch = (short)((oldpitch - actor->pitch) >> 16); cmd->ucmd.pitch = (short)((oldpitch - player->mo->pitch) >> 16);
if (cmd->ucmd.pitch == -32768) if (cmd->ucmd.pitch == -32768)
cmd->ucmd.pitch = -32767; cmd->ucmd.pitch = -32767;
cmd->ucmd.pitch /= ticdup; cmd->ucmd.pitch /= ticdup;
actor->angle = oldyaw + (cmd->ucmd.yaw << 16) * ticdup; player->mo->angle = oldyaw + (cmd->ucmd.yaw << 16) * ticdup;
actor->pitch = oldpitch - (cmd->ucmd.pitch << 16) * ticdup; player->mo->pitch = oldpitch - (cmd->ucmd.pitch << 16) * ticdup;
} }
if (actor->player->Bot->t_active) actor->player->Bot->t_active--; if (t_active) t_active--;
if (actor->player->Bot->t_strafe) actor->player->Bot->t_strafe--; if (t_strafe) t_strafe--;
if (actor->player->Bot->t_react) actor->player->Bot->t_react--; if (t_react) t_react--;
if (actor->player->Bot->t_fight) actor->player->Bot->t_fight--; if (t_fight) t_fight--;
if (actor->player->Bot->t_rocket) actor->player->Bot->t_rocket--; if (t_rocket) t_rocket--;
if (actor->player->Bot->t_roam) actor->player->Bot->t_roam--; if (t_roam) t_roam--;
//Respawn ticker //Respawn ticker
if (actor->player->Bot->t_respawn) if (t_respawn)
{ {
actor->player->Bot->t_respawn--; t_respawn--;
} }
else if (actor->health <= 0) else if (player->mo->health <= 0)
{ // Time to respawn { // Time to respawn
cmd->ucmd.buttons |= BT_USE; cmd->ucmd.buttons |= BT_USE;
} }
@ -72,62 +74,57 @@ void FCajunMaster::Think (AActor *actor, ticcmd_t *cmd)
//how the bot moves. //how the bot moves.
//MAIN movement function. //MAIN movement function.
void FCajunMaster::ThinkForMove (AActor *actor, ticcmd_t *cmd) void DBot::ThinkForMove (ticcmd_t *cmd)
{ {
player_t *b;
fixed_t dist; fixed_t dist;
bool stuck; bool stuck;
int r; int r;
b = actor->player;
if (b->Bot == NULL)
return;
stuck = false; stuck = false;
dist = b->Bot->dest ? P_AproxDistance(actor->x-b->Bot->dest->x, actor->y-b->Bot->dest->y) : 0; dist = dest ? P_AproxDistance(player->mo->x-dest->x, player->mo->y-dest->y) : 0;
if (b->Bot->missile && if (missile &&
((!b->Bot->missile->velx || !b->Bot->missile->vely) || !Check_LOS(actor, b->Bot->missile, SHOOTFOV*3/2))) ((!missile->velx || !missile->vely) || !Check_LOS(missile, SHOOTFOV*3/2)))
{ {
b->Bot->sleft = !b->Bot->sleft; sleft = !sleft;
b->Bot->missile = NULL; //Probably ended its travel. missile = NULL; //Probably ended its travel.
} }
if (actor->pitch > 0) if (player->mo->pitch > 0)
actor->pitch -= 80; player->mo->pitch -= 80;
else if (actor->pitch <= -60) else if (player->mo->pitch <= -60)
actor->pitch += 80; player->mo->pitch += 80;
//HOW TO MOVE: //HOW TO MOVE:
if (b->Bot->missile && (P_AproxDistance(actor->x-b->Bot->missile->x, actor->y-b->Bot->missile->y)<AVOID_DIST)) //try avoid missile got from P_Mobj.c thinking part. if (missile && (P_AproxDistance(player->mo->x-missile->x, player->mo->y-missile->y)<AVOID_DIST)) //try avoid missile got from P_Mobj.c thinking part.
{ {
Pitch (actor, b->Bot->missile); Pitch (missile);
actor->player->Bot->angle = R_PointToAngle2(actor->x, actor->y, b->Bot->missile->x, b->Bot->missile->y); angle = R_PointToAngle2(player->mo->x, player->mo->y, missile->x, missile->y);
cmd->ucmd.sidemove = b->Bot->sleft ? -SIDERUN : SIDERUN; cmd->ucmd.sidemove = sleft ? -SIDERUN : SIDERUN;
cmd->ucmd.forwardmove = -FORWARDRUN; //Back IS best. cmd->ucmd.forwardmove = -FORWARDRUN; //Back IS best.
if ((P_AproxDistance(actor->x-b->Bot->oldx, actor->y-b->Bot->oldy)<50000) if ((P_AproxDistance(player->mo->x-oldx, player->mo->y-oldy)<50000)
&& b->Bot->t_strafe<=0) && t_strafe<=0)
{ {
b->Bot->t_strafe = 5; t_strafe = 5;
b->Bot->sleft = !b->Bot->sleft; sleft = !sleft;
} }
//If able to see enemy while avoiding missile, still fire at enemy. //If able to see enemy while avoiding missile, still fire at enemy.
if (b->Bot->enemy && Check_LOS (actor, b->Bot->enemy, SHOOTFOV)) if (enemy && Check_LOS (enemy, SHOOTFOV))
Dofire (actor, cmd); //Order bot to fire current weapon Dofire (cmd); //Order bot to fire current weapon
} }
else if (b->Bot->enemy && P_CheckSight (actor, b->Bot->enemy, 0)) //Fight! else if (enemy && P_CheckSight (player->mo, enemy, 0)) //Fight!
{ {
Pitch (actor, b->Bot->enemy); Pitch (enemy);
//Check if it's more important to get an item than fight. //Check if it's more important to get an item than fight.
if (b->Bot->dest && (b->Bot->dest->flags&MF_SPECIAL)) //Must be an item, that is close enough. if (dest && (dest->flags&MF_SPECIAL)) //Must be an item, that is close enough.
{ {
#define is(x) b->Bot->dest->IsKindOf (PClass::FindClass (#x)) #define is(x) dest->IsKindOf (PClass::FindClass (#x))
if ( if (
( (
(actor->health < b->Bot->skill.isp && (player->mo->health < skill.isp &&
(is (Medikit) || (is (Medikit) ||
is (Stimpack) || is (Stimpack) ||
is (Soulsphere) || is (Soulsphere) ||
@ -140,78 +137,78 @@ void FCajunMaster::ThinkForMove (AActor *actor, ticcmd_t *cmd)
is (Megasphere) is (Megasphere)
) || ) ||
dist < (GETINCOMBAT/4) || dist < (GETINCOMBAT/4) ||
(b->ReadyWeapon == NULL || b->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON) (player->ReadyWeapon == NULL || player->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON)
) )
&& (dist < GETINCOMBAT || (b->ReadyWeapon == NULL || b->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON)) && (dist < GETINCOMBAT || (player->ReadyWeapon == NULL || player->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON))
&& Reachable (actor, b->Bot->dest)) && Reachable (dest))
#undef is #undef is
{ {
goto roam; //Pick it up, no matter the situation. All bonuses are nice close up. goto roam; //Pick it up, no matter the situation. All bonuses are nice close up.
} }
} }
b->Bot->dest = NULL; //To let bot turn right dest = NULL; //To let bot turn right
if (b->ReadyWeapon != NULL && !(b->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON)) if (player->ReadyWeapon != NULL && !(player->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON))
actor->flags &= ~MF_DROPOFF; //Don't jump off any ledges when fighting. player->mo->flags &= ~MF_DROPOFF; //Don't jump off any ledges when fighting.
if (!(b->Bot->enemy->flags3 & MF3_ISMONSTER)) if (!(enemy->flags3 & MF3_ISMONSTER))
b->Bot->t_fight = AFTERTICS; t_fight = AFTERTICS;
if (b->Bot->t_strafe <= 0 && if (t_strafe <= 0 &&
(P_AproxDistance(actor->x-b->Bot->oldx, actor->y-b->Bot->oldy)<50000 (P_AproxDistance(player->mo->x-oldx, player->mo->y-oldy)<50000
|| ((pr_botmove()%30)==10)) || ((pr_botmove()%30)==10))
) )
{ {
stuck = true; stuck = true;
b->Bot->t_strafe = 5; t_strafe = 5;
b->Bot->sleft = !b->Bot->sleft; sleft = !sleft;
} }
b->Bot->angle = R_PointToAngle2(actor->x, actor->y, b->Bot->enemy->x, b->Bot->enemy->y); angle = R_PointToAngle2(player->mo->x, player->mo->y, enemy->x, enemy->y);
if (b->ReadyWeapon == NULL || if (player->ReadyWeapon == NULL ||
P_AproxDistance(actor->x-b->Bot->enemy->x, actor->y-b->Bot->enemy->y) > P_AproxDistance(player->mo->x-enemy->x, player->mo->y-enemy->y) >
b->ReadyWeapon->MoveCombatDist) player->ReadyWeapon->MoveCombatDist)
{ {
// If a monster, use lower speed (just for cooler apperance while strafing down doomed monster) // If a monster, use lower speed (just for cooler apperance while strafing down doomed monster)
cmd->ucmd.forwardmove = (b->Bot->enemy->flags3 & MF3_ISMONSTER) ? FORWARDWALK : FORWARDRUN; cmd->ucmd.forwardmove = (enemy->flags3 & MF3_ISMONSTER) ? FORWARDWALK : FORWARDRUN;
} }
else if (!stuck) //Too close, so move away. else if (!stuck) //Too close, so move away.
{ {
// If a monster, use lower speed (just for cooler apperance while strafing down doomed monster) // If a monster, use lower speed (just for cooler apperance while strafing down doomed monster)
cmd->ucmd.forwardmove = (b->Bot->enemy->flags3 & MF3_ISMONSTER) ? -FORWARDWALK : -FORWARDRUN; cmd->ucmd.forwardmove = (enemy->flags3 & MF3_ISMONSTER) ? -FORWARDWALK : -FORWARDRUN;
} }
//Strafing. //Strafing.
if (b->Bot->enemy->flags3 & MF3_ISMONSTER) //It's just a monster so take it down cool. if (enemy->flags3 & MF3_ISMONSTER) //It's just a monster so take it down cool.
{ {
cmd->ucmd.sidemove = b->Bot->sleft ? -SIDEWALK : SIDEWALK; cmd->ucmd.sidemove = sleft ? -SIDEWALK : SIDEWALK;
} }
else else
{ {
cmd->ucmd.sidemove = b->Bot->sleft ? -SIDERUN : SIDERUN; cmd->ucmd.sidemove = sleft ? -SIDERUN : SIDERUN;
} }
Dofire (actor, cmd); //Order bot to fire current weapon Dofire (cmd); //Order bot to fire current weapon
} }
else if (b->Bot->mate && !b->Bot->enemy && (!b->Bot->dest || b->Bot->dest==b->Bot->mate)) //Follow mate move. else if (mate && !enemy && (!dest || dest==mate)) //Follow mate move.
{ {
fixed_t matedist; fixed_t matedist;
Pitch (actor, b->Bot->mate); Pitch (mate);
if (!Reachable (actor, b->Bot->mate)) if (!Reachable (mate))
{ {
if (b->Bot->mate == b->Bot->dest && pr_botmove.Random() < 32) if (mate == dest && pr_botmove.Random() < 32)
{ // [RH] If the mate is the dest, pick a new dest sometimes { // [RH] If the mate is the dest, pick a new dest sometimes
b->Bot->dest = NULL; dest = NULL;
} }
goto roam; goto roam;
} }
actor->player->Bot->angle = R_PointToAngle2(actor->x, actor->y, b->Bot->mate->x, b->Bot->mate->y); angle = R_PointToAngle2(player->mo->x, player->mo->y, mate->x, mate->y);
matedist = P_AproxDistance(actor->x - b->Bot->mate->x, actor->y - b->Bot->mate->y); matedist = P_AproxDistance(player->mo->x - mate->x, player->mo->y - mate->y);
if (matedist > (FRIEND_DIST*2)) if (matedist > (FRIEND_DIST*2))
cmd->ucmd.forwardmove = FORWARDRUN; cmd->ucmd.forwardmove = FORWARDRUN;
else if (matedist > FRIEND_DIST) else if (matedist > FRIEND_DIST)
@ -221,42 +218,42 @@ void FCajunMaster::ThinkForMove (AActor *actor, ticcmd_t *cmd)
} }
else //Roam after something. else //Roam after something.
{ {
b->Bot->first_shot = true; first_shot = true;
///// /////
roam: roam:
///// /////
if (b->Bot->enemy && Check_LOS (actor, b->Bot->enemy, SHOOTFOV*3/2)) //If able to see enemy while avoiding missile , still fire at it. if (enemy && Check_LOS (enemy, SHOOTFOV*3/2)) //If able to see enemy while avoiding missile , still fire at it.
Dofire (actor, cmd); //Order bot to fire current weapon Dofire (cmd); //Order bot to fire current weapon
if (b->Bot->dest && !(b->Bot->dest->flags&MF_SPECIAL) && b->Bot->dest->health < 0) if (dest && !(dest->flags&MF_SPECIAL) && dest->health < 0)
{ //Roaming after something dead. { //Roaming after something dead.
b->Bot->dest = NULL; dest = NULL;
} }
if (b->Bot->dest == NULL) if (dest == NULL)
{ {
if (b->Bot->t_fight && b->Bot->enemy) //Enemy/bot has jumped around corner. So what to do? if (t_fight && enemy) //Enemy/bot has jumped around corner. So what to do?
{ {
if (b->Bot->enemy->player) if (enemy->player)
{ {
if (((b->Bot->enemy->player->ReadyWeapon != NULL && b->Bot->enemy->player->ReadyWeapon->WeaponFlags & WIF_BOT_EXPLOSIVE) || if (((enemy->player->ReadyWeapon != NULL && enemy->player->ReadyWeapon->WeaponFlags & WIF_BOT_EXPLOSIVE) ||
(pr_botmove()%100)>b->Bot->skill.isp) && b->ReadyWeapon != NULL && !(b->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON)) (pr_botmove()%100)>skill.isp) && player->ReadyWeapon != NULL && !(player->ReadyWeapon->WeaponFlags & WIF_WIMPY_WEAPON))
b->Bot->dest = b->Bot->enemy;//Dont let enemy kill the bot by supressive fire. So charge enemy. dest = enemy;//Dont let enemy kill the bot by supressive fire. So charge enemy.
else //hide while b->t_fight, but keep view at enemy. else //hide while t_fight, but keep view at enemy.
b->Bot->angle = R_PointToAngle2(actor->x, actor->y, b->Bot->enemy->x, b->Bot->enemy->y); angle = R_PointToAngle2(player->mo->x, player->mo->y, enemy->x, enemy->y);
} //Just a monster, so kill it. } //Just a monster, so kill it.
else else
b->Bot->dest = b->Bot->enemy; dest = enemy;
//VerifFavoritWeapon(actor->player); //Dont know why here.., but it must be here, i know the reason, but not why at this spot, uh. //VerifFavoritWeapon(player); //Dont know why here.., but it must be here, i know the reason, but not why at this spot, uh.
} }
else //Choose a distant target. to get things going. else //Choose a distant target. to get things going.
{ {
r = pr_botmove(); r = pr_botmove();
if (r < 128) if (r < 128)
{ {
TThinkerIterator<AInventory> it (STAT_INVENTORY, firstthing); TThinkerIterator<AInventory> it (STAT_INVENTORY, bglobal.firstthing);
AInventory *item = it.Next(); AInventory *item = it.Next();
if (item != NULL || (item = it.Next()) != NULL) if (item != NULL || (item = it.Next()) != NULL)
@ -271,60 +268,53 @@ void FCajunMaster::ThinkForMove (AActor *actor, ticcmd_t *cmd)
{ {
item = it.Next(); item = it.Next();
} }
firstthing = item; bglobal.firstthing = item;
b->Bot->dest = item; dest = item;
} }
} }
else if (b->Bot->mate && (r < 179 || P_CheckSight(actor, b->Bot->mate))) else if (mate && (r < 179 || P_CheckSight(player->mo, mate)))
{ {
b->Bot->dest = b->Bot->mate; dest = mate;
} }
else if ((playeringame[(r&(MAXPLAYERS-1))]) && players[(r&(MAXPLAYERS-1))].mo->health > 0) else if ((playeringame[(r&(MAXPLAYERS-1))]) && players[(r&(MAXPLAYERS-1))].mo->health > 0)
{ {
b->Bot->dest = players[(r&(MAXPLAYERS-1))].mo; dest = players[(r&(MAXPLAYERS-1))].mo;
} }
} }
if (b->Bot->dest) if (dest)
{ {
b->Bot->t_roam = MAXROAM; t_roam = MAXROAM;
} }
} }
if (b->Bot->dest) if (dest)
{ //Bot has a target so roam after it. { //Bot has a target so roam after it.
Roam (actor, cmd); Roam (cmd);
} }
} //End of movement main part. } //End of movement main part.
if (!b->Bot->t_roam && b->Bot->dest) if (!t_roam && dest)
{ {
b->Bot->prev = b->Bot->dest; prev = dest;
b->Bot->dest = NULL; dest = NULL;
} }
if (b->Bot->t_fight<(AFTERTICS/2)) if (t_fight<(AFTERTICS/2))
actor->flags |= MF_DROPOFF; player->mo->flags |= MF_DROPOFF;
b->Bot->oldx = actor->x; oldx = player->mo->x;
b->Bot->oldy = actor->y; oldy = player->mo->y;
} }
//BOT_WhatToGet //BOT_WhatToGet
// //
//Determines if the bot will roam after an item or not. //Determines if the bot will roam after an item or not.
void FCajunMaster::WhatToGet (AActor *actor, AActor *item) void DBot::WhatToGet (AActor *item)
{ {
player_t *b = actor->player;
if (b == NULL)
{
return;
}
#define typeis(x) item->IsKindOf (PClass::FindClass (#x)) #define typeis(x) item->IsKindOf (PClass::FindClass (#x))
if ((item->renderflags & RF_INVISIBLE) //Under respawn and away. if ((item->renderflags & RF_INVISIBLE) //Under respawn and away.
|| item == b->Bot->prev) || item == prev)
{ {
return; return;
} }
@ -338,7 +328,7 @@ void FCajunMaster::WhatToGet (AActor *actor, AActor *item)
// FIXME // FIXME
AWeapon *heldWeapon; AWeapon *heldWeapon;
heldWeapon = static_cast<AWeapon *> (b->mo->FindInventory (item->GetClass())); heldWeapon = static_cast<AWeapon *> (player->mo->FindInventory (item->GetClass()));
if (heldWeapon != NULL) if (heldWeapon != NULL)
{ {
if (!weapgiveammo) if (!weapgiveammo)
@ -354,39 +344,38 @@ void FCajunMaster::WhatToGet (AActor *actor, AActor *item)
{ {
AAmmo *ammo = static_cast<AAmmo *> (item); AAmmo *ammo = static_cast<AAmmo *> (item);
const PClass *parent = ammo->GetParentAmmo (); const PClass *parent = ammo->GetParentAmmo ();
AInventory *holdingammo = b->mo->FindInventory (parent); AInventory *holdingammo = player->mo->FindInventory (parent);
if (holdingammo != NULL && holdingammo->Amount >= holdingammo->MaxAmount) if (holdingammo != NULL && holdingammo->Amount >= holdingammo->MaxAmount)
{ {
return; return;
} }
} }
else if ((typeis (Megasphere) || typeis (Soulsphere) || typeis (HealthBonus)) && actor->health >= deh.MaxSoulsphere) else if ((typeis (Megasphere) || typeis (Soulsphere) || typeis (HealthBonus)) && player->mo->health >= deh.MaxSoulsphere)
return; return;
else if (item->IsKindOf (RUNTIME_CLASS(AHealth)) && actor->health >= deh.MaxHealth /*MAXHEALTH*/) else if (item->IsKindOf (RUNTIME_CLASS(AHealth)) && player->mo->health >= deh.MaxHealth /*MAXHEALTH*/)
return; return;
if ((b->Bot->dest == NULL || if ((dest == NULL ||
!(b->Bot->dest->flags & MF_SPECIAL)/* || !(dest->flags & MF_SPECIAL)/* ||
!Reachable (actor, b->dest)*/)/* && !Reachable (dest)*/)/* &&
Reachable (actor, item)*/) // Calling Reachable slows this down tremendously Reachable (item)*/) // Calling Reachable slows this down tremendously
{ {
b->Bot->prev = b->Bot->dest; prev = dest;
b->Bot->dest = item; dest = item;
b->Bot->t_roam = MAXROAM; t_roam = MAXROAM;
} }
} }
void FCajunMaster::Set_enemy (AActor *actor) void DBot::Set_enemy ()
{ {
AActor *oldenemy; AActor *oldenemy;
AActor **enemy = &actor->player->Bot->enemy;
if (*enemy if (enemy
&& (*enemy)->health > 0 && enemy->health > 0
&& P_CheckSight (actor, *enemy)) && P_CheckSight (player->mo, enemy))
{ {
oldenemy = *enemy; oldenemy = enemy;
} }
else else
{ {
@ -395,15 +384,14 @@ void FCajunMaster::Set_enemy (AActor *actor)
// [RH] Don't even bother looking for a different enemy if this is not deathmatch // [RH] Don't even bother looking for a different enemy if this is not deathmatch
// and we already have an existing enemy. // and we already have an existing enemy.
if (deathmatch || !*enemy) if (deathmatch || !enemy)
{ {
actor->player->Bot->allround = !!*enemy; allround = !!enemy;
*enemy = NULL; enemy = Find_enemy();
*enemy = Find_enemy(actor); if (!enemy)
if (!*enemy) enemy = oldenemy; //Try go for last (it will be NULL if there wasn't anyone)
*enemy = oldenemy; //Try go for last (it will be NULL if there wasn't anyone)
} }
//Verify that that enemy is really something alive that bot can kill. //Verify that that enemy is really something alive that bot can kill.
if (*enemy && (((*enemy)->health < 0 || !((*enemy)->flags&MF_SHOOTABLE)) || actor->IsFriend(*enemy))) if (enemy && ((enemy->health < 0 || !(enemy->flags&MF_SHOOTABLE)) || player->mo->IsFriend(enemy)))
*enemy = NULL; enemy = NULL;
} }

4
src/p_mobj.cpp
View file

@ -3259,7 +3259,7 @@ void AActor::Tick ()
else if (flags & MF_SPECIAL) else if (flags & MF_SPECIAL)
{ //Item pickup time { //Item pickup time
//clock (BotWTG); //clock (BotWTG);
bglobal.WhatToGet (players[i].mo, this); players[i].Bot->WhatToGet (this);
//unclock (BotWTG); //unclock (BotWTG);
BotWTG++; BotWTG++;
} }
@ -3267,7 +3267,7 @@ void AActor::Tick ()
{ {
if (!players[i].Bot->missile && (flags3 & MF3_WARNBOT)) if (!players[i].Bot->missile && (flags3 & MF3_WARNBOT))
{ //warn for incoming missiles. { //warn for incoming missiles.
if (target != players[i].mo && bglobal.Check_LOS (players[i].mo, this, ANGLE_90)) if (target != players[i].mo && players[i].Bot->Check_LOS (this, ANGLE_90))
players[i].Bot->missile = this; players[i].Bot->missile = this;
} }
} }