Пример #1
0
        public static void SetFleetLevel(int fleetLevel)
        {
            Mem_record user_record = Comm_UserDatas.Instance.User_record;

            if (user_record.Level == fleetLevel)
            {
                return;
            }
            Dictionary <int, int> mstLevelUser = ArrayMaster.GetMstLevelUser();
            int num = 0;

            if (!mstLevelUser.TryGetValue(fleetLevel, ref num))
            {
                return;
            }
            uint exp  = user_record.Exp;
            int  num2 = (int)((long)num - (long)((ulong)exp));

            if (num2 < 0)
            {
                user_record.GetType().InvokeMember("_level", 2084, null, user_record, new object[]
                {
                    1
                });
                user_record.GetType().InvokeMember("_exp", 2084, null, user_record, new object[]
                {
                    0u
                });
                num2 = num;
            }
            user_record.UpdateExp(num2, mstLevelUser);
        }
Пример #2
0
        public static void SetFleetLevel(int fleetLevel)
        {
            Mem_record user_record = Comm_UserDatas.Instance.User_record;

            if (user_record.Level == fleetLevel)
            {
                return;
            }
            Dictionary <int, int> mstLevelUser = ArrayMaster.GetMstLevelUser();
            int value = 0;

            if (mstLevelUser.TryGetValue(fleetLevel, out value))
            {
                uint exp = user_record.Exp;
                int  num = (int)(value - exp);
                if (num < 0)
                {
                    user_record.GetType().InvokeMember("_level", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, user_record, new object[1]
                    {
                        1
                    });
                    user_record.GetType().InvokeMember("_exp", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, user_record, new object[1]
                    {
                        0u
                    });
                    num = value;
                }
                user_record.UpdateExp(num, mstLevelUser);
            }
        }
Пример #3
0
        public bool CreateNewUser(ICreateNewUser createInstance, DifficultKind difficult, int firstShip)
        {
            if (User_basic != null || createInstance == null)
            {
                return(false);
            }
            User_basic = new Mem_basic();
            User_basic.SetDifficult(difficult);
            User_record       = new Mem_record();
            User_turn         = new Mem_turn();
            User_trophy       = new Mem_trophy();
            User_plus         = new Mem_newgame_plus();
            User_deckpractice = new Mem_deckpractice();
            if (User_ndock.Count == 0)
            {
                Add_Ndock(1);
                Add_Ndock(1);
            }
            if (User_kdock.Count == 0)
            {
                Add_Kdock();
                Add_Kdock();
            }
            initMaterials(difficult);
            Add_Deck(1);
            List <int> list = Instance.Add_Ship(new List <int>
            {
                firstShip
            });

            Instance.User_deck[1].Ship[0] = list[0];
            List <Mst_furniture> furnitureDatas = User_room[1].getFurnitureDatas();
            Mem_furniture        furniture      = null;

            furnitureDatas.ForEach(delegate(Mst_furniture x)
            {
                furniture = new Mem_furniture(x.Id);
                User_furniture.Add(furniture.Rid, furniture);
            });
            Add_Slot(new List <int>
            {
                42,
                43
            });
            User_quest = new Dictionary <int, Mem_quest>();
            foreach (int key in Mst_DataManager.Instance.Mst_maparea.Keys)
            {
                Add_EscortDeck(key, key);
            }
            initTanker();
            UpdateDeckShipLocale();
            return(true);
        }
        public Api_Result <User_RecordFmt> Record()
        {
            Api_Result <User_RecordFmt> api_Result = new Api_Result <User_RecordFmt>();
            Mem_basic      user_basic     = Comm_UserDatas.Instance.User_basic;
            Mem_record     user_record    = Comm_UserDatas.Instance.User_record;
            User_RecordFmt user_RecordFmt = new User_RecordFmt();

            user_basic.SetUserRecordData(user_RecordFmt);
            user_record.SetUserRecordData(user_RecordFmt);
            user_RecordFmt.Deck_num  = Enumerable.Count <KeyValuePair <int, Mem_deck> >(Comm_UserDatas.Instance.User_deck);
            user_RecordFmt.Ship_num  = Enumerable.Count <KeyValuePair <int, Mem_ship> >(Comm_UserDatas.Instance.User_ship);
            user_RecordFmt.Slot_num  = Enumerable.Count <KeyValuePair <int, Mem_slotitem> >(Comm_UserDatas.Instance.User_slot);
            user_RecordFmt.Ndock_num = Enumerable.Count <KeyValuePair <int, Mem_ndock> >(Comm_UserDatas.Instance.User_ndock);
            user_RecordFmt.Kdock_num = Enumerable.Count <KeyValuePair <int, Mem_kdock> >(Comm_UserDatas.Instance.User_kdock);
            int num = Enumerable.Count <Mem_furniture>(Comm_UserDatas.Instance.User_furniture.get_Values(), (Mem_furniture x) => Mst_DataManager.Instance.Mst_furniture.get_Item(x.Rid).Price == 0 && Mst_DataManager.Instance.Mst_furniture.get_Item(x.Rid).Rarity == 0 && Mst_DataManager.Instance.Mst_furniture.get_Item(x.Rid).Title.Equals("なし"));

            user_RecordFmt.Furniture_num = Comm_UserDatas.Instance.User_furniture.get_Count() - num;
            user_RecordFmt.Material_max  = user_basic.GetMaterialMaxNum();
            api_Result.data = user_RecordFmt;
            return(api_Result);
        }
