public void ObservedEnemyAdd(Creature enemy)
{
if(!_observedEnemies.ContainsKey(enemy.UniqueID))
{
_observedEnemies.Add(enemy.UniqueID, enemy);
}
}
/// <summary>
/// Register creature in the Collider.
/// </summary>
public void RegisterCreature(Creature someGuy)
{
LinkedList<Coords> steppedOn = TilesCoveredByEllipse(new Coords(CoordsType.Pixel, someGuy.PositionDouble), someGuy.RadiusX, someGuy.RadiusY);
foreach (Coords c in steppedOn)
{
this.ClippingBoxesAddTo(c, someGuy);
}
_occupiedBoxes.Add(someGuy, steppedOn);
}
/// <summary>
/// Adds a creature to the list of tenant creatures of a tile of the grid.
/// </summary>
public void ClippingBoxesAddTo(Coords box, Creature newGuy)
{
_clippingBoxes[box.X, box.Y].Add(newGuy);
}
public ActionAttack(Creature actor, Creature target, UInt16 attackTime) : base(actor)
{
_target = target;
this.ActionTotalDuration = attackTime;
}
public ActionWait(Creature actor, UInt16 ticksToWait)
: base(actor)
{
this.ActionTotalDuration = ticksToWait;
}
/// <summary>
/// Performs a terrain passability check betwee two points by doing pixel validity checks at interval delta.
/// </summary>
public List<Creature> RayTracerPassabilityCheckRough(Creature client, Vector v1, Vector v2, double delta)
{
Vector difference = v2 - v1;
Vector deltaV = difference;
deltaV.ScaleToLength(delta);
Vector currentPosition = v1;
for (int i = 0; i < difference.Length() / deltaV.Length(); ++i)
{
Coords pixel = new Coords(CoordsType.Pixel, currentPosition);
List<Creature> collision = _myCollider.CreatureClippingCheck(client, pixel, false);
if (collision == null || collision.Count > 0)
{
return collision;
}
currentPosition += deltaV;
}
return new List<Creature>();
}
/// <summary>
/// Add creature to the menagerie. They 'key' is the creature ID.
/// </summary>
public void MenagerieAddCreatureTo(UInt32 key, Creature newGuy)
{
this._menagerie[key] = newGuy;
}
public Inventory(Creature owner)
: this()
{
this._ownerTile = null;
this._ownerCreature = owner;
}
/// <summary>
/// Creature processes incurred hit.
/// </summary>
/// <param name="attackerID">ID of the attacker</param>
/// <param name="struckMember">Struck body part</param>
/// <param name="hitMagnitude">Hit magnitude</param>
public void HitIncurred(Creature attacker, UInt16 hitMagnitude)
{
// elementary combat model
this._statHP = (UInt16) Math.Max(0, _statHP - (hitMagnitude - _statArmor));
if (_statHP == 0)
{
this._dead = true;
}
}
/// <summary>
/// Remove a creature from the Collider database.
/// </summary>
public void RemoveCreature(Creature someGuy)
{
//LinkedList<Coords> steppedOn = TilesCoveredByEllipse(new Coords(CoordsType.Pixel, someGuy.PositionDouble), someGuy.RadiusX, someGuy.RadiusY);
foreach (Coords c in _occupiedBoxes[someGuy])
{
this.ClippingBoxesRemoveFrom(c, someGuy);
}
_occupiedBoxes.Remove(someGuy);
}
/// <summary>
/// Returns an exact pixel-by-pixel collision check.
/// 'null' - terrain collision.
/// empty - no collision.
/// non-empty - creature collision.
/// </summary>
public List<Creature> RayTracerPassabilityCheckPrecise(Creature client, Vector v1, Vector v2)
{
return RayTracerPassabilityCheckPrecise(client, new Coords(CoordsType.Pixel, v1), new Coords(CoordsType.Pixel, v2));
}
private List<Creature> RayTracerPassabilityCheckPrecise(Creature client, Coords c1, Coords c2)
{
// this is only for pixels
if (c1.Type != CoordsType.Pixel || c2.Type != CoordsType.Pixel)
{
throw new Exception("Non-pixel coordinate passed for pixel-level collision check");
}
// check last point first.
List<Creature> testLast = this.CreatureClippingCheck(client, c2, true);
if (testLast == null || testLast.Count > 0)
{
return testLast;
}
Int32 x0 = c1.X;
Int32 y0 = c1.Y;
Int32 x1 = c2.X;
Int32 y1 = c2.Y;
int dx = Math.Abs(x1 - x0);
int dy = Math.Abs(y1 - y0);
int x = x0;
int y = y0;
int n = dx + dy;
int x_inc = (x1 > x0) ? 1 : -1;
int y_inc = (y1 > y0) ? 1 : -1;
int error = dx - dy;
dx *= 2;
dy *= 2;
for (; n > 0; --n)
{
Coords potentialPosition = new Coords(CoordsType.Pixel, x, y);
// validity check
List<Creature> collision = this.CreatureClippingCheck(client, potentialPosition, true);
if (collision == null || collision.Count > 0)
{
return collision;
}
if (error > 0)
{
x += x_inc;
error -= dy;
}
else
{
y += y_inc;
error += dx;
}
}
return new List<Creature>();
}
/// <summary>
/// Returns Creatures overlapped by agent.
/// </summary>
public List<Creature> PotentialCreatureToCreatureCollision(Creature critter, Coords potentialPosition)
{
List<Creature> returnVal = new List<Creature>();
UInt16 critterRadiusX = critter.RadiusX;
UInt16 critterRadiusY = critter.RadiusY;
LinkedList<Coords> checkList = this.TilesCoveredByEllipse(potentialPosition, critterRadiusX, critterRadiusY);
foreach (Coords checkme in checkList)
{
foreach (Creature obstacle in _clippingBoxes[checkme.X, checkme.Y])
{
// ignore self
if (obstacle == critter)
{
continue;
}
if (CollisionCheckEllipses(potentialPosition, critterRadiusX, critterRadiusY,
new Coords(CoordsType.Pixel, obstacle.PositionDouble), obstacle.RadiusX, obstacle.RadiusY))
{
returnVal.Add(obstacle);
}
}
}
return returnVal;
}
/// <summary>
/// Removes a creature from the list of tenants of a tile of the grid.
/// </summary>
public void ClippingBoxesRemoveFrom(Coords box, Creature removeMe)
{
_clippingBoxes[box.X, box.Y].Remove(removeMe);
}
public void MemberRemove(Creature oldGuy)
{
_members.Remove(oldGuy);
}
// Checks if there are valid contextual actions to be taken.
private void ObtainAction()
{
// take care of forced target, if any
if (_targetForced != null)
{
if (TargetIsInRange(_targetForced))
{
AddAction(new ActionAttack(_owner, _targetForced, _owner.StatAttackTime));
return;
}
else if (_owner.Team.EnemyIsObserved(_targetForced))
{
++_routeToForcedTargetRecalcTimer;
if (_routeToForcedTargetRecalcTimer % Constants.DefaultRouteToForcedTargetRecalcTimer == 1)
{
_myNavigator = new Navigator(_owner, _targetForced.PositionPixel, false);
return;
}
}
else
{
if (!_targetForced.Dead)
{
_myNavigator = new Navigator(_owner, _targetForced.PositionPixel, false);
}
_targetForced = null;
_routeToForcedTargetRecalcTimer = 0;
}
}
// check for enemies
if (_observedEnemies.Count > 0)
{
if (_target != null)
{
if (TargetIsInRange(_target))
{
AddAction(new ActionAttack(_owner, _target, _owner.StatAttackTime));
return;
}
}
// pick target
_target = NearestEnemy();
if (TargetIsInRange(_target))
{
AddAction(new ActionAttack(_owner, _target, _owner.StatAttackTime));
return;
}
else
{
_myNavigator = new Navigator(_owner, _target.PositionPixel, false);
return;
}
}
else
{
if (_target != null)
{
if (!_target.Dead)
{
_myNavigator = new Navigator(_owner, _target.PositionPixel, false);
}
_target = null;
return;
}
}
}
public bool EnemyIsObserved(Creature enemy)
{
return _observedEnemies.ContainsKey(enemy.UniqueID);
}
//private Int32 _observedCreaturesCount = 0;
/* public List<UInt32> ObservedCreatures
{
get
{
return this._observedCreatures;
}
}*/
// PROBLEM: make it so the update DOESN'T occur if a remove is followed by an add in the same tick.
public void ObservedCreaturesAdd(Creature critter)
{
// don't add self to list.
if (!critter.Equals(this._owner))
{
if (critter.Team == _owner.Team)
{
_observedFriends.Add(critter);
}
else
{
_observedEnemies.Add(critter);
_owner.Team.ObservedEnemyAdd(critter);
}
}
}
public void ObservedEnemyRemove(Creature enemy)
{
_observedEnemies.Remove(enemy.UniqueID);
}
public void ObservedCreaturesRemove(Creature critter)
{
if (critter.Team == _owner.Team)
{
_observedFriends.Remove(critter);
}
else
{
_observedEnemies.Remove(critter);
_owner.Team.ObservedEnemyRemove(critter);
}
}
public Inventory(TilePassable ownerTile)
: this()
{
this._ownerTile = ownerTile;
this._ownerCreature = null;
}
private bool TargetIsInRange(Creature target)
{
// NOTE: This should be adjusted according to bboxes!
return (_owner.PositionDouble.DistanceTo(target.PositionDouble) < _owner.StatAttackRange);
}
public void MortuaryAddCreatureTo(UInt32 key, Creature newGuy)
{
this._mortuary[key] = newGuy;
}
public Brain(Creature owner)
{
_owner = owner;
}
public void SpawnCreature(Coords startPoint, Team team, CreatureGenerator generator)
{
Creature newguy = new Creature(this, startPoint, (UInt16)this.IssueCreatureID(), team, generator);
team.MemberRegister(newguy);
}
public Navigator(Creature traveler, Coords goalPixel, bool forceMove)
{
this._traveler = traveler;
this._goalPixel = goalPixel;
this._goalTile = new Coords(CoordsType.Tile, goalPixel);
this._forceMove = forceMove;
this.AcquireRoute();
}
public ActionSaySomething(Creature actor, UInt16 duration, String wordsOfWisdom)
: base(actor)
{
this.ActionTotalDuration = duration;
this._text = wordsOfWisdom;
this.Passive = true;
}
public void MemberRegister(Creature newGuy)
{
_members.Add(newGuy);
}
public Action(Creature actor)
{
this._actor = actor;
_finished = false;
}
/// <summary>
/// Does a clip check on an agent. Returns the type of collision.
/// 'null' - terrain collision. 'empty list' - no collision.
/// </summary>
public List<Creature> CreatureClippingCheck(Creature critter, Coords potentialPosition, bool creaturesClipCheck)
{
// obtain new entry tiles
LinkedList<Coords> newEntries = this.TilesCoveredByEllipse(potentialPosition, critter.RadiusX, critter.RadiusY);
// we've hit a tileImpassable or out of bounds
if (newEntries == null)
{
return null;
}
List<Creature> returnVal = new List<Creature>();
// if the flags demands it, check if there is a creature in the way
if (creaturesClipCheck)
{
returnVal = this.PotentialCreatureToCreatureCollision(critter, potentialPosition);
}
return returnVal;
}
