C# Transform.Translate方法代码示例

    void Update()
    {
        iPx = iPhoneInput.acceleration.x;
        myTransform= transform;
        //float horizontalSpeed = Input.GetAxis("Horizontal") * Time.deltaTime * -movementSpeed;
        if(iPx>.2f){
            float horizontalSpeed = iPx * Time.deltaTime * movementSpeed;
            myTransform.Translate(-horizontalSpeed, 0, 0);
        }
        else if(iPx<-.2f){
            float horizontalSpeed = iPx * Time.deltaTime * -movementSpeed;
            myTransform.Translate(horizontalSpeed, 0, 0);

        }
        myTransform.position= new Vector3(Mathf.Clamp(myTransform.position.x, -4f, 4.3f),myTransform.position.y,myTransform.position.z);

        if(Input.GetKey(KeyCode.W)){
            enemySpeed= StaticVar.enemySpeedFast;
            laneSpeed= StaticVar.laneSpeedFast;
            scoreMultiplier= StaticVar.scoreMultiplyFast;
            motorSpeed= StaticVar.motorSpeedFast;
        }
        else{
            enemySpeed= StaticVar.enemySpeedSlow;
            laneSpeed= StaticVar.laneSpeedSlow;
            scoreMultiplier= StaticVar.scoreMultiplySlow;
            motorSpeed= StaticVar.motorSpeedSlow;
        }
    }

    public override void Execute(Context _context)
    {
        // action logic here
        //if( context.target == null) return;

        BaseContext context = (BaseContext) _context;
        if(context.target == null) return;

        if(context.animator != null) context.animator.SetFloat("Speed", 1);
        transform = context.gameObject.transform;
        frontRight = transform.TransformDirection( new Vector3( 0.2f, 0, 1));
        frontLeft =  transform.TransformDirection( new Vector3(-0.2f, 0, 1));
        // forward = transform.TransformDirection(Vector3.forward);
        heading = context.target.position - transform.position;
        origin = transform.position + new Vector3(0, 0.5f, 0);
        if(context.collision && Physics.Raycast(origin, frontRight, out hit, context.rayDistance, layerMask)){
            if(hit.transform.gameObject.GetInstanceID() == context.target.gameObject.GetInstanceID()){
                return;
            }
            else{
                while(Physics.Raycast(origin, transform.forward, out hit, context.rayDistance, layerMask)){
                    // Debug.Log(hit.point);
                    transform.Rotate(0, -1, 0 );
                }
                transform.Translate(Vector3.forward * Time.deltaTime * context.speed );
            }
        }
        else if(context.collision && Physics.Raycast(origin, frontLeft, out hit, context.rayDistance, layerMask)){
            if(hit.transform.gameObject == context.target){
                return;
            }
            else {
                while(Physics.Raycast(origin, transform.forward, out hit, context.rayDistance, layerMask)){
                    // Debug.Log(hit.point);
                    transform.Rotate(0, 1, 0 );
                }
                transform.Translate(Vector3.forward * Time.deltaTime * context.speed );
            }
        }

        // {
        // 	context.rerouting = true;
        // 	Debug.DrawRay(transform.position, transform.TransformDirection(Vector3.forward) * context.rayDistance, Color.red);
        // }
        // else{
        else {
            context.rerouting = false;
            //heading.y += offset.Value.y;
            distance = heading.magnitude;
            if(distance > 0.1)
            {
                heading = heading/distance;
                transform.Translate(heading * context.speed * Time.deltaTime, Space.World);
            }
        }
        Debug.DrawRay(origin, frontRight*context.rayDistance, 	Color.green);
        Debug.DrawRay(origin, frontLeft*context.rayDistance, 	Color.blue);
    }

    // Use this for initialization
    void Awake()
    {
        int width = 1;

        switch (side)
        {
        case Direction.Front:
            width = parentUnit.Files;
            break;

        case Direction.Right:
            width = parentUnit.Ranks;
            transform.localPosition = new Vector3(parentUnit.Files * 0.5f, 0, -parentUnit.Ranks * 0.5f);
            break;

        case Direction.Left:
            width = parentUnit.Ranks;
            transform.localPosition = new Vector3(-parentUnit.Files * 0.5f, 0, -parentUnit.Ranks * 0.5f);
            break;

        case Direction.Rear:
            width = parentUnit.Files;
            transform.localPosition = new Vector3(0, 0, -parentUnit.Ranks);
            break;
        }

        middleSection = transform.Find ("Middle");
        middleSection.localScale = new Vector3 (width, 0.1f, 1);

        rightSection = transform.Find ("Right");
        rightSection.Translate (width * 0.5f - 0.5f, 0, 0, transform);

        leftSection = transform.Find ("Left");
        leftSection.Translate (-(width * 0.5f - 0.5f), 0, 0, transform);
    }

	public void Start() 
	{
        OriginalPosition = gameObject.transform.position;
		ObjectPosition = GetComponent<Transform>();
        velocity = new Vector2(speed, 0);
		ObjectPosition.Translate(velocity.x * Time.deltaTime, 0,0);
	}

    public override void Act(Transform player, Transform npc)
    {
        //	Debug.Log ("attack act");
        //Set the target position as the player position
        destPos = player.position;
        Quaternion targetRotation = Quaternion.LookRotation (destPos - npc.position);
        npc.rotation = Quaternion.Slerp (npc.rotation, targetRotation, Time.deltaTime * rotationSpeed);

          //Use for kamikaze
        if (kamikaze) {
            targetRotation = Quaternion.LookRotation (destPos - npc.position);
            npc.rotation = Quaternion.Slerp (npc.rotation, targetRotation, Time.deltaTime * rotationSpeed);

            //Go Forward
            npc.Translate (Vector3.forward * Time.deltaTime * speed);
        //			if (Vector3.Distance(destPos,npc.position) <10) {
        //				Debug.Log("Shoot Shoot");
        //			}

        }

        //Always Turn the turret towards the player
        // Transform turret = npc.GetComponent<NPCTankController>().turret;
        // Quaternion turretRotation = Quaternion.LookRotation(destPos - turret.position);
        // turret.rotation = Quaternion.Slerp(turret.rotation, turretRotation, Time.deltaTime * curRotSpeed *10);

        //Shoot bullet towards the player
          //  npc.GetComponent<NPCTankController>().ShootBullet();
    }

 /// <summary>
 /// Moves a given transform in a given direction
 /// </summary>
 /// <param name="aTransform">
 /// A <see cref="Transform"/>
 /// </param>
 /// <param name="anAmount">
 /// A <see cref="Vector3"/>
 /// </param>
 private static void NudgeIt(Transform aTransform, Vector3 anAmount)
 {
     if (aTransform != null)
     {
         aTransform.Translate(anAmount, nudgeSpace);
     }
 }

 void CreateHealthBar()
 {
     healthBar = Instantiate (healthBar) as Image;
     transform = healthBar.GetComponent<Transform> ();
     transform.SetParent (GameObject.FindGameObjectWithTag ("Canvas").GetComponent<Transform> ());
     transform.Translate (new Vector3 (0, 3));
     curHealthBar = healthBar.GetComponentsInChildren<Image> () [1];
 }

 /// <summary>
 /// Moves a given transform in a given direction
 /// </summary>
 /// <param name="aTransform">
 /// A <see cref="Transform"/>
 /// </param>
 /// <param name="anAmount">
 /// A <see cref="Vector3"/>
 /// </param>
 private static void NudgeIt(Transform aTransform, Vector3 anAmount)
 {
     if (aTransform != null)
     {
         Undo.RegisterUndo(aTransform, "Nudge " + aTransform.name);
         aTransform.Translate(anAmount, nudgeSpace);
     }
 }

    void MoveThis(Transform tree, float distance)
    {
        tree.Translate((maxSpeed * distance) *
                       Vector3.left * Time.deltaTime, transform);

        float xdisplacement = (-area.x * 0.5f) - transform.InverseTransformPoint(tree.position).x;
        if(xdisplacement >= 0.0f){
            tree.position = tree.parent.position + (-transform.right * xdisplacement);
        }
    }

    // fonction de mise à jour
    public void FixedUpdate()
    {
        for(int i = 0; i < projectilePoolActive.Count; i++)
        {
            go = (GameObject)projectilePoolActive[i];

            bullet = go.GetComponent(typeof(ProjectileGun)) as ProjectileGun;

            if(bullet.isActive)
            {
                if(bullet.isExpired)
                {
                    bullet.isActive = false;

                    go.SetActive(false);

                    projectilePoolActive.RemoveAt(i);
                    projectilePoolReady.Add(go);
                }
                else if(bullet.hasCollided)
                {
                    previousTransform = bullet.transform;
                    previousTransform.Translate(previousTransformOffset, Space.Self);

                    raycastRay.origin =    previousTransform.position;
                    raycastRay.direction = bullet.direction;

                    if(Physics.Raycast(raycastRay, out raycastHit) && !bullet.hasBounced)
                    {
                        bullet.hasBounced = true;

                        impactPoint  = raycastHit.point;
                        impactNormal = raycastHit.normal;

                        impactIncidence = Vector3.Angle(raycastRay.direction, impactNormal);

                        reflectionQuaternion =
                            Quaternion.LookRotation(
                            Vector3.Reflect(
                                raycastRay.direction,
                                raycastHit.normal
                            )
                        );

                        bullet.transform.position = impactPoint;
                        bullet.transform.rotation = reflectionQuaternion;

                        print("<gun impact:" + impactPoint + " incidence:" + impactIncidence + ">");
                        Debug.DrawRay(raycastRay.origin, raycastRay.direction, Color.grey, 1, true);
                    }
                }
            }
        }
    }

    public override void Act(Transform player, Transform npc)
    {
        // Debug.Log ("chase act");
        //Rotate to the target point
        destPos = player.position;

        Quaternion targetRotation = Quaternion.LookRotation(destPos - npc.position);
        npc.rotation = Quaternion.Slerp(npc.rotation, targetRotation, Time.deltaTime * rotationSpeed);

        //Go Forward
        npc.Translate(Vector3.forward * Time.deltaTime * speed);
    }

 void OnTriggerStay(Collider other)
 {
     if (other.tag == "Attack" && animator.GetInteger("Int") == 0)
     {
         animator.SetInteger("Int", 1);
         if (Random.Range(0, 99) > 79)
         {
             clone = Instantiate(pickup, transform.position, transform.rotation) as Transform;
             clone.Translate(0, 0, 0);
         }
     }
 }

    void Awake()
    {
        transform = GetComponent<Transform> ();
        rigidbody = GetComponent<Rigidbody2D> ();

        // start at mouse click
        transform.position = Camera.main.ScreenToWorldPoint (Input.mousePosition);
        transform.position = new Vector3 (transform.position.x, transform.position.y, 0f);

        // randomly rotate and move back (off screen)
        transform.Rotate (0f, 0f, Random.Range(0f,360f));
        transform.Translate (Vector3.down * spawnDistance);
    }

	void Start ()
	{

		thisTransform = GetComponent<Transform> ();
		targetToReach = thisTransform.position;
		if (QuickSlideOnEnable) {

			thisTransform.Translate (quickSlideDistance);
		}

		Invoke ("Delay", move_delay_time);

	}

 // Use this for initialization
 void Start()
 {
     longshot = GameObject.Find("Player2").GetComponent<PlayerControllerP2>().rangeBoost;
     if (longshot)
     {
         range = 3;
     }
     bullet = GetComponent<Transform>();
     bullet.Translate(0, -1f, 0);
     Invoke("LeaveDecal", range);
     isMoving = true;
     image = GetComponent<tk2dSprite>();
 }