void OnCommandsDepleted(BattleQueue queue)
{
LogEx.Log <BattleStateExecute>("#--- End Turn " + (Coordinator.TurnCount) + " ---#");
queue.Emptied -= OnCommandsDepleted;
End();
}
public void RemoveEffect(FieldEffectType fieldEffectType)
{
// TODO.
LogEx.Log <FieldSide>("Removed effect: " + fieldEffectType);
_fieldEffects[fieldEffectType].Reset();
}
public void RegisterCharacter(Character character)
{
if (!_activeCharacters.Contains(character))
{
LogEx.Log <BattleSystem>("Registered character: '{0}'", character.name);
_activeCharacters.Add(character);
character.BattleEntities.ForEach(x => x.Initialize(this));
// Assign character into player slot.
//character.Owner.FieldSide.Register(character);
if (CharacterAddedToSlot != null)
{
CharacterAddedToSlot.Invoke(character);
}
if (PostCharacterAddedToSlot != null)
{
PostCharacterAddedToSlot.Invoke(character);
}
}
else
{
LogEx.LogError <BattleSystem>("Cannot register character '{0}' as they are already registered.", character.name);
}
}
void RegisterAction(BaseAction action, BattleQueueType type)
{
if (_logRegistrations)
{
LogEx.Log <BattleQueue>("Registered action: {0} of type '{1}'", action.GetType().Name, type.ToString());
}
switch (type)
{
case BattleQueueType.GenericUpdate:
_genericUpdates.Queue.Enqueue(action);
break;
case BattleQueueType.PlayerCommand:
_playerCommands.Queue.Enqueue(action);
break;
case BattleQueueType.StatusUpdate:
_statusUpdates.Queue.Enqueue(action);
break;
case BattleQueueType.Weather:
_weatherUpdates.Queue.Clear();
_weatherUpdates.Queue.Enqueue(action);
break;
}
}
void OnStateEnd(BattleState endingState)
{
switch (endingState.ID)
{
case BattleStateID.Start: SetState(BattleStateID.WaitingForInput); break;
case BattleStateID.WaitingForInput: SetState(BattleStateID.Executing); break;
case BattleStateID.Executing:
// TODO: Evaluate win condition.
bool gameOver = false;
if (gameOver)
{
LogEx.Log <BattleCoordinator>("Game Over!");
}
else
{
SetState(BattleStateID.PostTurn);
}
break;
case BattleStateID.PostTurn: SetState(BattleStateID.PostTurnExecute); break;
case BattleStateID.PostTurnExecute: SetState(BattleStateID.WaitingForInput); break;
}
}
public void RegisterPlayer(Player player, int fieldSideID)
{
if (!_players.Contains(player))
{
LogEx.Log <BattleSystem>("Registered player: '{0}'", player.name);
_players.Add(player);
fieldSideID = Mathf.Clamp(fieldSideID, 0, _fieldSides.Count - 1);
player.AssignFieldSide(_fieldSides[fieldSideID]);
// TEMP!!!
//RegisterCharacter(player.ActiveCharacter);
// TEMP!!!
//player.ActiveCharacter.BattleEntities.ForEach(x => x.Initialize(this));
if (PlayerAdded != null)
{
PlayerAdded.Invoke(player);
}
}
else
{
LogEx.LogError <BattleSystem>("Cannot register player '{0}' as they are already registered.", player.name);
}
}
protected override void OnApplyEffect(Character target)
{
LogEx.Log <FieldEffectSpikes>("Applying spikes. Multiplier {0}", Level);
var damage = _parameters.PercentageDamagePerLevel[Level];
target.Health.ChangeHealth(null, -damage);
}
void OnEnterWeather(BattleSystem battleSystem)
{
if (battleSystem.Weather.Current != null)
{
LogEx.Log <BattleQueue>("Found a weather effect.");
RegisterWeather(battleSystem.Weather.Current);
}
}
public void Assign(Character character)
{
LogEx.Log <FieldSlot>("Assigned character '{0}'", character.name);
Character = character;
Character.Fainted += OnCharacterFainted;
Character.AssignSlot(this);
CharacterAdded.InvokeSafe(Character);
}
void OnHealthChanged(HealthChangeEvent obj)
{
if (obj.NewValue <= 0)
{
LogEx.Log <Character>("{0} fainted...", name);
ActiveState = ActiveState.Fainted;
Fainted.InvokeSafe(this);
}
}
void OnPlayerReadyStateChanged(Player player)
{
LogEx.Log <BattleCoordinator>("{0} ready state changed to: {1}", player.name, player.IsReady);
if (Coordinator.System.Players.TrueForAll(x => x.IsReady))
{
End();
}
}
public void RemoveAllEffects()
{
// TODO.
LogEx.Log <FieldSide>("Removed all effects.");
foreach (var fieldEffect in _fieldEffects)
{
fieldEffect.Value.Reset();
}
}
public void IncreaseEffect()
{
Active = true;
if (CanApply)
{
Level++;
LogEx.Log <FieldEffectSpikes>("Increased effect multiplier to {0}", Level);
}
}
public override void OnStart()
{
Coordinator.System.Players.ForEach(x => x.ReadyStateChanged += OnPlayerReadyStateChanged);
LogEx.Log <BattleCoordinator>("Waiting for {0} players.", Coordinator.System.Players.Count);
if (Coordinator.AutoReadyPlayers)
{
Coordinator.System.Players.ForEach(x => x.Attack());
}
}
public override void OnStart()
{
base.OnStart();
Coordinator.AddTurn();
LogEx.Log <BattleStateExecute>("#--- Begin Turn " + (Coordinator.TurnCount) + " ---#");
Coordinator.Queue.Emptied += OnCommandsDepleted;
OnContinue();
}
void RegisterAction(BaseAction action, BattleQueueType type)
{
if (_logRegistrations)
{
LogEx.Log <BattleQueue>("Registered action: {0} of type '{1}'", action.GetType().Name, type.ToString());
}
if (ActionRegistered != null)
{
ActionRegistered.Invoke(action, type);
}
}
protected override void OnExecute(BattleSystem battleSystem)
{
_executionsTotal++;
TriggerCompletion();
if (Expired)
{
LogEx.Log <Lifetime>(name + "'s life expired.");
battleSystem.Log(ExpiryMessage);
}
}
public virtual void Execute(BattleSystem battleSystem)
{
Executed = true;
if (Log)
{
LogEx.Log <BaseAction>(name + " executed.");
}
_battleSystem = battleSystem;
OnExecute(battleSystem);
}
public void Log(string message, params object[] args)
{
if (!string.IsNullOrEmpty(message))
{
RegisterAction(() => LogEx.Log <BattleSystem>("Battle Log: " + message), "BattleLog");
RegisterAction(() =>
{
LogEx.Log <BattleSystem>("Battle Log: " + message);
LogPosted.InvokeSafe(message);
}, "BattleLog");
}
}
public void RelayToReference(BattleSystem battleSystem)
{
if (Log)
{
LogEx.Log <TriggerOnDestroy>("Relaying...");
}
foreach (var action in Reference.GetComponents <TargetedAction>())
{
action.SetSource(Source);
action.SetReciever(Reciever);
battleSystem.RegisterAction(action);
}
}
public void Set(Weather weather)
{
LogEx.Log <BattleWeather>("Weather is now: " + weather.ToString());
switch (weather)
{
case Weather.None: Clear(); break;
case Weather.Sandstorm: Create(Sandstorm); break;
}
if (Changed != null)
{
Changed.Invoke(this);
}
}
public void AddEffect(FieldEffectType fieldEffectType)
{
if (_fieldEffects.ContainsKey(fieldEffectType))
{
var fieldEffect = _fieldEffects[fieldEffectType];
if (fieldEffect.CanApply)
{
LogEx.Log <FieldSide>("Added effect: " + fieldEffectType);
_fieldEffects[fieldEffectType].IncreaseEffect();
}
else
{
LogEx.Log <FieldSide>("Field effect of type '{0}' cannot be applied.", fieldEffectType);
}
}
}
BaseAction Dequeue(ExecutionType executionType)
{
GenerateQueue(executionType);
if (_genericUpdates.Queue.Count != 0)
{
return(_genericUpdates.Queue.Dequeue());
}
if (_linearQueues.Count == 0)
{
return(null);
}
else
{
if (_linearQueues.Peek().Queue.Count != 0)
{
return(_linearQueues.Peek().Queue.Dequeue());
}
else
{
// Find the next non-empty queue.
BattleQueueWrapper next = null;
while (next == null || next.Queue.Count == 0 && _linearQueues.Count != 0)
{
next = _linearQueues.Dequeue();
// Activate the next queue.
if (next.OnActivation != null)
{
next.OnActivation(_battleSystem);
}
}
if (next != null)
{
LogEx.Log <BattleQueue>("Moving to next non-empty queue: " + next.Type);
}
return(next != null && next.Queue.Count != 0 ? next.Queue.Dequeue() : null);
}
}
}
void OnPlayerReplacementCharacterSelected(ReplaceCommand replaceCommand)
{
Coordinator.System.RegisterPlayerCommand(replaceCommand);
if (_replacingPlayers.Contains(replaceCommand.Player))
{
_replacingPlayers.Remove(replaceCommand.Player);
}
else
{
LogEx.LogError <BattleStatePostTurn>("Player {0} cannot be removed as they were never registered.", replaceCommand.Player.name);
}
if (_replacingPlayers.Count == 0)
{
LogEx.Log <BattleStatePostTurn>("All players have chosen their replacements. Executing...");
End();
}
}
void SetState(BattleStateID stateID)
{
switch (stateID)
{
case BattleStateID.Start: _state = _stateStart; break;
case BattleStateID.WaitingForInput: _state = _stateInput; break;
case BattleStateID.Executing: _state = _stateExecute; break;
case BattleStateID.PostTurn: _state = _statePostTurn; break;
case BattleStateID.PostTurnExecute: _state = _statePostTurnExecute; break;
}
LogEx.Log <BattleCoordinator>("State is now: " + _state.ID);
_state.Start(this);
}
public override void OnStart()
{
base.OnStart();
// Get all players whose character has fainted.
_replacingPlayers = new List <Player>();
_replacingPlayers.AddRange(Coordinator.System.Players
.Where(x => x.ActiveCharacter.ActiveState == ActiveState.Fainted)
.ToList());
if (_replacingPlayers.Count != 0)
{
LogEx.Log <BattleStatePostTurn>("Waiting for {0} players to choose a replacement...", _replacingPlayers.Count);
_replacingPlayers.ForEach(x => x.ReplacementCharacterSelected += OnPlayerReplacementCharacterSelected);
}
else
{
End();
}
}
public void Execute(ExecutionType executionType)
{
var next = Dequeue(executionType);
if (next != null)
{
next.Completed += OnActionExecutionComplete;
next.Execute(_battleSystem);
}
else
{
LogEx.Log <BattleSystem>("No more battle actions left to execute.");
// TODO: Move Turn Count somewhere else.
//TurnCount++;
Reset();
Emptied.InvokeSafe(this);
}
}
public void UnregisterPlayer(Player player)
{
if (_players.Contains(player))
{
LogEx.Log <BattleSystem>("Unregistered player: '{0}'", player.name);
_players.Remove(player);
// TEMP!!!
UnregisterCharacter(player.ActiveCharacter);
if (PlayerRemoved != null)
{
PlayerRemoved.Invoke(player);
}
}
else
{
LogEx.LogError <BattleSystem>("Cannot unregister player '{0}' as they were never registered.", player.name);
}
}
private void _HandleDispatcherException(object sender, DispatcherUnhandledExceptionEventArgs e)
{
var log = LogEx.Log(this);
log.Error(e.Exception, "Unhandled dispatcher exception");
FirstChanceDispatcherException?.Invoke(this, e);
if (e.Handled)
{
log.Information("Exception handled by first chance handler");
return;
}
if (MainWindow is MetroWindow window)
{
window.ShowModalMessageExternal(
"Error", $"{e.Exception.Message}\r\n\r\n{e.Exception}");
}
e.Handled = true;
Shutdown(e.Exception.GetHashCode());
}
public void UnregisterCharacter(Character character)
{
if (_activeCharacters.Contains(character))
{
LogEx.Log <BattleSystem>("Unregistered character: '{0}'", character.name);
_activeCharacters.Remove(character);
if (CharacterRemovedFromSlot != null)
{
CharacterRemovedFromSlot.Invoke(character);
}
if (PostCharacterRemovedFromSlot != null)
{
PostCharacterRemovedFromSlot.Invoke(character);
}
}
else
{
LogEx.LogError <BattleSystem>("Cannot unregister character '{0}' as they were never registered.", character.name);
}
}
