Esempio n. 1
0
 public static void SetSenderInfo(StreamEntry entry, LogicClientAvatar avatar)
 {
     entry.SetSenderAvatarId(avatar.GetId());
     entry.SetSenderHomeId(avatar.GetCurrentHomeId());
     entry.SetSenderName(avatar.GetName());
     entry.SetSenderLevel(avatar.GetExpLevel());
     entry.SetSenderLeagueType(avatar.GetLeagueType());
     entry.SetSenderRole(avatar.GetAllianceRole());
 }
Esempio n. 2
0
        /// <summary>
        ///     Sets the data.
        /// </summary>
        public void SetData(LogicClientAvatar avatar)
        {
            this._avatarId        = avatar.GetId();
            this._homeId          = avatar.GetCurrentHomeId();
            this._avatarName      = avatar.GetName();
            this._facebookId      = avatar.GetFacebookId();
            this._expLevel        = avatar.GetExpLevel();
            this._leagueType      = avatar.GetLeagueType();
            this._nameChangeState = avatar.GetNameChangeState();
            this._nameSetByUser   = avatar.GetNameSetByUser();

            if (avatar.IsInAlliance())
            {
                this._allianceId       = avatar.GetAllianceId();
                this._allianceName     = avatar.GetAllianceName();
                this._allianceExpLevel = avatar.GetAllianceExpLevel();
                this._allianceRole     = avatar.GetAllianceRole();
                this._badgeId          = avatar.GetAllianceBadge();
            }
        }
