Ejemplo n.º 1
0
        public static void LoadExps(object object1)
        {
            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Data))
            {
                try
                {
                    MySql database = dbConnection.Database;

                    string query = "SELECT * " +
                        "FROM experience";

                    foreach (DataColumnCollection columnCollection in database.RetrieveRowsEnumerable(query))
                    {
                        int level = columnCollection["level_num"].ValueString.ToInt();

                        exp[level - 1] = columnCollection["med_slow"].ValueString.ToUlng();

                        if (LoadUpdate != null)
                            LoadUpdate(null, new LoadingUpdateEventArgs(level, exp.MaxLevels));
                    }

                    if (LoadComplete != null)
                        LoadComplete(null, null);
                }
                catch (Exception ex)
                {
                    Exceptions.ErrorLogger.WriteToErrorLog(ex);
                }
            }
        }
Ejemplo n.º 2
0
        public static void RunTest(Client client)
        {
            Messenger.PlayerMsg(client, client.IP.ToString(), Text.BrightRed);

            return;
            int playerCount = 0;
            PacketHitList hitlist = null;
            PacketHitList.MethodStart(ref hitlist);
            IMap map = client.Player.Map;

            Stopwatch watch = new Stopwatch();
            watch.Start();
            using (DatabaseConnection db = new DatabaseConnection(DatabaseID.Players)) {
                PlayerManager.RetrieveCharacterID(db, "luigiDUDE");
            }
            //Messenger.PlayerWarp(client, map.MapID, 0, 25);
            watch.Stop();
            PacketHitList.MethodEnded(ref hitlist);
            Messenger.PlayerMsg(client, "Time: " + watch.ElapsedMilliseconds + "\nPlayer Count: " + playerCount, Text.BrightGreen);
            Messenger.PlayerMsg(client, "RNG: " + Server.Math.Rand(0, 1000), Text.BrightGreen);
            Messenger.PlayerMsg(client, "Tick Count: " + Server.Core.GetTickCount().Tick, Text.BrightGreen);
            //exPlayer.Get(client).EvolutionActive = !exPlayer.Get(client).EvolutionActive;
            //Messenger.PlayerMsg(client, "Evolution active: " + exPlayer.Get(client).EvolutionActive, Text.Yellow);
            //BossBattles.StartBossBattle(client, "CliffsideRelic");

            //map.SetTile(9, 3, 3, 0, 4, 3);
            //map.SetAttribute(9, 3, Server.Enums.TileType.Scripted, 46, 0, 0, "2", "1015", "25:25");
            //Messenger.SendTile(9, 3, map);
        }
Ejemplo n.º 3
0
        public static void DumpStatistics()
        {
            int playerCount = 0;
            int staffCount = 0;
            foreach (Client i in ClientManager.GetClients()) {
                if (i.Player != null) {
                    if (i.IsPlaying()) {
                        playerCount++;
                        if (Players.Ranks.IsAllowed(i, Enums.Rank.Moniter)) {
                            staffCount++;
                        }
                    }
                }
            }
            int partyCount = Server.Players.Parties.PartyManager.CountActiveParties();
            int activeMapCount = Server.Maps.MapManager.CountActiveMaps();
            int activeNetworkClients = Server.Network.ClientManager.CountActiveClients();

            Process serverProcess = Process.GetCurrentProcess();
            long workingSet = serverProcess.WorkingSet64;
            long elapsedHours = (long)Globals.LiveTime.Elapsed.TotalHours;

            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Data)) {
                dbConnection.Database.AddRow("stats_performance", new IDataColumn[] {
                    dbConnection.Database.CreateColumn(false, "Time", DateTime.UtcNow.ToString()),
                    dbConnection.Database.CreateColumn(false, "PlayerCount", playerCount.ToString()),
                    dbConnection.Database.CreateColumn(false, "StaffCount", staffCount.ToString()),
                    dbConnection.Database.CreateColumn(false, "ActiveNetworkClients", activeNetworkClients.ToString()),
                    dbConnection.Database.CreateColumn(false, "ActiveMaps", activeMapCount.ToString()),
                    dbConnection.Database.CreateColumn(false, "ActiveParties", partyCount.ToString()),
                    dbConnection.Database.CreateColumn(false, "WorkingSet", workingSet.ToString()),
                    dbConnection.Database.CreateColumn(false, "ElapsedHours", elapsedHours.ToString())
                });
            }
        }
