private void OnLocalAvatarChanged(BaseMonoAvatar from, BaseMonoAvatar to)
{
if (this._owner.monster.AttackTarget == from)
{
this._owner.monster.SetAttackTarget(to);
}
}
public void InitForReviveButton(BaseMonoAvatar avatar)
{
this._button = base.GetComponent <Button>();
this._hpBarImg = base.transform.Find("HPBar/Inner").GetComponent <Image>();
this._spBarImg = base.transform.Find("SPBar/Inner").GetComponent <Image>();
this._iconImage = base.transform.Find("Icon").GetComponent <Image>();
this._CDMaskImg = base.transform.Find("CDMask").GetComponent <Image>();
this.avatarRuntimeID = avatar.GetRuntimeID();
this._avatar = avatar;
this._avatarActor = (AvatarActor)Singleton <EventManager> .Instance.GetActor(this.avatarRuntimeID);
GameObject obj2 = Miscs.LoadResource <GameObject>(this._avatarActor.avatarIconPath, BundleType.RESOURCE_FILE);
this._iconImage.sprite = obj2.GetComponent <SpriteRenderer>().sprite;
Transform transform = base.transform.Find("Attr");
for (int i = 0; i < transform.childCount; i++)
{
transform.GetChild(i).gameObject.SetActive(false);
}
transform.Find(this._avatarActor.avatarDataItem.Attribute.ToString()).gameObject.SetActive(true);
this.onlyForShow = true;
this._button.interactable = true;
base.transform.Find("CDMask").gameObject.SetActive(true);
}
public void OnClick()
{
if (this.canChange)
{
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
if (this._avatar.IsAlive())
{
if ((!this._avatar.IsControlMuted() && localAvatar.IsAnimatorInTag(AvatarData.AvatarTagGroup.AllowTriggerInput)) && (localAvatar.GetRuntimeID() != this.avatarRuntimeID))
{
Singleton <LevelManager> .Instance.levelActor.TriggerSwapLocalAvatar(localAvatar.GetRuntimeID(), this.avatarRuntimeID, false);
}
}
else if (Singleton <LevelScoreManager> .Instance.LevelType != 4)
{
Singleton <LevelManager> .Instance.SetPause(true);
if (Singleton <LevelManager> .Instance.levelActor.levelMode == LevelActor.Mode.Single)
{
Singleton <MainUIManager> .Instance.ShowDialog(new InLevelReviveDialogContext(this.avatarRuntimeID, localAvatar.transform.position, false), UIType.Any);
}
else if ((Singleton <LevelManager> .Instance.levelActor.levelMode == LevelActor.Mode.Multi) || (Singleton <LevelManager> .Instance.levelActor.levelMode == LevelActor.Mode.MultiRemote))
{
Singleton <MainUIManager> .Instance.ShowDialog(new InLevelReviveDialogContext(this.avatarRuntimeID, this._avatar.transform.position, false), UIType.Any);
}
}
}
}
private static void FilterNearestMonsterTarget(BaseMonoAvatar aAvatar, List <BaseMonoMonster> monsters, ref BaseMonoEntity attackTarget)
{
float maxValue = float.MaxValue;
foreach (BaseMonoMonster monster in monsters)
{
List <BaseMonoAbilityEntity> allHitboxEnabledBodyParts = monster.GetAllHitboxEnabledBodyParts();
if (allHitboxEnabledBodyParts.Count > 0)
{
foreach (BaseMonoAbilityEntity entity in allHitboxEnabledBodyParts)
{
float num2 = Vector3.Distance(entity.XZPosition, aAvatar.XZPosition);
if (num2 < maxValue)
{
attackTarget = entity;
maxValue = num2;
}
}
}
else
{
float num3 = Vector3.Distance(monster.XZPosition, aAvatar.XZPosition);
if (num3 < maxValue)
{
attackTarget = monster;
maxValue = num3;
}
}
}
}
public override void HandleLocalPlayerAvatarDie(BaseMonoAvatar diedAvatar)
{
diedAvatar.gameObject.SetActive(false);
Singleton <CameraManager> .Instance.GetMainCamera().TransitToStatic();
Singleton <MainUIManager> .Instance.GetInLevelUICanvas().mainPageContext.SetInLevelMainPageActive(false, false, false);
}
public static void SelectNearestEnemyV1(BaseMonoAvatar aAvatar)
{
List <BaseMonoMonster> monsters = new List <BaseMonoMonster>();
foreach (BaseMonoMonster monster in Singleton <MonsterManager> .Instance.GetAllMonsters())
{
if (monster.IsActive() && !monster.denySelect)
{
monsters.Add(monster);
}
}
if (monsters.Count != 0)
{
BaseMonoEntity attackTarget = null;
if (monsters.Count > 0)
{
FilterNearestMonsterTarget(aAvatar, monsters, ref attackTarget);
}
else
{
attackTarget = null;
}
aAvatar.SetAttackTarget(attackTarget);
}
}
private static void FilterMonsterTargetByEllipse(BaseMonoAvatar aAvatar, List <BaseMonoMonster> monsters, Vector3 mainDirection, float eccentricity, ref BaseMonoEntity monsterTarget, ref float monsterScore)
{
for (int i = 0; i < monsters.Count; i++)
{
BaseMonoMonster target = monsters[i];
if (!target.denySelect && target.IsActive())
{
List <BaseMonoAbilityEntity> allHitboxEnabledBodyParts = target.GetAllHitboxEnabledBodyParts();
if (allHitboxEnabledBodyParts.Count > 0)
{
foreach (BaseMonoAbilityEntity entity in allHitboxEnabledBodyParts)
{
float num2 = GetScoreByEllipse(aAvatar, entity, mainDirection, eccentricity);
if (num2 < monsterScore)
{
monsterTarget = entity;
monsterScore = num2;
}
}
}
else
{
float num3 = GetScoreByEllipse(aAvatar, target, mainDirection, eccentricity);
if (num3 < monsterScore)
{
monsterTarget = target;
monsterScore = num3;
}
}
}
}
}
public static void SelectEnemyByEllipse(BaseMonoAvatar aAvatar)
{
List <BaseMonoMonster> monsters = new List <BaseMonoMonster>();
foreach (BaseMonoMonster monster in Singleton <MonsterManager> .Instance.GetAllMonsters())
{
if (monster.IsActive() && !monster.denySelect)
{
monsters.Add(monster);
}
}
if (monsters.Count != 0)
{
BaseMonoEntity entity;
Vector3 forward = Singleton <CameraManager> .Instance.GetMainCamera().Forward;
if (aAvatar.GetActiveControlData().hasSteer)
{
forward = aAvatar.GetActiveControlData().steerDirection;
}
forward.y = 0f;
if (monsters.Count > 0)
{
entity = monsters[0];
float eccentricity = 0.9f;
float monsterScore = GetScoreByEllipse(aAvatar, entity, forward, eccentricity);
FilterMonsterTargetByEllipse(aAvatar, monsters, forward, eccentricity, ref entity, ref monsterScore);
}
else
{
entity = null;
}
aAvatar.SetAttackTarget(entity);
}
}
public override void OnStart()
{
this._attackState = AttackState.NONE;
BaseMonoAvatar attackTarget = this._aiEntity.AttackTarget as BaseMonoAvatar;
if (attackTarget == null)
{
this._isTargetLocalAvatar = false;
}
else
{
this._isTargetLocalAvatar = Singleton <AvatarManager> .Instance.IsLocalAvatar(attackTarget.GetRuntimeID());
}
if (this._isTargetLocalAvatar && this.AvatarBeAttackNum.IsShared)
{
this._levelAIPlugin.AddAttackingMonster(base.GetComponent <BaseMonoMonster>());
}
if (this.SteerToTargetOnStart || ((this.SkillIDs != null) && (this.SkillIDs.Length > 0)))
{
this._abilityEntity.onCurrentSkillIDChanged = (Action <string, string>)Delegate.Combine(this._abilityEntity.onCurrentSkillIDChanged, new Action <string, string>(this.MonsterSkillIDChanged));
this._skillIDIx = -1;
this._hasSteeredToFacing = this.SteerToTargetOnStart;
}
this._abilityEntity.onBeHitCanceled = (Action <string>)Delegate.Combine(this._abilityEntity.onBeHitCanceled, new Action <string>(this.MonsterBeHitCanceld));
if (this.HitSuccess.IsShared)
{
this.HitSuccess.SetValue(false);
}
}
private void ApplyStageEffectSetting(ConfigStageEffectSetting setting)
{
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
this.AddEntityEffectPredicates(localAvatar, setting.LocalAvatarEffectPredicates);
this._localAvatarPredicates = setting.LocalAvatarEffectPredicates;
if (setting.AvatarColorOverrides.Length > 0)
{
List <BaseMonoAvatar> allPlayerAvatars = Singleton <AvatarManager> .Instance.GetAllPlayerAvatars();
for (int i = 0; i < allPlayerAvatars.Count; i++)
{
BaseMonoAvatar avatar2 = allPlayerAvatars[i];
MonoEffectOverride component = avatar2.GetComponent <MonoEffectOverride>();
if (component == null)
{
component = avatar2.gameObject.AddComponent <MonoEffectOverride>();
}
for (int j = 0; j < setting.AvatarColorOverrides.Length; j++)
{
ColorOverrideEntry entry = setting.AvatarColorOverrides[j];
component.colorOverrides.Add(entry.colorOverrideKey, entry.color);
}
}
}
}
public uint RetargetByThreat(uint curTargetID)
{
int num = 0;
uint num2 = 0;
for (int i = 0; i < this._threatTable.Count; i++)
{
int num4 = this._threatTable.Values[i];
if (num4 > num)
{
uint runtimeID = this._threatTable.Keys[i];
if (Singleton <EventManager> .Instance.GetActor <AvatarActor>(runtimeID) != null)
{
BaseMonoAvatar avatarByRuntimeID = Singleton <AvatarManager> .Instance.GetAvatarByRuntimeID(runtimeID);
if ((avatarByRuntimeID != null) && avatarByRuntimeID.IsActive())
{
num = num4;
num2 = this._threatTable.Keys[i];
}
}
}
}
if (num2 != curTargetID)
{
float threat = this.GetThreat(curTargetID);
if (num > (threat + 10f))
{
return(num2);
}
}
return(curTargetID);
}
public override TaskStatus OnUpdate()
{
if (this._entity is BaseMonoAvatar)
{
BaseMonoAvatar avatar = this._entity as BaseMonoAvatar;
for (int i = 0; i < this.animatorTagNamesAvatar.Count; i++)
{
if (avatar.IsAnimatorInTag(this.animatorTagNamesAvatar[i]))
{
return(TaskStatus.Success);
}
}
}
else if (this._entity is BaseMonoMonster)
{
BaseMonoMonster monster = this._entity as BaseMonoMonster;
for (int j = 0; j < this.animatorTagNamesMonster.Count; j++)
{
if (monster.IsAnimatorInTag(this.animatorTagNamesMonster[j]))
{
return(TaskStatus.Success);
}
}
}
return(TaskStatus.Failure);
}
public AvatarStastics GetAvatarStastics(uint avatarRuntimeID)
{
BaseMonoAvatar helperAvatar = Singleton <AvatarManager> .Instance.GetHelperAvatar();
if ((helperAvatar != null) && (helperAvatar.GetRuntimeID() == avatarRuntimeID))
{
return(null);
}
AvatarActor actor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(avatarRuntimeID);
if (actor == null)
{
return(null);
}
if (!this._avatarStasticsDict.ContainsKey(actor.avatarDataItem.avatarID))
{
AvatarStastics stastics = new AvatarStastics(actor.avatarDataItem.avatarID)
{
avatarLevel = actor.level,
avatarStar = actor.avatarDataItem.star,
stageID = Singleton <LevelScoreManager> .Instance.LevelId
};
this._avatarStasticsDict[actor.avatarDataItem.avatarID] = stastics;
}
return(this._avatarStasticsDict[actor.avatarDataItem.avatarID]);
}
public override TaskStatus OnUpdate()
{
if ((this.retargetEntity.Value != null) && this.retargetEntity.Value.IsActive())
{
this._monster.SetAttackTarget(this.retargetEntity.Value);
this.retargetEntity.SetValue((BaseMonoEntity)null);
return(TaskStatus.Success);
}
if (this._monster.AttackTarget == null)
{
BaseMonoAvatar newTarget = this.SelectNearestAvatar();
if (newTarget != null)
{
this._monsterAIPlugin.InitNearestAvatarThreat(newTarget.GetRuntimeID());
this._monster.SetAttackTarget(newTarget);
return(TaskStatus.Success);
}
}
else
{
uint runtimeID = this._monster.AttackTarget.GetRuntimeID();
uint num2 = this._monsterAIPlugin.RetargetByThreat(runtimeID);
if (runtimeID != num2)
{
this._monster.SetAttackTarget(Singleton <AvatarManager> .Instance.GetAvatarByRuntimeID(num2));
}
return(TaskStatus.Success);
}
return(TaskStatus.Running);
}
private Vector3 CalculateSummonPosition(Vector3 summonPosition)
{
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
if (localAvatar != null)
{
RaycastHit hit;
bool flag = false;
Vector3 start = new Vector3(localAvatar.transform.position.x, 0.1f, localAvatar.transform.position.z);
Vector3 end = new Vector3(summonPosition.x, 0.1f, summonPosition.z);
if (Physics.Linecast(start, end, out hit, (((int)1) << InLevelData.OBSTACLE_COLLIDER_LAYER) | (((int)1) << InLevelData.STAGE_COLLIDER_LAYER)))
{
flag = true;
}
if (flag)
{
Vector3 point = hit.point;
Vector3 vector8 = start - end;
Vector3 normalized = vector8.normalized;
float num = 0.1f;
Vector3 vector5 = point + ((Vector3)(normalized * num));
return(new Vector3(vector5.x, summonPosition.y, vector5.z));
}
}
return(summonPosition);
}
public override void Init()
{
this._avatar = Singleton <AvatarManager> .Instance.GetAvatarByRuntimeID(base.runtimeID);
this._avatarActor = Singleton <MPEventManager> .Instance.GetActor <AvatarActor>(base.runtimeID);
base._animatorEntity = this._avatar;
base._abilityEntity = this._avatar;
base._abilityActor = this._avatarActor;
this._avatarActor.GetPlugin <MPAvatarActorPlugin>().SetupIdentity(this);
this._avatarActor.GetPluginAs <ActorAbilityPlugin, MPActorAbilityPlugin>().SetupIdentity(this);
switch (Singleton <MPLevelManager> .Instance.mpMode)
{
case MPMode.Normal:
this._remoteMode = IdentityRemoteMode.Mute;
break;
case MPMode.PvP_SendNoReceive:
this._remoteMode = IdentityRemoteMode.SendAndNoReceive;
this._avatar.SetAttackSelectMethod(new Action <BaseMonoAvatar>(AvatarAttackTargetSelectPattern.PvPSelectRemoteAvatar));
break;
case MPMode.PvP_ReceiveNoSend:
this._remoteMode = IdentityRemoteMode.ReceiveAndNoSend;
this._avatar.SetAttackSelectMethod(new Action <BaseMonoAvatar>(AvatarAttackTargetSelectPattern.PvPSelectRemoteAvatar));
break;
}
base.Init();
}
private void OnUpdateAttackTarget(BaseMonoEntity entity)
{
if ((entity != null) && this._isTutorialAvailable)
{
MonsterActor attackee = Singleton <EventManager> .Instance.GetActor <MonsterActor>(entity.GetRuntimeID());
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
AvatarActor actor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(localAvatar.GetRuntimeID());
EntityNature attackerNature = (EntityNature)attackee.metaConfig.nature;
EntityNature attribute = (EntityNature)actor.avatarDataItem.Attribute;
float num = DamageModelLogic.GetNatureDamageBonusRatio(attackerNature, attribute, attackee);
if (((((attackee != null) && (actor != null)) && ((base.step == 0) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep))) && ((!this.IsAllStepDone() && (num > 1f)) && ((base.step == 0) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep)))) && !this.IsAllStepDone())
{
this.ActiveCurrentStep();
this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep0));
}
if ((((attackee != null) && (actor != null)) && ((this._killAmount >= 2) && (this._monsterCreatedAmount > 2))) && (((num > 1f) && (base.step == 2)) && ((base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep) && !this.IsAllStepDone())))
{
this.ActiveCurrentStep();
this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep2));
}
}
}
private bool ListenAvatarCreated(EvtAvatarCreated evt)
{
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
localAvatar.onAnimatorStateChanged = (Action <AnimatorStateInfo, AnimatorStateInfo>)Delegate.Combine(localAvatar.onAnimatorStateChanged, new Action <AnimatorStateInfo, AnimatorStateInfo>(this.OnLocalAvatarAnimatorStateChnage));
return(false);
}
public override TaskStatus OnUpdate()
{
BaseMonoAnimatorEntity component = base.GetComponent <BaseMonoAnimatorEntity>();
if (component is BaseMonoMonster)
{
BaseMonoMonster monster = component as BaseMonoMonster;
List <BaseMonoMonster> allMonsters = Singleton <MonsterManager> .Instance.GetAllMonsters();
for (int i = 0; i < allMonsters.Count; i++)
{
if (((allMonsters[i] != monster) && allMonsters[i].IsActive()) && (Vector3.Distance(allMonsters[i].XZPosition, monster.XZPosition) < this.range))
{
return(TaskStatus.Success);
}
}
return(TaskStatus.Failure);
}
if (component is BaseMonoAvatar)
{
BaseMonoAvatar avatar = component as BaseMonoAvatar;
List <BaseMonoAvatar> allAvatars = Singleton <AvatarManager> .Instance.GetAllAvatars();
for (int j = 0; j < allAvatars.Count; j++)
{
if (((allAvatars[j] != avatar) && allAvatars[j].IsActive()) && (Vector3.Distance(allAvatars[j].XZPosition, avatar.XZPosition) < this.range))
{
return(TaskStatus.Success);
}
}
}
return(TaskStatus.Failure);
}
public override void OnAwake()
{
this._avatar = base.GetComponent <BaseMonoAvatar>();
this._avatarActor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(this._avatar.GetRuntimeID());
this._avatarAIPlugin = this._avatarActor.GetPlugin <AvatarAIPlugin>();
}
public override TaskStatus OnUpdate()
{
BaseMonoAvatar attackTarget = this._aiEntity.AttackTarget as BaseMonoAvatar;
if (attackTarget == null)
{
this._isTargetLocalAvatar = false;
}
else
{
this._isTargetLocalAvatar = Singleton <AvatarManager> .Instance.IsLocalAvatar(attackTarget.GetRuntimeID());
}
if (this._isTargetLocalAvatar)
{
if (this.attackType == SetType.BEGIN)
{
this._levelAIPlugin.AddAttackingMonster(this.monster);
this.IsAttacking.Value = true;
}
else
{
this._levelAIPlugin.RemoveAttackingMonster(this.monster);
this.IsAttacking.Value = false;
}
}
return(TaskStatus.Success);
}
private void DragAllAvatarsNearLocalAvatar()
{
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
BaseMonoAvatar helperAvatar = Singleton <AvatarManager> .Instance.GetHelperAvatar();
List <BaseMonoAvatar> allPlayerAvatars = Singleton <AvatarManager> .Instance.GetAllPlayerAvatars();
List <BaseMonoAvatar> list2 = new List <BaseMonoAvatar>();
if (helperAvatar != null)
{
list2.Add(helperAvatar);
}
foreach (BaseMonoAvatar avatar3 in allPlayerAvatars)
{
if (avatar3 != localAvatar)
{
list2.Add(avatar3);
}
}
foreach (BaseMonoAvatar avatar4 in list2)
{
if (Physics.Linecast(localAvatar.transform.position, avatar4.transform.position, (int)(((int)1) << InLevelData.OBSTACLE_COLLIDER_LAYER)))
{
avatar4.transform.position = localAvatar.transform.position;
}
}
}
private bool ListenAvatarCreated(EvtAvatarCreated evt)
{
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
localAvatar.onAttackTargetChanged = (Action <BaseMonoEntity>)Delegate.Combine(localAvatar.onAttackTargetChanged, new Action <BaseMonoEntity>(this.OnUpdateAttackTarget));
return(false);
}
public override void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
base.OnStateUpdate(animator, stateInfo, layerIndex);
BaseMonoAvatar component = animator.GetComponent <BaseMonoAvatar>();
float num = animator.GetFloat("IdleCD") - (Time.deltaTime * component.TimeScale);
animator.SetFloat("IdleCD", num);
}
private bool ListenStageReady(EvtStageReady evt)
{
BaseMonoAvatar helperAvatar = Singleton <AvatarManager> .Instance.GetHelperAvatar();
this._hasHelperAvatar = helperAvatar != null;
this._finished = this._hasHelperAvatar;
return(false);
}
public override void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
base.OnStateUpdate(animator, stateInfo, layerIndex);
BaseMonoAvatar component = animator.GetComponent <BaseMonoAvatar>();
float @float = animator.GetFloat("CombatToStandByCD");
animator.SetFloat("CombatToStandByCD", @float - (Time.deltaTime * component.TimeScale));
}
public override void OnDecided()
{
base.OnDecided();
Singleton <NotifyManager> .Instance.FireNotify(new Notify(NotifyTypes.TutorialMonsterRobotDodge, this));
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
localAvatar.onAnimatorStateChanged = (Action <AnimatorStateInfo, AnimatorStateInfo>)Delegate.Remove(localAvatar.onAnimatorStateChanged, new Action <AnimatorStateInfo, AnimatorStateInfo>(this.OnLocalAvatarAnimatorStateChnage));
}
private void ClearAllSubAttackTargets()
{
BaseMonoAvatar entity = base.actor.entity as BaseMonoAvatar;
if (entity != null)
{
entity.ClearSubAttackList();
}
}
private void AddSubAttackTarget(BaseMonoEntity target)
{
BaseMonoAvatar entity = base.actor.entity as BaseMonoAvatar;
if (entity != null)
{
entity.AddTargetToSubAttackList(target);
}
}
protected virtual void Awake()
{
BaseMonoAvatar component = base.GetComponent <BaseMonoAvatar>();
this.GetFootAnchorFromAvatar(ref this.leftFootAnchor, component, "LeftFoot");
this.GetFootAnchorFromAvatar(ref this.rightFootAnchor, component, "RightFoot");
this._leftStepParser = new BaseSingleStepParser(this, this.leftFootAnchor);
this._rightStepParser = new BaseSingleStepParser(this, this.rightFootAnchor);
}
