heretic/game/BotPlayer.vc

//**************************************************************************
//**
//**    ##   ##    ##    ##   ##   ####     ####   ###     ###
//**    ##   ##  ##  ##  ##   ##  ##  ##   ##  ##  ####   ####
//**     ## ##  ##    ##  ## ##  ##    ## ##    ## ## ## ## ##
//**     ## ##  ########  ## ##  ##    ## ##    ## ##  ###  ##
//**      ###   ##    ##   ###    ##  ##   ##  ##  ##       ##
//**       #    ##    ##    #      ####     ####   ##       ##
//**
//**    $Id: BotPlayer.vc 4111 2009-11-14 23:46:45Z dj_jl $
//**
//**    Copyright (C) 1999-2006 Jānis Legzdiņš
//**
//**    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.
//**
//**************************************************************************
//
//  This section contains the main bot AI. The
//  main bot AI loop, B_Think, is called every tic.
//  Also included are various bot decision-making
//  procedures, such as B_CheckStuff and B_SetEnemy.
//
//**************************************************************************

// Main bot class
class BotPlayer : GameObject;

const float FORWARDWALK		= 200.0;
const float FORWARDRUN		= 400.0;
const float SIDEWALK		= 192.0;
const float SIDERUN			= 320.0;

/*const float MAX_TRAVERSE_DIST			(1024*FRACUNIT)	//10 meters, used within b_func.c*/
const float AVOID_DIST					= 512.0;	//Try avoid incoming missiles once they reached this close
const float SAFE_SELF_MISDIST			= 128.0;	//Distance from self to target where it's safe to pull a rocket.
/*const float FRIEND_DIST					(128*FRACUNIT)	//To friend.
const float DARK_DIST					(256*FRACUNIT)	//Distance that bot can see enemies in the dark from.
const float WHATS_DARK					64				//light value thats classed as dark.
const float MAX_MONSTER_TARGET_DIST		(1024*FRACUNIT)	//Too high can slow down the performance, see P_mobj.c*/
const float ENEMY_SCAN_FOV				= 120.0;
/*const float MAXMOVEHEIGHT				(32*FRACUNIT)	//MAXSTEPMOVE but with jumping counted in.
const float GETINCOMBAT					(512*FRACUNIT)	//Max distance to item. if it's due to be icked up in a combat situation.*/
const float SHOOTFOV					= 60.0;
/*const float MAXROAM						(5*TICRATE)		//When this time is elapsed the bot will roam after something else.*/

/*

  Class definitions for botinfo, chatinfo, and
  other various bot information thingamabobers.
*/

enum
{
	bsk_verypoor,
	bsk_poor,
	bsk_low,
	bsk_medium,
	bsk_high,
	bsk_excellent,
	bsk_supreme
};

struct botinfo_t
{
	string Name;		// Bot's name*/
	int accuracy;		// Accuracy with "instant" weapons (this includes "leading")
	int intelect;		// Accuracy with "missile" weapons (rocket launcher, etc.)
	int evade;			// Ability to dodge incoming missiles
	int anticip;		// Ability to anticipate "instant" shots
	int reaction;		// Overall reaction time (lower is "better")
/*	int pisschance;		// Chance the bot will get pissed when his threshold is reached
	int threshold;		// How much it takes to frustrate/piss off the bot
	int dangerlevel;	// When health is below this, we need some health
	int wpfav;			// Favorite weapon
	int chatinfo;		// Bot's chat strings
	int chattime;		// How long it takes us to type a line
	int chatty;			// How talkative the bot is
	char *colour;		// Colour (in form of a string)
	char *gender;		// Male/female/it :)
	char *skin;			// Skin
	int railcolour;		// Railgun trail colour
	bool revealed;		// Hidden bots must be revealed*/
	string userinfo;
};