Ejemplo n.º 4
0
        /*
        public static int FindMoveName(string moveName){
            for (int i = 1; i <= moves.MaxMoves; i++) {
                if (Moves.Moves[i].Name == moveName) {
                    return i;
                }
            }
            return -1;
        }
        */
        public static void Initialize()
        {
            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Data))
            {
                //method for getting count
                string query = "SELECT COUNT(num) FROM move";
                DataColumnCollection row = dbConnection.Database.RetrieveRow(query);

                int count = row["COUNT(num)"].ValueString.ToInt();
                moves = new MoveCollection(count);

            }
            standardAttack = new Move();

            //Set standard attack
            standardAttack.Name = "its regular attack";
            standardAttack.RangeType = Enums.MoveRange.FrontOfUser;
            standardAttack.Range = 1;
            standardAttack.Accuracy = 90;
            standardAttack.TargetType = Enums.MoveTarget.Foes;
            standardAttack.Element = Enums.PokemonType.None;
            standardAttack.MoveCategory = Enums.MoveCategory.Physical;
            standardAttack.EffectType = Enums.MoveType.SubHP;
            standardAttack.HitTime = 900;
            standardAttack.HitFreeze = false;
            standardAttack.Data1 = Server.Constants.STANDARDATTACKBASEPOWER;
            standardAttack.AttackerAnim.AnimationIndex = -1;
            standardAttack.TravelingAnim.AnimationIndex = -1;
            standardAttack.DefenderAnim.AnimationIndex = -1;
            standardAttack.Sound = -1;
        }
Ejemplo n.º 5
0
 public static bool AccountExists(DatabaseConnection dbConnection, string accountName)
 {
     if (!string.IsNullOrEmpty(accountName)) {
         return PlayerDataManager.IsAccountNameTaken(dbConnection.Database, accountName);
     } else {
         return false;
     }
 }
Ejemplo n.º 6
0
 public static bool CharacterNameExists(DatabaseConnection dbConnection, string characterName)
 {
     string retrievedCharID = RetrieveCharacterID(dbConnection, characterName);
     if (!string.IsNullOrEmpty(retrievedCharID)) {
         return true;
     } else {
         return false;
     }
 }
Ejemplo n.º 7
0
        public Party(string partyID, Client leader)
        {
            PartyID = partyID;

            Members = new List<string>();
            Members.Add(leader.Player.CharID);
            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                PartyManager.SaveParty(dbConnection.Database, this);
            }
        }
Ejemplo n.º 8
0
        public static void Initialize()
        {
            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Data))
            {
                //method for getting count
                string query = "SELECT COUNT(num) FROM item";
                DataColumnCollection row = dbConnection.Database.RetrieveRow(query);

                int count = row["COUNT(num)"].ValueString.ToInt();
                items = new ItemCollection(count);
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Creates a new account. Return codes: -1: Unknown error, 0: Success, 1: Account already exists
        /// </summary>
        /// <param name="accountName">Name of the account.</param>
        /// <param name="encryptedPassword">The encrypted password.</param>
        /// <returns></returns>
        public static int CreateNewAccount(DatabaseConnection dbConnection, string accountName, string encryptedPassword, string email)
        {
            int result = -1;
            if (PlayerDataManager.IsAccountNameTaken(dbConnection.Database, accountName) == false) {
                PlayerDataManager.CreateNewAccount(dbConnection.Database, accountName, encryptedPassword, email);
                result = 0;
            } else {
                result = 1;
            }

            return result;
        }
Ejemplo n.º 10
0
        public bool AddToParty(Client client)
        {
            if (CanAddToParty(client)) {
                Add(client.Player.CharID);
                //SwitchOutExtraMembers();

                using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                    PartyManager.SaveParty(dbConnection.Database, this);
                }
                return true;
            } else {
                return false;
            }
        }
Ejemplo n.º 11
0
 // Bans a player
 public static void BanPlayer(DatabaseConnection dbConnection, string ip, string bannedID, string bannedAccount,
     string bannedMac, string bannerID, string bannerIP, string unbanDate, Enums.BanType banType)
 {
     IDataColumn[] columns = new IDataColumn[] {
         dbConnection.Database.CreateColumn(true, "BannedPlayerID", bannedID),
         dbConnection.Database.CreateColumn(false, "BannedPlayerAccount", bannedAccount),
         dbConnection.Database.CreateColumn(false, "BannedPlayerIP", ip),
         dbConnection.Database.CreateColumn(false, "BannedPlayerMac", bannedMac),
         dbConnection.Database.CreateColumn(false, "BannerPlayerID", bannerID),
         dbConnection.Database.CreateColumn(false, "BannerPlayerIP",bannerIP),
         dbConnection.Database.CreateColumn(false, "BannedDate", DateTime.Now.ToString()),
         dbConnection.Database.CreateColumn(false, "UnbanDate", unbanDate),
         dbConnection.Database.CreateColumn(false, "BanType", ((int)banType).ToString())
     };
     dbConnection.Database.AddRow("bans", columns);
 }
