public static void SetRadingPhase(int phase)
{
if (phase > 4 || phase < 1)
{
return;
}
List <Mst_radingtype> list = Mst_DataManager.Instance.Mst_RadingType.get_Item((int)Comm_UserDatas.Instance.User_basic.Difficult);
int turn_from;
if (phase == 3)
{
turn_from = list.get_Item(0).Turn_from;
}
else if (phase == 2)
{
turn_from = list.get_Item(1).Turn_from;
}
else
{
turn_from = list.get_Item(2).Turn_from;
}
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
user_turn.GetType().InvokeMember("_total_turn", 2084, null, user_turn, new object[]
{
turn_from - 1
});
user_turn.GetType().InvokeMember("_reqQuestReset", 2084, null, user_turn, new object[]
{
true
});
}
public Api_TurnOperator()
{
this.turnInstance = Comm_UserDatas.Instance.User_turn;
this.basicInstance = Comm_UserDatas.Instance.User_basic;
this.getInstance = new Api_get_Member();
this.randInstance = new Random();
}
public static void SetRadingPhase(int phase)
{
if (phase <= 4 && phase >= 1)
{
List <Mst_radingtype> list = Mst_DataManager.Instance.Mst_RadingType[(int)Comm_UserDatas.Instance.User_basic.Difficult];
int turn_from;
switch (phase)
{
case 3:
turn_from = list[0].Turn_from;
break;
case 2:
turn_from = list[1].Turn_from;
break;
default:
turn_from = list[2].Turn_from;
break;
}
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
user_turn.GetType().InvokeMember("_total_turn", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, user_turn, new object[1]
{
turn_from - 1
});
user_turn.GetType().InvokeMember("_reqQuestReset", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, user_turn, new object[1]
{
true
});
}
}
private bool setRankA(DifficultKind difficult, DateTime dt, int elapsedYear, uint lostNum, ref OverallRank outRank, ref int outDecNum, ref bool outPositive)
{
if (difficult > DifficultKind.KOU)
{
return(false);
}
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
outRank = OverallRank.A;
outPositive = true;
outDecNum = 0;
if (difficult == DifficultKind.KOU && lostNum <= 6)
{
DateTime dateTime = user_turn.GetDateTime(3, 8, 15);
outDecNum = 3;
if (dt.Date <= dateTime.Date)
{
return(true);
}
}
if (difficult <= DifficultKind.OTU)
{
outDecNum = 2;
if (difficult != DifficultKind.OTU)
{
if (elapsedYear <= 1 && lostNum == 0)
{
return(true);
}
}
else
{
DateTime dateTime2 = user_turn.GetDateTime(3, 8, 15);
if (lostNum <= 6 && dt.Date <= dateTime2.Date)
{
return(true);
}
}
}
if (difficult <= DifficultKind.HEI)
{
outDecNum = 1;
if (elapsedYear <= 2 && lostNum == 0)
{
return(true);
}
}
outDecNum = 0;
if (difficult <= DifficultKind.HEI)
{
DateTime dateTime3 = user_turn.GetDateTime(3, 8, 15);
if (dt.Date <= dateTime3.Date && lostNum == 0)
{
return(true);
}
}
return(false);
}
private bool setRankB(DifficultKind difficult, DateTime dt, int elapsedYear, uint lostNum, ref OverallRank outRank, ref int outDecNum, ref bool outPositive)
{
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
DateTime dateTime = user_turn.GetDateTime(3, 8, 15);
outDecNum = 0;
outPositive = true;
outRank = OverallRank.B;
if (dt.Date <= dateTime.Date)
{
outDecNum = 2;
if (difficult <= DifficultKind.HEI && lostNum <= 4)
{
return(true);
}
if (difficult == DifficultKind.SHI && lostNum <= 19)
{
return(true);
}
if ((difficult == DifficultKind.KOU || difficult == DifficultKind.OTU) && lostNum <= 9)
{
return(true);
}
}
outDecNum = 1;
if (dt.Date <= dateTime.Date)
{
if (difficult <= DifficultKind.HEI && lostNum <= 9)
{
return(true);
}
if ((difficult == DifficultKind.KOU || difficult == DifficultKind.OTU) && lostNum <= 14)
{
return(true);
}
}
if ((difficult == DifficultKind.KOU || difficult == DifficultKind.OTU) && lostNum <= 9)
{
return(true);
}
outDecNum = 0;
if (difficult <= DifficultKind.HEI && lostNum <= 9)
{
return(true);
}
if ((difficult == DifficultKind.KOU || difficult == DifficultKind.OTU) && dt.Date <= dateTime.Date && lostNum <= 19)
{
return(true);
}
if (difficult == DifficultKind.SHI && lostNum <= 19)
{
return(true);
}
return(false);
}
public bool CreateNewUser(ICreateNewUser createInstance, DifficultKind difficult, int firstShip)
{
if (User_basic != null || createInstance == null)
{
return(false);
}
User_basic = new Mem_basic();
User_basic.SetDifficult(difficult);
User_record = new Mem_record();
User_turn = new Mem_turn();
User_trophy = new Mem_trophy();
User_plus = new Mem_newgame_plus();
User_deckpractice = new Mem_deckpractice();
if (User_ndock.Count == 0)
{
Add_Ndock(1);
Add_Ndock(1);
}
if (User_kdock.Count == 0)
{
Add_Kdock();
Add_Kdock();
}
initMaterials(difficult);
Add_Deck(1);
List <int> list = Instance.Add_Ship(new List <int>
{
firstShip
});
Instance.User_deck[1].Ship[0] = list[0];
List <Mst_furniture> furnitureDatas = User_room[1].getFurnitureDatas();
Mem_furniture furniture = null;
furnitureDatas.ForEach(delegate(Mst_furniture x)
{
furniture = new Mem_furniture(x.Id);
User_furniture.Add(furniture.Rid, furniture);
});
Add_Slot(new List <int>
{
42,
43
});
User_quest = new Dictionary <int, Mem_quest>();
foreach (int key in Mst_DataManager.Instance.Mst_maparea.Keys)
{
Add_EscortDeck(key, key);
}
initTanker();
UpdateDeckShipLocale();
return(true);
}
public static void SetRebellionPhase(int phase)
{
if (phase != 0 && phase <= 6)
{
int turn_from = Mst_DataManager.Instance.Mst_RebellionPoint[phase].Turn_from;
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
user_turn.GetType().InvokeMember("_total_turn", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, user_turn, new object[1]
{
turn_from - 1
});
user_turn.GetType().InvokeMember("_reqQuestReset", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, user_turn, new object[1]
{
true
});
}
}
private bool setRankEx(DifficultKind difficult, DateTime dt, int elapsedYear, uint lostNum, ref OverallRank outRank, ref int outDecNum, ref bool outPositive)
{
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
outPositive = true;
outRank = OverallRank.EX;
outDecNum = 0;
if (difficult != DifficultKind.SHI)
{
return(false);
}
if (elapsedYear <= 1 && lostNum == 0)
{
outDecNum = 4;
return(true);
}
if (elapsedYear <= 2 && lostNum == 0)
{
outDecNum = 3;
return(true);
}
if (elapsedYear <= 3 && lostNum == 0)
{
outDecNum = 2;
DateTime dateTime = user_turn.GetDateTime(3, 8, 15);
if (dt.Date <= dateTime.Date)
{
return(true);
}
}
if (elapsedYear <= 2 && lostNum <= 3)
{
outDecNum = 1;
return(true);
}
if (elapsedYear <= 3 && lostNum <= 3)
{
outDecNum = 0;
DateTime dateTime2 = user_turn.GetDateTime(3, 8, 15);
if (dt.Date <= dateTime2.Date)
{
return(true);
}
}
return(false);
}
public static void SetRebellionPhase(int phase)
{
if (phase == 0 || phase > 6)
{
return;
}
int turn_from = Mst_DataManager.Instance.Mst_RebellionPoint.get_Item(phase).Turn_from;
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
user_turn.GetType().InvokeMember("_total_turn", 2084, null, user_turn, new object[]
{
turn_from - 1
});
user_turn.GetType().InvokeMember("_reqQuestReset", 2084, null, user_turn, new object[]
{
true
});
}
public bool SetUserData()
{
XElement elements = VitaSaveManager.Instance.Elements;
if (elements == null)
{
return(false);
}
Mem_basic user_basic = Model_Base.SetUserData <Mem_basic>(Enumerable.First <XElement>(elements.Elements(Mem_basic.tableName)));
Mem_record user_record = Model_Base.SetUserData <Mem_record>(Enumerable.First <XElement>(elements.Elements(Mem_record.tableName)));
Mem_turn user_turn = Model_Base.SetUserData <Mem_turn>(Enumerable.First <XElement>(elements.Elements(Mem_turn.tableName)));
Mem_deckpractice user_deckpractice = Model_Base.SetUserData <Mem_deckpractice>(Enumerable.First <XElement>(elements.Elements(Mem_deckpractice.tableName)));
XElement xElement = Enumerable.FirstOrDefault <XElement>(elements.Elements(Mem_trophy.tableName));
Mem_trophy user_trophy;
if (xElement == null)
{
user_trophy = new Mem_trophy();
}
else
{
user_trophy = Model_Base.SetUserData <Mem_trophy>(xElement);
}
XElement xElement2 = Enumerable.FirstOrDefault <XElement>(elements.Elements(Mem_newgame_plus.tableName));
Mem_newgame_plus user_plus;
if (xElement2 == null)
{
user_plus = new Mem_newgame_plus();
}
else
{
user_plus = Model_Base.SetUserData <Mem_newgame_plus>(xElement2);
}
this.User_basic = null;
this.User_basic = user_basic;
this.User_record = null;
this.User_record = user_record;
this.User_turn = null;
this.User_turn = user_turn;
this.User_deckpractice = null;
this.User_deckpractice = user_deckpractice;
this.User_trophy = user_trophy;
this.User_plus = user_plus;
Dictionary <int, Mem_book> dictionary = new Dictionary <int, Mem_book>();
Dictionary <int, Mem_book> dictionary2 = new Dictionary <int, Mem_book>();
Dictionary <int, Mem_deck> dictionary3 = new Dictionary <int, Mem_deck>();
Dictionary <int, Mem_esccort_deck> dictionary4 = new Dictionary <int, Mem_esccort_deck>();
Dictionary <int, Mem_furniture> dictionary5 = new Dictionary <int, Mem_furniture>();
Dictionary <int, Mem_kdock> dictionary6 = new Dictionary <int, Mem_kdock>();
Dictionary <int, Mem_mapcomp> dictionary7 = new Dictionary <int, Mem_mapcomp>();
Dictionary <int, Mem_mapclear> dictionary8 = new Dictionary <int, Mem_mapclear>();
Dictionary <enumMaterialCategory, Mem_material> dictionary9 = new Dictionary <enumMaterialCategory, Mem_material>();
Dictionary <int, Mem_missioncomp> dictionary10 = new Dictionary <int, Mem_missioncomp>();
Dictionary <int, Mem_ndock> dictionary11 = new Dictionary <int, Mem_ndock>();
Dictionary <int, Mem_quest> dictionary12 = new Dictionary <int, Mem_quest>();
Dictionary <int, Mem_questcount> dictionary13 = new Dictionary <int, Mem_questcount>();
Dictionary <int, Mem_ship> dictionary14 = new Dictionary <int, Mem_ship>();
Dictionary <int, Mem_slotitem> dictionary15 = new Dictionary <int, Mem_slotitem>();
Dictionary <int, Mem_tanker> dictionary16 = new Dictionary <int, Mem_tanker>();
Dictionary <int, Mem_useitem> dictionary17 = new Dictionary <int, Mem_useitem>();
Dictionary <int, Mem_rebellion_point> dictionary18 = new Dictionary <int, Mem_rebellion_point>();
Dictionary <int, Mem_room> dictionary19 = new Dictionary <int, Mem_room>();
HashSet <int> hashSet = new HashSet <int>();
HashSet <int> hashSet2 = new HashSet <int>();
List <Mem_history> list = new List <Mem_history>();
using (IEnumerator <XElement> enumerator = Extensions.Elements <XElement>(elements.Elements("ship_books"), "mem_book").GetEnumerator())
{
while (enumerator.MoveNext())
{
XElement current = enumerator.get_Current();
Mem_book mem_book = Model_Base.SetUserData <Mem_book>(current);
dictionary.Add(mem_book.Table_id, mem_book);
}
}
this.Ship_book.Clear();
this.Ship_book = dictionary;
using (IEnumerator <XElement> enumerator2 = Extensions.Elements <XElement>(elements.Elements("slot_books"), "mem_book").GetEnumerator())
{
while (enumerator2.MoveNext())
{
XElement current2 = enumerator2.get_Current();
Mem_book mem_book2 = Model_Base.SetUserData <Mem_book>(current2);
dictionary2.Add(mem_book2.Table_id, mem_book2);
}
}
this.Slot_book.Clear();
this.Slot_book = dictionary2;
using (IEnumerator <XElement> enumerator3 = Extensions.Elements <XElement>(elements.Elements(Mem_deck.tableName + "s"), Mem_deck.tableName).GetEnumerator())
{
while (enumerator3.MoveNext())
{
XElement current3 = enumerator3.get_Current();
Mem_deck mem_deck = Model_Base.SetUserData <Mem_deck>(current3);
dictionary3.Add(mem_deck.Rid, mem_deck);
}
}
this.User_deck.Clear();
this.User_deck = dictionary3;
using (IEnumerator <XElement> enumerator4 = Extensions.Elements <XElement>(elements.Elements(Mem_esccort_deck.tableName + "s"), Mem_esccort_deck.tableName).GetEnumerator())
{
while (enumerator4.MoveNext())
{
XElement current4 = enumerator4.get_Current();
Mem_esccort_deck mem_esccort_deck = Model_Base.SetUserData <Mem_esccort_deck>(current4);
dictionary4.Add(mem_esccort_deck.Rid, mem_esccort_deck);
}
}
this.User_EscortDeck.Clear();
this.User_EscortDeck = dictionary4;
using (IEnumerator <XElement> enumerator5 = Extensions.Elements <XElement>(elements.Elements(Mem_furniture.tableName + "s"), Mem_furniture.tableName).GetEnumerator())
{
while (enumerator5.MoveNext())
{
XElement current5 = enumerator5.get_Current();
Mem_furniture mem_furniture = Model_Base.SetUserData <Mem_furniture>(current5);
dictionary5.Add(mem_furniture.Rid, mem_furniture);
}
}
this.User_furniture.Clear();
this.User_furniture = dictionary5;
using (IEnumerator <XElement> enumerator6 = Extensions.Elements <XElement>(elements.Elements(Mem_kdock.tableName + "s"), Mem_kdock.tableName).GetEnumerator())
{
while (enumerator6.MoveNext())
{
XElement current6 = enumerator6.get_Current();
Mem_kdock mem_kdock = Model_Base.SetUserData <Mem_kdock>(current6);
dictionary6.Add(mem_kdock.Rid, mem_kdock);
}
}
this.User_kdock.Clear();
this.User_kdock = dictionary6;
using (IEnumerator <XElement> enumerator7 = Extensions.Elements <XElement>(elements.Elements(Mem_mapcomp.tableName + "s"), Mem_mapcomp.tableName).GetEnumerator())
{
while (enumerator7.MoveNext())
{
XElement current7 = enumerator7.get_Current();
Mem_mapcomp mem_mapcomp = Model_Base.SetUserData <Mem_mapcomp>(current7);
dictionary7.Add(mem_mapcomp.Rid, mem_mapcomp);
}
}
this.User_mapcomp.Clear();
this.User_mapcomp = dictionary7;
using (IEnumerator <XElement> enumerator8 = Extensions.Elements <XElement>(elements.Elements(Mem_mapclear.tableName + "s"), Mem_mapclear.tableName).GetEnumerator())
{
while (enumerator8.MoveNext())
{
XElement current8 = enumerator8.get_Current();
Mem_mapclear mem_mapclear = Model_Base.SetUserData <Mem_mapclear>(current8);
dictionary8.Add(mem_mapclear.Rid, mem_mapclear);
}
}
this.User_mapclear.Clear();
this.User_mapclear = dictionary8;
using (IEnumerator <XElement> enumerator9 = Extensions.Elements <XElement>(elements.Elements(Mem_material.tableName + "s"), Mem_material.tableName).GetEnumerator())
{
while (enumerator9.MoveNext())
{
XElement current9 = enumerator9.get_Current();
Mem_material mem_material = Model_Base.SetUserData <Mem_material>(current9);
dictionary9.Add(mem_material.Rid, mem_material);
}
}
this.User_material.Clear();
this.User_material = dictionary9;
using (IEnumerator <XElement> enumerator10 = Extensions.Elements <XElement>(elements.Elements(Mem_missioncomp.tableName + "s"), Mem_missioncomp.tableName).GetEnumerator())
{
while (enumerator10.MoveNext())
{
XElement current10 = enumerator10.get_Current();
Mem_missioncomp mem_missioncomp = Model_Base.SetUserData <Mem_missioncomp>(current10);
dictionary10.Add(mem_missioncomp.Rid, mem_missioncomp);
}
}
this.User_missioncomp.Clear();
this.User_missioncomp = dictionary10;
using (IEnumerator <XElement> enumerator11 = Extensions.Elements <XElement>(elements.Elements(Mem_ndock.tableName + "s"), Mem_ndock.tableName).GetEnumerator())
{
while (enumerator11.MoveNext())
{
XElement current11 = enumerator11.get_Current();
Mem_ndock mem_ndock = Model_Base.SetUserData <Mem_ndock>(current11);
dictionary11.Add(mem_ndock.Rid, mem_ndock);
}
}
this.User_ndock.Clear();
this.User_ndock = dictionary11;
using (IEnumerator <XElement> enumerator12 = Extensions.Elements <XElement>(elements.Elements(Mem_quest.tableName + "s"), Mem_quest.tableName).GetEnumerator())
{
while (enumerator12.MoveNext())
{
XElement current12 = enumerator12.get_Current();
Mem_quest mem_quest = Model_Base.SetUserData <Mem_quest>(current12);
dictionary12.Add(mem_quest.Rid, mem_quest);
}
}
this.User_quest.Clear();
this.User_quest = dictionary12;
using (IEnumerator <XElement> enumerator13 = Extensions.Elements <XElement>(elements.Elements(Mem_questcount.tableName + "s"), Mem_questcount.tableName).GetEnumerator())
{
while (enumerator13.MoveNext())
{
XElement current13 = enumerator13.get_Current();
Mem_questcount mem_questcount = Model_Base.SetUserData <Mem_questcount>(current13);
dictionary13.Add(mem_questcount.Rid, mem_questcount);
}
}
this.User_questcount.Clear();
this.User_questcount = dictionary13;
using (IEnumerator <XElement> enumerator14 = Extensions.Elements <XElement>(elements.Elements(Mem_slotitem.tableName + "s"), Mem_slotitem.tableName).GetEnumerator())
{
while (enumerator14.MoveNext())
{
XElement current14 = enumerator14.get_Current();
Mem_slotitem mem_slotitem = Model_Base.SetUserData <Mem_slotitem>(current14);
dictionary15.Add(mem_slotitem.Rid, mem_slotitem);
}
}
this.User_slot.Clear();
this.User_slot = dictionary15;
using (IEnumerator <XElement> enumerator15 = Extensions.Elements <XElement>(elements.Elements(Mem_ship.tableName + "s"), Mem_ship.tableName).GetEnumerator())
{
while (enumerator15.MoveNext())
{
XElement current15 = enumerator15.get_Current();
Mem_ship mem_ship = Model_Base.SetUserData <Mem_ship>(current15);
dictionary14.Add(mem_ship.Rid, mem_ship);
}
}
this.User_ship.Clear();
this.User_ship = dictionary14;
using (IEnumerator <XElement> enumerator16 = Extensions.Elements <XElement>(elements.Elements(Mem_tanker.tableName + "s"), Mem_tanker.tableName).GetEnumerator())
{
while (enumerator16.MoveNext())
{
XElement current16 = enumerator16.get_Current();
Mem_tanker mem_tanker = Model_Base.SetUserData <Mem_tanker>(current16);
dictionary16.Add(mem_tanker.Rid, mem_tanker);
}
}
this.User_tanker.Clear();
this.User_tanker = dictionary16;
using (IEnumerator <XElement> enumerator17 = Extensions.Elements <XElement>(elements.Elements(Mem_useitem.tableName + "s"), Mem_useitem.tableName).GetEnumerator())
{
while (enumerator17.MoveNext())
{
XElement current17 = enumerator17.get_Current();
Mem_useitem mem_useitem = Model_Base.SetUserData <Mem_useitem>(current17);
dictionary17.Add(mem_useitem.Rid, mem_useitem);
}
}
this.User_useItem.Clear();
this.User_useItem = dictionary17;
using (IEnumerator <XElement> enumerator18 = Extensions.Elements <XElement>(elements.Elements(Mem_rebellion_point.tableName + "s"), Mem_rebellion_point.tableName).GetEnumerator())
{
while (enumerator18.MoveNext())
{
XElement current18 = enumerator18.get_Current();
Mem_rebellion_point mem_rebellion_point = Model_Base.SetUserData <Mem_rebellion_point>(current18);
dictionary18.Add(mem_rebellion_point.Rid, mem_rebellion_point);
}
}
this.User_rebellion_point.Clear();
this.User_rebellion_point = dictionary18;
using (IEnumerator <XElement> enumerator19 = Extensions.Elements <XElement>(elements.Elements(Mem_room.tableName + "s"), Mem_room.tableName).GetEnumerator())
{
while (enumerator19.MoveNext())
{
XElement current19 = enumerator19.get_Current();
Mem_room mem_room = Model_Base.SetUserData <Mem_room>(current19);
dictionary19.Add(mem_room.Rid, mem_room);
}
}
this.User_room.Clear();
this.User_room = dictionary19;
using (IEnumerator <XElement> enumerator20 = elements.Element("temp_escortships").Elements().GetEnumerator())
{
while (enumerator20.MoveNext())
{
XElement current20 = enumerator20.get_Current();
string value = current20.get_Value();
hashSet.Add(int.Parse(value));
}
}
this.Temp_escortship.Clear();
this.Temp_escortship = hashSet;
using (IEnumerator <XElement> enumerator21 = elements.Element("temp_deckships").Elements().GetEnumerator())
{
while (enumerator21.MoveNext())
{
XElement current21 = enumerator21.get_Current();
string value2 = current21.get_Value();
hashSet2.Add(int.Parse(value2));
}
}
this.Temp_deckship.Clear();
this.Temp_deckship = hashSet2;
using (IEnumerator <XElement> enumerator22 = Extensions.Elements <XElement>(elements.Elements(Mem_history.tableName + "s"), Mem_history.tableName).GetEnumerator())
{
while (enumerator22.MoveNext())
{
XElement current22 = enumerator22.get_Current();
Mem_history mem_history = Model_Base.SetUserData <Mem_history>(current22);
list.Add(mem_history);
}
}
this.User_history.Clear();
list.ForEach(delegate(Mem_history x)
{
this.Add_History(x);
});
return(true);
}
public bool NewGamePlus(ICreateNewUser createInstance, string nickName, DifficultKind selectedRank, int firstShipId)
{
if (createInstance == null)
{
return(false);
}
bool flag = Utils.IsGameClear();
List <DifficultKind> kind = User_record.ClearDifficult.ToList();
PurgeUserData(createInstance, plusGame: true);
if (flag)
{
Add_Useitem(55, 1);
}
foreach (Mem_book item in User_plus.Ship_book)
{
Ship_book.Add(item.Table_id, item);
}
foreach (Mem_book item2 in User_plus.Slot_book)
{
Slot_book.Add(item2.Table_id, item2);
}
User_basic = new Mem_basic();
User_basic.UpdateNickName(nickName);
User_basic.SetDifficult(selectedRank);
User_record = new Mem_record(createInstance, User_plus, kind);
User_turn = new Mem_turn();
User_deckpractice = new Mem_deckpractice();
if (User_ndock.Count == 0)
{
Add_Ndock(1);
Add_Ndock(1);
}
if (User_kdock.Count == 0)
{
Add_Kdock();
Add_Kdock();
}
initMaterials(selectedRank);
Add_Deck(1);
User_room[1].getFurnitureDatas();
foreach (Mem_furniture item3 in User_plus.Furniture)
{
User_furniture.Add(item3.Rid, item3);
}
foreach (Mem_slotitem item4 in User_plus.Slotitem)
{
User_slot.Add(item4.Rid, item4);
}
foreach (Mem_shipBase item5 in User_plus.Ship)
{
Mem_ship mem_ship = new Mem_ship();
Mst_ship mst_data = Mst_DataManager.Instance.Mst_ship[item5.Ship_id];
mem_ship.Set_ShipParam(item5, mst_data, enemy_flag: false);
mem_ship.Set_ShipParamNewGamePlus(createInstance);
User_ship.Add(mem_ship.Rid, mem_ship);
}
List <int> list = Add_Ship(new List <int>
{
firstShipId
});
Instance.User_deck[1].Ship[0] = list[0];
User_quest = new Dictionary <int, Mem_quest>();
foreach (int key in Mst_DataManager.Instance.Mst_maparea.Keys)
{
Add_EscortDeck(key, key);
}
initTanker();
UpdateDeckShipLocale();
return(true);
}
public bool SetUserData()
{
XElement elements = VitaSaveManager.Instance.Elements;
if (elements == null)
{
return(false);
}
Mem_basic user_basic = Model_Base.SetUserData <Mem_basic>(elements.Elements(Mem_basic.tableName).First());
Mem_record user_record = Model_Base.SetUserData <Mem_record>(elements.Elements(Mem_record.tableName).First());
Mem_turn user_turn = Model_Base.SetUserData <Mem_turn>(elements.Elements(Mem_turn.tableName).First());
Mem_deckpractice user_deckpractice = Model_Base.SetUserData <Mem_deckpractice>(elements.Elements(Mem_deckpractice.tableName).First());
XElement xElement = elements.Elements(Mem_trophy.tableName).FirstOrDefault();
Mem_trophy user_trophy = (xElement != null) ? Model_Base.SetUserData <Mem_trophy>(xElement) : new Mem_trophy();
XElement xElement2 = elements.Elements(Mem_newgame_plus.tableName).FirstOrDefault();
Mem_newgame_plus user_plus = (xElement2 != null) ? Model_Base.SetUserData <Mem_newgame_plus>(xElement2) : new Mem_newgame_plus();
User_basic = null;
User_basic = user_basic;
User_record = null;
User_record = user_record;
User_turn = null;
User_turn = user_turn;
User_deckpractice = null;
User_deckpractice = user_deckpractice;
User_trophy = user_trophy;
User_plus = user_plus;
Dictionary <int, Mem_book> dictionary = new Dictionary <int, Mem_book>();
Dictionary <int, Mem_book> dictionary2 = new Dictionary <int, Mem_book>();
Dictionary <int, Mem_deck> dictionary3 = new Dictionary <int, Mem_deck>();
Dictionary <int, Mem_esccort_deck> dictionary4 = new Dictionary <int, Mem_esccort_deck>();
Dictionary <int, Mem_furniture> dictionary5 = new Dictionary <int, Mem_furniture>();
Dictionary <int, Mem_kdock> dictionary6 = new Dictionary <int, Mem_kdock>();
Dictionary <int, Mem_mapcomp> dictionary7 = new Dictionary <int, Mem_mapcomp>();
Dictionary <int, Mem_mapclear> dictionary8 = new Dictionary <int, Mem_mapclear>();
Dictionary <enumMaterialCategory, Mem_material> dictionary9 = new Dictionary <enumMaterialCategory, Mem_material>();
Dictionary <int, Mem_missioncomp> dictionary10 = new Dictionary <int, Mem_missioncomp>();
Dictionary <int, Mem_ndock> dictionary11 = new Dictionary <int, Mem_ndock>();
Dictionary <int, Mem_quest> dictionary12 = new Dictionary <int, Mem_quest>();
Dictionary <int, Mem_questcount> dictionary13 = new Dictionary <int, Mem_questcount>();
Dictionary <int, Mem_ship> dictionary14 = new Dictionary <int, Mem_ship>();
Dictionary <int, Mem_slotitem> dictionary15 = new Dictionary <int, Mem_slotitem>();
Dictionary <int, Mem_tanker> dictionary16 = new Dictionary <int, Mem_tanker>();
Dictionary <int, Mem_useitem> dictionary17 = new Dictionary <int, Mem_useitem>();
Dictionary <int, Mem_rebellion_point> dictionary18 = new Dictionary <int, Mem_rebellion_point>();
Dictionary <int, Mem_room> dictionary19 = new Dictionary <int, Mem_room>();
HashSet <int> hashSet = new HashSet <int>();
HashSet <int> hashSet2 = new HashSet <int>();
List <Mem_history> list = new List <Mem_history>();
foreach (XElement item2 in elements.Elements("ship_books").Elements("mem_book"))
{
Mem_book mem_book = Model_Base.SetUserData <Mem_book>(item2);
dictionary.Add(mem_book.Table_id, mem_book);
}
Ship_book.Clear();
Ship_book = dictionary;
foreach (XElement item3 in elements.Elements("slot_books").Elements("mem_book"))
{
Mem_book mem_book2 = Model_Base.SetUserData <Mem_book>(item3);
dictionary2.Add(mem_book2.Table_id, mem_book2);
}
Slot_book.Clear();
Slot_book = dictionary2;
foreach (XElement item4 in elements.Elements(Mem_deck.tableName + "s").Elements(Mem_deck.tableName))
{
Mem_deck mem_deck = Model_Base.SetUserData <Mem_deck>(item4);
dictionary3.Add(mem_deck.Rid, mem_deck);
}
User_deck.Clear();
User_deck = dictionary3;
foreach (XElement item5 in elements.Elements(Mem_esccort_deck.tableName + "s").Elements(Mem_esccort_deck.tableName))
{
Mem_esccort_deck mem_esccort_deck = Model_Base.SetUserData <Mem_esccort_deck>(item5);
dictionary4.Add(mem_esccort_deck.Rid, mem_esccort_deck);
}
User_EscortDeck.Clear();
User_EscortDeck = dictionary4;
foreach (XElement item6 in elements.Elements(Mem_furniture.tableName + "s").Elements(Mem_furniture.tableName))
{
Mem_furniture mem_furniture = Model_Base.SetUserData <Mem_furniture>(item6);
dictionary5.Add(mem_furniture.Rid, mem_furniture);
}
User_furniture.Clear();
User_furniture = dictionary5;
foreach (XElement item7 in elements.Elements(Mem_kdock.tableName + "s").Elements(Mem_kdock.tableName))
{
Mem_kdock mem_kdock = Model_Base.SetUserData <Mem_kdock>(item7);
dictionary6.Add(mem_kdock.Rid, mem_kdock);
}
User_kdock.Clear();
User_kdock = dictionary6;
foreach (XElement item8 in elements.Elements(Mem_mapcomp.tableName + "s").Elements(Mem_mapcomp.tableName))
{
Mem_mapcomp mem_mapcomp = Model_Base.SetUserData <Mem_mapcomp>(item8);
dictionary7.Add(mem_mapcomp.Rid, mem_mapcomp);
}
User_mapcomp.Clear();
User_mapcomp = dictionary7;
foreach (XElement item9 in elements.Elements(Mem_mapclear.tableName + "s").Elements(Mem_mapclear.tableName))
{
Mem_mapclear mem_mapclear = Model_Base.SetUserData <Mem_mapclear>(item9);
dictionary8.Add(mem_mapclear.Rid, mem_mapclear);
}
User_mapclear.Clear();
User_mapclear = dictionary8;
foreach (XElement item10 in elements.Elements(Mem_material.tableName + "s").Elements(Mem_material.tableName))
{
Mem_material mem_material = Model_Base.SetUserData <Mem_material>(item10);
dictionary9.Add(mem_material.Rid, mem_material);
}
User_material.Clear();
User_material = dictionary9;
foreach (XElement item11 in elements.Elements(Mem_missioncomp.tableName + "s").Elements(Mem_missioncomp.tableName))
{
Mem_missioncomp mem_missioncomp = Model_Base.SetUserData <Mem_missioncomp>(item11);
dictionary10.Add(mem_missioncomp.Rid, mem_missioncomp);
}
User_missioncomp.Clear();
User_missioncomp = dictionary10;
foreach (XElement item12 in elements.Elements(Mem_ndock.tableName + "s").Elements(Mem_ndock.tableName))
{
Mem_ndock mem_ndock = Model_Base.SetUserData <Mem_ndock>(item12);
dictionary11.Add(mem_ndock.Rid, mem_ndock);
}
User_ndock.Clear();
User_ndock = dictionary11;
foreach (XElement item13 in elements.Elements(Mem_quest.tableName + "s").Elements(Mem_quest.tableName))
{
Mem_quest mem_quest = Model_Base.SetUserData <Mem_quest>(item13);
dictionary12.Add(mem_quest.Rid, mem_quest);
}
User_quest.Clear();
User_quest = dictionary12;
foreach (XElement item14 in elements.Elements(Mem_questcount.tableName + "s").Elements(Mem_questcount.tableName))
{
Mem_questcount mem_questcount = Model_Base.SetUserData <Mem_questcount>(item14);
dictionary13.Add(mem_questcount.Rid, mem_questcount);
}
User_questcount.Clear();
User_questcount = dictionary13;
foreach (XElement item15 in elements.Elements(Mem_slotitem.tableName + "s").Elements(Mem_slotitem.tableName))
{
Mem_slotitem mem_slotitem = Model_Base.SetUserData <Mem_slotitem>(item15);
dictionary15.Add(mem_slotitem.Rid, mem_slotitem);
}
User_slot.Clear();
User_slot = dictionary15;
foreach (XElement item16 in elements.Elements(Mem_ship.tableName + "s").Elements(Mem_ship.tableName))
{
Mem_ship mem_ship = Model_Base.SetUserData <Mem_ship>(item16);
dictionary14.Add(mem_ship.Rid, mem_ship);
}
User_ship.Clear();
User_ship = dictionary14;
foreach (XElement item17 in elements.Elements(Mem_tanker.tableName + "s").Elements(Mem_tanker.tableName))
{
Mem_tanker mem_tanker = Model_Base.SetUserData <Mem_tanker>(item17);
dictionary16.Add(mem_tanker.Rid, mem_tanker);
}
User_tanker.Clear();
User_tanker = dictionary16;
foreach (XElement item18 in elements.Elements(Mem_useitem.tableName + "s").Elements(Mem_useitem.tableName))
{
Mem_useitem mem_useitem = Model_Base.SetUserData <Mem_useitem>(item18);
dictionary17.Add(mem_useitem.Rid, mem_useitem);
}
User_useItem.Clear();
User_useItem = dictionary17;
foreach (XElement item19 in elements.Elements(Mem_rebellion_point.tableName + "s").Elements(Mem_rebellion_point.tableName))
{
Mem_rebellion_point mem_rebellion_point = Model_Base.SetUserData <Mem_rebellion_point>(item19);
dictionary18.Add(mem_rebellion_point.Rid, mem_rebellion_point);
}
User_rebellion_point.Clear();
User_rebellion_point = dictionary18;
foreach (XElement item20 in elements.Elements(Mem_room.tableName + "s").Elements(Mem_room.tableName))
{
Mem_room mem_room = Model_Base.SetUserData <Mem_room>(item20);
dictionary19.Add(mem_room.Rid, mem_room);
}
User_room.Clear();
User_room = dictionary19;
foreach (XElement item21 in elements.Element("temp_escortships").Elements())
{
string value = item21.Value;
hashSet.Add(int.Parse(value));
}
Temp_escortship.Clear();
Temp_escortship = hashSet;
foreach (XElement item22 in elements.Element("temp_deckships").Elements())
{
string value2 = item22.Value;
hashSet2.Add(int.Parse(value2));
}
Temp_deckship.Clear();
Temp_deckship = hashSet2;
foreach (XElement item23 in elements.Elements(Mem_history.tableName + "s").Elements(Mem_history.tableName))
{
Mem_history item = Model_Base.SetUserData <Mem_history>(item23);
list.Add(item);
}
User_history.Clear();
list.ForEach(delegate(Mem_history x)
{
Add_History(x);
});
return(true);
}
private void getRewardShip(BattleWinRankKinds rank, out ItemGetFmt out_items)
{
out_items = null;
if (rank < BattleWinRankKinds.B || Comm_UserDatas.Instance.User_basic.IsMaxChara() || Comm_UserDatas.Instance.User_basic.IsMaxSlotitem())
{
return;
}
int enemy_type = 0;
if (mst_enemy.Boss == 0)
{
enemy_type = 1;
Dictionary <BattleWinRankKinds, int> dictionary = new Dictionary <BattleWinRankKinds, int>();
dictionary.Add(BattleWinRankKinds.S, 30);
dictionary.Add(BattleWinRankKinds.A, 40);
dictionary.Add(BattleWinRankKinds.B, 30);
Dictionary <BattleWinRankKinds, int> dictionary2 = dictionary;
if (randInstance.Next(100) < dictionary2[rank])
{
return;
}
}
else
{
enemy_type = 2;
}
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
Dictionary <BattleWinRankKinds, int[]> dictionary4;
switch (difficult)
{
case DifficultKind.KOU:
case DifficultKind.SHI:
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
50
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
20,
70
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
100
});
dictionary4 = dictionary3;
break;
}
case DifficultKind.OTU:
if (user_turn.Total_turn >= 0 && user_turn.Total_turn <= 50)
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
45
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
15,
60
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
95
});
dictionary4 = dictionary3;
}
else if (user_turn.Total_turn >= 51 && user_turn.Total_turn <= 100)
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
50
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
15,
65
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
100
});
dictionary4 = dictionary3;
}
else
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
50
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
20,
70
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
100
});
dictionary4 = dictionary3;
}
break;
case DifficultKind.HEI:
if (user_turn.Total_turn >= 0 && user_turn.Total_turn <= 50)
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
40
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
15,
55
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
90
});
dictionary4 = dictionary3;
}
else if (user_turn.Total_turn >= 51 && user_turn.Total_turn <= 100)
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
45
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
15,
60
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
95
});
dictionary4 = dictionary3;
}
else
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
45
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
20,
65
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
95
});
dictionary4 = dictionary3;
}
break;
default:
if (user_turn.Total_turn >= 0 && user_turn.Total_turn <= 100)
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
35
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
15,
50
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
85
});
dictionary4 = dictionary3;
}
else if (user_turn.Total_turn >= 101 && user_turn.Total_turn <= 200)
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
40
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
15,
55
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
90
});
dictionary4 = dictionary3;
}
else
{
Dictionary <BattleWinRankKinds, int[]> dictionary3 = new Dictionary <BattleWinRankKinds, int[]>();
dictionary3.Add(BattleWinRankKinds.S, new int[2]
{
0,
45
});
dictionary3.Add(BattleWinRankKinds.A, new int[2]
{
15,
60
});
dictionary3.Add(BattleWinRankKinds.B, new int[2]
{
50,
95
});
dictionary4 = dictionary3;
}
break;
}
int num = randInstance.Next(dictionary4[rank][0], dictionary4[rank][1]) + mst_enemy.Geth;
if (num > dictionary4[rank][1])
{
num = dictionary4[rank][1] - 1;
}
XElement[] array = (from data in Mst_DataManager.Instance.Mst_shipget
where int.Parse(data.Element("Type").Value) == enemy_type
orderby int.Parse(data.Element("Id").Value)
select data).Skip(num).Take(1).ToArray();
if (array != null && array.Length != 0)
{
Mst_shipget2 instance = null;
Model_Base.SetMaster(out instance, array[0]);
if (instance.Ship_id > 0)
{
out_items = new ItemGetFmt();
out_items.Category = ItemGetKinds.Ship;
out_items.Count = 1;
out_items.Id = instance.Ship_id;
}
}
}
private bool setRankS(DifficultKind difficult, DateTime dt, int elapsedYear, uint lostNum, ref OverallRank outRank, ref int outDecNum, ref bool outPositive)
{
if (difficult < DifficultKind.OTU)
{
return(false);
}
Mem_turn user_turn = Comm_UserDatas.Instance.User_turn;
outPositive = true;
outRank = OverallRank.S;
outDecNum = 0;
if (elapsedYear <= 1 && lostNum == 0u)
{
outDecNum = 3;
return(true);
}
if (difficult >= DifficultKind.OTU)
{
outDecNum = 2;
if (difficult == DifficultKind.SHI)
{
if (lostNum <= 6u)
{
return(true);
}
}
else if (elapsedYear <= 2 && lostNum == 0u)
{
return(true);
}
}
if (difficult >= DifficultKind.OTU)
{
outDecNum = 1;
if (difficult == DifficultKind.SHI)
{
if (lostNum <= 9u)
{
return(true);
}
}
else if (elapsedYear <= 3)
{
DateTime dateTime = user_turn.GetDateTime(3, 8, 15);
if (dt.get_Date() <= dateTime.get_Date() && lostNum == 0u)
{
return(true);
}
}
}
if (difficult >= DifficultKind.OTU)
{
outDecNum = 0;
if (difficult == DifficultKind.SHI)
{
if (lostNum >= 10u && lostNum <= 19u)
{
return(true);
}
}
else
{
DateTime dateTime2 = user_turn.GetDateTime(3, 8, 15);
if (dt.get_Date() <= dateTime2.get_Date() && lostNum <= 3u)
{
return(true);
}
}
}
return(false);
}