Пример #5
0
        public Api_Result <User_RecordFmt> Record()
        {
            Api_Result <User_RecordFmt> api_Result = new Api_Result <User_RecordFmt>();
            Mem_basic      user_basic     = Comm_UserDatas.Instance.User_basic;
            Mem_record     user_record    = Comm_UserDatas.Instance.User_record;
            User_RecordFmt user_RecordFmt = new User_RecordFmt();

            user_basic.SetUserRecordData(user_RecordFmt);
            user_record.SetUserRecordData(user_RecordFmt);
            user_RecordFmt.Deck_num  = Comm_UserDatas.Instance.User_deck.Count();
            user_RecordFmt.Ship_num  = Comm_UserDatas.Instance.User_ship.Count();
            user_RecordFmt.Slot_num  = Comm_UserDatas.Instance.User_slot.Count();
            user_RecordFmt.Ndock_num = Comm_UserDatas.Instance.User_ndock.Count();
            user_RecordFmt.Kdock_num = Comm_UserDatas.Instance.User_kdock.Count();
            int num = Comm_UserDatas.Instance.User_furniture.Values.Count((Mem_furniture x) => (Mst_DataManager.Instance.Mst_furniture[x.Rid].Price == 0 && Mst_DataManager.Instance.Mst_furniture[x.Rid].Rarity == 0 && Mst_DataManager.Instance.Mst_furniture[x.Rid].Title.Equals("なし")) ? true : false);

            user_RecordFmt.Furniture_num = Comm_UserDatas.Instance.User_furniture.Count - num;
            user_RecordFmt.Material_max  = user_basic.GetMaterialMaxNum();
            api_Result.data = user_RecordFmt;
            return(api_Result);
        }
        public bool SetPropertie()
        {
            Mem_basic  user_basic  = Comm_UserDatas.Instance.User_basic;
            Mem_record user_record = Comm_UserDatas.Instance.User_record;
            Dictionary <int, Mem_deck>      user_deck      = Comm_UserDatas.Instance.User_deck;
            Dictionary <int, Mem_kdock>     user_kdock     = Comm_UserDatas.Instance.User_kdock;
            Dictionary <int, Mem_ndock>     user_ndock     = Comm_UserDatas.Instance.User_ndock;
            Dictionary <int, Mem_ship>      user_ship      = Comm_UserDatas.Instance.User_ship;
            Dictionary <int, Mem_slotitem>  user_slot      = Comm_UserDatas.Instance.User_slot;
            Dictionary <int, Mem_furniture> user_furniture = Comm_UserDatas.Instance.User_furniture;

            this.Nickname     = user_basic.Nickname;
            this.Difficult    = user_basic.Difficult;
            this.Level        = user_record.Level;
            this.DeckNum      = user_deck.get_Count();
            this.KdockNum     = user_kdock.get_Count();
            this.NdockNum     = user_ndock.get_Count();
            this.ShipNum      = user_ship.get_Count();
            this.ShipMax      = user_basic.Max_chara;
            this.SlotNum      = user_slot.get_Count();
            this.SlotMax      = user_basic.Max_slotitem;
            this.FurnitureNum = user_furniture.get_Count();
            return(true);
        }
        public bool SetUserData()
        {
            XElement elements = VitaSaveManager.Instance.Elements;

            if (elements == null)
            {
                return(false);
            }
            Mem_basic        user_basic        = Model_Base.SetUserData <Mem_basic>(Enumerable.First <XElement>(elements.Elements(Mem_basic.tableName)));
            Mem_record       user_record       = Model_Base.SetUserData <Mem_record>(Enumerable.First <XElement>(elements.Elements(Mem_record.tableName)));
            Mem_turn         user_turn         = Model_Base.SetUserData <Mem_turn>(Enumerable.First <XElement>(elements.Elements(Mem_turn.tableName)));
            Mem_deckpractice user_deckpractice = Model_Base.SetUserData <Mem_deckpractice>(Enumerable.First <XElement>(elements.Elements(Mem_deckpractice.tableName)));
            XElement         xElement          = Enumerable.FirstOrDefault <XElement>(elements.Elements(Mem_trophy.tableName));
            Mem_trophy       user_trophy;

            if (xElement == null)
            {
                user_trophy = new Mem_trophy();
            }
            else
            {
                user_trophy = Model_Base.SetUserData <Mem_trophy>(xElement);
            }
            XElement         xElement2 = Enumerable.FirstOrDefault <XElement>(elements.Elements(Mem_newgame_plus.tableName));
            Mem_newgame_plus user_plus;

            if (xElement2 == null)
            {
                user_plus = new Mem_newgame_plus();
            }
            else
            {
                user_plus = Model_Base.SetUserData <Mem_newgame_plus>(xElement2);
            }
            this.User_basic        = null;
            this.User_basic        = user_basic;
            this.User_record       = null;
            this.User_record       = user_record;
            this.User_turn         = null;
            this.User_turn         = user_turn;
            this.User_deckpractice = null;
            this.User_deckpractice = user_deckpractice;
            this.User_trophy       = user_trophy;
            this.User_plus         = user_plus;
            Dictionary <int, Mem_book>         dictionary  = new Dictionary <int, Mem_book>();
            Dictionary <int, Mem_book>         dictionary2 = new Dictionary <int, Mem_book>();
            Dictionary <int, Mem_deck>         dictionary3 = new Dictionary <int, Mem_deck>();
            Dictionary <int, Mem_esccort_deck> dictionary4 = new Dictionary <int, Mem_esccort_deck>();
            Dictionary <int, Mem_furniture>    dictionary5 = new Dictionary <int, Mem_furniture>();
            Dictionary <int, Mem_kdock>        dictionary6 = new Dictionary <int, Mem_kdock>();
            Dictionary <int, Mem_mapcomp>      dictionary7 = new Dictionary <int, Mem_mapcomp>();
            Dictionary <int, Mem_mapclear>     dictionary8 = new Dictionary <int, Mem_mapclear>();
            Dictionary <enumMaterialCategory, Mem_material> dictionary9 = new Dictionary <enumMaterialCategory, Mem_material>();
            Dictionary <int, Mem_missioncomp>     dictionary10          = new Dictionary <int, Mem_missioncomp>();
            Dictionary <int, Mem_ndock>           dictionary11          = new Dictionary <int, Mem_ndock>();
            Dictionary <int, Mem_quest>           dictionary12          = new Dictionary <int, Mem_quest>();
            Dictionary <int, Mem_questcount>      dictionary13          = new Dictionary <int, Mem_questcount>();
            Dictionary <int, Mem_ship>            dictionary14          = new Dictionary <int, Mem_ship>();
            Dictionary <int, Mem_slotitem>        dictionary15          = new Dictionary <int, Mem_slotitem>();
            Dictionary <int, Mem_tanker>          dictionary16          = new Dictionary <int, Mem_tanker>();
            Dictionary <int, Mem_useitem>         dictionary17          = new Dictionary <int, Mem_useitem>();
            Dictionary <int, Mem_rebellion_point> dictionary18          = new Dictionary <int, Mem_rebellion_point>();
            Dictionary <int, Mem_room>            dictionary19          = new Dictionary <int, Mem_room>();
            HashSet <int>      hashSet  = new HashSet <int>();
            HashSet <int>      hashSet2 = new HashSet <int>();
            List <Mem_history> list     = new List <Mem_history>();

            using (IEnumerator <XElement> enumerator = Extensions.Elements <XElement>(elements.Elements("ship_books"), "mem_book").GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    XElement current  = enumerator.get_Current();
                    Mem_book mem_book = Model_Base.SetUserData <Mem_book>(current);
                    dictionary.Add(mem_book.Table_id, mem_book);
                }
            }
            this.Ship_book.Clear();
            this.Ship_book = dictionary;
            using (IEnumerator <XElement> enumerator2 = Extensions.Elements <XElement>(elements.Elements("slot_books"), "mem_book").GetEnumerator())
            {
                while (enumerator2.MoveNext())
                {
                    XElement current2  = enumerator2.get_Current();
                    Mem_book mem_book2 = Model_Base.SetUserData <Mem_book>(current2);
                    dictionary2.Add(mem_book2.Table_id, mem_book2);
                }
            }
            this.Slot_book.Clear();
            this.Slot_book = dictionary2;
            using (IEnumerator <XElement> enumerator3 = Extensions.Elements <XElement>(elements.Elements(Mem_deck.tableName + "s"), Mem_deck.tableName).GetEnumerator())
            {
                while (enumerator3.MoveNext())
                {
                    XElement current3 = enumerator3.get_Current();
                    Mem_deck mem_deck = Model_Base.SetUserData <Mem_deck>(current3);
                    dictionary3.Add(mem_deck.Rid, mem_deck);
                }
            }
            this.User_deck.Clear();
            this.User_deck = dictionary3;
            using (IEnumerator <XElement> enumerator4 = Extensions.Elements <XElement>(elements.Elements(Mem_esccort_deck.tableName + "s"), Mem_esccort_deck.tableName).GetEnumerator())
            {
                while (enumerator4.MoveNext())
                {
                    XElement         current4         = enumerator4.get_Current();
                    Mem_esccort_deck mem_esccort_deck = Model_Base.SetUserData <Mem_esccort_deck>(current4);
                    dictionary4.Add(mem_esccort_deck.Rid, mem_esccort_deck);
                }
            }
            this.User_EscortDeck.Clear();
            this.User_EscortDeck = dictionary4;
            using (IEnumerator <XElement> enumerator5 = Extensions.Elements <XElement>(elements.Elements(Mem_furniture.tableName + "s"), Mem_furniture.tableName).GetEnumerator())
            {
                while (enumerator5.MoveNext())
                {
                    XElement      current5      = enumerator5.get_Current();
                    Mem_furniture mem_furniture = Model_Base.SetUserData <Mem_furniture>(current5);
                    dictionary5.Add(mem_furniture.Rid, mem_furniture);
                }
            }
            this.User_furniture.Clear();
            this.User_furniture = dictionary5;
            using (IEnumerator <XElement> enumerator6 = Extensions.Elements <XElement>(elements.Elements(Mem_kdock.tableName + "s"), Mem_kdock.tableName).GetEnumerator())
            {
                while (enumerator6.MoveNext())
                {
                    XElement  current6  = enumerator6.get_Current();
                    Mem_kdock mem_kdock = Model_Base.SetUserData <Mem_kdock>(current6);
                    dictionary6.Add(mem_kdock.Rid, mem_kdock);
                }
            }
            this.User_kdock.Clear();
            this.User_kdock = dictionary6;
            using (IEnumerator <XElement> enumerator7 = Extensions.Elements <XElement>(elements.Elements(Mem_mapcomp.tableName + "s"), Mem_mapcomp.tableName).GetEnumerator())
            {
                while (enumerator7.MoveNext())
                {
                    XElement    current7    = enumerator7.get_Current();
                    Mem_mapcomp mem_mapcomp = Model_Base.SetUserData <Mem_mapcomp>(current7);
                    dictionary7.Add(mem_mapcomp.Rid, mem_mapcomp);
                }
            }
            this.User_mapcomp.Clear();
            this.User_mapcomp = dictionary7;
            using (IEnumerator <XElement> enumerator8 = Extensions.Elements <XElement>(elements.Elements(Mem_mapclear.tableName + "s"), Mem_mapclear.tableName).GetEnumerator())
            {
                while (enumerator8.MoveNext())
                {
                    XElement     current8     = enumerator8.get_Current();
                    Mem_mapclear mem_mapclear = Model_Base.SetUserData <Mem_mapclear>(current8);
                    dictionary8.Add(mem_mapclear.Rid, mem_mapclear);
                }
            }
            this.User_mapclear.Clear();
            this.User_mapclear = dictionary8;
            using (IEnumerator <XElement> enumerator9 = Extensions.Elements <XElement>(elements.Elements(Mem_material.tableName + "s"), Mem_material.tableName).GetEnumerator())
            {
                while (enumerator9.MoveNext())
                {
                    XElement     current9     = enumerator9.get_Current();
                    Mem_material mem_material = Model_Base.SetUserData <Mem_material>(current9);
                    dictionary9.Add(mem_material.Rid, mem_material);
                }
            }
            this.User_material.Clear();
            this.User_material = dictionary9;
            using (IEnumerator <XElement> enumerator10 = Extensions.Elements <XElement>(elements.Elements(Mem_missioncomp.tableName + "s"), Mem_missioncomp.tableName).GetEnumerator())
            {
                while (enumerator10.MoveNext())
                {
                    XElement        current10       = enumerator10.get_Current();
                    Mem_missioncomp mem_missioncomp = Model_Base.SetUserData <Mem_missioncomp>(current10);
                    dictionary10.Add(mem_missioncomp.Rid, mem_missioncomp);
                }
            }
            this.User_missioncomp.Clear();
            this.User_missioncomp = dictionary10;
            using (IEnumerator <XElement> enumerator11 = Extensions.Elements <XElement>(elements.Elements(Mem_ndock.tableName + "s"), Mem_ndock.tableName).GetEnumerator())
            {
                while (enumerator11.MoveNext())
                {
                    XElement  current11 = enumerator11.get_Current();
                    Mem_ndock mem_ndock = Model_Base.SetUserData <Mem_ndock>(current11);
                    dictionary11.Add(mem_ndock.Rid, mem_ndock);
                }
            }
            this.User_ndock.Clear();
            this.User_ndock = dictionary11;
            using (IEnumerator <XElement> enumerator12 = Extensions.Elements <XElement>(elements.Elements(Mem_quest.tableName + "s"), Mem_quest.tableName).GetEnumerator())
            {
                while (enumerator12.MoveNext())
                {
                    XElement  current12 = enumerator12.get_Current();
                    Mem_quest mem_quest = Model_Base.SetUserData <Mem_quest>(current12);
                    dictionary12.Add(mem_quest.Rid, mem_quest);
                }
            }
            this.User_quest.Clear();
            this.User_quest = dictionary12;
            using (IEnumerator <XElement> enumerator13 = Extensions.Elements <XElement>(elements.Elements(Mem_questcount.tableName + "s"), Mem_questcount.tableName).GetEnumerator())
            {
                while (enumerator13.MoveNext())
                {
                    XElement       current13      = enumerator13.get_Current();
                    Mem_questcount mem_questcount = Model_Base.SetUserData <Mem_questcount>(current13);
                    dictionary13.Add(mem_questcount.Rid, mem_questcount);
                }
            }
            this.User_questcount.Clear();
            this.User_questcount = dictionary13;
            using (IEnumerator <XElement> enumerator14 = Extensions.Elements <XElement>(elements.Elements(Mem_slotitem.tableName + "s"), Mem_slotitem.tableName).GetEnumerator())
            {
                while (enumerator14.MoveNext())
                {
                    XElement     current14    = enumerator14.get_Current();
                    Mem_slotitem mem_slotitem = Model_Base.SetUserData <Mem_slotitem>(current14);
                    dictionary15.Add(mem_slotitem.Rid, mem_slotitem);
                }
            }
            this.User_slot.Clear();
            this.User_slot = dictionary15;
            using (IEnumerator <XElement> enumerator15 = Extensions.Elements <XElement>(elements.Elements(Mem_ship.tableName + "s"), Mem_ship.tableName).GetEnumerator())
            {
                while (enumerator15.MoveNext())
                {
                    XElement current15 = enumerator15.get_Current();
                    Mem_ship mem_ship  = Model_Base.SetUserData <Mem_ship>(current15);
                    dictionary14.Add(mem_ship.Rid, mem_ship);
                }
            }
            this.User_ship.Clear();
            this.User_ship = dictionary14;
            using (IEnumerator <XElement> enumerator16 = Extensions.Elements <XElement>(elements.Elements(Mem_tanker.tableName + "s"), Mem_tanker.tableName).GetEnumerator())
            {
                while (enumerator16.MoveNext())
                {
                    XElement   current16  = enumerator16.get_Current();
                    Mem_tanker mem_tanker = Model_Base.SetUserData <Mem_tanker>(current16);
                    dictionary16.Add(mem_tanker.Rid, mem_tanker);
                }
            }
            this.User_tanker.Clear();
            this.User_tanker = dictionary16;
            using (IEnumerator <XElement> enumerator17 = Extensions.Elements <XElement>(elements.Elements(Mem_useitem.tableName + "s"), Mem_useitem.tableName).GetEnumerator())
            {
                while (enumerator17.MoveNext())
                {
                    XElement    current17   = enumerator17.get_Current();
                    Mem_useitem mem_useitem = Model_Base.SetUserData <Mem_useitem>(current17);
                    dictionary17.Add(mem_useitem.Rid, mem_useitem);
                }
            }
            this.User_useItem.Clear();
            this.User_useItem = dictionary17;
            using (IEnumerator <XElement> enumerator18 = Extensions.Elements <XElement>(elements.Elements(Mem_rebellion_point.tableName + "s"), Mem_rebellion_point.tableName).GetEnumerator())
            {
                while (enumerator18.MoveNext())
                {
                    XElement            current18           = enumerator18.get_Current();
                    Mem_rebellion_point mem_rebellion_point = Model_Base.SetUserData <Mem_rebellion_point>(current18);
                    dictionary18.Add(mem_rebellion_point.Rid, mem_rebellion_point);
                }
            }
            this.User_rebellion_point.Clear();
            this.User_rebellion_point = dictionary18;
            using (IEnumerator <XElement> enumerator19 = Extensions.Elements <XElement>(elements.Elements(Mem_room.tableName + "s"), Mem_room.tableName).GetEnumerator())
            {
                while (enumerator19.MoveNext())
                {
                    XElement current19 = enumerator19.get_Current();
                    Mem_room mem_room  = Model_Base.SetUserData <Mem_room>(current19);
                    dictionary19.Add(mem_room.Rid, mem_room);
                }
            }
            this.User_room.Clear();
            this.User_room = dictionary19;
            using (IEnumerator <XElement> enumerator20 = elements.Element("temp_escortships").Elements().GetEnumerator())
            {
                while (enumerator20.MoveNext())
                {
                    XElement current20 = enumerator20.get_Current();
                    string   value     = current20.get_Value();
                    hashSet.Add(int.Parse(value));
                }
            }
            this.Temp_escortship.Clear();
            this.Temp_escortship = hashSet;
            using (IEnumerator <XElement> enumerator21 = elements.Element("temp_deckships").Elements().GetEnumerator())
            {
                while (enumerator21.MoveNext())
                {
                    XElement current21 = enumerator21.get_Current();
                    string   value2    = current21.get_Value();
                    hashSet2.Add(int.Parse(value2));
                }
            }
            this.Temp_deckship.Clear();
            this.Temp_deckship = hashSet2;
            using (IEnumerator <XElement> enumerator22 = Extensions.Elements <XElement>(elements.Elements(Mem_history.tableName + "s"), Mem_history.tableName).GetEnumerator())
            {
                while (enumerator22.MoveNext())
                {
                    XElement    current22   = enumerator22.get_Current();
                    Mem_history mem_history = Model_Base.SetUserData <Mem_history>(current22);
                    list.Add(mem_history);
                }
            }
            this.User_history.Clear();
            list.ForEach(delegate(Mem_history x)
            {
                this.Add_History(x);
            });
            return(true);
        }