Esempio n. 3
0
        public static void SetLogicClientAvatarToAllianceMemberEntry(LogicClientAvatar avatar, AllianceMemberEntry allianceMemberEntry, Alliance alliance = null)
        {
            bool updateScoring = avatar.GetScore() != avatar.GetScore();

            allianceMemberEntry.SetAvatarId(avatar.GetId());
            allianceMemberEntry.SetHomeId(avatar.GetCurrentHomeId());
            allianceMemberEntry.SetName(avatar.GetName());
            allianceMemberEntry.SetExpLevel(avatar.GetExpLevel());
            allianceMemberEntry.SetLeagueType(avatar.GetLeagueType());
            allianceMemberEntry.SetScore(avatar.GetScore());
            allianceMemberEntry.SetDuelScore(avatar.GetDuelScore());
            allianceMemberEntry.SetWarPreference(avatar.GetWarPreference());

            if (alliance != null)
            {
                if (updateScoring)
                {
                    alliance.UpdateScoring();
                }
            }
        }
        public void PublishMessage(LogicClientAvatar logicClientAvatar, string message)
        {
            GlobalChatLineMessage globalChatLineMessage = new GlobalChatLineMessage();

            globalChatLineMessage.SetMessage(message);
            globalChatLineMessage.SetAvatarName(logicClientAvatar.GetName());
            globalChatLineMessage.SetAvatarExpLevel(logicClientAvatar.GetExpLevel());
            globalChatLineMessage.SetAvatarLeagueType(logicClientAvatar.GetLeagueType());
            globalChatLineMessage.SetAvatarId(logicClientAvatar.GetId());
            globalChatLineMessage.SetHomeId(logicClientAvatar.GetCurrentHomeId());

            if (logicClientAvatar.IsInAlliance())
            {
                globalChatLineMessage.SetAllianceId(logicClientAvatar.GetAllianceId());
                globalChatLineMessage.SetAllianceName(logicClientAvatar.GetAllianceName());
                globalChatLineMessage.SetAllianceBadgeId(logicClientAvatar.GetAllianceBadgeId());
            }

            foreach (ChatSession session in this.m_sessions.Values)
            {
                session.SendPiranhaMessage(globalChatLineMessage, 1);
            }
        }
        public static void CalculateCombatScore(LogicClientAvatar attacker, LogicClientAvatar defender, int stars, bool ignoreLeague, bool revenge, int destructionPercentage,
                                                int starBonusMultiplier, bool duelMatch)
        {
            int multiplier = stars;

            if (stars <= 0)
            {
                multiplier = LogicDataTables.GetGlobals().GetScoreMultiplierOnAttackLose();
            }

            int attackerScore = attacker.GetScore();
            int defenderScore = defender.GetScore();

            LogicLeagueData attackerLeagueData = attacker.GetLeagueTypeData();
            LogicLeagueData defenderLeagueData = defender.GetLeagueTypeData();

            int newAttackerScore;
            int newDefenderScore;

            if (LogicDataTables.GetGlobals().EloOffsetDampeningEnabled())
            {
                newAttackerScore = LogicELOMath.CalculateNewRating(stars > 0, attackerScore, defenderScore, 20 * multiplier, LogicDataTables.GetGlobals().GetEloDampeningFactor(),
                                                                   LogicDataTables.GetGlobals().GetEloDampeningLimit(), LogicDataTables.GetGlobals().GetEloDampeningScoreLimit());
                newDefenderScore = LogicELOMath.CalculateNewRating(stars <= 0, defenderScore, attackerScore, 20 * multiplier, LogicDataTables.GetGlobals().GetEloDampeningFactor(),
                                                                   LogicDataTables.GetGlobals().GetEloDampeningLimit(), LogicDataTables.GetGlobals().GetEloDampeningScoreLimit());
            }
            else
            {
                newAttackerScore = LogicELOMath.CalculateNewRating(stars > 0, attackerScore, defenderScore, 20 * multiplier);
                newDefenderScore = LogicELOMath.CalculateNewRating(stars <= 0, defenderScore, attackerScore, 20 * multiplier);
            }

            int attackerGainCount = newAttackerScore - attackerScore;
            int defenderGainCount = newDefenderScore - defenderScore;

            if (attackerScore < 1000 && attackerGainCount < 0)
            {
                attackerGainCount = attackerScore * attackerGainCount / 1000;
            }

            if (defenderScore < 1000 && defenderGainCount < 0)
            {
                defenderGainCount = defenderScore * defenderGainCount / 1000;
            }

            if (LogicELOMath.CalculateNewRating(true, attackerScore, defenderScore, 60) > attackerScore)
            {
                if (stars <= 0)
                {
                    if (attackerGainCount >= 0)
                    {
                        attackerGainCount = -1;
                    }
                }
                else
                {
                    if (attackerGainCount <= 0)
                    {
                        attackerGainCount = 1;
                    }

                    if (defenderGainCount >= 0)
                    {
                        defenderGainCount = -1;
                    }
                }
            }

            newAttackerScore = LogicMath.Max(attackerScore + attackerGainCount, 0);
            newDefenderScore = LogicMath.Max(defenderScore + defenderGainCount, 0);

            if (!ignoreLeague)
            {
                attacker.SetScore(newAttackerScore);
                defender.SetScore(newDefenderScore);

                if (LogicDataTables.GetGlobals().EnableLeagues())
                {
                    if (!duelMatch)
                    {
                        if (attackerLeagueData != null)
                        {
                            if (stars <= 0)
                            {
                                attacker.SetAttackLoseCount(attacker.GetAttackLoseCount() + 1);
                            }
                            else
                            {
                                attacker.SetAttackWinCount(attacker.GetAttackWinCount() + 1);
                            }
                        }

                        if (defenderLeagueData != null)
                        {
                            if (stars > 0)
                            {
                                defender.SetDefenseLoseCount(defender.GetDefenseLoseCount() + 1);
                            }
                            else
                            {
                                defender.SetDefenseWinCount(defender.GetDefenseLoseCount() + 1);
                            }
                        }

                        if (stars > 0)
                        {
                            if (!revenge || LogicDataTables.GetGlobals().RevengeGiveLeagueBonus())
                            {
                                int leagueBonusPercentage = LogicDataTables.GetGlobals().GetLeagueBonusPercentage(destructionPercentage);

                                attacker.CommodityCountChangeHelper(0, LogicDataTables.GetGoldData(), attackerLeagueData.GetGoldReward() * leagueBonusPercentage / 100);
                                attacker.CommodityCountChangeHelper(0, LogicDataTables.GetElixirData(), attackerLeagueData.GetElixirReward() * leagueBonusPercentage / 100);

                                if (attacker.IsDarkElixirUnlocked())
                                {
                                    attacker.CommodityCountChangeHelper(0, LogicDataTables.GetDarkElixirData(),
                                                                        attackerLeagueData.GetDarkElixirReward() * leagueBonusPercentage / 100);
                                }
                            }
                        }

                        LogicGamePlayUtil.UpdateLeagueRank(attacker, newAttackerScore, false);
                        LogicGamePlayUtil.UpdateLeagueRank(defender, newDefenderScore, true);
                    }
                }
            }

            attacker.GetChangeListener().ScoreChanged(attacker.GetCurrentHomeId(), attackerGainCount, stars > 0 ? 1 : -1, true, attacker.GetLeagueTypeData(), attackerLeagueData,
                                                      destructionPercentage);
            defender.GetChangeListener().ScoreChanged(defender.GetCurrentHomeId(), defenderGainCount, stars > 0 ? -1 : 1, false, defender.GetLeagueTypeData(), defenderLeagueData,
                                                      destructionPercentage);

            if (stars > 0 && !ignoreLeague && !duelMatch && (!revenge || LogicDataTables.GetGlobals().RevengeGiveStarBonus()) && !attacker.GetStarBonusCooldown())
            {
                int totalStars = stars + attacker.GetStarBonusCounter();

                if (totalStars >= LogicDataTables.GetGlobals().GetStarBonusStarCount())
                {
                    LogicLeagueData leagueData = attacker.GetLeagueTypeData();

                    attacker.AddStarBonusReward(leagueData.GetGoldRewardStarBonus() * starBonusMultiplier, leagueData.GetElixirRewardStarBonus() * starBonusMultiplier,
                                                leagueData.GetDarkElixirRewardStarBonus() * starBonusMultiplier);
                    attacker.StarBonusCollected();

                    if (LogicDataTables.GetGlobals().AllowStarsOverflowInStarBonus() && !attacker.GetStarBonusCooldown())
                    {
                        totalStars %= LogicDataTables.GetGlobals().GetStarBonusStarCount();
                    }
                    else
                    {
                        totalStars = 0;
                    }
                }

                attacker.SetStarBonusCounter(totalStars);
            }
        }