public void triggerEncounter(int index)
{
// if (PlayerData.getInstance().bg[index].isFinished) {
// return;
// }
EncounterState es = PlayerData.getInstance().grids [index / GRID_WIDTH] [index % GRID_WIDTH];
if (es.isFinish)
{
return;
}
//Debug.Log (PlayerData.getInstance ().grids [index / GRID_WIDTH] [index % GRID_WIDTH].eid);
if (es.eid == "shop")
{
GameManager.getInstance().enterShop();
}
else
{
GameManager.getInstance().sbManager.initEncounter(es.eid);
}
PlayerData.getInstance().grids[index / GRID_WIDTH] [index % GRID_WIDTH].isFinish = true;
grids[index].reveal();
}
private static bool PlayerSeesEnemies(EncounterState state)
{
return(state.FoVCache.VisibleCells
.Select(cell => state.EntitiesAtPosition(cell.X, cell.Y))
.Any(entitiesAtPosition => entitiesAtPosition.Any(e => e.GetComponent <AIComponent>() != null &&
!(e.GetComponent <PathAIComponent>() is PathAIComponent))));
}
public static List <EncounterAction> ActionsForUnitReform(EncounterState state, Entity parent, int formationNumber, Unit unit)
{
var actions = new List <EncounterAction>();
var parentPos = parent.GetComponent <PositionComponent>().EncounterPosition;
var playerPos = state.Player.GetComponent <PositionComponent>().EncounterPosition;
var targetPosition = AIUtils._DecideFormationPosition(formationNumber, playerPos, unit);
if (parentPos != targetPosition)
{
// TODO: We may want to make pathfinding stateful/cache it or something, to save on turn times
var path = Pathfinder.AStarWithNewGrid(parentPos, targetPosition, state);
if (path != null)
{
actions.Add(new MoveAction(parent.EntityId, path[0]));
}
else
{
actions.Add(new WaitAction(parent.EntityId));
}
}
else
{
actions.Add(new WaitAction(parent.EntityId));
}
return(actions);
}
public void SetReadout(EncounterState state, EncounterZone zone, bool hasIntel)
{
GetNode <Label>("ReadoutContainer/NameEncounterBar/ZoneNameLabel").Text = zone.ZoneName;
if (hasIntel)
{
GetNode <Label>("ReadoutContainer/NameEncounterBar/ZoneEncounterLabel").Text = zone.ReadoutEncounterName;
}
else
{
GetNode <Label>("ReadoutContainer/NameEncounterBar/ZoneEncounterLabel").Text = "NO INTEL";
}
var itemsBar = GetNode <HBoxContainer>("ReadoutContainer/ItemsFeaturesBar");
if (hasIntel)
{
var itemsTextureSize = itemsBar.RectSize.y;
foreach (var itemReadout in zone.ReadoutItems)
{
if (state.GetEntityById(itemReadout.EntityId) != null)
{
itemsBar.AddChild(BuildTextureRect(itemReadout.TexturePath, itemsTextureSize));
}
else
{
itemsBar.AddChild(BuildTextureRect("res://resources/checkmark_18x18.png", itemsTextureSize));
}
}
}
else
{
var noIntelLabel = new Label();
noIntelLabel.Text = "-?-";
itemsBar.AddChild(noIntelLabel);
}
var featuresBar = GetNode <HBoxContainer>("ReadoutContainer/ItemsFeaturesBar");
if (hasIntel)
{
var featuresTextureSize = featuresBar.RectSize.y;
foreach (var featureReadout in zone.ReadoutFeatures)
{
if (state.GetEntityById(featureReadout.EntityId) != null)
{
featuresBar.AddChild(BuildTextureRect(featureReadout.TexturePath, featuresTextureSize));
}
else
{
featuresBar.AddChild(BuildTextureRect("res://resources/checkmark_18x18.png", featuresTextureSize));
}
}
}
else
{
var noIntelLabel = new Label();
noIntelLabel.Text = "-?-";
featuresBar.AddChild(noIntelLabel);
}
}
public static bool TryParse(string value, out EncounterState result)
{
result = default(EncounterState);
if (value == "planned")
{
result = EncounterState.Planned;
}
else if (value == "current")
{
result = EncounterState.Current;
}
else if (value == "onleave")
{
result = EncounterState.Onleave;
}
else if (value == "finished")
{
result = EncounterState.Finished;
}
else if (value == "cancelled")
{
result = EncounterState.Cancelled;
}
else
{
return(false);
}
return(true);
}
public override List <EncounterAction> _DecideNextAction(EncounterState state, Entity parent)
{
var unit = state.GetUnit(parent.GetComponent <UnitComponent>().UnitId);
var unitComponent = parent.GetComponent <UnitComponent>();
if (unit.StandingOrder == UnitOrder.REFORM)
{
if (state.CurrentTurn < EncounterStateBuilder.ADVANCE_AT_TURN)
{
if (state.EncounterRand.Next(750) == 0)
{
parent.GetComponent <PositionComponent>().PlaySpeechBubble(Quips[state.EncounterRand.Next(Quips.Length)]);
}
}
return(AIUtils.ActionsForUnitReform(state, parent, unitComponent.FormationNumber, unit));
}
else if (unit.StandingOrder == UnitOrder.ADVANCE)
{
return(AIUtils.ActionsForUnitAdvanceInLine(state, parent, unit));
}
else if (unit.StandingOrder == UnitOrder.ROUT)
{
return(AIUtils.ActionsForUnitRetreat(state, parent, unit));
}
else
{
throw new NotImplementedException();
}
}
private void PrepIntelColumn(EncounterState state)
{
var playerComponent = state.Player.GetComponent <PlayerComponent>();
var intelColumn = GetNode <VBoxContainer>("Columns/IntelColumn");
if (_intelLabels == null)
{
_intelLabels = new List <Label>();
for (int i = 1; i < state.LevelsInDungeon; i++)
{
var font = new DynamicFont();
font.FontData = (DynamicFontData)GD.Load(_fontPath);
var newLabel = new Label();
newLabel.AddFontOverride("font", font);
intelColumn.AddChild(newLabel);
_intelLabels.Add(newLabel);
newLabel.Text = string.Format("Sector {0}: {1}", i, playerComponent.KnowsIntel(i) ? "KNOWN" : "UNKNOWN");
}
}
else
{
for (int i = 1; i < state.LevelsInDungeon; i++)
{
_intelLabels[i - 1].Text = string.Format("Sector {0}: {1}", i, playerComponent.KnowsIntel(i) ? "KNOWN" : "UNKNOWN");
}
}
}
void UpdateMinionState(Creature minion, EncounterState state)
{
switch (state)
{
case EncounterState.NotStarted:
if (!minion.IsAlive())
{
minion.Respawn();
}
else if (minion.IsInCombat())
{
minion.GetAI().EnterEvadeMode();
}
break;
case EncounterState.InProgress:
if (!minion.IsAlive())
{
minion.Respawn();
}
else if (minion.GetVictim() == null)
{
minion.GetAI().DoZoneInCombat();
}
break;
default:
break;
}
}
public override bool SetBossState(uint type, EncounterState state)
{
if (!base.SetBossState(type, state))
{
return(false);
}
switch (type)
{
case DataTypes.JedogaShadowseeker:
if (state == EncounterState.Done)
{
foreach (ObjectGuid guid in InitiandGUIDs)
{
Creature cr = instance.GetCreature(guid);
if (cr)
{
cr.DespawnOrUnsummon();
}
}
}
break;
default:
break;
}
return(true);
}
private static bool ResolveMove(MoveAction action, EncounterState state)
{
Entity actor = state.GetEntityById(action.ActorId);
var positionComponent = state.GetEntityById(action.ActorId).GetComponent <PositionComponent>();
var oldPosition = positionComponent.EncounterPosition;
if (positionComponent.EncounterPosition == action.TargetPosition)
{
GD.PrintErr(string.Format("Entity {0}:{1} tried to move to its current position {2}", actor.EntityName, actor.EntityId, action.TargetPosition));
return(false);
}
else
{
state.TeleportEntity(actor, action.TargetPosition, ignoreCollision: false);
var unitComponent = actor.GetComponent <UnitComponent>();
if (unitComponent != null)
{
state.GetUnit(unitComponent.UnitId).NotifyEntityMoved(oldPosition, action.TargetPosition);
}
// If you go into the retreat zone you insta-die
if (IsInRetreatZone(state, action.TargetPosition))
{
if (actor.GetComponent <PlayerComponent>() != null)
{
state.NotifyPlayerRetreat();
return(false);
}
else
{
ResolveAction(new DestroyAction(action.ActorId), state);
}
}
return(true);
}
}
public override List <EncounterAction> _DecideNextAction(EncounterState state, Entity parent)
{
var actions = new List <EncounterAction>();
var parentPos = parent.GetComponent <PositionComponent>().EncounterPosition;
var playerPos = state.Player.GetComponent <PositionComponent>().EncounterPosition;
// Always attempt to close distance
var path = Pathfinder.AStarWithNewGrid(parentPos, playerPos, state);
if (path != null)
{
actions.Add(new MoveAction(parent.EntityId, path[0]));
}
// Fire reverser + cannon every 3rd turn, and shotgun + secondary batteries otherwise
if (this.CurrentReverserCooldown == 0)
{
actions.Add(FireProjectileAction.CreateReverserAction(parent.EntityId, playerPos));
actions.Add(FireProjectileAction.CreateSmallCannonAction(parent.EntityId, playerPos));
this.CurrentReverserCooldown += ReverserCooldown;
}
else
{
actions.Add(FireProjectileAction.CreateSmallCannonAction(parent.EntityId, playerPos));
actions.Add(FireProjectileAction.CreateSmallCannonAction(parent.EntityId, playerPos));
actions.AddRange(FireProjectileAction.CreateSmallShotgunAction(parent.EntityId, playerPos, numPellets: 2, spread: 3, state.EncounterRand));
if (this.CurrentReverserCooldown > 0)
{
this.CurrentReverserCooldown -= 1;
}
}
return(actions);
}
public override List <EncounterAction> _DecideNextAction(EncounterState state, Entity parent)
{
var actions = new List <EncounterAction>();
var parentPos = parent.GetComponent <PositionComponent>().EncounterPosition;
var playerPos = state.Player.GetComponent <PositionComponent>().EncounterPosition;
// Always attempt to close distance
var path = Pathfinder.AStarWithNewGrid(parentPos, playerPos, state);
if (path != null)
{
actions.Add(new MoveAction(parent.EntityId, path[0]));
}
// Fire comically dense & inaccurate shotgun volley every 4 turns, and shotgun otherwise
if (this.CurrentVolleyCooldown == 0)
{
actions.AddRange(FireProjectileAction.CreateSmallShotgunAction(parent.EntityId, playerPos, numPellets: 30, spread: 7, state.EncounterRand));
actions.Add(FireProjectileAction.CreateSmallCannonAction(parent.EntityId, playerPos));
this.CurrentVolleyCooldown += VolleyCooldown;
}
else
{
actions.AddRange(FireProjectileAction.CreateSmallShotgunAction(parent.EntityId, playerPos, numPellets: 2, spread: 1, state.EncounterRand));
if (this.CurrentVolleyCooldown > 0)
{
this.CurrentVolleyCooldown -= 1;
}
}
return(actions);
}
public static string ToString(EncounterState value)
{
if (value == EncounterState.Planned)
{
return("planned");
}
else if (value == EncounterState.Current)
{
return("current");
}
else if (value == EncounterState.Onleave)
{
return("onleave");
}
else if (value == EncounterState.Finished)
{
return("finished");
}
else if (value == EncounterState.Cancelled)
{
return("cancelled");
}
else
{
throw new ArgumentException("Unrecognized EncounterState value: " + value.ToString());
}
}
private static bool ResolveDestroy(DestroyAction action, EncounterState state)
{
Entity entity = state.GetEntityById(action.ActorId);
var onDeathComponent = entity.GetComponent <OnDeathComponent>();
// this 'shouldRemoveEntity' code is slightly confusing, simplify it if you come back to it
bool shouldRemoveEntity = true;
if (onDeathComponent != null)
{
foreach (var effectType in onDeathComponent.ActiveEffectTypes)
{
var effectStopsRemoval = !ResolveOnDeathEffect(effectType, state);
if (effectStopsRemoval)
{
shouldRemoveEntity = false;
}
}
}
if (shouldRemoveEntity)
{
state.RemoveEntity(entity);
return(true);
}
else
{
return(false);
}
}
public void PrepMenu(EncounterState state)
{
PrepLevelColumn(state);
PrepStatsColumn(state);
PrepIntelColumn(state);
PrepLevelUpMenu(state);
}
private static bool ResolveAutopilotBeginTravel(AutopilotBeginAction action, EncounterState state)
{
var playerPosition = state.Player.GetComponent <PositionComponent>().EncounterPosition;
EncounterZone zone = state.GetZoneById(action.ZoneId);
var foundPath = Pathfinder.AStarWithNewGrid(playerPosition, zone.Center, state, 9000);
int autopilotTries = 0;
while (foundPath == null && autopilotTries < 5)
{
foundPath = Pathfinder.AStarWithNewGrid(playerPosition, zone.RandomEmptyPosition(state.EncounterRand, state), state, 9000);
autopilotTries++;
}
if (foundPath != null && autopilotTries > 0)
{
state.LogMessage(String.Format("Autopilot could not find path to center of [b]{0}[/b]; autopiloting to randomly chosen position in [b]{0}[/b].", zone.ZoneName));
state.Player.GetComponent <PlayerComponent>().LayInAutopilotPathForTravel(new EncounterPath(foundPath));
return(true);
}
else if (foundPath != null)
{
state.LogMessage(String.Format("Autopiloting to [b]{0}[/b]", zone.ZoneName));
state.Player.GetComponent <PlayerComponent>().LayInAutopilotPathForTravel(new EncounterPath(foundPath));
return(true);
}
else
{
state.LogMessage(String.Format("Autopilot failed to plot course to to [b]{0}[/b]", zone.ZoneName), failed: true);
return(false);
}
}
// TODO: Maybe show level history?
private void PrepLevelColumn(EncounterState state)
{
var playerXPTracker = state.Player.GetComponent <XPTrackerComponent>();
GetNode <Label>("Columns/LevelColumn/LevelLabel").Text = string.Format("Level: {0}", playerXPTracker.Level);
GetNode <Label>("Columns/LevelColumn/ExperienceLabel").Text = string.Format("Experience: {0} / {1}", playerXPTracker.XP, playerXPTracker.NextLevelAtXP);
}
public void PrepMenu(EncounterState state)
{
this._mainMenuBotton.GrabFocus();
this._state = state;
var playerComponent = state.Player.GetComponent <PlayerComponent>();
Label prestigeTotalLabel = GetNode <Label>("PrestigeTotalLabel");
prestigeTotalLabel.Text = String.Format("You have fallen with {0} prestige.", playerComponent.Prestige);
Label prestigeVictoriesLabel = GetNode <Label>("PrestigeVictoriesLabel");
prestigeVictoriesLabel.Text = String.Format("You gained {0} prestige from your victories in battle.", playerComponent.PrestigeFrom(PrestigeSource.VICTORIES));
Label prestigeDefeatingFoesLabel = GetNode <Label>("PrestigeDefeatingFoesLabel");
prestigeDefeatingFoesLabel.Text = String.Format("You gained {0} prestige from defeating foes.", playerComponent.PrestigeFrom(PrestigeSource.DEFEATING_FOES));
Label prestigeLandingHitsLabel = GetNode <Label>("PrestigeLandingHitsLabel");
prestigeLandingHitsLabel.Text = String.Format("You gained {0} prestige from landing hits on foes.", playerComponent.PrestigeFrom(PrestigeSource.LANDING_HITS));
Label prestigeRotatingLabel = GetNode <Label>("PrestigeRotatingLabel");
prestigeRotatingLabel.Text = String.Format("You lost {0} prestige from rotating to the rear.", playerComponent.PrestigeFrom(PrestigeSource.ROTATING));
Label prestigeBreakingFormationLabel = GetNode <Label>("PrestigeBreakingFormationLabel");
prestigeBreakingFormationLabel.Text = String.Format("You lost {0} prestige from breaking formation.", playerComponent.PrestigeFrom(PrestigeSource.BREAKING_FORMATION));
Label prestigeFleeingLabel = GetNode <Label>("PrestigeFleeingLabel");
prestigeFleeingLabel.Text = String.Format("You lost {0} prestige from fleeing the battlefield.", playerComponent.PrestigeFrom(PrestigeSource.FLEEING));
}
private void PrepLevelUpMenu(EncounterState state)
{
var playerXPTracker = state.Player.GetComponent <XPTrackerComponent>();
if (playerXPTracker.UnusedLevelUps.Count == 0)
{
GetNode <VBoxContainer>("LevelUpMenu").Visible = false;
_closeButton.Disabled = false;
_closeButton.GrabFocus();
return;
}
else
{
// Make appropriate elements visible
GetNode <VBoxContainer>("LevelUpMenu").Visible = true;
var playerDefender = state.Player.GetComponent <DefenderComponent>();
if (playerDefender.MaxHp > playerDefender.CurrentHp)
{
GetNode <Button>("LevelUpMenu/LevelUpColumns/LevelUpRepairSelection").Visible = true;
}
else
{
GetNode <Button>("LevelUpMenu/LevelUpColumns/LevelUpRepairSelection").Visible = false;
}
// Disable exit
GetNode <Button>("LevelUpMenu/LevelUpColumns/LevelUpHPSelection").GrabFocus();
_closeButton.Disabled = true;
}
}
public override List <EncounterAction> _DecideNextAction(EncounterState state, Entity parent)
{
var actions = new List <EncounterAction>();
var parentPos = parent.GetComponent <PositionComponent>().EncounterPosition;
var playerPos = state.Player.GetComponent <PositionComponent>().EncounterPosition;
// Close distance if further than 5
if (parentPos.DistanceTo(playerPos) >= 5f)
{
// PERF: We may want to make pathfinding stateful/cache it or something, to save on turn times
var path = Pathfinder.AStarWithNewGrid(parentPos, playerPos, state);
if (path != null)
{
actions.Add(new MoveAction(parent.EntityId, path[0]));
}
}
// Fire shotgun pellets=5, spread=5 every 4th turn, else fire single cannon (this is honestly a comical amount of spread though)
if (this.CurrentShotgunCooldown == 0)
{
actions.AddRange(FireProjectileAction.CreateSmallShotgunAction(parent.EntityId, playerPos, numPellets: 5, spread: 5, state.EncounterRand));
this.CurrentShotgunCooldown += this.ShotgunCooldown;
}
else
{
actions.Add(FireProjectileAction.CreateSmallCannonAction(parent.EntityId, playerPos));
if (this.CurrentShotgunCooldown > 0)
{
this.CurrentShotgunCooldown -= 1;
}
}
return(actions);
}
public virtual void Run(LogicBlock.LogicType type, RunPayload payload)
{
IEnumerable <LogicBlock> logicBlocks = EncounterLogic.Where(logic => logic.Type == type);
switch (type)
{
case LogicBlock.LogicType.RESOURCE_REQUEST:
State = EncounterState.RUNNING;
RunGeneralLogic(logicBlocks, payload);
break;
case LogicBlock.LogicType.CONTRACT_OVERRIDE_MANIPULATION:
RunGeneralLogic(logicBlocks, payload);
break;
case LogicBlock.LogicType.ENCOUNTER_MANIPULATION:
RunGeneralLogic(logicBlocks, payload);
break;
case LogicBlock.LogicType.SCENE_MANIPULATION:
RunSceneManipulationLogic(logicBlocks, payload);
MissionControl.Instance.IsMCLoadingFinished = true;
break;
default:
Main.Logger.LogError($"[EncounterRules] Unknown logic type '{type}'");
break;
}
}
// This is actually much more like unit broken but oh well!
public static List <EncounterAction> ActionsForUnitRetreat(EncounterState state, Entity parent, Unit unit)
{
var parentPos = parent.GetComponent <PositionComponent>().EncounterPosition;
EncounterPosition targetEndPos = parentPos;
var backwardsPositions = new List <EncounterPosition>()
{
AIUtils.RotateAndProject(parentPos, 0, 1, unit.UnitFacing),
AIUtils.RotateAndProject(parentPos, 1, 1, unit.UnitFacing),
AIUtils.RotateAndProject(parentPos, -1, 1, unit.UnitFacing),
};
GameUtils.Shuffle(state.EncounterRand, backwardsPositions);
foreach (var position in backwardsPositions)
{
if (state.EntitiesAtPosition(position.X, position.Y).Count == 0)
{
targetEndPos = position;
break;
}
}
if (targetEndPos == parentPos)
{
targetEndPos = backwardsPositions[0];
}
return(new List <EncounterAction>()
{
new MoveAction(parent.EntityId, targetEndPos)
});
}
private List <EncounterAction> MoveAndAttack(EncounterState state, int dx, int dy)
{
var positionComponent = state.Player.GetComponent <PositionComponent>();
var oldPos = positionComponent.EncounterPosition;
var newPos = new EncounterPosition(oldPos.X + dx, oldPos.Y + dy);
// TODO: maybe not hostile?
var hostiles = AIUtils.HostilesInPosition(state, FactionName.PLAYER, newPos.X, newPos.Y);
if (hostiles.Count > 0)
{
var attackAction = new MeleeAttackAction(state.Player.EntityId, hostiles[state.EncounterRand.Next(hostiles.Count)]);
return(new List <EncounterAction>()
{
attackAction
});
}
else
{
var moveAction = new MoveAction(state.Player.EntityId, newPos);
return(new List <EncounterAction>()
{
moveAction
});
}
}
public override List <EncounterAction> _DecideNextAction(EncounterState state, Entity parent)
{
return(new List <EncounterAction>()
{
new WaitAction(parent.EntityId)
});
}
private void TriggerContinue(EncounterState encounterState)
{
_encounterState = encounterState;
_battleActionListBox.Items.Clear();
_battleActionListBox.Items.Add(BattleActions.Continue);
}
public List <EncounterAction> DecideNextAction(EncounterState state, Entity parent)
{
if (this._DeploymentOrders.ContainsKey(this._CurrentTurn))
{
var deploymentOrders = this._DeploymentOrders[this._CurrentTurn];
foreach (var order in deploymentOrders)
{
order.ExecuteOrder(state);
}
if (this.LastDeploymentTurn == this._CurrentTurn)
{
this.DeploymentComplete = true;
}
}
else if (this.DeploymentComplete)
{
foreach (var kvp in this._TriggerOrders)
{
var unit = state.GetUnit(kvp.Key);
if (unit.StandingOrder == UnitOrder.ROUT)
{
continue;
}
var removeThese = new List <TriggeredOrder>();
var addThese = new List <TriggeredOrder>();
foreach (var triggeredOrder in kvp.Value)
{
if (triggeredOrder.Trigger.IsTriggered(state))
{
var newOrders = triggeredOrder.Order.ExecuteOrder(state);
if (newOrders != null)
{
addThese.AddRange(newOrders);
}
if (!triggeredOrder.Trigger.Repeating)
{
removeThese.Add(triggeredOrder);
}
}
}
foreach (var removeThis in removeThese)
{
kvp.Value.Remove(removeThis);
}
foreach (var addThis in addThese)
{
this.RegisterTriggeredOrder(addThis);
}
}
}
this._CurrentTurn += 1;
return(new List <EncounterAction>()
{
new WaitAction(parent.EntityId)
});
}
public Outro(EncounterState encounterState, Battle battle)
: base(battle)
{
Battle.OverworldEncounter.State = encounterState;
Logger.Log(battle.PlayerPartyItemsUsed.ToString() + " items were used");
BattleStateRenderer = new IntroOutroRenderer(this);
Time = FadeTimeInSeconds * (encounterState == EncounterState.Won ? (1.0f - WinRenderer.MaxOverlayAlpha) : 1.0f);
}
public RunEncounterStateViewModel(IAsyncServiceProvider serviceProvider, EncounterState state)
: base(serviceProvider)
{
State = state ?? throw new ArgumentNullException(nameof(state));
PlayCommand = new RelayCommand(OnPlay, CanPlay);
StopCommand = new RelayCommand(OnStop, CanStop);
Load();
}
void UmaDerrota()
{
InterrompeFluxoDeLuta();
inimigo.Estado = CreatureManager.CreatureState.parado;
apresentaDerrota = new ApresentaDerrota(manager, inimigo);
estado = EncounterState.morreuEmLuta;
GameController.g.HudM.MenuDeI.FinalizarHud();
}
public Outro(EncounterState encounterState, Battle battle)
: base(battle)
{
Battle.OverworldEncounter.State = encounterState;
Logger.Log(battle.PlayerPartyItemsUsed.ToString() + " items were used");
BattleStateRenderer = new IntroOutroRenderer(this);
Time = FadeTimeInSeconds * (encounterState == EncounterState.Won ? (1.0f - WinRenderer.MaxOverlayAlpha) : 1.0f);
}
public List <string> AllowedActions(EncounterState state, Entity parent, UnitOrder standingOrder)
{
var parentPos = parent.GetComponent <PositionComponent>().EncounterPosition;
var unit = state.GetUnit(parent.GetComponent <UnitComponent>().UnitId);
var actions = new List <string>();
var parentIsLagging = AIUtils.IsPositionTooFarBehind(parentPos, unit);
// TODO: this is a silly place to run this check
if (parentIsLagging)
{
parent.GetComponent <AIRotationComponent>().NotifyRotationCompleted();
}
if (standingOrder == UnitOrder.ADVANCE && !parent.GetComponent <AIRotationComponent>().IsRotating)
{
// Directly ahead pos available if not too far ahead OR if too far behind
var validAheadPositions = new List <EncounterPosition>()
{
AIUtils.RotateAndProject(parentPos, 0, -1, unit.UnitFacing),
AIUtils.RotateAndProject(parentPos, 1, -1, unit.UnitFacing),
AIUtils.RotateAndProject(parentPos, -1, -1, unit.UnitFacing),
};
foreach (var possible in validAheadPositions)
{
if (positionNotTooFarAheadAndMovable(state, parentPos, unit, possible) || parentIsLagging)
{
actions.Add(ToCardinalDirection(parentPos, possible));
}
}
// Flank positions available if not too far ahead AND not too far behind
var validFlankPositions = new List <EncounterPosition>()
{
AIUtils.RotateAndProject(parentPos, 1, 0, unit.UnitFacing),
AIUtils.RotateAndProject(parentPos, -1, 0, unit.UnitFacing),
};
foreach (var possible in validFlankPositions)
{
if (positionNotTooFarAheadAndMovable(state, parentPos, unit, possible) && !parentIsLagging)
{
actions.Add(ToCardinalDirection(parentPos, possible));
}
}
if (parent.GetComponent <AIRotationComponent>().BackSecure(state, parent, unit))
{
actions.Add(InputHandler.ActionMapping.ROTATE);
}
}
if (!parentIsLagging)
{
actions.Add(InputHandler.ActionMapping.WAIT);
}
actions.Add(InputHandler.ActionMapping.LEAVE_FORMATION);
return(actions);
}
public override void Start()
{
primaryEnemyPartyMemberEntity = enemyParty.PrimaryPartyMember.OverworldEntity;
State = EncounterState.Pending;
new Battle(Overworld.PlayerParty, enemyParty, this);
}
void Awake()
{
anim = GetComponent<Animator>();
// targetObjPools = new Dictionary<EncounterState, Player>();
targetObjPools = new List<Player>();
savePos = Vector3.zero;
m_key = EncounterState.None;
groundCheck = transform.Find ("groundCheck");
if(soldierFlag == PlayerPosition.Enemy){//enemy
Vector3 theScale = transform.localScale;
theScale.x = -1;
transform.localScale = theScale;
facingRight = false;
}
else
facingRight = true;
}
public static bool TryParse(string value, out EncounterState result)
{
result = default(EncounterState);
if( value=="planned")
result = EncounterState.Planned;
else if( value=="current")
result = EncounterState.Current;
else if( value=="onleave")
result = EncounterState.Onleave;
else if( value=="finished")
result = EncounterState.Finished;
else if( value=="cancelled")
result = EncounterState.Cancelled;
else
return false;
return true;
}
public static string ToString(EncounterState value)
{
if( value==EncounterState.Planned )
return "planned";
else if( value==EncounterState.Current )
return "current";
else if( value==EncounterState.Onleave )
return "onleave";
else if( value==EncounterState.Finished )
return "finished";
else if( value==EncounterState.Cancelled )
return "cancelled";
else
throw new ArgumentException("Unrecognized EncounterState value: " + value.ToString());
}
public void selectEnemy(Sprite target, GameTime gameTime)
{
if (target != null && target.currentState != Sprite.State.Dead)
{
SoundUtils.Play(SoundUtils.Sound.Input);
targetedEnemy = target;
battleMenu.start(selectedSkill.gambit, target.getStats().difficulty, gameTime);
state = EncounterState.Gambit;
}
}
public void selectHero(int hero)
{
if (party[hero].currentState != Sprite.State.Resting && party[hero].currentState != Sprite.State.Dead)
{
SoundUtils.Play(SoundUtils.Sound.Input);
selectedHero = party[hero];
battleMenu.selected = hero;
state = EncounterState.ActionSelect;
}
}
public void selectSkill(Skill skill)
{
SoundUtils.Play(SoundUtils.Sound.Input);
selectedSkill = skill;
state = EncounterState.EnemySelect;
}
/// <summary>
/// This function will detect the current state of the battle and update the necessary components only
/// </summary>
/// <param name="gameTime">The current GameTime object</param>
/// <param name="inputState">The state of the inputs to be used for input handling</param>
public void update(GameTime gameTime, InputState inputState)
{
switch(state)
{
case EncounterState.HeroSelect:
for(int i = 0; i< HeroSelectActions.Count(); ++i)
if (HeroSelectActions[i].wasPressed(inputState))
{
selectHero(i);
break;
}
break;
case EncounterState.ActionSelect:
for (int i = 0; i < ActionSelectActions.Count(); ++i)
if (ActionSelectActions[i].wasPressed(inputState))
{
selectSkill(selectedHero.skills[i]);
break;
}
if (InputAction.B.wasPressed(inputState))
state = EncounterState.HeroSelect;
break;
case EncounterState.EnemySelect:
for (int i = 0; i < EnemySelectActions.Count(); ++i)
if (EnemySelectActions[i].wasPressed(inputState))
{
selectEnemy(enemies[i], gameTime);
break;
}
if (InputAction.B.wasPressed(inputState))
state = EncounterState.HeroSelect;
break;
case EncounterState.Gambit:
if (battleMenu.gambitComplete(out result))
{
selectedSkill.resolve(selectedHero, targetedEnemy, enemies, result);
state = EncounterState.Animating;
}
break;
case EncounterState.Animating:
if (party.idle())
{
if (party.hasActed())
{
state = EncounterState.EnemyTurn;
enemies.activate(gameTime);
}
else
state = EncounterState.HeroSelect;
}
break;
case EncounterState.EnemyTurn:
if (!enemies.acting())
{
state = EncounterState.HeroSelect;
party.activate();
}
break;
default:
break;
}
enemies.update(gameTime, inputState);
party.update(gameTime, inputState);
battleMenu.update(gameTime, inputState);
}
