Exemple #1
0
        private void CopyDataToRecruitData()
        {
            if (recruitData == null)
            {
                recruitData = new RecruitData();
            }

            // General
            recruitData.UsingTempStats       = this.InTempMode;
            recruitData.Name                 = this.Name;
            recruitData.Nickname             = this.Nickname;
            recruitData.NpcBase              = this.NpcBase;
            recruitData.Species              = this.Species;
            recruitData.Sex                  = (byte)this.Sex;
            recruitData.Form                 = this.PermanentForm;
            recruitData.Costume              = this.Costume;
            recruitData.Shiny                = (int)this.Shiny;
            recruitData.Level                = this.Level;
            recruitData.Exp                  = this.Exp;
            recruitData.HP                   = this.HP;
            recruitData.StatusAilment        = (int)this.StatusAilment;
            recruitData.StatusAilmentCounter = this.StatusAilmentCounter;
            recruitData.IQ                   = this.IQ;
            recruitData.Belly                = this.Belly;
            recruitData.MaxBelly             = this.MaxBelly;
            recruitData.AtkBonus             = this.AtkBonus;
            recruitData.DefBonus             = this.DefBonus;
            recruitData.SpeedBonus           = this.SpeedBuff;
            recruitData.SpclAtkBonus         = this.SpclAtkBonus;
            recruitData.SpclDefBonus         = this.SpclDefBonus;

            // Moves
            for (int i = 0; i < this.Moves.Length; i++)
            {
                RecruitMove move = this.Moves[i];

                recruitData.Moves[i].MoveNum   = move.MoveNum;
                recruitData.Moves[i].CurrentPP = move.CurrentPP;
                recruitData.Moves[i].MaxPP     = move.MaxPP;
                //recruitData.Moves[i].Sealed = move.Sealed;
            }

            // Volatile status
            recruitData.VolatileStatus.Clear();
            for (int i = 0; i < this.VolatileStatus.Count; i++)
            {
                Characters.VolatileStatus recruitDataVolatileStatus = new Characters.VolatileStatus();
                recruitDataVolatileStatus.Name     = this.VolatileStatus[i].Name;
                recruitDataVolatileStatus.Emoticon = this.VolatileStatus[i].Emoticon;
                recruitDataVolatileStatus.Counter  = this.VolatileStatus[i].Counter;

                recruitData.VolatileStatus.Add(recruitDataVolatileStatus);
            }
        }
Exemple #2
0
        public Recruit(Client owner)
        {
            this.owner = owner;

            recruitData = new RecruitData();

            HeldItemSlot   = -1;
            Mobility       = new bool[16];
            Darkness       = -2;
            TimeMultiplier = 1000;
            ActiveItems    = new List <int>();
            VolatileStatus = new ExtraStatusCollection();
        }
