protected override void setProperty(XElement element)
{
Level = int.Parse(element.Element("_level").Value);
Exp = uint.Parse(element.Element("_exp").Value);
St_win = uint.Parse(element.Element("_st_win").Value);
St_lose = uint.Parse(element.Element("_st_lose").Value);
Pt_win = uint.Parse(element.Element("_pt_win").Value);
Pt_lose = uint.Parse(element.Element("_pt_lose").Value);
Rate = double.Parse(element.Element("_rate").Value);
foreach (XElement item2 in element.Element("_clearDifficult").Elements())
{
DifficultKind item = (DifficultKind)(int)Enum.Parse(typeof(DifficultKind), item2.Value);
ClearDifficult.Add(item);
}
if (element.Element("_rebellion_win") != null)
{
Rebellion_win = uint.Parse(element.Element("_rebellion_win").Value);
}
if (element.Element("_deck_practice_num") != null)
{
Deck_practice_num = uint.Parse(element.Element("_deck_practice_num").Value);
}
if (element.Element("_lostShipNum") != null)
{
LostShipNum = uint.Parse(element.Element("_lostShipNum").Value);
}
}
protected override void setProperty(XElement element)
{
this.Level = int.Parse(element.Element("_level").get_Value());
this.Exp = uint.Parse(element.Element("_exp").get_Value());
this.St_win = uint.Parse(element.Element("_st_win").get_Value());
this.St_lose = uint.Parse(element.Element("_st_lose").get_Value());
this.Pt_win = uint.Parse(element.Element("_pt_win").get_Value());
this.Pt_lose = uint.Parse(element.Element("_pt_lose").get_Value());
this.Rate = double.Parse(element.Element("_rate").get_Value());
using (IEnumerator <XElement> enumerator = element.Element("_clearDifficult").Elements().GetEnumerator())
{
while (enumerator.MoveNext())
{
XElement current = enumerator.get_Current();
DifficultKind difficultKind = (DifficultKind)((int)Enum.Parse(typeof(DifficultKind), current.get_Value()));
this.ClearDifficult.Add(difficultKind);
}
}
if (element.Element("_rebellion_win") != null)
{
this.Rebellion_win = uint.Parse(element.Element("_rebellion_win").get_Value());
}
if (element.Element("_deck_practice_num") != null)
{
this.Deck_practice_num = uint.Parse(element.Element("_deck_practice_num").get_Value());
}
if (element.Element("_lostShipNum") != null)
{
this.LostShipNum = uint.Parse(element.Element("_lostShipNum").get_Value());
}
}
public static int GetRadingStartTurn()
{
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
Mst_radingtype mst_radingtype = Mst_DataManager.Instance.Mst_RadingType[(int)difficult].Last();
return(mst_radingtype.Turn_to);
}
private bool setRankF(DifficultKind difficult, DateTime dt, int elapsedYear, uint lostNum, ref OverallRank outRank, ref int outDecNum, ref bool outPositive)
{
outRank = OverallRank.F;
outDecNum = 0;
outPositive = true;
return(lostNum >= 40u);
}
public StartupData()
{
_strAdmiralName = string.Empty;
_nPartnerShipID = -1;
_iDifficultKind = DifficultKind.OTU;
_isInherit = false;
}
public static AudioSource PlayDifficultyVoice(DifficultKind iKind, bool isDecide, Action onFinished)
{
if (SingletonMonoBehaviour <SoundManager> .Instance == null || SingletonMonoBehaviour <ResourceManager> .Instance == null)
{
return(null);
}
int voiceNum = 0;
switch (iKind)
{
case DifficultKind.TEI:
voiceNum = ((!isDecide) ? 10 : 11);
break;
case DifficultKind.HEI:
voiceNum = ((!isDecide) ? 20 : 21);
break;
case DifficultKind.OTU:
voiceNum = ((!isDecide) ? 30 : 31);
break;
case DifficultKind.KOU:
voiceNum = ((!isDecide) ? 40 : 41);
break;
case DifficultKind.SHI:
voiceNum = ((!isDecide) ? 50 : 51);
break;
}
return(SingletonMonoBehaviour <SoundManager> .Instance.PlayVoice(SingletonMonoBehaviour <ResourceManager> .Instance.ShipVoice.Load(9997, voiceNum), onFinished));
}
public void SetData(List<Mem_shipBase> shipBase, List<Mem_slotitem> slotItems)
{
this.FleetLevel = Comm_UserDatas.Instance.User_record.Level;
this.FleetExp = Comm_UserDatas.Instance.User_record.Exp;
shipBase.Sort((Mem_shipBase x, Mem_shipBase y) => x.GetNo.CompareTo(y.GetNo));
slotItems.Sort((Mem_slotitem x, Mem_slotitem y) => x.GetNo.CompareTo(y.GetNo));
for (int i = 0; i < shipBase.get_Count(); i++)
{
shipBase.get_Item(i).GetNo = i + 1;
}
for (int j = 0; j < slotItems.get_Count(); j++)
{
slotItems.get_Item(j).ChangeSortNo(j + 1);
}
this.Ship.Clear();
this.Ship = shipBase;
this.Slotitem.Clear();
this.Slotitem = slotItems;
this.Furniture.Clear();
this.Furniture.AddRange(Comm_UserDatas.Instance.User_furniture.get_Values());
this.Ship_book.Clear();
this.Ship_book.AddRange(Comm_UserDatas.Instance.Ship_book.get_Values());
this.Slot_book.Clear();
this.Slot_book.AddRange(Comm_UserDatas.Instance.Slot_book.get_Values());
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
DifficultKind kind;
DifficultKind expr_163 = kind = difficult;
int num = this[kind];
this[expr_163] = num + 1;
if (this[difficult] > 999)
{
this[difficult] = 999;
}
}
private void getClearShip(DifficultKind kind, BattleWinRankKinds rank, out ItemGetFmt out_items)
{
out_items = null;
if (Utils.IsBattleWin(rank))
{
List <int> clearRewardShipList = ArrayMaster.GetClearRewardShipList(kind);
Dictionary <int, Mst_ship> mst_ship = Mst_DataManager.Instance.Mst_ship;
int num = 0;
foreach (int item in clearRewardShipList)
{
string targetYomi = mst_ship[item].Yomi;
if (!Comm_UserDatas.Instance.User_ship.Values.Any(delegate(Mem_ship x)
{
int ship_id = x.Ship_id;
string yomi = mst_ship[ship_id].Yomi;
return(yomi.Equals(targetYomi));
}))
{
num = item;
break;
}
}
if (num != 0)
{
out_items = new ItemGetFmt();
out_items.Category = ItemGetKinds.Ship;
out_items.Count = 1;
out_items.Id = num;
}
}
}
public static int GetRadingStartTurn()
{
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
Mst_radingtype mst_radingtype = Enumerable.Last <Mst_radingtype>(Mst_DataManager.Instance.Mst_RadingType.get_Item((int)difficult));
return(mst_radingtype.Turn_to);
}
public bool IsOpenMapSys()
{
Mst_maparea value = null;
if (!Mst_DataManager.Instance.Mst_maparea.TryGetValue(Maparea_id, out value))
{
return(false);
}
if (!value.IsOpenArea())
{
return(false);
}
if (Required_ids.Count > 0 && Required_ids[0] == 999)
{
return(false);
}
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
int num = Mst_maparea.MaxMapNum(difficult, Maparea_id);
if (No < 5 && No > num)
{
return(false);
}
return(true);
}
public void AddClearDifficult(DifficultKind difficult)
{
if (!ClearDifficult.Contains(difficult))
{
ClearDifficult.Add(difficult);
}
}
public bool GetOverallRank(out OverallRank clearRank, out int decorationNum)
{
clearRank = OverallRank.F;
decorationNum = 0;
List <getRankDlgt> list = new List <getRankDlgt>();
list.Add(this.setRankEx);
list.Add(this.setRankS);
list.Add(this.setRankA);
list.Add(this.setRankB);
list.Add(this.setRankC);
list.Add(this.setRankD);
list.Add(this.setRankD);
list.Add(this.setRankE);
list.Add(this.setRankF);
List <getRankDlgt> list2 = list;
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
DateTime dateTime = Comm_UserDatas.Instance.User_turn.GetDateTime();
int elapsedYear = Comm_UserDatas.Instance.User_turn.GetElapsedYear(dateTime);
uint lostShipNum = Comm_UserDatas.Instance.User_record.LostShipNum;
bool outPositive = true;
foreach (getRankDlgt item in list2)
{
if (item(difficult, dateTime, elapsedYear, lostShipNum, ref clearRank, ref decorationNum, ref outPositive))
{
return(outPositive);
}
}
clearRank = OverallRank.F;
return(outPositive);
}
public static double GetDifficultyCoefficient(DifficultKind difficulty)
{
if (_DIFFICULTY_COEFFICIENT == null)
{
_CreateDifficultyCoefficient();
}
return(_DIFFICULTY_COEFFICIENT[difficulty]);
}
public bool CreateNewUser(DifficultKind difficult, int firstShip)
{
if (!create_flag)
{
return(false);
}
return(Comm_UserDatas.Instance.CreateNewUser(this, difficult, firstShip));
}
public void AddClearDifficult(DifficultKind difficult)
{
if (this.ClearDifficult.Contains(difficult))
{
return;
}
this.ClearDifficult.Add(difficult);
}
public static double GetDifficultyCoefficient(DifficultKind difficulty)
{
if (SearchValueUtil._DIFFICULTY_COEFFICIENT == null)
{
SearchValueUtil._CreateDifficultyCoefficient();
}
return(SearchValueUtil._DIFFICULTY_COEFFICIENT.get_Item(difficulty));
}
private Api_Result <bool> SetDifficult(DifficultKind difficult)
{
Api_Result <bool> api_Result = new Api_Result <bool>();
Comm_UserDatas.Instance.User_basic.SetDifficult(difficult);
api_Result.data = true;
return(api_Result);
}
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);
}
public bool CreateNewUser(ICreateNewUser createInstance, DifficultKind difficult, int firstShip)
{
if (this.User_basic != null || createInstance == null)
{
return(false);
}
this.User_basic = new Mem_basic();
this.User_basic.SetDifficult(difficult);
this.User_record = new Mem_record();
this.User_turn = new Mem_turn();
this.User_trophy = new Mem_trophy();
this.User_plus = new Mem_newgame_plus();
this.User_deckpractice = new Mem_deckpractice();
if (this.User_ndock.get_Count() == 0)
{
this.Add_Ndock(1);
this.Add_Ndock(1);
}
if (this.User_kdock.get_Count() == 0)
{
this.Add_Kdock();
this.Add_Kdock();
}
this.initMaterials(difficult);
this.Add_Deck(1);
Comm_UserDatas arg_D2_0 = Comm_UserDatas.Instance;
List <int> list = new List <int>();
list.Add(firstShip);
List <int> list2 = arg_D2_0.Add_Ship(list);
Comm_UserDatas.Instance.User_deck.get_Item(1).Ship[0] = list2.get_Item(0);
List <Mst_furniture> furnitureDatas = this.User_room.get_Item(1).getFurnitureDatas();
Mem_furniture furniture = null;
furnitureDatas.ForEach(delegate(Mst_furniture x)
{
furniture = new Mem_furniture(x.Id);
this.User_furniture.Add(furniture.Rid, furniture);
});
list = new List <int>();
list.Add(42);
list.Add(43);
this.Add_Slot(list);
this.User_quest = new Dictionary <int, Mem_quest>();
using (Dictionary <int, Mst_maparea> .KeyCollection.Enumerator enumerator = Mst_DataManager.Instance.Mst_maparea.get_Keys().GetEnumerator())
{
while (enumerator.MoveNext())
{
int current = enumerator.get_Current();
this.Add_EscortDeck(current, current);
}
}
this.initTanker();
this.UpdateDeckShipLocale();
return(true);
}
public static double GetDifficultyCorrectionValue(DifficultKind difficulty, MapBranchResult.enumScoutingKind type)
{
if (type == MapBranchResult.enumScoutingKind.K2)
{
double difficultyCoefficient = GetDifficultyCoefficient(difficulty);
return(0.0 - difficultyCoefficient * 2.0);
}
return(0.0);
}
private bool specialToriggerCheck(Mst_quest mst_record)
{
if (mst_record.Id == 423)
{
DifficultKind difficult = Comm_UserDatas.Instance.User_basic.Difficult;
return((difficult == DifficultKind.KOU || difficult == DifficultKind.SHI) && this.isRequireShipLimit(mst_record.Get_1_id, 1));
}
return(true);
}
public static List <int> GetClearRewardShipList(DifficultKind kind)
{
List <int> result = null;
if (kind == DifficultKind.SHI)
{
List <int> list = new List <int>();
list.Add(463);
list.Add(131);
list.Add(153);
list.Add(143);
list.Add(176);
list.Add(445);
list.Add(432);
list.Add(442);
list.Add(441);
list.Add(171);
result = list;
}
else if (kind == DifficultKind.KOU)
{
List <int> list = new List <int>();
list.Add(463);
list.Add(131);
list.Add(153);
list.Add(143);
list.Add(176);
list.Add(445);
list.Add(432);
result = list;
}
else if (kind == DifficultKind.OTU)
{
List <int> list = new List <int>();
list.Add(463);
list.Add(131);
list.Add(153);
list.Add(143);
list.Add(176);
result = list;
}
else if (kind == DifficultKind.HEI)
{
List <int> list = new List <int>();
list.Add(131);
list.Add(153);
result = list;
}
else if (kind == DifficultKind.TEI)
{
List <int> list = new List <int>();
list.Add(131);
result = list;
}
return(result);
}
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);
}
private int this[DifficultKind kind]
{
get
{
return(_clear[(int)(kind - 1)]);
}
set
{
_clear[(int)(kind - 1)] = value;
}
}
private bool setRankE(DifficultKind difficult, DateTime dt, int elapsedYear, uint lostNum, ref OverallRank outRank, ref int outDecNum, ref bool outPositive)
{
outRank = OverallRank.E;
outDecNum = 0;
outPositive = true;
if (lostNum >= 35 && lostNum <= 39)
{
return(true);
}
return(false);
}
private int this[DifficultKind kind]
{
get
{
return this._clear.get_Item(kind - DifficultKind.TEI);
}
set
{
this._clear.set_Item(kind - DifficultKind.TEI, value);
}
}
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 bool CreateSaveDataPlus(string user_name, int ship_mst_id, DifficultKind difficulty)
{
if (Server_Common.Utils.IsGameClear() && Server_Common.Utils.IsValidNewGamePlus())
{
TrophyUtil.__tmp_start_album_ship_num__ = Server_Common.Utils.GetBookRegNum(1);
TrophyUtil.__tmp_start_album_slot_num__ = Server_Common.Utils.GetBookRegNum(2);
new Api_req_Member().NewGamePlus(user_name, difficulty, ship_mst_id);
ManagerBase.initialize();
return(true);
}
return(false);
}
private void initMaterials(DifficultKind difficult)
{
if (this.User_material == null)
{
this.User_material = new Dictionary <enumMaterialCategory, Mem_material>();
}
else
{
this.User_material.Clear();
}
int num = 1500;
if (difficult == DifficultKind.KOU)
{
num = 2000;
}
else if (difficult == DifficultKind.OTU)
{
num = 3000;
}
else if (difficult == DifficultKind.HEI)
{
num = 3000;
}
else if (difficult == DifficultKind.TEI)
{
num = 6000;
}
Dictionary <enumMaterialCategory, int> dictionary = new Dictionary <enumMaterialCategory, int>();
dictionary.Add(enumMaterialCategory.Fuel, num);
dictionary.Add(enumMaterialCategory.Bull, 3000);
dictionary.Add(enumMaterialCategory.Steel, 3000);
dictionary.Add(enumMaterialCategory.Bauxite, 3000);
dictionary.Add(enumMaterialCategory.Build_Kit, 5);
dictionary.Add(enumMaterialCategory.Repair_Kit, 5);
dictionary.Add(enumMaterialCategory.Dev_Kit, 10);
dictionary.Add(enumMaterialCategory.Revamp_Kit, 0);
Dictionary <enumMaterialCategory, int> dictionary2 = dictionary;
using (Dictionary <enumMaterialCategory, int> .Enumerator enumerator = dictionary2.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <enumMaterialCategory, int> current = enumerator.get_Current();
enumMaterialCategory key = current.get_Key();
int value = current.get_Value();
Mem_material mem_material = new Mem_material(key, value);
this.User_material.Add(key, mem_material);
}
}
}
private bool Init(DifficultKind iKind, int nIndex)
{
difficultKind = iKind;
index = nIndex;
_isFocus = false;
_uiForeground.spriteName = $"txt_diff{(int)iKind}_gray";
_uiForeground.MakePixelPerfect();
background.spriteName = "btn_diff1_gray";
_uiForegroundPaper.alpha = 0f;
_uiDifficultyLabel.alpha = 0f;
_uiDifficultyRedLabel.alpha = 0f;
return(true);
}