/*struct chatline_t
{
	char		*string;
	chattype_t  bot;
	chatline_t	*line;
};

struct chatinfo_t
{
	chatline_t		intro[5];
	chatline_t		inter[5];
	chatline_t		rare[5];
	chatline_t		frag[15];
	chatline_t		died[10];
	chatline_t		roam[10];
	chatline_t		pissed[5];
	chatline_t		frustrated[5];
	chatline_t		special[20];
} chatinfo_t;*/

// The things the bot knows about their enemy
//struct enemyinfo_t
//{
//	int				health;
//	weapontype_t	weap;
//};

//
// Bot states
//
enum
{
	// Deciding what to do
	BST_NOTHING,
	// Bot is "fetching" something (skull, whatever)
	BST_OFFENSE,
	// Bot is defending something
	BST_DEFENSE,
	// Bot is heading to scoring place
	BST_RETURN
};

Player player;		// Points to reference player
Actor botmo;

// Destinations
Actor item;			// Item (roam towards weapon, etc)
bool bItemIsWeapon;
bool bItemIsPowerup;
Actor goal;			// Teamgame goal spot
Actor node;			// Node we're heading towards
Actor prev;			// Previous node we were at
TVec posdest;			// Position of our destination (doesn't have to be an actor)
bool posdest_valid;
Actor enemy;			// The dead meat.
TVec lastpos;			// Last place we saw our enemy
bool lastpos_valid;
Actor missile;			// A threathing missile that got to be avoided.

Actor ally;			// Ally to tag along with
float t_strafe;
float t_react;
float t_fire;			// Tics left until our gun will actually fire again
float t_anticip;

float forwardmove;	// For building ucmd
float sidemove;

// Misc booleans
bool bAllRound;
bool bNewItemIsWeapon;
bool bNewItemIsPowerup;

botinfo_t info;			// Aiming, name, perfection, yadda yadda

int angerlevel;

float angle;			// The wanted angle that the bot tries to get every tic.

//==========================================================================
//
//	BotTick
//
//  Main bot function
//
//==========================================================================

void BotTick(float deltaTime)
{
	botmo = Actor(player.MO);

	player.ForwardMove = 0.0;
	player.SideMove = 0.0;
	player.FlyMove = 0.0;
	player.Buttons = 0;

	// We're dead, so hit space to respawn
	if (!player.Health)
	{
		player.Buttons |= BT_USE;
		return;
	}

	// Weed out any bad destinations/enemies
	CheckStuff();

	// Destination setting...
	SetEnemy();
	Scan();

	// Turning towards destination...
	BotAim();
	Turn();

	// Moving towards destination
	Attack();
	Move(deltaTime);

	Pitch();

	// Only walk if we're on skill 0
	if (!MainGameInfo(player.Level.Game).botskill)
	{
		if (forwardmove == FORWARDRUN)
			forwardmove = FORWARDWALK;
		if (forwardmove == -FORWARDRUN)
			forwardmove = -FORWARDWALK;
		if (sidemove == SIDERUN)
			sidemove = SIDEWALK;
		if (sidemove == -SIDERUN)
			sidemove = -SIDEWALK;
	}

	player.SideMove = sidemove;
	player.ForwardMove = forwardmove;

	t_react -= deltaTime;
	if (t_react <= 0.0)
	{
		t_react = 0.0;
	}
	t_anticip -= deltaTime;
	if (t_anticip <= 0.0)
	{
		t_anticip = 0.0;
	}
}

//==========================================================================
//
//	AngleTo
//
//==========================================================================

float AngleTo(TVec dest)
{
	TVec dir;
	TAVec ang;

	dir = dest - botmo.Origin;
	VectorAngles(&dir, &ang);
	return ang.yaw;
}

//==========================================================================
//
//	CheckItem
//
//	Determines if we should bother picking up an item or not
//
//==========================================================================