Ejemplo n.º 12
0
        public static void LoadMissionPool(DatabaseConnection dbConnection, int difficulty)
        {
            MissionPool missionPool = new MissionPool();
            MySql database = dbConnection.Database;

            string query = "SELECT mission_client.DexNum, mission_client.FormNum " +
                "FROM mission_client " +
                "WHERE mission_client.Rank = \'" + difficulty + "\'  " +
                "ORDER BY mission_client.ClientIndex";

            foreach (DataColumnCollection column in database.RetrieveRowsEnumerable(query))
            {
                MissionClientData data = new MissionClientData();
                data.Species = column["DexNum"].ValueString.ToInt();
                data.Form = column["FormNum"].ValueString.ToInt();
                missionPool.MissionClients.Add(data);
            }

            query = "SELECT mission_enemy.NpcNum " +
                "FROM mission_enemy " +
                "WHERE mission_enemy.Rank = \'" + difficulty + "\'  " +
                "ORDER BY mission_enemy.EnemyIndex";

            foreach (DataColumnCollection column in database.RetrieveRowsEnumerable(query))
            {
                MissionEnemyData data = new MissionEnemyData();
                data.NpcNum = column["NpcNum"].ValueString.ToInt();
                missionPool.Enemies.Add(data);
            }

            query = "SELECT mission_reward.ItemNum, mission_reward.ItemAmount, mission_reward.ItemTag " +
                "FROM mission_reward " +
                "WHERE mission_reward.Rank = \'" + difficulty + "\'  " +
                "ORDER BY mission_reward.RewardIndex";

            foreach (DataColumnCollection column in database.RetrieveRowsEnumerable(query))
            {
                MissionRewardData data = new MissionRewardData();
                data.ItemNum = column["ItemNum"].ValueString.ToInt();
                data.Amount = column["ItemAmount"].ValueString.ToInt();
                data.Tag = column["ItemTag"].ValueString;
                missionPool.Rewards.Add(data);
            }

            missionPools.MissionPools.Add(missionPool);
        }
Ejemplo n.º 13
0
        public static void DumpStatistics()
        {
            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Data)) {
                dbConnection.Database.ExecuteNonQuery("TRUNCATE TABLE packet_statistics");

                foreach (string key in statistics.Keys) {
                    PacketStatistic stats;
                    if (statistics.TryGetValue(key, out stats)) {
                        dbConnection.Database.UpdateOrInsert("packet_statistics", new IDataColumn[] {
                        dbConnection.Database.CreateColumn(true, "Header", key),
                        dbConnection.Database.CreateColumn(false, "Amount", stats.TimesReceived.ToString()),
                        dbConnection.Database.CreateColumn(false, "AverageTime", (stats.TotalProcessTime / stats.TimesReceived * 1000 / (double)System.Diagnostics.Stopwatch.Frequency).ToString()),
                        dbConnection.Database.CreateColumn(false, "AverageDataSplittingTime", (stats.TotalDataSplittingTime / stats.TimesReceived * 1000 / (double)System.Diagnostics.Stopwatch.Frequency).ToString()),
                        dbConnection.Database.CreateColumn(false, "AverageCPUUsage", (stats.CPUUsage / stats.TimesReceived).ToString())
                    });
                    }
                }
            }
        }
Ejemplo n.º 14
0
        public static void LoadStories(object object1)
        {
            try
            {

                using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Data))
                {
                    for (int i = 0; i <= stories.MaxStories; i++)
                    {
                        LoadStory(i, dbConnection.Database);
                        if (LoadUpdate != null)
                            LoadUpdate(null, new LoadingUpdateEventArgs(i, stories.MaxStories));
                    }
                    if (LoadComplete != null)
                        LoadComplete(null, null);

                }
            } catch (Exception ex) {
                Exceptions.ErrorLogger.WriteToErrorLog(ex);
            }
        }
Ejemplo n.º 15
0
        public static void DisbandGuild(Client client)
        {
            if (client.Player.GuildAccess < Enums.GuildRank.Founder) {
                Messenger.PlayerMsg(client, "You are not the owner of this guild!", Text.BrightRed);
                return;
            }

            string guildName = client.Player.GuildName;

            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                DataManager.Players.PlayerDataManager.RemoveGuild(dbConnection.Database, guildName);
            }

            foreach (Client member in ClientManager.GetClients()) {
                if (member.Player.GuildName == guildName) {
                    member.Player.GuildName = "";
                    member.Player.GuildAccess = Enums.GuildRank.None;
                    Messenger.SendPlayerGuild(member);
                    Messenger.PlayerMsg(client, "Your guild has been disbanded.", Text.BrightRed);
                }
            }
        }
Ejemplo n.º 16
0
 public static Enums.BanType IsBanned(DatabaseConnection dbConnection, string column, string value)
 {
     IDataColumn[] columns = RetrieveField(dbConnection, "UnbanDate", column, value);
     IDataColumn[] dataColumns = RetrieveField(dbConnection, "BanType", column, value);
     if (columns != null) {
         string unbanDate = (string)columns[0].Value;
         if (unbanDate == "-----") {
             // It's a permanent ban.
             return (Enums.BanType)((int)dataColumns[0].Value);
         } else {
             // It's a temp ban
             DateTime dtUnbanDate = DateTime.Parse(unbanDate);
             if (DateTime.Now > dtUnbanDate) {
                 RemoveBan(dbConnection, column, value);
                 return Enums.BanType.None;
             } else {
                 return (Enums.BanType)((int)dataColumns[0].Value);
             }
         }
     } else {
         // columns was null, which means their entry was not found
         return Enums.BanType.None;
     }
 }