Пример #8
0
        public bool NewGamePlus(ICreateNewUser createInstance, string nickName, DifficultKind selectedRank, int firstShipId)
        {
            if (createInstance == null)
            {
                return(false);
            }
            bool flag = Utils.IsGameClear();
            List <DifficultKind> kind = User_record.ClearDifficult.ToList();

            PurgeUserData(createInstance, plusGame: true);
            if (flag)
            {
                Add_Useitem(55, 1);
            }
            foreach (Mem_book item in User_plus.Ship_book)
            {
                Ship_book.Add(item.Table_id, item);
            }
            foreach (Mem_book item2 in User_plus.Slot_book)
            {
                Slot_book.Add(item2.Table_id, item2);
            }
            User_basic = new Mem_basic();
            User_basic.UpdateNickName(nickName);
            User_basic.SetDifficult(selectedRank);
            User_record       = new Mem_record(createInstance, User_plus, kind);
            User_turn         = new Mem_turn();
            User_deckpractice = new Mem_deckpractice();
            if (User_ndock.Count == 0)
            {
                Add_Ndock(1);
                Add_Ndock(1);
            }
            if (User_kdock.Count == 0)
            {
                Add_Kdock();
                Add_Kdock();
            }
            initMaterials(selectedRank);
            Add_Deck(1);
            User_room[1].getFurnitureDatas();
            foreach (Mem_furniture item3 in User_plus.Furniture)
            {
                User_furniture.Add(item3.Rid, item3);
            }
            foreach (Mem_slotitem item4 in User_plus.Slotitem)
            {
                User_slot.Add(item4.Rid, item4);
            }
            foreach (Mem_shipBase item5 in User_plus.Ship)
            {
                Mem_ship mem_ship = new Mem_ship();
                Mst_ship mst_data = Mst_DataManager.Instance.Mst_ship[item5.Ship_id];
                mem_ship.Set_ShipParam(item5, mst_data, enemy_flag: false);
                mem_ship.Set_ShipParamNewGamePlus(createInstance);
                User_ship.Add(mem_ship.Rid, mem_ship);
            }
            List <int> list = Add_Ship(new List <int>
            {
                firstShipId
            });

            Instance.User_deck[1].Ship[0] = list[0];
            User_quest = new Dictionary <int, Mem_quest>();
            foreach (int key in Mst_DataManager.Instance.Mst_maparea.Keys)
            {
                Add_EscortDeck(key, key);
            }
            initTanker();
            UpdateDeckShipLocale();
            return(true);
        }