bool CheckItem(Actor item)
{
	bNewItemIsWeapon = false;
	bNewItemIsPowerup = false;
//?????
    if (!item)
		return false;
	if (!item.bSpecial)
		return false;

	Weapon Wpn = Weapon(item);
	if (Wpn)
	{
		bNewItemIsWeapon = true;

		// If we don't have the weapon, pick it up
		if (!botmo.FindInventory(class<Inventory>(Wpn.Class)))
			return true;

		// If we have no more room for the ammo it gives
		if (botmo.FindInventory(Wpn.AmmoType1).Amount ==
			botmo.FindInventory(Wpn.AmmoType1).MaxAmount)
			return false;

		// Can't pick it up because we have it and it's not a dropped weapon
		if (!item.bDropped)
			return false;
	}

	if (Ammo(item))
	{
		// If we have no more room for the ammo it gives
		Inventory AmmoItem = botmo.FindInventory(Ammo(item).GetParentAmmo());
		if (AmmoItem && AmmoItem.Amount >= AmmoItem.MaxAmount)
			return false;
	}

	if (Health(item) && (botmo.Health >= Player::MAXHEALTH))
		return false;
	BasicArmor Armor = BasicArmor(botmo.FindInventory(BasicArmor));
	if (BasicArmorPickup(item) && (Armor.Amount >= BasicArmorPickup(item).SaveAmount))
		return false;

	// Guess we're okay
	return true;
}

//==========================================================================
//
//	SetEnemy
//
//==========================================================================

void SetEnemy()
{
	if (enemy && enemy.Health > 0 && player.MO &&
		player.MO.CanSee(enemy))
	{
		return;
	}

	bAllRound = !!enemy;
	enemy = FindEnemy();

	if (!enemy)
		return;

	// Double check the validity of the enemy
	if (!enemy.bShootable)
		enemy = none;
}

//==========================================================================
//
//	CheckTo
//
//	Checks if an location is reachable
//
//==========================================================================

bool CheckTo(TVec pos)
{
	float dist;
	float an;

	dist = Length(botmo.Origin - pos);
	an = GetAngle();

	if (!CheckPath(an, dist))
		return false;

	return true;
}

//==========================================================================
//
//	CheckStuff
//
//	Make sure that our destinations/enemies and everything are valid.
//
//==========================================================================

void CheckStuff()
{
	if (item)
	{
		if (!item.bSpecial || item.IsDestroyed() || // somebody picked
				!CheckTo(item.Origin)) // Can't reach
			item = none;
	}

	if (missile)
	{
		if (!missile.bMissile || missile.IsDestroyed())
			missile = none;
	}

	if (node)
	{
		if (!CheckTo(node.Origin) ||
			(botmo.DistTo2(node) < botmo.Radius))
		{
			prev = node;
			node = none;
		}
	}

	if (posdest_valid)
	{
		TVec dir;
		dir = posdest - botmo.Origin;
		dir.z = 0.0;
		if ((Length(dir) < botmo.Radius) || !CheckTo(posdest))
		{
			posdest_valid = false;
		}
	}

	if (lastpos_valid)
	{
		TVec dir;
		dir = lastpos - botmo.Origin;
		dir.z = 0.0;
		if ((Length(dir) < botmo.Radius) || !CheckTo(lastpos))
		{
			lastpos_valid = false;
		}
	}

	if (enemy)
	{
		if (enemy.Health <= 0 || !enemy.bShootable)
			enemy = none;
	}
}

//==========================================================================
//
//	Scan
//
//	Scan all mobj's visible to the bot for incoming missiles, enemies, and
// various items to pick up.
//
//==========================================================================

void Scan()
{
	Actor actor;

	foreach botmo.AllThinkers(Actor, actor)
	{
		if (!actor.bSpecial && !actor.bMissile)
		{
			// Not interested in this one
			continue;
		}
		if (Check_LOS(actor, 90.0))
		{
			// Look for special items
			if (!item && actor.bSpecial)
			{
				if (CheckItem(actor))
				{
					item = actor;
					bItemIsWeapon = bNewItemIsWeapon;
					bItemIsPowerup = bNewItemIsPowerup;
				}
			}
			else if (!missile && actor.bMissile &&
				(botmo.DistTo(actor) < AVOID_DIST))
			{
				missile = actor;
			}
		}
	}
}

