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);
}