Пример #9
0
        public bool SetUserData()
        {
            XElement elements = VitaSaveManager.Instance.Elements;

            if (elements == null)
            {
                return(false);
            }
            Mem_basic        user_basic        = Model_Base.SetUserData <Mem_basic>(elements.Elements(Mem_basic.tableName).First());
            Mem_record       user_record       = Model_Base.SetUserData <Mem_record>(elements.Elements(Mem_record.tableName).First());
            Mem_turn         user_turn         = Model_Base.SetUserData <Mem_turn>(elements.Elements(Mem_turn.tableName).First());
            Mem_deckpractice user_deckpractice = Model_Base.SetUserData <Mem_deckpractice>(elements.Elements(Mem_deckpractice.tableName).First());
            XElement         xElement          = elements.Elements(Mem_trophy.tableName).FirstOrDefault();
            Mem_trophy       user_trophy       = (xElement != null) ? Model_Base.SetUserData <Mem_trophy>(xElement) : new Mem_trophy();
            XElement         xElement2         = elements.Elements(Mem_newgame_plus.tableName).FirstOrDefault();
            Mem_newgame_plus user_plus         = (xElement2 != null) ? Model_Base.SetUserData <Mem_newgame_plus>(xElement2) : new Mem_newgame_plus();

            User_basic        = null;
            User_basic        = user_basic;
            User_record       = null;
            User_record       = user_record;
            User_turn         = null;
            User_turn         = user_turn;
            User_deckpractice = null;
            User_deckpractice = user_deckpractice;
            User_trophy       = user_trophy;
            User_plus         = user_plus;
            Dictionary <int, Mem_book>         dictionary  = new Dictionary <int, Mem_book>();
            Dictionary <int, Mem_book>         dictionary2 = new Dictionary <int, Mem_book>();
            Dictionary <int, Mem_deck>         dictionary3 = new Dictionary <int, Mem_deck>();
            Dictionary <int, Mem_esccort_deck> dictionary4 = new Dictionary <int, Mem_esccort_deck>();
            Dictionary <int, Mem_furniture>    dictionary5 = new Dictionary <int, Mem_furniture>();
            Dictionary <int, Mem_kdock>        dictionary6 = new Dictionary <int, Mem_kdock>();
            Dictionary <int, Mem_mapcomp>      dictionary7 = new Dictionary <int, Mem_mapcomp>();
            Dictionary <int, Mem_mapclear>     dictionary8 = new Dictionary <int, Mem_mapclear>();
            Dictionary <enumMaterialCategory, Mem_material> dictionary9 = new Dictionary <enumMaterialCategory, Mem_material>();
            Dictionary <int, Mem_missioncomp>     dictionary10          = new Dictionary <int, Mem_missioncomp>();
            Dictionary <int, Mem_ndock>           dictionary11          = new Dictionary <int, Mem_ndock>();
            Dictionary <int, Mem_quest>           dictionary12          = new Dictionary <int, Mem_quest>();
            Dictionary <int, Mem_questcount>      dictionary13          = new Dictionary <int, Mem_questcount>();
            Dictionary <int, Mem_ship>            dictionary14          = new Dictionary <int, Mem_ship>();
            Dictionary <int, Mem_slotitem>        dictionary15          = new Dictionary <int, Mem_slotitem>();
            Dictionary <int, Mem_tanker>          dictionary16          = new Dictionary <int, Mem_tanker>();
            Dictionary <int, Mem_useitem>         dictionary17          = new Dictionary <int, Mem_useitem>();
            Dictionary <int, Mem_rebellion_point> dictionary18          = new Dictionary <int, Mem_rebellion_point>();
            Dictionary <int, Mem_room>            dictionary19          = new Dictionary <int, Mem_room>();
            HashSet <int>      hashSet  = new HashSet <int>();
            HashSet <int>      hashSet2 = new HashSet <int>();
            List <Mem_history> list     = new List <Mem_history>();

            foreach (XElement item2 in elements.Elements("ship_books").Elements("mem_book"))
            {
                Mem_book mem_book = Model_Base.SetUserData <Mem_book>(item2);
                dictionary.Add(mem_book.Table_id, mem_book);
            }
            Ship_book.Clear();
            Ship_book = dictionary;
            foreach (XElement item3 in elements.Elements("slot_books").Elements("mem_book"))
            {
                Mem_book mem_book2 = Model_Base.SetUserData <Mem_book>(item3);
                dictionary2.Add(mem_book2.Table_id, mem_book2);
            }
            Slot_book.Clear();
            Slot_book = dictionary2;
            foreach (XElement item4 in elements.Elements(Mem_deck.tableName + "s").Elements(Mem_deck.tableName))
            {
                Mem_deck mem_deck = Model_Base.SetUserData <Mem_deck>(item4);
                dictionary3.Add(mem_deck.Rid, mem_deck);
            }
            User_deck.Clear();
            User_deck = dictionary3;
            foreach (XElement item5 in elements.Elements(Mem_esccort_deck.tableName + "s").Elements(Mem_esccort_deck.tableName))
            {
                Mem_esccort_deck mem_esccort_deck = Model_Base.SetUserData <Mem_esccort_deck>(item5);
                dictionary4.Add(mem_esccort_deck.Rid, mem_esccort_deck);
            }
            User_EscortDeck.Clear();
            User_EscortDeck = dictionary4;
            foreach (XElement item6 in elements.Elements(Mem_furniture.tableName + "s").Elements(Mem_furniture.tableName))
            {
                Mem_furniture mem_furniture = Model_Base.SetUserData <Mem_furniture>(item6);
                dictionary5.Add(mem_furniture.Rid, mem_furniture);
            }
            User_furniture.Clear();
            User_furniture = dictionary5;
            foreach (XElement item7 in elements.Elements(Mem_kdock.tableName + "s").Elements(Mem_kdock.tableName))
            {
                Mem_kdock mem_kdock = Model_Base.SetUserData <Mem_kdock>(item7);
                dictionary6.Add(mem_kdock.Rid, mem_kdock);
            }
            User_kdock.Clear();
            User_kdock = dictionary6;
            foreach (XElement item8 in elements.Elements(Mem_mapcomp.tableName + "s").Elements(Mem_mapcomp.tableName))
            {
                Mem_mapcomp mem_mapcomp = Model_Base.SetUserData <Mem_mapcomp>(item8);
                dictionary7.Add(mem_mapcomp.Rid, mem_mapcomp);
            }
            User_mapcomp.Clear();
            User_mapcomp = dictionary7;
            foreach (XElement item9 in elements.Elements(Mem_mapclear.tableName + "s").Elements(Mem_mapclear.tableName))
            {
                Mem_mapclear mem_mapclear = Model_Base.SetUserData <Mem_mapclear>(item9);
                dictionary8.Add(mem_mapclear.Rid, mem_mapclear);
            }
            User_mapclear.Clear();
            User_mapclear = dictionary8;
            foreach (XElement item10 in elements.Elements(Mem_material.tableName + "s").Elements(Mem_material.tableName))
            {
                Mem_material mem_material = Model_Base.SetUserData <Mem_material>(item10);
                dictionary9.Add(mem_material.Rid, mem_material);
            }
            User_material.Clear();
            User_material = dictionary9;
            foreach (XElement item11 in elements.Elements(Mem_missioncomp.tableName + "s").Elements(Mem_missioncomp.tableName))
            {
                Mem_missioncomp mem_missioncomp = Model_Base.SetUserData <Mem_missioncomp>(item11);
                dictionary10.Add(mem_missioncomp.Rid, mem_missioncomp);
            }
            User_missioncomp.Clear();
            User_missioncomp = dictionary10;
            foreach (XElement item12 in elements.Elements(Mem_ndock.tableName + "s").Elements(Mem_ndock.tableName))
            {
                Mem_ndock mem_ndock = Model_Base.SetUserData <Mem_ndock>(item12);
                dictionary11.Add(mem_ndock.Rid, mem_ndock);
            }
            User_ndock.Clear();
            User_ndock = dictionary11;
            foreach (XElement item13 in elements.Elements(Mem_quest.tableName + "s").Elements(Mem_quest.tableName))
            {
                Mem_quest mem_quest = Model_Base.SetUserData <Mem_quest>(item13);
                dictionary12.Add(mem_quest.Rid, mem_quest);
            }
            User_quest.Clear();
            User_quest = dictionary12;
            foreach (XElement item14 in elements.Elements(Mem_questcount.tableName + "s").Elements(Mem_questcount.tableName))
            {
                Mem_questcount mem_questcount = Model_Base.SetUserData <Mem_questcount>(item14);
                dictionary13.Add(mem_questcount.Rid, mem_questcount);
            }
            User_questcount.Clear();
            User_questcount = dictionary13;
            foreach (XElement item15 in elements.Elements(Mem_slotitem.tableName + "s").Elements(Mem_slotitem.tableName))
            {
                Mem_slotitem mem_slotitem = Model_Base.SetUserData <Mem_slotitem>(item15);
                dictionary15.Add(mem_slotitem.Rid, mem_slotitem);
            }
            User_slot.Clear();
            User_slot = dictionary15;
            foreach (XElement item16 in elements.Elements(Mem_ship.tableName + "s").Elements(Mem_ship.tableName))
            {
                Mem_ship mem_ship = Model_Base.SetUserData <Mem_ship>(item16);
                dictionary14.Add(mem_ship.Rid, mem_ship);
            }
            User_ship.Clear();
            User_ship = dictionary14;
            foreach (XElement item17 in elements.Elements(Mem_tanker.tableName + "s").Elements(Mem_tanker.tableName))
            {
                Mem_tanker mem_tanker = Model_Base.SetUserData <Mem_tanker>(item17);
                dictionary16.Add(mem_tanker.Rid, mem_tanker);
            }
            User_tanker.Clear();
            User_tanker = dictionary16;
            foreach (XElement item18 in elements.Elements(Mem_useitem.tableName + "s").Elements(Mem_useitem.tableName))
            {
                Mem_useitem mem_useitem = Model_Base.SetUserData <Mem_useitem>(item18);
                dictionary17.Add(mem_useitem.Rid, mem_useitem);
            }
            User_useItem.Clear();
            User_useItem = dictionary17;
            foreach (XElement item19 in elements.Elements(Mem_rebellion_point.tableName + "s").Elements(Mem_rebellion_point.tableName))
            {
                Mem_rebellion_point mem_rebellion_point = Model_Base.SetUserData <Mem_rebellion_point>(item19);
                dictionary18.Add(mem_rebellion_point.Rid, mem_rebellion_point);
            }
            User_rebellion_point.Clear();
            User_rebellion_point = dictionary18;
            foreach (XElement item20 in elements.Elements(Mem_room.tableName + "s").Elements(Mem_room.tableName))
            {
                Mem_room mem_room = Model_Base.SetUserData <Mem_room>(item20);
                dictionary19.Add(mem_room.Rid, mem_room);
            }
            User_room.Clear();
            User_room = dictionary19;
            foreach (XElement item21 in elements.Element("temp_escortships").Elements())
            {
                string value = item21.Value;
                hashSet.Add(int.Parse(value));
            }
            Temp_escortship.Clear();
            Temp_escortship = hashSet;
            foreach (XElement item22 in elements.Element("temp_deckships").Elements())
            {
                string value2 = item22.Value;
                hashSet2.Add(int.Parse(value2));
            }
            Temp_deckship.Clear();
            Temp_deckship = hashSet2;
            foreach (XElement item23 in elements.Elements(Mem_history.tableName + "s").Elements(Mem_history.tableName))
            {
                Mem_history item = Model_Base.SetUserData <Mem_history>(item23);
                list.Add(item);
            }
            User_history.Clear();
            list.ForEach(delegate(Mem_history x)
            {
                Add_History(x);
            });
            return(true);
        }
