public void GetContributionValueWithNoFactorList()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), null);
            var result = contributionManager.GetContributionValue(0);

            Assert.IsTrue(result == 0);
        }
        public void AddMultipleCharactersThenClear()
        {
            var fakeStaticWrapper = A.Fake <IStaticWrapper>();

            A.CallTo(fakeStaticWrapper).WithReturnType <ContributionDefinition>()
            .Returns(new ContributionDefinition {
                ContributionValue = 1, ContributionId = 1
            });

            var contributionManager = new ContributionManager(
                new ConcurrentDictionary <uint, List <PlayerContribution> >(),
                ContributionFactorReferenceList);

            contributionManager.UpdateContribution(100, 1);
            contributionManager.UpdateContribution(102, 2);
            contributionManager.UpdateContribution(104, 2);
            contributionManager.UpdateContribution(104, 1);

            contributionManager.RemoveCharacter(102);
            var result = contributionManager.GetContributionValue(102);

            Assert.IsTrue(result == 0);

            contributionManager.Clear();
            var result2 = contributionManager.GetContributionValue(102);

            Assert.IsTrue(result2 == 0);
            var result3 = contributionManager.GetContributionValue(104);

            Assert.IsTrue(result3 == 0);
        }
        public void GetContributionValueOnEmptyManager()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <World.Battlefronts.Bounty.PlayerContribution> >(), ContributionFactorReferenceList);
            var result = contributionManager.GetContributionValue(0);

            Assert.IsTrue(result == 0);
        }
        public void AddNewPlayerGetContribution()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), ContributionFactorReferenceList);

            contributionManager.AddCharacter(100);
            var result = contributionManager.GetContributionValue(100);

            Assert.IsTrue(result == 0);
        }
        public void UpdateCharacterNoAdd()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), ContributionFactorReferenceList);

            contributionManager.UpdateContribution(100, 1);
            contributionManager.UpdateContribution(100, 2);
            contributionManager.UpdateContribution(100, 2);
            contributionManager.UpdateContribution(100, 1);

            var result = contributionManager.GetContributionValue(100);

            Assert.IsTrue(result == 8);
        }
        public void ComplexContributionNoMax()
        {
            var contributionList    = new List <PlayerContribution>();
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), ContributionFactorReferenceList);

            contributionList.Add(new PlayerContribution {
                ContributionId = 1, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 1, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 1, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 1, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 1, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 1, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 1, Timestamp = 1111
            });

            contributionList.Add(new PlayerContribution {
                ContributionId = 2, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 2, Timestamp = 1111
            });
            contributionList.Add(new PlayerContribution {
                ContributionId = 2, Timestamp = 1111
            });

            var response = contributionManager.GetContributionStageDictionary(contributionList, ContributionFactorReferenceList);

            Assert.IsTrue(response[1].ContributionStageCount == 7);
            Assert.IsTrue(response[0].ContributionStageCount == 0);
            Assert.IsTrue(response[2].ContributionStageCount == 3);

            Assert.IsTrue(response[1].ContributionStageSum == 7);
            Assert.IsTrue(response[0].ContributionStageSum == 0);
            Assert.IsTrue(response[2].ContributionStageSum == 9);
        }
        public static void SavePlayerContribution(int battleFrontId, ContributionManager contributionManagerInstance)
        {
            WorldMgr.Database.ExecuteNonQuery($"DELETE FROM rvr_player_contribution Where BattleFrontId={battleFrontId};");

            foreach (var contribution in contributionManagerInstance.ContributionDictionary)
            {
                var characterId            = contribution.Key;
                var contributionSerialised = JsonConvert.SerializeObject(contribution.Value);
                var recordToWrite          = new Common.Database.World.Battlefront.PlayerContribution
                {
                    CharacterId            = characterId,
                    BattleFrontId          = battleFrontId,
                    ContributionSerialised = contributionSerialised,
                    Timestamp = DateTime.Now
                };

                WorldMgr.Database.AddObject(recordToWrite);
            }
        }
        public void NoPlayerContributionReturnsPreparedStructure()
        {
            var contributionList    = new List <World.Battlefronts.Bounty.PlayerContribution>();
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <World.Battlefronts.Bounty.PlayerContribution> >(), ContributionFactorReferenceList);

            var result = contributionManager.GetContributionStageDictionary(contributionList, ContributionFactorReferenceList);

            Assert.IsTrue(result.Count == ContributionFactorReferenceList.Count);
            Assert.IsTrue(result[0].ContributionStageSum == 0);
            Assert.IsTrue(result[1].ContributionStageSum == 0);
            Assert.IsTrue(result[2].ContributionStageSum == 0);

            Assert.IsTrue(result[0].ContributionStageCount == 0);
            Assert.IsTrue(result[1].ContributionStageCount == 0);
            Assert.IsTrue(result[2].ContributionStageCount == 0);

            Assert.IsTrue(result[0].ContributionStageMax == ContributionFactorReferenceList[0].MaxContributionCount);
            Assert.IsTrue(result[1].ContributionStageMax == ContributionFactorReferenceList[1].MaxContributionCount);
            Assert.IsTrue(result[2].ContributionStageMax == ContributionFactorReferenceList[2].MaxContributionCount);
        }
        public void RemoveCharacterFromNotEmptyWrongId()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), ContributionFactorReferenceList);

            contributionManager.AddCharacter(100);
            Assert.IsFalse(contributionManager.RemoveCharacter(101));

            contributionManager.UpdateContribution(100, 1);
            var result = contributionManager.GetContributionValue(100);

            Assert.IsTrue(result == 1);

            Assert.IsTrue(contributionManager.RemoveCharacter(100));


            contributionManager.UpdateContribution(100, 1);
            var result2 = contributionManager.GetContributionValue(100);

            Assert.IsTrue(result2 == 1);
        }
        public void AddNewPlayerAddContribution()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), ContributionFactorReferenceList);

            contributionManager.AddCharacter(100);
            contributionManager.UpdateContribution(100, 1);
            var result = contributionManager.GetContributionValue(100);

            Assert.IsTrue(result == 1);

            contributionManager.UpdateContribution(100, 1);
            var result2 = contributionManager.GetContributionValue(100);

            Assert.IsTrue(result2 == 2);

            // Has a value of 3
            contributionManager.UpdateContribution(100, 2);
            var result3 = contributionManager.GetContributionValue(100);

            Assert.IsTrue(result3 == 5);
        }
        public void TimingOnLargeSetUpdates()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), ContributionFactorReferenceList);

            contributionManager.UpdateContribution(100, 1);
            contributionManager.UpdateContribution(102, 2);
            Stopwatch sw = new Stopwatch();

            sw.Start();
            var result2 = contributionManager.GetContributionValue(102);

            Assert.IsTrue(result2 == 3);
            sw.Stop();

            contributionManager.UpdateContribution(104, 2);
            contributionManager.UpdateContribution(104, 1);
            for (uint i = 0; i < 2000; i++)
            {
                contributionManager.UpdateContribution(i + 200, 1);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 1);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 1);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 1);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 1);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 1);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
                contributionManager.UpdateContribution(i + 200, 2);
            }

            var result = contributionManager.GetContributionValue(102);

            Assert.IsTrue(result == 3);
            sw.Start();
            var result4 = contributionManager.GetContributionValue(200);

            sw.Stop();
            var elapsed = sw.ElapsedMilliseconds;
        }
        public void RemoveCharacterFromEmpty()
        {
            var contributionManager = new ContributionManager(new ConcurrentDictionary <uint, List <PlayerContribution> >(), ContributionFactorReferenceList);

            Assert.IsFalse(contributionManager.RemoveCharacter(100));
        }
