public void OnArrived(IAgentInfo arriver, IAgentUpdateInfo agentUpdate)
{
if (this.Clan != arriver.Clan)
{
this.Attack(arriver);
}
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
if (!agentUpdate.Has(AgentEffect.UnitTest))
{
this.UnitTest();
}
var currentNode = agentUpdate.Node;
if (currentNode.IsClaimable)
{
this.Claim(currentNode);
}
var opponent = currentNode.OpposingAgents.FirstOrDefault(_ => _.Clan != this.Clan);
if (opponent != null)
{
this.Attack(opponent);
}
var nodes = agentUpdate.Node.Exits
.Select(_ => _.Value)
.Where(_ => _ != agentUpdate.NodePrevious)
.Randomize()
.GetEnumerator();
while (nodes.MoveNext() && this.Move(nodes.Current).Result != NodeResultType.Success) ;
}
public static void UnitTest(IAgentUpdateInfo agentUpdate, IEngineer1 engineer)
{
if (!agentUpdate.Effects.Contains(AgentEffect.UnitTest))
{
engineer.UnitTest();
}
}
public static INodeInformation GreedyMoveToFirstClaimable(IAgentUpdateInfo agentUpdate, IGAgent agent)
{
List<INodeInformation> possibleNodes =
NextLevelFirstClaimable(agent.Deck,
new List<INodeInformation>() {agentUpdate.Node},
agentUpdate.Owner.Id,1);
if (!possibleNodes.Any())
{
ICollection<INodeInformation> nodeInformations = agentUpdate.Node.Exits.Values;
possibleNodes = NextLevelFirstClaimable(agent.Deck, nodeInformations, agentUpdate.Owner.Id,2);
if (!possibleNodes.Any())
{
var nextLevel = new List<INodeInformation>();
//3rd level
foreach (INodeInformation nodeInformation in nodeInformations)
{
nextLevel.AddRange(nodeInformation.Exits.Values);
}
possibleNodes = NextLevelFirstClaimable(agent.Deck, nextLevel, agentUpdate.Owner.Id,3);
}
}
return PickMove(agentUpdate, possibleNodes, agent);
}
public override void OnAttackedActions(IAgentInfo attacker, IAgentUpdateInfo agentUpdate)
{
if ((attacker.EffectFlags & AgentEffect.Decompile) != AgentEffect.Decompile)
Engineer.Decompile(attacker, this);
base.OnAttackedActions(attacker, agentUpdate);
}
protected void TryClaimAndMove(IAgentUpdateInfo agentUpdate)
{
if (!agentUpdate.Node.IsClaimable || Claim.TryClaim(agentUpdate.Node, this))
{
Move.GreedyMoveToFirstClaimable(agentUpdate, this);
}
}
public virtual void OnArrivedActions(IAgentInfo arriver, IAgentUpdateInfo agentUpdate)
{
if (arriver.Owner != agentUpdate.Owner)
{
this.Attack(arriver);
}
}
public static INodeInformation ClosestNode(IAgentUpdateInfo agentUpdate)
{
var cleanNodes = CleanNodes(agentUpdate);
return cleanNodes
.Where(n => n.Distance(agentUpdate.Node) == cleanNodes.Min(e => e.Distance(agentUpdate.Node)))
.FirstOrDefault();
}
private static IEnumerable<INodeInformation> CleanNodes(IAgentUpdateInfo agentUpdate)
{
var cleanNodes = agentUpdate.Node.Exits.Values.Where(e => e.Effects.Count() <= 0 || e.Effects.Contains(NodeEffect.None));
if (null == cleanNodes)
cleanNodes = new List<INodeInformation>();
return cleanNodes;
}
public static void Mentor(IAgentUpdateInfo agentUpdate, IEngineer4 engineer)
{
IEnumerable<IAgentInfo> mentorTargets = agentUpdate.Node.MyAgents.Where(x => !x.Effects.Contains(AgentEffect.Mentor));
if (mentorTargets.Any())
{
engineer.Mentor(mentorTargets);
}
}
public override void OnArrivedActions(IAgentInfo arriver, IAgentUpdateInfo agentUpdate)
{
if (arriver.Owner != agentUpdate.Owner)
if ((arriver.EffectFlags & AgentEffect.Decompile) != AgentEffect.Decompile)
Engineer.Decompile(arriver, this);
base.OnArrivedActions(arriver, agentUpdate);
}
protected virtual void GreedyClaim(IAgentUpdateInfo agentUpdate, Pawn agent)
{
string displayHandle = agentUpdate.Node.Owner.DisplayHandle;
if (ClaimSkills.TryClaim(agentUpdate.Node, agent))
{
Deck.Trace("Claimed From Node Owner: " + displayHandle, TraceType.Information);
MoveSkills.GreedyMoveToFirstClaimable(agentUpdate, agent);
}
}
protected virtual void AgentMove(IAgentUpdateInfo agentUpdate)
{
if (agentUpdate.Action == AgentAction.Raiding)
{
ClaimSkills.TryClaim(agentUpdate.Node, this);
}
MoveSkills.GreedyMoveToFirstAgent(agentUpdate, this,Deck);
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
Engineer.UnitTest(agentUpdate,this);
if (!agentUpdate.Node.IsClaimable || TryClaim(agentUpdate.Node))
{
Move.GreedyMoveToFirstClaimable(agentUpdate, this);
}
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
if (agentUpdate.Node.IsClaimable) {
var result = this.Claim(agentUpdate.Node);
_deck.Trace(result.Message, TraceType.Information);
} else {
var result = this.Move(agentUpdate.Node.Exits.First().Value);
_deck.Trace(result.Message, TraceType.Information);
}
}
private IAgentInfo GetTarget(IAgentUpdateInfo agentUpdate)
{
string nodeEnemiesInfo = agentUpdate.Node.Exits.Values.Aggregate(string.Empty, (current, node) => GetNodeEnemiesInfo(node, current));
Deck.Trace(string.Format("Alies: {0} Enemies: {1} Nodes:{2}",
agentUpdate.Node.MyAgents.Count() - 1,
agentUpdate.Node.OpposingAgents.Count(),
nodeEnemiesInfo), TraceType.Information);
IEnumerable<IAgentInfo> list = agentUpdate.Node.OpposingAgents.Where(x => x.Stack > 0);
return list.Any() ? list.OrderBy(x => x.Stack).First() : null;
}
protected void RookAttack(IAgentUpdateInfo agentUpdate)
{
Target = GetTarget(agentUpdate);
if (Target != null)
{
OnAgent.AttackAndTrySkills(Target, this, Deck, agentUpdate);
}
else
{
AgentMove(agentUpdate);
}
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
if (Agent != null && Agent.Node == agentUpdate.Node)
{
AttackAndTryPin();
}
else
{
Engineer.UnitTest(agentUpdate, this);
TryClaimAndMove(agentUpdate);
}
}
public override void OnTick(IAgentUpdateInfo agentUpdate)
{
// We don't want to fill the arena with Struts, we want to be fully offensive in there.
if (!Node.IsInArena(agentUpdate))
{
INodeInformation nodeWithEnemies = Node.AnyWithEnemies(agentUpdate);
if (null != nodeWithEnemies)
this.Struts(nodeWithEnemies);
}
base.OnTick(agentUpdate);
}
public void OnAttacked(IAgentInfo attacker, IAgentUpdateInfo agentUpdate)
{
Deck.Trace(":: OnAttacked", TraceType.Verbose);
Deck.Trace(String.Format("Owner:{0} Level:{1}", attacker.Owner, attacker.Level), TraceType.Warning);
try
{
OnAttackedActions(attacker, agentUpdate);
}
catch (Exception e)
{
Deck.Trace(string.Format("Exception in OnAttacked: {0}", e.Message), TraceType.Error);
}
}
public static void AttackAndTrySkills(IAgentInfo target, IAgent engineer, IDeck deck, IAgentUpdateInfo update)
{
if (target == null)
{
deck.Trace("Target is null",TraceType.Information);
return;
}
deck.Trace(string.Format("Attack: Owner {0} Level {1} Stack {2} at {3}:{4}:{5}", target.Owner, target.Level, target.Stack,
update.Node.Row, update.Node.Column, update.Node.Layer), TraceType.Information);
engineer.Attack(target);
Skills(target, update, engineer);
}
private static void LogExits(IAgentUpdateInfo agentUpdate, IDeck deck)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Connected Nodes: ");
foreach (INodeInformation node in agentUpdate.Node.Exits.Values)
{
sb.AppendLine(string.Format("Location: {0} (Distance: {4}), Number of Agents: {1} (of which {2} are Opposing), Effects: {3}"
, node.Sector.Name + ", " + node.Layer + "," + node.Row + "," + node.Column
, node.AllAgents.Count()
, node.OpposingAgents.Count()
, String.Join(", ",node.Effects.Select<NodeEffect, string>(e => e.ToString()).ToArray())
, agentUpdate.Node.Distance(node)));
}
deck.Trace(sb.ToString(), TraceType.Information);
}
public override void OnArrivedActions(IAgentInfo arriver, IAgentUpdateInfo agentUpdate)
{
if (arriver.Owner != agentUpdate.Owner)
base.OnArrivedActions(arriver, agentUpdate);
else
{
try
{
Engineer.Mentor(agentUpdate.Node.MyAgents, this);
}
catch (Exception ex)
{
Deck.Trace(string.Format("Exception in {0}. Message: {1}. StackTrace {2})", this.ToString(), ex.Message, ex.StackTrace), TraceType.Error);
}
}
}
public void OnArrived(IAgentInfo arriver, IAgentUpdateInfo agentUpdate)
{
if (arriver.Clan != agentUpdate.Clan)
{
if (arriver.Level >= agentUpdate.Level + 1)
{
this.Attack(arriver);
}
else
{
deck.Trace("Agent met by another agent with too high level! Will not attack.", TraceType.Verbose);
}
}
else
{
deck.Trace("Agent met by another agent from the same clan! Will not attack.", TraceType.Verbose);
}
}
public static void GreedyMoveToFirstAgent(IAgentUpdateInfo agentUpdate, IAgent agent, IAgentInfo agentBeingAttacked)
{
IEnumerable<INodeInformation> agentBeingAttackedMoved =
agentUpdate.Node.Exits.Values.Where(x => x.OpposingAgents.Contains(agentBeingAttacked));
if (agentBeingAttackedMoved.Count() > 0)
{
PickMove(agentUpdate, agentBeingAttackedMoved,agent);
}
else
{
IEnumerable<INodeInformation> possibleNodes =
agentUpdate.Node.Exits.Values.Where(x => x.OpposingAgents.Count() > 0).OrderBy(
x => x.OpposingAgents.Count());
PickMove(agentUpdate, possibleNodes, agent);
}
}
public void OnArrived(IAgentInfo arriver, IAgentUpdateInfo agentUpdate)
{
if (arriver.Clan != agentUpdate.Clan)
{
if (arriver.Level >= agentUpdate.Level + 1)
{
this.Attack(arriver);
}
else
{
deck.Trace("Agent met by another agent with too high level! Will not attack.", TraceType.Verbose);
}
}
else
{
deck.Trace("Agent met by another agent from the same clan! Will not attack.", TraceType.Verbose);
}
}
protected override void AgentMove(IAgentUpdateInfo agentUpdate)
{
if (agentUpdate.Node.Column == 0
&& agentUpdate.Node.Row == 0
&& agentUpdate.Node.Layer == 0)
{
if (agentUpdate.Node.AlliedAgents.Count() > 0)
{
if (this is IEngineer3 || this is IEngineer4 || this is IEngineer5)
{
EngineerSkills.Struts(agentUpdate.Node, (IEngineer3) this);
}
}
}
else
{
Move(agentUpdate.Node.Exits[ agentUpdate.Node.RouteTo(agentUpdate.Node, 0, 0, 0)]);
}
if (agentUpdate.Node.Sector.Id == ArenaId)
{
MoveSkills.GreedyMoveToFirstAgent(agentUpdate, this, Deck);
}
switch (agentUpdate.Action)
{
case AgentAction.Raiding:
ClaimSkills.TryClaim(agentUpdate.Node, this);
MoveSkills.GreedyMoveToFirstAgent(agentUpdate, this, Deck);
break;
case AgentAction.Defending:
MoveSkills.GreedyMoveToFirstAgent(agentUpdate, this, Deck);
break;
default:
break;
}
}
public virtual void OnTick(IAgentUpdateInfo agentUpdate)
{
Engineer.UnitTest(agentUpdate, this);
Deck.Trace(string.Format("Number of Opposing Agents on current Node: {0}", agentUpdate.Node.OpposingAgents.Count()), TraceType.Verbose);
IAgentInfo attacker = GetWeakestEnemy(agentUpdate);
if (null != attacker)
{
Deck.Trace(string.Format("Attacker Owner: {0}, Level: {1}, Stack: {2}", attacker.Owner, attacker.Level, attacker.Stack), TraceType.Verbose);
OnAttackedActions(attacker, agentUpdate);
}
if (agentUpdate.Node.IsClaimable && this.Claim(agentUpdate.Node).Result == NodeResultType.Success)
return;
var nextNode = Node.GetNextNode(agentUpdate, Deck);
if (null != nextNode)
this.Move(nextNode);
}
private static void Skills(IAgentInfo target, IAgentUpdateInfo update, IAgent engineer)
{
if (!(engineer is Bishop)
// && HaveAtLeastTwoMoreAgentsThanEnemiesInSameNode(update)
)
{
if (engineer is IEngineer6)
{
EngineerSkills.Scaffold(target.Node, (IEngineer6)engineer);
return;
}
if (engineer is IEngineer5)
{
EngineerSkills.Decompile(target, (IEngineer5)engineer);
return;
}
if (engineer is IEngineer4)
{
EngineerSkills.Mentor(update, (IEngineer4)engineer);
return;
}
if (engineer is IEngineer3)
{
EngineerSkills.Struts(target.Node, (IEngineer3)engineer);
return;
}
if (engineer is IEngineer2)
{
EngineerSkills.Pin(target, (IEngineer2)engineer);
return;
}
}
}
protected override void AgentMove(IAgentUpdateInfo agentUpdate)
{
if (agentUpdate.Node.Sector.Id == ArenaId)
{
MoveSkills.GreedyMoveToFirstAgent(agentUpdate, this, Deck);
}
switch(agentUpdate.Action)
{
case AgentAction.Raiding:
ClaimSkills.TryClaim(agentUpdate.Node, this);
MoveSkills.GreedyMoveToFirstAgent(agentUpdate, this,Deck);
break;
case AgentAction.Defending:
MoveSkills.GreedyMoveToFirstAgent(agentUpdate, this,Deck);
break;
default:
GreedyClaim(agentUpdate, this);
break;
}
}
public static INodeInformation GetNextNode(IAgentUpdateInfo agentUpdate, IDeck deck)
{
INodeInformation targetNode;
// If we are in the Arena look for enemies
if (IsInArena(agentUpdate) || agentUpdate.Action == AgentAction.Raiding)
{
LogExits(agentUpdate, deck);
targetNode = Node.AnyWithEnemies(agentUpdate);
}
else // Look for nodes that can be claimed
targetNode = Node.AnyClaimable(agentUpdate);
// else look for an unoccupied Node
if (null == targetNode)
targetNode = Node.AnyUnoccupied(agentUpdate);
// If all else fails, just Move to the closest Node!
if (null == targetNode)
targetNode = Node.ClosestNode(agentUpdate);
return targetNode;
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
bool unitTestApplied = false;
if (agentUpdate.Effects != null)
{
foreach (AgentEffect effect in agentUpdate.Effects)
{
if (effect.Equals(AgentEffect.UnitTest))
{
unitTestApplied = true;
}
}
}
if (!unitTestApplied)
{
this.UnitTest();
}
else
{
deck.Trace("UnitTest effect already applied. Will not extend ...", TraceType.Verbose);
}
if (currentNode == null)
{
deck.Trace("Current node was initialised for this agent!", TraceType.Verbose);
currentNode = agentUpdate.Node;
visited.Add(currentNode);
}
if (currentNode != null)
{
foreach (IAgentInfo agent in currentNode.OtherAgents)
{
this.Attack(agent);
}
}
if (currentNode != null && !currentNode.Owner.Equals(agentUpdate.Owner))
{
if (currentNode.IsClaimable)
{
this.Claim(currentNode);
}
else
{
deck.Trace("Agent met unclaimable node!", TraceType.Verbose);
}
}
else
{
deck.Trace("No current node or already owned by this agent!", TraceType.Warning);
}
if (walker == null)
{
if (currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Walker not initialised! Current node was not set.", TraceType.Critical);
}
}
else
{
if (!walker.MoveNext() && currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Agent is probably stuck on a single node!", TraceType.Critical);
}
}
if (walker != null)
{
INodeInformation nextNode = walker.Current;
while (nextNode == null)
{
if (!walker.MoveNext() && currentNode != null)
{
walker = currentNode.Exits.Values.GetEnumerator();
}
else
{
deck.Trace("Agent is probably stuck on a single node!", TraceType.Critical);
break;
}
}
if (nextNode != null)
{
this.Move(nextNode);
currentNode = nextNode;
}
else
{
deck.Trace("Next node is null - will not move anywher!", TraceType.Error);
}
}
}
public void OnAttacked(IAgentInfo attacker, IAgentUpdateInfo agentUpdate)
{
this.Attack(attacker); // just fight back - don't know what else to do, now
}
public void OnArrived(IAgentInfo arriver, IAgentUpdateInfo agentUpdate)
{
throw new NotImplementedException();
}
public void OnAttacked(IAgentInfo attacker, IAgentUpdateInfo agentUpdate)
{
throw new NotImplementedException();
}
public void Tick(IAgentUpdateInfo agentUpdate)
{
throw new NotImplementedException();
}