//==========================================================================
//
//	SkillLower
//
//==========================================================================

int SkillLower(int skill, int num)
{
	if (num <= 0)
		return skill;

	skill -= num;
	if (skill < 0)
		skill = 0;

	return skill;
}

//==========================================================================
//
//	SetAngle
//
//==========================================================================

void SetAngle(float an)
{
	angle = AngleMod360(an);
}

//==========================================================================
//
//	GetAngle
//
//==========================================================================

float GetAngle()
{
	return angle;
}

//==========================================================================
//
//	IsDangerous
//
//	Checks if a sector is dangerous.
//
//==========================================================================

bool IsDangerous(sector_t *sec)
{
	switch (sec->special & ~SECSPEC_SECRET_MASK)
	{
	case 71:	// Damage_Sludge
	case 82:	// Damage_LavaWimpy
	case 83:	// Damage_LavaHefty
	case 84:	// Scroll_EastLavaDamage
		return true;
	}
	return false;
}

//==========================================================================
//
//	CheckPath
//
//	Checks for obstructions at a certain angle and distance. Returns true if
// the path is clear, and false is the path is blocked.
//
//==========================================================================

bool CheckPath(float ang, float dist)
{
	float x1, y1, x2, y2;
	intercept_t* in;
	float bottracerange;
	TVec bottracedir;

	bottracerange = dist;
	bottracedir.x = cos(ang);
	bottracedir.y = sin(ang);
	bottracedir.z = 0.0;
	x1 = botmo.Origin.x;
	y1 = botmo.Origin.y;
 	x2 = x1 + dist * bottracedir.x;
 	y2 = y1 + dist * bottracedir.y;

	EntityEx(player.MO).UseLines(Player::USERANGE, Player::USETHINGRANGE, '*usefail');

	foreach botmo.PathTraverse(in, x1, y1, x2, y2, PT_ADDLINES)
	{
		Actor th;
		line_t *ld;
		TVec hit_point;

		if (in->bIsALine)
		{
			sector_t *back;
			sector_t *front;
			opening_t *open;
			float diffheight;

			ld = in->line;					// This linedef
			hit_point = botmo.Origin + (bottracerange * in->frac) * bottracedir;

			// Line is impassible
			if (!(ld->flags & ML_TWOSIDED) || (ld->flags & (ML_BLOCKING | ML_BLOCKPLAYERS | ML_BLOCKEVERYTHING)))
				return false;

			// Line isn't two sided
			if (!ld->backsector)
				return false;

			if (!PointOnPlaneSide(botmo.Origin, ld))
			{
				back = ld->backsector;
				front = ld->frontsector;
			}
			else
			{
				back = ld->frontsector;
				front = ld->backsector;
			}

			// Sector is dangerous
			if (IsDangerous(back))
				return false;

			// crosses a two sided line
			open = LineOpenings(ld, hit_point);
			open = FindOpening(open, hit_point.z, hit_point.z + botmo.Height);
			// No valid openings
			if (!open)
			{
				return false;
			}

			diffheight = GetPlanePointZ(&back->floor, hit_point) -
				GetPlanePointZ(&front->floor, hit_point);

			// No cliff jumping unless we're going after something
			if (-diffheight > 32.0 && !enemy)
			{
				return false;
			}

			if (diffheight > 0.0)
			{
				if (diffheight > 48.0)
				{
/*					if (front->SSpecial == ThrustThingZ || front->springpadzone)
					{
						return true;
					}
					else*/
						return false;
				}
				else if (diffheight <= 48.0 && diffheight >= 24.0)
				{
					player.Buttons |= BT_JUMP;
				}
			}
		}
		else
		{
			th = Actor(in->Thing);

			if (th == botmo)
				continue;

			if (th.bSolid)
				return false;

/*			fixed_t diffheight = (th->z + th->Height) - shootthing->z;

			if (diffheight > 0)
			{
				if (diffheight <= 48*FRACUNIT && diffheight >= 24*FRACUNIT)
				{
					bot->player.cmd.ucmd.buttons |= BT_JUMP;
					return true;
				}
				else if (diffheight <= 24*FRACUNIT)
					return true;
				else
					return false;

			}
*/
		}
	}
	return true;
}

