public static CreatureClassBase Create(CreatureClassType creatureClassType, CreatureBase creatureBase)
{
switch (creatureClassType)
{
case CreatureClassType.Monster:
return(new Monster(creatureBase));
case CreatureClassType.Warrior:
return(new Warrior(creatureBase));
case CreatureClassType.Barbarian:
return(new Barbarian(creatureBase));
case CreatureClassType.Monk:
return(new Monk(creatureBase));
case CreatureClassType.Cleric:
return(new Cleric(creatureBase));
case CreatureClassType.Thief:
return(new Thief(creatureBase));
case CreatureClassType.Mage:
return(new Mage(creatureBase));
default:
throw new ArgumentOutOfRangeException(nameof(creatureClassType), creatureClassType, null);
}
}
public bool Attack(CreatureBase creature)
{
if (creature == null)
{
return(false);
}
List <CreatureBase> inRange = creature.ActiveLaneNode.laneManager.SearchRange((int)creature.Range, creature.ActiveLaneNode, creature.Owner);
if (inRange.GetEnemies(creature.Owner).Count > 0 && inRange.GetEnemies(creature.Owner) [0].Health > 0)
{
if (!SpendToken())
{
return(false);
}
// LogStack.Log ("Response | Attack", LogLevel.Stack);
IResponse response = new ActionResponse(creature, 0, logicBase, ResponseActionType.Attack, creature.ActiveLaneNode);
if (!ResponseChain.Contains(response))
{
ResponseChain.Add(response);
}
else
{
LogStack.Log("##### Duplicate Attack Response", LogLevel.System);
RefundToken();
return(false);
}
return(true);
}
else
{
return(false);
}
}
void AttemptMoveAttack(CreatureBase creature)
{
if (creature != null)
{
List <CreatureBase> searchTargetCreatures = creature.ActiveLaneNode.laneManager.SearchRange((int)creature.Range, creature.ActiveLaneNode, this);
bool foundAttackTarget = false;
foreach (CreatureBase _creature in searchTargetCreatures)
{
if (_creature.Owner != creature.Owner) //Found enemy creature in range
{
foundAttackTarget = true;
AIResponse.Attack(creature);
}
}
if (!foundAttackTarget)
{
int moveSpaces = creature.ActiveLaneNode.laneManager.GetOpenNodes(creature.ActiveLaneNode, _RightFacing);
if (moveSpaces > AIResponse.Tokens)
{
moveSpaces = AIResponse.Tokens;
}
if (AIResponse.Move(creature, moveSpaces))
{
LogStack.Log("Hal Move " + creature.GetInstanceID() + " - " + moveSpaces + " spaces - " + creature.LaneProgress, LogLevel.System);
}
}
}
}
public virtual double DetermineAttack(CreatureBase target)
{
// default assumes just strength
return(_creatureBase.Strength +
_creatureBase.Bonuses.Where(b => b.StatType == StatType.Strength).Sum(b => b.StatValue) +
Dice.D20Roll());
}
void OnTriggerStay(Collider other)
{
Collider[] colliders = Physics.OverlapBox(transform.position, awarenessBox.size);
for (int i = 0; i < colliders.Length; i++)
{
if (colliders[i].gameObject.tag == "Player")
{
}
else if (colliders[i].gameObject.tag == "Food" && CreatureHunger < FindFoodHunger)
{
Vector3 targetPosition = colliders[i].transform.position;
MoveToPoint(targetPosition);
}
else
{
CreatureBase othercreaturebase = colliders[i].GetComponent <CreatureBase>();
if (othercreaturebase)
{
if (othercreaturebase.isAggressive | othercreaturebase.isHostile)
{
if (isAggressive | isHostile)
{
Vector3 targetPosition = colliders[i].transform.position;
MoveToPoint(targetPosition);
}
else
{
Vector3 targetPosition = transform.position - colliders[i].transform.position;
MoveToPoint(targetPosition);
}
}
}
}
}
}
public override void OnTick(IBoardState[] data)
{
//Spend all tokens
//Spawn in each lane otherwise attack or move
int maxCycles = 99;
while (AIResponse.Tokens > 0 && maxCycles > 0) //Spend all tokens
{
maxCycles--;
if (Random.Range(0, 2) == 0 || _Creatures.Count == 0)
{
int randomLane = Random.Range(1, TournamentManager._instance.lanes.Count + 1);
// LogStack.Log ("Random Spawn Lane " + randomLane, LogLevel.System);
if (!AIResponse.Spawn(Random.Range(0, 2) == 0 ? Spawnable.Bunny : Spawnable.Unicorn, randomLane))
{
if (_Creatures.Count > 0)
{
CreatureBase randomCreature = _Creatures[Random.Range(0, _Creatures.Count)];
AttemptMoveAttack(randomCreature);
}
}
}
else if (_Creatures.Count > 0)
{
CreatureBase randomCreature = _Creatures[Random.Range(0, _Creatures.Count)];
AttemptMoveAttack(randomCreature);
}
}
AIResponse.FinalizeResponse();
}
private void BunnyThreatCheck()
{
// TODO
LogStack.Log("%%%%%%%%%%%%%%%%%%%%%% BunnyThreatCheck(1) %%%%%%%%%%%%%% - iSavingTokens = " + iSavingTokens, LogLevel.Debug);
List <CreatureBase> ThreatenedBunnies = GetTroops(Spawnable.Bunny, true);
int iMaxThreatDist = 99;
foreach (CreatureBase bunny in ThreatenedBunnies)
{
if (bunny.Health == 1)
{
continue;
}
int iTargetDist = -1;
CreatureBase Target = GetClosestEnemy(bunny, out iTargetDist);
if (Target != null && Target.CreatureType == Spawnable.Unicorn && iMaxThreatDist >= iTargetDist && iTargetDist <= bunny.Health + 1)
{
LogStack.Log("%%%%%%%%%%%%%%%%%%%%%% BunnyThreatCheck(2) %%%%%%%%%%%%%% - FoundTarget = " + Target.name + " @ " + iTargetDist + " Tiles Away", LogLevel.Debug);
responseCreature = bunny;
iMaxThreatDist = iTargetDist;
}
}
if (iMaxThreatDist != 99)
{
iSavingTokens = iMaxThreatDist + 1;
responseState = EResponseState.BunnyRush;
LogStack.Log("%%%%%%%%%%%%%%%%%%%%%% BunnyThreatCheck(3) %%%%%%%%%%%%%% - iSavingTokens = " + iSavingTokens, LogLevel.Debug);
}
LogStack.Log("%%%%%%%%%%%%%%%%%%%%%% BunnyThreatCheck(4) %%%%%%%%%%%%%% - iSavingTokens = " + iSavingTokens, LogLevel.Debug);
}
//returns your nearest creature and how far away it is
// retuns null if no creature in the lane
public Tuple <CreatureBase, int> GetMyNearestCreature(CreatureBase OpponentCreature, LaneManager[] Board)
{
if (OpponentCreature == null)
{
return(null);
}
List <CreatureBase> CreaturesInLane = OpponentCreature.ActiveLaneNode.laneManager.GetFriendliesInLane(this);
CreatureBase NearestCreature = null;
if (CreaturesInLane.Count > 0)
{
NearestCreature = OpponentCreature.ActiveLaneNode.laneManager.GetFriendliesInLane(this) [0];
}
else
{
NearestCreature = null;
}
LogStack.Log("GetMyNearestCreature() " + NearestCreature, Logging.LogLevel.System);
if (NearestCreature == null)
{
return(null);
}
return(Tuple.Create(NearestCreature, Mathf.Abs(NearestCreature.LaneIndex - OpponentCreature.LaneIndex)));
}
public AIBase(CreatureBase C)
{
LinkedCreature = C;
RndGen = new Random();
FOVHandler = (libtcodWrapper.TCODFov)Utilities.InterStateResources.Instance.Resources["Game_FOVHandler"];
PathFinder = (libtcodWrapper.TCODPathFinding)Utilities.InterStateResources.Instance.Resources["Game_PathFinder"];
}
public void MoveAtk(CreatureBase creat)
{
Debug.Log("Moving or attacking: " + creat.name + ", in lane: " + creat.LaneIndex.ToString());
if (creat != null)
{
bool TargetInRange = false;
List <CreatureBase> Targets = creat.ActiveLaneNode.laneManager.SearchRange((int)creat.Range, creat.ActiveLaneNode, this);
foreach (CreatureBase creature in Targets)
{
if (creature.Owner != creat.Owner)
{
TargetInRange = true;
AIResponse.Attack(creat);
}
}
if (!TargetInRange)
{
int spaces = creat.ActiveLaneNode.laneManager.GetOpenNodes(creat.ActiveLaneNode, creat.RightFacing);
if (spaces > AIResponse.Tokens)
{
spaces = AIResponse.Tokens;
}
if (spaces > 10)
{
spaces = 10;
}
AIResponse.Move(creat, spaces);
}
}
}
public ActionResponse(CreatureBase Creature, int Lane, AI.LogicBase LogicBase, ResponseActionType ResponseActionType, LaneNode LaneNode)
{
_lane = Lane;
_creatureBase = Creature;
_logicBase = LogicBase;
_responseActionType = ResponseActionType;
_laneNode = LaneNode;
}
public void AssignToLane(CreatureBase creature, bool player1)
{
Transform spawnNode = player1 ? startNode.transform : endNode.transform;
creature.transform.position = spawnNode.transform.position;
creature.transform.rotation = spawnNode.transform.rotation;
creatures.Add(creature);
}
public LimbBase(CreatureBase H, string Desc, int HC)
{
Host = H;
AttachedItems = new Guardian_Roguelike.World.Items.Inventory();
HP = 100;
BleedRate = 0;
Description = Desc;
HitChance = HC;
}
public void Auto_Nearest(LaneManager[] Board)
{
Tuple <CreatureBase, int> nearestAndRange = GetNearestCreatureToNearestEnemy(Board);
if (nearestAndRange != null && _Creatures.Count > 0)
{
LogStack.Log("I have a nearby unit", Logging.LogLevel.Color);
List <CreatureBase> inRange = nearestAndRange.Item1.ActiveLaneNode.laneManager.SearchRange((int)nearestAndRange.Item1.Range, nearestAndRange.Item1.ActiveLaneNode, nearestAndRange.Item1.Owner);
if (inRange.GetEnemies(nearestAndRange.Item1.Owner).Count > 0)
{
// if (AIResponse.Attack (nearestAndRange.Item1)) {
if (!AIResponse.Attack(nearestAndRange.Item1, nearestAndRange.Item1.CreatureType == Spawnable.Bunny ? 1 : (int)GetNearestEnemy(Board).Health))
{
// LogStack.Log ("Attack Validation check failed", Logging.LogLevel.System);
}
else
{
LogStack.Log("Nearby Unit Attacking", Logging.LogLevel.Color);
}
}
else
{
LogStack.Log("Try Move " + nearestAndRange.Item1.GetInstanceID(), Logging.LogLevel.System);
if (!AIResponse.Move(nearestAndRange.Item1))
{
LogStack.Log("Move validation check failed", Logging.LogLevel.Color);
}
else
{
LogStack.Log("Nearby Unit Moving", Logging.LogLevel.Stack);
}
}
}
else if (Opponent._Creatures.Count > 0)
{
CreatureBase nearestCreature = GetNearestEnemy(Board);
int nearestLane = 1;
Spawnable spawnCreature = Spawnable.Bunny;
if (nearestCreature != null)
{
spawnCreature = nearestCreature.LaneProgress < 6 ? Spawnable.Unicorn : Spawnable.Bunny;
nearestLane = nearestCreature.ActiveLaneNode.laneManager.LaneNumber;
}
if (!AIResponse.Spawn(spawnCreature, nearestLane))
{
LogStack.Log("Spawn Validation check failed", Logging.LogLevel.Stack);
}
}
else if (Opponent._Creatures.Count == 0)
{
LogStack.Log("Wait till opponent does something", Logging.LogLevel.Stack);
}
}
void AttemptAttackMoveTarget(CreatureBase creature)
{
Debug.Log("---Attempt Target---");
//---Find friendly in same lane as _targetCreature---
List <CreatureBase> friendlies = creature.ActiveLaneNode.laneManager.GetFriendliesInLane(this);
if (friendlies.Count > 0)
{
CreatureBase closestFriendly = friendlies[0];
//--Attempt to attack...
int openNodes = closestFriendly.ActiveLaneNode.laneManager.GetOpenNodes(closestFriendly.ActiveLaneNode, _RightFacing);
//--is enemy in attack range? Attack...
if (openNodes < closestFriendly.Range)
{
// AIResponse.Attack (closestFriendly);
foreach (var pair in attackingPairs)
{
if (pair.ContainsCreature(closestFriendly))
{
//---if first creature still exists---
if (pair.creatures[0] != null)
{
if (!pair.AttackAsPair(AIResponse))
{
pair.MovePair(AIResponse);
}
}
else
{
//---------attempt to attack with second creature-----------
if (!pair.AttackSingle(pair.creatures[1], AIResponse))
{
//--------else attempt to move second creature------------
pair.MoveSingle(pair.creatures[1], AIResponse, openNodes);
}
}
break;
}
}
}
//--Else move...
else
{
foreach (var pair in attackingPairs)
{
if (pair.ContainsCreature(closestFriendly))
{
pair.MovePair(AIResponse);
break;
}
}
}
}
}
public bool MoveSingle(CreatureBase _creature, AIResponseManager responseManager, int _Range)
{
if (responseManager.Move(creatures[1], _Range))
{
return(true);
}
else
{
return(false);
}
}
// returns your nearest creature and how far away it is from the other xreature
// retuns null if no creature in the lane
public Tuple <CreatureBase, int> GetNearestCreatureToNearestEnemy(LaneManager[] Board)
{
CreatureBase creature = GetNearestEnemy(Board);
Tuple <CreatureBase, int> NearestCreatureToNearestEnemy = GetMyNearestCreature(creature, Board);
if (creature != null)
{
// LogStack.Log ("GetNearestCreatureToNearestEnemy() " + NearestCreatureToNearestEnemy == null?null : NearestCreatureToNearestEnemy.Item1.ToString (), Logging.LogLevel.System);
}
return(NearestCreatureToNearestEnemy);
}
public bool ContainsCreature(CreatureBase creaturetoTest)
{
for (int i = 0; i < creatures.Length; i++)
{
if (creatures[i] == creaturetoTest)
{
return(true);
}
}
return(false);
}
private void TrackCreatureDeaths(CreatureBase creature)
{
if (creature.Owner == this)
{
I_Deaths++;
}
else
{
I_Kills++;
}
}
public bool AttackSingle(CreatureBase _creature, AIResponseManager responseManager)
{
if (responseManager.Attack(creatures[1], 1))
{
return(true);
}
else
{
return(false);
}
}
void OnTriggerEnter(Collider other)
{
if (other.gameObject.layer == 10 && !dead)
{
CreatureBase otherCreature = other.attachedRigidbody.GetComponent <CreatureBase> ();
if (otherCreature.owner != owner)
{
otherCreature.StopAttack();
}
}
}
public void Damage(CreatureBase killer, float amount)
{
LogStack.Log(transform.name + " killed by Player " + (killer == TournamentManager._instance.P1 ? "1" : "2") + "'s " + killer.CreatureType, LogLevel.Stack);
health -= amount;
uiHealth.SetHealth(health);
if (health <= 0)
{
Die();
// shouldDie = true;
}
}
public bool Attack(CreatureBase creature, int AmountOfTimes = 1)
{
bool allTrue = true;
for (int i = 0; i < AmountOfTimes; i++)
{
if (!Attack(creature))
{
allTrue = false;
}
}
return(allTrue);
}
public override void OnTick(IBoardState[] data)
{
boardState = (LaneManager[])data;
for (int i = 1; i < (TournamentManager._instance.tokensPerRound == 1?3:6); i++)
{
FormPattern(LanePattern, i, boardState);
}
//for (int i = 0; i < 3; i++)
//{
// AIResponse.Attack(boardState[i].GetFriendliesInLane(this).Count>0? boardState[i].GetFriendliesInLane(this)[0]:null);
//}
Auto_Nearest(boardState);
CreatureBase nearest = null;
for (int i = 0; i < 2; i++)
{
if (boardState[i].GetFriendliesInLane(this).Count != 0)
{
if (nearest != null)
{
if (boardState[i].GetFriendliesInLane(this) [0].LaneProgress > nearest.LaneProgress)
{
nearest = boardState[i].GetFriendliesInLane(this) [0];
}
}
else
{
nearest = boardState[i].GetFriendliesInLane(this) [0];
}
}
}
if (AIResponse.Tokens > Threshhold)
{
AIResponse.Move(nearest, AIResponse.Tokens - Threshhold);
}
else
{
AIResponse.Move(nearest, 1);
}
for (int i = 0; i < AIResponse.Tokens; i++)
{
Auto_Nearest(boardState);
}
AIResponse.FinalizeResponse();
}
void AwardToken(CreatureBase creature)
{
if (logicBase != creature.Owner)
{
if (creature.CreatureType == Spawnable.Bunny)
{
tokens += 1;
}
else if (creature.CreatureType == Spawnable.Unicorn)
{
tokens += 2;
}
}
}
public int GetNearestEnemyNodesAway(LaneManager[] Board)
{
LogStack.Log("GetNearestEnemyNodesAway()", Logging.LogLevel.Color);
CreatureBase creature = GetNearestEnemy(Board);
if (creature != null)
{
return(creature.ActiveLaneNode.laneManager.GetNodeCount - creature.LaneProgress);
}
else
{
return(-1);
}
}
public int GetNearestEnemyNodesAwayFrom(CreatureBase myCreature)
{
LogStack.Log("GetNearestEnemyNodesAwayFrom()", Logging.LogLevel.Color);
CreatureBase creature = GetNearestEnemyTo(myCreature);
if (creature != null)
{
return(Mathf.Abs(myCreature.LaneIndex - creature.LaneIndex));
}
else
{
return(-1);
}
}
public int GetNearestEnemyLane(LaneManager[] Board)
{
LogStack.Log("GetNearestEnemyLane()", Logging.LogLevel.Color);
CreatureBase creature = GetNearestEnemy(Board);
if (creature != null)
{
return(TournamentManager._instance.lanes.IndexOf(creature.ActiveLaneNode.laneManager));
}
else
{
return(-1);
}
}
public FSM_Aggressive(CreatureBase C)
: base(C)
{
CurState = AIState.Wander;
CurWanderDirection = new Point();
do
{
CurWanderDirection.X = RndGen.Next(-1, 1);
CurWanderDirection.Y = RndGen.Next(-1, 1);
} while (CurWanderDirection.X == 0 && CurWanderDirection.Y == 0);
PlayerLastSeenAt = new Point();
Player = (CreatureBase)Utilities.InterStateResources.Instance.Resources["Game_PlayerCreature"];
}
public CreatureBase GetNearestEnemyTo(CreatureBase myCreature)
{
List <CreatureBase> enemyCreatures = myCreature.ActiveLaneNode.laneManager.GetEnemiesInLane(this);
if (enemyCreatures.Count > 0)
{
LogStack.Log("GetNearestEnemy()" + enemyCreatures[0], Logging.LogLevel.Color);
return(enemyCreatures[0]);
}
else
{
LogStack.Log("GetNearestEnemy()" + null, Logging.LogLevel.Color);
return(null);
}
}