Ejemplo n.º 17
0
        public int GetTotalDungeonCompletionCount()
        {
            // On demand loading!
            if (playerData.DungeonCompletionCountsLoaded == false) {
                using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                    PlayerDataManager.LoadPlayerDungeonCompletionCounts(dbConnection.Database, playerData);
                }
            }
            int total = 0;

            for (int i = 0; i < DungeonCompletionCounts.Count; i++) {
                total += DungeonCompletionCounts.ValueByIndex(i);
            }

            return total;
        }
Ejemplo n.º 18
0
        public bool GetStoryState(int storyNum)
        {
            int index = StoryChapters.IndexOfKey(storyNum);
            if (index > -1) {
                return StoryChapters.ValueByIndex(index);
            } else {
                // Load on demand and cache
                bool state;
                using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                    state = PlayerDataManager.RetrievePlayerStoryChapterState(dbConnection.Database, CharID, storyNum);
                }
                StoryChapters.Add(storyNum, state);

                return state;
            }
        }
Ejemplo n.º 19
0
        public Enums.PokedexStat GetPokedexStatus(int pokemonID)
        {
            int index = RecruitList.IndexOfKey(pokemonID);
            if (index > -1) {
                return (Enums.PokedexStat)RecruitList.ValueByIndex(index);
            } else {
                byte status;
                using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                    status = PlayerDataManager.RetrievePlayerRecruitListStatus(dbConnection.Database, CharID, pokemonID);
                }
                RecruitList.Add(pokemonID, status);

                return (Enums.PokedexStat)status;
            }
        }
Ejemplo n.º 20
0
 public int GetDungeonCompletionCount(int dungeonIndex)
 {
     // On demand loading!
     if (playerData.DungeonCompletionCountsLoaded == false) {
         using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
             PlayerDataManager.LoadPlayerDungeonCompletionCounts(dbConnection.Database, playerData);
         }
     }
     int index = DungeonCompletionCounts.IndexOfKey(dungeonIndex);
     if (index > -1) {
         return DungeonCompletionCounts.ValueByIndex(index);
     } else {
         return -1;
     }
 }
Ejemplo n.º 21
0
        public void EndTempStatMode()
        {
            PacketHitList hitlist = null;
            PacketHitList.MethodStart(ref hitlist);

            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                for (int i = 0; i < Team.Length; i++) {
                    if (Team[i].Loaded && Team[i].InTempMode) {
                        int recruitIndex = Team[i].RecruitIndex;
                        Team[i] = new Recruit(client);
                        RecruitData recruitData = PlayerDataManager.LoadPlayerRecruit(dbConnection.Database, CharID, recruitIndex, false);
                        Team[i].LoadFromRecruitData(recruitData, recruitIndex);
                        PlayerDataManager.DeletePlayerRecruit(dbConnection.Database, CharID, recruitIndex, true);
                    }
                }
            }

            PacketBuilder.AppendPlayerData(client, hitlist);
            PacketBuilder.AppendStats(client, hitlist);
            PacketBuilder.AppendEXP(client, hitlist);

            PacketBuilder.AppendPlayerMoves(client, hitlist);
            PacketBuilder.AppendActiveTeam(client, hitlist);
        }
Ejemplo n.º 22
0
 public void DeleteFromRecruitmentBank(DatabaseConnection dbConnection, int recruitIndex, bool RemoveFromTeamSlot)
 {
     if (recruitIndex > 0) {
         if (RemoveFromTeamSlot) {
             for (int i = 0; i < Constants.MAX_ACTIVETEAM; i++) {
                 if (Team[i].RecruitIndex == recruitIndex) {
                     RemoveFromTeam(i);
                 }
             }
         }
         // Delete both the normal version, and the temp stat mode copy
         PlayerDataManager.DeletePlayerRecruit(dbConnection.Database, CharID, recruitIndex, false);
         PlayerDataManager.DeletePlayerRecruit(dbConnection.Database, CharID, recruitIndex, true);
     } else if (recruitIndex == 0) {
         Messenger.PlayerMsg(client, "You can't release your starter Pokémon!", Text.BrightRed);
     } else {
         Messenger.PlayerMsg(client, "Error: Unable to release selected Pokémon", Text.BrightRed);
     }
 }