Exemple #13
0
        public static void DefenceTickReward(BattleFrontKeep keep, List <Player> playersInRange, string description, ContributionManager contributionManagerInstance)
        {
            RewardLogger.Info($"DefenceTickReward. {keep.Info.Name} Players : {playersInRange.Count} {description}");
            foreach (var plr in playersInRange)
            {
                if (keep.Realm == plr.Realm && plr.ValidInTier(keep.Tier, true))
                {
                    var influenceId    = plr.Realm == Realms.REALMS_REALM_DESTRUCTION ? plr.CurrentArea.DestroInfluenceId : plr.CurrentArea.OrderInfluenceId;
                    var random         = StaticRandom.Instance.Next(80, 120);
                    var totalXp        = 2000 * keep.Tier * random / 100;
                    var totalRenown    = 300 * keep.Tier * random / 100;
                    var totalInfluence = 100 * keep.Tier * random / 100;

                    if (keep.PlayersKilledInRange < 4 * keep.Tier)
                    {
                        totalXp        += (int)(totalXp * (0.25 + keep.PlayersKilledInRange / 40f * 0.75));
                        totalRenown    += (int)(totalRenown * (0.25 + keep.PlayersKilledInRange / 40f * 0.75));
                        totalInfluence += (int)(totalInfluence * (0.25 + keep.PlayersKilledInRange / 40f * 0.75));
                    }

                    plr.AddXp((uint)totalXp, false, false);
                    plr.AddRenown((uint)totalRenown, false, RewardType.None, $"Defence of {description} against the enemy");
                    plr.AddInfluence((ushort)influenceId, (ushort)totalInfluence);

                    plr.SendClientMessage($"You've received a reward for your contribution to the holding of {keep.Info.Name}.", ChatLogFilters.CHATLOGFILTERS_RVR);

                    // Add Contribution for Keep Defence Tick
                    plr.UpdatePlayerBountyEvent((byte)ContributionDefinitions.KEEP_DEFENCE_TICK);

                    RewardLogger.Info("Keep", $"Keep Defence XP : {totalXp} RP: {totalRenown}, Influence: {totalInfluence}. Players killed in range {keep.PlayersKilledInRange}");
                }
            }
        }
