2013年9月12日 星期四

unity3d和下OrtHello的使用教程 （二） 移动物体，碰撞等

http://blog.csdn.net/djy2130/article/details/7035090

回顾一下上一次的教程orz，也许有许多地方没有说清楚的，我补充一下

首先是OT的预设物体有：

是不是看到了熟悉的Sprite等物体，首先OT这个物体是一定要一开始就拖到场景中了，它作为一个管理全局的OT物体而存在。
然后是Sprites，Sprites简单来说只有3种：不会自己主动动画的Sprite，会自己主动动画的AnimatingSprite，能填充一定区域范围的FilledSprite，这三种Sprite是直接放进场景中的，
Sprites目录下的Animation是根据SpriteAtlas或者是SpriteSheet的Texture来生成序列帧动画的，主要是设置从第几帧到第几帧是什么动画，这样子方便AnimatingSprite的调用，这些Animation就是放到场景中的OT下的Animation目录中的
Sprites目录下的SpriteAtlas和SpriteSheet都是用来管理Texture的，以后说。



话说，unity有一点我超不喜欢的就是：一个在场景中的物体带有collior 可我不知道是自己附上去的还是通过代码添加的orz

下面是附C#代码
[csharp] view plaincopy

  1. public class CExample2 : MonoBehaviour {  
  2.   
  3.     /// <exclude />  
  4.     public OTSprite blockPrototype; // prototype to create blocks  
  5.     /// <exclude />  
  6.     public OTSprite starPrototype;  // prototype to create stars  
  7.   
  8.     bool initialized = false;       // initialization indicator  
  9.   
  10.     // Create the objects of this demo using provided prototypes  
  11.     void CreateObjects()  
  12.     {  
  13.         // Find the empty that will act as the block container  
  14.         GameObject blocks = GameObject.Find("Blocks");  
  15.         if (blocks!=null)  
  16.         {  
  17.             // Calculate the horizontal number of blocks for the current resolution  
  18.             int c = (Screen.width - 20) / 85;  
  19.             // Calculate horizontal center spacing  
  20.             int s = (Screen.width - (c * 85)) / 2;  
  21.             // Create bottom horizontal blocks  
  22.             for (int x = 0; x < c; x++)  
  23.             {  
  24.                 // Create a new block  
  25.                 OTSprite b = (Instantiate(blockPrototype.gameObject) as GameObject).GetComponent<OTSprite>();  
  26.                 // Set block's position  
  27.                 b.position = new Vector2(s + 50 + (x * 85)- (Screen.width/2), 20 - (Screen.height/2));  
  28.                 // Set block's name  
  29.                 b.name = "bottom" + x;  
  30.                 // Link to parent  
  31.                 b.transform.parent = blocks.transform;  
  32.             }  
  33.             // Create top horizontal blocks  
  34.             for (int x = 0; x < c; x++)  
  35.             {  
  36.                 // Create a new block  
  37.                 OTSprite b = (Instantiate(blockPrototype.gameObject) as GameObject).GetComponent<OTSprite>();  
  38.                 // Set block's position  
  39.                 b.position = new Vector2(s + 50 + (x * 85) - (Screen.width / 2), Screen.height - 20 - (Screen.height / 2));  
  40.                 // Set block's name  
  41.                 b.name = "top" + x;  
  42.                 // Link to parent  
  43.                 b.transform.parent = blocks.transform;  
  44.             }  
  45.             // Calculate the vertical number of blocks for the current resolution  
  46.             c = (Screen.height - 50) / 85;  
  47.             // Calculate vertical center spacing  
  48.             s = (Screen.height - (c * 85)) / 2;  
  49.             // Create left vertical blocks  
  50.             for (int x = 0; x < c; x++)  
  51.             {  
  52.                 // Create a new block  
  53.                 OTSprite b = (Instantiate(blockPrototype.gameObject) as GameObject).GetComponent<OTSprite>();  
  54.                 // Rotate this block 90 degrees  
  55.                 b.rotation = 90;  
  56.                 // Set block's position  
  57.                 b.position = new Vector2(20 - (Screen.width / 2), (Screen.height/2) - 40 - s - (x*85) );  
  58.                 // Set block's name  
  59.                 b.name = "left" + x;  
  60.                 // Link block to parent  
  61.                 b.transform.parent = blocks.transform;  
  62.             }  
  63.             // Create right vertical blocks  
  64.             for (int x = 0; x < c; x++)  
  65.             {  
  66.                 // Create new block  
  67.                 OTSprite b = (Instantiate(blockPrototype.gameObject) as GameObject).GetComponent<OTSprite>();  
  68.                 // Rotate block 90 degrees  
  69.                 b.rotation = 90;  
  70.                 // Set block's position  
  71.                 b.position = new Vector2((Screen.width / 2)-20, (Screen.height / 2) - 40 - s - (x * 85));  
  72.                 // Set block's name  
  73.                 b.name = "right" + x;  
  74.                 // Link block to parent  
  75.                 b.transform.parent = blocks.transform;  
  76.             }  
  77.         }  
  78.   
  79.         // Find the empty that will act as the stars container  
  80.         GameObject stars = GameObject.Find("Stars");  
  81.         if (stars != null)  
  82.         {  
  83.             // We will create 50 stars  
  84.             int c = 50;  
  85.             for (int x = 0; x < c; x++)  
  86.             {  
  87.                 // Create a new star  
  88.                 OTSprite s = (Instantiate(starPrototype.gameObject) as GameObject).GetComponent<OTSprite>();  
  89.                 // Set star's random position  
  90.                 s.position =  
  91.                     new Vector2(  
  92.                         -1 * (Screen.width / 2) + 50 + Random.value * (Screen.width - 100),  
  93.                         (Screen.height / 2) - 40 - Random.value * (Screen.height - 80));  
  94.                 // Set star's name  
  95.                 s.name = "star" + x;  
  96.                 s.depth = 100 + x;  
  97.                 // Link star to parent  
  98.                 s.transform.parent = stars.transform;  
  99.             }  
  100.         }  
  101.     }  
  102.   
  103.     // Application initialization  
  104.     void Initialize()  
  105.     {  
  106.         // Create all objects for this demo  
  107.         CreateObjects();  
  108.         // Set initialization notifier - we only need to initialize once.  
  109.         initialized = true;  
  110.     }  
  111.   
  112.       
  113.     // Update is called once per frame  
  114.     void Update () {  
  115.         // Only go one when Orthello is initialized  
  116.         if (!OT.isValid) return;  
  117.   
  118.         // Call initialization once from this Update() so we can be sure all  
  119.         // Orthello objects have been started  
  120.         if (!initialized)  
  121.             Initialize();  
  122.     }  
  123. }  

