public void SetupAndShow(UnitBasicProperties unit, MoveChoserType moveType, UnitBasicProperties awayFrom = null)
{
var positions = GameStateManager.Instance.GetActiveTile().GetPositions();
var awayFromPosition = awayFrom != null?positions.First(p => p.HasUnit(awayFrom.gameObject)) : null;
SetupAndShow(unit, moveType, awayFromPosition);
}
private void ShowNextPushAway()
{
if (unitToPushRemaining.Count == 0)
{
FinishCurrentStep();
return;
}
currentDefender = unitToPushRemaining[0];
unitToPushRemaining.RemoveAt(0);
SetDefenderPanel();
SetAttackerPanel();
defenderPortraitRenderer.material = currentDefender.portrait;
attackerPortraitRenderer.material = attackerRecieved.portrait;
currentDefender.ShowAttackedBrillance();
if (movementRecieved.PushDamage > 0)
{
ShowNextPushAwayBlockDodge();
}
else
{
ShowNextPushAwayPush();
}
}
private void ApplyFrostbite(MovementAction movement, UnitBasicProperties attacker)
{
if (attacker.side == UnitSide.Hollow)
{
movement.MoveDistance = Math.Max(0, movement.MoveDistance - (attacker.isFrozen ? 1 : 0));
}
}
private void ClearCurrent()
{
defenderCurrent = null;
defenseCurrent = null;
blockRoll = 0;
dodgeRoll = 0;
}
private void CloneRecievedToCurrent()
{
defenderCurrent = defenderRecieved;
attackResolved = false;
shiftBeforeResolved = 0;
shiftAfterResolved = 0;
}
private void ApplyPushDamage()
{
var damageToApply = movementRecieved.PushDamage;
var hit = true;
if (rollType == EncounterRollType.Block)
{
damageToApply = Math.Max(0, damageToApply - blockRoll);
}
else if (rollType == EncounterRollType.Dodge)
{
if (dodgeRoll >= movementRecieved.DodgeLevel)
{
damageToApply = 0;
hit = false;
}
currentDefender.ConsumeStamina(1 + (currentDefender.isFrozen ? 1 : 0));
}
currentDefender.RecieveInjuries(damageToApply);
DestroyDices();
confirmButton.SetActive(false);
if (hit)
{
ShowNextPushAwayPush();
}
else
{
currentDefender = null;
}
}
private void ApplyStagger(AttackAction attack, UnitBasicProperties unit)
{
attack.StaminaCost += unit.isStaggered ? 1 : 0;
if (unit is EnemyProperties)
{
attack.FlatModifier = System.Math.Max(0, attack.FlatModifier - (unit.isStaggered ? 1 : 0));
}
}
private void ActivateNextUnit()
{
firstMovementFree = true;
bool isEnemyTurn = false;
if (currentUnit == null)
{
// first turn, set the next player to be the one carying the activation token, or the first players by default.
isEnemyTurn = true;
LastActiveEnemy = -1;
var lastactivePlayer = players.FirstOrDefault(p => p.hasActivationToken);
if (lastactivePlayer == null)
{
LastActivePlayer = -1;
}
else
{
LastActivePlayer = players.IndexOf(lastactivePlayer) - 1;
}
}
else
{
currentUnit.EndOfTurn();
if (currentUnit.side == UnitSide.Hollow && LastActiveEnemy >= enemies.Count - 1)
{
LastActivePlayer = LastActivePlayer < players.Count - 1 ? LastActivePlayer : -1;
}
else
{
isEnemyTurn = true;
if (currentUnit.side == UnitSide.Player)
{
LastActiveEnemy = -1;
}
}
}
currentUnitHasAttacked = false;
currentUnitHasMoved = false;
CheckUnitsAlive();
if (isEnemyTurn)
{
LastActiveEnemy++;
currentUnit = enemies[LastActiveEnemy];
enemyAi.ResolveEnemyTurn(enemies[LastActiveEnemy].gameObject);
}
else
{
RemoveAllAggroToken();
LastActivePlayer++;
currentUnit = players[LastActivePlayer];
}
currentUnit.Activate();
}
private void FinalizeEncounter()
{
resolvingMovement = false;
movementRecieved = null;
attackerRecieved = null;
primaryTargetRecieved = null;
SetGlobalPanelVisibility(false);
}
private void SetNextToCurrent()
{
var next = defensesToResolve.First();
defenderCurrent = next;
defenderCurrent.ShowAttackedBrillance();
defenseCurrent = defenderCurrent.GetDefenseDices(attackRecieved.MagicAttack);
blockRoll = 0;
dodgeRoll = 0;
}
public void SetUnit(UnitBasicProperties unitBasic)
{
if (unitBasic != null && unitBasic is PlayerProperties)
{
unit = (PlayerProperties)unitBasic;
}
else
{
unit = null;
}
}
private void RemoveEnemy(UnitBasicProperties enemy)
{
enemy.ClearEquipement();
enemyToProperties.Remove(enemy.gameObject);
enemies.Remove(enemy);
foreach (var position in positions)
{
position.RemoveNonBossUnit(enemy.gameObject);
}
Destroy(enemy.gameObject);
}
private void PrepareEncounterToResolve(BehaviorAction attack, UnitBasicProperties originalTarget)
{
var sourcePosition = positions.FirstOrDefault(p => p.HasActiveUnit());
var targetPosition = positions.FirstOrDefault(p => p.HasUnit(originalTarget.gameObject));
var encounter = new Encounter(attack, currentUnit, originalTarget);
UnregisterPositionClicked();
EventManager.RaiseEvent(ObjectEventType.EncounterToResolve, encounter);
EventManager.StartListening(ObjectEventType.EncountersResolved, CheckUnitStatusAfterEncounter);
}
private void ApplyStagger(AttackAction attack, UnitBasicProperties attacker)
{
if (attacker.side == UnitSide.Player)
{
attack.StaminaCost += attacker.isStaggered ? 1 : 0;
}
else if (attacker.side == UnitSide.Hollow)
{
attack.FlatModifier = attack.FlatModifier - (attacker.isStaggered ? 1 : 0);
}
}
public void Execute(UnitBasicProperties unit, MovementAction movement)
{
var tile = gameState.GetActiveTile();
var positions = tile.GetPositions();
var currentPosition = positions.First(p => p.HasUnit(unit.gameObject));
var targetsInRange = movement.FindTargetsInRange(unit, currentPosition, positions);
var target = FindClosestTarget(currentPosition, movement.TargetPreference, targetsInRange);
EventManager.RaiseEvent(ObjectEventType.AttackSelected, movement);
EventManager.RaiseEvent(GameObjectEventType.UnitSelected, target);
}
private void PushMoveSelected(PositionBehavior position)
{
currentDefender.HideAttakedBrillance();
if (currentStep == MovementStep.InitialPush)
{
currentDefender = null;
}
else if (currentStep == MovementStep.PushAway)
{
currentDefender = null;
}
}
public override List <UnitBasicProperties> FindTargetsInRange(UnitBasicProperties attacker, PositionBehavior attackerPosition, IEnumerable <PositionBehavior> positions)
{
var currentSide = attacker.side;
var targetSide = currentSide == UnitSide.Hollow ? UnitSide.Player : UnitSide.Hollow;
var targets = new List <UnitBasicProperties>();
foreach (var position in positions)
{
var potential = position.GetUnits(targetSide).ToList();
targets.AddRange(potential.Select(p => p.GetComponent <UnitBasicProperties>()));
}
return(targets);
}
public List <UnitBasicProperties> FindTargetsOnNode(UnitBasicProperties attacker, PositionBehavior targetPosition, UnitBasicProperties originalTarget)
{
var currentSide = attacker.side;
var targetSide = TargetAllies ? currentSide : currentSide == UnitSide.Hollow ? UnitSide.Player : UnitSide.Hollow;
var targets = new List <UnitBasicProperties>();
if (NodeSplash)
{
targets = targetPosition.GetUnits(targetSide).Select(u => u.GetComponent <UnitBasicProperties>()).ToList();
}
else
{
targets.Add(originalTarget);
}
return(targets);
}
private void ShowAggroSeleciton()
{
AggroSelectionCanvas.SetActive(true);
Portrait1.enabled = false;
Portrait2.enabled = false;
Portrait3.enabled = false;
Portrait4.enabled = false;
var i = 0;
foreach (var player in GameStateManager.Instance.players.Select(p => p.GetComponent <UnitBasicProperties>()))
{
if (i == 0)
{
Portrait1.material = player.portrait;
Portrait1.enabled = true;
Char1 = player;
Char1.hasAggroToken = false;
}
else if (i == 1)
{
Portrait2.material = player.portrait;
Portrait2.enabled = true;
Char2 = player;
Char1.hasAggroToken = false;
}
else if (i == 2)
{
Portrait3.material = player.portrait;
Portrait3.enabled = true;
Char3 = player;
Char1.hasAggroToken = false;
}
else if (i == 3)
{
Portrait4.material = player.portrait;
Portrait4.enabled = true;
Char4 = player;
Char1.hasAggroToken = false;
}
i++;
}
}
public void Resolve(object eventLoad)
{
var castLoad = (Encounter)eventLoad;
if (castLoad.Action.GetType() != typeof(MovementAction))
{
return;
}
resolvingMovement = true;
currentStepCounter = 0;
movementRecieved = (MovementAction)castLoad.Action.Clone();
attackerRecieved = castLoad.Attacker;
primaryTargetRecieved = castLoad.Defender;
ApplyFrostbite(movementRecieved, attackerRecieved);
PrepareEncounter();
}
public void SetupTile(BehaviorAction action, UnitBasicProperties properties, AttackSide side)
{
action.Side = side;
if (action is AttackAction)
{
attack = (AttackAction)action;
}
else if (action is MovementAction)
{
movement = (MovementAction)action;
}
UnitProperties = properties;
IsSelected = false;
IsDisabled = false;
SetupAttack();
}
private void PreparePushAway()
{
currentStep = MovementStep.PushAway;
checkNextStep = false;
if (!movementRecieved.Push)
{
FinishCurrentStep();
return;
}
SetPushAwayVisibility();
unitToPushRemaining = GetUnitsToPush();
foreach (var unit in unitToPushRemaining)
{
unit.ShowTargetableBrillance();
}
currentDefender = null;
}
public void SetupAndShow(UnitBasicProperties unit, MoveChoserType moveType, PositionBehavior awayFromPosition)
{
movingUnit = unit;
DescriptionText.text = $"Choose {moveType.ToString()} {Environment.NewLine} Direction";
OcclusionBackground.SetActive(true);
DescriptionText.gameObject.SetActive(true);
var positions = GameStateManager.Instance.GetActiveTile().GetPositions();
currentPosition = positions.First(p => p.HasUnit(unit.gameObject));
ShowValidDirections(currentPosition, awayFromPosition);
if (moveType == MoveChoserType.Shift)
{
NoneButton.SetActive(true);
}
}
private void ShowNextInitialPush()
{
if (unitToPushRemaining.Count == 0)
{
FinishCurrentStep();
return;
}
currentDefender = unitToPushRemaining[0];
unitToPushRemaining.RemoveAt(0);
defenderPortraitRenderer.material = currentDefender.portrait;
attackerPortraitRenderer.material = attackerRecieved.portrait;
SetDefenderPanel();
SetAttackerPanel();
currentDefender.ShowAttackedBrillance();
pushMover.SetupAndShow(currentDefender, MoveChoserType.Push, attackerRecieved);
}
private List <UnitBasicProperties> FindTargetsInRangeInternal(UnitBasicProperties attacker, PositionBehavior attackerPosition, IEnumerable <PositionBehavior> positions, bool withShift)
{
var currentSide = attacker.side;
var targetSide = TargetAllies ? currentSide : currentSide == UnitSide.Hollow ? UnitSide.Player : UnitSide.Hollow;
var targets = new List <UnitBasicProperties>();
foreach (var position in positions)
{
var pathLength = PathFinder.GetPath(attackerPosition, position).Count;
if (!InRange(pathLength, withShift))
{
continue;
}
var potential = position.GetUnits(targetSide).ToList();
targets.AddRange(potential.Select(p => p.GetComponent <UnitBasicProperties>()));
}
return(targets);
}
private void PrepareInitialPush()
{
currentStep = MovementStep.InitialPush;
checkNextStep = false;
DestroyDices();
if (!movementRecieved.Push)
{
FinishCurrentStep();
return;
}
SetInitialPushVisibility();
unitToPushRemaining = GetUnitsToPush();
foreach (var unit in unitToPushRemaining)
{
unit.ShowTargetableBrillance();
}
currentDefender = null;
attackerOriginNode = null;
}
public void Resolve(object eventLoad)
{
var castLoad = (Encounter)eventLoad;
if (castLoad.Action.GetType() != typeof(AttackAction))
{
return;
}
resolvingEncounter = true;
currentDefenderIsSetup = true;
attackRecieved = (AttackAction)castLoad.Action.Clone();
attackerRecieved = castLoad.Attacker;
defenderRecieved = castLoad.Defender;
ApplyStagger(attackRecieved, attackerRecieved);
CloneRecievedToCurrent();
currentStep = EncounterStep.None;
attackRepeatCounter = 1;
}
private void SetLeftAttack(BehaviorAction action, UnitBasicProperties unitProperties, int index)
{
if (index == 0)
{
LeftAttack1.gameObject.SetActive(true);
LeftAttack1.Reset();
LeftAttack1.SetupTile(action, unitProperties, AttackSide.Left);
existing.Add(LeftAttack1);
}
else if (index == 1)
{
LeftAttack2.gameObject.SetActive(true);
LeftAttack2.Reset();
LeftAttack2.SetupTile(action, unitProperties, AttackSide.Left);
existing.Add(LeftAttack2);
}
else if (index == 2)
{
LeftAttack3.gameObject.SetActive(true);
LeftAttack3.Reset();
LeftAttack3.SetupTile(action, unitProperties, AttackSide.Left);
existing.Add(LeftAttack3);
}
}
private void NewTileFocused(GameObject arg0)
{
focusedTile = gameState.GetActiveTile();
activeUnit = null;
}
private void NewUnitActivated(GameObject unitObject)
{
activeUnit = unitObject.GetComponent <UnitBasicProperties>();
followActiveUnit = true;
}