Exemple #14
0
        public static void InnerDoorReward(KeepDoor door, Realms attackingRealm, string description, ContributionManager contributionManagerInstance)
        {
            var attackingPlayers = door.GameObject.PlayersInRange.Where(x => x.Realm == attackingRealm);

            // Small reward for inner door destruction
            foreach (var player in attackingPlayers)
            {
                if (!player.Initialized)
                {
                    continue;
                }

                RewardLogger.Trace($"Inner Door reward for player : {player.Name} ");


                var random = StaticRandom.Instance.Next(1, 25);
                player.AddXp((uint)(INNER_DOOR_XP * (1 + (float)random / 100)), false, false);
                player.AddRenown((uint)(INNER_DOOR_RP * (1 + (float)random / 100)), false, RewardType.None, $"Destruction of {description}'s inner door");

                player.UpdatePlayerBountyEvent((byte)ContributionDefinitions.DESTROY_INNER_DOOR);

                // Add contribution
                //contributionManagerInstance.UpdateContribution(player.CharacterId, (byte)ContributionDefinitions.DESTROY_INNER_DOOR);
                //var contributionDefinition = new BountyService().GetDefinition((byte)ContributionDefinitions.DESTROY_INNER_DOOR);
                //player.BountyManagerInstance.AddCharacterBounty(player.CharacterId, contributionDefinition.ContributionValue);
            }
        }
Exemple #15
0
        public static bool AddZoneLockBags(Player plr, ref List <string> values)
        {
            var destructionLootChest = LootChest.Create(plr.Region, plr.WorldPosition, (ushort)plr.ZoneId);

            var orderLootChest = LootChest.Create(plr.Region, plr.WorldPosition, (ushort)plr.ZoneId);

            plr = GetTargetOrMe(plr) as Player;
            if (plr == null)
            {
                return(true);
            }
            int numberBags     = GetInt(ref values);
            var _rewardManager = new RVRRewardManager();

            var rewardAssigner = new RewardAssigner(StaticRandom.Instance, null);

            var bagDefinitions = rewardAssigner.DetermineBagTypes(numberBags);

            // Assign eligible players to the bag definitions.
            foreach (var lootBagTypeDefinition in bagDefinitions)
            {
                var listPlayerContributions = new List <PlayerContribution>();
                var pc = new PlayerContribution();
                pc.ContributionId = 4;
                pc.Timestamp      = TCPManager.GetTimeStamp();
                listPlayerContributions.Add(pc);

                var cd = new ConcurrentDictionary <uint, List <PlayerContribution> >();
                cd.TryAdd(plr.CharacterId, listPlayerContributions);
                var cm = new ContributionManager(cd, BountyService._ContributionDefinitions);

                var eligPlayer = new List <KeyValuePair <uint, int> >();
                eligPlayer.Add(new KeyValuePair <uint, int>(plr.CharacterId, 10));
                var bonuses              = new List <RVRPlayerBagBonus>();
                var randomRolls          = new Dictionary <uint, int>();
                var pairingContributions = new Dictionary <uint, int>();
                var rewardAssignments    = rewardAssigner.AssignLootToPlayers(numberBags, new List <LootBagTypeDefinition> {
                    lootBagTypeDefinition
                }, eligPlayer, bonuses, randomRolls, pairingContributions, new WorldConfigs {
                    AllowBagBonusContribution = "Y", AllowPairingContribution = "Y", AllowRandomContribution = "Y"
                });

                var bagContentSelector = new BagContentSelector(RVRZoneRewardService.RVRRewardKeepItems, StaticRandom.Instance);

                foreach (var reward in rewardAssignments)
                {
                    if (reward.Assignee != 0)
                    {
                        var playerItemList   = (from item in plr.ItmInterface.Items where item != null select item.Info.Entry).ToList();
                        var playerRenown     = plr.CurrentRenown.Level;
                        var playerClass      = plr.Info.CareerLine;
                        var playerRenownBand = PlayerUtil.CalculateRenownBand(playerRenown);

                        var lootDefinition = bagContentSelector.SelectBagContentForPlayer(_logger, reward, playerRenownBand, playerClass, playerItemList.ToList(), true);
                        if (lootDefinition.IsValid())
                        {
                            plr.SendClientMessage("Lootdefinition is valid");
                            // Only distribute if loot is valid
                            var generatedLootBag = new LootBagBuilder().BuildChestLootBag(lootDefinition, plr);

                            if (plr.Realm == Realms.REALMS_REALM_DESTRUCTION)
                            {
                                destructionLootChest.Add(plr.CharacterId, generatedLootBag);
                            }
                            if (plr.Realm == Realms.REALMS_REALM_ORDER)
                            {
                                orderLootChest.Add(plr.CharacterId, generatedLootBag);
                            }
                        }
                        else
                        {
                            plr.SendClientMessage("Lootdefinition is NOT valid");
                        }
                    }
                }
            }
            return(true);
        }