public static string DeckPracticeTypeToString(DeckPracticeType deckPracticeType)
{
switch (deckPracticeType)
{
case DeckPracticeType.Normal:
return("艦隊行動");
case DeckPracticeType.Hou:
return("砲戦");
case DeckPracticeType.Kouku:
return("航空戦");
case DeckPracticeType.Rai:
return("雷撃戦");
case DeckPracticeType.Sougou:
return("総合");
case DeckPracticeType.Taisen:
return("対潜戦");
default:
return(string.Empty);
}
}
private void _InitValidDeckPracType(DeckPracticeType type, Mem_deckpractice mem_dp, ref Dictionary <DeckPracticeType, bool> list)
{
if (mem_dp[type])
{
this._valid_deck_prac_type_dic.set_Item(type, this._reqPrac.PrackticeDeckCheck(type, this.CurrentDeck.Id));
}
}
public void Initialize(Dictionary <DeckPracticeType, bool> selectableDeckPracticeTypes)
{
base.transform.localScale = Vector3.one;
mGridFocasable.cellHeight = 0f;
mUIPracticeDeckTypeSelectChildrenFocusable = null;
mFocus = null;
List <UIPracticeDeckTypeSelectChild> list = new List <UIPracticeDeckTypeSelectChild>();
UIPracticeDeckTypeSelectChild[] array = mUIPracticeDeckTypeSelectChildrenAll;
foreach (UIPracticeDeckTypeSelectChild uIPracticeDeckTypeSelectChild in array)
{
uIPracticeDeckTypeSelectChild.gameObject.SetActive(false);
uIPracticeDeckTypeSelectChild.transform.localPosition = Vector3.zero;
uIPracticeDeckTypeSelectChild.SetOnClickListener(null);
DeckPracticeType deckPracticeType = uIPracticeDeckTypeSelectChild.GetDeckPracticeType();
if (selectableDeckPracticeTypes.ContainsKey(deckPracticeType))
{
list.Add(uIPracticeDeckTypeSelectChild);
uIPracticeDeckTypeSelectChild.gameObject.SetActive(true);
uIPracticeDeckTypeSelectChild.transform.parent = mGridFocasable.transform;
uIPracticeDeckTypeSelectChild.transform.localPosition = Vector3.zero;
uIPracticeDeckTypeSelectChild.transform.localScale = Vector3.one;
uIPracticeDeckTypeSelectChild.ParentHasChanged();
uIPracticeDeckTypeSelectChild.SetOnClickListener(OnDeckTypeSelect);
}
else
{
uIPracticeDeckTypeSelectChild.transform.parent = mTransform_ObjectPools;
}
}
mUIPracticeDeckTypeSelectChildrenFocusable = list.ToArray();
}
public void StateChange(DeckPracticeType type, bool state)
{
if (type != DeckPracticeType.Normal)
{
this[type] = state;
}
}
public void Initialize(Dictionary <DeckPracticeType, bool> selectableDeckPracticeTypes)
{
base.get_transform().set_localScale(Vector3.get_one());
this.mGridFocasable.cellHeight = 0f;
this.mUIPracticeDeckTypeSelectChildrenFocusable = null;
this.mFocus = null;
List <UIPracticeDeckTypeSelectChild> list = new List <UIPracticeDeckTypeSelectChild>();
UIPracticeDeckTypeSelectChild[] array = this.mUIPracticeDeckTypeSelectChildrenAll;
for (int i = 0; i < array.Length; i++)
{
UIPracticeDeckTypeSelectChild uIPracticeDeckTypeSelectChild = array[i];
uIPracticeDeckTypeSelectChild.get_gameObject().SetActive(false);
uIPracticeDeckTypeSelectChild.get_transform().set_localPosition(Vector3.get_zero());
uIPracticeDeckTypeSelectChild.SetOnClickListener(null);
DeckPracticeType deckPracticeType = uIPracticeDeckTypeSelectChild.GetDeckPracticeType();
bool flag = selectableDeckPracticeTypes.ContainsKey(deckPracticeType);
if (flag)
{
list.Add(uIPracticeDeckTypeSelectChild);
uIPracticeDeckTypeSelectChild.get_gameObject().SetActive(true);
uIPracticeDeckTypeSelectChild.get_transform().set_parent(this.mGridFocasable.get_transform());
uIPracticeDeckTypeSelectChild.get_transform().set_localPosition(Vector3.get_zero());
uIPracticeDeckTypeSelectChild.get_transform().set_localScale(Vector3.get_one());
uIPracticeDeckTypeSelectChild.ParentHasChanged();
uIPracticeDeckTypeSelectChild.SetOnClickListener(new Action <UIPracticeDeckTypeSelectChild>(this.OnDeckTypeSelect));
}
else
{
uIPracticeDeckTypeSelectChild.get_transform().set_parent(this.mTransform_ObjectPools);
}
}
this.mUIPracticeDeckTypeSelectChildrenFocusable = list.ToArray();
}
private static string FindPracticeMovieClipPath(DeckPracticeType practiceType)
{
switch (practiceType)
{
case DeckPracticeType.Normal:
return("StreamingAssets/Movies/Practice/Practice_Type_A.mp4");
case DeckPracticeType.Hou:
return("StreamingAssets/Movies/Practice/Practice_Type_B.mp4");
case DeckPracticeType.Rai:
return("StreamingAssets/Movies/Practice/Practice_Type_C.mp4");
case DeckPracticeType.Taisen:
return("StreamingAssets/Movies/Practice/Practice_Type_D.mp4");
case DeckPracticeType.Kouku:
return("StreamingAssets/Movies/Practice/Practice_Type_E.mp4");
case DeckPracticeType.Sougou:
return("StreamingAssets/Movies/Practice/Practice_Type_F.mp4");
default:
throw new Exception("Unknown DeckPracticeType Exception");
}
}
public void StateChange(DeckPracticeType type, bool state)
{
if (type == DeckPracticeType.Normal)
{
return;
}
this[type] = state;
}
private void OnSelectedDeckPracticeType(DeckPracticeType deckPracticeType)
{
SoundUtils.PlaySE(SEFIleInfos.CommonEnter1);
if (this.mOnSelectedDeckPracticeTypeCallBack != null)
{
this.mOnSelectedDeckPracticeTypeCallBack.Invoke(deckPracticeType);
}
}
public DeckPracticeResultModel(DeckPracticeType type, PracticeDeckResultFmt fmt, UserInfoModel user_info, Dictionary <int, int> exp_rates_before)
{
_type = type;
_mission_fmt = fmt.PracticeResult;
_powup = fmt.PowerUpData;
_user_info = user_info;
_exps = new Dictionary <int, ShipExpModel>();
_SetShipExp(exp_rates_before);
}
public Api_Result <PracticeDeckResultFmt> GetResultData(DeckPracticeType type, int deck_rid)
{
Api_Result <PracticeDeckResultFmt> api_Result = new Api_Result <PracticeDeckResultFmt>();
if (!Comm_UserDatas.Instance.User_deck.TryGetValue(deck_rid, out mem_deck))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
mem_ship = mem_deck.Ship.getMemShip();
PracticeDeckResultFmt practiceDeckResultFmt = new PracticeDeckResultFmt();
practiceDeckResultFmt.PracticeResult.Deck = mem_deck;
practiceDeckResultFmt.PracticeResult.GetSpoint = 0;
if (execFunc == null)
{
execFunc = new Dictionary <DeckPracticeType, Action <PracticeDeckResultFmt> >
{
{
DeckPracticeType.Normal,
getPracticeUpInfo_To_Normal
},
{
DeckPracticeType.Hou,
getPracticeUpInfo_To_Houg
},
{
DeckPracticeType.Rai,
getPracticeUpInfo_To_Raig
},
{
DeckPracticeType.Taisen,
getPracticeUpInfo_To_Taisen
},
{
DeckPracticeType.Kouku,
getPracticeUpInfo_To_Kouku
},
{
DeckPracticeType.Sougou,
getPracticeUpInfo_To_Sougou
}
};
}
execFunc[type](practiceDeckResultFmt);
practiceDeckResultFmt.PracticeResult.MemberLevel = updateRecordLevel(practiceDeckResultFmt.PracticeResult.GetMemberExp);
practiceDeckResultFmt.PracticeResult.LevelUpInfo = updateShip(type, practiceDeckResultFmt.PracticeResult.GetShipExp, practiceDeckResultFmt.PowerUpData);
api_Result.data = practiceDeckResultFmt;
mem_deck.ActionEnd();
QuestPractice questPractice = new QuestPractice(type, practiceDeckResultFmt);
questPractice.ExecuteCheck();
Comm_UserDatas.Instance.User_record.UpdatePracticeCount(BattleWinRankKinds.NONE, practiceBattle: false);
return(api_Result);
}
public DeckPracticeResultModel StartDeckPractice(DeckPracticeType type)
{
Dictionary <int, int> dic = new Dictionary <int, int>();
CurrentDeck.__CreateShipExpRatesDictionary__(ref dic);
Api_Result <PracticeDeckResultFmt> resultData = _reqPrac.GetResultData(type, CurrentDeck.Id);
if (resultData.state != 0)
{
return(null);
}
return(new DeckPracticeResultModel(type, resultData.data, base.UserInfo, dic));
}
public bool this[DeckPracticeType kind]
{
get
{
int index = (int)(kind - 1);
return(_practiceStatus[index]);
}
private set
{
int index = (int)(kind - 1);
_practiceStatus[index] = value;
}
}
public DeckPracticeResultModel StartDeckPractice(DeckPracticeType type)
{
Dictionary <int, int> exp_rates_before = new Dictionary <int, int>();
this.CurrentDeck.__CreateShipExpRatesDictionary__(ref exp_rates_before);
Api_Result <PracticeDeckResultFmt> resultData = this._reqPrac.GetResultData(type, this.CurrentDeck.Id);
if (resultData.state != Api_Result_State.Success)
{
return(null);
}
return(new DeckPracticeResultModel(type, resultData.data, base.UserInfo, exp_rates_before));
}
public bool this[DeckPracticeType kind]
{
get
{
int num = kind - DeckPracticeType.Normal;
return(this._practiceStatus.get_Item(num));
}
private set
{
int num = kind - DeckPracticeType.Normal;
this._practiceStatus.set_Item(num, value);
}
}
private Dictionary <int, List <int> > updateShip(DeckPracticeType type, Dictionary <int, int> getShipExp, Dictionary <int, PowUpInfo> powerUp)
{
Dictionary <int, List <int> > dictionary = new Dictionary <int, List <int> >();
double[] array = this.useMaterial.get_Item(type);
using (List <Mem_ship> .Enumerator enumerator = this.mem_ship.GetEnumerator())
{
while (enumerator.MoveNext())
{
Mem_ship current = enumerator.get_Current();
int rid = current.Rid;
Mem_shipBase mem_shipBase = new Mem_shipBase(current);
Mst_ship mst_data = Mst_DataManager.Instance.Mst_ship.get_Item(mem_shipBase.Ship_id);
int num = getShipExp.get_Item(rid);
List <int> list = null;
int levelupInfo = current.getLevelupInfo(this.mstLevelShip, current.Level, current.Exp, ref num, out list);
getShipExp.set_Item(rid, num);
if (getShipExp.get_Item(rid) != 0)
{
mem_shipBase.Exp += num;
mem_shipBase.Level = levelupInfo;
}
dictionary.Add(rid, list);
Dictionary <Mem_ship.enumKyoukaIdx, int> dictionary2 = current.Kyouka;
if (!powerUp.get_Item(current.Rid).IsAllZero())
{
this.addKyoukaValues(powerUp.get_Item(current.Rid), dictionary2);
}
int num2 = levelupInfo - current.Level;
for (int i = 0; i < num2; i++)
{
dictionary2 = current.getLevelupKyoukaValue(current.Ship_id, dictionary2);
}
mem_shipBase.SetKyoukaValue(dictionary2);
current.SetRequireExp(mem_shipBase.Level, this.mstLevelShip);
mem_shipBase.Fuel = (int)((double)mem_shipBase.Fuel - (double)mem_shipBase.Fuel * array[0]);
mem_shipBase.Bull = (int)((double)mem_shipBase.Bull - (double)mem_shipBase.Bull * array[1]);
if (mem_shipBase.Fuel < 0)
{
mem_shipBase.Fuel = 0;
}
if (mem_shipBase.Bull < 0)
{
mem_shipBase.Bull = 0;
}
current.Set_ShipParam(mem_shipBase, mst_data, false);
}
}
return(dictionary);
}
private Dictionary <int, List <int> > updateShip(DeckPracticeType type, Dictionary <int, int> getShipExp, Dictionary <int, PowUpInfo> powerUp)
{
Dictionary <int, List <int> > dictionary = new Dictionary <int, List <int> >();
double[] array = useMaterial[type];
foreach (Mem_ship item in mem_ship)
{
int rid = item.Rid;
Mem_shipBase mem_shipBase = new Mem_shipBase(item);
Mst_ship mst_data = Mst_DataManager.Instance.Mst_ship[mem_shipBase.Ship_id];
int addExp = getShipExp[rid];
List <int> lvupInfo = null;
int levelupInfo = item.getLevelupInfo(mstLevelShip, item.Level, item.Exp, ref addExp, out lvupInfo);
getShipExp[rid] = addExp;
if (getShipExp[rid] != 0)
{
mem_shipBase.Exp += addExp;
mem_shipBase.Level = levelupInfo;
}
dictionary.Add(rid, lvupInfo);
Dictionary <Mem_ship.enumKyoukaIdx, int> dictionary2 = item.Kyouka;
if (!powerUp[item.Rid].IsAllZero())
{
addKyoukaValues(powerUp[item.Rid], dictionary2);
}
int num = levelupInfo - item.Level;
for (int i = 0; i < num; i++)
{
dictionary2 = item.getLevelupKyoukaValue(item.Ship_id, dictionary2);
}
mem_shipBase.SetKyoukaValue(dictionary2);
item.SetRequireExp(mem_shipBase.Level, mstLevelShip);
mem_shipBase.Fuel = (int)((double)mem_shipBase.Fuel - (double)mem_shipBase.Fuel * array[0]);
mem_shipBase.Bull = (int)((double)mem_shipBase.Bull - (double)mem_shipBase.Bull * array[1]);
if (mem_shipBase.Fuel < 0)
{
mem_shipBase.Fuel = 0;
}
if (mem_shipBase.Bull < 0)
{
mem_shipBase.Bull = 0;
}
item.Set_ShipParam(mem_shipBase, mst_data, enemy_flag: false);
}
return(dictionary);
}
private string ToString(DeckPracticeType type, Dictionary <DeckPracticeType, bool> dic)
{
List <string> list = new List <string>();
list.Add(string.Empty);
list.Add("艦隊行動演習");
list.Add("砲戦演習");
list.Add("雷撃戦演習");
list.Add("対潜戦演習");
list.Add("航空戦演習");
list.Add("総合演習");
List <string> list2 = list;
string str = $"{list2[(int)type]}-{type} ";
str = ((!dic.ContainsKey(type)) ? (str + $"[未開放]") : (str + string.Format("{0}", (!dic[type]) ? "[選択不可]" : string.Empty)));
return(str + "\n");
}
public bool PrackticeDeckCheck(DeckPracticeType type, int deck_rid)
{
Mem_deck value = null;
if (!Comm_UserDatas.Instance.User_deck.TryGetValue(deck_rid, out value))
{
return(false);
}
List <Mem_ship> memShip = value.Ship.getMemShip();
if (memShip.Count < 0)
{
return(false);
}
Dictionary <int, Mst_ship> mst_shipDict = Mst_DataManager.Instance.Mst_ship;
switch (type)
{
case DeckPracticeType.Normal:
return(true);
case DeckPracticeType.Hou:
{
HashSet <int> disableItem = submarineGroup;
return(memShip.Any((Mem_ship x) => !disableItem.Contains(x.Stype)));
}
case DeckPracticeType.Rai:
return(memShip.Any((Mem_ship x) => mst_shipDict[x.Ship_id].Raig > 0));
case DeckPracticeType.Taisen:
return(memShip.Any((Mem_ship x) => mst_shipDict[x.Ship_id].Tais > 0));
case DeckPracticeType.Kouku:
{
HashSet <int> enableItem = motherBGroup;
return(memShip.Any((Mem_ship x) => enableItem.Contains(x.Stype)));
}
case DeckPracticeType.Sougou:
return((memShip.Count >= 6) ? true : false);
default:
return(false);
}
}
private void OnSelectedDeckPracticeType(DeckPracticeType selectedType)
{
if (mStateManager.CurrentState == State.DeckPracticeTypeSelect)
{
if (mPracticeManager.DeckPracticeTypeDic[selectedType])
{
mDeckPracticeContext.SetPracticeType(selectedType);
mDeckPracticeTypeSelect.SetKeyController(null);
OnCommitDeckPractice(mDeckPracticeContext);
mStateManager.PushState(State.Production);
}
else
{
string mes = UserInterfacePracticeManager.Util.DeckPracticeTypeToString(selectedType) + "に参加できる編成ではありません";
CommonPopupDialog.Instance.StartPopup(mes, 0, CommonPopupDialogMessage.PlayType.Long);
}
}
}
private void OnSelectedDeckPracticeType(DeckPracticeType selectedType)
{
bool flag = this.mStateManager.CurrentState == UIDeckPracticeManager.State.DeckPracticeTypeSelect;
if (flag)
{
bool flag2 = this.mPracticeManager.DeckPracticeTypeDic.get_Item(selectedType);
if (flag2)
{
this.mDeckPracticeContext.SetPracticeType(selectedType);
this.mDeckPracticeTypeSelect.SetKeyController(null);
this.OnCommitDeckPractice(this.mDeckPracticeContext);
this.mStateManager.PushState(UIDeckPracticeManager.State.Production);
}
else
{
string mes = UserInterfacePracticeManager.Util.DeckPracticeTypeToString(selectedType) + "に参加できる編成ではありません";
CommonPopupDialog.Instance.StartPopup(mes, 0, CommonPopupDialogMessage.PlayType.Long);
}
}
}
public bool PrackticeDeckCheck(DeckPracticeType type, int deck_rid)
{
Mem_deck mem_deck = null;
if (!Comm_UserDatas.Instance.User_deck.TryGetValue(deck_rid, ref mem_deck))
{
return(false);
}
List <Mem_ship> memShip = mem_deck.Ship.getMemShip();
if (memShip.get_Count() < 0)
{
return(false);
}
Dictionary <int, Mst_ship> mst_shipDict = Mst_DataManager.Instance.Mst_ship;
if (type == DeckPracticeType.Normal)
{
return(true);
}
if (type == DeckPracticeType.Hou)
{
HashSet <int> disableItem = this.submarineGroup;
return(Enumerable.Any <Mem_ship>(memShip, (Mem_ship x) => !disableItem.Contains(x.Stype)));
}
if (type == DeckPracticeType.Rai)
{
return(Enumerable.Any <Mem_ship>(memShip, (Mem_ship x) => mst_shipDict.get_Item(x.Ship_id).Raig > 0));
}
if (type == DeckPracticeType.Taisen)
{
return(Enumerable.Any <Mem_ship>(memShip, (Mem_ship x) => mst_shipDict.get_Item(x.Ship_id).Tais > 0));
}
if (type == DeckPracticeType.Kouku)
{
HashSet <int> enableItem = this.motherBGroup;
return(Enumerable.Any <Mem_ship>(memShip, (Mem_ship x) => enableItem.Contains(x.Stype)));
}
return(type == DeckPracticeType.Sougou && memShip.get_Count() >= 6);
}
private IEnumerator OnCommitDeckPracticeStartCoroutine(DeckPracticeContext context)
{
DeckPracticeType type = context.PracticeType;
string practiceTypeToString = Util.DeckPracticeTypeToString(type);
mPracticeHeader.UpdateHeaderText(practiceTypeToString + "演習\u3000参加中");
yield return(new WaitForEndOfFrame());
DeckPracticeResultModel result = mPracticeManager.StartDeckPractice(context.PracticeType);
yield return(new WaitForEndOfFrame());
mUIDeckPracticeProductionManager.SetKeyController(mKeyController);
IEnumerator initializeCoroutine = mUIDeckPracticeProductionManager.InitializeCoroutine(mPracticeManager.CurrentDeck, result);
yield return(StartCoroutine(initializeCoroutine));
mUIDeckPracticeProductionManager.SetOnChangeStateListener(OnDeckPracticeProductionStateChangeListener);
IEnumerator playVoiceAndLive2DMotionCoroutine = GeneratePlayVoiceAndLive2DMotionCoroutine(mPracticeManager.CurrentDeck.GetFlagShip(), 14, OnFinishedPlayVoiceAndLive2DMotion);
yield return(StartCoroutine(playVoiceAndLive2DMotionCoroutine));
}
private Texture RequestDeckPracticeImage(DeckPracticeType deckPracticeType)
{
switch (deckPracticeType)
{
case DeckPracticeType.Hou:
return(Resources.Load <Texture>("Textures/Duty/open_img3"));
case DeckPracticeType.Rai:
return(Resources.Load <Texture>("Textures/Duty/open_img4"));
case DeckPracticeType.Taisen:
return(Resources.Load <Texture>("Textures/Duty/open_img5"));
case DeckPracticeType.Kouku:
return(Resources.Load <Texture>("Textures/Duty/open_img6"));
case DeckPracticeType.Sougou:
return(Resources.Load <Texture>("Textures/Duty/open_img7"));
default:
return(null);
}
}
private string ToString(DeckPracticeType type, Dictionary <DeckPracticeType, bool> dic)
{
List <string> list = new List <string>();
list.Add(string.Empty);
list.Add("艦隊行動演習");
list.Add("砲戦演習");
list.Add("雷撃戦演習");
list.Add("対潜戦演習");
list.Add("航空戦演習");
list.Add("総合演習");
List <string> list2 = list;
string text = string.Format("{0}-{1} ", list2.get_Item((int)type), type);
if (dic.ContainsKey(type))
{
text += string.Format("{0}", (!dic.get_Item(type)) ? "[選択不可]" : string.Empty);
}
else
{
text += string.Format("[未開放]", new object[0]);
}
return(text + "\n");
}
public Api_Result <PracticeDeckResultFmt> GetResultData(DeckPracticeType type, int deck_rid)
{
Api_Result <PracticeDeckResultFmt> api_Result = new Api_Result <PracticeDeckResultFmt>();
if (!Comm_UserDatas.Instance.User_deck.TryGetValue(deck_rid, ref this.mem_deck))
{
api_Result.state = Api_Result_State.Parameter_Error;
return(api_Result);
}
this.mem_ship = this.mem_deck.Ship.getMemShip();
PracticeDeckResultFmt practiceDeckResultFmt = new PracticeDeckResultFmt();
practiceDeckResultFmt.PracticeResult.Deck = this.mem_deck;
practiceDeckResultFmt.PracticeResult.GetSpoint = 0;
if (this.execFunc == null)
{
Dictionary <DeckPracticeType, Action <PracticeDeckResultFmt> > dictionary = new Dictionary <DeckPracticeType, Action <PracticeDeckResultFmt> >();
dictionary.Add(DeckPracticeType.Normal, new Action <PracticeDeckResultFmt>(this.getPracticeUpInfo_To_Normal));
dictionary.Add(DeckPracticeType.Hou, new Action <PracticeDeckResultFmt>(this.getPracticeUpInfo_To_Houg));
dictionary.Add(DeckPracticeType.Rai, new Action <PracticeDeckResultFmt>(this.getPracticeUpInfo_To_Raig));
dictionary.Add(DeckPracticeType.Taisen, new Action <PracticeDeckResultFmt>(this.getPracticeUpInfo_To_Taisen));
dictionary.Add(DeckPracticeType.Kouku, new Action <PracticeDeckResultFmt>(this.getPracticeUpInfo_To_Kouku));
dictionary.Add(DeckPracticeType.Sougou, new Action <PracticeDeckResultFmt>(this.getPracticeUpInfo_To_Sougou));
this.execFunc = dictionary;
}
this.execFunc.get_Item(type).Invoke(practiceDeckResultFmt);
practiceDeckResultFmt.PracticeResult.MemberLevel = this.updateRecordLevel(practiceDeckResultFmt.PracticeResult.GetMemberExp);
practiceDeckResultFmt.PracticeResult.LevelUpInfo = this.updateShip(type, practiceDeckResultFmt.PracticeResult.GetShipExp, practiceDeckResultFmt.PowerUpData);
api_Result.data = practiceDeckResultFmt;
this.mem_deck.ActionEnd();
QuestPractice questPractice = new QuestPractice(type, practiceDeckResultFmt);
questPractice.ExecuteCheck();
Comm_UserDatas.Instance.User_record.UpdatePracticeCount(BattleWinRankKinds.NONE, false);
return(api_Result);
}
public static void DeckPracticeMenu_StateChange(DeckPracticeType type, bool state)
{
Comm_UserDatas.Instance.User_deckpractice.StateChange(type, state);
}
public QuestPractice(DeckPracticeType pracType, PracticeDeckResultFmt pracResultFmt)
: this()
{
deckPrackType = pracType;
deckPracticeResult = pracResultFmt;
}
public void SetPracticeType(DeckPracticeType practiceType)
{
PracticeType = practiceType;
}
public Reward_DeckPracitce(int opened_deckpractice_id)
{
_type = (DeckPracticeType)opened_deckpractice_id;
}
public double[] GetUseMaterialKeisu(DeckPracticeType type)
{
return(useMaterial[type]);
}