下面是运动的物体，简称star
[csharp] view plaincopy
  1. public class CStar2 : MonoBehaviour {  
  2.   
  3.     OTSprite sprite;                    // This star's sprite class  
  4.     Vector2 speed =                     // Star movement speed / second  
  5.         new Vector2(150, 150);            
  6.     float rotation = 90;                // Star rotation speed / second   
  7.   
  8.     Color startColor =  
  9.         new Color(0.5f, 1f, 0.5f);    // Star's tint color  
  10.     Color stayColor =   
  11.         new Color(1f, 1f, 1f);     // Star's tint color when overlapping  
  12.   
  13.     // Use this for initialization  
  14.     void Start () {  
  15.         // get this star's sprite class  
  16.         sprite = GetComponent<OTSprite>();  
  17.         // Set this sprite's stay/exit/collision delegates  
  18.         // HINT : We could use sprite.InitCallBacks(this) as well.  
  19.         // but because delegates are the C# way we will use this technique  
  20.         sprite.onStay = OnStay;  
  21.         sprite.onExit = OnExit;  
  22.         sprite.onCollision = OnCollision;  
  23.         // Create a random speed for this star  
  24.         speed = new Vector2(150 + 150 * Random.value, 150 + 150 * Random.value);  
  25.         // Set star's color  
  26.         sprite.tintColor = startColor;  
  27.         // register the start material so we can use it later for assignment  
  28.         OT.RegisterMaterial("Star-start", new Material(sprite.material));  
  29.         var m = new Material(sprite.material);  
  30.         // register the material so we can use it later for assignment  
  31.         m.SetColor("_EmisColor", stayColor);  
  32.         OT.RegisterMaterial("Star-stay", m);  
  33.     }  
  34.       
  35.     // Update is called once per frame  
  36.     void Update () {  
  37.         // adjust this star's position  
  38.         sprite.position += speed * Time.deltaTime;  
  39.         // adjust this star's rotation  
  40.         sprite.rotation  += (rotation * Time.deltaTime);  
  41.     }  
  42.   
  43.     // OnStay delegate is called when star enters (overlaps) another 'collidable' object  
  44.     // !IMPORTANT - This sprite's collidable setting has to be true otherwide  
  45.     // collision delegates will not be called  
  46.     /// <exclude />  
  47.     public void OnStay(OTObject owner)  
  48.     {  
  49.         // check if we entered another star and adjust color if we did  
  50.         if (owner.collisionObject.name.IndexOf("star") == 0)  
  51.             sprite.material = OT.LookupMaterial("Star-stay");  
  52.     }  
  53.     // OnExit delegate is called when star no longer overlaps another 'collidable' object  
  54.     /// <exclude />  
  55.     public void OnExit(OTObject owner)  
  56.     {  
  57.         // check if we have left another star and adjust color if we did  
  58.         if (owner.collisionObject.name.IndexOf("star") == 0)  
  59.             sprite.material = OT.LookupMaterial("Star-start");  
  60.     }  
  61.     // OnCollision delegate is called when star collides with another 'collidable' object  
  62.     // HINT - OnEnter and OnCollision delegates are called exactly at the same time, the only  
  63.     // difference is their naming convention  
  64.     /// <exclude />  
  65.     public void OnCollision(OTObject owner)  
  66.     {  
  67.         // check if we collided with a top block and adjust our speed and rotation accordingly  
  68.         if (owner.collisionObject.name.IndexOf("top") == 0 && speed.y > 0)  
  69.         {  
  70.             speed = new Vector2(speed.x, speed.y * -1);  
  71.             if ((speed.x < 0 && rotation > 0) || (speed.x > 0 && rotation < 0))  
  72.                 rotation *= -1;  
  73.         }  
  74.         else  
  75.             // check if we collided with a bottom block and adjust our speed and rotation accordingly  
  76.             if (owner.collisionObject.name.IndexOf("bottom") == 0 && speed.y < 0)  
  77.             {  
  78.                 speed = new Vector2(speed.x, speed.y * -1);  
  79.                 if ((speed.x < 0 && rotation < 0) || (speed.x > 0 && rotation > 0))  
  80.                     rotation *= -1;  
  81.             }  
  82.             else  
  83.                 // check if we collided with a left block and adjust our speed and rotation accordingly  
  84.                 if (owner.collisionObject.name.IndexOf("left") == 0 && speed.x < 0)  
  85.                 {  
  86.                     speed = new Vector2(speed.x * -1, speed.y);  
  87.                     if ((speed.y < 0 && rotation > 0) || (speed.y > 0 && rotation < 0))  
  88.                         rotation *= -1;  
  89.                 }  
  90.                 else  
  91.                     // check if we collided with a right block and adjust our speed and rotation accordingly  
  92.                     if (owner.collisionObject.name.IndexOf("right") == 0 && speed.x > 0)  
  93.                     {  
  94.                         speed = new Vector2(speed.x * -1, speed.y);  
  95.                         if ((speed.y < 0 && rotation < 0) || (speed.y > 0 && rotation > 0))  
  96.                             rotation *= -1;  
  97.                     }  
  98.     }  
  99.   
  100. }  

