Object floating

If you just want a smooth floating movement, use the Mathf.Sin function:

 // Save the y position prior to start floating (maybe in the Start function):
 
   var y0:float = transform.position.y;
 
 // Put the floating movement in the Update function:
 
   transform.position.y = y0+amplitude*Mathf.Sin(speed*Time.time);

Since Sin ranges from -1 to +1, you'll have the object floating from -amplitude to +amplitude around the y0 coordinate, and the time to complete one cycle is 2 PI speed - about 6.3 seconds if speed is 1.

I figure out!! :)

 var floatup;
 function Start(){
     floatup = false;
 }
 function Update(){
     if(floatup)
         floatingup();
     else if(!floatup)
         floatingdown();
 }
 function floatingup(){
     transform.position.y += 0.3 * Time.deltaTime;
     yield WaitForSeconds(1);
     floatup = false;
 }
 function floatingdown(){
     transform.position.y -= 0.3 * Time.deltaTime;;
     yield WaitForSeconds(1);
     floatup = true;
 }

hope it will help.

You can also do something like this easily, and more advanced movements using Unity's built-in animation editor.

Take a look at these videos...

http://lesterbanks.com/2010/05/unity-3d-animation-tutorials/

In C# you can write something like this:

     public float amplitude;          //Set in Inspector 
     public float speed;                  //Set in Inspector 
     private float tempVal;
     private Vector3 tempPos;
     
     void Start () 
     {
         tempVal = transform.position.y;
     }
 
     void Update () 
     {        
         tempPos.y = tempVal + amplitude * Mathf.Sin(speed * Time.time);
         transform.position = tempPos;
     }

Since I was looking for a quick 'floating' script to save me some time and stumbled onto this topic on Google, but I still didn't get exactly what I wanted (some 'universal solution'), here is what I wrote afterwards to help other googling guys. Also includes 'floating' functionality for rotation and scale apart from position, all are togglable on/off:

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
 public class SimpleFloating : MonoBehaviour {
 
     public bool animPos = true;
     public Vector3 posAmplitude = Vector3.one;
     public Vector3 posSpeed = Vector3.one;
 
     public bool animRot = true;
     public Vector3 rotAmplitude = Vector3.one*20;
     public Vector3 rotSpeed = Vector3.one;
 
     public bool animScale = false;
     public Vector3 scaleAmplitude = Vector3.one*0.1f;
     public Vector3 scaleSpeed = Vector3.one;
 
     private Vector3 origPos;
     private Vector3 origRot;
     private Vector3 origScale;
 
     private float startAnimOffset = 0;
 
 
     /**
      * Awake
      */
     void Awake() {
         origPos = transform.position;
         origRot = transform.eulerAngles;
         origScale = transform.localScale;
         startAnimOffset = Random.Range(0f, 540f);        // so that the xyz anims are already offset from each other since the start
     }
     
     /**
      * Update
      */
     void Update() {
         /* position */
         if(animPos) {
             Vector3 pos;
             pos.x = origPos.x + posAmplitude.x*Mathf.Sin(posSpeed.x*Time.time + startAnimOffset);
             pos.y = origPos.y + posAmplitude.y*Mathf.Sin(posSpeed.y*Time.time + startAnimOffset);
             pos.z = origPos.z + posAmplitude.z*Mathf.Sin(posSpeed.z*Time.time + startAnimOffset);
             transform.position = pos;
         }
 
         /* rotation */
         if(animRot) {
             Vector3 rot;
             rot.x = origRot.x + rotAmplitude.x*Mathf.Sin(rotSpeed.x*Time.time + startAnimOffset);
             rot.y = origRot.y + rotAmplitude.y*Mathf.Sin(rotSpeed.y*Time.time + startAnimOffset);
             rot.z = origRot.z + rotAmplitude.z*Mathf.Sin(rotSpeed.z*Time.time + startAnimOffset);
             transform.eulerAngles = rot;
         }
 
         /* scale */
         if(animScale) {
             Vector3 scale;
             scale.x = origScale.x * (1+scaleAmplitude.x*Mathf.Sin(scaleSpeed.x*Time.time + startAnimOffset));
             scale.y = origScale.y * (1+scaleAmplitude.y*Mathf.Sin(scaleSpeed.y*Time.time + startAnimOffset));
             scale.z = origScale.z * (1+scaleAmplitude.z*Mathf.Sin(scaleSpeed.z*Time.time + startAnimOffset));
             transform.localScale = scale;
         }
     }
 }