Esempio n. 1
0
        public void StartDefendersPlacement()
        {
            if (State != FightState.Placement)
            {
                return;
            }

            m_placementTimer.Dispose();
            m_placementTimer            = null;
            m_isAttackersPlacementPhase = false;

            if (DefendersQueue.Count == 0)
            {
                StartFighting();
            }

            foreach (var defender in DefendersQueue)
            {
                var defender1 = defender;
                defender.Area.ExecuteInContext(() =>
                {
                    var lastMap = defender.Map;
                    defender1.Teleport(Map, Map.Cells[defender1.Cell.Id]);
                    defender1.ResetDefender();
                    Map.Area.ExecuteInContext(() =>
                    {
                        var fighter = defender.CreateFighter(DefendersTeam);

                        m_defendersMaps.Add(fighter, lastMap);
                        DefendersTeam.AddFighter(fighter);

                        // if all defenders have been teleported we can launch the timer
                        if (DefendersQueue.All(
                                x => DefendersTeam.Fighters.OfType <CharacterFighter>().Any(y => y.Character == x)))
                        {
                            m_placementTimer = Map.Area.CallDelayed(PvTDefendersPlacementPhaseTime, StartFighting);
                        }
                    });
                });
            }
        }
Esempio n. 2
0
        protected override List <IFightResult> GetResults()
        {
            var challengersRank =
                (int)ChallengersTeam.GetAllFightersWithLeavers().OfType <CharacterFighter>().Average(x => x.Character.ArenaRank);
            var defendersRank =
                (int)DefendersTeam.GetAllFightersWithLeavers().OfType <CharacterFighter>().Average(x => x.Character.ArenaRank);

            var results = (from fighter in GetFightersAndLeavers().OfType <CharacterFighter>()
                           let outcome = fighter.GetFighterOutcome()
                                         select new ArenaFightResult(fighter, outcome, fighter.Loot,
                                                                     ArenaRankFormulas.AdjustRank(fighter.Character.ArenaRank,
                                                                                                  fighter.Team == ChallengersTeam ? defendersRank : challengersRank,
                                                                                                  outcome == FightOutcomeEnum.RESULT_VICTORY)) as IFightResult).ToList();

            foreach (var playerResult in results.OfType <FightPlayerResult>())
            {
                var document = new BsonDocument
                {
                    { "FightId", UniqueId.ToString() },
                    { "FightType", Enum.GetName(typeof(FightTypeEnum), FightType) },
                    { "Duration", GetFightDuration().TotalMilliseconds },
                    { "Team", Enum.GetName(typeof(TeamEnum), playerResult.Fighter.Team.Id) },
                    { "Win", Winners.Id == playerResult.Fighter.Team.Id },
                    { "AcctId", playerResult.Character.Account.Id },
                    { "AcctName", playerResult.Character.Account.Login },
                    { "CharacterId", playerResult.Character.Id },
                    { "CharacterName", playerResult.Character.Name },
                    { "IPAddress", playerResult.Character.Client.IP },
                    { "ClientKey", playerResult.Character.Account.LastHardwareId },
                    { "Date", DateTime.Now.ToString(CultureInfo.InvariantCulture) }
                };

                MongoLogger.Instance.Insert("fights_results", document);
            }

            return(results);
        }
Esempio n. 3
0
        protected override List <IFightResult> GetResults()
        {
            var results = new List <IFightResult>();

            var looters = ChallengersTeam.GetAllFightersWithLeavers().Where(entry => entry.HasResult).
                          Select(entry => entry.GetFightResult()).OrderByDescending(entry => entry.Prospecting);

            results.AddRange(looters);
            results.AddRange(DefendersTeam.GetAllFightersWithLeavers().Where(entry => entry.HasResult).Select(entry => entry.GetFightResult()));

            if (Winners != ChallengersTeam)
            {
                return(results);
            }

            var teamPP = ChallengersTeam.GetAllFighters().Where(entry => entry.HasResult).Sum(entry => entry.Stats[PlayerFields.Prospecting].Total);
            var kamas  = TaxCollector.Kamas;

            foreach (var looter in looters)
            {
                looter.Loot.Kamas = kamas > 0 ? FightFormulas.AdjustDroppedKamas(looter, teamPP, kamas, false) : 0;
            }

            var i = 0;

            // dispatch loots
            foreach (var looter in looters)
            {
                var count = i + (int)Math.Ceiling(TaxCollector.Items.Count * ((double)looter.Prospecting / teamPP));
                for (; i < count && i < TaxCollector.Items.Count; i++)
                {
                    looter.Loot.AddItem(TaxCollector.Items[i]);
                }
            }

            return(results);
        }