下面是边界
[csharp] view plaincopy
  1. public class CBlock2 : MonoBehaviour {  
  2.   
  3.     OTSprite sprite;                // This block's sprite class  
  4.     bool colorFade = false;         // color fade notifier  
  5.     float fadeTime = 0;             // fade time counter  
  6.     float fadeSpeed = 0.25f;         // fade speed  
  7.       
  8.     Color startColor =   
  9.         new Color(0.3f, 0.3f, 0.3f); // block color  
  10.   
  11.     // Use this for initialization  
  12.     void Start () {  
  13.         // Lookup this block's sprite  
  14.         sprite = GetComponent<OTSprite>();  
  15.         // Set this sprite's collision delegate   
  16.         // HINT : We could use sprite.InitCallBacks(this) as well.  
  17.         // but because delegates are the C# way we will use this technique  
  18.         sprite.onCollision = OnCollision;  
  19.         // Set this block's tinting to the start color  
  20.         sprite.tintColor = startColor;  
  21.         // Register this material with Orthello so we can re-use it later  
  22.         OT.RegisterMaterial("Block-start", new Material(sprite.material));  
  23.         // Generate Highlight materials and store them  
  24.         for (int i=0; i<10; i++)  
  25.         {  
  26.             var m = new Material(sprite.material);  
  27.             m.SetColor("_EmisColor", Color.Lerp(Color.white,startColor,0.1f * i));  
  28.             OT.RegisterMaterial("Block-tint"+i, m);              
  29.         }  
  30.     }  
  31.   
  32.     // Update is called once per frame  
  33.     void Update()  
  34.     {  
  35.         if (colorFade)  
  36.         {  
  37.             // We are color fading so set block's color to fade time dependend color  
  38.             int fadeIndex = (int)(Mathf.Floor((fadeTime / fadeSpeed) * 10));  
  39.             sprite.material = OT.LookupMaterial("Block-tint" + fadeIndex);  
  40.             // Incement fade time  
  41.             fadeTime += Time.deltaTime;  
  42.             if (fadeTime >= fadeSpeed)  
  43.             {  
  44.                 // We have faded long enough  
  45.                 colorFade = false;  
  46.   
  47.                 if (OT.LookupMaterial("Block-start") == null)  
  48.                     print("Block-start material not found!");  
  49.   
  50.                 // Set block's color to start color  
  51.                 sprite.material = OT.LookupMaterial("Block-start");  
  52.             }  
  53.         }  
  54.     }  
  55.   
  56.     // This method will be called when this block is hit.  
  57.     /// <exclude />  
  58.     public void OnCollision(OTObject owner)  
  59.     {  
  60.         // Set color fading indicator  
  61.         colorFade = true;  
  62.         // Reset fade time  
  63.         fadeTime = 0;  
  64.     }  
  65.   
  66. }  

先贴完代码，以后慢慢补全

於
標籤：