public void OnLeave(FSMContext context)
{
BattleProcedure.CurSession.OrderController.StopInputJob();
SetReady(false);
playOrder = null;
BattleProcedure.CurSession.CleanPlayCardTable();
}
public void Enact(BattleOrder battleOrder)
{
this.battleOrder = battleOrder;
Debug.Log("woah battle order!" + battleOrder);
if ("attack".Equals(battleOrder.Action)) {
battleOrder.SourceCombatant.Stats.TurnStats.ConsumeAttack();
battleOrder.SourceCombatant.StartAttackAnimation(battleOrder.TargetTile);
state = State.ATTACKING;
//TODO shuffle this somewhere else
ApplyDamage();
} else if ("move".Equals(battleOrder.Action)) {
battleOrder.SourceCombatant.Stats.TurnStats.ConsumeMovement();
MapManager map = GameObject.FindGameObjectWithTag("Map").GetComponent<MapManager>();
// TODO clean up
tilePath = map.GetShortestPathThreadsafe(battleOrder.SourceCombatant.Tile.TileData,
battleOrder.TargetTile.TileData, TeamId.EnemyTeam).ConvertAll(t => t.Tile);
previousHop = tilePath[0];
nextHop = tilePath[0];
state = State.MOVING;
} else if ("endturn".Equals(battleOrder.Action)) {
battleOrder.SourceCombatant.Stats.TurnStats.EndTurn();
state = State.FINISHED;
}
}
public override void Execute()
{
parentMenu.gameObject.SetActive(false);
Debug.Log("attack! - " + combatant);
BattleOrder order = new BattleOrder();
order.Action = "attack";
order.SourceCombatant = combatant;
MapManager map = GameObject.FindGameObjectWithTag("Map").GetComponent <MapManager>();
//List<Tile> tiles = map.GetTilesInRange(combatant.Tile, 1, true);
List <Tile> tiles = map.GetTilesInRangeThreadsafe(combatant.Tile.TileData, 1, TeamId.MOVE_THROUGH_ALL)
.ConvertAll(t => t.Tile);
tiles.Remove(combatant.Tile);
GameObject objToSpawn = new GameObject("Tile Picker - Attack");
objToSpawn.AddComponent <TilePicker>();
TilePicker tilePicker = objToSpawn.GetComponent <TilePicker>();
tilePicker.SetTiles(tiles);
tilePicker.battleStateTracker.previous = this.parentMenu.battleStateTracker;
tilePicker.SetBattleOrder(order);
parentMenu.CleanUp();
}
public void ExecuteTurn_WhenGroupRandomReturns1AndGroupHasNoObjectsLeft_ShouldReturnFirstObjectFromFirstGroup(
[Frozen] IBattleRandom battleRandom,
BattleOrder battleOrder)
{
// 999 controls order to be defense
// 1 is the second group idx
// 0 is the first combat obj idx
battleRandom.Next(Arg.Any <int>()).Returns(999, 1, 0);
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var attackerObject = CreateCombatObject(round: 0);
var attackerGroup = CreateGroup(attackerObject);
var attackerList = CreateList(upkeepNotParticipated: 1, combatGroups: attackerGroup);
var defenderObject1 = CreateCombatObject(round: 0);
var defenderGroup1 = CreateGroup(defenderObject1);
var defenderObject2 = CreateCombatObject(round: 1);
var defenderGroup2 = CreateGroup(defenderObject2);
var defenderList = CreateList(upkeepNotParticipated: 999, combatGroups: new [] { defenderGroup1, defenderGroup2 });
var result = battleOrder.NextObject(0, attackerList, defenderList, out outCombatObject, out outCombatGroup, out foundInGroup);
result.Should().Be(true);
outCombatObject.Should().Be(defenderObject1);
((object)outCombatGroup).Should().Be(defenderGroup1);
foundInGroup.Should().Be(BattleManager.BattleSide.Defense);
}
public override void Execute()
{
parentMenu.gameObject.SetActive(false);
Debug.Log("Move! - " + combatant);
BattleOrder order = new BattleOrder();
order.Action = "move";
order.SourceCombatant = combatant;
MapManager map = GameObject.FindGameObjectWithTag("Map").GetComponent <MapManager>();
//List<Tile> tiles = map.GetTilesInRange(combatant.Tile, combatant.Stats.Movement, false);
List <Tile> tiles = map.GetTilesInRangeThreadsafe(combatant.Tile.TileData, combatant.Stats.Movement).ConvertAll(t => t.Tile);
tiles = TileUtility.FilterOutOccupiedTiles(tiles);
// TODO also maybe cache tilepicker results
GameObject objToSpawn = new GameObject("Tile Picker - Move");
objToSpawn.AddComponent <TilePicker>();
TilePicker tilePicker = objToSpawn.GetComponent <TilePicker>();
tilePicker.SetTileParamsMove(combatant);
//tilePicker.SetTiles(tiles);
tilePicker.battleStateTracker.previous = this.parentMenu.battleStateTracker;
tilePicker.SetBattleOrder(order);
parentMenu.CleanUp();
}
public void Enact(BattleOrder battleOrder)
{
this.battleOrder = battleOrder;
Debug.Log("woah battle order!" + battleOrder);
if ("attack".Equals(battleOrder.Action))
{
battleOrder.SourceCombatant.Stats.TurnStats.ConsumeAttack();
battleOrder.SourceCombatant.StartAttackAnimation(battleOrder.TargetTile);
state = State.ATTACKING;
//TODO shuffle this somewhere else
ApplyDamage();
}
else if ("move".Equals(battleOrder.Action))
{
battleOrder.SourceCombatant.Stats.TurnStats.ConsumeMovement();
MapManager map = GameObject.FindGameObjectWithTag("Map").GetComponent <MapManager>();
// TODO clean up
tilePath = map.GetShortestPathThreadsafe(battleOrder.SourceCombatant.Tile.TileData,
battleOrder.TargetTile.TileData, TeamId.EnemyTeam).ConvertAll(t => t.Tile);
previousHop = tilePath[0];
nextHop = tilePath[0];
state = State.MOVING;
}
else if ("endturn".Equals(battleOrder.Action))
{
battleOrder.SourceCombatant.Stats.TurnStats.EndTurn();
state = State.FINISHED;
}
}
public void ExecuteTurn_WhenDoesNotHaveObjectsInCurrentRoundAndGroupRandomReturns0AndFirstGroupIsEmpty_ShouldReturnObjectFromSecondGroup(
[Frozen] IBattleRandom battleRandom,
BattleOrder battleOrder)
{
// 999 controls order to be defense
// 0 is the to always return first obj and first group
battleRandom.Next(Arg.Any <int>()).Returns(999, 0);
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var attackerObject = CreateCombatObject(round: 1);
var attackerGroup = CreateGroup(attackerObject);
var attackerList = CreateList(upkeepNotParticipated: 1, combatGroups: attackerGroup);
var defenderGroup1 = CreateGroup();
var defenderObject2 = CreateCombatObject(round: 1);
var defenderGroup2 = CreateGroup(defenderObject2);
var defenderList = CreateList(upkeepNotParticipated: 999, combatGroups: new [] { defenderGroup1, defenderGroup2 });
var result = battleOrder.NextObject(0, attackerList, defenderList, out outCombatObject, out outCombatGroup, out foundInGroup);
result.Should().Be(false);
outCombatObject.Should().Be(defenderObject2);
((object)outCombatGroup).Should().Be(defenderGroup2);
foundInGroup.Should().Be(BattleManager.BattleSide.Defense);
}
public void ExecuteTurn_WhenDoesNotHaveObjectsInCurrentRoundAndGroupRandomReturns0AndObjectRandomReturns1_ShouldReturnSecondObjectFromFirstGroup(
[Frozen] IBattleRandom battleRandom,
BattleOrder battleOrder)
{
// 999 controls order to be defense
// 0 is the first group idx
// 1 is the second combat obj idx
// 1 is the random obj after we've found no objects are in the current round
// 0 is going to be when looking into the attacker list (for group and obj) after it didnt find a defense
battleRandom.Next(Arg.Any <int>()).Returns(999, 0, 1, 1, 0);
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var attackerObject = CreateCombatObject(round: 1);
var attackerGroup = CreateGroup(attackerObject);
var attackerList = CreateList(upkeepNotParticipated: 1, combatGroups: attackerGroup);
var defenderObject1 = CreateCombatObject(round: 1);
var defenderObject2 = CreateCombatObject(round: 1);
var defenderGroup = CreateGroup(defenderObject1, defenderObject2);
var defenderList = CreateList(upkeepNotParticipated: 999, combatGroups: defenderGroup);
var result = battleOrder.NextObject(0, attackerList, defenderList, out outCombatObject, out outCombatGroup, out foundInGroup);
result.Should().Be(false);
outCombatObject.Should().Be(defenderObject2);
((object)outCombatGroup).Should().Be(defenderGroup);
foundInGroup.Should().Be(BattleManager.BattleSide.Defense);
}
public void BeginTask(BattleOrder order)
{
_order = order;
_selectUnits = new List <int>();
switch (_unitType)
{
case TaskUnitType.Self:
{
bFinish = true;
BattleProcedure.CurSession.Field.FindUnit(BattleProcedure.CurSession.CurSelectUid).SetSelected(true);
_selectUnits.Add(BattleProcedure.CurSession.CurSelectUid);
_order.units.Add(BattleProcedure.CurSession.CurSelectUid);
break;
}
case TaskUnitType.Friend:
{
break;
}
case TaskUnitType.Enemy:
{
GestureManager.Instance.ClickAction += OnClick;
break;
}
default:
return;
}
}
public void NextObject_WhenCalled_CorrectAttackerIsReturned(int randomness, int attackerUpkeep, int defenderUpkeep, BattleManager.BattleSide side)
{
var random = Substitute.For <IBattleRandom>();
random.Next(Arg.Any <int>()).Returns(randomness);
BattleOrder battleOrder = new BattleOrder(random);
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var attackerObject = CreateCombatObject(0);
var attackerGroup = CreateGroup(attackerObject);
var attackerList = CreateList(attackerUpkeep, attackerGroup);
var defenderObject = CreateCombatObject(0);
var defenderGroup = CreateGroup(defenderObject);
var defenderList = CreateList(defenderUpkeep, defenderGroup);
var result = battleOrder.NextObject(0, attackerList, defenderList, out outCombatObject, out outCombatGroup, out foundInGroup);
result.Should().Be(true);
outCombatObject.Should().Be(side == BattleManager.BattleSide.Attack ? attackerObject : defenderObject);
foundInGroup.Should().Be(side);
random.Received(1).Next(defenderUpkeep + attackerUpkeep);
}
public override void Execute()
{
parentMenu.gameObject.SetActive(false);
Debug.Log("Move! - " + combatant);
BattleOrder order = new BattleOrder();
order.Action = "move";
order.SourceCombatant = combatant;
MapManager map = GameObject.FindGameObjectWithTag("Map").GetComponent<MapManager>();
//List<Tile> tiles = map.GetTilesInRange(combatant.Tile, combatant.Stats.Movement, false);
List<Tile> tiles = map.GetTilesInRangeThreadsafe(combatant.Tile.TileData, combatant.Stats.Movement).ConvertAll(t => t.Tile);
tiles = TileUtility.FilterOutOccupiedTiles(tiles);
// TODO also maybe cache tilepicker results
GameObject objToSpawn = new GameObject("Tile Picker - Move");
objToSpawn.AddComponent<TilePicker>();
TilePicker tilePicker = objToSpawn.GetComponent<TilePicker>();
tilePicker.SetTileParamsMove(combatant);
//tilePicker.SetTiles(tiles);
tilePicker.battleStateTracker.previous = this.parentMenu.battleStateTracker;
tilePicker.SetBattleOrder(order);
parentMenu.CleanUp();
}
public void StopInputJob()
{
if (_curOrder != null)
{
_curOrder.StopTask();
_curOrder = null;
}
}
public void SetBattleOrder(BattleOrder order, bool autoConfirm)
{
this.order = order;
order.TargetTile.OnCursorOver();
SetupCharacterPanes();
this.autoConfirm = autoConfirm;
}
public void SetBattleOrder(BattleOrder order, bool autoConfirm)
{
this.order = order;
order.TargetTile.OnCursorOver();
SetupCharacterPanes();
this.autoConfirm = autoConfirm;
}
public void OnEnter(FSMContext context)
{
_fsm = context.FSM;
SetReady(false);
paramList = BattleProcedure.CurSession.CurPlayReq.Cast <List <LuaTable> >();
playOrder = BattleProcedure.CurSession.OrderController.TakeInputJob(paramList);
EventManager.Instance.On(EventConst.ON_QUIT_PALYCARD, OnQuitPlayCard);
}
public void Populate(BattleOrder order)
{
this.order = order;
actionText.text = order.Action;
if (order.TargetTile.GetOccupant() != null && !order.TargetTile.GetOccupant().Stats.HasStatus("dead")) {
CombatantStats stats = order.SourceCombatant.Stats;
damageText.text = " " + stats.AttackPower + " Dmg \n " + stats.Accuracy + " % Acc";
} else {
damageText.text = "-/-";
}
}
private void SetReady(bool value)
{
if (bReady == value)
{
return;
}
bReady = value;
BattleOrder order = value ? playOrder : null;
BattleProcedure.CurLuaSession.UpdateReadyOrder(bReady, order);
}
public override void Execute()
{
Debug.Log("end turn!");
BattleOrder order = new BattleOrder();
order.SourceCombatant = parentMenu.Combatant;
order.Action = "endturn";
GameObject enactor = new GameObject("BattleOrderEnactor Action");
enactor.AddComponent<BattleOrderEnactor>();
enactor.GetComponent<BattleOrderEnactor>().battleStateTracker.previous = this.parentMenu.battleStateTracker;
enactor.GetComponent<BattleOrderEnactor>().Enact(order);
parentMenu.CleanUp();
}
public void Populate(BattleOrder order)
{
this.order = order;
actionText.text = order.Action;
if (order.TargetTile.GetOccupant() != null && !order.TargetTile.GetOccupant().Stats.HasStatus("dead"))
{
CombatantStats stats = order.SourceCombatant.Stats;
damageText.text = " " + stats.AttackPower + " Dmg \n " + stats.Accuracy + " % Acc";
}
else
{
damageText.text = "-/-";
}
}
public override void Execute()
{
Debug.Log("end turn!");
BattleOrder order = new BattleOrder();
order.SourceCombatant = parentMenu.Combatant;
order.Action = "endturn";
GameObject enactor = new GameObject("BattleOrderEnactor Action");
enactor.AddComponent <BattleOrderEnactor>();
enactor.GetComponent <BattleOrderEnactor>().battleStateTracker.previous = this.parentMenu.battleStateTracker;
enactor.GetComponent <BattleOrderEnactor>().Enact(order);
parentMenu.CleanUp();
}
public BattleOrder TakeInputJob(List <LuaTable> taskTable)
{
_curOrder = new BattleOrder();
_curOrder.type = OrderType.Play;
_curOrder.bFinish = false;
_curOrder.tasks = new List <IInputTask>();
for (int i = 0; i < taskTable.Count; ++i)
{
InputTaskType taskType = (InputTaskType)taskTable[i].Get <int>("taskType");
var task = CreateTask(taskType);
task.InjectData(taskTable[i]);
_curOrder.tasks.Add(task);
}
return(_curOrder);
}
public void Calculate()
{
Debug.Log("Creating AI Order...");
if (!combatant.Stats.TurnStats.HasAITurnPlan())
{
Debug.Log("Creating turn plan...");
combatant.Stats.TurnStats.AITurnPlan = CreateTurnPlan();
combatant.Stats.TurnStats.AITurnPlan.map = map;
Debug.Log("finished creating turn plan: " + combatant.Stats.TurnStats.AITurnPlan.TurnPlan);
}
Debug.Log("Onto exection of plan...");
// Execute Plan
this.BattleOrder = combatant.Stats.TurnStats.AITurnPlan.CreateNextBattleOrder();
isDone = true;
}
public BattleOrder CreateNextBattleOrder()
{
actionsTaken = actionsTaken + 1;
BattleOrder battleOrder = new BattleOrder();
battleOrder.SourceCombatant = combatant;
switch (this.TurnPlan) {
case Plan.MOVE_AND_ATTACK:
if (actionsTaken == 1) {
battleOrder.Action = "move";
battleOrder.TargetTile = FurthestValidTile(this.Destination).Tile;
} else if (actionsTaken == 2) {
battleOrder.Action = "attack";
battleOrder.TargetTile = this.Target.Tile;
}
return battleOrder;
case Plan.ATTACK_AND_BACK_OFF:
if (actionsTaken == 1) {
battleOrder.Action = "attack";
battleOrder.TargetTile = this.Target.Tile;
} else if (actionsTaken == 2) {
battleOrder.Action = "endturn";
}
return battleOrder;
case Plan.MOVE_AND_END_TURN:
if (actionsTaken == 1) {
battleOrder.Action = "move";
battleOrder.TargetTile = FurthestValidTile(this.Destination).Tile;
} else if (actionsTaken == 2) {
battleOrder.Action = "endturn";
}
return battleOrder;
case Plan.ATTACK_AND_END_TURN:
if (actionsTaken == 1) {
battleOrder.Action = "attack";
battleOrder.TargetTile = this.Target.Tile;
} else if (actionsTaken == 2) {
battleOrder.Action = "endturn";
}
return battleOrder;
case Plan.END_TURN:
battleOrder.Action = "endturn";
return battleOrder;
default:
return null;
}
}
public void ExecuteTurn_WhenGroupsAreEmpty_ShouldReturnTrueAndNullObjAndNullGroup(
BattleOrder battleOrder)
{
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var attackerList = CreateList(upkeepNotParticipated: 0, combatGroups: CreateGroup());
var defenderList = CreateList(upkeepNotParticipated: 0, combatGroups: CreateGroup());
var result = battleOrder.NextObject(0, attackerList, defenderList, out outCombatObject, out outCombatGroup, out foundInGroup);
result.Should().Be(true);
outCombatObject.Should().BeNull();
((object)outCombatGroup).Should().BeNull();
}
/// <summary>
/// 普攻受击伤害
/// </summary>
/// <param name="battleOrder"></param>
public void OnDamageTaken(BattleOrder battleOrder)
{
if (this.isDead)
{
return;
}
//类似 闪避 免疫功能的实现
//if (blMissGongBing && (battleOrder.attacker.playInfo.armyID / 10) % 10 == 3)
//{
// //AddHUDText("免疫", eScoreFlashType.Common);
// AddHUDText("Icon/Skill/SkillHudTag/免疫", eScoreFlashType.SkillUp);
// return;
//}
if (Damage(battleOrder.damageInfo.damage, battleOrder.target.position, battleOrder.damageInfo.alignment))
{
battleOrder.target = null;
}
}
public void BeginTask(BattleOrder order)
{
_order = order;
switch (_type)
{
case TaskPathType.WalkPath:
{
_uid = _order.units[_order.units.Count - 1];
CameraManager.Instance.FocusUnit(_uid);
GestureManager.Instance.ClickAction += OnClick;
GestureManager.Instance.LongPressBeginAction += OnBeginPress;
GestureManager.Instance.LongPressAction += OnPressMove;
GestureManager.Instance.LongPressEndAction += OnEndPress;
BattleProcedure.CurSession.Map.ShowUnitMovableRegion(_uid, true, _count);
break;
}
default:
return;
}
}
public void TestNoMoreAttacker(BattleOrder battleOrder)
{
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var attackerObject = CreateCombatObject(1);
var attackerList = CreateList(0, CreateGroup(attackerObject));
attackerList.UpkeepNotParticipatedInRound(1).Returns(1);
var defenderList = CreateList(0, CreateGroup(CreateCombatObject(1)));
defenderList.UpkeepNotParticipatedInRound(1).Returns(0);
battleOrder.NextObject(0,
attackerList,
defenderList,
out outCombatObject,
out outCombatGroup,
out foundInGroup).Should().Be(false);
foundInGroup.Should().Be(BattleManager.BattleSide.Attack);
outCombatObject.Should().Be(attackerObject);
}
public override void Execute()
{
parentMenu.gameObject.SetActive(false);
Debug.Log("attack! - " + combatant);
BattleOrder order = new BattleOrder();
order.Action = "attack";
order.SourceCombatant = combatant;
MapManager map = GameObject.FindGameObjectWithTag("Map").GetComponent<MapManager>();
//List<Tile> tiles = map.GetTilesInRange(combatant.Tile, 1, true);
List<Tile> tiles = map.GetTilesInRangeThreadsafe(combatant.Tile.TileData, 1, TeamId.MOVE_THROUGH_ALL)
.ConvertAll(t => t.Tile);
tiles.Remove(combatant.Tile);
GameObject objToSpawn = new GameObject("Tile Picker - Attack");
objToSpawn.AddComponent<TilePicker>();
TilePicker tilePicker = objToSpawn.GetComponent<TilePicker>();
tilePicker.SetTiles(tiles);
tilePicker.battleStateTracker.previous = this.parentMenu.battleStateTracker;
tilePicker.SetBattleOrder(order);
parentMenu.CleanUp();
}
public void SetBattleOrder(BattleOrder order)
{
this.SetBattleOrder(order, false);
}
public void NextObject_WhenNextObjectShouldBeAttackerAndNotAttackersLeft_ShouldChooseDefense(BattleOrder battleOrder)
{
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var expectedObject = CreateCombatObject(0);
var expectedGroup = CreateGroup(CreateCombatObject(1), expectedObject, CreateCombatObject(0));
battleOrder.NextObject(0,
CreateList(1, CreateGroup(CreateCombatObject(1))),
CreateList(1, expectedGroup),
out outCombatObject,
out outCombatGroup,
out foundInGroup).Should().Be(true);
outCombatObject.Should().Be(expectedObject);
foundInGroup.Should().Be(BattleManager.BattleSide.Defense);
}
public void SetBattleOrder(BattleOrder battleOrder)
{
this.battleOrder = battleOrder;
}
public void NextObject_WhenNextObjectIsWaitingToJoinBattleIsTrue_ShouldNotChooseThatObject(BattleOrder battleOrder)
{
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var expectedObject = CreateCombatObject(0);
var isStillWaitingToJoinbattleCombatObject = CreateCombatObject(0);
isStillWaitingToJoinbattleCombatObject.IsWaitingToJoinBattle.Returns(true);
var result = battleOrder.NextObject(0,
CreateList(1, CreateGroup(isStillWaitingToJoinbattleCombatObject, expectedObject)),
CreateList(1, CreateGroup(CreateCombatObject(1))),
out outCombatObject,
out outCombatGroup,
out foundInGroup);
result.Should().Be(true);
outCombatObject.Should().Be(expectedObject);
foundInGroup.Should().Be(BattleManager.BattleSide.Attack);
}
public void NextObject_WhenNextObjectShouldBeDefenderAndNoDefendersAreLeftInTheRound_ShouldChooseAttacker(BattleOrder battleOrder)
{
ICombatObject outCombatObject;
ICombatGroup outCombatGroup;
BattleManager.BattleSide foundInGroup;
var expectedObject = CreateCombatObject(0);
var result = battleOrder.NextObject(0,
CreateList(1, CreateGroup(CreateCombatObject(1), expectedObject, CreateCombatObject(0))),
CreateList(1, CreateGroup(CreateCombatObject(1))),
out outCombatObject,
out outCombatGroup,
out foundInGroup);
result.Should().Be(true);
outCombatObject.Should().Be(expectedObject);
foundInGroup.Should().Be(BattleManager.BattleSide.Attack);
}
public void SetBattleOrder(BattleOrder battleOrder)
{
this.battleOrder = battleOrder;
}
public BattleOrder CreateNextBattleOrder()
{
actionsTaken = actionsTaken + 1;
BattleOrder battleOrder = new BattleOrder();
battleOrder.SourceCombatant = combatant;
switch (this.TurnPlan)
{
case Plan.MOVE_AND_ATTACK:
if (actionsTaken == 1)
{
battleOrder.Action = "move";
battleOrder.TargetTile = FurthestValidTile(this.Destination).Tile;
}
else if (actionsTaken == 2)
{
battleOrder.Action = "attack";
battleOrder.TargetTile = this.Target.Tile;
}
return(battleOrder);
case Plan.ATTACK_AND_BACK_OFF:
if (actionsTaken == 1)
{
battleOrder.Action = "attack";
battleOrder.TargetTile = this.Target.Tile;
}
else if (actionsTaken == 2)
{
battleOrder.Action = "endturn";
}
return(battleOrder);
case Plan.MOVE_AND_END_TURN:
if (actionsTaken == 1)
{
battleOrder.Action = "move";
battleOrder.TargetTile = FurthestValidTile(this.Destination).Tile;
}
else if (actionsTaken == 2)
{
battleOrder.Action = "endturn";
}
return(battleOrder);
case Plan.ATTACK_AND_END_TURN:
if (actionsTaken == 1)
{
battleOrder.Action = "attack";
battleOrder.TargetTile = this.Target.Tile;
}
else if (actionsTaken == 2)
{
battleOrder.Action = "endturn";
}
return(battleOrder);
case Plan.END_TURN:
battleOrder.Action = "endturn";
return(battleOrder);
default:
return(null);
}
}
public void SetBattleOrder(BattleOrder order)
{
this.SetBattleOrder(order, false);
}
