private int takeBonusDevKit()
{
Dictionary <int, Mst_maparea> .ValueCollection values = Mst_DataManager.Instance.Mst_maparea.Values;
Comm_UserDatas instance = Comm_UserDatas.Instance;
int num = 0;
foreach (Mst_maparea item in values)
{
int mapinfo_no = Mst_maparea.MaxMapNum(Comm_UserDatas.Instance.User_basic.Difficult, item.Id);
int key = Mst_mapinfo.ConvertMapInfoId(item.Id, mapinfo_no);
Mem_mapclear value = null;
if (instance.User_mapclear.TryGetValue(key, out value) && value.State == MapClearState.Cleard)
{
num++;
}
}
int num2 = num + 4;
int value2 = Comm_UserDatas.Instance.User_material[enumMaterialCategory.Dev_Kit].Value;
int num3 = value2 + num2;
int materialLimit = Mst_DataManager.Instance.Mst_item_limit[1].GetMaterialLimit(Mst_DataManager.Instance.Mst_item_limit, enumMaterialCategory.Dev_Kit);
if (num3 > materialLimit)
{
num2 = materialLimit - value2;
if (num2 < 0)
{
num2 = 0;
}
}
Comm_UserDatas.Instance.User_material[enumMaterialCategory.Dev_Kit].Add_Material(num2);
return(num2);
}
private bool updateAreaCompHisory(int maxMapNum)
{
int firstMap = Mst_mapinfo.ConvertMapInfoId(mst_mapinfo.Maparea_id, 1);
List <Mem_history> value = null;
if (!Comm_UserDatas.Instance.User_history.TryGetValue(999, out value))
{
value = new List <Mem_history>();
}
if (value.Any((Mem_history x) => x.MapinfoId == firstMap))
{
return(false);
}
int num = Comm_UserDatas.Instance.User_mapclear.Values.Count((Mem_mapclear x) => (x.Maparea_id == mst_mapinfo.Maparea_id && x.Cleared && x.State == MapClearState.Cleard) ? true : false);
if (num != maxMapNum)
{
return(false);
}
Mem_history mem_history = new Mem_history();
mem_history.SetAreaComplete(firstMap);
Comm_UserDatas.Instance.Add_History(mem_history);
return(true);
}
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);
}
public static void OpenMapAreaAll()
{
using (Dictionary <int, Mst_mapinfo> .ValueCollection.Enumerator enumerator = Mst_DataManager.Instance.Mst_mapinfo.get_Values().GetEnumerator())
{
while (enumerator.MoveNext())
{
Mst_mapinfo current = enumerator.get_Current();
if (!Comm_UserDatas.Instance.User_mapclear.ContainsKey(current.Id))
{
Mem_mapclear mem_mapclear = new Mem_mapclear(current.Id, current.Maparea_id, current.No, MapClearState.Cleard);
mem_mapclear.Insert();
}
if (current.Maparea_id != 1 && current.No == 1 && Mem_history.IsFirstOpenArea(current.Id))
{
Mem_history mem_history = new Mem_history();
mem_history.SetAreaOpen(Comm_UserDatas.Instance.User_turn.Total_turn, current.Id);
Comm_UserDatas.Instance.Add_History(mem_history);
}
}
}
if (Utils.IsGameClear() && Comm_UserDatas.Instance.User_kdock.get_Count() > 0)
{
Comm_UserDatas.Instance.User_record.AddClearDifficult(Comm_UserDatas.Instance.User_basic.Difficult);
}
new Api_get_Member().StrategyInfo();
}
public MapModel(Mst_mapinfo mst_map, User_MapinfoFmt mem_map)
{
_mst_map_data = mst_map;
_mem_map_data = mem_map;
_mapHP = new MapHPModel(_mst_map_data, _mem_map_data);
if (_mapHP.MaxValue == 0)
{
_mapHP = null;
}
}
public static bool IsGameClear()
{
Dictionary <int, Mem_mapclear> user_mapclear = Comm_UserDatas.Instance.User_mapclear;
if (user_mapclear == null)
{
return(false);
}
int num = 17;
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
int mapinfo_no = Mst_maparea.MaxMapNum(difficult, num);
int num2 = Mst_mapinfo.ConvertMapInfoId(num, mapinfo_no);
return(user_mapclear.ContainsKey(num2) && user_mapclear.get_Item(num2).Cleared);
}
public static void OpenMapArea(int maparea_id, int mapinfo_no)
{
if (Comm_UserDatas.Instance.User_basic.Starttime == 0)
{
return;
}
if (!Mst_DataManager.Instance.Mst_maparea.ContainsKey(maparea_id))
{
return;
}
int num = Mst_mapinfo.ConvertMapInfoId(maparea_id, mapinfo_no);
if (!Mst_DataManager.Instance.Mst_mapinfo.ContainsKey(num))
{
return;
}
Mem_mapclear mem_mapclear = null;
if (Comm_UserDatas.Instance.User_mapclear.TryGetValue(num, ref mem_mapclear))
{
if (mem_mapclear.State == MapClearState.InvationClose)
{
return;
}
if (mem_mapclear.State != MapClearState.Cleard)
{
mem_mapclear.StateChange(MapClearState.Cleard);
}
}
else
{
mem_mapclear = new Mem_mapclear(num, maparea_id, mapinfo_no, MapClearState.Cleard);
mem_mapclear.Insert();
}
if (Utils.IsGameClear() && Comm_UserDatas.Instance.User_kdock.get_Count() > 0)
{
Comm_UserDatas.Instance.User_record.AddClearDifficult(Comm_UserDatas.Instance.User_basic.Difficult);
}
if (maparea_id != 1 && mapinfo_no == 1 && Mem_history.IsFirstOpenArea(num))
{
Mem_history mem_history = new Mem_history();
mem_history.SetAreaOpen(Comm_UserDatas.Instance.User_turn.Total_turn, num);
Comm_UserDatas.Instance.Add_History(mem_history);
}
List <int> list = new List <int>();
new RebellionUtils().MapReOpen(mem_mapclear, out list);
}
public void LostArea(int maparea_id, List <int> sortieDeckRid)
{
Comm_UserDatas commInstance = Comm_UserDatas.Instance;
if (sortieDeckRid == null)
{
sortieDeckRid = new List <int>();
}
List <int> lostArea = getLostArea(maparea_id);
lostArea.ForEach(delegate(int lostAreaId)
{
Dictionary <int, Mem_mapclear> dictionary = (from x in commInstance.User_mapclear.Values
where x.Maparea_id == lostAreaId
select x).ToDictionary((Mem_mapclear x) => x.Mapinfo_no, (Mem_mapclear y) => y);
int num = Mst_maparea.MaxMapNum(commInstance.User_basic.Difficult, lostAreaId);
for (int i = 1; i <= num; i++)
{
if (!dictionary.ContainsKey(i))
{
int mapinfo_id = Mst_mapinfo.ConvertMapInfoId(lostAreaId, i);
Mem_mapclear mem_mapclear = new Mem_mapclear(mapinfo_id, lostAreaId, i, MapClearState.InvationClose);
mem_mapclear.Insert();
dictionary.Add(i, mem_mapclear);
}
}
lostMapClear(dictionary.Values.ToList(), Mst_DataManager.Instance.Mst_maparea[lostAreaId].Neighboring_area);
Comm_UserDatas.Instance.User_rebellion_point.Remove(lostAreaId);
List <Mem_tanker> areaTanker = Mem_tanker.GetAreaTanker(lostAreaId);
lostTanker(areaTanker);
IEnumerable <Mem_deck> memDeck = from x in commInstance.User_deck.Values
where x.Area_id == lostAreaId
select x;
goBackDeck(memDeck, sortieDeckRid);
Mem_esccort_deck escort = commInstance.User_EscortDeck[lostAreaId];
goBackEscortDeck(escort);
List <Mem_ndock> ndock = (from x in commInstance.User_ndock.Values
where x.Area_id == lostAreaId
select x).ToList();
lostNdock(ndock);
Dictionary <enumMaterialCategory, Mem_material> user_material = commInstance.User_material;
lostMaterial(user_material);
if (lostAreaId == 1)
{
lostKdock();
}
});
}
private void lostMapClear(List <Mem_mapclear> ownMapClear, List <int> neighboringArea)
{
ownMapClear.ForEach(delegate(Mem_mapclear x)
{
x.StateChange(MapClearState.InvationClose);
});
neighboringArea.ForEach(delegate(int area)
{
int mapinfo_no = Mst_maparea.MaxMapNum(Comm_UserDatas.Instance.User_basic.Difficult, area);
int key = Mst_mapinfo.ConvertMapInfoId(area, mapinfo_no);
if (Comm_UserDatas.Instance.User_mapclear.TryGetValue(key, out Mem_mapclear value) && value.State != MapClearState.InvationClose)
{
value.StateChange(MapClearState.InvationNeighbor);
}
});
}
public static Dictionary <int, Mst_mapinfo> GetActiveMap()
{
Dictionary <int, Mst_mapinfo> dictionary = new Dictionary <int, Mst_mapinfo>();
using (Dictionary <int, Mst_mapinfo> .ValueCollection.Enumerator enumerator = Mst_DataManager.Instance.Mst_mapinfo.get_Values().GetEnumerator())
{
while (enumerator.MoveNext())
{
Mst_mapinfo current = enumerator.get_Current();
User_MapinfoFmt user_MapinfoData = current.GetUser_MapinfoData();
if (user_MapinfoData != null && user_MapinfoData.IsGo)
{
dictionary.Add(current.Id, current);
}
}
}
return(dictionary);
}
public SortieManager(int area_id)
{
_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 = (api_Result.state != 0) ? new Dictionary <int, User_MapinfoFmt>() : api_Result.data;
_maps = new List <MapModel>();
foreach (User_MapinfoFmt value in dictionary.Values)
{
Mst_mapinfo mst_mapinfo2 = mst_mapinfo[value.Id];
if (mst_mapinfo2.Maparea_id == area_id)
{
MapModel item = new MapModel(mst_mapinfo2, value);
_maps.Add(item);
}
}
_maps.Sort((MapModel x, MapModel y) => (x.MstId > y.MstId) ? 1 : (-1));
}
private int takeBonusDevKit()
{
Dictionary <int, Mst_maparea> .ValueCollection values = Mst_DataManager.Instance.Mst_maparea.get_Values();
Comm_UserDatas instance = Comm_UserDatas.Instance;
int num = 0;
using (Dictionary <int, Mst_maparea> .ValueCollection.Enumerator enumerator = values.GetEnumerator())
{
while (enumerator.MoveNext())
{
Mst_maparea current = enumerator.get_Current();
int mapinfo_no = Mst_maparea.MaxMapNum(Comm_UserDatas.Instance.User_basic.Difficult, current.Id);
int num2 = Mst_mapinfo.ConvertMapInfoId(current.Id, mapinfo_no);
Mem_mapclear mem_mapclear = null;
if (instance.User_mapclear.TryGetValue(num2, ref mem_mapclear))
{
if (mem_mapclear.State == MapClearState.Cleard)
{
num++;
}
}
}
}
int num3 = num + 4;
int value = Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Dev_Kit).Value;
int num4 = value + num3;
int materialLimit = Mst_DataManager.Instance.Mst_item_limit.get_Item(1).GetMaterialLimit(Mst_DataManager.Instance.Mst_item_limit, enumMaterialCategory.Dev_Kit);
if (num4 > materialLimit)
{
num3 = materialLimit - value;
if (num3 < 0)
{
num3 = 0;
}
}
Comm_UserDatas.Instance.User_material.get_Item(enumMaterialCategory.Dev_Kit).Add_Material(num3);
return(num3);
}
public MapHPModel(Mst_mapinfo mst, User_MapinfoFmt mem)
{
this._mapID = mst.Id;
if (mem != null)
{
this._type = mem.Boss_type;
if (this._type == User_MapinfoFmt.enumExBossType.MapHp)
{
this._max_value = mem.Eventmap.Event_maxhp;
this._now_value = mem.Eventmap.Event_hp;
}
else if (this._type == User_MapinfoFmt.enumExBossType.Defeat)
{
this._max_value = 0;
this._now_value = Math.Max(this._max_value - mem.Defeat_count, 0);
}
}
else
{
this._type = User_MapinfoFmt.enumExBossType.Normal;
this._max_value = (this._now_value = 0);
}
}
public Exec_BattleResult(BattleResultBase execBattleData)
{
mst_shiplevel = Mst_DataManager.Instance.Get_MstLevel(shipTable: true);
_f_Data = execBattleData.MyData;
_e_Data = execBattleData.EnemyData;
_f_SubInfo = execBattleData.F_SubInfo;
_e_SubInfo = execBattleData.E_SubInfo;
practiceFlag = execBattleData.PracticeFlag;
battleKinds = execBattleData.ExecKinds;
clothBrokenIds = new List <int>();
if (!execBattleData.PracticeFlag)
{
mst_enemy = Mst_DataManager.Instance.Mst_mapenemy[_e_Data.Enemy_id];
string str = mst_enemy.Maparea_id.ToString();
string str2 = mst_enemy.Mapinfo_no.ToString();
int key = int.Parse(str + str2);
mst_mapinfo = Mst_DataManager.Instance.Mst_mapinfo[key];
deleteTargetShip = new List <Mem_ship>();
cleard = execBattleData.Cleard;
nowCell = execBattleData.NowCell;
}
isRebellionBattle = execBattleData.RebellionBattle;
airCellItems = execBattleData.GetAirCellItems;
}
private List <RadingResultData> getRadingResult(int radingPhase, Dictionary <int, RadingKind> targetArea, Dictionary <int, List <Mem_tanker> > tankers)
{
DifficultKind difficult = basicInstance.Difficult;
List <RadingResultData> list = new List <RadingResultData>();
foreach (KeyValuePair <int, RadingKind> item in targetArea)
{
int key = item.Key;
List <Mem_tanker> list2 = tankers[key];
Mst_radingrate mst_radingrate = Mst_DataManager.Instance.Mst_RadingRate[key][radingPhase];
int count = list2.Count;
List <Mem_ship> memShip = Comm_UserDatas.Instance.User_EscortDeck[key].Ship.getMemShip();
RadingResultData radingResultData = new RadingResultData();
radingResultData.AreaId = key;
radingResultData.AttackKind = item.Value;
radingResultData.BeforeNum = list2.Count;
List <Mem_ship> deleteShips = null;
if (memShip.Count > 0)
{
radingResultData.FlagShipMstId = memShip[0].Ship_id;
radingResultData.FlagShipDamageState = memShip[0].Get_DamageState();
}
radingResultData.RadingDamage = getRadingDamage(key, item.Value, mst_radingrate, memShip, out radingResultData.DeckAttackPow, out deleteShips);
radingResultData.BreakNum = getRadingTankerLostNum(item.Value, memShip, count, mst_radingrate);
IEnumerable <Mem_tanker> enumerable = list2.Take(radingResultData.BreakNum);
if (radingResultData.RadingDamage.Count > 0)
{
List <int> list3 = new List <int>();
using (List <Mem_ship> .Enumerator enumerator2 = memShip.GetEnumerator())
{
Mem_ship checkShip;
while (enumerator2.MoveNext())
{
checkShip = enumerator2.Current;
if (radingResultData.RadingDamage.Any((RadingDamageData x) => x.Rid == checkShip.Rid && x.Damage) && checkShip.Get_DamageState() >= DamageState.Tyuuha)
{
list3.Add(checkShip.Ship_id);
}
}
}
Comm_UserDatas.Instance.UpdateShipBookBrokenClothState(list3);
}
foreach (Mem_ship item2 in deleteShips)
{
Comm_UserDatas.Instance.User_EscortDeck[key].Ship.RemoveShip(item2.Rid);
Comm_UserDatas.Instance.User_record.AddLostShipCount();
}
Comm_UserDatas.Instance.Remove_Ship(deleteShips);
foreach (Mem_tanker item3 in enumerable)
{
Comm_UserDatas.Instance.Remove_Tanker(item3.Rid);
}
if (radingResultData.BeforeNum > 0)
{
double num = (double)radingResultData.BreakNum / (double)radingResultData.BeforeNum;
if (num >= 0.5)
{
int mapinfo_id = Mst_mapinfo.ConvertMapInfoId(key, 1);
Mem_history mem_history = new Mem_history();
mem_history.SetTanker(turnInstance.Total_turn, mapinfo_id, (num >= 1.0) ? true : false);
Comm_UserDatas.Instance.Add_History(mem_history);
}
}
list.Add(radingResultData);
}
return(list);
}
private List <RadingResultData> getRadingResult(int radingPhase, Dictionary <int, RadingKind> targetArea, Dictionary <int, List <Mem_tanker> > tankers)
{
DifficultKind difficult = this.basicInstance.Difficult;
List <RadingResultData> list = new List <RadingResultData>();
using (Dictionary <int, RadingKind> .Enumerator enumerator = targetArea.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <int, RadingKind> current = enumerator.get_Current();
int key = current.get_Key();
List <Mem_tanker> list2 = tankers.get_Item(key);
Mst_radingrate mst_radingrate = Mst_DataManager.Instance.Mst_RadingRate.get_Item(key).get_Item(radingPhase);
int count = list2.get_Count();
List <Mem_ship> memShip = Comm_UserDatas.Instance.User_EscortDeck.get_Item(key).Ship.getMemShip();
RadingResultData radingResultData = new RadingResultData();
radingResultData.AreaId = key;
radingResultData.AttackKind = current.get_Value();
radingResultData.BeforeNum = list2.get_Count();
List <Mem_ship> list3 = null;
if (memShip.get_Count() > 0)
{
radingResultData.FlagShipMstId = memShip.get_Item(0).Ship_id;
radingResultData.FlagShipDamageState = memShip.get_Item(0).Get_DamageState();
}
radingResultData.RadingDamage = this.getRadingDamage(key, current.get_Value(), mst_radingrate, memShip, out radingResultData.DeckAttackPow, out list3);
radingResultData.BreakNum = this.getRadingTankerLostNum(current.get_Value(), memShip, count, mst_radingrate);
IEnumerable <Mem_tanker> enumerable = Enumerable.Take <Mem_tanker>(list2, radingResultData.BreakNum);
if (radingResultData.RadingDamage.get_Count() > 0)
{
List <int> list4 = new List <int>();
using (List <Mem_ship> .Enumerator enumerator2 = memShip.GetEnumerator())
{
Mem_ship checkShip;
while (enumerator2.MoveNext())
{
checkShip = enumerator2.get_Current();
if (Enumerable.Any <RadingDamageData>(radingResultData.RadingDamage, (RadingDamageData x) => x.Rid == checkShip.Rid && x.Damage) && checkShip.Get_DamageState() >= DamageState.Tyuuha)
{
list4.Add(checkShip.Ship_id);
}
}
}
Comm_UserDatas.Instance.UpdateShipBookBrokenClothState(list4);
}
using (List <Mem_ship> .Enumerator enumerator3 = list3.GetEnumerator())
{
while (enumerator3.MoveNext())
{
Mem_ship current2 = enumerator3.get_Current();
Comm_UserDatas.Instance.User_EscortDeck.get_Item(key).Ship.RemoveShip(current2.Rid);
Comm_UserDatas.Instance.User_record.AddLostShipCount();
}
}
Comm_UserDatas.Instance.Remove_Ship(list3);
using (IEnumerator <Mem_tanker> enumerator4 = enumerable.GetEnumerator())
{
while (enumerator4.MoveNext())
{
Mem_tanker current3 = enumerator4.get_Current();
Comm_UserDatas.Instance.Remove_Tanker(current3.Rid);
}
}
if (radingResultData.BeforeNum > 0)
{
double num = (double)radingResultData.BreakNum / (double)radingResultData.BeforeNum;
if (num >= 0.5)
{
int mapinfo_id = Mst_mapinfo.ConvertMapInfoId(key, 1);
Mem_history mem_history = new Mem_history();
mem_history.SetTanker(this.turnInstance.Total_turn, mapinfo_id, num >= 1.0);
Comm_UserDatas.Instance.Add_History(mem_history);
}
}
list.Add(radingResultData);
}
}
return(list);
}
public bool MapReOpen(Mem_mapclear clearData, out List <int> reOpenMap)
{
reOpenMap = new List <int>();
if (clearData.State != 0)
{
return(false);
}
Dictionary <int, Mem_mapclear> dictionary = (from data in Comm_UserDatas.Instance.User_mapclear.Values
where data.State == MapClearState.InvationClose && data.Mapinfo_no == 1
select data).ToDictionary((Mem_mapclear key) => key.Rid, (Mem_mapclear value) => value);
if (dictionary.Count == 0)
{
return(true);
}
Dictionary <int, Mst_maparea> mst_maparea = Mst_DataManager.Instance.Mst_maparea;
int maparea_id = clearData.Maparea_id;
int num = Mst_maparea.MaxMapNum(Comm_UserDatas.Instance.User_basic.Difficult, clearData.Maparea_id);
bool flag = (clearData.Mapinfo_no == num) ? true : false;
new Dictionary <int, List <int> >();
Dictionary <int, List <int> > dictionary2 = new Dictionary <int, List <int> >();
foreach (Mem_mapclear value3 in dictionary.Values)
{
Mst_mapinfo mst_mapinfo = Mst_DataManager.Instance.Mst_mapinfo[value3.Rid];
if (mst_mapinfo.Required_ids.Contains(clearData.Rid))
{
dictionary2.Add(value3.Maparea_id, mst_mapinfo.Required_ids);
}
else if (flag && mst_maparea[value3.Maparea_id].Neighboring_area.Contains(maparea_id))
{
if (value3.Maparea_id == 7 || value3.Maparea_id == 8)
{
dictionary2.Add(value3.Maparea_id, new List <int>
{
Mst_mapinfo.ConvertMapInfoId(1, 4)
});
}
else
{
List <int> list = mst_mapinfo.Required_ids.ToList();
list.Add(clearData.Rid);
dictionary2.Add(value3.Maparea_id, list);
}
}
}
if (dictionary2.Count == 0)
{
return(true);
}
bool result = false;
foreach (KeyValuePair <int, List <int> > item in dictionary2)
{
int areaId = item.Key;
List <int> value2 = item.Value;
if (value2.Count == 0)
{
throw new Exception();
}
if (mapReOpenCheck(value2))
{
result = true;
IEnumerable <Mem_mapclear> enumerable = from x in Comm_UserDatas.Instance.User_mapclear.Values
where x.Maparea_id == areaId
select x;
foreach (Mem_mapclear item2 in enumerable)
{
item2.StateChange(MapClearState.InvationOpen);
reOpenMap.Add(item2.Rid);
}
}
}
return(result);
}
