private void OnAbilityStateRemove(AbilityState state) { if ((state & (AbilityState.Frozen | AbilityState.Paralyze | AbilityState.Stun)) != AbilityState.None) { this.InterruptMainAI(false); } }
public override void OnAdded() { this._state = State.Idle; this.shield = this.maxShield = base.actor.baseMaxHP * base.instancedAbility.Evaluate(this.config.ShieldHPRatio); this._betweenAttackResumeTimer.SetActive(true); this._forceResumeTimer.SetActive(false); this._minForceResumeTimer.SetActive(false); this._shieldResumeTimer.SetActive(false); base.actor.abilityPlugin.ApplyModifier(base.instancedAbility, this.config.ShieldOnModifierName); if (this._showShieldBar) { this._shieldDisplay = base.actor.abilityPlugin.CreateOrGetDisplayFloat("Shield", 0f, 1f, this.config.ShieldDisplayRatioCeiling); if (this._shieldDisplay.value < this.config.ShieldDisplayRatioCeiling) { this._state = State.Resuming; this._displayFloor = this._shieldDisplay.value; this._shieldResumeTimer.timespan = 0.3f; this._shieldResumeTimer.Reset(true); this._shieldResumeStart = 0f; this._shieldResumeTarget = this.maxShield; } else { this._displayFloor = this.config.ShieldDisplayRatioFloor; } } if (this.config.ControlledAbilityStates != null) { for (int i = 0; i < this.config.ControlledAbilityStates.Length; i++) { this._controlledAbilityState |= this.config.ControlledAbilityStates[i]; } } }
private void OnAbilityStateAdd(AbilityState state, bool muteDisplayEffect) { if ((state & (AbilityState.Frozen | AbilityState.Paralyze | AbilityState.Stun)) != AbilityState.None) { this.InterruptMainAI(true); } }
/// <summary> /// Updates the internal state of the ability /// </summary> public void UpdateState() { if (State == AbilityState.Destroyed) { return; } if (!isEnabled) { State = AbilityState.Disabled; } else if (Time.time >= startTime + cooldownDuration) { State = AbilityState.Ready; } else if (Time.time >= startTime + activeDuration) { State = AbilityState.Cooldown; } else if (Time.time >= startTime + chargeDuration) { State = AbilityState.Active; } else { State = AbilityState.Charging; } if (!Core || Core.GetIsDead()) { State = AbilityState.Destroyed; Debug.Log($"Destroyed!! Core: {Core}, IsDead: {Core?.GetIsDead()}"); } }
public void CreateLight() { ChannelingHandler.PlExists = true; Vector3 pilotedLightPosition = Transform.localScale.x > 0f ? transform.position + new Vector3(0.4f, 0, 0) : transform.position + new Vector3(-0.4f, 0, 0); var pl = (GameObject)Instantiate( PilotedLight, pilotedLightPosition, transform.rotation); pl.GetComponent <PilotedLightController>().Player = this; _camera.Pl = pl.transform; if (AbilityState.IsActive(Ability.Tether)) { var tetherObject = Instantiate(Tether); var tether = tetherObject.GetComponent <Tether>(); tether.Player = transform; tether.Pl = pl.transform; } }
public void ResetAbilityState() { if (!_isLocked) { _state = AbilityState.AS_IDLE; } }
protected override void OnAbilityStateAdd(AbilityState state, bool muteDisplayEffect) { base.OnAbilityStateAdd(state, muteDisplayEffect); if (state == AbilityState.Stun) { this.monster.SetLocomotionBool("BuffStun", true, false); this.monster.SetCountedMuteControl(true); } else if (state == AbilityState.Paralyze) { this.monster.SetLocomotionBool("BuffParalyze", true, false); this._paralyzeAnimatorSpeedIx = this.monster.PushProperty("Animator_OverallSpeedRatioMultiplied", 1f); this._paralyzeTimer.Reset(true); this._paralyzeTimer.timespan = 0.35f; this._paralyzeState = ParalyzeState.ParalyzeHitResuming; this.monster.SetCountedMuteControl(true); } else if (state == AbilityState.Frozen) { if (this.monster.IsAnimatorInTag(MonsterData.MonsterTagGroup.Throw)) { this._frozenAnmatorSpeedIx = this.monster.PushProperty("Animator_OverallSpeedRatioMultiplied", 1f); this._frozenState = FrozenState.WaitingForGrounded; } else { this._frozenAnmatorSpeedIx = this.monster.PushProperty("Animator_OverallSpeedRatioMultiplied", 0f); this._frozenState = FrozenState.FrozenFreezed; } this.monster.SetCountedMuteControl(true); } Singleton <EventManager> .Instance.FireEvent(new EvtBuffAdd(base.runtimeID, state), MPEventDispatchMode.Normal); }
public override void Init(BaseMonoEntity entity) { this.prop = (BaseMonoPropObject)entity; this.config = this.prop.config; base.commonConfig = this.config.CommonConfig; base.Init(entity); for (int i = 0; i < this.config.Abilities.Length; i++) { ConfigEntityAbilityEntry entry = this.config.Abilities[i]; base.appliedAbilities.Add(Tuple.Create <ConfigAbility, Dictionary <string, object> >(AbilityData.GetAbilityConfig(entry.AbilityName, entry.AbilityOverride), new Dictionary <string, object>())); } if (this.config.PropArguments.IsTriggerField) { this._triggerFieldPlugin = new ActorTriggerFieldPlugin(this); base.AddPlugin(this._triggerFieldPlugin); } for (int j = 0; j < 0x1b; j++) { AbilityState state = (AbilityState)(((int)1) << j); if (((state & (AbilityState.Undamagable | AbilityState.MaxMoveSpeed | AbilityState.Immune | AbilityState.CritUp | AbilityState.Shielded | AbilityState.PowerUp | AbilityState.AttackSpeedUp | AbilityState.MoveSpeedUp | AbilityState.Endure)) != AbilityState.None) || ((state & (AbilityState.Tied | AbilityState.TargetLocked | AbilityState.Fragile | AbilityState.Weak | AbilityState.AttackSpeedDown | AbilityState.MoveSpeedDown | AbilityState.Frozen | AbilityState.Poisoned | AbilityState.Burn | AbilityState.Paralyze | AbilityState.Stun | AbilityState.Bleed)) != AbilityState.None)) { base.SetAbilityStateImmune(state, true); } } Singleton <EventManager> .Instance.RegisterEventListener <EvtLevelBuffState>(base.runtimeID); this._opacity = 1f; }
public override bool Use() { reviveTarget = null; List <GameObject> revivableCorpses = detectVolume.DetectedObjects; float closestDist = -1f; foreach (GameObject corpse in revivableCorpses) { UnitCorpse unitCorpse = corpse.GetComponent <UnitCorpse>(); if (!unitCorpse.CanRevive) { continue; } float dist = (corpse.transform.position - transform.position).magnitude; if (reviveTarget == null || dist < closestDist) { reviveTarget = unitCorpse; closestDist = dist; } } if (reviveTarget != null) { state = AbilityState.Channeling; timer = channelTime; return(true); } return(false); }
void Start() { //abilityQ.keybind = keybinding.q; //abilityW.keybind = keybinding.w; //abilityE.keybind = keybinding.e; //abilityR.keybind = keybinding.q; //abilityQ.player = this; //abilityW.player = this; //abilityE.player = this; //abilityR.player = this; state = AbilityState.None; terrain = GameObject.Find("Terrain").GetComponent<Terrain>(); Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("Player"), LayerMask.NameToLayer("TerrainRoughCollider")); Physics2D.IgnoreLayerCollision(LayerMask.NameToLayer("Player"), LayerMask.NameToLayer("VisionCollider")); var pathCollidersContainer = TerrainManager.Instance.ColliderContainer; GameObject circleColliderGO = new GameObject("CircleCollider"); rigbody2D = circleColliderGO.AddComponent<Rigidbody2D>(); rigbody2D.transform.position = new Vector3(transform.position.x, transform.position.z, 0); col2D = circleColliderGO.AddComponent<CircleCollider2D>(); col2D.radius = hitBoxRadius; circleColliderGO.transform.parent = pathCollidersContainer.transform; circleColliderGO.layer = LayerMask.NameToLayer("Player"); }
public void AddRecords(List <IFrameRecord> records, float frameStartTime, float frameEndTime) { foreach (IFrameRecord record in records) { AbilityRecord abilityRecord = (AbilityRecord)record; AbilityState state; if (m_AbilityStates.Count > 0 && m_AbilityStates.Last.abilityType == abilityRecord.abilityType) { state = m_AbilityStates.Last; m_AbilityStates.PopBack(); state.endTime = frameEndTime; } else { state = new AbilityState() { abilityType = abilityRecord.abilityType, startTime = frameStartTime, endTime = frameEndTime }; } m_AbilityStates.PushBack(state); } }
public AbilityHolder(Ability ability) { Ability = ability; Handle = ability.Handle; Name = ability.Name; MaximumLevel = Ability.MaximumLevel; Owner = (Hero)ability.Owner; Id = Ability.Id; AbilityState = ability.AbilityState; Texture = Ability is Item ? Textures.GetItemTexture(ability.Name) : Textures.GetSpellTexture(ability.Name); Cooldown = Ability.Cooldown; IsUltimate = ability.AbilityType == AbilityType.Ultimate; IsHidden = ability.IsHidden; AbilitySlot = ability.AbilitySlot; Item = ability as Item; if (Item != null) { Cost = Item.Cost; } UpdateManager.BeginInvoke(async() => { while (ability.IsValid) { AbilityState = ability.AbilityState; Cooldown = Ability.Cooldown; IsHidden = ability.IsHidden; AbilitySlot = ability.AbilitySlot; await Task.Delay(300); } //Log.Debug($"[{Owner.Name}] end for -> {Id}"); }); }
/// <summary> /// Update the ability cast time and set the ability state to Active when the cast time is elapsed. /// </summary> /// <param name="deltaTime">The amount of time elapsed since the last update.</param> public void UpdateCastTime(float deltaTime) { CastTime.Update(deltaTime); if (CastTime.IsElapsed()) { State = AbilityState.Active; } }
/// <summary> /// Update the ability cooldowns and set the ability state to CooledDown when the cooldowns are elapsed. /// </summary> /// <param name="deltaTime">The amount of time elapsed since the last update.</param> public void UpdateCoolDowns(float deltaTime) { CoolDown.Update(deltaTime); if (CoolDown.IsElapsed()) { State = AbilityState.CooledDown; } }
private void UpdateControlBorder() { if (_currentControl != _controlLastFrame || _isScoutActive != AbilityState.IsActive(Ability.Scout)) { _controlBorder.SetSize(DistanceFromPlayer * (AbilityState.IsActive(Ability.Scout) ? 4 : 2)); _isScoutActive = AbilityState.IsActive(Ability.Scout); _controlLastFrame = _currentControl; } }
public virtual void End() { // Movement restrictions resetMovementRestrictions(); // Cooldown coolDownRemaining = coolDownDuration; state = AbilityState.cooldownInProgress; }
public void SwitchToCooldown() { coolDownTime = ability.coolDownTime; state = AbilityState.Cooldown; animator.SetTrigger(COOLDOWN); Debug.Log("Cooldown"); }
public Ability(float coolDown, float castTime, Range range) : this() { State = AbilityState.CoolingDown; CoolDown = new Timing(coolDown); CastTime = new Timing(castTime); Range = range; IsInRange = false; HasEnougthRessource = true; }
void TransferAbilityState(AbilityState from, AbilityState to) { // Handle 'From' Logic // Rules, for changes depending on what state the battle is moving FROM // e.g. if moving 'from' CharacterSelect, we stop highlighting the 'Ready' characters switch (from) { case AbilityState.CharcterSelect: // remove highlight from friendly charcters //RemoveCharacterSelectHighlight(); <- Not required to highlight anymore, might rename this state break; case AbilityState.ActionSelect: break; case AbilityState.TargetSelect: // remove highlight from targets RemoveTargetHighlight(); break; case AbilityState.ConfirmSelect: // TODO... Remove confirmation flash RemoveConfirmHighlight(); break; } // Handle 'To' logic // Rules, for changes depending on what state the battle is moving TO // e.g. if moving 'to' CharacterSelect, we begin to highlight the 'Ready' characters switch (to) { case AbilityState.CharcterSelect: // highlight all 'ready' friendly characters //CharacterSelectHighlight(); <- Not required to highlight anymore, might rename this state abilityState = AbilityState.CharcterSelect; // Previous turn is over - Reset tracking variables isMenuSetup = false; break; case AbilityState.ActionSelect: abilityState = AbilityState.ActionSelect; break; case AbilityState.TargetSelect: // highlight relevant Targets TargetHighlight(); abilityState = AbilityState.TargetSelect; break; case AbilityState.ConfirmSelect: // TODO... Activate Confirm flash ConfirmHighlight(); abilityState = AbilityState.ConfirmSelect; break; } }
public void UsePrimary() { if (_activePrimary == null || _isLocked) { return; } _state = AbilityState.AS_USING_PRIMARY; _activePrimary.Use(); }
public void UseSecondary() { if (_activeSecondary == null || _isLocked) { return; } _state = AbilityState.AS_USING_SECONDARY; _activeSecondary.Use(); }
private void Execute() { state = AbilityState.Executing; timer = executeTime; if (reviveTarget != null && reviveTarget.Revive()) { detectVolume.Remove(reviveTarget.gameObject); } }
private bool IsTargetState(AbilityState target) { for (int i = 0; i < this.config.AbilityStates.Length; i++) { if (target.ContainsState(this.config.AbilityStates[i])) { return(true); } } return(false); }
private void ChangeState(AbilityState newState, float stateDuration) { state = newState; timer = stateDuration; var handler = StateChanged; if (handler != null) { handler(this, new EventArgs()); } }
public override void OnStep(float dt) { if (state == AbilityState.RELOAD) { timer -= dt; if (timer <= 0f) { state = AbilityState.READY; } } }
private void changeAbilityAnimations(AbilityState newState, string animName) { if (newState != AbilityState.AS_IDLE) { if (AbilityStartAnimations.ContainsKey(_abilities.UsingAbility)) { playAnimation(AbilityStartAnimations[_abilities.UsingAbility]); _isPlayingAbility = true; } else if (AbilityIdleAnimations.ContainsKey(_abilities.UsingAbility)) { _isPlayingAbility = true; playAnimation(AbilityIdleAnimations[_abilities.UsingAbility]); } //if (AbilityStartSounds.ContainsKey(_abilities.UsingAbility)) //SendMessage("Play", new object[] { AbilityStartSounds[_abilities.UsingAbility] }); //if (AbilityIdleSounds.ContainsKey(_abilities.UsingAbility)) //SendMessage("Play", new object[] { AbilityIdleSounds[_abilities.UsingAbility] }); } else { if (AbilityEndAnimations.ContainsKey(animName)) { _isPlayingAbility = true; _isPlayingStoppingAnimation = true; playAnimation(AbilityEndAnimations[animName]); } else if (!_isPlayingCinematic) { _isPlayingAbility = false; SendMessage("StopAnimation"); if (_physics != null) { changePhysicsAnimations(_physics.State); } } if (AbilityEndSounds.ContainsKey(animName)) { playAnimation(AbilityEndSounds[animName]); } else if (!_isPlayingCinematic) { // SendMessage("Stop"); if (_physics != null) { changePhysicsAnimations(_physics.State); } } } }
private void OnAbilityStateRemove(AbilityState state) { bool flag = this.IsTargetState(state); if (flag && (this.config.OnModifierName != null)) { base.actor.abilityPlugin.TryRemoveModifier(base.instancedAbility, this.config.OnModifierName); } if (flag && (this.config.OffModifierName != null)) { base.actor.abilityPlugin.ApplyModifier(base.instancedAbility, this.config.OffModifierName); } }
private void Update() { for (int i = 0; i < _abilities.Count; i++) { BaseAbility ability = _abilities[i]; ability.Update(); AbilityState abs = new AbilityState(); abs.cooldownPercent = ability.CooldownPercent; abs.name = ability.Name; _abilityStates[i] = abs; } }
public void AddAbilityState(AbilityState state, bool muteDisplayEffect) { AbilityStateEntry entry = this.GetStateEntry(this._abilityStatePushCount, state, true); if (entry.count == 0) { this.abilityState |= state; if (this.onAbilityStateAdd != null) { this.onAbilityStateAdd(state, muteDisplayEffect); } } entry.count++; }
private void SetNewCurrentPoint(int key, AbilityPoint abilityPoint) { abilityPoint.IsActivated = true; _abilityPoints[key] = abilityPoint; _currentPoint = key; AbilityState.SetActive(abilityPoint.Ability, true); PlayerPrefs.SetFloat(Meter, (abilityPoint.Point.y * 10) + 1); AddToSpentPoints(1); PlayerPrefs.Save(); SaveAbilityPoints(); CreateLight(key, abilityPoint.Point); }
public static void reset() { AbilityState[] listAbilityPool = new AbilityState[]{ AbilityState.AGUA, AbilityState.TIERRA, AbilityState.FUEGO, AbilityState.VIENTO, AbilityState.NATURALEZA, AbilityState.ARCANO }; foreach (AbilityState state in listAbilityPool) setBoost (0, state); setLastLevel(1); setMoney(0); setScore(0); setSaved (); }
public void generateTreasureRandomLootBoost() { AbilityState[] listAbilityPool = new AbilityState[]{ AbilityState.AGUA, AbilityState.TIERRA, AbilityState.FUEGO, AbilityState.VIENTO, AbilityState.NATURALEZA, AbilityState.ARCANO }; int randomBoost = Random.Range(0,6); // A number between 0 and 5 Game.GetInstance ().player.addBoost (listAbilityPool[randomBoost], 4); ApplicationData.addBoost (4, listAbilityPool[randomBoost]); switch (listAbilityPool [randomBoost]) { case AbilityState.AGUA: SoundManager.instance.PlaySingle ("tesoro-agua"); break; case AbilityState.TIERRA: SoundManager.instance.PlaySingle ("tesoro-tierra"); break; case AbilityState.FUEGO: SoundManager.instance.PlaySingle ("tesoro-fuego"); break; case AbilityState.VIENTO: SoundManager.instance.PlaySingle ("tesoro-viento"); break; case AbilityState.NATURALEZA: SoundManager.instance.PlaySingle ("tesoro-naturaleza"); break; case AbilityState.ARCANO: SoundManager.instance.PlaySingle ("tesoro-arcano"); break; default: break; } }
public double getMultiplier(AbilityState ability) { return stats[ability]; }
public int getBaseDamage(AbilityState ability) { return abilitiesBaseDamage[ability]; }
public void addBoost(AbilityState ability, int amount = 1) { boosts[ability] += amount; abilitiesBaseDamage[ability] = boosts[ability] / boostsToLevelUp + 1; //abilitiesBaseDamage[ability] += boosts[ability] / boostsToLevelUp; //boosts[ability] = boosts[ability] % boostsToLevelUp; }
public int getBoost(AbilityState ability) { return boosts[ability]; }
public void setBaseDamage(AbilityState ability, int dmg) { abilitiesBaseDamage[ability] = dmg; }
public static void setBoost(int score, AbilityState ability) { PlayerPrefs.SetInt (PLAYER_BOOST+ability, score); }
public static void addBoost(int boost, AbilityState ability ) { PlayerPrefs.SetInt (PLAYER_BOOST+ability, getBoost(ability) + boost); }
public static int getBoost(AbilityState ability) { return PlayerPrefs.GetInt (PLAYER_BOOST+ability); }