Ejemplo n.º 23
0
        public void CreateCharacter(DatabaseConnection dbConnection, string name, Enums.Sex sex, int slot, bool silent)
        {
            PlayerData characterData = new PlayerData(PlayerID.GeneratePlayerID());
            characterData.Name = name;

            characterData.Map = MapManager.GenerateMapID(Settings.StartMap);
            characterData.X = Settings.StartX;
            characterData.Y = Settings.StartY;

            characterData.MaxInv = 20;
            characterData.MaxBank = 100;

            RecruitData leaderData = new RecruitData();
            leaderData.Name = name;
            leaderData.Sex = (byte)sex;
            leaderData.Species = 0;
            leaderData.Form = 1;
            leaderData.Level = 1;
            leaderData.HP = -1;

            Scripting.ScriptManager.InvokeSub("CharacterCreated", accountName, slot, characterData, leaderData);

            PlayerDataManager.CreateNewCharacter(dbConnection.Database, accountName, slot, characterData);

            //PlayerDataManager.SavePlayerAvailableExpKitModules(client.Database, playerData);
            //PlayerDataManager.SavePlayerCharacteristics(client.Database, playerData);
            //PlayerDataManager.SavePlayerGuild(client.Database, playerData);
            //PlayerDataManager.SavePlayerItemGenerals(client.Database, playerData);
            //PlayerDataManager.SavePlayerJobList(client.Database, playerData);
            //PlayerDataManager.SavePlayerLocation(client.Database, playerData);
            //PlayerDataManager.SavePlayerMissionBoardGenerals(client.Database, playerData);
            //PlayerDataManager.SavePlayerMissionBoardMissions(client.Database, playerData);
            //PlayerDataManager.SavePlayerMissionGenerals(client.Database, playerData);
            //PlayerDataManager.SavePlayerStoryGenerals(client.Database, playerData);
            //PlayerDataManager.SavePlayerStoryHelperStateSettings(client.Database, playerData);

            //// Save inventory
            //ListPair<int, PlayerDataInventoryItem> updatedInventory = new ListPair<int, PlayerDataInventoryItem>();
            //for (int i = 1; i <= Inventory.Count; i++) {
            //    if (Inventory[i].Updated) {
            //        updatedInventory.Add(i, Inventory[i].BaseInventoryItem);
            //        Inventory[i].Updated = false;
            //    }
            //}
            //PlayerDataManager.SavePlayerInventoryUpdates(client.Database, CharID, updatedInventory);

            //// Save bank
            //ListPair<int, PlayerDataInventoryItem> updatedBank = new ListPair<int, PlayerDataInventoryItem>();
            //for (int i = 1; i <= Bank.Count; i++) {
            //    if (Bank[i].Updated) {
            //        updatedBank.Add(i, Bank[i].BaseInventoryItem);
            //        Bank[i].Updated = false;
            //    }
            //}
            //PlayerDataManager.SavePlayerBankUpdates(client.Database, CharID, updatedBank);

            //// Save trigger events
            //playerData.TriggerEvents.Clear();
            //for (int i = 0; i < triggerEvents.Count; i++) {
            //    PlayerDataTriggerEvent triggerEvent = new PlayerDataTriggerEvent();
            //    triggerEvents[i].Save(triggerEvent);
            //    playerData.TriggerEvents.Add(triggerEvent);
            //}
            //PlayerDataManager.SavePlayerTriggerEvents(client.Database, playerData);

            //// Save team
            //for (int i = 0; i < team.Length; i++) {
            //    playerData.TeamMembers[i].RecruitIndex = team[i].RecruitIndex;
            //    playerData.TeamMembers[i].UsingTempStats = team[i].InTempMode;
            //    if (team[i].Loaded) {
            //        team[i].Save();
            //    }
            //}
            //PlayerDataManager.SavePlayerTeam(client.Database, playerData);

            PlayerDataManager.SavePlayerRecruit(dbConnection.Database, characterData.CharID, 0, leaderData);

            if (silent == false) {
                Messenger.SendChars(dbConnection, client);
                Messenger.PlainMsg(client, "Character has been created!", Enums.PlainMsgType.Chars);
            }
        }
Ejemplo n.º 24
0
 public bool CharacterExists(DatabaseConnection dbConnection, int slot)
 {
     return !PlayerDataManager.IsCharacterSlotEmpty(dbConnection.Database, accountName, slot);
 }
Ejemplo n.º 25
0
        public void BeginTempStatMode(int level, bool keepMoves)
        {
            PacketHitList hitlist = null;
            PacketHitList.MethodStart(ref hitlist);

            // Save the current team
            using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                for (int i = 0; i < Team.Length; i++) {
                    if (Team[i].Loaded) {
                        Team[i].Save(dbConnection);
                    }
                }
            }
            // Now that the team is saved, change the levels!
            for (int i = 0; i < Team.Length; i++) {
                if (Team[i].Loaded) {
                    Team[i].InTempMode = true;
                    Team[i].Level = level;
                    Team[i].Exp = 0;
                    Team[i].CalculateOriginalStats();
                    Team[i].HP = Team[i].MaxHP;
                    if (!keepMoves) {
                        for (int move = 0; move < Team[i].Moves.Length; move++) {
                            Team[i].Moves[move] = new RecruitMove();
                        }
                        Team[i].GenerateMoveset();
                    }
                }
            }

            PacketBuilder.AppendPlayerData(client, hitlist);
            PacketBuilder.AppendStats(client, hitlist);
            PacketBuilder.AppendEXP(client, hitlist);

            PacketBuilder.AppendPlayerMoves(client, hitlist);
            PacketBuilder.AppendActiveTeam(client, hitlist);

            PacketHitList.MethodEnded(ref hitlist);
        }
