void CheckForHit(EnemyController en, ASCollCheck ac)
{
//AngleRanged
if (en.stats.health > 0.0f)
{
float angle = ac.conicAngle / 2;
Vector3 tDelta = en.gameObject.transform.position - transform.position;
float tAngle = Vector3.Angle(transform.forward, tDelta);
if (tAngle < 0)
{
tAngle *= -1;
}
if (tAngle < angle)
{
if (Vector3.Distance(transform.position, en.gameObject.transform.position) < ac.range)
{
//we have a hit
//AngleRanged
//Damage
//RUNGY, for chained hits you will need to change this to use a hit index
float damage1 = ac.spawns[0].lowValue;
float damage2 = ac.spawns[0].highValue;
float damage = UnityEngine.Random.Range(damage1, damage2);
en.stats.health -= damage;
Transform tm = (Transform)Instantiate(hitReport, (en.gameObject.transform.position + new Vector3(0.0f, 1.6f, 0.0f)), Quaternion.identity);
tm.gameObject.SetActive(true);
Hit tmHit = tm.GetComponent <Hit>();
tmHit.text = Mathf.RoundToInt(damage).ToString();
Transform ph = (Transform)Instantiate(particleHit, (en.gameObject.transform.position + new Vector3(0.0f, 1.5f, 0.0f)), Quaternion.identity);
ph.transform.LookAt(Camera.main.transform.position);
ph.transform.position += (ph.transform.forward * 2.0f);
ph.gameObject.SetActive(true);
for (int spawnIndex = 0; spawnIndex < ac.spawns.Length; spawnIndex++)
{
if (ac.spawns[spawnIndex].prefab != null)
{
Transform tempSpawn = (Transform)Instantiate(ac.spawns[spawnIndex].prefab);
Vector3 tempPos = tempSpawn.position;
Quaternion tempRot = tempSpawn.rotation;
if (ac.spawns[0].parent == ParentType.Self)
{
tempSpawn.parent = transform;
}
else if (ac.spawns[0].parent == ParentType.Target)
{
tempSpawn.parent = en.transform;
}
tempSpawn.localPosition = tempPos;
tempSpawn.localRotation = tempRot;
if (ac.spawns[0].parent == ParentType.None)
{
tempSpawn.parent = null;
tempSpawn.position = transform.position;
}
}
}
}
}
}
return;
}
// Update is called once per frame
void LateUpdate()
{
if (!game.paused)
{
//The Update logic does:
//
// Checks whether or not mecanim told us to check for a hit
// Mecanim is great for sending us this info because it can play animations at any speed, rather than calculate the time
// we use it to tell us the appropriate hit time
//
// Get UI input from keyboard, and mouse clicks
//
// Tells mecanim what animation we should be playing based on variables such as idling, pain or death
//
// Handle movement and direction
////////////////////////////////
/// ABILITY SYSTEM
////////////////////////////////
if (stats.hitCheck) //hitCheck is a boolean variable, it gets set by mecanim attack states, if mecanim set it...then we need to do hit checks right now
{
wasAttacking = true;
//RUNGY
//code for chained attacks should go here
//animator.SetInteger("AttackIndex", abilities[abilityIndex].ability.animIndex);
///RUNGY you have to setup for chained attacks HERE
for (int collisionIndex = 0; collisionIndex < abilities[abilityIndex].ability.collChecks.Length; collisionIndex++)
{
if (ahc < 1)
{
ahc = 1; //we may have a "double pulse" coming from Mecanim so...
}
ASCollCheck abilColl = new ASCollCheck();
abilColl = abilities[abilityIndex].ability.collChecks[collisionIndex];
if (abilColl.checkType == CollCheckType.angleRange)
{
//ANGLE RANGE which can be used for any angle/range including radial attacks
for (int i = 0; i < game.enemies.Length; i++) //loop throught the enemies
{
CheckForHit(game.enemies[i], abilColl);
}
ahc -= 1; // some abilities have multiple checks, so when we use an ability, we set ahc to the number of hits in the ability (combo punches for example)
}
if (abilColl.checkType == CollCheckType.worldPoint)
{
Transform tm = (Transform)Instantiate(abilColl.spawns[0].prefab);
Vector3 tempPos = tm.position;
Quaternion tempRot = tm.rotation;
tm.parent = transform;
tm.localPosition = tempPos;
tm.localRotation = tempRot;
if (abilColl.spawns[0].parent == ParentType.Self)
{
tm.parent = transform;
}
}
}
stats.hitCheck = false; // we are done checking, reset the hitCheck bool
//targetedEnemy = null;
}
if (!useThird && !mounted)
{
//if the mouse pointer is over an enemy, then set aim vectors to do aim blending and look at that enemy
//but only if we are "somewhat" facing that enemy
float aimX2 = 0.998f;
float aimY2 = 0.0f;
if (targetedEnemy)
{
Vector3 tempDelta = (targetedEnemy.position - transform.position).normalized;
aimY2 = tempDelta.y;
Vector3 flatdelta = new Vector3(tempDelta.x, 0.0f, tempDelta.z);
aimX2 = Vector3.Distance(Vector3.zero, flatdelta);
flatdelta = flatdelta.normalized;
if (Vector3.Dot(transform.forward, flatdelta) < 0.9f) //we need to be "somewhat" facing the target direction
{
aimX2 = 0.998f;
aimY2 = 0.0f;
}
}
aimX = Mathf.Lerp(aimX, aimX2, Time.deltaTime * 20.0f);
aimY = Mathf.Lerp(aimY, aimY2, Time.deltaTime * 20.0f);
animator.SetFloat("AimY", aimY);
animator.SetFloat("AimX", aimX);
}
else if (useThird)
{
animator.SetFloat("AimY", aimY);
animator.SetFloat("AimX", aimX);
}
//////////////////////
//
// ATTACKS UI
//
//////////////////////
///
////Right MOUSE BUTTON
///
//////////////////////
if (!Input.GetKey(KeyCode.LeftAlt)) // if we're changing camera transforms, do not use "USE"
{
if (Input.GetMouseButton(1)) // are we using the right button?
{
if (rightButtonDown != true) // was it previously down? if so we are already using "USE" bailout (we don't want to repeat attacks 800 times a second...just once per press please
{
abilityUse = true;
abilityIndex = abilityKeys[0];
}
}
else
{
rightButtonDown = false;
}
}
///////////////////
///
/// KEYBOARD
///
///////////////////
if (Input.GetKey(KeyCode.A))
{
if (!keyHeld)
{
abilityUse = true;
abilityIndex = abilityKeys[1];
keyHeld = true;
}
}
else if (Input.GetKey(KeyCode.S))
{
if (!keyHeld)
{
abilityUse = true;
abilityIndex = abilityKeys[2];
keyHeld = true;
}
}
else if (Input.GetKey(KeyCode.D))
{
if (!keyHeld)
{
abilityUse = true;
abilityIndex = abilityKeys[3];
keyHeld = true;
}
}
else if (Input.GetKey(KeyCode.F))
{
if (!keyHeld)
{
abilityUse = true;
abilityIndex = abilityKeys[4];
keyHeld = true;
}
}
else if (Input.GetKey(KeyCode.G))
{
if (!keyHeld)
{
abilityUse = true;
abilityIndex = abilityKeys[5];
keyHeld = true;
}
}
else if (Input.GetKey(KeyCode.H))
{
if (!keyHeld)
{
abilityUse = true;
abilityIndex = abilityKeys[6];
keyHeld = true;
}
}
else if (Input.GetKey(KeyCode.J))
{
if (!keyHeld)
{
abilityUse = true;
abilityIndex = abilityKeys[7];
keyHeld = true;
}
}
else
{
keyHeld = false;
}
if (abilityUse && abilities[abilityIndex].ability.cost == CostType.energy)
{
if (stats.energy > abilities[abilityIndex].ability.costValue)
{
stats.energy -= abilities[abilityIndex].ability.costValue;
}
else
{
abilityUse = false;
}
}
animator.SetInteger("WeaponState", abilities[abilityIndex].ability.weaponState);
animator.SetInteger("Ability", abilityIndex);
//Abilities that just spawn are check type "none" and get processed after targeting code
if (abilityUse && abilities[abilityIndex].ability.collChecks[0].checkType != CollCheckType.None)
{
wasAttacking = true;
if (targetedEnemy)
{
EnemyController ec = targetedEnemy.GetComponentInChildren <EnemyController>();
if (ec)
{
if (ec.stats.health <= 0.0f)
{
targetedEnemy = null;
}
}
}
if (!mounted && !useThird)
{
Vector3 oldAP = attackPlane.transform.position;
Quaternion oldARot = attackPlane.transform.rotation;
if (targetedEnemy)
{
//move the attack plane to the enemies position + 1 meter high
attackPlane.transform.position = targetedEnemy.position + (transform.up);
Vector3 tempV3 = Camera.main.transform.position;
tempV3.y = targetedEnemy.position.y; //attackplane should only face camera direction not tilt at all
attackPlane.transform.up = Camera.main.transform.up;
attackPlane.transform.forward = Camera.main.transform.forward;
}
attackPlane.enabled = true;
ray = Camera.main.ScreenPointToRay(Input.mousePosition); //get a ray that goes from the camera -> "THROUGH" the mouse pointer - > and out into the scene
if (attackPlane.Raycast(ray, out hit, 500.0f))
{
attackPos = hit.point; // establish the point that we hit with the mouse
attackPos.y = transform.position.y; //use our height for the LOOKAT function, so we stay level and dont lean the character in weird angles
//check if we are at idle
//check ability for useWhenRunning
//determine if we should run backwards,forwards or sideways
//if we are running
//and if we attack to the sides or behind us
//use appropriate run animation and fire whilst running
//set attackTime counter so we can exit aiming while running
//AND look forward again
if (velocityPS < 0.1)
{
lookAtPos = transform.position + (attackPos - transform.position).normalized * 0.3f; //lookat the target using this vector
movementTarget.transform.position = lookAtPos;
}
attackDelta = hit.point; //we need the Vector delta which is an un-normalized direction vector
animator.SetTrigger("Use"); //tell mecanim to do the attack animation(trigger)
ahc = abilities[abilityIndex].ability.collChecks.Length; //ahc=ability hit counter, used for animations that have multiple hits like combos
//animator.SetBool("Idling", true);//stop moving
rightButtonDown = true; //right button was not down before, mark it as down so we don't attack 800 frames a second
wasAttacking = true; //some mecanims will actually move us past the target, so we want to keep looking in one direction instead of spinning wildly around the target
}
attackPlane.enabled = false;
attackPlane.transform.position = oldAP;
attackPlane.transform.rotation = oldARot;
}
else if (mounted)
{
ray.origin = game.mouseCam.transform.position;
ray.direction = (aimPoint.transform.position - ray.origin).normalized;
mountedPlane.enabled = true;
if (mountedPlane.Raycast(ray, out hit, 500.0f))
{
attackPos = hit.point; // establish the point that we hit with the mouse
attackPos.y = transform.position.y; //use our height for the LOOKAT function, so we stay level and dont lean the character in weird angles
attackDelta = hit.point; //we need the Vector delta which is an un-normalized direction vector
animator.SetTrigger("Use"); //tell mecanim to do the attack animation(trigger)
ahc = abilities[abilityIndex].ability.collChecks.Length; //ahc=ability hit counter, used for animations that have multiple hits like combos
animator.SetBool("Idling", true); //stop moving
rightButtonDown = true; //right button was not down before, mark it as down so we don't attack 800 frames a second
wasAttacking = true; //some mecanims will actually move us past the target, so we want to keep looking in one direction instead of spinning wildly around the target
}
mountedPlane.enabled = false;
}
else if (useThird)
{
targetedEnemy = null;
ray.origin = game.mouseCam.transform.position;
ray.direction = game.mouseCam.transform.forward;
attackPos = (ray.origin + ray.direction * 1.0f);
//lookAtPos = (transform.position + transform.forward).normalized * 0.3f;//lookat the target using this vector
//movementTarget.transform.position = lookAtPos;
attackDelta = attackPos; //we need the Vector delta which is an un-normalized direction vector
animator.SetTrigger("Use"); //tell mecanim to do the attack animation(trigger)
ahc = abilities[abilityIndex].ability.collChecks.Length; //ahc=ability hit counter, used for animations that have multiple hits like combos
//animator.SetBool("Idling", true);//stop moving
rightButtonDown = true; //right button was not down before, mark it as down so we don't attack 800 frames a second
wasAttacking = true; //some mecanims will actually move us past the target, so we want to keep looking in one direction instead of spinning wildly around the target
}
// AIM ASSIST
// DOT each enemy with the attack vector
// the one with the highest dot value will be our vector
// only values above .85 should be considered
// attackDelta IS a hit point for missiles
// attackPos IS locked to player's y(height)for beams
float closestOne = -2.0f;
Vector3 clickVector = (attackPos - transform.position).normalized;
if (useThird || mounted)
{
clickVector = (aimPoint.transform.position - game.mouseCam.transform.position).normalized;
}
Vector3 eVector3;
if (!targetedEnemy)
{
for (int i = 0; i < game.enemies.Length; i++)
{
if (game.enemies[i].stats.health > 0.0f)
{
eVector3 = (game.enemies[i].transform.position - transform.position).normalized;
if (Vector3.Dot(clickVector, eVector3) > closestOne)
{
closestOne = Vector3.Dot(clickVector, eVector3);
if (Vector3.Dot(clickVector, eVector3) > 0.85f)
{
//we use a secondary targeted type known as aimAssist
//we do this because forcing data into targetedEnemy would screw mouse over behavior badly
aimAssist = game.enemies[i].transform;
attackTarget.transform.position = aimAssist.position;
}
}
}
}
}
if (targetedEnemy)
{
attackTarget.transform.position = targetedEnemy.position;
}
else
{
attackTarget.transform.position = attackPos;
}
abilityUse = false;
}
else
{
//the check type = none...process the ability which in all likeliness is just a spawner
if (abilityUse && abilities[abilityIndex].ability.collChecks[0].checkType == CollCheckType.None)
{
animator.SetTrigger("Use");
wasAttacking = true;
}
abilityUse = false;
}
//ATTACKS reset right mouse button
if (Input.GetMouseButtonUp(1)) //ok, we can clear the right mouse button and use it for the next attack
{
if (rightButtonDown == true)
{
rightButtonDown = false;
}
}
if (!mounted)
{
/// JUMPING start
foundFloor = false; ///declaring it here because we use it elsewhere as well
//jump key pressed
if (Input.GetKey(KeyCode.Space) && !jumping && !falling)
{
//RUNGY ADD THIS IN loop througbh the ability bar, do we have a jump?
Jump();
}
if (jumping)
{
lookAtPos.y = transform.position.y;
if (Vector3.Distance(movementTarget.transform.position, transform.position) < 0.5f)
{
//movementTarget.transform.position = transform.position;
lookAtPos = transform.position + (transform.forward * 0.2f);
}
}
if (!jumping)
{
if (!wasAttacking)
{
if (Vector3.Distance(lookAtPos, transform.position) > 0.5f)
{
animator.SetBool("Idling", false);
animator.SetFloat("MoveType", moveType);
}
else
{
animator.SetBool("Idling", true);
movementTarget.enabled = false;
lookAtPos = transform.position + (transform.forward * 0.2f);
}
}
else
{ //this level of else means wasAttacking is true
//as long aas the ability is not a use moving type, we can look at our target
if (!abilities[abilityIndex].ability.useMoving)
{
lookAtPos = attackPos;
lookAtPos.y = transform.position.y;
movementTarget.transform.position = lookAtPos;
if (Vector3.Distance(attackPos, transform.position) < 0.5f)
{
animator.SetBool("Idling", true);
movementTarget.enabled = false;
movementTarget.transform.position = transform.position;
lookAtPos = transform.position + transform.forward;
}
}
}
}
//////////////////////////////
//GROUND DETECTION
//////////////////////////////
ray.direction = transform.up * -1; //make a downward ray, negative "up" is "down"
ray.origin = transform.position + transform.up; //one meter up from our feet
foundFloor = false;
float closest = 210.0f; //same for this
RaycastHit target = new RaycastHit();
newZone = null;
for (int i = 0; i < currentZone.zones.Count; i++) //loop through current zones and its connected zones
{
for (int f = 0; f < currentZone.zones[i].floors.Count; f++) //loop throught the floors of the zones
{
//If a floor is the closest...
if (currentZone.zones[i].floors[f].Raycast(ray, out hit, 500))
{
float dist = Vector3.Distance(hit.point, ray.origin);
if (!foundFloor)
{
//we are going to take the first floor we check so that we at least have one
target = hit;
floorPlane = currentZone.zones[i].floors[f];
newZone = currentZone.zones[i];
closest = dist;
foundFloor = true;
}
if (dist <= closest)
{
closest = dist;
target = hit;
floorPlane = currentZone.zones[i].floors[f];
newZone = currentZone.zones[i];
//RUNGY...need to check for PLATFORMS HERE BADLY
//AND SETPLATFOR
}
}
}
}
if (newZone != null)
{
currentZone = newZone;
}
foundFloor = false; // reseting this for the next two raycasts
//use two ground checks...one higher...the other lower
if (floorPlane.Raycast(ray, out hit, 1.0f))
{
//always hit if we are going up
if (hit.point.y > (transform.position.y + 0.02f))
{
transform.position = hit.point;
lookAtPos.y = transform.position.y;
foundFloor = true; //RE-using foundFloor bool, to represent "ON FLOOR" status
}
angler.up = hit.normal;
}
else if (floorPlane.Raycast(ray, out hit, 1.2f))
{
if (!jumping)
{
// lower hit check for going down ramps
if (hit.point.y < (transform.position.y - 0.02f))
{
transform.position = hit.point;
lookAtPos.y = transform.position.y;
foundFloor = true; //RE-using foundFloor bool, to represent "ON FLOOR" status
}
angler.up = hit.normal;
}
}
else if (!jumping && !foundFloor) //we have no ground contact, and if we're not jumping, then we are falling
{
//Falling
if (falling == false)
{
animator.SetBool("Falling", true); //start falling animation
fallForwardSpeed = 0.15f;
lookAtPos = movementTarget.transform.position + (transform.forward);
}
falling = true;
transform.parent = null;
movementTarget.transform.parent = null;
fallspeed += (Time.unscaledDeltaTime / 0.015f) * 0.3f;
Vector3 v = new Vector3(0.0f, fallspeed * Time.deltaTime, 0.0f);
fallForwardSpeed = fallForwardSpeed * (1.0f - (0.9f * Time.deltaTime)); //this will diminish the forward speed, but never negate it
//v += -(transform.forward * fallForwardSpeed);
transform.position -= v;
transform.position += transform.forward * (fallForwardSpeed * (Time.unscaledDeltaTime / 0.015f));
}
//unconditional velocity check for falling through the world
ray.origin = lastPosition + transform.up;
velocityPS = Vector3.Distance(transform.position, lastPosition) / Time.unscaledDeltaTime;
ray.direction = -transform.up; //velocity.normalized;
float speed = Vector3.Distance(transform.position, lastPosition);
if (floorPlane.Raycast(ray, out hit, speed))
{
if (hit.point.y > transform.position.y)
{
transform.position = hit.point;
foundFloor = true;
}
}
if (foundFloor)
{
fallspeed = 0.0f;
if (falling == true) //we currently have ground contact, turn off falling if we were falling
{
animator.SetBool("Falling", false); //start falling animation
falling = false;
movementTarget.transform.position = transform.position + (transform.forward * 0.2f);
lookAtPos = transform.position + (transform.forward * 0.2f);
angler.gameObject.SetActive(true);
}
if (jumping) //we were jumping and we landed on something
{
jumping = false;
animator.SetBool("Jumping", false);
jumpTarget.doTrajectory = false;
rotateSpeed = 20.0f;
movementTarget.enabled = false;
movementTarget.transform.position = transform.position + (transform.forward * 0.2f);
lookAtPos = transform.position + (transform.forward * 0.2f);
angler.gameObject.SetActive(true);
}
envVars envVariables = floorPlane.transform.gameObject.GetComponent <envVars>();
if (envVariables != null)
{
if (envVariables.isPlatform) //RUNGY change this to use env flags instead of string comparison
{
transform.parent = floorPlane.transform;
if (movementTarget.transform.parent != floorPlane.transform || lookAtTarget.transform.parent != floorPlane.transform)
{
movementTarget.transform.parent = floorPlane.transform;
lookAtTarget.transform.parent = floorPlane.transform;
movementTarget.transform.position = transform.position + (transform.forward * 0.2f);
lookAtPos = transform.position + (transform.forward * 0.2f);
}
}
else
{
transform.parent = null;
movementTarget.transform.parent = null;
lookAtTarget.transform.parent = null;
}
}
}
//////////////////////////////
//HORIZONTAL/LATERAL DETECTION
//////////////////////////////
//make a forward ray, that's about waist high
ray.direction = transform.forward;
//on meter up from our feet
ray.origin = transform.position + transform.up;
target = new RaycastHit();
for (int i = 0; i < currentZone.zones.Count; i++)
{
for (int f = 0; f < currentZone.zones[i].floors.Count; f++)
{
//If a floor is the closest...
if (currentZone.zones[i].floors[f].Raycast(ray, out hit, 0.8f))
{
animator.SetBool("Idling", true);
movementTarget.enabled = false;
if (jumping)
{
jumping = false;
animator.SetBool("Jumping", false);
jumpTarget.doTrajectory = false;
rotateSpeed = 20.0f;
}
}
}
}
if (transform.parent == floorPlane.transform)
{
lookAtPos = movementTarget.transform.position;
}
lookAtPos.y = transform.position.y;
Quaternion tempRot = transform.rotation; //save current rotation
transform.LookAt(lookAtPos);
Quaternion hitRot = transform.rotation; // store the new rotation
// now we slerp orientation
transform.rotation = Quaternion.Slerp(tempRot, hitRot, Time.deltaTime * rotateSpeed);
Vector3 gv = new Vector3(0.0f, fallspeed * Time.deltaTime, 0.0f);
transform.position -= gv;
/////////////////////////////
/// LEFT MOUSE CLICK
/////////////////////////////
if (!Input.GetKey(KeyCode.LeftAlt)) //if we are not using the ALT key(camera control)...
{
// RUNGY THIRD PERSON INTERCEPT
// floor goal
if (Input.GetMouseButton(0)) //is the left mouse button being clicked?
{
//RUNGY, this is where you setup your close third person controller
if (useThird)
{
}
else
{
foundFloor = false; ///declaring it here because we use it elsewhere as well
destFloor = null;
closest = 210.0f; //same for this
ray = Camera.main.ScreenPointToRay(Input.mousePosition);
for (int i = 0; i < currentZone.zones.Count; i++)
{
for (int f = 0; f < currentZone.zones[i].floors.Count; f++)
{
//If a floor is the closest...
if (currentZone.zones[i].floors[f].Raycast(ray, out hit, 500))
{
float dist = Vector3.Distance(hit.point, ray.origin);
if (!foundFloor)
{
target = hit;
closest = dist;
foundFloor = true;
destFloor = currentZone.zones[i].floors[f];
}
//Rungy this is wrong, it could potentially pick an equals to over a less than value
if (dist <= closest)
{
closest = dist;
target = hit;
destFloor = currentZone.zones[i].floors[f];
}
}
}
}
if (destFloor != null)
{
clickedFloor = destFloor;
attackTarget.transform.position = target.point;
//Rungy, this is where you need to use a cursor object with a character controller on it
//placing the controller on the spot wherre you hit, getting the name of the object...doing another downward trce to it for the actual position
movementTarget.transform.position = target.point; //mark it where it hit
movementTarget.transform.up = target.normal;
movementTarget.enabled = true;
envVars envVariables = destFloor.transform.gameObject.GetComponent <envVars>();
if (envVariables != null)
{
if (envVariables.isPlatform) //RUNGY change this to use env flags instead of string comparison
{
movementTarget.transform.parent = destFloor.transform;
}
}
lookAtPos = target.point;
lookAtPos.y = transform.position.y;
wasAttacking = false; //we're moving now, not attacking
}
}
}
}
Debug.DrawLine((movementTarget.transform.position + transform.up * 2), movementTarget.transform.position); //useful for visuals in editor
lookAtTarget.transform.position = lookAtPos;
lastDir = (transform.position - lastPosition).normalized;
lastPosition = transform.position;
if (Input.GetKey(KeyCode.UpArrow))
{
moveType = 0.0f;
wasAttacking = false;
}
else if (Input.GetKey(KeyCode.DownArrow))
{
moveType = 2.0f;
wasAttacking = false;
}
else if (Input.GetKey(KeyCode.LeftArrow))
{
moveType = 3.0f;
wasAttacking = false;
}
else if (Input.GetKey(KeyCode.RightArrow))
{
moveType = 1.0f;
wasAttacking = false;
}
}
else //MOUNTED
{
animator.SetBool("Idling", true);
//still need thesed variables even if we're on a mount
lastDir = (transform.position - lastPosition).normalized;
velocityPS = Vector3.Distance(transform.position, lastPosition) / Time.unscaledDeltaTime;
lastPosition = transform.position;
}
}
}