public void TestFindTwoTurnCompultionWinForTile2()
{
//setup the initial condition
var player1 = "Player 1";
var player2 = "Player 2";
var game = new GameCore(player1, player2);
var board = game.Board;
//
//
//
// . . x x . . .
//////////////////
board[2][0].OwningPlayer = player1;
board[3][0].OwningPlayer = player1;
List <Tile> compulsionWin = AIHelper.FindTwoTurnCompulsionWin(game, player1);
Assert.AreEqual(2, compulsionWin.Count);
Assert.AreEqual(board[1][0], compulsionWin[0]);
Assert.AreEqual(board[4][0], compulsionWin[1]);
}
} // Update
public void ScanForTarget(GameTime gameTime)
{
NextDefendScan -= (float)gameTime.ElapsedGameTime.TotalMilliseconds;
if (NextDefendScan <= 0)
{
NextDefendScan = 0;
var newTarget = AIHelper.FindClosestDamagedFriend(this);
if (newTarget != null)
{
var repair = StateMachine.GetState <RepairShipRepairState>();
repair.Target = newTarget;
repair.RepairRate = RepairRate;
StateMachine.SetState(repair);
}
else
{
NextDefendScan = DefendScanFrequency;
}
}
} // ScanForTarget
/// <summary>
/// 找最近的可以寻路的触发器
/// </summary>
/// <param name="runningProperty"></param>
/// <returns></returns>
public static Vector3 GetNearestNeedNavigateColliderPosition(AIRunningProperty runningProperty)
{
if (runningProperty == null)
{
return(Vector3.zero);
}
float shortest = float.MaxValue;
Vector3 selfActorPos = runningProperty.SelfActorPos;
Vector3 targetPos = Vector3.zero;
List <xc.Dungeon.ColliderObject> colliderObjects = xc.Dungeon.ColliderObjectManager.Instance.GetNeedNavigateColliderObjects();
foreach (xc.Dungeon.ColliderObject colliderObject in colliderObjects)
{
if (colliderObject == null || colliderObject.BindGameObject == null || colliderObject.BindGameObject.transform == null)
{
continue;
}
Vector3 pos = colliderObject.BindGameObject.transform.position;
if (!TargetPositionHeightIsAbnormal(pos))
{
continue;
}
float distanceSquare = AIHelper.DistanceSquare(selfActorPos, pos);
if (distanceSquare < shortest)
{
shortest = distanceSquare;
targetPos = pos;
}
}
return(targetPos);
}
public void TestFindTwoTurnCompultionWinForTile1()
{
//setup the initial condition
var player1 = "Player 1";
var player2 = "Player 2";
var game = new GameCore(player1, player2);
var board = game.Board;
// . . . . . x
// . . . . . t
// . . x x . x
// . . x t . t .
////////////////////
board[2][0].OwningPlayer = player1;
board[2][1].OwningPlayer = player1;
board[3][0].OwningPlayer = player2;
board[3][1].OwningPlayer = player1;
//column 4 is empty, with which we can create a compulsion.
//If player one places a tile in column four, it will cause a potential
//win if they place another one (4 horizontally) so player 2 will have to
//block it. But that will let player 1 place a tile there to win
//via a diagonal.
board[5][0].OwningPlayer = player2;
board[5][1].OwningPlayer = player1;
board[5][2].OwningPlayer = player2;
board[5][3].OwningPlayer = player1;
List <Tile> compulsionWin = AIHelper.FindTwoTurnCompulsionWin(game, player1);
Assert.AreEqual(1, compulsionWin.Count);
Assert.AreEqual(board[4][0], compulsionWin[0]);
}
internal string getType(int u)
{
if (u == 0)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity));
}
if (u == 1)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CollectingSpeed));
}
if (u == 2)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.Defence));
}
if (u == 3)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
if (u == 4)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.MaximumHealth));
}
return("");
}
void Update()
{
if (currentCooldown >= 0)
{
currentCooldown -= Time.deltaTime;
}
//Dead
if (hc.isDead)
{
if (this.gameObject.name.Contains("Big Fish Enemy"))
{
SFXHelper.PlayEffect(SFXs.BigFishDeath);
}
if (this.gameObject.name.Contains("Jelly Fish Enemy"))
{
SFXHelper.PlayEffect(SFXs.JellyFishDeath);
}
Destroy(this.gameObject);
}
/* BEHAVIOUR ACTIONS */
timeSinceLastAction += Time.deltaTime;
if (timeSinceLastAction > TimeBetweenActions)
{
timeSinceLastAction = 0;
currentBehaviour.BehaviorAction(this);
//Flock adjustments
CurrentDirection += AIHelper.FlockMainBehaviour(this).normalized;
}
UpdateVelocity();
UpdateSpriteDirection();
enemyBrain.CheckConditionsForNewBehaviours(this);
}
public override string Execute()
{
return(AIHelper.CreateUpgradeAction(_upgradeList.Pop()));
}
/// <summary>
/// 设置最近的目标
/// </summary>
/// <returns></returns>
public BehaviourReturnCode ActionSetPlayerOrMonsterToTarget()
{
if (RunningProperty.TargetActor != null)
{
if (HookSettingManager.Instance.RangeType == EHookRangeType.FixedPos && RunningProperty.GetToTargetDistanceSquare() > (MaxAttackDistance * MaxAttackDistance))
{
RunningProperty.TargetActor = null;
}
else if (RunningProperty.TargetActor.IsDead() == false)
{
return(BehaviourReturnCode.Success);
}
}
var player = AIHelper.GetNearestActor(RunningProperty, ActorManager.Instance.PlayerSet);
if (SceneHelp.Instance.PrecedentPlayer)// 优先选择玩家
{
if (player != null)
{
RunningProperty.TargetActor = player;
RunningProperty.TargetActorIsCounterattack = false;
return(BehaviourReturnCode.Success);
}
}
float motionRadius = RunningProperty.MotionRadius;
// 定点挂机
if (RunningProperty.SelfActor is LocalPlayer && HookSettingManager.Instance.RangeType == EHookRangeType.FixedPos)
{
motionRadius = 1f;
}
Dictionary <UnitID, Actor> monsters = null;
if (RunningProperty.TargetMonsterId == 0)
{
monsters = AIHelper.GetMonsterListByRange(RunningProperty.OriginalSelfActorPos, motionRadius + MaxAttackDistance);
}
else
{
monsters = AIHelper.GetMonsterListByActorIdAndRange(RunningProperty.TargetMonsterId, RunningProperty.OriginalSelfActorPos, motionRadius + MaxAttackDistance);
}
Actor monster = null;
// 先看看怪物列表里面是否有boss，有的话只在boss里面选
Actor boss = AIHelper.GetBossActor(monsters);
if (boss != null)
{
monster = boss;
}
else
{
monster = AIHelper.GetNearestActor(RunningProperty, monsters);
}
if (player == null)
{
RunningProperty.TargetActor = monster;
}
else if (monster == null)
{
RunningProperty.TargetActor = player;
}
else
{
if (Vector3.Distance(RunningProperty.SelfActorPos, player.transform.position) <= Vector3.Distance(RunningProperty.SelfActorPos, monster.transform.position))
{
RunningProperty.TargetActor = player;
}
else
{
RunningProperty.TargetActor = monster;
}
}
if (RunningProperty.TargetActor != null && Vector3.Distance(RunningProperty.SelfActorPos, RunningProperty.TargetActor.transform.position) <= AttackCtrl.MaxTargetRange)
{
RunningProperty.SelfActor.AttackCtrl.CurSelectActor = RunningProperty.TargetActor.GetActorMono();
}
RunningProperty.RefreshState();
if (RunningProperty.TargetActor == null)
{
return(BehaviourReturnCode.Success);
}
if (RunningProperty.GetToTargetDistanceSquare() > ((motionRadius + MaxAttackDistance) * (motionRadius + MaxAttackDistance)))
{
RunningProperty.TargetActor = null;
return(BehaviourReturnCode.Success);
}
if (HookSettingManager.Instance.RangeType == EHookRangeType.FixedPos && RunningProperty.GetToTargetDistanceSquare() > (MaxAttackDistance * MaxAttackDistance))
{
RunningProperty.TargetActor = null;
return(BehaviourReturnCode.Success);
}
if (RunningProperty.TargetActor.IsDead() == true)
{
RunningProperty.TargetActor = null;
return(BehaviourReturnCode.Success);
}
RunningProperty.TargetActorIsCounterattack = false;
return(BehaviourReturnCode.Success);
}
protected virtual bool RunConditionImplement(string condition, object[] parameters)
{
if (condition == "ConditionTargetIsInAttackRange")
{
return(mFunction.ConditionTargetIsInAttackRange());
}
else if (condition == "ConditionIsSeeTarget")
{
return(mFunction.ConditionIsSeeTarget());
}
else if (condition == "ConditionIsInMotionRange")
{
return(mFunction.ConditionIsInMotionRange());
}
else if (condition == "ConditionIsNeedPatrol")
{
return(mFunction.ConditionIsNeedPatrol());
}
else if (condition == "ConditionIsNeedFollowPlayer")
{
return(mFunction.ConditionIsNeedFollowPlayer());
}
else if (condition == "ConditionHaveTargetDrop")
{
return(mFunction.ConditionHaveTargetDrop());
}
else if (condition == "ConditionHaveTargetCollection")
{
return(mFunction.ConditionHaveTargetCollection());
}
else if (condition == "ConditionSelfActorIsInteraction")
{
return(mFunction.ConditionSelfActorIsInteraction());
}
else if (condition == "ConditionIsChasingOverrideTime")
{
float time = (float)parameters[0];
return(mFunction.ConditionIsChasingOverrideTime(time));
}
else if (condition == "ConditionIsStandingOverrideTime")
{
float time = (float)parameters[0];
return(mFunction.ConditionIsStandingOverrideTime(time));
}
else if (condition == "ConditionIsInSafaArea")
{
return(mFunction.ConditionIsInSafaArea());
}
else if (condition == "ConditionIsInWildScene")
{
return(mFunction.ConditionIsInWildScene());
}
else if (condition == "ConditionPlayerIsControlling")
{
return(mFunction.ConditionPlayerIsControlling());
}
else if (condition == "ConditionIsHaveFollowInfo")
{
return(mFunction.ConditionIsHaveFollowInfo());
}
else if (condition == "ConditionIsFarAwayFollowActor")
{
return(mFunction.ConditionIsFarAwayFollowActor());
}
else if (condition == "ConditionIsInChaosState")
{
return(mFunction.ConditionIsInChaosState());
}
else if (condition == "ConditionFollowActorIsAttacked")
{
return(mFunction.ConditionFollowActorIsAttacked());
}
else if (condition == "ConditionIsIdle")
{
return(mFunction.ConditionIsIdle());
}
else if (condition == "ConditionSelectSkillInCanFire")
{
return(mFunction.ConditionSelectSkillInCanFire());
}
else if (condition == "ConditionIsWalking")
{
return(mFunction.ConditionIsWalking());
}
else if (condition == "ConditionIsAttacking")
{
return(mFunction.ConditionIsAttacking());
}
else if (condition == "ConditionIsAttackingOrBeAttacking")
{
return(mFunction.ConditionIsAttackingOrBeAttacking());
}
else if (condition == "ConditionTargetSkillIsInBeforeSkillActionEndingStage")
{
return(mFunction.ConditionTargetSkillIsInBeforeSkillActionEndingStage());
}
else if (condition == "ConditionIsWalkingToOriginalPos")
{
return(mFunction.ConditionIsWalkingToOriginalPos());
}
else if (condition == "ConditionIsWalkingToDropPos")
{
return(mFunction.ConditionIsWalkingToDropPos());
}
else if (condition == "ConditionIsWalkingToCollectionPos")
{
return(mFunction.ConditionIsWalkingToCollectionPos());
}
else if (condition == "ConditionIsFarAwayParentActor")
{
float distanceSquare = 0f;
if (parameters.Length >= 1)
{
distanceSquare = (float)parameters[0];
}
return(mFunction.ConditionIsFarAwayParentActor(distanceSquare));
}
else if (condition == "ConditionIsNearParentActor")
{
float distanceSquare = 0f;
if (parameters.Length >= 1)
{
distanceSquare = (float)parameters[0];
}
return(mFunction.ConditionIsNearParentActor(distanceSquare));
}
else
{
AIHelper.WriteErrorLog("BehaviourAI.RunConditionImplement can not find condition:" + condition, this);
}
return(true);
}
public override string GetNextMove(IPlayer player, IEnumerable <IPlayer> visiblePlayers, LegacyMap map)
{
// Dropper nos ressoruces si on est colles a la maison
if (Point.DistanceManhatan(player.HouseLocation, player.Position) == 0 && player.CarriedResources > 0)
{
return(AIHelper.CreateEmptyAction());
}
// Verifier si on doit rentrer pour drop nos ressources
if (player.CarryingCapacity - player.CarriedResources < 100)
{
Move moveTowardsHome = new Move(player, map, player.HouseLocation);
return(moveTowardsHome.NextAction(map, player));
}
// Trouver le filon le plus proche
Point closestMineralPosition = GetClosestMineralPosition(player, map);
// Si le filon le plus proche renvoit la maison, ca veut dire quon ne truove rien proche de nous. Nous allons donc aller explorer.
//if (closestMineralPosition.X == player.HouseLocation.X && closestMineralPosition.Y == player.HouseLocation.Y)
//{
// Random random = new Random();
// int randomlyGeneratedNumber = random.Next(1, 3);
// if (randomlyGeneratedNumber == 1)
// {
// Move moveTowardsHome = new Move(player, map, new Point(player.Position.X + 1, player.Position.Y));
// return moveTowardsHome.NextAction(map, player);
// }
// else
// {
// Move moveTowardsHome = new Move(player, map, new Point(player.Position.X, player.Position.Y -1));
// return moveTowardsHome.NextAction(map, player);
// }
//}
Console.WriteLine("");
// Sinon, good, on a qqch a miner. On trouve la case a partir de laquelle on va miner
Point closestMineralAdjacentPosition = GetClosestFreeAdjacentPosition(player, closestMineralPosition, map);
// Si on est colles au filon, le miner
if (Point.DistanceManhatan(closestMineralPosition, player.Position) <= 1)
{
return(AIHelper.CreateCollectAction(new Point(closestMineralPosition.X - player.Position.X,
closestMineralPosition.Y - player.Position.Y)));
}
// Si aller passer par la maison avant daller au filon ne nous ralenti pas, on va aller a la maison tds
// Verifier si on doit rentrer pour drop nos ressources
if ((player.CarriedResources >= 500) &&
((player.Position.X <= player.HouseLocation.X && closestMineralAdjacentPosition.X >= player.HouseLocation.X &&
player.Position.Y <= player.HouseLocation.Y && closestMineralAdjacentPosition.Y >= player.HouseLocation.Y)
|| (player.Position.X <= player.HouseLocation.X && closestMineralAdjacentPosition.X >= player.HouseLocation.X &&
player.Position.Y >= player.HouseLocation.Y && closestMineralAdjacentPosition.Y <= player.HouseLocation.Y)
|| (player.Position.X >= player.HouseLocation.X && closestMineralAdjacentPosition.X <= player.HouseLocation.X &&
player.Position.Y >= player.HouseLocation.Y && closestMineralAdjacentPosition.Y <= player.HouseLocation.Y)
|| (player.Position.X >= player.HouseLocation.X && closestMineralAdjacentPosition.X <= player.HouseLocation.X &&
player.Position.Y <= player.HouseLocation.Y && closestMineralAdjacentPosition.Y >= player.HouseLocation.Y)))
{
Move moveTowardsHome = new Move(player, map, player.HouseLocation);
return(moveTowardsHome.NextAction(map, player));
}
// Si on est pas colles, quon rentre pas, aller vers le filon
Move moveTowardsMineral = new Move(player, map, closestMineralAdjacentPosition);
return(moveTowardsMineral.NextAction(map, player));
}
/// <summary>
/// Implement your bot here.
/// </summary>
/// <param name="map">The gamemap.</param>
/// <param name="visiblePlayers">Players that are visible to your bot.</param>
/// <returns>The action you wish to execute.</returns>
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
Console.WriteLine("My pos = " + PlayerInfo.Position.ToString());
Console.WriteLine("House = " + PlayerInfo.HouseLocation.ToString());
Console.WriteLine("Total = " + PlayerInfo.TotalResources.ToString());
Console.WriteLine("Collect= " + PlayerInfo.CollectingSpeed.ToString());
Console.WriteLine("Carryin= " + PlayerInfo.CarryingCapacity.ToString());
Console.WriteLine("Atk = " + PlayerInfo.AttackPower.ToString());
Console.WriteLine("Def = " + PlayerInfo.Defence.ToString());
Console.WriteLine("Health = " + PlayerInfo.Health.ToString());
Console.WriteLine("Max Hea= " + PlayerInfo.MaxHealth.ToString());
Console.WriteLine("C1 = " + (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 10000 &&
PlayerInfo.CollectingSpeed == 1).ToString());
Console.WriteLine("C2 = " + (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 10000 &&
PlayerInfo.CarryingCapacity == 1000).ToString());
//Bypass upgrade
if (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 10000 &&
PlayerInfo.CarryingCapacity == 1000)
{
Console.WriteLine("Buying a Carrying Capacity");
return(AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity));
}
if (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 10000 &&
PlayerInfo.CarryingCapacity == 1250)
{
Console.WriteLine("Buying a Carrying Capacity");
return(AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity));
}
if (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 10000 &&
PlayerInfo.AttackPower == 1)
{
Console.WriteLine("Buying a Attack");
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
if (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 10000 &&
PlayerInfo.Defence == 1)
{
Console.WriteLine("Buying a Defence");
return(AIHelper.CreateUpgradeAction(UpgradeType.Defence));
}
if (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 15000 &&
PlayerInfo.AttackPower == 2)
{
Console.WriteLine("Buying a Attack");
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
if (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 15000 &&
PlayerInfo.Defence == 2)
{
Console.WriteLine("Buying a Defence");
return(AIHelper.CreateUpgradeAction(UpgradeType.Defence));
}
if (PlayerInfo.Position == PlayerInfo.HouseLocation &&
PlayerInfo.TotalResources >= 25000 &&
PlayerInfo.AttackPower == 4)
{
Console.WriteLine("Buying a Attack");
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
//fin des upgrades
//update map of the world
worldMap.UpdateMap(map.GetVisibleTiles());
//worldMap.UpdateOtherPLayerMap(gameInfo.OtherPlayers);
StrategyManager.PickStrategy(PlayerInfo, visiblePlayers, worldMap);
return(StrategyManager.currentStrategy.GetNextMove(PlayerInfo, visiblePlayers, worldMap));
/*string action = null;
*
* Console.WriteLine("Collect= " + PlayerInfo.CollectingSpeed.ToString());
* Console.WriteLine("Carryin= " + PlayerInfo.CarryingCapacity.ToString());
* =======
*
*
* //Bypass upgrade
* if (PlayerInfo.Position == PlayerInfo.HouseLocation && !alreadyTriedToBuy)
* {
* Console.WriteLine("Buying a Carrying Capacity");
* alreadyTriedToBuy = true;
* return AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity);
* }
* if (PlayerInfo.Position != PlayerInfo.HouseLocation)
* {
* alreadyTriedToBuy = false;
* }
*
*
*
* //update map of the world
* worldMap.UpdateMap(map.GetVisibleTiles());
* //worldMap.UpdateOtherPLayerMap(gameInfo.OtherPlayers);
* StrategyManager.PickStrategy();
* return StrategyManager.currentStrategy.GetNextMove(PlayerInfo, visiblePlayers, worldMap);
*
* /*string action = null;
*
* string action = null;
* while (action == null)
* {
* if (currentAction == null)
* {
* currentAction = strategy.NextAction(worldMap, PlayerInfo);
* if (currentAction == null)
* {
* break;
* }
* //log(currentAction.ToString());
* }
* action = currentAction.NextAction(worldMap, PlayerInfo);
* if (action == null)
* {
* currentAction = null;
* }
* }
*
* return action;*/
}
public override void Update(GameTime gameTime)
{
AIHelper.SmallAttackingShipAI(this, gameTime);
base.Update(gameTime);
}
private void chooseStrategyRandomly()
{
currentStrategy = AIHelper.getRandomAIStrategyType();
currentRandomDelay = Random.Range(0, gameConfig.shootMaximumDelay);
isCompletingStrategy = false;
}
// Iterate the ammoModePairs on the weapon to find the highest direct damage, heat damage, and stab damage
private static (WeaponAttackEval damage, WeaponAttackEval heat, WeaponAttackEval stab) OptimizeAmmoPairForAttack(Weapon weapon, AttackDetails details)
{
WeaponAttackEval damage = new WeaponAttackEval()
{
Weapon = weapon
};
WeaponAttackEval heat = new WeaponAttackEval()
{
Weapon = weapon
};
WeaponAttackEval stab = new WeaponAttackEval()
{
Weapon = weapon
};
BehaviorTree bTree = details.Attacker.BehaviorTree;
try
{
float attackTypeWeight = AIHelper.GetCachedBehaviorVariableValue(bTree, BehaviorVariableName.Float_ShootingDamageMultiplier).FloatVal;;
// Damage prediction assumes an attack quality of Solid. It doesn't apply targetMultis either
Dictionary <AmmoModePair, WeaponFirePredictedEffect> damagePredictions = CleverGirlHelper.gatherDamagePrediction(weapon, details.AttackPosition, details.Target);
foreach (KeyValuePair <AmmoModePair, WeaponFirePredictedEffect> kvp in damagePredictions)
{
AmmoModePair ammoModePair = kvp.Key;
WeaponFirePredictedEffect weaponFirePredictedEffect = kvp.Value;
Mod.Log.Debug?.Write($" - Evaluating ammoId: {ammoModePair.ammoId} with modeId: {ammoModePair.modeId}");
WeaponAttackEval wae = new WeaponAttackEval()
{
Weapon = weapon, AmmoMode = ammoModePair
};
foreach (DamagePredictionRecord dpr in weaponFirePredictedEffect.predictDamage)
{
Hostility targetHostility = SharedState.Combat.HostilityMatrix.GetHostility(details.Attacker.team, dpr.Target.team);
if (targetHostility == Hostility.FRIENDLY)
{
// Friendly and self damage weights directly into a self damage, and doesn't contribute to any attacks
float damageMulti;
if (details.Attacker.GUID == dpr.Target.GUID)
{
damageMulti = Mod.Config.Weights.DamageMultis.Self;
}
else
{
damageMulti = Mod.Config.Weights.DamageMultis.Friendly;
}
wae.EVFriendlyDmg += dpr.ToHit * dpr.Normal * damageMulti;
wae.EVFriendlyDmg += dpr.ToHit * dpr.AP * damageMulti;
wae.EVFriendlyDmg += dpr.ToHit * dpr.Heat * damageMulti;
wae.EVFriendlyDmg += dpr.ToHit * dpr.Instability * damageMulti;
}
else if (targetHostility == Hostility.NEUTRAL)
{
// Neutrals are weighted lower, to emphasize attacking enemies more directly
wae.EVDirectDmg += dpr.ToHit * dpr.Normal * Mod.Config.Weights.DamageMultis.Neutral;
wae.EVStructDam += dpr.ToHit * dpr.AP * Mod.Config.Weights.DamageMultis.Neutral;
wae.EVHeat += dpr.ToHit * dpr.Heat * Mod.Config.Weights.DamageMultis.Neutral;
wae.EVStab += dpr.ToHit * dpr.Instability * Mod.Config.Weights.DamageMultis.Neutral;
}
else
{
wae.EVDirectDmg += dpr.ToHit * dpr.Normal;
wae.EVStructDam += dpr.ToHit * dpr.AP;
wae.EVHeat += dpr.ToHit * dpr.Heat;
wae.EVStab += dpr.ToHit * dpr.Instability;
}
if (!dpr.isAoE && dpr.ToHit > wae.ToHit)
{
wae.ToHit = dpr.ToHit;
}
}
if ((wae.EVDirectDmg + wae.EVStructDam) >= (damage.EVDirectDmg + damage.EVStructDam))
{
damage = wae;
}
if (wae.EVHeat >= heat.EVHeat)
{
heat = wae;
}
if (wae.EVStructDam >= stab.EVStructDam)
{
stab = wae;
}
}
}
catch (Exception e)
{
Mod.Log.Error?.Write(e, "Failed to calculate weapon damageEV!");
}
return(damage, heat, stab);
}
/// <summary>
/// Implement your bot here.
/// </summary>
/// <param name="map">The gamemap.</param>
/// <param name="visiblePlayers">Players that are visible to your bot.</param>
/// <returns>The action you wish to execute.</returns>
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
getInterestingObjects(map, PlayerInfo.Position);
objects.Sort((x, y) => x.priority.CompareTo(y.priority));
Point nextMove;
if (PlayerInfo.Position == PlayerInfo.HouseLocation)
{
nextMove = new Point();
if (PlayerInfo.GetUpgradeLevel(UpgradeType.Defence) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.Defence));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.CarryingCapacity) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.AttackPower) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.CarryingCapacity) == 1 && PlayerInfo.TotalResources >= upgrades[1])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CarryingCapacity));
}
if (PlayerInfo.GetUpgradeLevel(UpgradeType.CollectingSpeed) == 0 && PlayerInfo.TotalResources >= upgrades[0])
{
return(AIHelper.CreateUpgradeAction(UpgradeType.CollectingSpeed));
}
}
if (PlayerInfo.TotalResources >= 30000 && !PlayerInfo.CarriedItems.Contains(PurchasableItem.Backpack))
{
Point shopLocation = map.GetVisibleTiles().FirstOrDefault(x => x.TileType == TileContent.Shop)?.Position;
if (shopLocation == null)
{
TileContent tileToTheLeft = map.GetTileAt(PlayerInfo.Position.X - 1, PlayerInfo.Position.Y);
nextMove = tileToTheLeft != TileContent.Resource && tileToTheLeft != TileContent.Lava ? new Point(-1, 0) : new Point(0, 1);
}
else
{
nextMove = new PathFinder(map, PlayerInfo.Position, shopLocation).FindNextMove();
}
if (Point.DistanceSquared(PlayerInfo.Position, shopLocation) == 1)
{
return(AIHelper.CreatePurchaseAction(PurchasableItem.Backpack));
}
}
else if (PlayerInfo.CarriedResources == PlayerInfo.CarryingCapacity || objects.Count == 0)
{
nextMove = new PathFinder(map, PlayerInfo.Position, PlayerInfo.HouseLocation).FindNextMove();
}
else
{
nextMove = new PathFinder(map, PlayerInfo.Position, objects[0].position).FindNextMove();
}
Point shouldIStayOrShouldIGoNow = PlayerInfo.Position + nextMove;
TileContent content = map.GetTileAt(shouldIStayOrShouldIGoNow.X, shouldIStayOrShouldIGoNow.Y);
switch (content)
{
case TileContent.Empty:
case TileContent.House:
return(AIHelper.CreateMoveAction(nextMove));
case TileContent.Resource:
return(AIHelper.CreateCollectAction(nextMove));
case TileContent.Wall:
return(AIHelper.CreateMeleeAttackAction(nextMove));
case TileContent.Player:
return(AIHelper.CreateMeleeAttackAction(nextMove));
default:
return(AIHelper.CreateEmptyAction());
}
}
private void EnemyMove()
{
//Todo: анимацию для хода противника
AIHelper.MakeMove(enemyInfo);
}
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
// TODO: Implement your AI here.
string instruction = "";
map.VisibleDistance = 20;
List <Tile> visibleTiles = map.GetVisibleTiles().ToList();
ressourceTiles = visibleTiles.Where(t => t.TileType == TileContent.Resource).ToList();
enemiesTiles = visibleTiles.Where(t => t.TileType == TileContent.Player).ToList();
DistanceFromTiles dist = new DistanceFromTiles(TrouverDistanceEntreDeuxPoints);
Point destination = PlayerInfo.HouseLocation;
Tuple <Point, TileContent> nextMove = null;
switch (listTitlePriority[0])
{
case TileContent.House:
nextMove = checkNextTile(map, destination);
break;
case TileContent.Lava:
break;
case TileContent.Player:
if (enemiesTiles.Count != 0)
{
enemiesTiles = enemiesTiles.OrderBy(p => dist(p.Position, PlayerInfo.Position)).ToList();
}
nextMove = checkNextTile(map, enemiesTiles[1].Position);
break;
case TileContent.Resource:
if (ressourceTiles.Count != 0)
{
ressourceTiles = ressourceTiles.OrderBy(t => dist(t.Position, PlayerInfo.Position)).ToList();
destination = ressourceTiles[0].Position;
}
nextMove = checkNextTile(map, destination);
break;
case TileContent.Shop:
break;
case TileContent.Wall:
break;
}
switch (nextMove.Item2)
{
case TileContent.Empty:
instruction = AIHelper.CreateMoveAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
case TileContent.House:
instruction = AIHelper.CreateMoveAction(nextMove.Item1 - this.PlayerInfo.Position);
//nextMove = checkNextTile(map, closestResource.Position);
break;
case TileContent.Lava:
break;
case TileContent.Resource:
instruction = AIHelper.CreateCollectAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
case TileContent.Shop:
break;
case TileContent.Player:
instruction = AIHelper.CreateMeleeAttackAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
case TileContent.Wall:
instruction = AIHelper.CreateMeleeAttackAction(nextMove.Item1 - this.PlayerInfo.Position);
break;
}
if (vertical < 20)
{
vertical++;
instruction = AIHelper.CreateMoveAction(PlayerInfo.HouseLocation - this.PlayerInfo.Position);
}
var data = StorageHelper.Read <TestClass>("Test");
Console.WriteLine(data?.Test);
return(instruction);//AIHelper.CreateCollectAction(new Point(1, 0));
//return AIHelper.CreateMoveAction(new Point(-1, 0));
}
public override Actor GetDefaultTargetActor()
{
Monster monster = mRunningProperty.SelfActor as Monster;
if (monster == null)
{
return(null);
}
//if (monster is Pet)
//{
// if (!SceneHelp.Instance.IsInSingleInstance())
// {
// return null;
// }
//}
Actor targetActor = null;
float shortest = float.MaxValue;
Actor localPlayer = Game.GetInstance().GetLocalPlayer();
// 有没有强制目标
//Spartan.MonsterGroupInfo monsterGroupInfo = monster.SpartanMonsterGroupInfo;
//if(monsterGroupInfo != null)
//{
// targetActor = NpcManager.Instance.GetNpcByNpcId((uint)monsterGroupInfo.TargetNpcId);
// if(targetActor != null && !targetActor.IsActorInvisiable)
// {
// return targetActor;
// }
//}
float viewRange = mRunningProperty.ViewRange * mRunningProperty.ViewRange;
if (InstanceManager.Instance.IsPlayerVSPlayerType)
{
if (mRunningProperty.SelfActor.ParentActor == null)
{
return(null);
}
foreach (var item in ActorManager.Instance.PlayerSet)
{
Actor oppositeActor = null;
if (item.Value.UID != mRunningProperty.SelfActor.ParentActor.UID)
{
oppositeActor = item.Value;
float distanceSquare = AIHelper.DistanceSquare(mRunningProperty.SelfActorPos, item.Value.transform.position);
shortest = distanceSquare;
foreach (var son in oppositeActor.SonActors)
{
if (son == null || son.IsDead() || son.IsActorInvisiable)
{
continue;
}
distanceSquare = AIHelper.DistanceSquare(mRunningProperty.SelfActorPos, son.transform.position);
if (distanceSquare < shortest)
{
shortest = distanceSquare;
oppositeActor = son;
}
}
return(oppositeActor);
}
}
}
//else if (InstanceManager.Instance.InstanceType == GameConst.WAR_TYPE_ARENA)
//{
// if (mRunningProperty.SelfActor.ParentActor == null)
// {
// return null;
// }
// foreach (var item in ActorManager.Instance.ActorSet)
// {
// if(item.Value.IsActorInvisiable)
// {
// continue;
// }
// if (item.Value.UID != mRunningProperty.SelfActor.ParentActor.UID)
// {
// return item.Value;
// }
// }
//}
// 是玩家队友
if (localPlayer != null && monster.Camp == localPlayer.Camp)
{
Dictionary <UnitID, Actor> monsters = ActorManager.Instance.MonsterSet;
// 计算出最短距离
foreach (var item in monsters)
{
if (item.Value == null)
{
continue;
}
if (item.Value.IsDead() || (item.Value.gameObject.activeSelf == false))
{
continue;
}
if (item.Value == mRunningProperty.SelfActor.ParentActor || item.Value.IsActorInvisiable)
{
continue;
}
if (item.Value == mRunningProperty.SelfActor)
{
continue;
}
if (item.Value.Camp == monster.Camp)
{
continue;
}
if (mRunningProperty.SelfActor.ParentActor != null)
{
if (item.Value.ParentActor == mRunningProperty.SelfActor.ParentActor)
{
continue;
}
}
float distanceSquare = AIHelper.DistanceSquare(mRunningProperty.SelfActorPos, item.Value.transform.position);
if (distanceSquare < shortest)
{
shortest = distanceSquare;
targetActor = item.Value;
}
}
if (InstanceManager.Instance.InstanceType == GameConst.WAR_TYPE_WILD)
{
if (localPlayer != null && localPlayer.WildState == Actor.EWildState.Kill)
{
Dictionary <UnitID, Actor> players = ActorManager.Instance.PlayerSet;
// Linq
//monsters = monsters.Concat(players).ToDictionary(k => k.Key, v => v.Value);
// 计算出最短距离
foreach (var item in players)
{
if (item.Value == null)
{
continue;
}
if (item.Value.IsDead() || (item.Value.gameObject.activeSelf == false))
{
continue;
}
if (item.Value == mRunningProperty.SelfActor.ParentActor || item.Value.IsActorInvisiable)
{
continue;
}
if (mRunningProperty.SelfActor.ParentActor != null)
{
if (!mRunningProperty.SelfActor.ParentActor.CheckCanAttackOtherPlayer(item.Value))
{
continue;
}
}
float distanceSquare = AIHelper.DistanceSquare(mRunningProperty.SelfActorPos, item.Value.transform.position);
if (distanceSquare < shortest)
{
shortest = distanceSquare;
targetActor = item.Value;
}
}
}
if (shortest > viewRange)
{
targetActor = null;
}
}
return(targetActor);
}
// 先检测当前目标有没有脱离视野范围
if (mRunningProperty.TargetActor != null && !mRunningProperty.TargetActor.IsActorInvisiable)
{
float distance = AIHelper.DistanceSquare(mRunningProperty.TargetActor.transform.position, mRunningProperty.SelfActorPos);
if (distance <= viewRange && !mRunningProperty.TargetActor.IsActorInvisiable)
{
return(mRunningProperty.TargetActor);
}
}
targetActor = Game.GetInstance().GetLocalPlayer();
if (targetActor != null)
{
shortest = AIHelper.DistanceSquare(targetActor.transform.position, mRunningProperty.SelfActorPos);
}
else
{
shortest = float.MaxValue;
}
// 检测召唤出来的怪物
Dictionary <UnitID, Actor> summonMonsters = ActorManager.Instance.SummonMonsterSet;
foreach (var item in summonMonsters)
{
Monster monster2 = item.Value as Monster;
if (monster2 == null)
{
continue;
}
if (monster2.BeSummonedType == Monster.BeSummonType.BE_SUMMON_BY_MONSTER)
{
continue;
}
if (monster2.IsActorInvisiable)
{
continue;
}
float distance = AIHelper.DistanceSquare(item.Value.transform.position, mRunningProperty.SelfActorPos);
if (distance > viewRange || distance > shortest)
{
continue;
}
shortest = distance;
targetActor = item.Value;
}
// 检测场景内的NPC
var allNpc = NpcManager.Instance.AllNpc;
foreach (var item in allNpc)
{
NpcPlayer npc = item.Value.BindActor as NpcPlayer;
if (npc.NpcData.Relationship != Neptune.Relationship.FRIENDLY)
{
continue;
}
float distance = AIHelper.DistanceSquare(npc.transform.position, mRunningProperty.SelfActorPos);
if (distance > viewRange || distance > shortest)
{
continue;
}
if (npc.IsActorInvisiable)
{
continue;
}
shortest = distance;
targetActor = npc;
}
if (shortest > viewRange)
{
targetActor = null;
}
return(targetActor);
}
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
//portion pathfinding pour les Mines debut
PathNoeud playerPosition = new PathNoeud(PlayerInfo.Position.X, PlayerInfo.Position.Y, 0, 0, null);
List <PathNoeud> minePosition = new List <PathNoeud>();
List <ResourceTile> minePosition_ = new List <ResourceTile>();
minePosition_ = GetVisibleResourceTiles(map);
foreach (ResourceTile rt in minePosition_)
{
minePosition.Add(new PathNoeud(rt.Position.X, rt.Position.Y, 0, 0, null));
}
List <PathNoeud> paths = new List <PathNoeud>();
//List<PathNoeud> finalPath = new List<PathNoeud>();
if (PlayerInfo.Position.X == PlayerInfo.HouseLocation.X)
{
if (PlayerInfo.Position.Y == PlayerInfo.HouseLocation.Y)
{
if (CanBuy_Amelioration(PlayerInfo))
{
return(WhatToBuy_Amelioration(PlayerInfo));
}
}
}
if (finalPath.Count() == 0)
{
if (MustReturnToHouse() || minePosition.Count == 0)
{
int x = PlayerInfo.HouseLocation.X;
int y = PlayerInfo.HouseLocation.Y;
PathNoeud housePath = new PathNoeud(x, y, 0, 0, null);
PathNoeud path = trouverPathMine(playerPosition, housePath, map, PlayerInfo);
paths.Add(path);
}
else
{
foreach (PathNoeud n in minePosition)
{
PathNoeud path = trouverPathMine(playerPosition, n, map, PlayerInfo);
if (path != null)
{
paths.Add(path);
}
}
}
if (paths.Count > 0)
{
PathNoeud currentPath = paths[0];
foreach (PathNoeud n in paths)
{
if (currentPath.getGCost() > n.getGCost())
{
currentPath = n;
}
}
//fin portion pathfinding
finalPath = new List <PathNoeud>();
while (currentPath != null)
{
finalPath.Add(currentPath);
currentPath = currentPath.getParent();
}
}
}
// miner si a coter dune mine
if (PlayerInfo.CarriedResources != PlayerInfo.CarryingCapacity && mineAutour(map, PlayerInfo))
{
int x = 0;
int y = 0;
for (int i = -1; i <= 1; i += 2)
{
if (TileContent.Resource == map.GetTileAt(PlayerInfo.Position.X + i, PlayerInfo.Position.Y))
{
x = PlayerInfo.Position.X + i;
y = PlayerInfo.Position.Y;
return(AIHelper.CreateCollectAction(new Point(x - PlayerInfo.Position.X, y - PlayerInfo.Position.Y)));
}
}
for (int i = -1; i <= 1; i += 2)
{
if (TileContent.Resource == map.GetTileAt(PlayerInfo.Position.X, PlayerInfo.Position.Y + i))
{
x = PlayerInfo.Position.X;
y = PlayerInfo.Position.Y + i;
return(AIHelper.CreateCollectAction(new Point(x - PlayerInfo.Position.X, y - PlayerInfo.Position.Y)));
}
}
}
// se deplacer
if (finalPath.Count > 0)
{
PathNoeud prochainMove = finalPath[finalPath.Count - 1];
if (map.GetTileAt(prochainMove.getX(), prochainMove.getY()) == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(new Point(prochainMove.getX() - PlayerInfo.Position.X, prochainMove.getY() - PlayerInfo.Position.Y)));
}
else
{
finalPath.Remove(prochainMove);
return(AIHelper.CreateMoveAction(new Point(prochainMove.getX() - PlayerInfo.Position.X, prochainMove.getY() - PlayerInfo.Position.Y)));
}
}
var data = StorageHelper.Read <TestClass>("Test");
Console.WriteLine(data?.Test);
return(AIHelper.CreateMoveAction(new Point(_currentDirection, 0)));
return(null);
}
internal string MoveRandomly(Map map)
{
if (!moving)
{
Random rnd = new Random();
randomDirection = rnd.Next(1, 5);
randomDistance = rnd.Next(1, MAX_RANDOM_DISTANCE);
moving = true;
while (randomDirection == previousDirection)
{
randomDirection = rnd.Next(1, 5);
}
}
if (distanceTravelled >= randomDistance)
{
moving = false;
distanceTravelled = 0;
}
if (moving)
{
switch (randomDirection)
{
case 1:
if (MeleeTargetExists(map, 1, 0))
{
return(AIHelper.CreateMeleeAttackAction(new Point(1, 0)));
}
return(AIHelper.CreateMoveAction(new Point(1, 0)));
case 2:
if (MeleeTargetExists(map, -1, 0))
{
return(AIHelper.CreateMeleeAttackAction(new Point(-1, 0)));
}
return(AIHelper.CreateMoveAction(new Point(-1, 0)));
case 3:
if (MeleeTargetExists(map, 0, 1))
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, 1)));
}
return(AIHelper.CreateMoveAction(new Point(0, 1)));
case 4:
if (MeleeTargetExists(map, 0, -1))
{
return(AIHelper.CreateMeleeAttackAction(new Point(0, -1)));
}
return(AIHelper.CreateMoveAction(new Point(0, -1)));
}
distanceTravelled++;
}
if (distanceTravelled >= randomDistance)
{
moving = false;
distanceTravelled = 0;
}
var data = StorageHelper.Read <TestClass>("Test");
return(AIHelper.CreateEmptyAction());
}
// WARNING: Replaces the existing logic
// isStationary here represents the attacker, not the target
public static bool Prefix(AbstractActor unit, bool isStationary, ref BehaviorTreeResults __result)
{
// If there is no unit, exit immediately
if (unit == null)
{
__result = new BehaviorTreeResults(BehaviorNodeState.Failure);
return(false);
}
// If there are no enemies, exit immediately
if (unit.BehaviorTree.enemyUnits.Count == 0)
{
Mod.Log.Info?.Write("No important enemy units, skipping decision making.");
__result = new BehaviorTreeResults(BehaviorNodeState.Failure);
return(false);
}
// Initialize decision data caches
AEHelper.InitializeAttackOrderDecisionData(unit);
Mod.Log.Debug?.Write($" == Evaluating attack from unit: {CombatantUtils.Label(unit)} at pos: {unit.CurrentPosition} against {unit.BehaviorTree.enemyUnits.Count} enemies.");
BehaviorTreeResults behaviorTreeResults = null;
AbstractActor designatedTarget = AEHelper.FilterEnemyUnitsToDesignatedTarget(unit.team as AITeam, unit.lance, unit.BehaviorTree.enemyUnits);
float desTargDamage = 0f;
float desTargFirepowerReduction = 0f;
if (designatedTarget != null)
{
desTargDamage = AOHelper.MakeAttackOrderForTarget(unit, designatedTarget, isStationary, out behaviorTreeResults);
desTargFirepowerReduction = AIAttackEvaluator.EvaluateFirepowerReductionFromAttack(unit, unit.CurrentPosition, designatedTarget, designatedTarget.CurrentPosition, designatedTarget.CurrentRotation, unit.Weapons, MeleeAttackType.NotSet);
Mod.Log.Debug?.Write($" DesignatedTarget: {CombatantUtils.Label(designatedTarget)} will suffer: {desTargDamage} damage and lose: {desTargFirepowerReduction} firepower from attack.");
}
else
{
Mod.Log.Debug?.Write(" No designated target identified.");
}
float behavior1 = AIHelper.GetBehaviorVariableValue(unit.BehaviorTree, BehaviorVariableName.Float_OpportunityFireExceedsDesignatedTargetByPercentage).FloatVal;
float opportunityFireThreshold = 1f + (behavior1 / 100f);
float behavior2 = AIHelper.GetBehaviorVariableValue(unit.BehaviorTree, BehaviorVariableName.Float_OpportunityFireExceedsDesignatedTargetFirepowerTakeawayByPercentage).FloatVal;
float opportunityFireTakeawayThreshold = 1f + (behavior2 / 100f);
Mod.Log.Info?.Write($" Opportunity Fire damageThreshold: {opportunityFireThreshold} takeawayThreshold: {opportunityFireTakeawayThreshold}");
// Walk through every alive enemy, and see if a better shot presents itself.
for (int j = 0; j < unit.BehaviorTree.enemyUnits.Count; j++)
{
ICombatant combatant = unit.BehaviorTree.enemyUnits[j];
if (combatant == designatedTarget || combatant.IsDead)
{
continue;
}
Mod.Log.Debug?.Write($" Checking opportunity fire against target: {CombatantUtils.Label(combatant)}");
AbstractActor opportunityFireTarget = combatant as AbstractActor;
BehaviorTreeResults oppTargAttackOrder;
// Should MAOFT take a param for opportunity attacks to simplify?
float oppTargDamage = AOHelper.MakeAttackOrderForTarget(unit, combatant, isStationary, out oppTargAttackOrder);
float oppTargFirepowerReduction = AIAttackEvaluator.EvaluateFirepowerReductionFromAttack(unit, unit.CurrentPosition, combatant, combatant.CurrentPosition, combatant.CurrentRotation, unit.Weapons, MeleeAttackType.NotSet);
Mod.Log.Debug?.Write($" Target will suffer: {oppTargDamage} with firepower reduction: {oppTargFirepowerReduction}");
// TODO: Was where opportunity cost from evasion strip was added to target damage.
// Reintroduce utility damage to this calculation
bool exceedsOpportunityFireThreshold = oppTargDamage > desTargDamage * opportunityFireThreshold;
Mod.Log.Debug?.Write($" Comparing damage - opportunity: {oppTargDamage} > designated: {designatedTarget} * threshold: {opportunityFireThreshold}");
bool exceedsFirepowerReductionThreshold = oppTargFirepowerReduction > desTargFirepowerReduction * opportunityFireTakeawayThreshold;
Mod.Log.Debug?.Write($" Comparing firepower reduction - opportunity: {oppTargFirepowerReduction} vs. designated: {desTargFirepowerReduction} * threshold: {1f + opportunityFireTakeawayThreshold}");
// TODO: Short circuit here - takes the first result, instead of the best result. Should we fix this?
if (oppTargAttackOrder != null && oppTargAttackOrder.orderInfo != null &&
(exceedsOpportunityFireThreshold || exceedsFirepowerReductionThreshold))
{
Mod.Log.Debug?.Write(" Taking opportunity fire attack, instead of attacking designated target.");
__result = oppTargAttackOrder;
return(false);
}
}
if (behaviorTreeResults != null && behaviorTreeResults.orderInfo != null)
{
Mod.Log.Debug?.Write("Successfuly calculated attack order");
unit.BehaviorTree.AddMessageToDebugContext(AIDebugContext.Shoot, "attacking designated target. Success");
__result = behaviorTreeResults;
return(false);
}
Mod.Log.Debug?.Write("Could not calculate reasonable attacks. Skipping node.");
__result = new BehaviorTreeResults(BehaviorNodeState.Failure);
return(false);
}
private string GoTo(Point location, Map map, bool moveHorizontally)
{
Point direction = null;
if (_temporaryTarget != null && PlayerInfo.Position != _temporaryTarget)
{
location = _temporaryTarget;
}
else if (PlayerInfo.Position == _temporaryTarget)
{
_temporaryTarget = null;
}
if (moveHorizontally)
{
if (PlayerInfo.Position.X != location.X)
{
direction = new Point(MathF.Sign(location.X - PlayerInfo.Position.X), 0);
}
else
{
return(GoTo(location, map, false));
}
TileContent content = map.GetTileAt(PlayerInfo.Position.X + direction.X, PlayerInfo.Position.Y + direction.Y);
if (content != TileContent.Empty && content != TileContent.House)
{
if (content == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(direction));
}
else if (PlayerInfo.Position.Y == location.Y)
{
_temporaryTarget = FindTemporaryTarget(PlayerInfo.Position, location, true, map);
}
return(GoTo(location, map, false));
}
else
{
return(AIHelper.CreateMoveAction(direction));
}
}
else
{
if (PlayerInfo.Position.Y != location.Y)
{
direction = new Point(0, MathF.Sign(location.Y - PlayerInfo.Position.Y));
}
else
{
return(GoTo(location, map, true));
}
TileContent content = map.GetTileAt(PlayerInfo.Position.X + direction.X, PlayerInfo.Position.Y + direction.Y);
if (content != TileContent.Empty && content != TileContent.House)
{
if (content == TileContent.Wall)
{
return(AIHelper.CreateMeleeAttackAction(direction));
}
else if (PlayerInfo.Position.X == location.X)
{
_temporaryTarget = FindTemporaryTarget(PlayerInfo.Position, location, false, map);
}
return(GoTo(location, map, true));
}
else
{
return(AIHelper.CreateMoveAction(direction));
}
}
}
public override void Update(GameTime gameTime)
{
AIHelper.BigWarshipAI(this, gameTime);
base.Update(gameTime);
}
public override void Update(IGameTimeService gameTime)
{
if (IsLocalSim)
{
Simulate(gameTime);
return;
}
if (IsDead)
{
return;
}
Weapon.Update(gameTime);
DelayTime += gameTime.ElapsedMilliseconds; // Used for Loading.
#region Logic
//0 = No target(s) in range, laser at rest
//1 = Target(s) on planet, find one
//2 = Turn head to aim or Fire if within aim tolerance
//3 = Fire
switch (logicState)
//Just FYI in case you're confused, a locally simulated turret doesn't run this code, it runs .Simulate() instead.
{
case LogicStates.Resting:
if (PotentialTargets.Count > 0)
{
logicState = LogicStates.SearchingForTarget;
}
break;
case LogicStates.SearchingForTarget:
FindTarget();
if (CurrentTarget != null)
{
logicState = LogicStates.TurningTowardTarget;
}
break;
case LogicStates.TurningTowardTarget:
if (CurrentTarget == null)
{
logicState = LogicStates.Resting;
break;
}
else if (CurrentTarget != null && !CurrentTarget.IsBodyValid)
{
PotentialTargets.Remove(CurrentTarget.Id);
CurrentTarget = null;
logicState = LogicStates.Resting;
break;
}
else if (gameTime.TotalMilliseconds - _lastTargetCheckTime > 200)
//Retargets closest item 5 times per second
//Retargeting is expensive, if turrets lag this needs to be rethought
{
_lastTargetCheckTime = (float)gameTime.TotalMilliseconds;
CurrentTarget = null;
logicState = LogicStates.Resting;
break;
}
else if (Vector2.Distance(CurrentTarget.Position, Position) > turretRange)
{
CurrentTarget = null;
logicState = LogicStates.Resting;
break;
}
Rotation = AIHelper.TurnTowardPosition(
Rotation, rotationSpeed,
Position, CurrentTarget.Position,
gameTime.ElapsedMilliseconds, AimTolerance
).Rotation;
break;
}
#endregion
OldTime += gameTime.ElapsedMilliseconds; // Updates Time since Last Action
}
public static Actor GetNearestActor(AIRunningProperty runningProperty, Dictionary <UnitID, Actor> actors, Vector3 targetPos)
{
if (actors == null || runningProperty == null)
{
return(null);
}
Actor targetActor = null;
float shortest = float.MaxValue;
float viewRange = runningProperty.ViewRange * runningProperty.ViewRange;
bool show_tips = false;
// 计算出最短距离
foreach (var item in actors)
{
if (item.Value == null)
{
continue;
}
if (item.Value.transform == null)
{
continue;
}
if (!TargetPositionHeightIsAbnormal(item.Value.transform.position))
{
continue;
}
if (runningProperty.SelfActor is LocalPlayer || runningProperty.SelfActor.ParentActor is LocalPlayer)
{
show_tips = false;
if (PKModeManagerEx.Instance.IsLocalPlayerCanAttackActor(item.Value, ref show_tips) == false)
{
continue;
}
}
if (item.Value.IsDead() || (item.Value.gameObject.activeSelf == false))
{
continue;
}
if (item.Value.IsActorInvisiable)
{
continue;
}
if (item.Value is Pet)
{
continue;
}
if (item.Value.Camp == runningProperty.SelfActor.Camp)
{
continue;
}
float distanceSquare = AIHelper.DistanceSquare(targetPos, item.Value.transform.position);
if (distanceSquare < shortest)
{
shortest = distanceSquare;
targetActor = item.Value;
}
}
if (shortest > viewRange)
{
targetActor = null;
}
return(targetActor);
}
public override string GetNextMove(IPlayer player, IEnumerable <IPlayer> visiblePlayers, LegacyMap map)
{
Point direction = new Point(ennemy.Position.X - player.Position.X, ennemy.Position.Y - player.Position.Y);
return(AIHelper.CreateMeleeAttackAction(direction));
}
public float GetAngleToTarget(Vector2 target)
{
return(AIHelper.GetAngleToTarget(Position, Rotation, target));
}
protected virtual BehaviourTree.BehaviourReturnCode RunActionImplement(string action, object[] parameters)
{
if (action == "ActionFireEvent")
{
int eventId = (int)parameters[0];
return(mFunction.ActionFireEvent(eventId));
}
else if (action == "ActionTestRun")
{
return(mFunction.ActionTestRun());
}
else if (action == "ActionReturnCode")
{
int returnCode = 0;
if (parameters.Length >= 1)
{
returnCode = (int)parameters[0];
}
return(mFunction.ActionReturnCode(returnCode));
}
else if (action == "ActionChaseTarget")
{
return(mFunction.ActionChaseTarget());
}
else if (action == "ActionAttack")
{
return(mFunction.ActionAttack());
}
else if (action == "ActionTryAttack")
{
return(mFunction.ActionTryAttack());
}
else if (action == "ActionStand")
{
return(mFunction.ActionStand());
}
else if (action == "ActionSetMostHateActorToTarget")
{
return(mFunction.ActionSetMostHateActorToTarget());
}
else if (action == "ActionSetPlayerToTarget")
{
return(mFunction.ActionSetPlayerToTarget());
}
else if (action == "ActionSetMonsterToTarget")
{
return(mFunction.ActionSetMonsterToTarget());
}
else if (action == "ActionDoNothing")
{
return(mFunction.ActionDoNothing());
}
else if (action == "ActionSetDefaultActorToTarget")
{
return(mFunction.ActionSetDefaultActorToTarget());
}
else if (action == "ActionSetNeedCounterattackPlayerToTarget")
{
return(mFunction.ActionSetNeedCounterattackPlayerToTarget());
}
else if (action == "ActionSetPlayerOrMonsterToTarget")
{
return(mFunction.ActionSetPlayerOrMonsterToTarget());
}
else if (action == "ActionCleanCanNotAttackTarget")
{
return(mFunction.ActionCleanCanNotAttackTarget());
}
else if (action == "ActionSuicide")
{
return(mFunction.ActionSuicide());
}
else if (action == "ActionPatrol")
{
bool setCenterPos = false;
if (parameters.Length >= 1)
{
setCenterPos = (bool)parameters[0];
}
return(mFunction.ActionPatrol(setCenterPos));
}
else if (action == "ActionSetAILevelHpBeacons")
{
float beacon1 = (float)parameters[0];
float beacon2 = 0.0f;
// 是不是有三级AI还是有二级AI
if (parameters.Length > 1)
{
beacon2 = (float)parameters[1];
}
int beaconType = 0;
if (parameters.Length > 2)
{
beaconType = (int)parameters[2];
}
return(mFunction.ActionSetAILevelHpBeacons(beacon1, beacon2, beaconType));
}
else if (action == "ActionFollowPlayer")
{
return(mFunction.ActionFollowPlayer());
}
else if (action == "ActionSelectSkillAttack")
{
int skillId = (int)parameters[0];
return(mFunction.ActionSelectSkillAttack(skillId));
}
else if (action == "ActionSetLastSkillAndTargetToCurrent")
{
return(mFunction.ActionSetLastSkillAndTargetToCurrent());
}
else if (action == "ActionWalkToOriginalPos")
{
return(mFunction.ActionWalkToOriginalPos());
}
else if (action == "ActionTeleportToParentActorRangeRandomPosition")
{
float nearRadius = 0;
float farRadius = 0;
if (parameters.Length >= 1)
{
nearRadius = (float)parameters[0];
}
if (parameters.Length >= 2)
{
farRadius = (float)parameters[1];
}
return(mFunction.ActionTeleportToParentActorRangeRandomPosition(nearRadius, farRadius));
}
else if (action == "ActionWalkToParentActorRangeRandomPosition")
{
float nearRadius = 0;
float farRadius = 0;
if (parameters.Length >= 1)
{
nearRadius = (float)parameters[0];
}
if (parameters.Length >= 2)
{
farRadius = (float)parameters[1];
}
return(mFunction.ActionWalkToParentActorRangeRandomPosition(nearRadius, farRadius));
}
else
{
AIHelper.WriteErrorLog("BehaviourAI.RunActionImplement can not find action:" + action, this);
}
return(BehaviourTree.BehaviourReturnCode.Success);
}
public override void Simulate(IGameTimeService gameTime)
{
if (!IsBodyValid)
{
return;
}
Weapon.Update(gameTime);
DelayTime += gameTime.ElapsedMilliseconds; // Used for Loading.
#region Logic
if (logicState != LogicStates.Resting && (CurrentTarget == null || !CurrentTarget.IsBodyValid))
{
CurrentTarget = null;
logicState = LogicStates.SearchingForTarget;
}
switch (logicState)
{
case LogicStates.Resting:
if (PotentialTargets.Count > 0)
{
logicState = LogicStates.SearchingForTarget;
}
break;
case LogicStates.SearchingForTarget:
FindTarget();
if (CurrentTarget != null)
{
logicState = LogicStates.TurningTowardTarget;
}
break;
case LogicStates.TurningTowardTarget:
if (!CurrentTarget.IsBodyValid)
{
PotentialTargets.Remove(CurrentTarget.Id);
CurrentTarget = null;
logicState = LogicStates.Resting;
break;
}
if (gameTime.TotalMilliseconds - _lastTargetCheckTime > 200) //Retargets closest item 5 times per second
//Retargeting is expensive, if turrets lag this needs to be rethought
{
_lastTargetCheckTime = (float)gameTime.TotalMilliseconds;
CurrentTarget = null;
logicState = LogicStates.Resting;
break;
}
if (Vector2.Distance(CurrentTarget.Position, Position) > turretRange)
{
CurrentTarget = null;
logicState = LogicStates.Resting;
break;
}
var result = AIHelper.TurnTowardPosition(Rotation, rotationSpeed, Position, CurrentTarget.Position, gameTime.ElapsedMilliseconds, AimTolerance);
Rotation = result.Rotation;
if (!result.Rotated)
{
if (Weapon.CanFire())
{
Weapon.TimeOfWaitStart = gameTime.TotalMilliseconds;
Weapon.Fire_LocalOrigin(Rotation, 0, true);
Weapon.WaitingForFireResponse = true;
}
}
break;
}
#endregion
OldTime += gameTime.ElapsedMilliseconds; // Updates Time since Last Action
}
/// <summary>
/// Implement your bot here.
/// </summary>
/// <param name="map">The gamemap.</param>
/// <param name="visiblePlayers">Players that are visible to your bot.</param>
/// <returns>The action you wish to execute.</returns>
internal string ExecuteTurn(Map map, IEnumerable <IPlayer> visiblePlayers)
{
worldMap = WorldMap.ReadMap();
if (worldMap == null || worldMap.HomePosition != PlayerInfo.HouseLocation)
{
worldMap = new WorldMap();
}
worldMap.UpdateWorldMap(map);
worldMap.HomePosition = PlayerInfo.HouseLocation;
WorldMap.WriteMap(worldMap);
this.astarService = new AStarAlgo(worldMap);
this.ressourcePlaner = new RessourcePlaner(worldMap, PlayerInfo, astarService);
this.navigationHelper = new NavigationHelper(PlayerInfo, astarService);
this.manathan = new Manathan();
this.placePlaner = new PlacePlaner(map, PlayerInfo, astarService);
Console.WriteLine("Cash : " + PlayerInfo.TotalResources);
try
{
var best_ressource = ressourcePlaner.GetBestRessourcePath();
//var best_place_for_shop = placePlaner.GetBestPlacePath(TileContent.Shop);
// 10000 15000 25000 50000 100000
if (PlayerInfo.Position == PlayerInfo.HouseLocation)
{
bool upgrade = false;
switch (PlayerInfo.GetUpgradeLevel(UpgradeType.AttackPower))
{
case 0:
if (PlayerInfo.TotalResources >= 10000)
{
upgrade = true;
}
break;
case 1:
if (PlayerInfo.TotalResources >= 15000)
{
upgrade = true;
}
break;
case 2:
if (PlayerInfo.TotalResources >= 25000)
{
upgrade = true;
}
break;
case 3:
if (PlayerInfo.TotalResources >= 50000)
{
upgrade = true;
}
break;
case 4:
if (PlayerInfo.TotalResources >= 100000)
{
upgrade = true;
}
break;
}
if (upgrade)
{
return(AIHelper.CreateUpgradeAction(UpgradeType.AttackPower));
}
}
if (PlayerInfo.CarriedResources < PlayerInfo.CarryingCapacity && best_ressource != null)
{
if (best_ressource.Path.Count == 2)
{
// On est adjacent à la meilleure ressource
var direction = astarService.DirectionToward(PlayerInfo.Position, best_ressource.Tile.Position);
return(AIHelper.CreateCollectAction(direction));
}
else if (best_ressource.Path.Count == 1)
{
// on est dessus
var tileToGo = map.GetTile(PlayerInfo.Position.X - 1, PlayerInfo.Position.Y);
var action = navigationHelper.NavigateToNextPosition(tileToGo);
return(action);
}
else
{
// On est pas rendu
return(navigationHelper.NavigateToNextPosition(best_ressource.Path[1]));
}
}
else
{
// on doit aller à la base
var home_tile = worldMap.GetTile(PlayerInfo.HouseLocation.X, PlayerInfo.HouseLocation.Y);
var current_tile = worldMap.GetTile(PlayerInfo.Position.X, PlayerInfo.Position.Y);
if (home_tile == null)
{
var path = manathan.GetManathanPath(current_tile.Position, PlayerInfo.HouseLocation);
return(navigationHelper.NavigateToNextPosition(worldMap.GetTile(path[0].X, path[0].Y)));
}
else
{
var best_path_to_home = astarService.Run(current_tile, home_tile);
if (best_path_to_home == null)
{
var path = manathan.GetManathanPath(current_tile.Position, PlayerInfo.HouseLocation);
return(navigationHelper.NavigateToNextPosition(worldMap.GetTile(path[0].X, path[0].Y)));
}
// On est pas rendu
return(navigationHelper.NavigateToNextPosition(best_path_to_home[1]));
}
}
}
catch (Exception e)
{
Console.WriteLine("*** Reset the map! ***");
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.InnerException);
Console.WriteLine("*** inner exception ***");
Console.WriteLine(e);
Console.WriteLine("*** exception ***");
worldMap = new WorldMap();
worldMap.UpdateWorldMap(map);
worldMap.HomePosition = PlayerInfo.HouseLocation;
WorldMap.WriteMap(worldMap);
return("");
}
/*
* AStarAlgo astar = new AStarAlgo(map);
* var result = astar.Run(PlayerInfo.Position, new Point(-4, 21));
*
*
* var data = StorageHelper.Read<TestClass>("Test");
* Console.WriteLine(data?.Test);
* //return AIHelper.CreateMoveAction(new Point(_currentDirection, 0)); astar.DirectionToward(PlayerInfo.Position, result[0].Position);
* return AIHelper.CreateMoveAction(astar.DirectionToward(PlayerInfo.Position, result[0].Position));*/
}