//==========================================================================
//
//	Check_LOS
//
//	Doesnt check LOS, checks visibility with a set view angle.
//	B_Checksight checks LOS (straight line)
//
//	Check if mo1 has free line to mo2 and if mo2 is within mo1 viewangle
// (vangle) given with normal degrees. If these conditions are true, the
// function returns true. GOOD TO KNOW is that the players view angle in
// doom is 90 degrees infront.
//
//==========================================================================

bool Check_LOS(Actor to, float vangle)
{
	if (!botmo.CanSee(to))
		return false; // out of sight
	if (vangle == 360.0)
		return true;
	if (vangle == 0.0)
		return false; //Looker seems to be blind.

	return fabs(AngleMod180(AngleTo(to.Origin) - botmo.Angles.yaw)) <=
		vangle / 2.0;
}

//==========================================================================
//
//	BotAim
//
//==========================================================================

void BotAim()
{
	float dist;
	bool right;
	float an;

	if (!enemy)
		return;

	if (t_react)
		return;

	// Distance to enemy.
	dist = botmo.DistTo2(enemy);

	right = !!(P_Random() & 1);
	an = AngleTo(enemy.Origin);

	// [BC] Cajun prediction... maybe use this somewhere
	/*
			{
			//Here goes the prediction.
			dist = P_AproxDistance(MO->x - enemy->x, MO->y - enemy->y);
			fixed_t m = (dist/FRACUNIT) / mobjinfo[MT_PLASMA].speed;
			bot->SetAngle(R_PointToAngle2(MO->x,
											MO->y,
											enemy->x + FixedMul (enemy->momx, (m*2*FRACUNIT)),
											enemy->y + FixedMul (enemy->momy, (m*2*FRACUNIT))));
			}
	*/

	// Fix me: Implement botskill, accuracy, and intelligence
	if (player.ReadyWeapon.bBotProjectile)
	{
		// Splash weapons
//		bot->SetAngle(R_PointToAngle2(MO->x, MO->y, enemy->x, enemy->y));

		// Projectile weapons
		switch (info.intelect)
		{
		case bsk_verypoor:
		case bsk_poor:
		case bsk_low:
			// Aim right at the enemy
			SetAngle(an);
			break;
		case bsk_medium:
		case bsk_high:
		case bsk_excellent:
		case bsk_supreme:
			if (right)
				SetAngle(an + Random() * 20.0);
			else
				SetAngle(an - Random() * 20.0);
			break;

		default:
			Error("Unknown bot skill level: %d", info.accuracy);
			return;
		}
	}
	else
	{
		// Instant weapons
		switch (info.accuracy)
		{
		case bsk_verypoor:
			if (right)
				SetAngle(an + Random() * 60.0);
			else
				SetAngle(an - Random() * 60.0);
			break;
		case bsk_poor:
			if (right)
				SetAngle(an + Random() * 45.0);
			else
				SetAngle(an - Random() * 45.0);
			break;
		case bsk_low:
			if (right)
				SetAngle(an + Random() * 30.0);
			else
				SetAngle(an - Random() * 30.0);
			break;
		case bsk_medium:
			if (right)
				SetAngle(an + Random() * 15.0);
			else
				SetAngle(an - Random() * 15.0);
			break;
		case bsk_high:
			SetAngle(an);
			break;
		case bsk_excellent:
			SetAngle(AngleTo(enemy.Origin + enemy.Velocity * 0.1));
			break;
		case bsk_supreme://FIXME
			SetAngle(AngleTo(enemy.Origin + enemy.Velocity * 0.1));
			break;
		default:
			Error("Unknown bot skill level: %d", info.accuracy);
			return;
		}
	}
}

