protected void MoveTo(object sender, WriterCommandEventArgs args)
{
if (args.Mode == WriterCommandEventMode.QueryState)
{
args.Enabled = args.Document != null;
}
else if (args.Mode == WriterCommandEventMode.Invoke)
{
MoveTarget target = MoveTarget.None;
if (args.Parameter is MoveTarget)
{
target = (MoveTarget)args.Parameter;
}
else if (args.Parameter is string)
{
try
{
target = (MoveTarget)Enum.Parse(
typeof(MoveTarget),
(string)args.Parameter,
true);
}
catch
{
}
}
if (target != MoveTarget.None)
{
args.Document.Content.AutoClearSelection = true;
args.Document.Content.MoveTo(target);
}
}
}
IEnumerator RuneMoveEffects(MoveEffects effects, Pokemon source, Pokemon target, MoveTarget moveTarget) //Creating a function of the Effects move, so we'll call it easyly
{
if (effects.Boosts != null) //Call for stat boost
{
if (moveTarget == MoveTarget.Self)
{
source.ApplyBoosts(effects.Boosts);
}
else
{
target.ApplyBoosts(effects.Boosts);
}
}
//Check from the dictionnary if there are any status condition, and call for status
if (effects.Status != ConditionID.none)
{
target.SetStatus(effects.Status);
}
//Same with volatile status
if (effects.VolatileStatus != ConditionID.none)
{
target.SetVolatileStatus(effects.VolatileStatus);
}
yield return(ShowStatusChanges(source));
yield return(ShowStatusChanges(target));
}
private IEnumerator UseMoveEffects(MoveEffects effects, MonsterObj attackingMonster, MonsterObj defendingMonster,
MoveTarget moveTarget)
{
// Handle any stat changes.
if (effects.StatChanges != null)
{
if (moveTarget == MoveTarget.Self)
{
attackingMonster.ApplyStatChanges(effects.StatChanges);
}
else
{
defendingMonster.ApplyStatChanges(effects.StatChanges);
}
}
// Handle any status conditions.
if (effects.Status != ConditionID.None)
{
defendingMonster.SetStatus(effects.Status);
}
// Handle any volatile status conditions.
if (effects.VolatileStatus != ConditionID.None)
{
defendingMonster.SetVolatileStatus(effects.VolatileStatus);
}
yield return(ShowStatusChanges(attackingMonster));
yield return(ShowStatusChanges(defendingMonster));
}
IEnumerator RunMoveEffects(MoveEffects effects, Animal source, Animal target, MoveTarget moveTarget)
{
// Stat Boosting
if (effects.Boosts != null)
{
if (moveTarget == MoveTarget.Self)
{
source.ApplyBoosts(effects.Boosts);
}
else
{
target.ApplyBoosts(effects.Boosts);
}
}
//Status Conditions
if (effects.Status != ConditionID.none)
{
target.SetStatus(effects.Status);
}
//VolatileStatus Conditions
if (effects.VolatileStatus != ConditionID.none)
{
target.SetVolatileStatus(effects.VolatileStatus);
}
yield return(ShowStatusChanges(source));
yield return(ShowStatusChanges(target));
}
private void LaunchAttack(float holdDuration)
{
if (selectedMove != null && selectedMove.target != null) //networkView.isMine &&
{
GameObject move = (GameObject)Instantiate(Resources.Load("Moves/" + selectedMove.name));
move.transform.parent = GameObject.Find("Moves").transform;
MoveTarget source = new MoveTarget(gameObject, transform.position);
DamageManager damageManagerScript = (DamageManager)move.AddComponent(typeof(DamageManager));
damageManagerScript.SetParameters(selectedMove.name, source, selectedMove.target);
Move moveScript = (Move)move.AddComponent(typeof(Move));
float freezeDuration = moveScript.SetMoveParameters(selectedMove.name, source, selectedMove.target);
//float freezeDuration = selectedMove.info.Duration;
Invoke("Unfreeze", freezeDuration); // Even the non-immobilizing moves need to "unfreeze" the animation.
if (freezeDuration > 0)
{
float maxAttackAnimSpeed = 0.2f;
/*if(attackAnimHalfDuration.ContainsKey(selectedMove.info.attackCategory))
* {
* float ratio = attackAnimHalfDuration[selectedMove.info.attackCategory] / freezeDuration / 2;
* anim.speed = Mathf.Min(ratio, maxAttackAnimSpeed);
* }
* else*/
{
anim.speed = maxAttackAnimSpeed;
}
}
}
}
/// <summary>
/// Stores the caster and the target of the move.
/// This method has to be called directly upon creation of this DamageManager component.
/// </summary>
/// <param name="_moveName">Move's name.</param>
/// <param name="_caster">Caster's MoveTarget.</param>
/// <param name="_target">Target's MoveTarget.</param>
public void SetParameters(string _moveName, MoveTarget _caster, MoveTarget _target)
{
if (!Attackdex.move.ContainsKey(_moveName))
{
Debug.LogError("The move '" + _moveName + "' is not registered in the Attackdex.");
}
else
{
moveName = _moveName;
moveInfo = Attackdex.move[moveName];
if (moveInfo.TargetKind == MoveTargetKind.Single)
{
timeBeforeDamage = moveInfo.DelayBeforeDamage;
}
}
caster = _caster;
target = _target;
if (moveInfo.TargetKind != MoveTargetKind.Single) // We assume that those spells can't deal damage to several targets.
{
foreach (ParticleSystem ps in this.GetComponentsInChildren <ParticleSystem>())
{
if (ps.name == "MainParticle")
{
TransmitCollisionMessage script = ps.gameObject.AddComponent <TransmitCollisionMessage>();
script.SetManager(this.GetComponent <DamageManager>());
}
}
}
}
public void NewPos(int side)
{
float GX = (float)Random.Range(-2, 2);
if (moveTo != null)
{
if (GX > moveTo.X)
{
xForce *= 1.5f;
}
else if (GX < moveTo.X)
{
xForce /= 1.5f;
}
}
moveTo = new MoveTarget(GX, transform.position.x);
if (side == 1)
{
GX = (float)Random.Range(-2, 0);
moveTo = new MoveTarget(GX, transform.position.x);
}
else if (side == 2)
{
GX = (float)Random.Range(0, 2);
moveTo = new MoveTarget(GX, transform.position.x);
}
}
IEnumerator RunMoveEffects(MoveEffects Effects, Pokemon source, Pokemon target, MoveTarget moveTarget)
{
var effects = Effects;
if (effects.Boosts != null)
{
if (moveTarget == MoveTarget.Self)
{
source.ApplyBoosts(effects.Boosts);
}
else
{
target.ApplyBoosts(effects.Boosts);
}
}
if (effects.Status != StatusID.none)
{
target.SetStatus(effects.Status);
}
if (effects.VolatileStatus != StatusID.none)
{
target.SetVolatileStatus(effects.VolatileStatus);
}
yield return(ShowStatChanges(source));
yield return(ShowStatChanges(target));
}
public SlideTransition(float time, FourWayDirection direction, MoveTarget moveTarget, SlideTransitionInterpolator interpolator)
{
this.Time = time;
this.MoveDirection = direction;
this.MoveTarget = moveTarget;
this.Interpolator = interpolator;
}
public SelectedMove(string _name)
{
name = _name;
target = null;
info = Attackdex.move[name];
isDone = false;
}
protected override void Decode()
{
PlayerID = _incoming.ReadInt32();
id = _incoming.ReadInt32();
Quantity = _incoming.ReadInt32();
Slot = _incoming.ReadInt32();
To = (MoveTarget)_incoming.ReadByte();
From = (MoveTarget)_incoming.ReadByte();
}
/// <summary>
/// Sets the move parameters.
/// </summary>
/// <param name="moveName">Move name.</param>
/// <param name="source">Source.</param>
/// <param name="target">Target.</param>
public float SetMoveParameters(string moveName, MoveTarget source, MoveTarget target)
{
float animationFreezeDuration = 0f;
if (!Attackdex.move.ContainsKey(moveName))
{
Debug.LogError("The move '" + moveName + "' is not registered in Attackdex");
}
else
{
this.Info = Attackdex.move[moveName];
this.IsRunning = true;
this.Source = source;
this.Target = target;
// Positions the Attack gameobject
this.transform.position = this.GetPosition();
this.transform.forward = source.GameObject.transform.forward;
// Starts the FX
this.ParticleSystems = this.GetComponentsInChildren <ParticleSystem>().ToList();
//this.PlayFX();
// Retrieves the MainParticle
Transform mainParticleTransform = transform.Find("MainParticle");
if (mainParticleTransform == null)
{
Debug.LogError("The move " + moveName + " has no MainParticle child.");
}
else
{
this.MainParticleSystem = (ParticleSystem)mainParticleTransform.gameObject.GetComponent(typeof(ParticleSystem));
if (this.MainParticleSystem == null)
{
Debug.LogError("The MainParticle of the move " + moveName + " contains no ParticleSystem component.");
}
else
{
// If the move should not stop the attack animation, then we don't want to freeze it and we return 0.
if (this.Info.IsImmobilizingCaster)
{
animationFreezeDuration = this.MainParticleSystem.duration;
if (animationFreezeDuration > 2)
{
Debug.LogError("The MainParticle of " + moveName + " lasts way too long and may cause animation issues.");
}
}
}
}
}
return(animationFreezeDuration);
}
void SetState(State newState, float initialWaitedTime = 0.0f)
{
waitedTime = initialWaitedTime;
// Stop cancelling special.
cancelSpecial = false;
// Disable input if not idle.
if (state == State.Idle && newState != State.Idle)
{
// store the old value (only the Idle state contains the "real" value)
inputEnabledCached = inputEnabled;
}
if (newState != State.Idle)
{
inputEnabled = false;
}
else
{
// restore the old value
inputEnabled = inputEnabledCached;
}
state = newState;
switch (state)
{
case State.Moving:
{
currentMove = moves[0];
break;
}
case State.CompletingMove:
{
// Set speed and move delta.
speed = 0.0f;
moveDelta = new Vector3(0.0f, moveDelta.y, 0.0f);
break;
}
case State.Idle:
case State.CompletingTurn:
case State.CompletingFollow:
{
// Set speed, move delta and rotation speed.
speed = 0.0f;
moveDelta = new Vector3(0.0f, moveDelta.y, 0.0f);
rotateSpeed = 0.0f;
break;
}
}
}
public void StartUpActions()
{
this.hideCoroutine = StartCoroutine(HideAfterTime(timeToHide));
// this.audioController.Play();
MoveTarget moveTarget = GetComponent <MoveTarget>();
if (moveTarget != null)
{
moveTarget.enabled = true;
}
}
public async Task GetMoveTargetResourceAsyncIntegrationTest()
{
// assemble
PokeApiClient client = new PokeApiClient();
// act
MoveTarget moveTarget = await client.GetResourceAsync <MoveTarget>(1);
// assert
Assert.True(moveTarget.Id != default(int));
}
private void RaiseOrLower()
{
if (Input.GetKey(KeyCode.Q))
{
MoveTarget.Translate(Vector3.down * speed * Time.deltaTime, Space.World);
}
else if (Input.GetKey(KeyCode.E))
{
MoveTarget.Translate(Vector3.up * speed * Time.deltaTime, Space.World);
}
}
public Move(string name, PokemonType type, int?power, DamageType?damageType, int accuracy, MoveTarget target, int basePP, int maxPossiblePP, int priority, int criticalHitStage)
{
Name = name;
Type = type;
Power = power;
DamageType = damageType;
Accuracy = accuracy;
Target = target;
BasePP = basePP;
MaxPPLimit = maxPossiblePP;
Priority = priority;
CriticalHitStage = criticalHitStage;
}
void SetState(State newState, float initialWaitedTime = 0.0f)
{
waitedTime = initialWaitedTime;
state = newState;
// Stop cancelling special.
cancelSpecial = false;
// Disable input if not idle.
if (state != State.Idle)
{
Debug.Log(state);
inputEnabled = false;
}
else
{
inputEnabled = true;
}
switch (state)
{
case State.Moving:
{
currentMove = moves[0];
break;
}
case State.CompletingMove:
{
// Set speed and move delta.
speed = 0.0f;
moveDelta = new Vector3(0.0f, moveDelta.y, 0.0f);
break;
}
case State.Idle:
case State.CompletingTurn:
case State.CompletingFollow:
{
// Set speed, move delta and rotation speed.
speed = 0.0f;
moveDelta = new Vector3(0.0f, moveDelta.y, 0.0f);
rotateSpeed = 0.0f;
break;
}
}
}
private void MoveDestination(MoveTarget moveTarget, ActorAI actor)
{
float pas = this.currentSpeedLevel * RandomSpeedFactor * Time.deltaTime;
Vector3 destination = Vector3.zero;
switch (moveTarget)
{
case MoveTarget.Item:
destination = ItemTargetDestination;
break;
case MoveTarget.Map:
destination = MapDestination;
break;
case MoveTarget.Opponent:
destination = OpponentTargetDestination;
break;
default:
break;
}
destination.y = FloorYOffset;
NavMeshPath path = new NavMeshPath();
NavMesh.CalculatePath(actor.transform.position, destination, NavMesh.AllAreas, path);
Vector3[] pathpoints;
if (path.status == NavMeshPathStatus.PathComplete)
{
pathpoints = new Vector3[path.corners.Length];
int nbr = path.GetCornersNonAlloc(pathpoints);
if (nbr > PathVectorIndex)
{
destination = pathpoints[PathVectorIndex];
}
}
destination.y = FloorYOffset;
Vector3 nouvellePosition = Vector3.MoveTowards(actor.transform.position, destination, pas);
Vector3 mouvement = new Vector3(nouvellePosition.x - actor.transform.position.x, nouvellePosition.y - actor.transform.position.y, nouvellePosition.z - actor.transform.position.z);
float angle = Mathf.Atan2(mouvement.x, mouvement.z) * Mathf.Rad2Deg;
actor.transform.position = nouvellePosition;
actor.transform.rotation = Quaternion.AngleAxis(angle, Vector3.up);
}
public void RocketingDone()
{
Rocketing = false;
BirdPowerup.SetActive(false);
if (JustMovedRight == true)
{
GoTarget = MoveTarget.topRight;
}
else if (JustMovedRight == false)
{
GoTarget = MoveTarget.topLeft;
}
}
// attaches the MoveTarget component to the GameObject, configuring its angle of movement and speed.
private void AttachMoveComponent(GameObject obj, float angle)
{
MoveTarget moveTarget = obj.AddComponent(typeof(MoveTarget)) as MoveTarget;
// script must be disabled. the target itself will enable it after appearing.
moveTarget.enabled = false;
float totalAngle = Random.Range(0, maximumMovingAngle);
float startAngle;
float endAngle;
if (angle - lowerAngle < (totalAngle / 2) && higherAngle - angle < (totalAngle / 2))
{
// the total angle is constrained by both limit angles.
// set the angles to be as big as the difference between the limits and its actual angle.
endAngle = angle - lowerAngle;
startAngle = higherAngle - angle;
}
else if (angle - lowerAngle < (totalAngle / 2))
{
// the total angle is only constrained by the lower angle.
// set the start angle to be the difference between the angle and the lower angle, and add the remaining
// to the other half of the total angle for the end angle.
endAngle = angle - lowerAngle;
startAngle = ((totalAngle / 2) - (angle - lowerAngle)) + (totalAngle / 2);
}
else if (higherAngle - angle < (totalAngle / 2))
{
// the total angle is only constrained by the higher angle.
// set the end angle to be the difference between the angle and the higher angle, and add the remaining
// to the other half of the total angle for the start angle.
endAngle = ((totalAngle / 2) - (higherAngle - angle)) + (totalAngle / 2);
startAngle = higherAngle - angle;
}
else
{
// the total angle is not constrained by any angle.
// simply set the half of the total angle into the start and end angles of the script.
startAngle = totalAngle / 2;
endAngle = totalAngle / 2;
}
moveTarget.startAngle = startAngle;
moveTarget.endAngle = endAngle;
// Debug.Log("A: " + angle + " LA: " + lowerAngle + " HA: " + higherAngle + " TA: " + totalAngle + " SA: " + startAngle + " EA: " + endAngle);
moveTarget.speed = movingTargetSpeed;
}
private void UpdateMovement()
{
float translation = Input.GetAxis("Vertical") * speed;
float straffe = Input.GetAxis("Horizontal") * speed;
translation *= Time.deltaTime;
straffe *= Time.deltaTime;
Vector3 moveDir = new Vector3(straffe, 0, translation);
MoveTarget.Translate((RotTarget.rotation * moveDir).SetY(0), Space.World);
if (Input.GetKeyDown("escape"))
{
Cursor.lockState = CursorLockMode.None;
}
}
/*
* Metodo encargado de gestionar los efectos secundarios de los ataques, como bajadas de stats o estados alterados
*/
IEnumerator RunMoveEffects(MoveEffects effects, Pokemon source, Pokemon target, MoveTarget moveTarget)
{
//Boosts
if (effects.Boosts != null) //de momento solo contemplamos los ataques de estado que implican boosts
{
if (moveTarget == MoveTarget.Self)
{
source.ApplyBoosts(effects.Boosts);
}
else if (moveTarget == MoveTarget.Foe)
{
target.ApplyBoosts(effects.Boosts);
}
}
//Status conditions
if (effects.Status != ConditionID.none)
{
//TODO: Estamos suponiendo que el target del status es el enemigo y no uno mismo
EffectResult result = target.SetStatus(effects.Status);
if (result == EffectResult.AlreadyOne)
{
yield return(dialogBox.TypeDialog($"{source.CurrentMove.Base.Name} had no effect!"));
}
else if (result == EffectResult.Inmune)
{
yield return(dialogBox.TypeDialog($"{target.Base.Name} it's inmune!"));
}
}
//Volatile Status conditions
if (effects.VolatileStatus != ConditionID.none)
{
//TODO: Estamos suponiendo que el target del status es el enemigo y no uno mismo
target.SetVolatileStatus(effects.VolatileStatus);
}
//Mostramos en el dialogo las bajadas y subidas de stats de ambos pokemons
yield return(ShowStatusChanges(source));
yield return(ShowStatusChanges(target));
}
void NextTarget()
{
CancelInvoke();
MoveTutorial.StartMoving();
foreach (Falling go in fallingThings)
{
if (go != null)
{
go.GetComponent <Falling>().StopAimAssist();
}
}
if (GoTarget == MoveTarget.topLeft)
{
GoTarget = MoveTarget.botLeft;
return;
}
else if (GoTarget == MoveTarget.botLeft)
{
GoTarget = MoveTarget.topRight;
JustMovedRight = true;
jump = false;
return;
}
else if (GoTarget == MoveTarget.topRight)
{
GoTarget = MoveTarget.botRight;
return;
}
else if (GoTarget == MoveTarget.botRight)
{
jump = false;
JustMovedRight = false;
GoTarget = MoveTarget.topLeft;
return;
}
}
public void MoveTo(Vector3 destination, float minDistance = 0.0f, Action onComplete = null, float onCompleteDelay = 0.0f,
float moveDelay = 0.0f, bool cancelSpecial = true, float speedMultiplier = 1.0f, float rotationSpeedMultiplier = 1.0f, Vector3?turnToWhileCompleting = null)
{
MoveTarget move = new MoveTarget()
{
destination = destination,
minDistance = minDistance,
onComplete = onComplete,
onCompleteDelay = onCompleteDelay,
moveDelay = moveDelay,
cancelSpecial = cancelSpecial,
speedMultiplier = speedMultiplier,
rotationSpeedMultiplier = rotationSpeedMultiplier,
turnToWhileCompleting = turnToWhileCompleting
};
moves.Add(move);
UpdateState();
}
public void AnimateDestruction()
{
disappearSound.Play();
Material mat = this.targetRigidbody.GetComponent <Renderer>().material;
// StandardShaderUtils.ChangeRenderMode(mat, StandardShaderUtils.BlendMode.Transparent);
mat.SetFloat("_Alpha", 0.8f);
if (this.compass != null)
{
this.compass.DeleteTarget(this.gameObject);
}
if (hideCoroutine != null)
{
StopCoroutine(hideCoroutine);
}
if (sonarTrigger != null)
{
sonarTrigger.GetComponent <NearbySonarElement>().sonarElement.StopSound();
Destroy(sonarTrigger);
}
DisableColliders();
Light light = GetComponentInChildren <Light>();
light.enabled = false;
MoveTarget moveTarget = GetComponent <MoveTarget>();
if (moveTarget != null)
{
moveTarget.enabled = false;
}
this.targetRigidbody.isKinematic = false;
this.targetRigidbody.useGravity = true;
this.targetRigidbody.AddRelativeForce(Vector3.right * 5f, ForceMode.Impulse);
// Destroy after 3 seconds.
StartCoroutine((this.gameObject.AddComponent(typeof(DestructionScheduler)) as DestructionScheduler).DestroyAfterTime(3f));
}
// Use this for initialization
void Start()
{
Roof = FindObjectOfType <SpawnRoof>();
GoTarget = MoveTarget.topRight;
score = FindObjectOfType <Score>();
Background = FindObjectOfType <ScrollingBackground>();
MoveTutorial = FindObjectOfType <MoveTutorialDown>();
anim = GetComponent <Animator>();
cube = FindObjectsOfType <TutorialCube>();
anim.speed = 0;
if (score.DoubleCoins == true)
{
DoubleCoinsUI.SetActive(true);
}
else
{
DoubleCoinsUI.SetActive(false);
}
}
//on state move update
public void On_Move_Update( float t )
{
//if target lost by some reason, stop, change to idle
if (moveTarget == null)
{
Idle();
return;
}
//get target position
Vector3 targetPos = Vector3.zero;
//if target is a position, just use the position as target
if (moveTarget.type == MoveTarget.MoveTargetType.Position)
{
targetPos = moveTarget.targetPosition;
}
//if target is a character, adjust a offset to the target, might evaluate by weapon/skill/etc
else if (moveTarget.type == MoveTarget.MoveTargetType.Character)
{
Vector3 _dir = GetDirectionToCharacter(moveTarget.targetObject, Vector3.zero);
Vector3 offset = new Vector3( characterData.attackRange * (_dir.x > 0f ? -1 : 1), 0, 0);
targetPos = moveTarget.targetObject.transform.position + offset;
}
//get the distance to target
Vector3 dir = targetPos - transform.position;
float dis = dir.magnitude;
//if readlly near to target
if (dis <= 3f)
{
//fix the position
targetPos.z = 0f;
transform.position = targetPos;
//if reach target position, go to idle
if (moveTarget.type == MoveTarget.MoveTargetType.Position)
{
moveTarget = null;
Idle();
}
//if reach target character, then attack it
else if (moveTarget.type == MoveTarget.MoveTargetType.Character)
{
Attack();
}
return;
}
//move the character position by speed * time
transform.position = transform.position + dir.normalized * characterData.moveSpeed * Time.deltaTime;
//adjust character face to direct
{
float s = dir.x > 0f ? 1 : -1;
if (!characterData.defaultFaceToRight)
s = -s;
Vector3 scale = spriteRenderer.localScale;
scale.x = Mathf.Abs(scale.x) * s;
spriteRenderer.localScale = scale;
}
}
public MoveArchetype(string name, MoveType moveType, ElementType elementType,
int maxPp, int power, int accuracy, DurationType durationType, int turnDuration, BattleEffectStageEffect battleEffectStageEffect,
EffectType effectType, EffectStart effectStart, MoveTarget moveTarget,
BattleEffectType battleEffectType, string battleEffectText)
{
Name = name;
MoveType = moveType;
ElementType = elementType;
MaxPP = maxPp;
Power = power;
Accuracy = accuracy;
TurnDuration = turnDuration;
BattleEffectStageEffect = battleEffectStageEffect;
EffectType = effectType;
EffectStart = effectStart;
MoveTarget = moveTarget;
DurationType = durationType;
BattleEffectType = battleEffectType;
BattleEffectText = battleEffectText;
}
//find a enemy as a target
public MoveTarget SearchEnemy()
{
//if we have a target object already, just return it
if (moveTarget != null && moveTarget.type == MoveTarget.MoveTargetType.Character )
return moveTarget;
MoveTarget tmpTarget = null;
//find the nearest enemy in search range
foreach (BattleCharacterController bcc in characters)
{
//not same category type, and not myself
if (bcc.characterData.isPlayer != characterData.isPlayer && bcc != this)
{
float dis = GetDistanceToCharacter(bcc, Vector3.zero);
if (dis < characterData.enemySearchRange)
{
if (tmpTarget == null)
tmpTarget = new MoveTarget(bcc);
else
{
float lastTargetDis = GetDistanceToCharacter(tmpTarget.targetObject, Vector3.zero);
if (dis < lastTargetDis)
tmpTarget.targetObject = bcc;
}
}
}
}
return tmpTarget;
}
public void RocketState()
{
GoTarget = MoveTarget.rocket;
}
public void SetTarget(MoveTarget _target)
{
target = _target;
}
//moved this out of Runmove as there will hopefully be a lot of stats changes in here in the future
IEnumerator RunMoveEffects(MoveEffects effects, Creature source, Creature target, MoveTarget moveTarget)
{
//var effects = move.Base.Effects;
//stat boosting
if (effects.Boosts != null)
{
//see if the move is targeting what creature, self boost or decline on enemy
if (moveTarget == MoveTarget.self)
{
source.ApplyBoosts(effects.Boosts);
}
else
{
target.ApplyBoosts(effects.Boosts);
}
}
//check if this move will cause a status condition
if (effects.Status != ConditionsID.none)
{
target.SetStatus(effects.Status);
}
//check if this move will cause a Volitilestatus condition
if (effects.VolitileStatus != ConditionsID.none)
{
target.SetVolitileStatus(effects.VolitileStatus);
}
//now we apply the boost we show the status function to either
yield return(ShowStatusChanges(source));
yield return(ShowStatusChanges(target));
}
//these On_xxx_xxx function called by BehaviourController with SendMessage
//on state idle update
public void On_Idle_Update(float dt)
{
//we are idle, try to find a enemy
MoveTarget tmp = SearchEnemy();
//if got one
if ( tmp != null )
{
float dis = GetDistanceToCharacter(tmp.targetObject, Vector2.zero);
float yDis = Mathf.Abs(tmp.targetObject.transform.position.y - transform.position.y);
//if we can attack enemy immediatally? if yes, attack it, if no move to it
if ( dis < characterData.attackRange && yDis < characterData.attackRange * 0.2f )
{
moveTarget = tmp;
Attack();
}
else
Move(tmp);
}
}
//change character state to move, and set the move target
public void Move( MoveTarget target )
{
moveTarget = target;
behaviourController.ChangeState("Move");
}
public void HitRoof()
{
GoTarget = MoveTarget.falling;
}
