public Entity CreateSteelWall(float x, float y, int offsetX, int cellType)
{
var entity = CreateEntity(EntityType.SteelWall);
var sprite = new Sprite(textureManager.Get(Images.Instance.TileSet), cellSize, Layers.Wall);
var fsm = new EntityStateMachine(entity);
var position = new Position(x, y);
AddCellToMap(x, y, cellType);
return(entity
.Add(new Wall())
.Add(new Health(10000))
.Add(new Display(new Clip(sprite, new Vector2(offsetX, 0))))
.Add(new Collision(cellSize, 15))
.Add(new FSM(fsm))
.Add(new Damage(100))
.Add(new Position(x, y))
.Add(new ActionAfterDeath(() =>
{
var cellPos = position.position.Divide(cellSize.X);
gameField.ClearCell(position.position.Divide(cellSize.X));
gameField.GetCell(cellPos).Entity.Get <FSM>().list["Default"].ChangeState(States.Destroyed);
CreateEnemyExplosion(position.position);
CreateQuake();
})));
}
protected override void OnConstruct()
{
waypoint = new Vector2(-1, -1);
queuedWaypoint = new Vector2(-1, -1);
stateMachine = new EntityStateMachine <HeroState, Hero>(this);
stateMachine.RegisterInitialState(HeroState.Standing, new StandingState());
stateMachine.RegisterState(HeroState.Running, new RunningState());
boxCollider = this.GetComponentStrict <BoxCollider2D>();
OrbBehavior = this.GetComponentStrict <OrbBehavior>();
buffs = new Buffable <HeroBuffs, Hero, IHero>(this);
collisionFilter = new ContactFilter2D();
var layerMask = new LayerMask();
layerMask.value |= 1 << 8;
collisionFilter.SetLayerMask(layerMask);
this.stats.Initialize();
regenTimer = new Timer(1);
isSpellOnCooldown = true;
this.paddle = AddChild(Game.Resources.LoadPrefab <Paddle>("Heroes/Paddle"), resetPosition: true);
audioSource = this.GetComponentStrict <AudioSource>();
this.spell = AddChild(Game.Objects.CreatePrefab(this.spell));
spellCooldownTimer = new Timer(this.spell.cooldown);
}
private void DoUpdate(EntityStateMachine stateMachine, EntityState newState)
{
if (!body || !animator)
{
enabled = false;
return;
}
bool isCurrentStateValid = stateNames.Contains(stateMachine.state.GetType().Name);
bool isNextStateValid = stateNames.Contains(newState.GetType().Name);
if ((parameterType == EntityStateParameterType.OnStateEnterTrigger && isNextStateValid) || (parameterType == EntityStateParameterType.OnStateExitTrigger && isCurrentStateValid))
{
animator.SetTrigger(parameterName);
}
else if (parameterType == EntityStateParameterType.IsInStateBool)
{
if (isNextStateValid)
{
animator.SetBool(parameterName, true);
}
else if (isCurrentStateValid)
{
animator.SetBool(parameterName, false);
}
}
}
private void FixedUpdate()
{
if (this.hudElement.targetCharacterBody)
{
SkillLocator component = this.hudElement.targetCharacterBody.GetComponent <SkillLocator>();
if (component && component.secondary)
{
EntityStateMachine stateMachine = component.secondary.stateMachine;
if (stateMachine)
{
SecondaryScope scopeSniper = stateMachine.state as SecondaryScope;
if (scopeSniper != null && scopeSniper.scopeComponent != null && scopeSniper.scopeComponent.IsScoped)
{
if (component.secondary.stock > 0)
{
image.color = chargeColor;
image.fillAmount = scopeSniper.scopeComponent.charge;
}
else
{
image.color = rechargeColor;
image.fillAmount = 1f - component.secondary.rechargeStopwatch / component.secondary.CalculateFinalRechargeInterval();
}
}
}
}
}
}
public NeutralState(EntityStateMachine ownerFiniteStateMachine) : base(ownerFiniteStateMachine)
{
Name = "Wander";
childStateMachine = new EntityStateMachine(OwnerEntity);
childStateMachine.ParentState = this;
childStateMachine.SetState(new SchoolTogetherState(childStateMachine));
}
public override void OnUpdate(GameEntity entity, EntityStateMachine fsm)
{
if (entity.GetComponent <EntityEffector>().GetEffect <Stun>() == null)
{
fsm.ChangeState(IdleState);
}
}
protected override void OnConstruct()
{
stateMachine = new EntityStateMachine <BeeState, Bee>(this);
stateMachine.RegisterInitialState(BeeState.Idle, new IdleState());
stateMachine.RegisterState(BeeState.Moving, new MovingState());
stateMachine.RegisterState(BeeState.Hit, new HitState());
}
internal void OnActivation(ActivationBaseState <TSkillData> state)
{
this.data = state.CreateSkillData();
if (this.dataStateMachine is null)
{
var name = this.data.targetStateMachineName;
if (!(name is null))
{
EntityStateMachine[] machs = this.skillSlot.GetComponents <EntityStateMachine>();
for (Int32 i = 0; i < machs.Length; ++i)
{
EntityStateMachine mach = machs[i];
if (mach.customName == name)
{
this.dataStateMachine = mach;
break;
}
}
}
}
if (!(this.dataStateMachine is null))
{
this.data.targetStateMachine = this.dataStateMachine;
}
}
// Token: 0x060023CE RID: 9166 RVA: 0x000A8464 File Offset: 0x000A6664
private void FixedUpdate()
{
float fillAmount = 0f;
if (this.hudElement.targetCharacterBody)
{
SkillLocator component = this.hudElement.targetCharacterBody.GetComponent <SkillLocator>();
if (component && component.secondary)
{
EntityStateMachine stateMachine = component.secondary.stateMachine;
if (stateMachine)
{
ScopeSniper scopeSniper = stateMachine.state as ScopeSniper;
if (scopeSniper != null)
{
fillAmount = scopeSniper.charge;
}
}
}
}
if (this.image)
{
this.image.fillAmount = fillAmount;
}
}
public void Awake()
{
this.body = base.GetComponent <CharacterBody>();
this.outer = base.GetComponent <EntityStateMachine>();
this.musicRemote = base.GetComponent <TTGLMusicRemote>();
On.RoR2.CharacterBody.RecalculateStats += CharacterBody_RecalculateStats;
}
// Token: 0x06001E1D RID: 7709 RVA: 0x00081C8F File Offset: 0x0007FE8F
private bool IsArmed()
{
EntityStateMachine entityStateMachine = this.armingStateMachine;
BaseMineArmingState baseMineArmingState = ((entityStateMachine != null) ? entityStateMachine.state : null) as BaseMineArmingState;
return(((baseMineArmingState != null) ? baseMineArmingState.damageScale : 0f) > 1f);
}
public override void Update()
{
base.Update();
Collider[] colliders = Physics.OverlapSphere(this.gameObject.transform.position, m_SearchRadius, ~(1 << this.gameObject.layer));
List <EntityController> availableTargets = new List <EntityController>();
foreach (Collider collider in colliders)
{
if (Physics.GetIgnoreLayerCollision(collider.gameObject.layer, this.gameObject.layer))
{
continue;
}
EntityController entityController = collider.gameObject.GetComponentInParent <EntityController>();
if (!entityController)
{
continue;
}
if (entityController.Entity.Description.EntityType != EntityType.SpaceShip)
{
continue;
}
availableTargets.Add(entityController);
}
CommonComponents.EntityController.Target = FindBestTarget(availableTargets);
if (CommonComponents.EntityController.Target && m_NextState != null)
{
EntityStateMachine.SetNextState(m_NextState);
return;
}
}
public override void OnUpdate(GameEntity entity, EntityStateMachine fsm)
{
var movable = entity.GetComponent <MovableEntity>();
var movement = (fsm as EntityController).Movement;
movement.y = 0;
entity.GetComponent <AnimationController>().PlayAnimation(AnimatorController, movement.x);
movable.Move(movement);
if (movable.velocity.y < 0)
{
movable.GravityScale = 1.4f;
}
else
{
movable.GravityScale = 1;
}
if (movable.OnGround)
{
movable.GravityScale = 1f;
fsm.ChangeState(IdleState);
}
if (ClimbState)
{
fsm.ChangeState(ClimbState);
}
}
public override void Update()
{
base.Update();
if (CommonComponents.TranslationalController == null)
{
return;
}
if (CommonComponents.EntityController.Target && m_OnTargetFoundState)
{
EntityStateMachine.SetNextState(m_OnTargetFoundState);
return;
}
float radius = Mathf.PerlinNoise(Age, m_Seed) * (m_MaxOrbitRadius - m_MinOrbitRadius);
radius = Mathf.Clamp(radius + m_MinOrbitRadius, m_MinOrbitRadius, m_MaxOrbitRadius);
if (radius != 0.0f)
{
m_OrbitPerSecond = m_OrbitSpeed * CommonComponents.EnemyController.Entity.GetStat("core.modtypes.ship.movementspeed").Current / radius;
m_Angle += Time.deltaTime * m_OrbitPerSecond * m_OrbitSpeedMultiplier;
}
Vector3 targetPosition = Vector3.forward * radius;
targetPosition = Quaternion.Euler(0, m_Angle, 0) * targetPosition;
targetPosition += CommonComponents.EnemyController.Entity.Description.Parent.EntityController.Head.position;
CommonComponents.TranslationalController.MoveTowardsPosition(targetPosition);
}
public override bool OnEnter(GameEntity entity, EntityState previousState, EntityStateMachine fsm)
{
var effector = entity.GetComponent <EntityEffector>();
var trigger = effector.GetEffect <Damage>()?.GetTrigger <ImpactData>()
?? effector.GetEffect <BlowUp>()?.GetTrigger <ImpactData>()
?? effector.GetEffect <Interruption>()?.GetTrigger <ImpactData>();
var blowUp = effector.GetEffect <BlowUp>();
var interrupt = effector.GetEffect <Interruption>();
if (trigger == null)
{
return(false);
}
if (blowUp != null)
{
return(true);
}
if (fsm.State is EntityMove)
{
return(false);
}
if (interrupt is null && fsm.State is EntitySkill)
{
return(false);
}
if (interrupt != null && !entity.GetComponent <SkillController>().Interrupt(Mathf.RoundToInt(interrupt.Strength)))
{
return(false);
}
return(true);
}
public DontSchoolTogetherState(EntityStateMachine ownerFiniteStateMachine) : base(ownerFiniteStateMachine)
{
steeringBehaviours.Add(new WanderBehaviour(OwnerEntity));
steeringBehaviours.Add(new DistancingBehaviour(OwnerEntity));
steeringBehaviours.Add(new ObstacleAvoidance(OwnerEntity));
Name = "DontSchoolTogetherState";
}
public sealed override BaseSkillInstanceData OnAssigned(GenericSkill skillSlot)
{
EntityStateMachine reloadTargetStatemachine = null;
EntityStateMachine[] stateMachines = skillSlot.GetComponents <EntityStateMachine>();
for (Int32 i = 0; i < stateMachines.Length; ++i)
{
EntityStateMachine mach = stateMachines[i];
if (mach.customName == this.reloadStateMachineName)
{
reloadTargetStatemachine = mach;
}
}
#if ASSERT
if (reloadTargetStatemachine == null)
{
Log.Error("No state machine found for reload");
}
#endif
skillSlot.stock = this.actualMaxStock;
return(new SniperPrimaryInstanceData(this, reloadTargetStatemachine, this.reloadParams, skillSlot));
}
//Adds tesla mine to projectile register list
internal static void RegisterTeslaMine()
{
//Start with the base engi mine
teslaMinePrefab = LegacyResourcesAPI.Load <GameObject>("prefabs/projectiles/engimine").InstantiateClone("TeslaMine", true);
//If it exists (AKA if shit no break)
if (teslaMinePrefab)
{
//Change the forward speed on it a bit, not sure why but it feels nice so keeping it
teslaMinePrefab.GetComponent <ProjectileSimple>().desiredForwardSpeed = 40f;
//Grab the arming state machine (Handler for the arming states, I think)
EntityStateMachine teslaArmingStateMachine = teslaMinePrefab.GetComponentsInChildren <EntityStateMachine>().First(machine => machine.customName == "Arming");
//Replace the initial and main states of the arming state to our own, cooler states
teslaArmingStateMachine.initialStateType = new SerializableEntityStateType(typeof(TeslaArmingUnarmedState));
teslaArmingStateMachine.mainStateType = new SerializableEntityStateType(typeof(TeslaArmingUnarmedState));
//Grab the main state machine (Handler for the mine after it has landed and is ready to splode)
EntityStateMachine teslaMainStateMachine = teslaMinePrefab.GetComponentsInChildren <EntityStateMachine>().First(machine => machine.customName == "Main");
//Replace initial and main with our own: Initial is the waiting for target, main state is predet state
//Note that the main state is also called when a mine is about to be unloaded (For ex too many mines)
teslaMainStateMachine.initialStateType = new SerializableEntityStateType(typeof(TeslaWaitForStick));
teslaMainStateMachine.mainStateType = new SerializableEntityStateType(typeof(TeslaPreDetState));
//Add it to the projectile queue after modifying it
projList.Add(teslaMinePrefab);
}
}
protected override bool PerformEquipmentAction(EquipmentSlot slot)
{
if (!slot || !slot.characterBody)
{
return(false);
}
var cpt = slot.characterBody.GetComponent <RewindComponent>();
if (!cpt || cpt.frames.Count == 0)
{
return(false);
}
var esm = EntityStateMachine.FindByCustomName(slot.characterBody.gameObject, "Body");
if (esm == null || esm.state is RewindState)
{
return(false);
}
new MsgRewind(slot.characterBody).Send(R2API.Networking.NetworkDestination.Clients);
if (Compat_ClassicItems.enabled)
{
if (Util.CheckRoll(Mathf.Pow(0.5f, Compat_ClassicItems.CheckEmbryoProc(slot, equipmentDef)) * 100f))
{
return(false);
}
}
return(true);
}
public override void OnEnter()
{
base.OnEnter();
this.skinController = base.GetModelTransform().GetComponent <WispModelBitSkinController>();
var model = this.skinController.GetComponent <CharacterModel>();
this.bodyParticles = model.GetComponent <ParticleHolder>().systems[0];
this.flareSprite = base.gameObject.GetComponentInChildren <SpriteRenderer>();
this.eyeFlare = this.flareSprite.GetComponent <EyeFlare>();
this.eyeFlare.localScale = baseFlareIntensity;
var emis = this.bodyParticles.emission;
emis.rateOverTime = baseEmissionRate;
base.characterBody.skinIndex = baseSkin;
this.skinController.Apply(WispBitSkin.GetWispSkin(baseSkin));
this.flareSprite.color = this.skinController.activeLightColor;
this.flareSprite.material = this.skinController.activeTracerMaterial;
this.weaponStateMachine = base.outer.GetComponents <EntityStateMachine>().Where <EntityStateMachine>((esm) => esm.customName == "Weapon").Single <EntityStateMachine>();
}
public Entity CreateTile(float x, float y, int gid, Ground g)
{
var offsetX = gid > 66 ? gid * cellSize.X - 2010 : gid * cellSize.X;
var offsetY = gid > 66 ? 30 : 0;
var destroyedPos = Vector2.Zero;
var randForDestroyed = r.Next(3) * cellSize.X;
if (g == Ground.Ground)
{
destroyedPos = new Vector2(510 + randForDestroyed, 0);
}
else if (g == Ground.Asphalt)
{
destroyedPos = new Vector2(1560 + randForDestroyed, 30);
}
else if (g == Ground.Sand)
{
destroyedPos = new Vector2(630 + randForDestroyed, 30);
}
var sprite = new Sprite(textureManager.Get(Images.Instance.TileSet), cellSize, Layers.Ground);
var entity = CreateEntity();
var fsm = new EntityStateMachine(entity);
fsm.CreateState(States.Alive)
.Add <Display>().WithInstance(new Display(new Clip(sprite, new Vector2(offsetX, offsetY))));
fsm.CreateState(States.Destroyed)
.Add <Display>().WithInstance(new Display(new Clip(sprite, destroyedPos)));
fsm.ChangeState(States.Alive);
return(entity
.Add(new FSM(fsm))
.Add(new Position(x, y)));
}
public override void OnLoad()
{
base.OnLoad();
itemDef.name = "MysticsItems_DasherDisc";
SetItemTierWhenAvailable(ItemTier.Tier3);
itemDef.tags = new ItemTag[]
{
ItemTag.Utility
};
MysticsItemsContent.Resources.unlockableDefs.Add(GetUnlockableDef());
itemDef.pickupModelPrefab = PrepareModel(Main.AssetBundle.LoadAsset <GameObject>("Assets/Items/Dasher Disc/Model.prefab"));
itemDef.pickupIconSprite = Main.AssetBundle.LoadAsset <Sprite>("Assets/Items/Dasher Disc/Icon.png");
Material mat = itemDef.pickupModelPrefab.transform.Find("mdlDasherDisc").GetComponent <MeshRenderer>().sharedMaterial;
HopooShaderToMaterial.Standard.Apply(mat);
HopooShaderToMaterial.Standard.Emission(mat, 4f);
HopooShaderToMaterial.Standard.Gloss(mat);
MysticsItemsDasherDiscSpinner spinner = itemDef.pickupModelPrefab.transform.Find("mdlDasherDisc").gameObject.AddComponent <MysticsItemsDasherDiscSpinner>();
spinner.trail = itemDef.pickupModelPrefab.transform.Find("mdlDasherDisc").Find("Particle System").gameObject;
itemDisplayPrefab = PrepareItemDisplayModel(PrefabAPI.InstantiateClone(itemDef.pickupModelPrefab, itemDef.pickupModelPrefab.name + "Display", false));
itemDisplayPrefab.transform.Find("mdlDasherDisc").localScale = Vector3.one * 5f;
controllerPrefab.AddComponent <GenericOwnership>();
NetworkedBodyAttachment networkedBodyAttachment = controllerPrefab.AddComponent <NetworkedBodyAttachment>();
networkedBodyAttachment.forceHostAuthority = true;
EntityStateMachine stateMachine = controllerPrefab.AddComponent <EntityStateMachine>();
stateMachine.mainStateType = stateMachine.initialStateType = new SerializableEntityStateType(typeof(DiscBaseState.Ready));
NetworkStateMachine networkStateMachine = controllerPrefab.AddComponent <NetworkStateMachine>();
networkStateMachine.SetFieldValue("stateMachines", new EntityStateMachine[] {
stateMachine
});
DiscController component = controllerPrefab.AddComponent <DiscController>();
GameObject follower = PrefabAPI.InstantiateClone(itemDisplayPrefab, "DasherDiscFollower", false);
follower.transform.SetParent(controllerPrefab.transform);
component.follower = follower;
component.disc = follower.transform.Find("mdlDasherDisc").gameObject;
component.discSpinner = component.disc.GetComponent <MysticsItemsDasherDiscSpinner>();
MysticsItemsContent.Resources.entityStateTypes.Add(typeof(DiscBaseState));
MysticsItemsContent.Resources.entityStateTypes.Add(typeof(DiscBaseState.Ready));
MysticsItemsContent.Resources.entityStateTypes.Add(typeof(DiscBaseState.Trigger));
MysticsItemsContent.Resources.entityStateTypes.Add(typeof(DiscBaseState.Invincible));
On.RoR2.CharacterBody.Awake += (orig, self) =>
{
orig(self);
self.onInventoryChanged += delegate()
{
if (NetworkServer.active)
{
self.AddItemBehavior <MysticsItemsDasherDiscBehaviour>(self.inventory.GetItemCount(itemDef));
}
};
};
}
internal virtual void InitializeCharacter()
{
// this creates a config option to enable the character- feel free to remove if the character is the only thing in your mod
characterEnabled = Modules.Config.CharacterEnableConfig(bodyName);
if (characterEnabled.Value)
{
InitializeUnlockables();
bodyPrefab = Modules.Prefabs.CreatePrefab(bodyName + "Body", "mdl" + bodyName, bodyInfo);
EntityStateMachine entityStateMachine = bodyPrefab.GetComponent <EntityStateMachine>();
entityStateMachine.mainStateType = new EntityStates.SerializableEntityStateType(characterMainState);
entityStateMachine.initialStateType = new EntityStates.SerializableEntityStateType(characterSpawnState);
Modules.Prefabs.SetupCharacterModel(bodyPrefab, customRendererInfos, mainRendererIndex);
displayPrefab = Modules.Prefabs.CreateDisplayPrefab(bodyName + "Display", bodyPrefab, bodyInfo);
if (!displayPrefab)
{
displayPrefab = GameObject.Instantiate(bodyPrefab.GetComponent <ModelLocator>().modelBaseTransform.gameObject);
}
Modules.Prefabs.RegisterNewSurvivor(bodyPrefab, displayPrefab, Color.grey, bodyName.ToUpper(), characterUnlockableDef, survivorSortPosition);
InitializeHitboxes();
InitializeSkills();
InitializeSkins();
InitializeItemDisplays();
InitializeDoppelganger();
}
}
public Entity CreateTank(float x, float y, int level = 0)
{
var entity = CreateEntity(EntityType.RedTank);
var position = new Position(x, y, AntEnum.Parse <Direction>(r.Next(1, 5).ToString()));
var myvars = vars.LightTank[level];
var view = new TankView(myvars[5], 0, position.direction);
var listFsm = new Dictionary <string, EntityStateMachine>();
var moveFSM = new EntityStateMachine(entity);
var aiFSM = new EntityStateMachine(entity);
var motionFSM = new EntityStateMachine(entity);
moveFSM.CreateState(States.Stand).Add <Stand>().WithInstance(new Stand());
moveFSM.CreateState(States.Turn).Add <Turn>().WithInstance(new Turn());
moveFSM.CreateState(States.Walk).Add <Walk>().WithInstance(new Walk());
moveFSM.ChangeState(States.Stand);
aiFSM.CreateState(States.Idle).Add <Idle>().WithInstance(new Idle(7));
aiFSM.CreateState(States.Pursuit).Add <Pursuit>().WithInstance(new Pursuit());
aiFSM.CreateState(States.Attack).Add <Attack>().WithInstance(new Attack());
aiFSM.ChangeState(States.Idle);
var addSpeed = Mathf.FromPercent(0.5f, myvars[0]);
motionFSM.CreateState(States.Fast).Add <Controls>()
.WithInstance(new Controls(new Vector2(myvars[0] + addSpeed)));
motionFSM.CreateState(States.Slow).Add <Controls>()
.WithInstance(new Controls(new Vector2(myvars[0] - addSpeed)));
motionFSM.CreateState(States.Normal).Add <Controls>()
.WithInstance(new Controls(new Vector2(myvars[0])));
motionFSM.ChangeState(States.Normal);
listFsm.Add("MoveFSM", moveFSM);
listFsm.Add("AiFSM", aiFSM);
listFsm.Add("MotionFSM", motionFSM);
entity
.Add(position)
.Add(view.GetView())
.Add(new Health(myvars[2], myvars[4]))
.Add(new Damage(100))
.Add(new Tank())
.Add(new FSM(listFsm))
.Add(new AI(360, 210, new[] { EntityType.GreenTank }))
.Add(new Gun(myvars[1], myvars[3]))
.Add(new Collision(cellSize, 15))
.Add(new Motion(Vector2.Zero, r.Next(CellType.Segment, 10000)))
.Add(new ActionAfterDeath(() =>
{
gameField.ClearCell(position.prevCell);
CreateEnemyExplosion(position.position);
CreateQuake();
}));
CreateRedOverlay(entity);
CreateGreenHealthBar(entity);
return(entity);
}
public IEnumerator Starts_In_Idle_State()
{
yield return(Helpers.LoadEntityStateMachineTestsScene());
EntityStateMachine stateMachine = GameObject.FindObjectOfType <EntityStateMachine>();
Assert.AreEqual(typeof(Idle), stateMachine.CurrentStateType);
}
internal static void UtilityStateMachineSetup()
{
EntityStateMachine entityStateMachine = characterPrefab.AddComponent <EntityStateMachine>();
entityStateMachine.customName = "ROCKETEER_Utility";
entityStateMachine.initialStateType = new SerializableEntityStateType(typeof(BaseState));
entityStateMachine.mainStateType = new SerializableEntityStateType(typeof(RocketeerSmallJet));
}
private void JetpackStateMachineSetup(GameObject go)
{
EntityStateMachine jetpackMachine = go.AddComponent <EntityStateMachine>();
jetpackMachine.customName = "Jetpack";
jetpackMachine.initialStateType = new SerializableEntityStateType(typeof(EntityStates.BaseBodyAttachmentState));
jetpackMachine.mainStateType = new SerializableEntityStateType(typeof(EntityStates.BaseBodyAttachmentState));
}
public override IEnumerator Begin(GameEntity entity, EntityStateMachine fsm)
{
var trigger = entity.GetComponent <EntityEffector>()?.GetEffect <Damage>()?.GetTrigger <ImpactData>();
var blowUp = entity.GetComponent <EntityEffector>()?.GetEffect <BlowUp>();
var effector = entity.GetComponent <EntityEffector>();
if (trigger != null)
{
if (blowUp != null)
{
var locker = (fsm as EntityController).Lock(this);
// Debug.Log($"locked {(fsm as EntityController).Locker.Locked}");
entity.GetComponent <SkillController>().Abort();
var movable = entity.GetComponent <MovableEntity>();
var v = (blowUp.Effect as BlowUp).Blow;
v.x *= MathUtility.SignInt(blowUp.GetTrigger <ImpactData>().Position.x - entity.transform.position.x);
entity.GetComponent <MovableEntity>().Frozen = true;
entity.GetComponent <MovableEntity>().SetVelocity(v);
entity.GetComponent <AnimationController>().PlayAnimation(BlowUpAction, trigger.Position.x - entity.transform.position.x);
yield return(null);
while (!movable.OnGround)
{
yield return(null);
}
movable.Frozen = false;
entity.GetComponent <Animator>().SetTrigger("end");
yield return(new WaitForSeconds(BlowUpSleepTime));
entity.GetComponent <EntityEffector>().RemoveEffect(blowUp.Effect);
(fsm as EntityController).UnLock(locker);
while (!fsm.ChangeState(MoveState) && !fsm.ChangeState(JumpState))
{
yield return(null);
}
// Debug.Log($"unlocked {(fsm as EntityController).Locker.Locked}");
yield break;
}
else
{
var interrupt = effector.GetEffect <Interruption>();
if (interrupt != null && entity.GetComponent <SkillController>().Interrupt(Mathf.RoundToInt(interrupt.Strength)))
{
entity.GetComponent <AnimationController>().PlayAnimation(HitAction, trigger.Position.x - entity.transform.position.x);
while (!entity.GetComponent <AnimationController>().IsEnd())
{
yield return(null);
if (fsm.ChangeState(JumpState) || fsm.ChangeState(MoveState))
{
yield break;
}
}
}
}
}
fsm.ChangeState(IdleState);
}
public void Start()
{
var hereticPrefab = Resources.Load <GameObject>("prefabs/charactermasters/hereticmonstermaster");
hereticSkillDrivers = hereticPrefab.GetComponents <AISkillDriver>();
hereticESM = hereticPrefab.GetComponent <EntityStateMachine>();
On.RoR2.CharacterMaster.TransformBody += CharacterMaster_TransformBody;
//On.RoR2.CharacterMaster.TransformBody += CharacterMaster_TransformBody1; //spawn
}
public override bool OnEnter(GameEntity entity, EntityState previousState, EntityStateMachine fsm)
{
if ((fsm as EntityController).Jumped && entity.GetComponent <MovableEntity>().Jump())
{
base.OnEnter(entity, previousState, fsm);
fsm.ChangeState(AirState);
}
return(false);
}
