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 void SetMemData(Mem_ship mem_ship)
{
this._mem_data = mem_ship;
int ship_id = this._mem_data.Ship_id;
this._mst_data = Mst_DataManager.Instance.Mst_ship.get_Item(ship_id);
}
private DayBattleProductionFmt RaigPosture(int index)
{
DayBattleProductionFmt dayBattleProductionFmt = new DayBattleProductionFmt();
dayBattleProductionFmt.productionKind = BattleCommand.Raigeki;
dayBattleProductionFmt.FSPP = this.Fspp;
dayBattleProductionFmt.RSPP = this.Rspp;
dayBattleProductionFmt.BoxNo = index + 1;
double max = Math.Sqrt((double)this.userBaseData.ShipData.get_Item(0).Level / 3.0);
int num = 10 + (int)Utils.GetRandDouble(0.0, max, 1.0, 1);
Mem_ship mem_ship = this.userBaseData.ShipData.get_Item(0);
if (mem_ship.Lov >= 100)
{
double max2 = Math.Sqrt((double)mem_ship.Lov) / 3.0;
double randDouble = Utils.GetRandDouble(0.0, max2, 0.1, 1);
int num2 = (int)(randDouble + 0.5);
num += num2;
}
if (this.highSpeedFlag)
{
num += 3;
}
this.Tspp += num;
dayBattleProductionFmt.TSPP = this.Tspp;
return(dayBattleProductionFmt);
}
public bool RecoverEnd(bool timeChk)
{
if (timeChk && !this.IsRecoverEndTime())
{
return(false);
}
if (this.State != NdockStates.RESTORE)
{
return(false);
}
Mem_ship ship = Comm_UserDatas.Instance.User_ship.get_Item(this.Ship_id);
ship.NdockRecovery(this);
this.Ship_id = 0;
this.Item1 = 0;
this.Item3 = 0;
this.State = NdockStates.EMPTY;
this.StartTime = 0;
this.CompleteTime = 0;
if (!Enumerable.Any <Mem_deck>(Comm_UserDatas.Instance.User_deck.get_Values(), (Mem_deck x) => x.Ship.Find(ship.Rid) != -1))
{
if (timeChk)
{
ship.BlingSet(this.Area_id);
}
else
{
ship.BlingWait(this.Area_id, Mem_ship.BlingKind.WaitDeck);
}
}
return(true);
}
public Mem_shipBase(Mem_ship base_ship) : this()
{
this.Rid = base_ship.Rid;
this.GetNo = base_ship.GetNo;
this.Ship_id = base_ship.Ship_id;
this.Level = base_ship.Level;
this.Exp = base_ship.Exp;
this.Nowhp = base_ship.Nowhp;
this.Slot = Enumerable.ToList <int>(base_ship.Slot);
this.Onslot = Enumerable.ToList <int>(base_ship.Onslot);
this.SetKyoukaValue(base_ship.Kyouka);
this.Fuel = base_ship.Fuel;
this.Bull = base_ship.Bull;
this.Locked = base_ship.Locked;
this.Cond = base_ship.Cond;
this.Escape_sts = base_ship.Escape_sts;
this.BlingType = base_ship.BlingType;
this.Bling_start = base_ship.Bling_start;
this.Bling_end = base_ship.Bling_end;
this.BlingWaitArea = base_ship.BlingWaitArea;
base_ship.GetBattleCommand(out this.BattleCommand);
this.Lov = base_ship.Lov;
this.Lov_back_processed = base_ship.Lov_back_processed;
this.Lov_back_value = base_ship.Lov_back_value;
this.Lov_front_processed = base_ship.Lov_front_processed;
this.Lov_front_value = base_ship.Lov_front_value;
this.Exslot = base_ship.Exslot;
}
public BattleBaseData(Mem_deck deck)
{
List <Mem_ship> memShip = deck.Ship.getMemShip();
this.ShipData = new List <Mem_ship>();
this.SlotData = new List <List <Mst_slotitem> >();
this.StartHp = new List <int>();
this.SlotLevel = new List <List <int> >();
this.SlotExperience = new Dictionary <int, int[]>();
memShip.ForEach(delegate(Mem_ship x)
{
this.SlotData.Add(x.GetMstSlotItems());
List <int> list = null;
this.setSlotLevel(x.Slot, false, out list, ref this.SlotExperience);
this.SlotLevel.Add(list);
Mst_ship mst_data = Mst_DataManager.Instance.Mst_ship.get_Item(x.Ship_id);
Mem_shipBase baseData = new Mem_shipBase(x);
Mem_ship mem_ship = new Mem_ship();
mem_ship.Set_ShipParamPracticeShip(baseData, mst_data);
this.ShipData.Add(mem_ship);
this.StartHp.Add(mem_ship.Nowhp);
});
this.Enemy_Name = deck.Name;
this.haveBattleCommand = false;
}
public bool GoBackPort(int escapeRid, int towRid)
{
Mem_ship mem_ship = null;
Mem_ship mem_ship2 = null;
if (!Comm_UserDatas.Instance.User_ship.TryGetValue(escapeRid, ref mem_ship))
{
return(false);
}
if (!Comm_UserDatas.Instance.User_ship.TryGetValue(towRid, ref mem_ship2))
{
return(false);
}
if (mem_ship.Escape_sts)
{
return(false);
}
if (mem_ship2.Escape_sts)
{
return(false);
}
mem_ship.ChangeEscapeState();
mem_ship2.ChangeEscapeState();
return(true);
}
public bool Check_22(Mem_quest targetQuest)
{
if (type != KousyouKind.DestroyItem)
{
return(false);
}
Dictionary <int, int> counter = isAddCounter(targetQuest.Rid, checkData);
Mem_ship flagShip = getFlagShip(1);
string yomi = Mst_DataManager.Instance.Mst_ship[flagShip.Ship_id].Yomi;
if (!yomi.Equals("しょうかく"))
{
return(false);
}
Dictionary <int, int> mstSlotItemNum_OrderId = flagShip.GetMstSlotItemNum_OrderId(new HashSet <int>
{
143
});
if (mstSlotItemNum_OrderId[143] == 0)
{
return(false);
}
int num = destroyItems.Count((Mst_slotitem x) => x.Id == 17);
for (int i = 0; i < num; i++)
{
addCounterIncrementAll(counter);
}
return(CheckClearCounter(targetQuest.Rid));
}
public bool Check_26(Mem_quest targetQuest)
{
if (type != KousyouKind.DestroyItem)
{
return(false);
}
Dictionary <int, int> counter = isAddCounter(targetQuest.Rid, checkData);
Mem_ship flagShip = getFlagShip(1);
Dictionary <int, int> mstSlotItemNum_OrderId = flagShip.GetMstSlotItemNum_OrderId(new HashSet <int>
{
96
});
if (mstSlotItemNum_OrderId[96] == 0)
{
return(false);
}
int num = destroyItems.Count((Mst_slotitem x) => x.Id == 21);
for (int i = 0; i < num; i++)
{
addCounterIncrementAll(counter);
}
return(CheckClearCounter(targetQuest.Rid));
}
private void updateShipPracticeEnemy(SerializableDictionary <int, int> getShipExp, ref SerializableDictionary <int, List <int> > lvupInfo)
{
List <Mem_ship> shipData = E_Data.ShipData;
Dictionary <int, int> mst_level = mst_shiplevel;
foreach (Mem_ship item in shipData)
{
Mem_ship mem_ship = Comm_UserDatas.Instance.User_ship[item.Rid];
Mem_shipBase mem_shipBase = new Mem_shipBase(mem_ship);
Mst_ship mst_data = Mst_DataManager.Instance.Mst_ship[mem_shipBase.Ship_id];
int addExp = getShipExp[mem_ship.Rid];
List <int> lvupInfo2 = null;
int levelupInfo = mem_ship.getLevelupInfo(mst_level, mem_shipBase.Level, mem_shipBase.Exp, ref addExp, out lvupInfo2);
lvupInfo.Add(mem_ship.Rid, lvupInfo2);
mem_shipBase.Level = levelupInfo;
mem_shipBase.Exp += addExp;
int num = levelupInfo - mem_ship.Level;
Dictionary <Mem_ship.enumKyoukaIdx, int> dictionary = mem_ship.Kyouka;
for (int i = 0; i < num; i++)
{
dictionary = mem_ship.getLevelupKyoukaValue(mem_ship.Ship_id, dictionary);
}
mem_shipBase.SetKyoukaValue(dictionary);
mem_ship.SetRequireExp(mem_shipBase.Level, mst_level);
mem_ship.Set_ShipParam(mem_shipBase, mst_data, enemy_flag: false);
}
}
private SerializableDictionary <int, int> getShipExpSortie(BattleWinRankKinds rank, int mvpShip, int shipBaseExp)
{
SerializableDictionary <int, int> serializableDictionary = new SerializableDictionary <int, int>();
float num = 1.5f;
int num2 = 2;
double num3 = 4.5;
new List <int>();
foreach (KeyValuePair <int, BattleShipSubInfo> item in F_SubInfo)
{
Mem_ship shipInstance = item.Value.ShipInstance;
double num4 = shipInstance.IsFight() ? shipBaseExp : 0;
if (item.Value.DeckIdx == 0)
{
num4 *= (double)num;
}
num4 *= num3;
serializableDictionary.Add(shipInstance.Rid, (int)num4);
}
if (mvpShip <= 0)
{
return(serializableDictionary);
}
double num5 = serializableDictionary[mvpShip] * num2;
serializableDictionary[mvpShip] = (int)num5;
return(serializableDictionary);
}
protected List <Mem_ship> selectTaikuPlane(Dictionary <Mem_ship, List <FighterInfo> > fighter, ref int planeCount)
{
if (fighter == null)
{
return(null);
}
List <Mem_ship> list = new List <Mem_ship>();
foreach (KeyValuePair <Mem_ship, List <FighterInfo> > item in fighter)
{
Mem_ship key = item.Key;
int num = 0;
foreach (FighterInfo item2 in item.Value)
{
if (item2.ValidTaiku() && key.Onslot[item2.SlotIdx] > 0)
{
num += key.Onslot[item2.SlotIdx];
}
}
if (num > 0)
{
planeCount += num;
list.Add(key);
}
}
return(list);
}
protected virtual int getBakuraiAtkPow(FighterInfo fighter, int fighterNum, Mem_ship target)
{
if (!fighter.ValidBakurai())
{
return(0);
}
Mst_ship mst_ship = Mst_DataManager.Instance.Mst_ship[target.Ship_id];
Mst_stype mst_stype = Mst_DataManager.Instance.Mst_stype[target.Stype];
int num = fighter.AttackShipPow;
if (fighter.Kind == FighterInfo.FighterKinds.RAIG && mst_stype.IsLandFacillity(mst_ship.Soku))
{
num = 0;
}
int num2 = 150;
double num3 = valance3 + (double)num * Math.Sqrt(fighterNum);
if (fighter.Kind == FighterInfo.FighterKinds.RAIG)
{
num3 *= 0.8 + (double)randInstance.Next(2) * 0.7;
}
if (num3 > (double)num2)
{
num3 = (double)num2 + Math.Sqrt(num3 - (double)num2);
}
return((int)num3);
}
public void SetMemData(Mem_ship mem_ship)
{
_mem_data = mem_ship;
int ship_id = _mem_data.Ship_id;
_mst_data = Mst_DataManager.Instance.Mst_ship[ship_id];
}
public int GetRequireUseBauxiteNum(Mem_ship ship, ref int haveBauxite, out List <int> afterOnslot)
{
afterOnslot = new List <int>(ship.Onslot);
if (haveBauxite == 0)
{
return(0);
}
int num = haveBauxite;
Mst_ship mst_ship = Mst_DataManager.Instance.Mst_ship[ship.Ship_id];
for (int i = 0; i < ship.Slotnum; i++)
{
if (haveBauxite == 0)
{
break;
}
if (afterOnslot[i] < mst_ship.Maxeq[i])
{
int num4 = ship.Slot[i];
int num2 = mst_ship.Maxeq[i] - ship.Onslot[i];
int num3 = num2 * 5;
if (haveBauxite >= num3)
{
afterOnslot[i] += num2;
haveBauxite -= num3;
}
}
}
return(num - haveBauxite);
}
protected void subOnslot(SakutekiInfo targetInfo)
{
using (Dictionary <Mem_ship, List <int> > .Enumerator enumerator = targetInfo.LostTargetOnslot.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <Mem_ship, List <int> > current = enumerator.get_Current();
Mem_ship key = current.get_Key();
using (List <int> .Enumerator enumerator2 = current.get_Value().GetEnumerator())
{
while (enumerator2.MoveNext())
{
int current2 = enumerator2.get_Current();
int num = this.randInstance.Next(3);
if (key.Onslot.get_Item(current2) < num)
{
num = key.Onslot.get_Item(current2);
}
List <int> onslot;
List <int> expr_73 = onslot = key.Onslot;
int num2;
int expr_78 = num2 = current2;
num2 = onslot.get_Item(num2);
expr_73.set_Item(expr_78, num2 - num);
}
}
}
}
}
private HashSet <int> ChargeDataSet_Onslot(enumHokyuType type, Mem_ship m_ship)
{
enumMaterialCategory key = enumMaterialCategory.Bauxite;
int haveBauxite = Comm_UserDatas.Instance.User_material[key].Value;
HashSet <int> hashSet = new HashSet <int>();
List <int> afterOnslot;
if (haveBauxite == 0)
{
int haveBauxite2 = 100;
int requireUseBauxiteNum = GetRequireUseBauxiteNum(m_ship, ref haveBauxite2, out afterOnslot);
if (requireUseBauxiteNum > 0)
{
hashSet.Add(-2);
}
hashSet.Add(-1);
return(hashSet);
}
int requireUseBauxiteNum2 = GetRequireUseBauxiteNum(m_ship, ref haveBauxite, out afterOnslot);
m_ship.Set_ChargeData(m_ship.Bull, m_ship.Fuel, afterOnslot);
Comm_UserDatas.Instance.User_material[key].Sub_Material(requireUseBauxiteNum2);
List <int> maxeq = Mst_DataManager.Instance.Mst_ship[m_ship.Ship_id].Maxeq;
for (int i = 0; i < m_ship.Slotnum; i++)
{
if (maxeq[i] > 0 && maxeq[i] != m_ship.Onslot[i])
{
hashSet.Add(-2);
}
}
return(hashSet);
}
public bool GoBackPort(int escapeRid, int towRid)
{
Mem_ship value = null;
Mem_ship value2 = null;
if (!Comm_UserDatas.Instance.User_ship.TryGetValue(escapeRid, out value))
{
return(false);
}
if (!Comm_UserDatas.Instance.User_ship.TryGetValue(towRid, out value2))
{
return(false);
}
if (value.Escape_sts)
{
return(false);
}
if (value2.Escape_sts)
{
return(false);
}
value.ChangeEscapeState();
value2.ChangeEscapeState();
return(true);
}
protected bool CanAirAttack(Mem_ship ship, List <Mst_slotitem> slotData)
{
if (!ship.IsFight())
{
return(false);
}
HashSet <int> hashSet = new HashSet <int>();
hashSet.Add(7);
hashSet.Add(8);
HashSet <int> hashSet2 = hashSet;
int num = 0;
int num2 = 0;
int num3 = 0;
for (int i = 0; i < slotData.Count(); i++)
{
Mst_slotitem mst_slotitem = slotData[i];
if (mst_slotitem != null && hashSet2.Contains(mst_slotitem.Api_mapbattle_type3))
{
num += ship.Onslot[i];
num2 += mst_slotitem.Baku;
num3 += mst_slotitem.Raig;
}
}
if (num <= 0)
{
return(false);
}
if (getAirAtackPow(num2, num3) <= 0)
{
return(false);
}
return(true);
}
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 bool RecoverEnd(bool timeChk)
{
if (timeChk && !IsRecoverEndTime())
{
return(false);
}
if (State != NdockStates.RESTORE)
{
return(false);
}
Mem_ship ship = Comm_UserDatas.Instance.User_ship[Ship_id];
ship.NdockRecovery(this);
Ship_id = 0;
Item1 = 0;
Item3 = 0;
State = NdockStates.EMPTY;
StartTime = 0;
CompleteTime = 0;
if (!Comm_UserDatas.Instance.User_deck.Values.Any((Mem_deck x) => x.Ship.Find(ship.Rid) != -1))
{
if (timeChk)
{
ship.BlingSet(Area_id);
}
else
{
ship.BlingWait(Area_id, Mem_ship.BlingKind.WaitDeck);
}
}
return(true);
}
public SlotSetChkResult_Slot IsValidSlotSet(int ship_rid, int slot_rid)
{
if (this.IsValidSlotSet(ship_rid) != Api_req_Kaisou.SlotSetChkResult_Ship.Ok)
{
return(SlotSetChkResult_Slot.NgInvalid);
}
Mem_ship mem_ship = Comm_UserDatas.Instance.User_ship.get_Item(ship_rid);
if (!mem_ship.IsOpenExSlot())
{
return(SlotSetChkResult_Slot.NgInvalid);
}
Mem_slotitem mem_slotitem = null;
if (slot_rid != -1)
{
Comm_UserDatas.Instance.User_slot.TryGetValue(slot_rid, ref mem_slotitem);
if (mem_slotitem == null)
{
return(SlotSetChkResult_Slot.NgInvalid);
}
if (mem_slotitem.Equip_flag == Mem_slotitem.enumEquipSts.Equip)
{
return(SlotSetChkResult_Slot.NgInvalid);
}
}
else if (slot_rid == -1)
{
return(SlotSetChkResult_Slot.Ok);
}
return(SlotSetChkResult_Slot.Ok);
}
protected void subSlotExp(SakutekiInfo targetInfo, BattleSearchValues serchKind)
{
if (serchKind == BattleSearchValues.Lost || serchKind == BattleSearchValues.Success_Lost)
{
Dictionary <int, int[]> slotExperience = F_Data.SlotExperience;
foreach (KeyValuePair <Mem_ship, List <int> > item in targetInfo.LostTargetOnslot)
{
Mem_ship key = item.Key;
foreach (int item2 in item.Value)
{
if (key.Onslot[item2] > 0)
{
int key2 = key.Slot[item2];
double num = (serchKind != BattleSearchValues.Lost) ? 6.0 : 12.0;
double randDouble = Utils.GetRandDouble(0.0, num - 1.0, 1.0, 1);
int num2 = slotExperience[key2][0];
int num3 = num2 - (int)(num * 0.5 + randDouble * 0.05);
if (num3 < 0)
{
num3 = 0;
}
int num4 = num3 - num2;
slotExperience[key2][1] = slotExperience[key2][1] + num4;
}
}
}
}
}
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);
}
protected override double getAvoHosei(Mem_ship target)
{
List <Mst_slotitem> source;
List <int> list;
if (target.IsEnemy())
{
int deckIdx = E_SubInfo[target.Rid].DeckIdx;
source = E_Data.SlotData[deckIdx];
list = E_Data.SlotLevel[deckIdx];
}
else
{
int deckIdx2 = F_SubInfo[target.Rid].DeckIdx;
source = F_Data.SlotData[deckIdx2];
list = F_Data.SlotLevel[deckIdx2];
}
double num = 0.0;
foreach (var item in source.Select((Mst_slotitem obj, int idx) => new
{
obj,
idx
}))
{
if (item.obj.Api_mapbattle_type3 == 14 || item.obj.Api_mapbattle_type3 == 40)
{
num += Math.Sqrt(list[item.idx]) * 1.5;
}
}
return(num);
}
public Api_req_Kaisou.SlotSetChkResult_Ship IsValidSlotSet(int ship_rid)
{
Mem_ship mem_ship = null;
if (!Comm_UserDatas.Instance.User_ship.TryGetValue(ship_rid, ref mem_ship))
{
return(Api_req_Kaisou.SlotSetChkResult_Ship.Invalid);
}
if (mem_ship.IsBlingShip())
{
return(Api_req_Kaisou.SlotSetChkResult_Ship.BlingShip);
}
Mem_deck mem_deck = Enumerable.FirstOrDefault <Mem_deck>(Comm_UserDatas.Instance.User_deck.get_Values(), (Mem_deck x) => x.Ship.Find(ship_rid) != -1);
if (mem_deck != null)
{
if (mem_deck.MissionState != MissionStates.NONE)
{
return(Api_req_Kaisou.SlotSetChkResult_Ship.Mission);
}
if (mem_deck.IsActionEnd)
{
return(Api_req_Kaisou.SlotSetChkResult_Ship.ActionEndDeck);
}
}
if (Enumerable.Any <Mem_ndock>(Comm_UserDatas.Instance.User_ndock.get_Values(), (Mem_ndock x) => x.Ship_id == ship_rid))
{
return(Api_req_Kaisou.SlotSetChkResult_Ship.Repair);
}
return(Api_req_Kaisou.SlotSetChkResult_Ship.Ok);
}
private int getSyokusetuPlane(Dictionary <Mst_slotitem, HashSet <Mem_ship> > touchItems)
{
IOrderedEnumerable <Mst_slotitem> orderedEnumerable = Enumerable.OrderByDescending <Mst_slotitem, int>(touchItems.get_Keys(), (Mst_slotitem x) => x.Houm);
using (IEnumerator <Mst_slotitem> enumerator = orderedEnumerable.GetEnumerator())
{
while (enumerator.MoveNext())
{
Mst_slotitem current = enumerator.get_Current();
Mst_slotitem mst_slotitem = current;
using (HashSet <Mem_ship> .Enumerator enumerator2 = touchItems.get_Item(current).GetEnumerator())
{
while (enumerator2.MoveNext())
{
Mem_ship current2 = enumerator2.get_Current();
double num = Math.Sqrt((double)mst_slotitem.Saku);
double num2 = Math.Sqrt((double)current2.Level);
int num3 = (int)(num * num2);
if (num3 > this.randInstance.Next(25))
{
return(mst_slotitem.Id);
}
}
}
}
}
return(0);
}
public int GetRequireUseBauxiteNum(Mem_ship ship, ref int haveBauxite, out List <int> afterOnslot)
{
afterOnslot = new List <int>(ship.Onslot);
if (haveBauxite == 0)
{
return(0);
}
int num = haveBauxite;
Mst_ship mst_ship = Mst_DataManager.Instance.Mst_ship.get_Item(ship.Ship_id);
for (int i = 0; i < ship.Slotnum; i++)
{
if (haveBauxite == 0)
{
break;
}
if (afterOnslot.get_Item(i) < mst_ship.Maxeq.get_Item(i))
{
int num2 = ship.Slot.get_Item(i);
int num3 = mst_ship.Maxeq.get_Item(i) - ship.Onslot.get_Item(i);
int num4 = num3 * 5;
if (haveBauxite >= num4)
{
afterOnslot.set_Item(i, afterOnslot.get_Item(i) + num3);
haveBauxite -= num4;
}
}
}
return(num - haveBauxite);
}
private DayBattleProductionFmt Kaihi(int index)
{
Mem_ship mem_ship = this.userBaseData.ShipData.get_Item(0);
double num = -4.0 + Utils.GetRandDouble(0.0, Math.Sqrt((double)(mem_ship.Level / 20)), 1.0, 1);
double num2 = -6.0 + Utils.GetRandDouble(0.0, Math.Sqrt((double)(mem_ship.Level / 15)), 1.0, 1);
double num3 = 5.0 + Utils.GetRandDouble(0.0, Math.Sqrt((double)(mem_ship.Level / 10)), 1.0, 1);
if (this.highSpeedFlag)
{
num3 = num3 + 1.0 + Utils.GetRandDouble(0.0, Math.Sqrt((double)(mem_ship.Level / 20)), 1.0, 1);
}
else
{
num3 += Utils.GetRandDouble(0.0, Math.Sqrt((double)(mem_ship.Level / 25)), 1.0, 1);
}
this.Fspp += (int)num;
this.Tspp += (int)num2;
this.Rspp += (int)num3;
return(new DayBattleProductionFmt
{
productionKind = BattleCommand.Kaihi,
FSPP = this.Fspp,
RSPP = this.Rspp,
TSPP = this.Tspp,
BoxNo = index + 1
});
}
private void setEscapeData(IEnumerable <Mem_ship> ships, IEnumerable <Mem_ship> enableTowShips)
{
List <int> list = new List <int>();
List <int> list2 = new List <int>();
using (IEnumerator <Mem_ship> enumerator = ships.GetEnumerator())
{
while (enumerator.MoveNext())
{
Mem_ship current = enumerator.get_Current();
if (current.IsFight())
{
DamageState damageState = current.Get_DamageState();
bool flag = Enumerable.Contains <Mem_ship>(enableTowShips, current);
if (damageState == DamageState.Taiha)
{
list.Add(current.Rid);
}
else if (damageState == DamageState.Normal && current.Stype == 2 && flag)
{
list2.Add(current.Rid);
}
}
}
}
if (list.get_Count() > 0 && list2.get_Count() > 0)
{
this.EscapeShips = list;
this.TowShips = list2;
}
}