//==========================================================================
//
//	FindEnemy
//
//==========================================================================

Actor FindEnemy()
{
	float closest_dist, temp;
	Actor target;
	float vangle;
	int i;

	//Note: It's hard to ambush a bot who is not alone
	if (bAllRound || ally)
		vangle = 360.0;
	else
		vangle = ENEMY_SCAN_FOV;
	bAllRound = false;

	target = none;
	closest_dist = 99999.0;

	// Search for player enemies
	for (i = 0; i < MAXPLAYERS; i++)
	{
		if (player.Level.Game.Players[i] &&
			player.Level.Game.Players[i].MO.Health > 0 && botmo != player.Level.Game.Players[i].MO)
		{
			 //Here's a strange one, when bot is standing still, the CanSee 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(Actor(player.Level.Game.Players[i].MO), vangle))
			{
				if (botmo.CanSee(player.Level.Game.Players[i].MO))
				{
					temp = player.Level.Game.Players[i].MO.DistTo(botmo);
					if (temp < closest_dist)
					{
						closest_dist = temp;
						target = Actor(player.Level.Game.Players[i].MO);
					}
				}
			}
		}
	}

	return target;
}

//==========================================================================
//
//	Roam
//
//	Handle non-attack/dodging movement
//
//==========================================================================

void Roam()
{
	TVec dest;

	if (lastpos_valid)
	{
		TVec dir;

		dir = lastpos - botmo.Origin;
		dir.z = 0.0;
		if (Length(dir) <= 32.0)
		{
			lastpos_valid = false;
		}
	}

	// Order of item response precedence:
	if (goal)
	{
		dest = goal.Origin;
	}
	else if (lastpos_valid)
	{
		dest = lastpos;
	}
	else if (item)
	{
		dest = item.Origin;
	}
	else if (node)
	{
		dest = node.Origin;
	}
	else if (posdest_valid)
	{
		dest = posdest;
	}
	else
	{
		// No target, so just run around until we find something
		int r = P_Random();
		float an = GetAngle();
		float dist;

		for (dist = 256.0; dist >= 64.0; dist -= 64.0)
		{
			if (CheckPath(an, dist))
			{
				posdest_valid = true;
				posdest.x = botmo.Origin.x + dist * cos(an);
				posdest.y = botmo.Origin.y + dist * sin(an);
				posdest.z = botmo.Origin.z;
				SetAngle(an);
				break;
			}

			if (CheckPath(an + 45.0, dist))
			{
				posdest_valid = true;
				posdest.x = botmo.Origin.x + dist * cos(an + 45.0);
				posdest.y = botmo.Origin.y + dist * sin(an + 45.0);
				posdest.z = botmo.Origin.z;
				SetAngle(an + 45.0);
				break;
			}

			// Left is no good, try right
			if (CheckPath(an - 45.0, dist))
			{
				posdest_valid = true;
				posdest.x = botmo.Origin.x + dist * cos(an - 45.0);
				posdest.y = botmo.Origin.y + dist * sin(an - 45.0);
				posdest.z = botmo.Origin.z;
				SetAngle(an - 45.0);
				break;
			}
		}
		if (posdest_valid)
		{
			dest = posdest;
		}
		else
		{
			SetAngle(GetAngle() + 45.0 / 3.0);
			forwardmove = -FORWARDWALK;
			return;
		}
	}

	forwardmove = FORWARDRUN;
	SetAngle(AngleTo(dest));
}

//==========================================================================
//
//	Move
//
//	Main bot movement function. Dodging/attacking movement is also handled
// here
//
//==========================================================================

