private void _UpdateSlotitems()
{
this._slotitems = new List <SlotitemModel>();
Api_Result <Dictionary <int, Mem_slotitem> > api_Result = new Api_get_Member().Slotitem();
if (api_Result.state == Api_Result_State.Success && api_Result.data != null)
{
for (int i = 0; i < this.SlotCount; i++)
{
if (this._mem_data.Slot.get_Item(i) == -1)
{
this._slotitems.Add(null);
}
else
{
Mem_slotitem data = api_Result.data.get_Item(this._mem_data.Slot.get_Item(i));
this._slotitems.Add(new SlotitemModel(data));
}
}
if (this._mem_data.Exslot <= 0)
{
this._slotitem_ex = null;
}
else
{
Mem_slotitem data2 = api_Result.data.get_Item(this._mem_data.Exslot);
this._slotitem_ex = new SlotitemModel(data2);
}
}
while (this._slotitems.get_Count() < this.SlotCount)
{
this._slotitems.Add(null);
}
}
private void __UpdateCount__()
{
Dictionary <int, Mem_slotitem> dictionary = null;
for (int i = 0; i < _have_items.Count; i++)
{
ItemlistModel itemlistModel = _have_items[i];
Mst_item_shop mst_cabinet = _cabinet_relations[itemlistModel];
if (mst_cabinet == null || !mst_cabinet.IsChildReference() || mst_cabinet.Item2_type == 1)
{
itemlistModel.__SetOverrideCount__(0);
}
else if (mst_cabinet.Item2_type == 2)
{
if (dictionary == null)
{
dictionary = new Api_get_Member().Slotitem().data;
}
int value = dictionary.Count((KeyValuePair <int, Mem_slotitem> item) => item.Value.Slotitem_id == mst_cabinet.Item2_id);
itemlistModel.__SetOverrideCount__(value);
}
else if (mst_cabinet.Item2_type == 3)
{
enumMaterialCategory item2_id = (enumMaterialCategory)mst_cabinet.Item2_id;
int count = base.Material.GetCount(item2_id);
itemlistModel.__SetOverrideCount__(count);
}
else
{
itemlistModel.__SetOverrideCount__(0);
}
}
}
public PracticeManager(int deck_id)
{
this._current_deck = base.UserInfo.GetDeck(deck_id);
base._CreateMapAreaModel();
this._reqPrac = new Api_req_PracticeDeck();
this._valid_deck_prac_type_dic = new Dictionary <DeckPracticeType, bool>();
Api_Result <Mem_deckpractice> api_Result = new Api_get_Member().DeckPractice();
if (api_Result.state == Api_Result_State.Success)
{
Mem_deckpractice data = api_Result.data;
this._InitValidDeckPracType(DeckPracticeType.Normal, data, ref this._valid_deck_prac_type_dic);
this._InitValidDeckPracType(DeckPracticeType.Hou, data, ref this._valid_deck_prac_type_dic);
this._InitValidDeckPracType(DeckPracticeType.Rai, data, ref this._valid_deck_prac_type_dic);
this._InitValidDeckPracType(DeckPracticeType.Taisen, data, ref this._valid_deck_prac_type_dic);
this._InitValidDeckPracType(DeckPracticeType.Kouku, data, ref this._valid_deck_prac_type_dic);
this._InitValidDeckPracType(DeckPracticeType.Sougou, data, ref this._valid_deck_prac_type_dic);
}
DeckModel[] decks = this.MapArea.GetDecks();
this._rival_decks = new List <DeckModel>();
this._validation_results = new Dictionary <int, List <IsGoCondition> >();
for (int i = 0; i < decks.Length; i++)
{
DeckModel deckModel = decks[i];
if (deckModel.Count != 0)
{
if (deckModel.Id != this._current_deck.Id)
{
this._rival_decks.Add(deckModel);
this._validation_results.Add(deckModel.Id, deckModel.IsValidPractice());
}
}
}
this._validation_results.Add(this._current_deck.Id, this._current_deck.IsValidPractice());
}
public void Init()
{
if (_ship == null || _slot == null)
{
Api_get_Member api_get_Member = new Api_get_Member();
api_get_Member.InitBookData();
Api_Result <Dictionary <int, User_BookFmt <BookShipData> > > api_Result = api_get_Member.PictureShip();
_ship = new Dictionary <int, IAlbumModel>();
if (api_Result.state == Api_Result_State.Success)
{
foreach (KeyValuePair <int, User_BookFmt <BookShipData> > datum in api_Result.data)
{
if (datum.Value != null)
{
_ship[datum.Key] = new AlbumShipModel(datum.Value);
}
_ship_last_no = Math.Max(_ship_last_no, datum.Key);
}
}
Api_Result <Dictionary <int, User_BookFmt <BookSlotData> > > api_Result2 = api_get_Member.PictureSlot();
_slot = new Dictionary <int, IAlbumModel>();
if (api_Result2.state == Api_Result_State.Success)
{
foreach (KeyValuePair <int, User_BookFmt <BookSlotData> > datum2 in api_Result2.data)
{
if (datum2.Value != null)
{
_slot[datum2.Key] = new AlbumSlotModel(datum2.Value);
}
_slot_last_no = Math.Max(_slot_last_no, datum2.Key);
}
}
}
}
protected void _CreateMapAreaModel()
{
_UpdateTankerManager();
Dictionary <int, MapAreaModel> dictionary = new Dictionary <int, MapAreaModel>();
foreach (int key in _area.Keys)
{
dictionary.Add(key, _area[key]);
}
_area.Clear();
Api_get_Member api_get_Member = new Api_get_Member();
Api_Result <Dictionary <int, User_StrategyMapFmt> > api_Result = api_get_Member.StrategyInfo();
Dictionary <int, List <Mem_ndock> > data = api_get_Member.AreaNdock().data;
if (api_Result.state == Api_Result_State.Success)
{
Dictionary <int, User_StrategyMapFmt> data2 = api_Result.data;
foreach (int key2 in data2.Keys)
{
if (dictionary.ContainsKey(key2))
{
dictionary[key2].__Update__(UserInfo, data2[key2], data, _tanker_manager);
_area.Add(key2, dictionary[key2]);
dictionary.Remove(key2);
}
else
{
_area.Add(key2, new MapAreaModel(UserInfo, data2[key2], data, _tanker_manager));
}
}
}
}
private void _UpdateSlotitems()
{
_slotitems = new List <SlotitemModel>();
Api_Result <Dictionary <int, Mem_slotitem> > api_Result = new Api_get_Member().Slotitem();
if (api_Result.state == Api_Result_State.Success && api_Result.data != null)
{
for (int i = 0; i < SlotCount; i++)
{
if (_mem_data.Slot[i] == -1)
{
_slotitems.Add(null);
continue;
}
Mem_slotitem data = api_Result.data[_mem_data.Slot[i]];
_slotitems.Add(new SlotitemModel(data));
}
if (_mem_data.Exslot <= 0)
{
_slotitem_ex = null;
}
else
{
Mem_slotitem data2 = api_Result.data[_mem_data.Exslot];
_slotitem_ex = new SlotitemModel(data2);
}
}
while (_slotitems.Count < SlotCount)
{
_slotitems.Add(null);
}
}
public void __UpdateEscortDeck__(Api_get_Member api_get_mem)
{
Api_Result <Dictionary <int, Mem_esccort_deck> > api_Result = api_get_mem.EscortDeck();
if (api_Result.state == Api_Result_State.Success)
{
using (Dictionary <int, Mem_esccort_deck> .KeyCollection.Enumerator enumerator = api_Result.data.get_Keys().GetEnumerator())
{
while (enumerator.MoveNext())
{
int current = enumerator.get_Current();
Mem_esccort_deck mem_escort_deck = api_Result.data.get_Item(current);
__EscortDeckModel__ _EscortDeckModel__;
if (this._escort_decks.TryGetValue(current, ref _EscortDeckModel__))
{
_EscortDeckModel__.__Update__(mem_escort_deck, this._ships);
}
else
{
this._escort_decks.set_Item(current, new __EscortDeckModel__(mem_escort_deck, this._ships));
}
}
}
}
}
private void _UpdateBuildDockData()
{
if (_docks == null)
{
_docks = new List <BuildDockModel>();
}
Api_Result <List <Mem_kdock> > api_Result = new Api_get_Member().kdock();
if (api_Result.state != 0)
{
return;
}
List <Mem_kdock> mem_docks = api_Result.data;
int i;
for (i = 0; i < mem_docks.Count; i++)
{
BuildDockModel buildDockModel = _docks.Find((BuildDockModel dock) => dock.Id == mem_docks[i].Rid);
if (buildDockModel != null)
{
buildDockModel.__Update__(mem_docks[i]);
}
else
{
_docks.Add(new BuildDockModel(mem_docks[i]));
}
}
}
private void _InitializeSlotitems()
{
if (this._all_items == null)
{
Api_Result <Dictionary <int, Mem_slotitem> > api_Result = new Api_get_Member().Slotitem();
if (api_Result.state != Api_Result_State.Success)
{
this._all_items = new List <Mem_slotitem>();
}
else
{
this._all_items = new List <Mem_slotitem>(api_Result.data.get_Values());
}
}
if (this._items == null)
{
this._items = new Dictionary <int, List <SlotitemModel> >();
}
else
{
this._items.Clear();
}
for (int i = 0; i < this._recipes.get_Count(); i++)
{
RevampRecipeModel recipe = this._recipes.get_Item(i);
List <Mem_slotitem> list = this._all_items.FindAll((Mem_slotitem item) => item.Slotitem_id == recipe.Slotitem.MstId);
list = list.FindAll((Mem_slotitem item) => item.Equip_flag == Mem_slotitem.enumEquipSts.Unset);
list.Sort((Mem_slotitem a, Mem_slotitem b) => (a.Level >= b.Level) ? -1 : 1);
this._items.set_Item(recipe.RecipeId, list.ConvertAll <SlotitemModel>((Mem_slotitem item) => new SlotitemModel(item)));
}
}
public PracticeManager(int deck_id)
{
_current_deck = base.UserInfo.GetDeck(deck_id);
_CreateMapAreaModel();
_reqPrac = new Api_req_PracticeDeck();
_valid_deck_prac_type_dic = new Dictionary <DeckPracticeType, bool>();
Api_Result <Mem_deckpractice> api_Result = new Api_get_Member().DeckPractice();
if (api_Result.state == Api_Result_State.Success)
{
Mem_deckpractice data = api_Result.data;
_InitValidDeckPracType(DeckPracticeType.Normal, data, ref _valid_deck_prac_type_dic);
_InitValidDeckPracType(DeckPracticeType.Hou, data, ref _valid_deck_prac_type_dic);
_InitValidDeckPracType(DeckPracticeType.Rai, data, ref _valid_deck_prac_type_dic);
_InitValidDeckPracType(DeckPracticeType.Taisen, data, ref _valid_deck_prac_type_dic);
_InitValidDeckPracType(DeckPracticeType.Kouku, data, ref _valid_deck_prac_type_dic);
_InitValidDeckPracType(DeckPracticeType.Sougou, data, ref _valid_deck_prac_type_dic);
}
DeckModel[] decks = MapArea.GetDecks();
_rival_decks = new List <DeckModel>();
_validation_results = new Dictionary <int, List <IsGoCondition> >();
foreach (DeckModel deckModel in decks)
{
if (deckModel.Count != 0 && deckModel.Id != _current_deck.Id)
{
_rival_decks.Add(deckModel);
_validation_results.Add(deckModel.Id, deckModel.IsValidPractice());
}
}
_validation_results.Add(_current_deck.Id, _current_deck.IsValidPractice());
}
private void _InitializeSlotitems()
{
if (_all_items == null)
{
Api_Result <Dictionary <int, Mem_slotitem> > api_Result = new Api_get_Member().Slotitem();
if (api_Result.state != 0)
{
_all_items = new List <Mem_slotitem>();
}
else
{
_all_items = new List <Mem_slotitem>(api_Result.data.Values);
}
}
if (_items == null)
{
_items = new Dictionary <int, List <SlotitemModel> >();
}
else
{
_items.Clear();
}
for (int i = 0; i < _recipes.Count; i++)
{
RevampRecipeModel recipe = _recipes[i];
List <Mem_slotitem> list = _all_items.FindAll((Mem_slotitem item) => item.Slotitem_id == recipe.Slotitem.MstId);
list = list.FindAll((Mem_slotitem item) => item.Equip_flag == Mem_slotitem.enumEquipSts.Unset);
list.Sort((Mem_slotitem a, Mem_slotitem b) => (a.Level < b.Level) ? 1 : (-1));
_items[recipe.RecipeId] = list.ConvertAll((Mem_slotitem item) => new SlotitemModel(item));
}
}
public SortieManager(int area_id)
{
this._area_id = area_id;
Dictionary <int, Mst_mapinfo> mst_mapinfo = Mst_DataManager.Instance.Mst_mapinfo;
Api_Result <Dictionary <int, User_MapinfoFmt> > api_Result = new Api_get_Member().Mapinfo();
Dictionary <int, User_MapinfoFmt> dictionary;
if (api_Result.state == Api_Result_State.Success)
{
dictionary = api_Result.data;
}
else
{
dictionary = new Dictionary <int, User_MapinfoFmt>();
}
this._maps = new List <MapModel>();
using (Dictionary <int, User_MapinfoFmt> .ValueCollection.Enumerator enumerator = dictionary.get_Values().GetEnumerator())
{
while (enumerator.MoveNext())
{
User_MapinfoFmt current = enumerator.get_Current();
Mst_mapinfo mst_mapinfo2 = mst_mapinfo.get_Item(current.Id);
if (mst_mapinfo2.Maparea_id == area_id)
{
MapModel mapModel = new MapModel(mst_mapinfo2, current);
this._maps.Add(mapModel);
}
}
}
this._maps.Sort((MapModel x, MapModel y) => (x.MstId <= y.MstId) ? -1 : 1);
}
private void _UpdateUnsetSlotitems()
{
this._unset_slotitems = new Dictionary <int, List <SlotitemModel> >();
Api_Result <Dictionary <int, Mem_slotitem> > api_Result = new Api_get_Member().Slotitem();
if (api_Result.state == Api_Result_State.Success)
{
using (Dictionary <int, Mem_slotitem> .KeyCollection.Enumerator enumerator = api_Result.data.get_Keys().GetEnumerator())
{
while (enumerator.MoveNext())
{
int current = enumerator.get_Current();
SlotitemModel slotitemModel = new SlotitemModel(api_Result.data.get_Item(current));
if (!slotitemModel.IsEauiped())
{
if (!this._unset_slotitems.ContainsKey(slotitemModel.Type3))
{
this._unset_slotitems.set_Item(slotitemModel.Type3, new List <SlotitemModel>());
}
this._unset_slotitems.get_Item(slotitemModel.Type3).Add(slotitemModel);
}
}
}
}
}
public List <HistoryModelBase> CreateHistoryData()
{
List <HistoryModelBase> list = new List <HistoryModelBase>();
Api_Result <List <User_HistoryFmt> > api_Result = new Api_get_Member().HistoryList();
if (api_Result.state == Api_Result_State.Success)
{
for (int i = 0; i < api_Result.data.Count; i++)
{
User_HistoryFmt user_HistoryFmt = api_Result.data[i];
if (user_HistoryFmt.Type == HistoryType.MapClear1 || user_HistoryFmt.Type == HistoryType.MapClear2 || user_HistoryFmt.Type == HistoryType.MapClear3)
{
list.Add(new HistoryModel_AreaClear(user_HistoryFmt));
}
else if (user_HistoryFmt.Type == HistoryType.NewAreaOpen)
{
list.Add(new HistoryModel_AreaStart(user_HistoryFmt));
}
else if (user_HistoryFmt.Type == HistoryType.TankerLostAll || user_HistoryFmt.Type == HistoryType.TankerLostHalf)
{
list.Add(new HistoryModel_TransportCraft(user_HistoryFmt));
}
else if (user_HistoryFmt.Type == HistoryType.GameClear || user_HistoryFmt.Type == HistoryType.GameOverLost || user_HistoryFmt.Type == HistoryType.GameOverTurn)
{
list.Add(new HistoryModel_GameEnd(user_HistoryFmt));
}
}
}
return(list);
}
private void _UpdateMission()
{
_mission_dic = new Dictionary <int, List <MissionModel> >();
Api_Result <List <User_MissionFmt> > api_Result = new Api_get_Member().Mission();
if (api_Result.state != 0)
{
return;
}
DeckModel[] decksFromArea = base.UserInfo.GetDecksFromArea(_area_id);
Dictionary <int, DeckModel> dictionary = new Dictionary <int, DeckModel>();
foreach (DeckModel deckModel in decksFromArea)
{
if (deckModel.MissionState != 0)
{
dictionary.Add(deckModel.MissionId, deckModel);
}
}
for (int j = 0; j < api_Result.data.Count; j++)
{
User_MissionFmt user_MissionFmt = api_Result.data[j];
MissionModel missionModel = (!dictionary.ContainsKey(user_MissionFmt.MissionId)) ? new MissionModel(user_MissionFmt) : new MissionModel(user_MissionFmt, dictionary[user_MissionFmt.MissionId]);
if (!_mission_dic.ContainsKey(missionModel.AreaId))
{
_mission_dic[missionModel.AreaId] = new List <MissionModel>();
}
_mission_dic[missionModel.AreaId].Add(missionModel);
}
}
public virtual TurnState MapEnd()
{
TurnState result = this._req_map.SortieEnd();
Api_get_Member api_get_mem = new Api_get_Member();
base.UserInfo.__UpdateShips__(api_get_mem);
return(result);
}
public List <User_HistoryFmt> CreateHistoryRawData()
{
Api_Result <List <User_HistoryFmt> > api_Result = new Api_get_Member().HistoryList();
if (api_Result.state == Api_Result_State.Success)
{
return(api_Result.data);
}
return(new List <User_HistoryFmt>());
}
private void _UpdateBuildDockData()
{
if (this._docks == null)
{
this._docks = new List <BuildDockModel>();
}
Api_Result <List <Mem_kdock> > api_Result = new Api_get_Member().kdock();
if (api_Result.state == Api_Result_State.Success)
{
ArsenalManager.< _UpdateBuildDockData > c__AnonStorey507 <_UpdateBuildDockData> c__AnonStorey = new ArsenalManager.< _UpdateBuildDockData > c__AnonStorey507();
public bool Update()
{
Api_Result <Dictionary <enumMaterialCategory, Mem_material> > api_Result = new Api_get_Member().Material();
if (api_Result.state == Api_Result_State.Success)
{
this.Update(api_Result.data);
return(true);
}
return(false);
}
public static int __IsInDeck__(int ship_mem_id, bool checkPartnerShip)
{
Dictionary <int, Mem_deck> data = new Api_get_Member().Deck().data;
int[] array = data.get_Item(1).Search_ShipIdx(data, ship_mem_id);
if (checkPartnerShip && array[0] == 1 && array[1] == 0)
{
return(0);
}
return(array[0]);
}
public __ShipModelMem__(int memID)
{
Api_Result <Dictionary <int, Mem_ship> > api_Result = new Api_get_Member().Ship(new List <int>
{
memID
});
_mem_data = api_Result.data[memID];
int ship_id = _mem_data.Ship_id;
_mst_data = Mst_DataManager.Instance.Mst_ship[ship_id];
}
public bool Update()
{
Api_Result <Dictionary <int, List <Mem_tanker> > > api_Result = new Api_get_Member().Tanker();
if (api_Result.state == Api_Result_State.Success)
{
_data = api_Result.data;
return(true);
}
_data = new Dictionary <int, List <Mem_tanker> >();
return(false);
}
public ArsenalManager()
{
this._tanker_manager = new _TankerManager();
this._api = new Api_req_Kousyou();
this._UpdateBuildDockData();
Api_Result <Dictionary <int, Mem_useitem> > api_Result = new Api_get_Member().UseItem();
if (api_Result.state == Api_Result_State.Success && api_Result.data != null)
{
api_Result.data.TryGetValue(49, ref this._dock_key_item);
}
}
private void _Update()
{
Api_Result <User_RecordFmt> api_Result = new Api_get_Member().Record();
if (api_Result.state == Api_Result_State.Success)
{
_record_data = api_Result.data;
}
else
{
_record_data = new User_RecordFmt();
}
}
public UseitemUtil()
{
Api_Result <Dictionary <int, Mem_useitem> > api_Result = new Api_get_Member().UseItem();
if (api_Result.state == Api_Result_State.Success)
{
this._data = api_Result.data;
}
else
{
this._data = null;
}
}
public RepairManager(int area_id)
{
_area_id = area_id;
_CreateMapAreaModel();
_UpdateRepairDockData();
_UpdateRepairShipList();
Api_Result <Dictionary <int, Mem_useitem> > api_Result = new Api_get_Member().UseItem();
if (api_Result.state == Api_Result_State.Success && api_Result.data != null)
{
api_Result.data.TryGetValue(49, out _dock_key_item);
}
}
public bool ChangeOrganize(int deck_id, int selected_index, int ship_mem_id)
{
Api_Result <Hashtable> api_Result = _api.Change(deck_id, selected_index, ship_mem_id);
if (api_Result.state == Api_Result_State.Success)
{
Api_get_Member api_get_mem = new Api_get_Member();
base.UserInfo.__UpdateDeck__(api_get_mem);
_UpdateShipList();
return(true);
}
return(false);
}
public __ShipModelMem__(int memID)
{
Api_get_Member arg_19_0 = new Api_get_Member();
List <int> list = new List <int>();
list.Add(memID);
Api_Result <Dictionary <int, Mem_ship> > api_Result = arg_19_0.Ship(list);
this._mem_data = api_Result.data.get_Item(memID);
int ship_id = this._mem_data.Ship_id;
this._mst_data = Mst_DataManager.Instance.Mst_ship.get_Item(ship_id);
}
public void __UpdateShips__(Api_get_Member api_get_mem)
{
_ships = new Dictionary <int, ShipModel>();
Api_Result <Dictionary <int, Mem_ship> > api_Result = api_get_mem.Ship(null);
if (api_Result.state == Api_Result_State.Success)
{
foreach (Mem_ship value in api_Result.data.Values)
{
_ships.Add(value.Rid, new ShipModel(value));
}
}
__UpdateDeck__(api_get_mem);
}
private void _Init()
{
_decks = new Dictionary <int, DeckModel>();
_escort_decks = new Dictionary <int, __EscortDeckModel__>();
Api_get_Member api_get_Member = new Api_get_Member();
Api_Result <Mem_basic> api_Result = api_get_Member.Basic();
if (api_Result.state == Api_Result_State.Success)
{
_basic = api_Result.data;
_tutorialFlgs.__Update__(_basic);
}
__UpdateShips__(api_get_Member);
__UpdateDeck__(api_get_Member);
__UpdateEscortDeck__(api_get_Member);
}