Ejemplo n.º 26
0
 //public int GetTeamSize() {
 //    int total = 0;
 //    for (int i = 0; i < Constants.MAX_ACTIVETEAM; i++) {
 //        if (team[i].Loaded) {
 //            if (team[i].RecruitIndex > -1 || team[i].RecruitBoost == -2) {
 //                total += team[i].Size;
 //            }
 //        }
 //    }
 //    return total;
 //}
 public void AddToTeam(int recruitIndex, int teamSlot)
 {
     using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
         if (((recruitIndex > -1 && IsInTeam(recruitIndex) == false && RecruitExists(dbConnection, recruitIndex)) || recruitIndex == -2) && (!(teamSlot < 0) || !(teamSlot > 3))) {
             Recruit recruit = new Recruit(client);
             recruit.LoadFromRecruitData(PlayerDataManager.LoadPlayerRecruit(dbConnection.Database, CharID, recruitIndex, false), recruitIndex);
             team[teamSlot] = recruit;
             for (int i = 0; i < team.Length; i++) {
                 if (team[i].RecruitIndex != -1) {
                     team[i].LoadActiveItemList();
                 }
             }
             if (recruitIndex != -2) {
                 ScriptManager.InvokeSub("RecruitAddedToTeam", client, teamSlot, recruitIndex);
             }
         }
     }
 }
Ejemplo n.º 27
0
        public int AddToRecruitmentBank(DatabaseConnection dbConnection, Recruit requestedRecruit)
        {
            int index = FindOpenRecruitmentSlot(dbConnection);
            if (index > -1 && index <= Constants.MAX_RECRUITMENTS) {

                PokemonCaught(requestedRecruit.Species);

                Recruit recruit = new Recruit(client);
                recruit.RecruitIndex = index;
                recruit.Level = requestedRecruit.Level;
                recruit.Species = requestedRecruit.Species;
                recruit.Form = requestedRecruit.Form;
                recruit.Sex = requestedRecruit.Sex;
                recruit.CalculateOriginalStats();
                recruit.Exp = requestedRecruit.Exp;
                recruit.IQ = requestedRecruit.IQ;
                //recruit.HP = recruit.MaxHP;
                recruit.Name = requestedRecruit.Name;
                recruit.NpcBase = requestedRecruit.NpcBase;
                recruit.AtkBonus = requestedRecruit.AtkBonus;
                recruit.DefBonus = requestedRecruit.DefBonus;
                recruit.SpclAtkBonus = requestedRecruit.SpclAtkBonus;
                recruit.SpclDefBonus = requestedRecruit.SpclDefBonus;
                recruit.SpdBonus = requestedRecruit.SpdBonus;
                recruit.MaxHPBonus = requestedRecruit.MaxHPBonus;

                for (int i = 0; i < Constants.MAX_PLAYER_MOVES; i++) {
                    recruit.Moves[i].MoveNum = requestedRecruit.Moves[i].MoveNum;
                    recruit.Moves[i].MaxPP = requestedRecruit.Moves[i].MaxPP;
                    recruit.Moves[i].CurrentPP = recruit.Moves[i].MaxPP;
                    recruit.Moves[i].Sealed = false;
                }
                recruit.Save(dbConnection);
                //Return the index of the recruited player
                return index;
            }
            //Return -1 so we know we're full
            return -1;
        }
Ejemplo n.º 28
0
 private int FindOpenRecruitmentSlot(DatabaseConnection dbConnection)
 {
     int slot = PlayerDataManager.FindOpenRecruitmentSlot(dbConnection.Database, CharID);
     if (slot > Constants.MAX_RECRUITMENTS) {
         slot = -1;
     }
     return slot;
 }
Ejemplo n.º 29
0
 internal void ChangePassword(DatabaseConnection dbConnection, string currentPassword, string newPassword)
 {
     if (!string.IsNullOrEmpty(accountName)) {
         PlayerDataManager.ChangePassword(dbConnection.Database, accountName, currentPassword, newPassword);
     }
 }
Ejemplo n.º 30
0
        public void AddFriend(string friendName)
        {
            Client pIndex = ClientManager.FindClient(friendName.Trim());
            string pName;
            if (pIndex != null) {
                pName = pIndex.Player.Name.Trim();
                if (pName.Trim().ToLower() == Name.Trim().ToLower()) {
                    Messenger.PlayerMsg(client, "You can't add yourself!", Text.BrightRed);
                    return;
                }
            } else {
                Messenger.PlayerMsg(client, "Player is not online", Text.White);
                return;
            }

            if (Friends.Count < 20) {
                int result;
                using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players)) {
                    result = Friends.AddFriend(dbConnection.Database, pName);
                }
                if (result == 0) {
                    SendFriendsList();
                    Messenger.PlayerMsg(client, pName + " has been added!", Text.Yellow);
                    ScriptManager.InvokeSub("FriendAdded", client, pName);
                } else if (result == 1) {
                    Messenger.PlayerMsg(client, "Player is already on your friends list!", Text.BrightRed);
                }
            } else {
                Messenger.PlayerMsg(client, "Friends list full", Text.BrightRed);
            }
        }
