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; } }