private void _InitializeRecipes(int deck_id)
{
this._recipes = new List <RevampRecipeModel>();
Api_Result <Dictionary <int, List <Mst_slotitem_remodel> > > slotitemRemodelList = this._req.getSlotitemRemodelList(deck_id);
if (slotitemRemodelList.state != Api_Result_State.Success || slotitemRemodelList.data == null)
{
return;
}
Dictionary <int, List <Mst_slotitem_remodel> > data = slotitemRemodelList.data;
List <Mst_slotitem_remodel> list = new List <Mst_slotitem_remodel>();
using (Dictionary <int, List <Mst_slotitem_remodel> > .KeyCollection.Enumerator enumerator = data.get_Keys().GetEnumerator())
{
while (enumerator.MoveNext())
{
int current = enumerator.get_Current();
List <Mst_slotitem_remodel> list2 = data.get_Item(current);
if (list2 != null && list2.get_Count() > 0)
{
list.AddRange(list2);
}
}
}
list.Sort((Mst_slotitem_remodel a, Mst_slotitem_remodel b) => (a.Position <= b.Position) ? -1 : 1);
this._recipes = list.ConvertAll <RevampRecipeModel>((Mst_slotitem_remodel mst) => new RevampRecipeModel(mst));
}
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));
}
}
}
}
}
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);
}
}
}
}
public SlotSetChkResult_Slot ChangeSlotitemEx(int ship_mem_id, int slotitem_id)
{
Api_Result <SlotSetChkResult_Slot> api_Result = this._api.SlotSet(ship_mem_id, slotitem_id);
this._unset_slotitems = null;
return(api_Result.data);
}
public BuildDockModel CreateTanker(int dock_id, bool highSpeed, int fuel, int ammo, int steel, int baux, int spoint)
{
Dictionary <enumMaterialCategory, int> dictionary = new Dictionary <enumMaterialCategory, int>();
dictionary[enumMaterialCategory.Fuel] = fuel;
dictionary[enumMaterialCategory.Bull] = ammo;
dictionary[enumMaterialCategory.Steel] = steel;
dictionary[enumMaterialCategory.Bauxite] = baux;
int value = 0;
if (highSpeed)
{
value = _api.GetRequireMaterials_Max(2)[enumMaterialCategory.Build_Kit];
}
dictionary[enumMaterialCategory.Build_Kit] = value;
if (!IsValidCreateTanker(dock_id, highSpeed, fuel, ammo, steel, baux, spoint))
{
return(null);
}
Api_Result <Mem_kdock> api_result = _api.StartTanker(dock_id, highSpeed, dictionary, spoint);
if (api_result.state != 0 || api_result.data == null)
{
return(null);
}
return(_docks.Find((BuildDockModel dock) => dock.Id == api_result.data.Rid));
}
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));
}
}
}
}
public bool SlotLock(int slot_mem_id)
{
Api_Result<bool> api_Result = _api.SlotLockChange(slot_mem_id);
if (api_Result.state != 0)
{
return false;
}
return true;
}
public bool ChangeHighSpeed(int dock_id)
{
if (!this._api.ValidSpeedChange(dock_id))
{
return(false);
}
Api_Result <Mem_kdock> api_Result = this._api.SpeedChange(dock_id);
return(api_Result.state == Api_Result_State.Success);
}
public bool UnsetSlotitemEx(int ship_mem_id)
{
Api_Result<SlotSetChkResult_Slot> api_Result = _api.SlotSet(ship_mem_id, -1);
if (api_Result.state != 0)
{
return false;
}
_unset_slotitems = null;
return true;
}
public bool UnsetAll(int ship_mem_id)
{
Api_Result<Hashtable> api_Result = _api.Unslot_all(ship_mem_id);
if (api_Result.state != 0)
{
return false;
}
_unset_slotitems = null;
return true;
}
public IReward_Slotitem CreateItem(Dictionary <enumMaterialCategory, int> materials, int deck_id)
{
Api_Result <Mst_slotitem> api_Result = _api.CreateItem(materials, deck_id);
if (api_Result.state != 0 || api_Result.data == null)
{
return(null);
}
_unset_slotitem = null;
return(new Reward_Slotitem(api_Result.data));
}
public bool UnsetAll(int ship_mem_id)
{
Api_Result <Hashtable> api_Result = this._api.Unslot_all(ship_mem_id);
if (api_Result.state != Api_Result_State.Success)
{
return(false);
}
this._unset_slotitems = null;
return(true);
}
public bool UnsetSlotitemEx(int ship_mem_id)
{
Api_Result <SlotSetChkResult_Slot> api_Result = this._api.SlotSet(ship_mem_id, -1);
if (api_Result.state != Api_Result_State.Success)
{
return(false);
}
this._unset_slotitems = null;
return(true);
}
public bool UnsetAllOrganize(int deck_id)
{
Api_Result <Hashtable> api_Result = _api.Change(deck_id, 0, -2);
if (api_Result.state == Api_Result_State.Success)
{
base.UserInfo.__UpdateDeck__(new Api_get_Member());
_UpdateShipList();
return(true);
}
return(false);
}
public bool BuyItem(int paymentitem_mst_id, int count)
{
ItemStoreModel itemStoreModel = this.Items.Find((ItemStoreModel i) => i != null && i.MstId == paymentitem_mst_id);
if (!this.IsValidBuy(itemStoreModel, count))
{
return(false);
}
Api_Result <object> api_Result = this._req_store.Buy(itemStoreModel.MstId, count);
return(api_Result.state == Api_Result_State.Success);
}
public bool UnsetOrganize(int deck_id, int selected_index)
{
Api_Result <Hashtable> api_Result = this._api.Change(deck_id, selected_index, -1);
if (api_Result.state == Api_Result_State.Success)
{
base.UserInfo.__UpdateDeck__(new Api_get_Member());
this._UpdateShipList();
return(true);
}
return(false);
}
public bool BreakShip(int ship_mem_id)
{
Api_Result <object> api_Result = _api.DestroyShip(ship_mem_id);
if (api_Result.state == Api_Result_State.Success)
{
base.UserInfo.__UpdateShips__(new Api_get_Member());
_breakable_ships = null;
return(true);
}
return(false);
}
public bool BreakItem()
{
Api_Result <object> api_Result = _api.DestroyItem(_selected_items);
if (api_Result.state == Api_Result_State.Success)
{
_unset_slotitem = null;
ClearSelectedState();
return(true);
}
return(false);
}
protected override BattleResultFmt _GetBattleResult()
{
if (_cache_result_fmt == null)
{
Api_Result <BattleResultFmt> api_Result = _reqBattle.BattleResult();
if (api_Result.state == Api_Result_State.Success)
{
_cache_result_fmt = api_Result.data;
}
}
return(_cache_result_fmt);
}
public DeckPracticeResultModel StartDeckPractice(DeckPracticeType type)
{
Dictionary <int, int> dic = new Dictionary <int, int>();
CurrentDeck.__CreateShipExpRatesDictionary__(ref dic);
Api_Result <PracticeDeckResultFmt> resultData = _reqPrac.GetResultData(type, CurrentDeck.Id);
if (resultData.state != 0)
{
return(null);
}
return(new DeckPracticeResultModel(type, resultData.data, base.UserInfo, dic));
}
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);
}
private bool _UpdateDutyData()
{
Api_Result <List <User_QuestFmt> > api_Result = this._quest.QuestList();
if (api_Result.state != Api_Result_State.Success || api_Result.data == null)
{
return(false);
}
List <User_QuestFmt> data = api_Result.data;
this._duties = data.ConvertAll <__DutyModel__>((User_QuestFmt fmt) => new __DutyModel__(fmt));
return(true);
}
public bool MissionStart(int deck_id, int mission_id, int tanker_count)
{
if (this.IsValidMissionStart(deck_id, mission_id, tanker_count).get_Count() == 0)
{
Api_Result <Mem_deck> api_Result = this._req_mission.Start(deck_id, mission_id, tanker_count);
if (api_Result.state == Api_Result_State.Success)
{
this._mission_dic = null;
return(true);
}
}
return(false);
}
public DeckPracticeResultModel StartDeckPractice(DeckPracticeType type)
{
Dictionary <int, int> exp_rates_before = new Dictionary <int, int>();
this.CurrentDeck.__CreateShipExpRatesDictionary__(ref exp_rates_before);
Api_Result <PracticeDeckResultFmt> resultData = this._reqPrac.GetResultData(type, this.CurrentDeck.Id);
if (resultData.state != Api_Result_State.Success)
{
return(null);
}
return(new DeckPracticeResultModel(type, resultData.data, base.UserInfo, exp_rates_before));
}
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 bool MissionStop(int deck_id)
{
if (_req_mission.ValidStop(deck_id))
{
Api_Result <int> api_Result = _req_mission.Stop(deck_id);
if (api_Result.state == Api_Result_State.Success)
{
_mission_dic = null;
return(true);
}
return(false);
}
return(false);
}
public bool OpenSlotEx(int ship_mem_id)
{
if (!IsValidOpenSlotEx(ship_mem_id))
{
return false;
}
Api_Result<Mem_ship> api_Result = _api.ExpandSlot(ship_mem_id);
if (api_Result.state == Api_Result_State.Success)
{
_hokyo_zousetsu_num--;
return true;
}
return false;
}
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);
}
public bool ChangeHighSpeedTanker(int dock_id)
{
if (!_api.ValidSpeedChangeTanker(dock_id))
{
return(false);
}
Api_Result <Mem_kdock> api_Result = _api.SpeedChangeTanker(dock_id);
if (api_Result.state == Api_Result_State.Success)
{
return(true);
}
return(false);
}
public SlotitemModel Revamp(RevampRecipeDetailModel detail)
{
Api_Result <bool> api_Result = this._req.RemodelSlot(detail.__mst_detail__, this.Deck.Id, detail.Slotitem.MemId, detail.Determined);
this._all_items = null;
this._InitializeSlotitems();
if (api_Result.state != Api_Result_State.Success || !api_Result.data)
{
return(null);
}
Comm_UserDatas.Instance.User_trophy.Revamp_count++;
detail.Slotitem.__update__();
return(detail.Slotitem);
}