Ejemplo n.º 31
0
        public void ProcessCommandCallback(object obj)
        {
            int     activeLine  = (int)((ParamObject)obj).Param[0];
            string  command     = (string)((ParamObject)obj).Param[1];
            Command fullCommand = Server.CommandProcessor.ParseCommand(command);
            string  fullArgs    = CommandProcessor.JoinArgs(fullCommand.CommandArgs.ToArray());

            switch (fullCommand.CommandArgs[0].ToLower())
            {
            case "/help":
            {
                DisplayHelp();
            }
            break;

            case "/clear":
            {
            }
            break;

            case "/global":
            {
                Messenger.GlobalMsg(fullArgs, Text.White);
                ServerConsole.WriteLine("Global: " + fullArgs);
            }
            break;

            case "/masskick":
            {
                foreach (Client i in ClientManager.GetClients())
                {
                    if (i.IsPlaying() && Ranks.IsDisallowed(i, Enums.Rank.Monitor))
                    {
                        Messenger.GlobalMsg(i.Player.Name + " has been kicked by the server!", Text.White);
                        Messenger.AlertMsg(i, "You have been kicked by the server!");
                    }
                }
                ServerConsole.WriteLine("Everyone has been kicked.");
            }
            break;

            case "/dumpstats":
            {
                Statistics.PacketStatistics.DumpStatistics();
                ServerConsole.WriteLine("Packet statistics dumped to database.");
            }
            break;

            case "/clearstats":
            {
                Statistics.PacketStatistics.ClearStatistics();
                ServerConsole.WriteLine("Packet statistics cleared.");
            }
            break;

            case "/masswarp":
            {
                if (fullCommand.CommandArgs.Count == 4)
                {
                    int map = fullCommand.CommandArgs[1].ToInt(-1);
                    int x   = fullCommand.CommandArgs[2].ToInt(-1);
                    int y   = fullCommand.CommandArgs[3].ToInt(-1);
                    if (map <= 0)
                    {
                        ServerConsole.WriteLine("Invalid Map.");
                        break;
                    }
                    else if (x == -1)
                    {
                        ServerConsole.WriteLine("Invalid X coordinate.");
                        break;
                    }
                    else if (y == -1)
                    {
                        ServerConsole.WriteLine("Invalid Y coordinate.");
                        break;
                    }
                    // TODO: Mass Warp
                    //if (x > MapManager.Maps[map].MaxX) {
                    //    ServerConsole.WriteLine("Invalid X coordinate.");
                    //    break;
                    //}
                    //if (y > MapManager.Maps[map].MaxY) {
                    //    ServerConsole.WriteLine("Invalid Y coordinate.");
                    //    break;
                    //}
                    foreach (Client i in ClientManager.GetClients())
                    {
                        if (i.IsPlaying() && Ranks.IsDisallowed(i, Enums.Rank.Monitor))
                        {
                            Messenger.GlobalMsg("The server has warped everyone!", Text.White);
                            Messenger.PlayerWarp(i, map, x, y);
                        }
                    }
                    ServerConsole.WriteLine("Everyone has been warped.");
                }
                else
                {
                    ServerConsole.WriteLine("Invalid arguments.");
                }
            }
            break;

            case "/kick":
            {
                if (fullCommand.CommandArgs.Count == 2)
                {
                    Client client = ClientManager.FindClient(fullCommand.CommandArgs[1]);
                    if (client == null)
                    {
                        ServerConsole.WriteLine("Player is offline.");
                    }
                    else
                    {
                        Messenger.GlobalMsg(client.Player.Name + " has been kicked by the server!", Text.White);
                        Messenger.AlertMsg(client, "You have been kicked by the server!");
                        ServerConsole.WriteLine(client.Player.Name + " has been kicked!");
                    }
                }
                else
                {
                    ServerConsole.WriteLine("Invalid arguments.");
                }
            }
            break;

            case "/warp":
            {
                if (fullCommand.CommandArgs.Count == 5)
                {
                    Client client = ClientManager.FindClient(fullCommand.CommandArgs[1]);
                    if (client == null)
                    {
                        ServerConsole.WriteLine("Player is offline.");
                    }
                    else
                    {
                        int mapNum = fullCommand.CommandArgs[2].ToInt(-1);
                        int x      = fullCommand.CommandArgs[3].ToInt(-1);
                        int y      = fullCommand.CommandArgs[4].ToInt(-1);
                        if (mapNum <= 0)
                        {
                            ServerConsole.WriteLine("Invalid Map.");
                            break;
                        }
                        else if (x == -1)
                        {
                            ServerConsole.WriteLine("Invalid X coordinate.");
                            break;
                        }
                        else if (y == -1)
                        {
                            ServerConsole.WriteLine("Invalid Y coordinate.");
                            break;
                        }
                        IMap map;
                        if (MapManager.IsMapActive(MapManager.GenerateMapID(mapNum)))
                        {
                            map = MapManager.RetrieveActiveMap(MapManager.GenerateMapID(mapNum));
                        }
                        else
                        {
                            using (Database.DatabaseConnection dbConnection = new Database.DatabaseConnection(Database.DatabaseID.Data))
                            {
                                map = MapManager.LoadStandardMap(dbConnection, MapManager.GenerateMapID(mapNum));
                            }
                        }
                        if (x > map.MaxX)
                        {
                            ServerConsole.WriteLine("Invalid X coordinate.");
                            break;
                        }
                        if (y > map.MaxY)
                        {
                            ServerConsole.WriteLine("Invalid Y coordinate.");
                            break;
                        }
                        Messenger.PlayerMsg(client, "You have been warped by the server!", Text.White);
                        Messenger.PlayerWarp(client, mapNum, x, y);
                        ServerConsole.WriteLine(client.Player.Name + " has been warped.");
                    }
                }
                else
                {
                    ServerConsole.WriteLine("Invalid arguments.");
                }
            }
            break;

            case "/mapmsg":
            {
                if (fullCommand.CommandArgs.Count == 3)
                {
                    string map = fullCommand.CommandArgs[1];
                    // Check if the map is active
                    if (!MapManager.IsMapActive(map))
                    {
                        ServerConsole.WriteLine("Invalid Map.");
                        break;
                    }
                    Messenger.MapMsg(map, fullCommand.CommandArgs[2], Text.DarkGrey);
                    ServerConsole.WriteLine("Map Msg (Map " + map.ToString() + "): " + fullCommand.CommandArgs[2]);
                }
                else
                {
                    ServerConsole.WriteLine("Invalid arguments.");
                }
            }
            break;

            case "/reloadscripts":
            {
                Scripting.ScriptManager.Reload();
                ServerConsole.WriteLine("Scripts reloaded.");
            }
            break;

            case "/players":
            {
                string players = "";
                int    count   = 0;
                foreach (Client i in ClientManager.GetClients())
                {
                    if (i.IsPlaying())
                    {
                        count++;
                        players += i.Player.Name + "\r\n";
                    }
                }
                ServerConsole.WriteLine("Players online: \r\n" + players);
                ServerConsole.WriteLine("There are " + count.ToString() + " players online");
            }
            break;

            case "/test":
            {
                //Email.Email.SendEmail("test");
                //ServerConsole.WriteLine("Mail sent!");
                //ServerConsole.WriteLine("There are currently no benchmarking tests");
                //System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
                //watch.Start();
                //MapGeneralInfo genInfo = MapManager.RetrieveMapGeneralInfo(10);
                //watch.Stop();
                //ServerConsole.WriteLine("Elapsed, New: " + watch.Elapsed.ToString());
                //watch.Reset();
                //watch.Start();
                //Map map = MapManager.LoadMap(10);
                //watch.Stop();
                //ServerConsole.WriteLine("Elapsed, Old: " + watch.Elapsed.ToString());
                //ServerConsole.WriteLine("Name: " + genInfo.Name);
            }
            break;

            case "/finditem":
            {
                int itemsFound = 0;
                for (int i = 0; i < Server.Items.ItemManager.Items.MaxItems; i++)
                {
                    if (ItemManager.Items[i].Name.ToLower().StartsWith(fullCommand.CommandArgs[1].ToLower()))
                    {
                        ServerConsole.WriteLine(ItemManager.Items[i].Name + "'s number is " + i.ToString());
                        itemsFound++;
                        //return;
                    }
                }
                if (itemsFound == 0)
                {
                    ServerConsole.WriteLine("Unable to find an item that starts with '" + fullCommand.CommandArgs[1] + "'");
                }
            }
            break;

            case "/finditemc":
            {
                int itemsFound = 0;
                for (int i = 0; i < Server.Items.ItemManager.Items.MaxItems; i++)
                {
                    if (ItemManager.Items[i].Name.ToLower().Contains(fullCommand.CommandArgs[1].ToLower()))
                    {
                        ServerConsole.WriteLine(ItemManager.Items[i].Name + "'s number is " + i.ToString());
                        itemsFound++;
                        //return;
                    }
                }
                if (itemsFound == 0)
                {
                    ServerConsole.WriteLine("Unable to find an item that starts with '" + fullCommand.CommandArgs[1] + "'");
                }
            }
            break;

            case "/calcwm":
            {
                ServerConsole.WriteLine("Factorial: " + Server.Math.CalculateFactorial(fullCommand.CommandArgs[1].ToInt()).ToString("R"));
            }
            break;

            case "/gmmode":
            {
                Globals.GMOnly = !Globals.GMOnly;
                ServerConsole.WriteLine("GM Only Mode Active: " + Globals.GMOnly);
            }
            break;

            default:
            {
                Scripting.ScriptManager.InvokeSub("ProcessServerCommand", fullCommand, fullArgs);
            }
            break;
            }
        }