private void failCond(Unit target, CondEffect effect, ConditionEffectTypes effect_type, EUnitCondition condition, LogMapTrick.TargetInfo log_mt_ti)
{
SceneBattle instance = SceneBattle.Instance;
if (UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
BattleCore battle = instance.Battle;
if (battle != null)
{
LogFailCondition logFailCondition = battle.Log <LogFailCondition>();
logFailCondition.self = target;
logFailCondition.source = (Unit)null;
logFailCondition.condition = condition;
TacticsUnitController unitController = instance.FindUnitController(target);
if (UnityEngine.Object.op_Implicit((UnityEngine.Object)unitController))
{
unitController.LockUpdateBadStatus(condition, false);
}
}
}
CondAttachment condAttachment = this.createCondAttachment(target, effect, effect_type, condition);
target.SetCondAttachment(condAttachment);
if (log_mt_ti == null || !target.IsUnitCondition(condition))
{
return;
}
log_mt_ti.IsEffective = true;
log_mt_ti.FailCondition |= condition;
}
public override void OnActivate()
{
TacticsUnitController byUniqueName = TacticsUnitController.FindByUniqueName(this.ActorID);
switch (this.Type)
{
case EventAction_ToggleActor.ToggleTypes.Hide:
if (Object.op_Inequality((Object)byUniqueName, (Object)null))
{
byUniqueName.SetVisible(false);
break;
}
break;
case EventAction_ToggleActor.ToggleTypes.Show:
case EventAction_ToggleActor.ToggleTypes.Summon:
if (Object.op_Inequality((Object)byUniqueName, (Object)null))
{
byUniqueName.SetVisible(true);
if (Object.op_Inequality((Object)this.mSummonEffect, (Object)null))
{
GameUtility.RequireComponent <OneShotParticle>((Object.Instantiate((Object)this.mSummonEffect, ((Component)byUniqueName).get_transform().get_position(), ((Component)byUniqueName).get_transform().get_rotation()) as GameObject).get_gameObject());
break;
}
break;
}
break;
}
this.ActivateNext();
}
private void SendPlacementInfo()
{
MyPhoton pt = PunMonoSingleton <MyPhoton> .Instance;
MyPhoton.MyPlayer myPlayer = pt.GetMyPlayer();
if (myPlayer == null)
{
return;
}
JSON_MyPhotonPlayerParam param = JSON_MyPhotonPlayerParam.Parse(myPlayer.json);
if (param.units != null)
{
for (int i = 0; i < param.units.Length; ++i)
{
TacticsUnitController tacticsUnitController = this.m_Units.Find((Predicate <TacticsUnitController>)(data =>
{
if (data.Unit.OwnerPlayerIndex == pt.MyPlayerIndex)
{
return(data.UnitData.UnitParam.iname == param.units[i].unit.UnitParam.iname);
}
return(false);
}));
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)tacticsUnitController, (UnityEngine.Object)null))
{
param.units[i].place = this.GetPlacementID(tacticsUnitController.Unit.x, tacticsUnitController.Unit.y);
PlayerPrefsUtility.SetInt(PlayerPrefsUtility.MULTITW_ID_KEY + (object)i, param.units[i].place, false);
}
}
}
PlayerPrefsUtility.Save();
pt.SetMyPlayerParam(param.Serialize());
}
public EventScript.Sequence OnUseSkill(EventScript.SkillTiming timing, TacticsUnitController controller, SkillData skill, List <TacticsUnitController> TargetLists, bool isFirstPlay)
{
return(this.StartSequence((EventScript.TestCondition)(trigger =>
{
bool flag = false;
if (TargetLists != null)
{
using (List <TacticsUnitController> .Enumerator enumerator = TargetLists.GetEnumerator())
{
while (enumerator.MoveNext())
{
TacticsUnitController current = enumerator.Current;
if (this.IsContainsUnit(trigger.TargetUnit, current, controller))
{
flag = true;
break;
}
}
}
}
if (trigger.Trigger == EventScript.ScriptSequence.StartConditions.UseSkill && (EventScript.SkillTiming)trigger.SkillTiming == timing && (!trigger.IsFirstOnly || isFirstPlay) && (this.IsContainsUnit(trigger.UnitName, controller, (TacticsUnitController)null) && flag))
{
return this.IsContainsSkill(trigger.TargetSkill, skill);
}
return false;
}), true, 0));
}
private void CalcPosition(TacticsUnitController controller)
{
Vector3 vector3;
// ISSUE: explicit reference operation
((Vector3)@vector3).\u002Ector((float)controller.Unit.x + 0.5f, 100f, (float)controller.Unit.y + 0.5f);
((Component)controller).get_gameObject().get_transform().set_position(vector3);
}
public override void OnStart(GameObject go)
{
TacticsUnitController componentInParent = (TacticsUnitController)go.GetComponentInParent <TacticsUnitController>();
if (!Object.op_Implicit((Object)componentInParent))
{
return;
}
SceneBattle instance = SceneBattle.Instance;
if (!Object.op_Implicit((Object)instance))
{
return;
}
Vector3 center = Vector3.get_zero();
float distance = GameSettings.Instance.GameCamera_SkillCameraDistance;
List <Vector3> vector3List = new List <Vector3>();
switch (this.CenterType)
{
case CameraMove.eCenterType.Self:
case CameraMove.eCenterType.All:
vector3List.Add(componentInParent.CenterPosition);
if (this.CenterType != CameraMove.eCenterType.All)
{
break;
}
goto case CameraMove.eCenterType.Targets;
case CameraMove.eCenterType.Targets:
using (List <TacticsUnitController> .Enumerator enumerator = componentInParent.GetSkillTargets().GetEnumerator())
{
while (enumerator.MoveNext())
{
TacticsUnitController current = enumerator.Current;
vector3List.Add(current.CenterPosition);
}
break;
}
}
instance.GetCameraTargetView(out center, out distance, vector3List.ToArray());
switch (this.DistanceType)
{
case CameraMove.eDistanceType.Skill:
distance = GameSettings.Instance.GameCamera_SkillCameraDistance;
break;
case CameraMove.eDistanceType.Far:
distance = GameSettings.Instance.GameCamera_DefaultDistance;
break;
case CameraMove.eDistanceType.MoreFar:
distance = GameSettings.Instance.GameCamera_MoreFarDistance;
break;
}
instance.InterpCameraTarget(center);
instance.InterpCameraDistance(distance);
}
private void SetupMask_SelectDir(TacticsUnitController controller, FlowNode_TutorialMask flownode_mask)
{
if (flownode_mask.ComponentId != FlowNode_TutorialMask.eComponentId.SELECT_DIR)
{
return;
}
Vector3 vector3;
// ISSUE: explicit reference operation
((Vector3)@vector3).\u002Ector((float)controller.CenterPosition.x + (float)this.iVal1, (float)(controller.CenterPosition.y - (double)controller.Height / 2.0), (float)controller.CenterPosition.z);
Vector3[] vector3Array = new Vector3[4]
{
new Vector3((float)(vector3.x - 0.5), (float)vector3.y, (float)(vector3.z - 0.5)),
new Vector3((float)(vector3.x - 0.5), (float)vector3.y, (float)(vector3.z + 0.5)),
new Vector3((float)(vector3.x + 0.5), (float)vector3.y, (float)(vector3.z + 0.5)),
new Vector3((float)(vector3.x + 0.5), (float)vector3.y, (float)(vector3.z - 0.5))
};
float num1 = 99999f;
float num2 = 99999f;
float num3 = -99999f;
float num4 = -99999f;
for (int index = 0; index < vector3Array.Length; ++index)
{
Vector2 screenPoint = RectTransformUtility.WorldToScreenPoint(Camera.get_main(), vector3Array[index]);
if ((double)num1 >= screenPoint.x)
{
num1 = (float)screenPoint.x;
}
if ((double)num2 >= screenPoint.y)
{
num2 = (float)screenPoint.y;
}
if ((double)num3 <= screenPoint.x)
{
num3 = (float)screenPoint.x;
}
if ((double)num4 <= screenPoint.y)
{
num4 = (float)screenPoint.y;
}
}
float width = num3 - num1;
float height = num4 - num2;
DirectionArrow[] objectsOfType = (DirectionArrow[])UnityEngine.Object.FindObjectsOfType <DirectionArrow>();
for (int index = 0; index < objectsOfType.Length; ++index)
{
if (objectsOfType[index].Direction == EUnitDirection.PositiveX)
{
Vector3 position = ((Component)objectsOfType[index]).get_transform().get_position();
flownode_mask.Setup(TutorialMask.eActionType.SELECT_DIR, position, true, (string)null);
flownode_mask.SetupMaskSize(width, height);
break;
}
}
}
private void ApplySceneFade(Color fadeColor)
{
CameraHook.ColorMod = fadeColor;
if (this.mSceneFadeIncluders != null && this.mSceneFadeExcluders != null)
{
for (int index = TacticsUnitController.Instances.Count - 1; index >= 0; --index)
{
TacticsUnitController instance = TacticsUnitController.Instances[index];
if (Array.IndexOf <TacticsUnitController>(this.mSceneFadeIncluders, instance) >= 0 && Array.IndexOf <TacticsUnitController>(this.mSceneFadeExcluders, instance) < 0)
{
instance.ColorMod = fadeColor;
}
else
{
instance.ResetColorMod();
}
}
}
else if (this.mSceneFadeIncluders != null)
{
for (int index = TacticsUnitController.Instances.Count - 1; index >= 0; --index)
{
TacticsUnitController instance = TacticsUnitController.Instances[index];
if (Array.IndexOf <TacticsUnitController>(this.mSceneFadeIncluders, instance) >= 0)
{
instance.ColorMod = fadeColor;
}
else
{
instance.ResetColorMod();
}
}
}
else if (this.mSceneFadeExcluders != null)
{
for (int index = TacticsUnitController.Instances.Count - 1; index >= 0; --index)
{
TacticsUnitController instance = TacticsUnitController.Instances[index];
if (Array.IndexOf <TacticsUnitController>(this.mSceneFadeExcluders, instance) < 0)
{
instance.ColorMod = fadeColor;
}
else
{
instance.ResetColorMod();
}
}
}
else
{
for (int index = TacticsUnitController.Instances.Count - 1; index >= 0; --index)
{
TacticsUnitController.Instances[index].ColorMod = fadeColor;
}
}
}
public override void OnActivate()
{
TacticsUnitController byUniqueName = TacticsUnitController.FindByUniqueName(this.ActorID);
if (Object.op_Inequality((Object)byUniqueName, (Object)null))
{
byUniqueName.CollideGround = this.GroundSnap;
}
this.ActivateNext();
}
private TacticsUnitController GetController()
{
TacticsUnitController tacticsUnitController = TacticsUnitController.FindByUniqueName(this.ActorID);
if (UnityEngine.Object.op_Equality((UnityEngine.Object)tacticsUnitController, (UnityEngine.Object)null))
{
tacticsUnitController = TacticsUnitController.FindByUnitID(this.ActorID);
}
return(tacticsUnitController);
}
public EventScript.Sequence OnUnitWithdraw(TacticsUnitController controller, bool isFirstPlay)
{
return(this.StartSequence((EventScript.TestCondition)(trigger =>
{
if (trigger.Trigger == EventScript.ScriptSequence.StartConditions.UnitWithdraw && (!trigger.IsFirstOnly || isFirstPlay))
{
return controller.IsA(trigger.UnitName);
}
return false;
}), true, 0));
}
public EventScript.Sequence OnUnitHPChange(TacticsUnitController controller)
{
return(this.StartSequence((EventScript.TestCondition)(trigger =>
{
if (trigger.Trigger == EventScript.ScriptSequence.StartConditions.HPBelowPercent && controller.IsA(trigger.UnitName))
{
return controller.HPPercentage <= trigger.Percentage;
}
return false;
}), true, 0));
}
public EventScript.Sequence OnUnitStart(TacticsUnitController controller)
{
return(this.StartSequence((EventScript.TestCondition)(trigger =>
{
if (trigger.Trigger == EventScript.ScriptSequence.StartConditions.UnitStart && controller.IsA(trigger.UnitName))
{
return trigger.Turn == controller.Unit.TurnCount;
}
return false;
}), true, 0));
}
public EventScript.Sequence OnRecvSkillCond(TacticsUnitController controller, EUnitCondition cond, bool isFirstPlay)
{
return(this.StartSequence((EventScript.TestCondition)(trigger =>
{
if (trigger.Trigger == EventScript.ScriptSequence.StartConditions.RecvSkillCond && (!trigger.IsFirstOnly || isFirstPlay) && this.IsContainsUnit(trigger.UnitName, controller, (TacticsUnitController)null))
{
return (cond & (EUnitCondition)trigger.SkillCond) != (EUnitCondition)0;
}
return false;
}), true, 0));
}
private void UpdateSelectGrid()
{
if (this.m_SelectGrid.x < 0 || this.m_SelectGrid.y < 0)
{
return;
}
if (this.m_SelectParty < 0)
{
for (int index = 0; index < this.m_Units.Count; ++index)
{
TacticsUnitController unit = this.m_Units[index];
if (unit.Unit.x == this.m_SelectGrid.x && unit.Unit.y == this.m_SelectGrid.y)
{
this.m_SelectParty = index;
break;
}
}
if (this.m_SelectParty < 0)
{
return;
}
this.UpdateUnitStatus(0, false);
}
else
{
int num = this.CheckExistUnit(this.m_SelectGrid.x, this.m_SelectGrid.y);
if (num != -1)
{
this.m_SelectParty = num;
this.UpdateUnitStatus(0, true);
MonoSingleton <MySound> .Instance.PlaySEOneShot("SE_0005", 0.0f);
}
else
{
using (List <UnitSetting> .Enumerator enumerator = this.CurrentMap.PartyUnitSettings.GetEnumerator())
{
while (enumerator.MoveNext())
{
UnitSetting current = enumerator.Current;
if (this.CheckExistUnit((int)current.pos.x, (int)current.pos.y) == -1 && (int)current.pos.x == this.m_SelectGrid.x && (int)current.pos.y == this.m_SelectGrid.y)
{
this.m_Units[this.m_SelectParty].Unit.x = (int)current.pos.x;
this.m_Units[this.m_SelectParty].Unit.y = (int)current.pos.y;
this.CalcPosition(this.m_Units[this.m_SelectParty]);
this.UpdateUnitStatus(0, true);
MonoSingleton <MySound> .Instance.PlaySEOneShot("SE_0002", 0.0f);
break;
}
}
}
}
}
}
public EventScript.Sequence OnStandbyGrid(TacticsUnitController controller, bool isFirstPlay)
{
return(this.StartSequence((EventScript.TestCondition)(trigger =>
{
IntVector2 intVector2Grid = EventScript.ConvToIntVector2Grid(trigger.GridXY);
if (trigger.Trigger == EventScript.ScriptSequence.StartConditions.StandbyGrid && (!trigger.IsFirstOnly || isFirstPlay) && (this.IsContainsUnit(trigger.UnitName, controller, (TacticsUnitController)null) && controller.Unit.x == intVector2Grid.x))
{
return controller.Unit.y == intVector2Grid.y;
}
return false;
}), true, 0));
}
public override void OnActivate()
{
this.mController = this.GetController();
if (Object.op_Equality((Object)this.mController, (Object)null) || this.mPoints.Length == 0)
{
this.ActivateNext();
}
else
{
this.mReady = false;
}
}
public override void GoToEndState()
{
if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.mController, (UnityEngine.Object)null))
{
this.mController = this.GetController();
}
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.mController, (UnityEngine.Object)null) && this.mController.IsLoading)
{
return;
}
((Component)this.mController).get_transform().set_position(EventAction.PointToWorld(this.mPoints[this.mPoints.Length - 1]));
}
private void SetupMask_AttackTargetDesc(TacticsUnitController controller, FlowNode_TutorialMask flownode_mask)
{
if (flownode_mask.ComponentId != FlowNode_TutorialMask.eComponentId.ATTACK_TARGET_DESC || !UnityEngine.Object.op_Inequality((UnityEngine.Object)controller, (UnityEngine.Object)null) || !UnityEngine.Object.op_Inequality((UnityEngine.Object)flownode_mask, (UnityEngine.Object)null))
{
return;
}
Vector3 world_pos;
// ISSUE: explicit reference operation
((Vector3)@world_pos).\u002Ector((float)controller.CenterPosition.x + (float)this.iVal1, (float)controller.CenterPosition.y, (float)controller.CenterPosition.z);
flownode_mask.Setup(TutorialMask.eActionType.ATTACK_TARGET_DESC, world_pos, true, (string)null);
Vector3 vector3;
// ISSUE: explicit reference operation
((Vector3)@vector3).\u002Ector((float)controller.CenterPosition.x + (float)this.iVal1, (float)(controller.CenterPosition.y - (double)controller.Height / 2.0), (float)controller.CenterPosition.z);
Vector3[] vector3Array = new Vector3[5]
{
new Vector3((float)(vector3.x - 0.5), (float)vector3.y, (float)(vector3.z - 0.5)),
new Vector3((float)(vector3.x - 0.5), (float)vector3.y, (float)(vector3.z + 0.5)),
new Vector3((float)(vector3.x + 0.5), (float)vector3.y, (float)(vector3.z + 0.5)),
new Vector3((float)(vector3.x + 0.5), (float)vector3.y, (float)(vector3.z - 0.5)),
new Vector3((float)vector3.x, (float)vector3.y + controller.Height, (float)vector3.z)
};
float num1 = 99999f;
float num2 = 99999f;
float num3 = -99999f;
float num4 = -99999f;
for (int index = 0; index < vector3Array.Length; ++index)
{
Vector2 screenPoint = RectTransformUtility.WorldToScreenPoint(Camera.get_main(), vector3Array[index]);
if ((double)num1 >= screenPoint.x)
{
num1 = (float)screenPoint.x;
}
if ((double)num2 >= screenPoint.y)
{
num2 = (float)screenPoint.y;
}
if ((double)num3 <= screenPoint.x)
{
num3 = (float)screenPoint.x;
}
if ((double)num4 <= screenPoint.y)
{
num4 = (float)screenPoint.y;
}
}
float width = num3 - num1;
float num5 = num4 - num2;
flownode_mask.SetupMaskSize(width, num5 * 1.5f);
}
public override void OnActivate()
{
TacticsUnitController byUniqueName = TacticsUnitController.FindByUniqueName(this.ActorID);
if (Object.op_Inequality((Object)byUniqueName, (Object)null))
{
foreach (Behaviour componentsInChild in (YuremonoInstance[])((Component)byUniqueName).get_gameObject().GetComponentsInChildren <YuremonoInstance>())
{
componentsInChild.set_enabled(this.EnableYuremono);
}
}
this.ActivateNext();
}
private void UpdateMarker(TacticsUnitController controller = null)
{
if (Object.op_Inequality((Object)controller, (Object)null) && Object.op_Inequality((Object)this.m_Marker, (Object)null))
{
this.m_Marker.get_transform().SetParent(((Component)controller).get_transform(), false);
this.m_Marker.get_transform().set_localPosition(Vector3.op_Multiply(Vector3.get_up(), 1.5f));
this.m_Marker.get_gameObject().SetActive(true);
}
else
{
this.m_Marker.get_gameObject().SetActive(false);
}
}
public override void OnActivate()
{
GameObject actor = EventAction.FindActor(this.ActorID);
if (Object.op_Inequality((Object)actor, (Object)null))
{
TacticsUnitController component = (TacticsUnitController)actor.GetComponent <TacticsUnitController>();
if (Object.op_Inequality((Object)component, (Object)null))
{
Object.Destroy((Object)((Component)component).get_gameObject());
}
}
this.ActivateNext();
}
public void OnSelectDirectionStart(Unit unit, int turn)
{
if (this.TriggerType != FlowNode_TutorialTrigger.TriggerTypes.UnitSelectDirection)
{
return;
}
TacticsUnitController unitController = SceneBattle.Instance.FindUnitController(unit);
foreach (FlowNode_TutorialMask component in (FlowNode_TutorialMask[])((Component)this).GetComponents <FlowNode_TutorialMask>())
{
this.SetupMask_SelectDir(unitController, component);
}
this.TriggerIf(this.CompareUnit(unit, turn));
}
private List <int> CheckExistUnit(int x, int y)
{
List <int> intList = new List <int>();
for (int index = 0; index < this.m_Units.Count; ++index)
{
TacticsUnitController unit = this.m_Units[index];
if (unit.Unit.x == x && unit.Unit.y == y)
{
intList.Add(index);
}
}
return(intList);
}
private TacticsUnitController getTarget(TacticsUnitController tuc)
{
if (Object.op_Equality((Object)tuc, (Object)null))
{
return((TacticsUnitController)null);
}
List <TacticsUnitController> targetTucLists = tuc.GetTargetTucLists();
if (targetTucLists == null || targetTucLists.Count == 0)
{
return((TacticsUnitController)null);
}
return(targetTucLists[0]);
}
public override void OnActivate()
{
GameObject actor = EventAction.FindActor(this.ActorID);
if (Object.op_Inequality((Object)actor, (Object)null))
{
TacticsUnitController component = (TacticsUnitController)actor.GetComponent <TacticsUnitController>();
if (Object.op_Inequality((Object)component, (Object)null))
{
component.SetRunAnimation(this.AnimationName);
}
}
this.ActivateNext();
}
public override void OnTick(GameObject go, float ratio)
{
if (!this.mIsValid)
{
return;
}
TacticsUnitController componentInParent = (TacticsUnitController)go.GetComponentInParent <TacticsUnitController>();
if (!Object.op_Implicit((Object)componentInParent))
{
return;
}
((Component)componentInParent).get_transform().set_position(Vector3.Lerp(this.mPosStart, this.mPosEnd, ratio));
}
public int GetDisplayHeight(Unit unit)
{
TacticsUnitController tacticsUnitController = this.m_Units.Find((Predicate <TacticsUnitController>)(ctrl => ctrl.Unit == unit));
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)tacticsUnitController, (UnityEngine.Object)null))
{
IntVector2 intVector2 = this.CalcCoord(tacticsUnitController.CenterPosition);
Grid current = this.CurrentMap[intVector2.x, intVector2.y];
if (current != null)
{
return(current.height);
}
}
return(0);
}
public override void OnActivate()
{
this.mController = this.GetController();
if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.mController, (UnityEngine.Object)null) || this.mPoints.Length == 0)
{
this.ActivateNext();
}
else
{
this.mController.SetRunningSpeed(this.RunSpeed);
this.mReady = false;
this.mActorCollideGround = this.mController.CollideGround;
this.mController.CollideGround = this.GroundSnap;
}
}
private int CheckExistUnit(int x, int y)
{
int num = -1;
for (int index = 0; index < this.m_Units.Count; ++index)
{
TacticsUnitController unit = this.m_Units[index];
if (unit.Unit.x == x && unit.Unit.y == y)
{
num = index;
break;
}
}
return(num);
}