void Move(float deltaTime)
{
	float dist;

	// Worry about missiles above all else
	if (missile)
	{
		if (t_strafe)
		{
			t_strafe -= deltaTime;
			if (!t_strafe)
			{
				// Don't change direction while dodging missiles (that could be bad)
				//bot->sidemove = -bot->sidemove;
				t_strafe = 2.0;
			}
		}

		// Look at the missle and sidestep it
		SetAngle(AngleTo(missile.Origin));
		forwardmove = -FORWARDRUN;
		return;
	}

	// Anticipate a shot: time to dodge!
	if (enemy && t_anticip <= 0.25)
	{
		if (!sidemove)
			sidemove = SIDERUN;

		switch (info.anticip)
		{
		case bsk_verypoor:
			// Deer caught in the headlights
			sidemove = 0.0;
			return;

		case bsk_poor:
			// Always walk right
			sidemove = SIDEWALK;
			break;

		case bsk_low:
			// Always run right
			sidemove = SIDERUN;
			break;

		case bsk_medium:
			// Just switch directions every couple seconds
			if (t_strafe)
			{
				t_strafe -= deltaTime;
				if (t_strafe <= 0.0)
				{
					sidemove = -sidemove;
					t_strafe = 2.0;
				}
			}
			break;

		case bsk_high:
			// Switch directions when we think our opponent will fire
			if (!t_anticip)
				sidemove = -sidemove;
			break;

		case bsk_excellent:
			// Move in a somewhat random direction when we think our opponent will fire
			if (!t_anticip)
			{
				sidemove = Random() < 0.5 ? SIDERUN : -SIDERUN;

				if (Random() < 0.5)
				{
					forwardmove = -FORWARDWALK;
				}
			}
			break;

		case bsk_supreme:
			// What a squirmy little fucker!
			if (!t_anticip)
			{
				switch (P_Random() & 3)
				{
				case 0:
					sidemove = SIDERUN;
					break;
				case 1:
					sidemove = SIDEWALK;
					break;
				case 2:
					sidemove = -SIDERUN;
					break;
				case 3:
					sidemove = -SIDEWALK;
					break;
				}

				switch (P_Random() & 3)
				{
				case 0:
					forwardmove = FORWARDRUN;
					break;
				case 1:
					forwardmove = FORWARDWALK;
					break;
				case 2:
					forwardmove = -FORWARDRUN;
					break;
				case 3:
					forwardmove = -FORWARDWALK;
					break;
				}
			}
			break;

		default:
			Error("Unknown bot skill level: %d", info.anticip);
			return;
		}
	}

	// Now handle attack movement
	if (enemy)
	{
		bool noforward;
		bool noside;
		float an;

		noforward = false;
		noside = false;
		if (!sidemove )
			sidemove = SIDERUN;

		if (t_strafe)
		{
			t_strafe -= deltaTime;
			if (t_strafe <= 0.0)
			{
				sidemove = -sidemove;
				t_strafe = 2.0;
			}
		}

		dist = botmo.DistTo(enemy);

		// Remember where we saw him last in case he gets away
		lastpos = enemy.Origin;
		lastpos_valid = true;

		// Check if we'd rather pick up something than fight
		if (item)
		{
			if (bItemIsPowerup ||
				(bItemIsWeapon && player.ReadyWeapon.bWimpyWeapon))
			{
				Roam();
				return;
			}
		}

		an = botmo.Angles.yaw;
		if (sidemove < 0.0)
			an -= 90.0;
		else
			an += 90.0;

		if (!CheckPath(an, 48.0)) // We're blocked, so go the other way!
			sidemove = -sidemove;

		if (CheckTo(enemy.Origin) && dist > player.ReadyWeapon.BotCombatDist)
			forwardmove = FORWARDRUN;
		else
			forwardmove = -FORWARDRUN;

		return;
	}

	if (t_strafe)
	{
		t_strafe -= deltaTime;
		if (t_strafe <= 0.0)
		{
			sidemove = -sidemove;
			t_strafe = 2.0;
		}
	}

	// Roam after an item
	Roam();
}

//==========================================================================
//
//	Attack
//
//==========================================================================

