Ejemplo n.º 1
0
        private void CheckEventQueue()
        {
            lock (EventQueue)
            {
                // Dequeue next ability if none is in progress
                if (ActiveAbility == null)
                {
                    if (EventQueue.Count > 0)
                    {
                        BattleEvent activeEvent = EventQueue.Dequeue();

                        if (activeEvent != null)
                        {
                            activeEvent.Begin();

                            ActiveAbility = activeEvent;
#if DEBUG
                            Console.WriteLine("Event has begun:" + ActiveAbility.ToString());
#endif
                        }
                    }
                }

                // If the current ability is done, clear it
                if (ActiveAbility != null)
                {
                    bool isDone = ActiveAbility.RunIteration();

                    if (isDone)
                    {
#if DEBUG
                        Console.WriteLine("Event has completed:" + ActiveAbility.ToString());
#endif
                        //                if (ActiveAbility.Performer is Ally)
                        //                {
                        //                    LastPartyAction = (AbilityState)ActiveAbility.Clone();
                        //                }

                        if (ActiveAbility == _victoryEvent)
                        {
                            int exp = 0;
                            int ap  = 0;
                            int gil = 0;
                            List <IInventoryItem> items = new List <IInventoryItem>();

                            foreach (Enemy enemy in DeadEnemies)
                            {
                                exp += enemy.Exp;
                                ap  += enemy.AP;
                                gil += enemy.Gil;
                                IInventoryItem item = enemy.WinItem();
                                if (item != null)
                                {
                                    items.Add(item);
                                }
                            }

                            Seven.EndBattle(exp, ap, gil, items);
                        }

                        if (ActiveAbility == _lossEvent)
                        {
                            Seven.LoseGame();
                        }

                        ActiveAbility = null;

                        CheckForDeadEnemies();

                        // We need to prune all events from a source who cannot act.
                        // We must do the whole queue at once. We can't just look at
                        //   the head of the queue.
                        // Example. You attack with a character -- an event goes in the
                        //   queue, possibly behind many other events. Then that ally is
                        //   paralyzed. Then that ally is attacked, and it reaches its
                        //   limit break. Then that character is cured by, say, one of
                        //   Aeris's limit breaks (all of these things went in the queue
                        //   before said ally's attack). Then you use that ally's limit
                        //   break immediately upon regaining control of it.
                        // In theory, the attack event could still happen AFTER the limit
                        //   break. It needs to come out of the queue NOW if the ally
                        //   cannot act.
                        EventQueue.PruneEvents(x => x.Source.CannotAct, "source cannot act");
                    }
                }
            }
        }