public void SetData(ConceptCardData currentCardData, int prevAwakeCount, int prevLevel, bool includeMaxPowerUp)
{
List <ConceptCardEquipEffect> cardSkills = currentCardData.GetCardSkills();
int count = cardSkills.Count;
int lvCap = (int)currentCardData.LvCap;
int awakeCountCap = currentCardData.AwakeCountCap;
List <string> stringList = new List <string>();
for (int index = 0; index < count; ++index)
{
SkillData cardSkill = cardSkills[index].CardSkill;
if (cardSkill != null && !stringList.Contains(cardSkill.Name))
{
stringList.Add(cardSkill.Name);
SkillPowerUpResultContent.Param obj = new SkillPowerUpResultContent.Param(cardSkill, currentCardData, lvCap, awakeCountCap, prevLevel, prevAwakeCount, includeMaxPowerUp);
if (obj.IsBonusParamChanged())
{
SkillPowerUpResult.DispParam dispParam = new SkillPowerUpResult.DispParam();
dispParam.sourceParam = obj;
foreach (SkillPowerUpResultContent.DispType dispType in obj.GetAllBonusChangeType())
{
if (!dispType.isScale)
{
dispParam.dispTypeList.Add(dispType.type);
}
else
{
dispParam.dispTypeListMul.Add(dispType.type);
}
}
this.dispParamList.Add(dispParam);
}
}
}
}
private bool RefreshEquipParam(ConceptCardData conceptCardData, ConceptCardEffectsParam equipParam)
{
if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.mStatusList, (UnityEngine.Object)null))
{
return(false);
}
if (equipParam == null)
{
this.mStatusList.SetValues(new BaseStatus(), new BaseStatus(), false);
return(false);
}
BaseStatus add1 = new BaseStatus();
BaseStatus add2 = new BaseStatus();
BaseStatus scale1 = new BaseStatus();
BaseStatus scale2 = new BaseStatus();
ConceptCardParam.GetSkillStatus(equipParam.statusup_skill, (int)conceptCardData.LvCap, (int)conceptCardData.Lv, ref add1, ref scale1);
if (this.mIsEnhance)
{
int levelCap = Mathf.Min((int)conceptCardData.LvCap, (int)conceptCardData.CurrentLvCap + this.mAddAwakeLv);
int totalExp = (int)conceptCardData.Exp + this.mAddExp;
int lv = MonoSingleton <GameManager> .Instance.MasterParam.CalcConceptCardLevel((int)conceptCardData.Rarity, totalExp, levelCap);
ConceptCardParam.GetSkillStatus(equipParam.statusup_skill, (int)conceptCardData.LvCap, lv, ref add2, ref scale2);
this.mStatusList.SetValuesAfterOnly(add1, scale1, add2, scale2, false, true);
}
else
{
this.mStatusList.SetValues(add1, scale1, false);
}
return(this.IsValueEmpty(add1, scale1));
}
private void CreateItems(QuestParam questParam)
{
if (questParam.bonusObjective == null)
{
return;
}
for (int index = 0; index < questParam.bonusObjective.Length; ++index)
{
QuestBonusObjective bonusObjective = questParam.bonusObjective[index];
QuestMissionItem rewardItem = this.CreateRewardItem(bonusObjective);
if (bonusObjective.itemType == RewardType.ConceptCard)
{
ConceptCardIcon componentInChildren = (ConceptCardIcon)((Component)rewardItem).get_gameObject().GetComponentInChildren <ConceptCardIcon>();
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)componentInChildren, (UnityEngine.Object)null))
{
ConceptCardData cardDataForDisplay = ConceptCardData.CreateConceptCardDataForDisplay(bonusObjective.item);
componentInChildren.Setup(cardDataForDisplay);
}
}
rewardItem.SetGameParameterIndex(index);
this.m_ListItems.Add(new QuestDetail.ViewParam()
{
ListItem = rewardItem,
MissionIndex = index,
IsAchieved = questParam.IsMissionClear(index)
});
GameParameter.UpdateAll(((Component)rewardItem).get_gameObject());
}
}
private GameObject SetConceptCard(string _iname)
{
GameObject gameObject = (GameObject)null;
if (MonoSingleton <GameManager> .Instance.MasterParam.GetConceptCardParam(_iname) == null)
{
DebugUtility.LogError("真理念装 INAME:" + _iname + "は存在しません");
return((GameObject)null);
}
if (Object.op_Inequality((Object)this.ConceptCardTemplate, (Object)null))
{
gameObject = (GameObject)Object.Instantiate <GameObject>((M0)this.ConceptCardTemplate);
if (Object.op_Inequality((Object)gameObject, (Object)null))
{
gameObject.get_transform().SetParent(this.ConceptCardTemplate.get_transform().get_parent(), false);
gameObject.SetActive(true);
ConceptCardData cardDataForDisplay = ConceptCardData.CreateConceptCardDataForDisplay(_iname);
if (cardDataForDisplay != null)
{
ConceptCardIcon component = (ConceptCardIcon)gameObject.GetComponent <ConceptCardIcon>();
if (Object.op_Inequality((Object)component, (Object)null))
{
component.Setup(cardDataForDisplay);
}
}
this.SetAnimatorTrigger(gameObject, "on");
}
}
return(gameObject);
}
public void RefreshIcon()
{
if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.mTrustMasterRewardBase, (UnityEngine.Object)null))
{
return;
}
ConceptCardTrustRewardItemParam reward = this.mConceptCardData.GetReward();
if (reward != null)
{
bool is_on = reward.reward_type == eRewardType.ConceptCard;
this.SwitchObject(is_on, ((Component)this.mTrustMasterRewardCardIcon).get_gameObject(), this.mTrustMasterRewardItemIconObject);
this.mTrustMasterRewardBase.get_gameObject().SetActive(true);
if (is_on)
{
ConceptCardData cardDataForDisplay = ConceptCardData.CreateConceptCardDataForDisplay(reward.iname);
if (cardDataForDisplay == null)
{
return;
}
this.mTrustMasterRewardCardIcon.Setup(cardDataForDisplay);
}
else
{
this.LoadImage(reward.GetIconPath(), this.mTrustMasterRewardIcon);
}
}
else
{
this.mTrustMasterRewardBase.get_gameObject().SetActive(false);
}
}
private static void GetBonusStatus(SkillData groupSkill, ConceptCardData currentCardData, int levelCap, int awakeCountCap, int level, int awakeCount, ref BaseStatus bonusAdd, ref BaseStatus bonusScale, bool includeMaxPowerUp)
{
if (currentCardData.EquipEffects == null)
{
return;
}
using (List <ConceptCardEquipEffect> .Enumerator enumerator = currentCardData.EquipEffects.GetEnumerator())
{
while (enumerator.MoveNext())
{
ConceptCardEquipEffect current = enumerator.Current;
if (current.CardSkill != null && current.CardSkill.Name == groupSkill.Name)
{
current.GetAddCardSkillBuffStatusAwake(awakeCount, awakeCountCap, ref bonusAdd, ref bonusScale);
if (!includeMaxPowerUp || level != levelCap || awakeCount != awakeCountCap)
{
break;
}
BaseStatus total_add = new BaseStatus();
BaseStatus total_scale = new BaseStatus();
current.GetAddCardSkillBuffStatusLvMax(level, levelCap, awakeCount, ref total_add, ref total_scale);
bonusAdd.Add(total_add);
bonusScale.Add(total_scale);
break;
}
}
}
}
public Param(SkillData groupSkill, ConceptCardData currentCardData, int levelCap, int awakeCountCap, int prevLevel, int prevAwakeCount, bool includeMaxPowerUp)
{
this.skilName = groupSkill.Name;
this.prevParam = new BaseStatus();
this.prevParamMul = new BaseStatus();
this.currentParam = new BaseStatus();
this.currentParamMul = new BaseStatus();
this.prevParamBonus = new BaseStatus();
this.prevParamBonusMul = new BaseStatus();
this.currentParamBonus = new BaseStatus();
this.currentParamBonusMul = new BaseStatus();
ConceptCardParam.GetSkillAllStatus(groupSkill.SkillID, levelCap, (int)currentCardData.Lv, ref this.currentParam, ref this.currentParamMul);
ConceptCardParam.GetSkillAllStatus(groupSkill.SkillID, levelCap, prevLevel, ref this.prevParam, ref this.currentParamMul);
SkillPowerUpResultContent.Param.GetBonusStatus(groupSkill, currentCardData, levelCap, awakeCountCap, (int)currentCardData.Lv, (int)currentCardData.AwakeCount, ref this.currentParamBonus, ref this.currentParamBonusMul, includeMaxPowerUp);
SkillPowerUpResultContent.Param.GetBonusStatus(groupSkill, currentCardData, levelCap, awakeCountCap, prevLevel, prevAwakeCount, ref this.prevParamBonus, ref this.currentParamBonusMul, false);
int length = Enum.GetValues(typeof(ParamTypes)).Length;
for (int index1 = 0; index1 < length; ++index1)
{
if (index1 != 2)
{
ParamTypes index2 = (ParamTypes)index1;
if ((int)this.prevParamBonus[index2] != (int)this.currentParamBonus[index2])
{
this.typeList.Add(index2);
}
if ((int)this.prevParamBonusMul[index2] != (int)this.currentParamBonusMul[index2])
{
this.typeListMul.Add(index2);
}
}
}
}
public override void OnSuccess(WWWResult www)
{
if (Network.IsError)
{
Network.EErrCode errCode = Network.ErrCode;
this.OnRetry();
}
else
{
WebAPI.JSON_BodyResponse <FlowNode_ReqMailSelectConceptCard.Json> jsonObject = JSONParser.parseJSONObject <WebAPI.JSON_BodyResponse <FlowNode_ReqMailSelectConceptCard.Json> >(www.text);
DebugUtility.Assert(jsonObject != null, "res == null");
if (jsonObject.body == null)
{
this.OnRetry();
}
else
{
Network.RemoveAPI();
if (jsonObject.body.select == null || jsonObject.body.select.Length <= 0)
{
return;
}
ConceptCardData[] data = new ConceptCardData[jsonObject.body.select.Length];
for (int index = 0; index < jsonObject.body.select.Length; ++index)
{
FlowNode_ReqMailSelectConceptCard.Json_SelectConceptCard selectConceptCard = jsonObject.body.select[index];
data[index] = ConceptCardData.CreateConceptCardDataForDisplay(selectConceptCard.iname);
MonoSingleton <GameManager> .Instance.Player.SetConceptCardNum(selectConceptCard.iname, selectConceptCard.has_count);
}
this.m_GetConceptCardListWindow.Setup(data);
}
}
}
public static void CalcTotalExpTrust(ConceptCardData selectedCard, MultiConceptCard materials, out int mixTotalExp, out int mixTrustExp, out int mixTotalAwakeLv)
{
int num = 0;
mixTotalExp = 0;
mixTrustExp = 0;
mixTotalAwakeLv = 0;
using (List <ConceptCardData> .Enumerator enumerator = materials.GetList().GetEnumerator())
{
while (enumerator.MoveNext())
{
ConceptCardData current = enumerator.Current;
mixTotalExp += current.MixExp;
mixTrustExp += current.Param.en_trust;
if (selectedCard != null && selectedCard.Param.iname == current.Param.iname)
{
mixTrustExp += (int)MonoSingleton <GameManager> .Instance.MasterParam.FixParam.CardTrustPileUp;
}
if (selectedCard != null && selectedCard.Param.iname == current.Param.iname && (int)selectedCard.AwakeCount + num < selectedCard.AwakeCountCap)
{
++num;
}
}
}
mixTotalAwakeLv = (int)MonoSingleton <GameManager> .Instance.MasterParam.FixParam.CardAwakeUnlockLevelCap * num;
}
public void SetData(SkillPowerUpResult inSkillPowerUpResult, ConceptCardData inCurrentCardData, int inPrevAwakeCount, int inPrevLevel)
{
this.prevAwakeCount = inPrevAwakeCount;
this.skillPowerUpResult = inSkillPowerUpResult;
this.currentCardData = inCurrentCardData;
this.skillPowerUpResult.SetData(this.currentCardData, this.prevAwakeCount, inPrevLevel, true);
this.conceptCardTrustMaster.SetData(this.currentCardData);
if (this.skillPowerUpResult.IsEnd)
{
Object.Destroy((Object)((Component)this.skillPowerUpResult).get_gameObject());
this.skillPowerUpResult = (SkillPowerUpResult)null;
if (!this.HasAbilityPowerUp())
{
FlowNode_GameObject.ActivateOutputLinks((Component)this, 101);
}
else
{
this.StartCoroutine(this.CreateAbilityResultCroutine());
}
}
else
{
this.CheckPages();
}
}
private void Start()
{
if (Object.op_Equality((Object)this.mCardObjectTemplate, (Object)null) && Object.op_Equality((Object)this.mCardObjectParent, (Object)null))
{
Debug.LogWarning((object)"mCardObject is null");
}
else
{
this.mCardObjectTemplate.SetActive(false);
ConceptCardManager instance = ConceptCardManager.Instance;
if (Object.op_Equality((Object)instance, (Object)null))
{
return;
}
using (List <ConceptCardData> .Enumerator enumerator = instance.SelectedMaterials.GetList().GetEnumerator())
{
while (enumerator.MoveNext())
{
ConceptCardData current = enumerator.Current;
if (current.Param.not_sale)
{
GameObject gameObject = (GameObject)Object.Instantiate <GameObject>((M0)this.mCardObjectTemplate);
gameObject.get_transform().SetParent((Transform)this.mCardObjectParent, false);
ConceptCardIcon component = (ConceptCardIcon)gameObject.GetComponent <ConceptCardIcon>();
if (Object.op_Inequality((Object)component, (Object)null))
{
component.Setup(current);
}
gameObject.SetActive(true);
}
}
}
}
}
public void Add(ConceptCardData ccd)
{
if (ccd == null || this.mMultiSelectedUniqueID.Contains(ccd.UniqueID))
{
return;
}
this.mMultiSelectedUniqueID.Add(ccd.UniqueID);
}
public void OpenSelectIconExistPage(ConceptCardData card)
{
if (card == null)
{
return;
}
this.mReservedSelectConceptCardData = card;
}
public void Clear()
{
this.target = (ConceptCardData)null;
this.add_exp = 0;
this.add_trust = 0;
this.add_awake_lv = 0;
this.predict_lv = 0;
}
public override void SetParam(ConceptCardData card_data, int addExp, int addTrust, int addAwakeLv)
{
this.mConceptCardData = card_data;
this.mAddExp = addExp;
this.mAddTrust = addTrust;
this.mAddAwakeLv = addAwakeLv;
this.mEnhance = ConceptCardDescription.IsEnhance;
}
public void SetParam(ConceptCardDetailBase concept, ConceptCardData data)
{
if (!Object.op_Inequality((Object)concept, (Object)null))
{
return;
}
concept.SetParam(data);
}
public void SetParam(ConceptCardDetailBase concept, ConceptCardData data, int addExp, int addTrust, int addAwakeLv)
{
if (!Object.op_Inequality((Object)concept, (Object)null))
{
return;
}
concept.SetParam(data, addExp, addTrust, addAwakeLv);
}
public void Remove(ConceptCardData ccd)
{
if (ccd == null || !this.mMultiSelectedUniqueID.Contains(ccd.UniqueID))
{
return;
}
this.mMultiSelectedUniqueID.Remove(ccd.UniqueID);
}
public void SetupConceptCard(ConceptCardData conceptCardData)
{
if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.conceptCard_icon, (UnityEngine.Object)null))
{
return;
}
this.conceptCard_icon.Setup(conceptCardData);
}
private IEnumerator EffectRoutine(ConceptCardData conceptCardData)
{
// ISSUE: object of a compiler-generated type is created
return((IEnumerator) new FlowNode_ConceptCardGetUnit.\u003CEffectRoutine\u003Ec__IteratorB1()
{
conceptCardData = conceptCardData,
\u003C\u0024\u003EconceptCardData = conceptCardData
});
}
public void SetParam(ConceptCardData conceptCardData, ConceptCardEffectsParam conceptCardEffectsParam, int addExp, int addAwakeLv, bool isEnhance, bool isBaseParam)
{
this.mConceptCardData = conceptCardData;
this.mConceptCardEffectsParam = conceptCardEffectsParam;
this.mAddExp = addExp;
this.mAddAwakeLv = addAwakeLv;
this.mIsEnhance = isEnhance;
this.mIsBaseParam = isBaseParam;
}
public static void SetSelectedConceptCard(ConceptCardData data)
{
GetConceptCardListWindow.ClearSelectedConceptCard();
if (data == null || data.Param == null)
{
return;
}
GetConceptCardListWindow.s_SelectedConceptCardID = data.Param.iname;
}
private IEnumerator TrustMasterUpdate(ConceptCardData cardData)
{
// ISSUE: object of a compiler-generated type is created
return((IEnumerator) new ConceptCardDetail.\u003CTrustMasterUpdate\u003Ec__IteratorF5()
{
cardData = cardData,
\u003C\u0024\u003EcardData = cardData,
\u003C\u003Ef__this = this
});
}
private IEnumerator OpenBonusWindow(ConceptCardData concept_card)
{
// ISSUE: object of a compiler-generated type is created
return((IEnumerator) new ConceptCardDescription.\u003COpenBonusWindow\u003Ec__IteratorF4()
{
concept_card = concept_card,
\u003C\u0024\u003Econcept_card = concept_card,
\u003C\u003Ef__this = this
});
}
public ConceptCardEnhanceInfo(ConceptCardData _concept_card, int _add_exp, int _add_trust, int _add_awake_lv)
{
this.target = _concept_card;
this.add_exp = _add_exp;
this.add_trust = _add_trust;
this.add_awake_lv = _add_awake_lv;
this.predict_lv = MonoSingleton <GameManager> .Instance.MasterParam.CalcConceptCardLevel((int)this.target.Rarity, (int)this.target.Exp + this.add_exp, Mathf.Min((int)this.target.LvCap, (int)this.target.CurrentLvCap + this.add_awake_lv));
this.predict_awake = Mathf.Min(this.target.AwakeCountCap, (int)this.target.AwakeCount + this.add_awake_lv / (int)MonoSingleton <GameManager> .Instance.MasterParam.FixParam.CardAwakeUnlockLevelCap);
}
public void SetParam()
{
this.mConceptCardData = (ConceptCardData)GlobalVars.SelectedConceptCardData;
this.mUnitData = ConceptCardEquipDetail.s_UnitData;
if (this.mConceptCardData == null)
{
return;
}
this.Refresh();
this.mConceptCardDescription.SetConceptCardData(this.mConceptCardData, ((Component)this).get_gameObject(), false, this.CheckGetUnitFrame(), this.mUnitData);
}
public void Flip(ConceptCardData ccd)
{
if (!this.IsSelected(ccd))
{
this.Add(ccd);
}
else
{
this.Remove(ccd);
}
}
private bool SelectConceptCard(string _iname)
{
if (string.IsNullOrEmpty(_iname))
{
return(false);
}
ConceptCardData cardDataForDisplay = ConceptCardData.CreateConceptCardDataForDisplay(_iname);
GlobalVars.SelectedConceptCardData.Set(cardDataForDisplay);
return(true);
}
public void Setup(ConceptCardData card)
{
this.mConceptCard = card;
if (card != null)
{
this.Refresh();
}
else
{
this.ResetIcon();
}
}
public override void OnSuccess(WWWResult www)
{
if (Network.IsError)
{
Network.EErrCode errCode = Network.ErrCode;
this.OnRetry();
}
else
{
WebAPI.JSON_BodyResponse <FlowNode_ReqConceptCardMix.Json_ConceptCardMix> jsonObject = JSONParser.parseJSONObject <WebAPI.JSON_BodyResponse <FlowNode_ReqConceptCardMix.Json_ConceptCardMix> >(www.text);
DebugUtility.Assert(jsonObject != null, "res == null");
Network.RemoveAPI();
long iid = -1;
int beforeLevel = -1;
int beforeAwakeCount = -1;
int beforeTrust = -1;
if (jsonObject.body.concept_card != null)
{
iid = jsonObject.body.concept_card.iid;
ConceptCardData conceptCardByUniqueId = MonoSingleton <GameManager> .Instance.Player.FindConceptCardByUniqueID(iid);
if (conceptCardByUniqueId != null)
{
beforeLevel = (int)conceptCardByUniqueId.Lv;
beforeAwakeCount = (int)conceptCardByUniqueId.AwakeCount;
beforeTrust = (int)conceptCardByUniqueId.Trust;
}
}
try
{
MonoSingleton <GameManager> .Instance.Deserialize(jsonObject.body.player);
MonoSingleton <GameManager> .Instance.Player.Deserialize(jsonObject.body.concept_card);
MonoSingleton <GameManager> .Instance.Player.RemoveConceptCardData(jsonObject.body.mix_ids);
}
catch (Exception ex)
{
DebugUtility.LogException(ex);
return;
}
MonoSingleton <GameManager> .Instance.Player.OnGoldChange(this.totalMixZeny);
MonoSingleton <GameManager> .Instance.ServerSyncTrophyExecEnd(www);
ConceptCardData conceptCardByUniqueId1 = MonoSingleton <GameManager> .Instance.Player.FindConceptCardByUniqueID(iid);
MonoSingleton <GameManager> .Instance.Player.OnMixedConceptCard(conceptCardByUniqueId1.Param.iname, beforeLevel, (int)conceptCardByUniqueId1.Lv, beforeAwakeCount, (int)conceptCardByUniqueId1.AwakeCount, beforeTrust, (int)conceptCardByUniqueId1.Trust);
this.ActivateOutputLinks(1000);
((Behaviour)this).set_enabled(false);
}
}