Пример #10
0
        private BattleResultFmt getData()
        {
            BattleResultFmt ret = new BattleResultFmt();

            if (!practiceFlag)
            {
                ret.QuestName = mst_mapinfo.Name;
            }
            ret.EnemyName = E_Data.Enemy_Name;
            E_Data.ShipData.ForEach(delegate(Mem_ship x)
            {
                ret.EnemyId.Add(x.Ship_id);
            });
            ret.WinRank = getWinRank();
            if (isMvpGet(ret.WinRank))
            {
                Dictionary <int, BattleShipSubInfo> subInfoDict = F_SubInfo.Values.ToDictionary((BattleShipSubInfo key) => key.DeckIdx, (BattleShipSubInfo value) => value);
                int mvp = getMvp(ret.WinRank, subInfoDict);
                ret.MvpShip = mvp;
            }
            Mem_record user_record = Comm_UserDatas.Instance.User_record;
            int        addValue;

            if (!practiceFlag)
            {
                int num = Mst_maparea.MaxMapNum(Comm_UserDatas.Instance.User_basic.Difficult, mst_mapinfo.Maparea_id);
                ret.GetBaseExp = mst_enemy.Experience;
                ret.GetShipExp = getShipExpSortie(ret.WinRank, ret.MvpShip, ret.GetBaseExp);
                addValue       = getUserExpSortie(ret.WinRank);
                SerializableDictionary <int, List <int> > lvupInfo = null;
                updateShip(ret.WinRank, ret.MvpShip, ret.GetShipExp, out lvupInfo);
                ret.LevelUpInfo = lvupInfo;
                bool flag           = Utils.IsBattleWin(ret.WinRank);
                bool takeAwayBattle = false;
                if (cleard != null && (cleard.State == MapClearState.InvationNeighbor || cleard.State == MapClearState.InvationOpen))
                {
                    takeAwayBattle = true;
                }
                if (flag)
                {
                    List <ItemGetFmt> list    = new List <ItemGetFmt>();
                    ItemGetFmt        getShip = null;
                    bool flag2 = isLastDance(Comm_UserDatas.Instance.User_basic.Difficult);
                    if (!flag2)
                    {
                        getRewardShip(ret.WinRank, out getShip);
                        if (getShip != null)
                        {
                            if (Comm_UserDatas.Instance.User_turn.Total_turn <= 100 && Comm_UserDatas.Instance.User_ship.Values.Any((Mem_ship x) => x.Ship_id == getShip.Id))
                            {
                                getRewardShip(ret.WinRank, out getShip);
                            }
                            if (getShip != null && Comm_UserDatas.Instance.User_ship.Values.Any((Mem_ship x) => x.Ship_id == getShip.Id))
                            {
                                getRewardShip(ret.WinRank, out getShip);
                            }
                        }
                    }
                    else
                    {
                        getClearShip(Comm_UserDatas.Instance.User_basic.Difficult, ret.WinRank, out getShip);
                    }
                    if (getShip != null)
                    {
                        addShip(getShip.Id, flag2);
                        list.Add(getShip);
                    }
                    if (list.Count > 0)
                    {
                        ret.GetItem = list;
                    }
                    if (!isRebellionBattle)
                    {
                        List <int> diffMapOpen = null;
                        List <int> reOpenMap   = null;
                        ret.FirstClear   = updateMapComp(out diffMapOpen, out reOpenMap);
                        ret.NewOpenMapId = diffMapOpen;
                        ret.ReOpenMapId  = reOpenMap;
                        if (ret.FirstClear && Utils.IsGameClear())
                        {
                            user_record.AddClearDifficult(Comm_UserDatas.Instance.User_basic.Difficult);
                        }
                        else if (ret.FirstClear && mst_mapinfo.No == num)
                        {
                            ItemGetFmt itemGetFmt = new ItemGetFmt();
                            itemGetFmt.Id           = 57;
                            itemGetFmt.Count        = 1;
                            itemGetFmt.Category     = ItemGetKinds.UseItem;
                            ret.AreaClearRewardItem = itemGetFmt;
                            Comm_UserDatas.Instance.Add_Useitem(itemGetFmt.Id, itemGetFmt.Count);
                        }
                        if (mst_enemy.Boss != 0)
                        {
                            ret.FirstAreaComplete = updateAreaCompHisory(num);
                        }
                    }
                    if (mst_enemy.Boss != 0 && airCellItems != null)
                    {
                        ret.GetAirReconnaissanceItems = airCellItems;
                    }
                }
                else if (mst_enemy.Boss != 0 && airCellItems != null)
                {
                    ret.GetAirReconnaissanceItems = new List <MapItemGetFmt>();
                }
                if (isRebellionBattle)
                {
                    updateRebellion(ret.WinRank);
                    ret.FirstClear = false;
                }
                bool rebellionBoss = (isRebellionBattle && mst_enemy.Boss != 0) ? true : false;
                user_record.UpdateSortieCount(ret.WinRank, rebellionBoss);
                if (ret.FirstClear)
                {
                    ret.GetSpoint = mst_mapinfo.Clear_spoint;
                    Comm_UserDatas.Instance.User_basic.AddPoint(ret.GetSpoint);
                }
                deleteLostShip();
                if (mst_enemy.Boss != 0)
                {
                    updateHistory(flag, ret.NewOpenMapId, takeAwayBattle);
                }
            }
            else
            {
                ret.GetBaseExp = getBaseExpPractice(ret.WinRank);
                ret.GetShipExp = getShipExpPractice(ret.WinRank, ret.MvpShip, ret.GetBaseExp);
                addValue       = getUserExpPractice(ret.WinRank, Comm_UserDatas.Instance.User_record.Level, E_Data.ShipData[0].Level);
                SerializableDictionary <int, List <int> > lvupInfo2 = null;
                updateShip(ret.WinRank, ret.MvpShip, ret.GetShipExp, out lvupInfo2);
                updateShipPracticeEnemy(ret.GetShipExp, ref lvupInfo2);
                ret.LevelUpInfo = lvupInfo2;
                user_record.UpdatePracticeCount(ret.WinRank, practiceBattle: true);
            }
            Comm_UserDatas.Instance.UpdateShipBookBrokenClothState(clothBrokenIds);
            ret.BasicLevel = user_record.UpdateExp(addValue, Mst_DataManager.Instance.Get_MstLevel(shipTable: false));
            return(ret);
        }