Exemple #3
0
        public bool LoadCharacter(DatabaseConnection dbConnection, int characterSlot)
        {
            dataLock.EnterReadLock();
            bool   result      = false;
            string characterID = PlayerDataManager.RetrieveAccountCharacterID(dbConnection.Database, accountName, characterSlot);

            if (!string.IsNullOrEmpty(characterID))
            {
                playerData = new PlayerData(characterID);
                PlayerDataManager.LoadPlayerData(dbConnection.Database, playerData);
                PlayerDataManager.LoadPlayerStatistics(dbConnection.Database, playerData);
                PlayerDataManager.LoadPlayerMissionBoardMissions(dbConnection.Database, playerData);
                PlayerDataManager.LoadPlayerStoryHelperStateSettings(dbConnection.Database, playerData);
                PlayerDataManager.LoadPlayerJobList(dbConnection.Database, playerData);
                PlayerDataManager.LoadPlayerTriggerEvents(dbConnection.Database, playerData);

                inventory = new Inventory(playerData.Inventory);
                bank      = new Inventory(playerData.Bank);

                // Load available ExpKit modules
                if (string.IsNullOrEmpty(playerData.AvailableModules))
                {
                    AddEnabledExpKitModules();
                }
                else
                {
                    string[] modules = playerData.AvailableModules.Split(';');
                    availableExpKitModules = new AvailableExpKitModuleCollection(modules.Length);
                    AddEnabledExpKitModules();
                    for (int i = 0; i < modules.Length; i++)
                    {
                        if (modules[i].IsNumeric())
                        {
                            if (availableExpKitModules.Contains((Enums.ExpKitModules)modules[i].ToInt()) == false)
                            {
                                availableExpKitModules.Add(new AvailableExpKitModule((Enums.ExpKitModules)modules[i].ToInt(), false));
                            }
                        }
                    }
                }

                // Load statistics - Statistics data is inherited from PlayerData
                statistics = new Statistics.PlayerStatistics(this);

                // Load mission board data
                missionBoard = new WonderMails.MissionBoard(this);
                missionBoard.LoadMissionBoardData();
                missionBoard.UpdateMissionBoard();

                // Load joblist
                jobList = new WonderMailTasks(this);
                jobList.LoadJobList(playerData.JobList);

                //load mission goals [HIGH]
                goalPoints = new List <GoalPoint>();

                // Load story helper
                storyHelper = new StoryHelper(this);

                // Load trigger events [HIGH]
                triggerEvents = new List <Events.Player.TriggerEvents.ITriggerEvent>();

                // Load player team
                team = new Recruit[playerData.TeamMembers.Length];
                for (int i = 0; i < playerData.TeamMembers.Length; i++)
                {
                    team[i] = new Recruit(client);
                }
                for (int i = 0; i < playerData.TeamMembers.Length; i++)
                {
                    if (playerData.TeamMembers[i].RecruitIndex != -1)
                    {
                        RecruitData recruitData = PlayerDataManager.LoadPlayerRecruit(dbConnection.Database, CharID, playerData.TeamMembers[i].RecruitIndex, playerData.TeamMembers[i].UsingTempStats);
                        if (recruitData != null)
                        {
                            team[i].LoadFromRecruitData(recruitData, playerData.TeamMembers[i].RecruitIndex);
                        }
                        else
                        {
                            playerData.TeamMembers[i].RecruitIndex = -1;
                        }
                    }
                }

                for (int i = 0; i < playerData.TeamMembers.Length; i++)
                {
                    if (team[i].RecruitIndex != -1)
                    {
                        team[i].LoadActiveItemList();
                    }
                }

                // Set the explorer rank
                while (ExplorerRank != Enums.ExplorerRank.Guildmaster && MissionExp >= MissionManager.DetermineMissionExpRequirement(ExplorerRank + 1))
                {
                    ExplorerRank++;
                }

                if (MapID.IsNumeric())
                {
                    int mapNum = MapID.ToInt();
                    if (mapNum == -2)
                    {
                        MapID = MapManager.GenerateMapID(Settings.Crossroads);
                    }
                    else
                    {
                        MapID = "s" + MapID;
                    }
                }
                //            if (string.IsNullOrEmpty(this.id)) {
                //                id = PlayerID.GeneratePlayerID();
                //            }
                //PlayerID.AddPlayerToIndexList(CharID, client.TcpID);

                loaded = true;
            }

            dataLock.ExitReadLock();
            return(result);
        }
Exemple #4
0
        public void LoadFromRecruitData(RecruitData recruitData, int recruitIndex)
        {
            this.recruitData  = recruitData;
            base.RecruitIndex = recruitIndex;

            CopyDataFromRecruitData();

            if (Level <= -1)
            {
                return;
            }
            // Do checks
            if (base.HP < 0)
            {
                base.HP = 1;
            }
            if (IQ < 0)
            {
                IQ = 0;
            }
            if (MaxBelly <= 0)
            {
                MaxBelly = CalculateBaseMaxBelly();
                Belly    = MaxBelly;
            }
            if (Belly < 0 || Belly > MaxBelly)
            {
                Belly = MaxBelly;
            }

            //if (SpeciesOverride > 0 && SpeciesOverride <= Constants.TOTAL_POKEMON) {
            //    Species = SpeciesOverride;
            //} else {
            //Pokedex.Pokemon pokemon = Pokedex.Pokedex.FindBySprite(Sprite);
            //if (pokemon != null) {
            //    Species = pokemon.ID;
            //} else {
            //    Species = 0;
            //}
            //}
            if (Species < 0 || Species > Constants.TOTAL_POKEMON)
            {
                Species = 0;
            }

            CalculateOriginalSprite();
            CalculateOriginalStats();
            CalculateOriginalType();
            CalculateOriginalAbility();

            //CalculateOriginalMobility();

            // Do some more checks
            if (base.HP > MaxHP)
            {
                base.HP = MaxHP;
            }

            Loaded = true;

            if (Loaded)
            {
                // Verify move PP
                for (int i = 0; i < Moves.Length; i++)
                {
                    if (Moves[i].MoveNum > 0)
                    {
                        if (Moves[i].MaxPP == -1 || Moves[i].MaxPP != MoveManager.Moves[Moves[i].MoveNum].MaxPP)
                        {
                            Moves[i].MaxPP = MoveManager.Moves[Moves[i].MoveNum].MaxPP;
                        }
                        if (Moves[i].CurrentPP == -1 || Moves[i].CurrentPP > Moves[i].MaxPP)
                        {
                            Moves[i].CurrentPP = Moves[i].MaxPP;
                        }
                    }
                }

                // Add Active Items
                LoadActiveItemList();
            }
        }