| public Move ( Vector3 offset ) : void | ||
| offset | Vector3 | The relative movement vector. |
| return | void | |
void NavmeshMove()
{
m_NavAgent.Move(transform.forward * m_Speed * Time.deltaTime);
Vector3 lookat = m_NavAgent.steeringTarget - transform.position;
lookat.y = 0;
if (lookat != Vector3.zero)
{
Quaternion to = Quaternion.LookRotation(lookat, Vector3.up);
transform.rotation = Quaternion.RotateTowards(transform.rotation, to, 10);
}
}
void Move()
{
movement.Set(0f, 0f, 1f);
movement = movement.normalized * speed * Time.deltaTime;
//rigidbody.position += transform.forward * speed * Time.deltaTime;
nav.Move(transform.forward * speed * Time.deltaTime);
}
void UpdateMove()
{
float h = Input.GetAxis("Horizontal");
float v = Input.GetAxis("Vertical");
if (JoyStickController.h != 0 || JoyStickController.v != 0)
{
h = JoyStickController.h;
v = JoyStickController.v;
}
if (h != 0f || v != 0f)
{
Vector3 tempVector = new Vector3(h, 0f, v);
tempVector.Normalize();
Vector3 relative = transform.InverseTransformPoint(transform.position + tempVector);
float angle = Mathf.Atan2(relative.x, relative.z) * Mathf.Rad2Deg;
transform.Rotate(Vector3.up * angle);
m_NavAgent.velocity = Vector3.zero;
//cc.Move(tempVector * m_Speed * Time.deltaTime);
m_NavAgent.Move(tempVector * m_Speed * Time.deltaTime);
if (!m_Animator.GetBool("Move"))
{
m_Animator.SetBool("Move", true);
}
}
else
{
m_NavAgent.Stop();
if (m_Animator.GetBool("Move"))
{
m_Animator.SetBool("Move", false);
}
}
}
private IEnumerator OnTriggerEnter(Collider other)
{
if (other.tag == "TailStink" || other.tag == "Bomb")
{
agent = transform.parent.GetComponent <UnityEngine.AI.NavMeshAgent>();
pushDirection = new Vector3(0, 0, -1);
pushDirection = player.transform.position - transform.parent.position;
pushDirection = -pushDirection.normalized;
pushDirection.y = 0;
float i = 0;
while (i <= knockbackDuration)
{
yield return(wffu);
i += (1f * Time.deltaTime);
agent.Move(pushDirection * Time.deltaTime * knockbackSpeed);
if ((i > .01f && i < .2f))
{
color.a = .4f;
}
else
{
if (!isPhysical)
{
color.a = 1f;
}
else
{
color.a = 0.75f;
}
}
for (int x = 0; x <= transform.childCount; x++)
{
colorAll[x].material.color = color;
}
}
health -= 1f;
if (health <= 0f)
{
callEvent?.Invoke();
enemy.SetActive(false);
var dropRandom = Random.value;
if (dropRandom >= heartChance)
{
Instantiate(heart, transform.position + offset, transform.rotation);
}
if (dropRandom <= beanChance)
{
Instantiate(bean, transform.position + offset, transform.rotation);
}
}
}
}
static public int Move(IntPtr l)
{
try {
UnityEngine.AI.NavMeshAgent self = (UnityEngine.AI.NavMeshAgent)checkSelf(l);
UnityEngine.Vector3 a1;
checkType(l, 2, out a1);
self.Move(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static int Move(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
UnityEngine.AI.NavMeshAgent obj = (UnityEngine.AI.NavMeshAgent)ToLua.CheckObject(L, 1, typeof(UnityEngine.AI.NavMeshAgent));
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 2);
obj.Move(arg0);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public void ImpulseUpdate()
{
foreach (int u in impulses.Keys)
{
if (!impulses [u].Tick(nma, Time.deltaTime) && isServer)
{
RpcRemoveImpulse(u, impulses [u].accMove);
}
}
if (impulseCorrection != Vector3.zero)
{
Vector3 pos = transform.position;
Vector3 cor = Vector3.Lerp(impulseCorrection, Vector3.zero, 12 * Time.deltaTime);
nma.Move(cor);
impulseCorrection -= pos - transform.position;
}
}
public void ConstSpdUpdate(float dt)
{
int count = speeds.Count;
if (count > 0)
{
for (int i = count - 1; i >= 0; i--)
{
ConstantSpeed spd = speeds [i];
float rdt = Mathf.Min(spd.timeLeft, dt);
nma.Move(spd.speed * rdt);
spd.timeLeft -= rdt;
if (spd.timeLeft <= 0)
{
speeds.RemoveAt(i);
}
}
}
}
public bool Tick(UnityEngine.AI.NavMeshAgent nma, float dt)
{
if (impLeft == Vector3.zero)
{
return(false);
}
Vector3 prevPos = nma.transform.position;
Vector3 prevImp = impLeft;
impLeft = Vector3.MoveTowards(impLeft, Vector3.zero, impDeacc * dt);
nma.Move(0.5f * (prevImp + impLeft) * dt);
Vector3 delta = nma.transform.position - prevPos;
accMove += delta;
if (impLeft != Vector3.zero && impLeft == prevImp)
{
Debug.Log("deltaImp " + delta + " impLeft " + impLeft);
}
return(true);
}
// Update is called once per frame
void Update()
{
if (target != null)
{
agent.SetDestination(target.position);
}
if (agent.remainingDistance < agent.stoppingDistance)
{
agent.Move(agent.desiredVelocity);
}
dirToPlayer = playerTransform.position - transform.position;
switch (state)
{
case AIState.WANDERING:
if (!isWandering)
{
isWandering = true;
StartCoroutine(Wander());
}
break;
case AIState.NAVIGATING:
if (!isNavigating)
{
isNavigating = true;
StartCoroutine(Navigate());
}
break;
case AIState.PUSHING:
if (!isPushing)
{
isPushing = true;
StartCoroutine(Push());
}
break;
}
}
// Update is called once per frame
void Update()
{
if (isLocalPlayer)
{
h = ETCInput.GetAxis("Horizontal");
v = ETCInput.GetAxis("Vertical");
moveVec = new Vector3(h, 0, v);
moveVec.Normalize();
}
if (isDead)
{
return;
}
if (isBusy)
{
//Quaternion targetRotation = Quaternion.LookRotation(faceVec);
//transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, speedRotate);
transform.LookAt(faceVec);
return;
}
if (h != 0 || v != 0)
{
ani.SetBool("Run", true);
// 根据摄像机方向 进行移动
moveVec = Quaternion.Euler(0, Camera.main.transform.eulerAngles.y, 0) * moveVec;
nav.Move(moveVec * Time.deltaTime * speedMove);
RotatePlayer();
}
else
{
ani.SetBool("Run", false);
}
}
void OnMove(Vector2 dir)
{
var dir_world = m_camera.transform.rotation * new Vector3(dir.x, 0, dir.y);
dir_world.y = 0;
dir_world.Normalize();
//var offset = dir_world * SPEED * Time.deltaTime;
//transform.forward = dir_world;
//m_agent.Move(offset);
if (useNav)
{
var offset = dir_world * SPEED * Time.deltaTime;
transform.forward = dir_world;
m_agent.Move(offset);
}
else
{
doJoyMove(this.GetPositon(), dir_world);
}
}
private void Move()
{
Vector3 move = Vector3.zero;
Debug.Log(Input.GetAxis(LeftJoystickVertical));
if (Input.GetAxis(LeftJoystickVertical) > 0.1f ||
Input.GetAxis(LeftJoystickVertical) < -0.1f)
{
move += Vector3.back * Time.deltaTime * speed * Input.GetAxis(LeftJoystickVertical);
}
if (Input.GetAxis(LeftJoystickHorizontal) > 0.1f ||
Input.GetAxis(LeftJoystickHorizontal) < -0.1f)
{
move += Vector3.right * Time.deltaTime * speed * Input.GetAxis(LeftJoystickHorizontal);
}
Quaternion rotation = Quaternion.Euler(CameraLeftRightRotationParent.transform.eulerAngles);
move = rotation * move;
pNavAgent.Move(move);
watchPoint.transform.position = transform.position;
watchPoint.transform.Translate(new Vector3(Input.GetAxis(LeftJoystickHorizontal), 0.0f, -Input.GetAxis(LeftJoystickVertical)), CameraLeftRightRotationParent.transform);
playerMeshItem.transform.LookAt(watchPoint.transform);
}
void Move()
{
//get keyboard input
float VInput = Input.GetAxis("Vertical");
if (VInput == 0) // if not moving, idle animation, increase stamina count
{
_anim.SetBool("Idle", true);
_stamina = Mathf.Max(0, _stamina - 0.02f);
}
else
{
if (camera.zoomState == 2)
{
camera.zoomState = 3; //if moving and camera zoomed out, then zoom back in (so player can't move around in zoomed out view)
}
if (levelManager.levelInt == 1 || levelManager.levelInt == 2)
{
GameManager.infoPopups[levelManager.levelInt - 1] = true; //if moving, close info popup at beginning of lvl1 or lvl2
}
_anim.SetBool("Idle", false);
if (Input.GetKeyDown(KeyCode.Space)) //first pressed down SPACE, initalize stamina vars
{
_SpaceKey = true;
_startTime = Time.time; //time at which player starts running
_startStamina = _stamina;
}
else if (Input.GetKeyUp(KeyCode.Space)) //first released SPACE, stop running
{
_SpaceKey = false;
run = false;
}
if (_SpaceKey) //if SPACE pressed down, calculate stamina increase and deterine if player can run
{
_stamina = _startStamina + Time.time - _startTime; //when running, add stamina (the more stamina, the less the player can run, it's inverted and a tiny bit confusing heh)
_stamina = Mathf.Min(_stamina, 3f); //makes sure stamina doesn't go over limit
if (_stamina >= 3f)
{
run = false; //can't run if stamina goes over limit
}
else
{
run = true;
}
}
if (run) //if player is running, set running animation var to true, change speed to run speed
{
_anim.SetBool("Run", true);
_speed = _runSpeed;
}
else //if player is not running, set running animation var to false, change speed to walk spped, increase stamina
{
_anim.SetBool("Run", false);
_speed = _walkSpeed;
_stamina = Mathf.Max(0, _stamina - 0.02f); //stamina regenerate
}
}
//movement
move = new Vector3(0, 0, VInput * _speed * Time.deltaTime);
move = this.transform.TransformDirection(move);
agent.Move(move); //move player
}
// 寻路移动
void MoveTo()
{
float speed = m_movSpeed * Time.deltaTime;
m_agent.Move(m_transform.TransformDirection((new Vector3(0, 0, speed))));
}
void Update()
{
// Doit servir à update les STATES uniquement
// si je voit le drapeau
/* if (bot.CanSeeObject (master.flag_prefab))
* {
* print ("I SEE A FLAG");
* // Je le récupère
* agent.SetDestination (master.flag_prefab.transform.position);
* }*/
//Si je voit un ennemy je tir
hit = Physics.OverlapSphere(this.transform.position, 100f);
int max = hit.Length;
for (int i = 0; i < max; i++)
{
if (hit [i] != null && hit [i].gameObject.layer == enemyLayer)
{
if (bot.CanSeeObject(hit [i].gameObject))
{
bot.ShootInDirection(hit [i].transform.position - this.transform.position);
}
}
}
// fin de shoot
UpdateState();
// Si j'ai le flag enemy
// Si le flag est la base enemy je retourne le chercher
if (master.IsTeamFlagHome(team.enemy_team_ID))
{
SwitchState(BotState.IDLE);
}
// si le flag ennemi est tombé je retourne le chercher
if (master.flag_carriers [team.enemy_team_ID] == -1)
{
agent.SetDestination(team.enemy_flag.transform.position);
}
// si mon flag est tombé je retourne le chercher
if (master.flag_carriers [team.team_ID] == -1 && master.flag_carriers [team.enemy_team_ID] != -1)
{
agent.SetDestination(team.team_flag.transform.position);
}
// si je voit un mon drapeau sur la map, raid
if (!master.IsTeamFlagHome(team.enemy_team_ID))
{
SwitchState(BotState.RAID);
}
if (!master.IsTeamFlagHome(team.enemy_team_ID))
{
SwitchState(BotState.GOBACK);
}
if (master.flag_carriers [team.enemy_team_ID] != -1)
{
if (bot.CanSeeObject(master.GetBotFromID(master.flag_carriers [team.team_ID])))
{
SwitchState(BotState.RAID);
}
}
/*
* // si j'ai le flag ennemi et que mon flag n'est pas à ma base.
* if (master.is_flag_home[team.team_ID] == false && master.flag_carriers [team.enemy_team_ID] != -1) {
*
* SwitchState (BotState.GOTOENNEMYBASE);
* }*/
//Si une balle viens sur moi je l'esquive
if (GameObject.FindWithTag("Rocket") != null)
{
if (bot.CanSeeObject(GameObject.FindGameObjectWithTag("Rocket")))
{
GameObject rocket = GameObject.FindGameObjectWithTag("Rocket");
if (rocketPosition != Vector3.zero)
{
dirRocket = rocket.transform.position - rocketPosition;
}
rocketPosition = rocket.transform.position;
agent.Move(dirRocket + new Vector3(Random.Range(0, 170), Random.Range(0, 170), Random.Range(0, 170)));
}
}
}
void Move()
{
float h, v;
Transform cameratransform = Camera.main.transform;
cameratransform.rotation = Quaternion.LookRotation(new Vector3(transform.position.x - cameratransform.position.x, 0, transform.position.z - cameratransform.position.z));
Vector3 forward = cameratransform.TransformDirection(Vector3.forward);
Vector3 right = cameratransform.TransformDirection(Vector3.right);
h = Input.GetAxisRaw(controllerName + "LStickX");
if (Mathf.Abs(h) < 0.2)
{
h = 0;
}
else
{
if (h < 0)
{
h = -1;
}
else
{
h = 1;
}
}
v = Input.GetAxisRaw(controllerName + "LStickY");
if (Mathf.Abs(v) < 0.2)
{
v = 0;
}
else
{
if (v < 0)
{
v = -1;
}
else
{
v = 1;
}
}
playerDirection = h * right + v * forward;
speed = playerDirection.magnitude;
if (speedWeight < 1.0f)
{
speedWeight += Time.deltaTime * 2.0f;
}
else
{
speedWeight = 1.0f;
}
speed = speed * speedWeight;
if (speed > 0)
{
if (playerDirection != Vector3.zero)
{
Quaternion playerRotation = Quaternion.LookRotation(playerDirection);
transform.rotation = Quaternion.Lerp(transform.rotation, playerRotation, Time.deltaTime * lerpSpeed);
}
agent.Move(transform.forward * Time.deltaTime * speed * 3.0f);
}
anim.SetFloat("speed", speed);
}
private void wander()
{
agent.Move(new Vector3(1 * Time.deltaTime, 0, 0));
}
void FixedUpdate()
{
agent.Move(velocity * Time.deltaTime);
}
void Update()
{
agent.Move(agenttf.forward * Time.deltaTime * agent.speed);
}
