public Api_Result <Hashtable> Unslot_all(int ship_rid)
{
Api_Result <Hashtable> result = new Api_Result <Hashtable>();
Mem_ship mem_ship = Comm_UserDatas.Instance.User_ship.get_Item(ship_rid);
Mem_shipBase mem_shipBase = new Mem_shipBase(mem_ship);
for (int i = 0; i < Enumerable.Count <int>(mem_shipBase.Slot); i++)
{
Mem_slotitem mem_slotitem = null;
int num = mem_shipBase.Slot.get_Item(i);
mem_shipBase.Slot.set_Item(i, -1);
if (num > 0 && Comm_UserDatas.Instance.User_slot.TryGetValue(num, ref mem_slotitem))
{
Mst_slotitem_cost mst_slotitem_cost = null;
if (Mst_DataManager.Instance.Mst_slotitem_cost.TryGetValue(mem_slotitem.Slotitem_id, ref mst_slotitem_cost))
{
int addNum = mst_slotitem_cost.GetAddNum(mem_shipBase.Onslot.get_Item(i));
Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Bauxite).Add_Material(addNum);
}
mem_slotitem.UnEquip();
}
}
mem_ship.Set_ShipParam(mem_shipBase, Mst_DataManager.Instance.Mst_ship.get_Item(mem_shipBase.Ship_id), false);
mem_ship.TrimSlot();
return(result);
}
public Api_Result <SlotSetChkResult_Slot> SlotSet(int ship_rid, int slot_rid)
{
Api_Result <SlotSetChkResult_Slot> api_Result = new Api_Result <SlotSetChkResult_Slot>();
SlotSetChkResult_Slot slotSetChkResult_Slot = this.IsValidSlotSet(ship_rid, slot_rid);
if (slotSetChkResult_Slot != SlotSetChkResult_Slot.Ok)
{
api_Result.state = Api_Result_State.Parameter_Error;
api_Result.data = slotSetChkResult_Slot;
return(api_Result);
}
Mem_ship mem_ship = Comm_UserDatas.Instance.User_ship.get_Item(ship_rid);
Mem_slotitem mem_slotitem = null;
Comm_UserDatas.Instance.User_slot.TryGetValue(slot_rid, ref mem_slotitem);
Mem_shipBase mem_shipBase = new Mem_shipBase(mem_ship);
Mem_slotitem mem_slotitem2 = null;
Comm_UserDatas.Instance.User_slot.TryGetValue(mem_ship.Exslot, ref mem_slotitem2);
mem_shipBase.Exslot = slot_rid;
if (mem_slotitem2 != null)
{
mem_slotitem2.UnEquip();
}
if (slot_rid != -1)
{
mem_slotitem.Equip(ship_rid);
}
mem_ship.Set_ShipParam(mem_shipBase, Mst_DataManager.Instance.Mst_ship.get_Item(mem_shipBase.Ship_id), false);
return(api_Result);
}
public Api_Result <List <User_QuestFmt> > QuestList()
{
if (Comm_UserDatas.Instance.User_quest.get_Count() == 0)
{
Comm_UserDatas.Instance.InitQuest(this, Enumerable.ToList <Mst_quest>(this.mst_quest.get_Values()));
}
if (Comm_UserDatas.Instance.User_turn.ReqQuestReset)
{
this.QuestReset();
Comm_UserDatas.Instance.User_turn.DisableQuestReset();
}
this.SetEnableList();
Api_Result <List <User_QuestFmt> > api_Result = new Api_Result <List <User_QuestFmt> >();
IEnumerable <Mem_quest> enumerable = Enumerable.Where <Mem_quest>(Enumerable.OrderBy <Mem_quest, int>(Comm_UserDatas.Instance.User_quest.get_Values(), (Mem_quest member) => member.Rid), (Mem_quest member) => member.State != QuestState.END && member.State != QuestState.NOT_DISP);
api_Result.data = new List <User_QuestFmt>();
int num = Comm_UserDatas.Instance.User_deck.get_Item(1).Ship[0];
Mem_ship flagShip = Comm_UserDatas.Instance.User_ship.get_Item(num);
using (IEnumerator <Mem_quest> enumerator = enumerable.GetEnumerator())
{
while (enumerator.MoveNext())
{
Mem_quest current = enumerator.get_Current();
Mst_quest mstObj = this.mst_quest.get_Item(current.Rid);
User_QuestFmt user_QuestFmt = new User_QuestFmt(current, mstObj);
this.slotModelChangeQuestNormalize(flagShip, current, mstObj, user_QuestFmt);
api_Result.data.Add(user_QuestFmt);
}
}
return(api_Result);
}
public Api_Result <List <User_QuestFmt> > QuestList()
{
if (Comm_UserDatas.Instance.User_quest.Count == 0)
{
Comm_UserDatas.Instance.InitQuest(this, mst_quest.Values.ToList());
}
if (Comm_UserDatas.Instance.User_turn.ReqQuestReset)
{
QuestReset();
Comm_UserDatas.Instance.User_turn.DisableQuestReset();
}
SetEnableList();
Api_Result <List <User_QuestFmt> > api_Result = new Api_Result <List <User_QuestFmt> >();
IEnumerable <Mem_quest> enumerable = from member in Comm_UserDatas.Instance.User_quest.Values
orderby member.Rid
where member.State != QuestState.END && member.State != QuestState.NOT_DISP
select member;
api_Result.data = new List <User_QuestFmt>();
int key = Comm_UserDatas.Instance.User_deck[1].Ship[0];
Mem_ship flagShip = Comm_UserDatas.Instance.User_ship[key];
foreach (Mem_quest item in enumerable)
{
Mst_quest mstObj = mst_quest[item.Rid];
User_QuestFmt user_QuestFmt = new User_QuestFmt(item, mstObj);
slotModelChangeQuestNormalize(flagShip, item, mstObj, user_QuestFmt);
api_Result.data.Add(user_QuestFmt);
}
return(api_Result);
}
public Api_Result <Dictionary <int, Mem_ship> > Ship(int area_id)
{
List <DeckShips> list = new List <DeckShips>();
Mem_esccort_deck mem_esccort_deck = Comm_UserDatas.Instance.User_EscortDeck.Values.FirstOrDefault((Mem_esccort_deck x) => x.Maparea_id == area_id);
if (mem_esccort_deck != null)
{
list.Add(mem_esccort_deck.Ship);
}
IEnumerable <DeckShips> enumerable = from deck in Comm_UserDatas.Instance.User_deck.Values
where deck.Area_id == area_id
select deck.Ship;
if (enumerable.Count() > 0)
{
list.AddRange(enumerable);
}
if (list.Count == 0)
{
Api_Result <Dictionary <int, Mem_ship> > api_Result = new Api_Result <Dictionary <int, Mem_ship> >();
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
List <int> list2 = new List <int>();
foreach (DeckShips item in list)
{
List <int> out_ships = null;
item.Clone(out out_ships);
list2.AddRange(out_ships);
}
return(Ship(list2));
}
public Api_Result <int> Stop(int deck_rid)
{
Api_Result <int> api_Result = new Api_Result <int>();
Mem_deck mem_deck = Comm_UserDatas.Instance.User_deck.get_Item(deck_rid);
Mst_mission2 mst_mission = Mst_DataManager.Instance.Mst_mission.get_Item(mem_deck.Mission_id);
int num = mst_mission.Time - (mem_deck.StartTime - mem_deck.CompleteTime);
double num2 = Math.Ceiling((double)(mst_mission.Time + num) / 2.0);
int total_turn = Comm_UserDatas.Instance.User_turn.Total_turn;
int num3 = ((double)(total_turn - mem_deck.StartTime) >= num2) ? 2 : 1;
double num4;
if (num3 == 1)
{
num4 = (double)(total_turn - mem_deck.StartTime);
}
else
{
num4 = (double)(mem_deck.CompleteTime - total_turn);
}
num4 = Math.Ceiling(num4 / 3.0);
int newEndTime = (int)((double)total_turn + num4);
mem_deck.MissionStop(newEndTime);
api_Result.data = mem_deck.StartTime - mem_deck.CompleteTime;
return(api_Result);
}
public Api_Result <Mem_basic> Basic()
{
Api_Result <Mem_basic> api_Result = new Api_Result <Mem_basic>();
api_Result.data = Comm_UserDatas.Instance.User_basic;
return(api_Result);
}
public Api_Result <Mem_deckpractice> DeckPractice()
{
Api_Result <Mem_deckpractice> api_Result = new Api_Result <Mem_deckpractice>();
api_Result.data = Comm_UserDatas.Instance.User_deckpractice;
return(api_Result);
}
public Api_Result <Dictionary <int, Mem_slotitem> > Slotitem()
{
Api_Result <Dictionary <int, Mem_slotitem> > api_Result = new Api_Result <Dictionary <int, Mem_slotitem> >();
Dictionary <int, Mem_slotitem> dictionary = api_Result.data = Comm_UserDatas.Instance.User_slot.ToDictionary((KeyValuePair <int, Mem_slotitem> x) => x.Key, (KeyValuePair <int, Mem_slotitem> y) => y.Value);
return(api_Result);
}
public Api_Result <Dictionary <int, User_StrategyMapFmt> > StrategyInfo()
{
Api_Result <Dictionary <int, User_StrategyMapFmt> > api_Result = new Api_Result <Dictionary <int, User_StrategyMapFmt> >();
api_Result.data = new Dictionary <int, User_StrategyMapFmt>();
Dictionary <int, Mst_mapinfo> dictionary = (from x in Mst_DataManager.Instance.Mst_mapinfo.Values
where x.No == 1
select x).ToDictionary((Mst_mapinfo y) => y.Maparea_id, (Mst_mapinfo z) => z);
foreach (Mst_maparea value2 in Mst_DataManager.Instance.Mst_maparea.Values)
{
bool flag = (dictionary[value2.Id].GetUser_MapinfoData() != null) ? true : false;
User_StrategyMapFmt user_StrategyMapFmt = new User_StrategyMapFmt(value2, flag);
Mem_rebellion_point value = null;
if (Comm_UserDatas.Instance.User_rebellion_point.TryGetValue(value2.Id, out value))
{
user_StrategyMapFmt.RebellionState = value.State;
}
if (user_StrategyMapFmt.IsActiveArea)
{
if (!Comm_UserDatas.Instance.User_EscortDeck.ContainsKey(value2.Id))
{
Comm_UserDatas.Instance.Add_EscortDeck(value2.Id, value2.Id);
}
if (value == null)
{
value = new Mem_rebellion_point(value2.Id);
Comm_UserDatas.Instance.User_rebellion_point.Add(value.Rid, value);
user_StrategyMapFmt.RebellionState = value.State;
}
}
api_Result.data.Add(user_StrategyMapFmt.Maparea.Id, user_StrategyMapFmt);
}
return(api_Result);
}
public Api_Result <Dictionary <enumMaterialCategory, Mem_material> > Material()
{
Api_Result <Dictionary <enumMaterialCategory, Mem_material> > api_Result = new Api_Result <Dictionary <enumMaterialCategory, Mem_material> >();
Dictionary <enumMaterialCategory, Mem_material> dictionary = api_Result.data = Comm_UserDatas.Instance.User_material.ToDictionary((KeyValuePair <enumMaterialCategory, Mem_material> x) => x.Key, (KeyValuePair <enumMaterialCategory, Mem_material> y) => y.Value);
return(api_Result);
}
public Api_Result <Dictionary <int, Mem_deck> > Deck()
{
Api_Result <Dictionary <int, Mem_deck> > api_Result = new Api_Result <Dictionary <int, Mem_deck> >();
Dictionary <int, Mem_deck> dictionary = api_Result.data = Comm_UserDatas.Instance.User_deck.ToDictionary((KeyValuePair <int, Mem_deck> x) => x.Key, (KeyValuePair <int, Mem_deck> y) => y.Value);
return(api_Result);
}
public Api_Result <SlotSetChkResult_Slot> SlotSet(int ship_rid, int slot_rid)
{
Api_Result <SlotSetChkResult_Slot> api_Result = new Api_Result <SlotSetChkResult_Slot>();
SlotSetChkResult_Slot slotSetChkResult_Slot = IsValidSlotSet(ship_rid, slot_rid);
if (slotSetChkResult_Slot != 0)
{
api_Result.state = Api_Result_State.Parameter_Error;
api_Result.data = slotSetChkResult_Slot;
return(api_Result);
}
Mem_ship mem_ship = Comm_UserDatas.Instance.User_ship[ship_rid];
Mem_slotitem value = null;
Comm_UserDatas.Instance.User_slot.TryGetValue(slot_rid, out value);
Mem_shipBase mem_shipBase = new Mem_shipBase(mem_ship);
Mem_slotitem value2 = null;
Comm_UserDatas.Instance.User_slot.TryGetValue(mem_ship.Exslot, out value2);
mem_shipBase.Exslot = slot_rid;
value2?.UnEquip();
if (slot_rid != -1)
{
value.Equip(ship_rid);
}
mem_ship.Set_ShipParam(mem_shipBase, Mst_DataManager.Instance.Mst_ship[mem_shipBase.Ship_id], enemy_flag: false);
return(api_Result);
}
public Api_Result <Hashtable> Unslot_all(int ship_rid)
{
Api_Result <Hashtable> result = new Api_Result <Hashtable>();
Mem_ship mem_ship = Comm_UserDatas.Instance.User_ship[ship_rid];
Mem_shipBase mem_shipBase = new Mem_shipBase(mem_ship);
for (int i = 0; i < mem_shipBase.Slot.Count(); i++)
{
Mem_slotitem value = null;
int num = mem_shipBase.Slot[i];
mem_shipBase.Slot[i] = -1;
if (num > 0 && Comm_UserDatas.Instance.User_slot.TryGetValue(num, out value))
{
Mst_slotitem_cost value2 = null;
if (Mst_DataManager.Instance.Mst_slotitem_cost.TryGetValue(value.Slotitem_id, out value2))
{
int addNum = value2.GetAddNum(mem_shipBase.Onslot[i]);
Comm_UserDatas.Instance.User_material[enumMaterialCategory.Bauxite].Add_Material(addNum);
}
value.UnEquip();
}
}
mem_ship.Set_ShipParam(mem_shipBase, Mst_DataManager.Instance.Mst_ship[mem_shipBase.Ship_id], enemy_flag: false);
mem_ship.TrimSlot();
return(result);
}
public override Api_Result <BattleResultFmt> BattleResult()
{
Api_Result <BattleResultFmt> api_Result = base.BattleResult();
int count = userData.StartHp.Count;
for (int i = 0; i < count; i++)
{
userData.ShipData[i].SetHp(this, userData.StartHp[i]);
}
if (api_Result.state == Api_Result_State.Parameter_Error)
{
return(api_Result);
}
Dictionary <int, int> slotExpBattleData = GetSlotExpBattleData();
foreach (KeyValuePair <int, int> item in slotExpBattleData)
{
Mem_slotitem value = null;
if (Comm_UserDatas.Instance.User_slot.TryGetValue(item.Key, out value))
{
value.ChangeExperience(item.Value);
}
}
QuestPractice questPractice = new QuestPractice(api_Result.data);
questPractice.ExecuteCheck();
return(api_Result);
}
public Api_Result <Mem_ndock> SpeedChange(int rid)
{
Api_Result <Mem_ndock> api_Result = new Api_Result <Mem_ndock>();
Mem_ndock mem_ndock = null;
if (!Comm_UserDatas.Instance.User_ndock.TryGetValue(rid, ref mem_ndock))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (mem_ndock.State != NdockStates.RESTORE)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Repair_Kit).Value < 1)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (mem_ndock.RecoverEnd(false))
{
Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Repair_Kit).Sub_Material(1);
api_Result.data = mem_ndock;
return(api_Result);
}
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
public Api_Result <object> Buy(int mst_id, int buyNum)
{
Api_Result <object> api_Result = new Api_Result <object>();
Mst_payitem value = null;
if (!mst_payitem.TryGetValue(mst_id, out value))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
foreach (PayItemEffectInfo item in value.Items)
{
if (item.Type == 1)
{
Comm_UserDatas.Instance.Add_Useitem(item.MstId, item.Count);
}
else if (item.Type == 2)
{
IEnumerable <int> source = Enumerable.Repeat(item.MstId, item.Count);
Comm_UserDatas.Instance.Add_Slot(source.ToList());
}
else if (item.Type == 3)
{
enumMaterialCategory mstId = (enumMaterialCategory)item.MstId;
Comm_UserDatas.Instance.User_material[mstId].Add_Material(item.Count);
}
}
Comm_UserDatas.Instance.User_basic.SubPoint(value.Price * buyNum);
return(api_Result);
}
public Api_Result <Mem_ndock> SpeedChange(int rid)
{
Api_Result <Mem_ndock> api_Result = new Api_Result <Mem_ndock>();
Mem_ndock value = null;
if (!Comm_UserDatas.Instance.User_ndock.TryGetValue(rid, out value))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (value.State != NdockStates.RESTORE)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (Comm_UserDatas.Instance.User_material[enumMaterialCategory.Repair_Kit].Value < 1)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (value.RecoverEnd(timeChk: false))
{
Comm_UserDatas.Instance.User_material[enumMaterialCategory.Repair_Kit].Sub_Material(1);
api_Result.data = value;
return(api_Result);
}
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
public override Api_Result <BattleResultFmt> BattleResult()
{
Api_Result <BattleResultFmt> api_Result = base.BattleResult();
int count = this.userData.StartHp.get_Count();
for (int i = 0; i < count; i++)
{
this.userData.ShipData.get_Item(i).SetHp(this, this.userData.StartHp.get_Item(i));
}
if (api_Result.state == Api_Result_State.Parameter_Error)
{
return(api_Result);
}
Dictionary <int, int> slotExpBattleData = base.GetSlotExpBattleData();
using (Dictionary <int, int> .Enumerator enumerator = slotExpBattleData.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <int, int> current = enumerator.get_Current();
Mem_slotitem mem_slotitem = null;
if (Comm_UserDatas.Instance.User_slot.TryGetValue(current.get_Key(), ref mem_slotitem))
{
mem_slotitem.ChangeExperience(current.get_Value());
}
}
}
QuestPractice questPractice = new QuestPractice(api_Result.data);
questPractice.ExecuteCheck();
return(api_Result);
}
public Api_Result <bool> SetPortBGMFromJukeBoxList(int deck_rid, int music_id)
{
Api_Result <bool> api_Result = new Api_Result <bool>();
Mst_bgm_jukebox jukeBoxItem = Mst_DataManager.Instance.GetJukeBoxItem(music_id);
if (jukeBoxItem == null)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (jukeBoxItem.Bgm_flag == 0)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
api_Result.data = true;
Mem_room value = null;
if (!Comm_UserDatas.Instance.User_room.TryGetValue(deck_rid, out value))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
value.SetPortBgmFromJuke(music_id);
api_Result.state = Api_Result_State.Success;
api_Result.data = true;
return(api_Result);
}
public override Api_Result <BattleResultFmt> BattleResult()
{
Api_Result <BattleResultFmt> api_Result = base.BattleResult();
if (api_Result.state == Api_Result_State.Parameter_Error)
{
return(api_Result);
}
List <Mem_ship> ships = null;
List <Mem_ship> list = null;
this.mapInstance.GetSortieShipDatas(out ships, out list);
EscapeInfo escapeInfo = new EscapeInfo(ships);
api_Result.data.EscapeInfo = ((!escapeInfo.ValidEscape()) ? null : escapeInfo);
if (api_Result.data.GetAirReconnaissanceItems != null)
{
this.mapInstance.updateMapitemGetData(api_Result.data.GetAirReconnaissanceItems);
}
this.battleKinds = ExecBattleKinds.None;
Mst_mapcell2 nowCell = this.mapInstance.GetNowCell();
bool boss = Mst_DataManager.Instance.Mst_mapenemy.get_Item(this.enemyData.Enemy_id).Boss == 1;
List <int> list2 = new QuestSortie(nowCell.Maparea_id, nowCell.Mapinfo_no, api_Result.data.WinRank, this.userData.Deck.Rid, this.userData.ShipData, this.enemyData.ShipData, boss).ExecuteCheck();
this.mapInstance.SetSlotExpChangeValues(this, base.GetSlotExpBattleData());
return(api_Result);
}
public Api_Result <object> Buy(int mst_id, int buyNum)
{
Api_Result <object> api_Result = new Api_Result <object>();
Mst_payitem mst_payitem = null;
if (!this.mst_payitem.TryGetValue(mst_id, ref mst_payitem))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
using (List <PayItemEffectInfo> .Enumerator enumerator = mst_payitem.Items.GetEnumerator())
{
while (enumerator.MoveNext())
{
PayItemEffectInfo current = enumerator.get_Current();
if (current.Type == 1)
{
Comm_UserDatas.Instance.Add_Useitem(current.MstId, current.Count);
}
else if (current.Type == 2)
{
IEnumerable <int> enumerable = Enumerable.Repeat <int>(current.MstId, current.Count);
Comm_UserDatas.Instance.Add_Slot(Enumerable.ToList <int>(enumerable));
}
else if (current.Type == 3)
{
enumMaterialCategory mstId = (enumMaterialCategory)current.MstId;
Comm_UserDatas.Instance.User_material.get_Item(mstId).Add_Material(current.Count);
}
}
}
Comm_UserDatas.Instance.User_basic.SubPoint(mst_payitem.Price * buyNum);
return(api_Result);
}
public Api_Result <Dictionary <int, User_MapinfoFmt> > Mapinfo()
{
Api_Result <Dictionary <int, User_MapinfoFmt> > api_Result = new Api_Result <Dictionary <int, User_MapinfoFmt> >();
api_Result.data = new Dictionary <int, User_MapinfoFmt>();
using (Dictionary <int, Mst_mapinfo> .Enumerator enumerator = Mst_DataManager.Instance.Mst_mapinfo.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <int, Mst_mapinfo> current = enumerator.get_Current();
User_MapinfoFmt user_MapinfoFmt = current.get_Value().GetUser_MapinfoData();
if (user_MapinfoFmt != null)
{
api_Result.data.Add(user_MapinfoFmt.Id, user_MapinfoFmt);
}
else if (current.get_Value().IsOpenMapSys())
{
user_MapinfoFmt = new User_MapinfoFmt();
user_MapinfoFmt.Id = current.get_Value().Id;
api_Result.data.Add(user_MapinfoFmt.Id, user_MapinfoFmt);
}
}
}
return(api_Result);
}
public Api_Result <Mem_ndock> Start(int rid, int ship_rid, bool highspeed)
{
Api_Result <Mem_ndock> api_Result = new Api_Result <Mem_ndock>();
Mem_ndock mem_ndock = null;
if (!Comm_UserDatas.Instance.User_ndock.TryGetValue(rid, ref mem_ndock))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (mem_ndock.State != NdockStates.EMPTY)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
Mem_ship mem_ship = null;
if (!Comm_UserDatas.Instance.User_ship.TryGetValue(ship_rid, ref mem_ship))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (mem_ship.IsBlingShip())
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
Dictionary <enumMaterialCategory, int> ndockMaterialNum = mem_ship.GetNdockMaterialNum();
if (ndockMaterialNum == null)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
int num = (!highspeed) ? 0 : 1;
if (ndockMaterialNum.get_Item(enumMaterialCategory.Fuel) > Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Fuel).Value || ndockMaterialNum.get_Item(enumMaterialCategory.Steel) > Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Steel).Value || num > Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Repair_Kit).Value)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
mem_ship.BlingWaitToStop();
if (!highspeed)
{
int ndockTimeSpan = mem_ship.GetNdockTimeSpan();
mem_ndock.RecoverStart(ship_rid, ndockMaterialNum, ndockTimeSpan);
}
else
{
mem_ndock.RecoverStart(ship_rid, ndockMaterialNum, 0);
mem_ndock.RecoverEnd(false);
Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Repair_Kit).Sub_Material(1);
}
api_Result.data = mem_ndock;
QuestSupply questSupply = new QuestSupply();
questSupply.ExecuteCheck();
return(api_Result);
}
public Api_Result <Mem_ndock> Start(int rid, int ship_rid, bool highspeed)
{
Api_Result <Mem_ndock> api_Result = new Api_Result <Mem_ndock>();
Mem_ndock value = null;
if (!Comm_UserDatas.Instance.User_ndock.TryGetValue(rid, out value))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (value.State != NdockStates.EMPTY)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
Mem_ship value2 = null;
if (!Comm_UserDatas.Instance.User_ship.TryGetValue(ship_rid, out value2))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (value2.IsBlingShip())
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
Dictionary <enumMaterialCategory, int> ndockMaterialNum = value2.GetNdockMaterialNum();
if (ndockMaterialNum == null)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
int num = highspeed ? 1 : 0;
if (ndockMaterialNum[enumMaterialCategory.Fuel] > Comm_UserDatas.Instance.User_material[enumMaterialCategory.Fuel].Value || ndockMaterialNum[enumMaterialCategory.Steel] > Comm_UserDatas.Instance.User_material[enumMaterialCategory.Steel].Value || num > Comm_UserDatas.Instance.User_material[enumMaterialCategory.Repair_Kit].Value)
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
value2.BlingWaitToStop();
if (!highspeed)
{
int ndockTimeSpan = value2.GetNdockTimeSpan();
value.RecoverStart(ship_rid, ndockMaterialNum, ndockTimeSpan);
}
else
{
value.RecoverStart(ship_rid, ndockMaterialNum, 0);
value.RecoverEnd(timeChk: false);
Comm_UserDatas.Instance.User_material[enumMaterialCategory.Repair_Kit].Sub_Material(1);
}
api_Result.data = value;
QuestSupply questSupply = new QuestSupply();
questSupply.ExecuteCheck();
return(api_Result);
}
public Api_Result <Mem_deck> Start(int deck_rid, int mission_id, int tankerNum)
{
Api_Result <Mem_deck> api_Result = new Api_Result <Mem_deck>();
Mst_mission2 value = null;
if (mission_id > 0)
{
if (!Mst_DataManager.Instance.Mst_mission.TryGetValue(mission_id, out value))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
}
else
{
List <Mst_mission2> supportResistedData = Mst_DataManager.Instance.GetSupportResistedData(Comm_UserDatas.Instance.User_deck[deck_rid].Area_id);
value = ((mission_id != -1) ? supportResistedData[1] : supportResistedData[0]);
}
Mem_deck value2 = null;
if (!Comm_UserDatas.Instance.User_deck.TryGetValue(deck_rid, out value2))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (mission_id > 0 && !Comm_UserDatas.Instance.User_missioncomp.ContainsKey(mission_id))
{
Mem_missioncomp mem_missioncomp = new Mem_missioncomp(mission_id, value.Maparea_id, MissionClearKinds.NOTCLEAR);
mem_missioncomp.Insert();
}
if (!value2.MissionStart(value))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
if (tankerNum > 0)
{
IEnumerable <Mem_tanker> enumerable = Mem_tanker.GetFreeTanker(Comm_UserDatas.Instance.User_tanker).Take(tankerNum);
List <Mem_tanker> list = new List <Mem_tanker>();
foreach (Mem_tanker item in enumerable)
{
if (!item.MissionStart(value.Maparea_id, deck_rid))
{
list.ForEach(delegate(Mem_tanker x)
{
x.MissionTerm();
});
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
list.Add(item);
}
}
api_Result.data = value2;
QuestMission questMission = new QuestMission(value.Id, value2, MissionResultKinds.FAILE);
questMission.ExecuteCheck();
return(api_Result);
}
private Api_Result <bool> SetDifficult(DifficultKind difficult)
{
Api_Result <bool> api_Result = new Api_Result <bool>();
Comm_UserDatas.Instance.User_basic.SetDifficult(difficult);
api_Result.data = true;
return(api_Result);
}
public Api_Result <List <User_MissionFmt> > Mission()
{
Api_Result <List <User_MissionFmt> > api_Result = new Api_Result <List <User_MissionFmt> >();
Mem_missioncomp mem_missioncomp = new Mem_missioncomp();
api_Result.data = mem_missioncomp.GetActiveMission();
return(api_Result);
}
public Api_Result <Dictionary <int, Mem_slotitem> > Slotitem()
{
Api_Result <Dictionary <int, Mem_slotitem> > api_Result = new Api_Result <Dictionary <int, Mem_slotitem> >();
Dictionary <int, Mem_slotitem> data = Enumerable.ToDictionary <KeyValuePair <int, Mem_slotitem>, int, Mem_slotitem>(Comm_UserDatas.Instance.User_slot, (KeyValuePair <int, Mem_slotitem> x) => x.get_Key(), (KeyValuePair <int, Mem_slotitem> y) => y.get_Value());
api_Result.data = data;
return(api_Result);
}
public Api_Result <Dictionary <enumMaterialCategory, Mem_material> > Material()
{
Api_Result <Dictionary <enumMaterialCategory, Mem_material> > api_Result = new Api_Result <Dictionary <enumMaterialCategory, Mem_material> >();
Dictionary <enumMaterialCategory, Mem_material> data = Enumerable.ToDictionary <KeyValuePair <enumMaterialCategory, Mem_material>, enumMaterialCategory, Mem_material>(Comm_UserDatas.Instance.User_material, (KeyValuePair <enumMaterialCategory, Mem_material> x) => x.get_Key(), (KeyValuePair <enumMaterialCategory, Mem_material> y) => y.get_Value());
api_Result.data = data;
return(api_Result);
}