void Attack()
{
	// Still reacting to something or we don't have an enemy to fight
	if (t_react || !enemy)
		return;

	// No point in firing if we won't hit them
	if (!Check_LOS(enemy, SHOOTFOV))
		return;

	player.Buttons |= BT_ATTACK;
}

//==========================================================================
//
//	Turn
//
//	[BC] Ahh, the new and improved turning...
//
//==========================================================================

void Turn()
{
	float distance;

	distance = GetAngle() - botmo.Angles.yaw;

	if (!enemy)
	{
		player.ViewAngles.yaw = GetAngle();
		return;
	}

	// [BC] Don't act crazy while trying to aim
	switch (info.accuracy)
	{
	case bsk_verypoor:
	case bsk_poor:
	case bsk_low:
		if (distance > 7.5)
			distance = 7.5;
		if (distance < -7.5)
			distance = -7.5;
		break;
	case bsk_medium:
		if (distance > 15.0)
			distance = 15.0;
		if (distance < -15.0)
			distance = -15.0;
		break;
	case bsk_high:
		if (distance > 22.5)
			distance = 22.5;
		if (distance < -22.5)
			distance = -22.5;
		break;
	case bsk_excellent:
		if (distance > 30.0)
			distance = 30.0;
		if (distance < -30.0)
			distance = -30.0;
		break;
	case bsk_supreme:
		if (distance > 37.5)
			distance = 37.5;
		if (distance < -37.5)
			distance = -37.5;
		break;
	}
	player.ViewAngles.yaw = AngleMod360(botmo.Angles.yaw + distance);
}

//==========================================================================
//
//	Pitch
//
//==========================================================================

void Pitch()
{
	if (enemy)
	{
		TVec dir;
		TAVec ang;

		dir = enemy.Origin - botmo.Origin;
		VectorAngles(&dir, &ang);
		botmo.Angles.pitch = ang.pitch;
	}
	else
	{
		botmo.Angles.pitch = 0.0;
	}
}

//==========================================================================
//
//	Killed
//
//==========================================================================

void Killed(EntityEx victim)
{
	// [BC] Let some anger out
	angerlevel -= 5;
	enemy = none;

	// [BC] Don't need to worry about following him anymore
	lastpos_valid = false;
}

//==========================================================================
//
//	Died
//
//==========================================================================

void Died(EntityEx killer)
{
}

//==========================================================================
//
//	OnBeginPlay
//
//==========================================================================

void OnBeginPlay()
{
	int botskill = 2;
	int bottype = 0;
	botinfo_t *binfo;
	int i;

	if (strcmp(player.PlayerName, ""))
	{
		for (i = 0; i < MainGameInfo::NUMTOTALBOTS; i++)
		{
			if (!stricmp(MainGameInfo(player.Level.Game).botinfo[i].Name, player.PlayerName))
			{
				bottype = i;
				break;
			}
		}
		// We've already handled the "what if there's no match" exception
	}
	else
	{
		// If the user doesn't input a name, don't
		// spawn one of the "special" bots, only one of the
		// normal ones.
		bottype = P_Random() % MainGameInfo::NUMBOTTYPES;
	}

	binfo = &MainGameInfo(player.Level.Game).botinfo[bottype];

	t_strafe = 1.0;

	if (botskill > 4)
		botskill = 4;
	if (botskill < 0)
		botskill = 0;

	// Implement skill settings
	info.accuracy = SkillLower(binfo->accuracy, 4 - botskill);
	info.intelect = SkillLower(binfo->intelect, 4 - botskill);
	info.evade = SkillLower(binfo->evade, 4 - botskill);
	info.anticip = SkillLower(binfo->anticip, 4 - botskill);
	info.reaction = SkillLower(binfo->reaction, 4 - botskill);
	player.UserInfo = binfo->userinfo;
}

//==========================================================================
//
//	OnSpawn
//
//==========================================================================

void OnSpawn()
{
}

defaultproperties
{
}