Exemple #1
0
        private Task RemoveEncounterAsync(GridEncounter encounter)
        {
            _encounters.Remove(encounter);
            if (RemovedEncounter != null)
            {
                return(RemovedEncounter.Invoke(encounter));
            }

            return(Task.CompletedTask);
        }
Exemple #2
0
        private Task AddEncounterAsync(GridEncounter encounter)
        {
            _encounters.Add(encounter);
            if (AddedEncounter != null)
            {
                return(AddedEncounter.Invoke(encounter));
            }

            return(Task.CompletedTask);
        }
Exemple #3
0
        public async Task <GridEncounter> AppendOrNewEncounterAsync(GridEntity initiated, GridEntity target)
        {
            GridEncounter currentEncounter = null;

            // we need to see if the 2 entities are already in other encounters.. of so we will merge.. otherwise we join or create one
            var encounterForInitated = _encounters.FirstOrDefault(e => e.Combatants.Any(c => c.Key == initiated));
            var encounterForTarget   = _encounters.FirstOrDefault(e => e.Combatants.Any(c => c.Key == target));
            var attackerCombatant    = initiated.FindComponent <GridCombatant>();
            var targetCombatant      = target.FindComponent <GridCombatant>();


            if (encounterForInitated != null &&
                encounterForTarget != null &&
                encounterForInitated != encounterForTarget)
            {
                // merge
            }
            else
            {
                // the same encounter already? just switch to target it
                if (encounterForInitated != null && encounterForTarget != null & encounterForInitated == encounterForTarget)
                {
                    attackerCombatant.TargetPreference = target;
                    return(null);
                }

                currentEncounter = encounterForTarget == null ? encounterForInitated : encounterForTarget;
                if (currentEncounter == null)
                {
                    // create
                    _encounterCounter++;
                    currentEncounter = new GridEncounter(_encounterCounter);
                    attackerCombatant.TargetPreference = target;
                    targetCombatant.TargetPreference   = initiated;

                    await currentEncounter.AddCombatantAsync(initiated, attackerCombatant);

                    await currentEncounter.AddCombatantAsync(target, targetCombatant);

                    currentEncounter.Ended += EncounterEnded;
                    await AddEncounterAsync(currentEncounter);
                }

                // join

                if (initiated.IsAlive)
                {
                    currentEncounter.Dead.Remove(initiated);
                }

                if (target.IsAlive)
                {
                    currentEncounter.Dead.Remove(target);
                }

                if (!currentEncounter.Combatants.ContainsKey(initiated))
                {
                    attackerCombatant.TargetPreference = target;
                    await currentEncounter.AddCombatantAsync(initiated, attackerCombatant);
                }

                if (!currentEncounter.Combatants.ContainsKey(target))
                {
                    await currentEncounter.AddCombatantAsync(target, targetCombatant);
                }
            }


            return(currentEncounter);
        }
Exemple #4
0
 private Task MergeEncounters(GridEncounter keepEncounter, GridEncounter mergedEncounter)
 {
     return(Task.CompletedTask);
 }