[unity for android]第三人称视角研究

本次学习：

1.第三人称视角研究

2.摇杆区域制作

3.视角限制设计

4.简单的战斗部分

 

1.第三人称视角研究

第三人称视角是什么大家玩玩游戏就懂了-0- 羽化不是专业制作人，只是一个玩家，下面是羽化玩家身份的总结出来的一些经验，很多词汇非专业，见谅。。。

1.人物移动 玩过魔兽世界的玩家可能都知道W A S D可以控制人物往8个方向移动，但人的面向不会改变，意味着有左移右移和后退等动作，羽化认为这样设计比较有真实感，而且效果很好，但有些游戏比如神鬼寓言就有所改变，W A S D不仅可以控制移动方向，而且还能改变人的面向，这种设计更加灵活，适合ACT，不适合ARPG，所以羽化这是做的一个ARPG，使用的是魔兽世界的移动标准，摇杆第一次点进区域就可自由移动，原来羽化就是这么想的，看到混乱与秩序的摇杆后觉得更加合理，所以就借鉴了下。

2.视角移动 ARPG也有很多种视角，有斜45°类似火炬之光这种，也有魔兽世界一样360°的，羽化原来做过斜45°的Demo，固定视角可以解决很多问题，但也伴随着更棘手的问题，既然公司要求，所以就做了这个360°的视角转换，包括手势放大缩小。视角改变很容易，但当视角更改以后问题出现了，玩过魔兽世界包括众多自由视角游戏的玩家都知道视角虽然可以随便移动，但存在着很多约束，比如你向上滑动时，视角不可能穿过地面而到地下，一定会沿着人的方向放大，这是前人给我们的经验，比如有一个物体挡在人物和玩家中间时，视角应该拉近，这样就不会产生视觉死角，诸如此类的情况很多，就运用到了射线Ray，进入我们今天的主题。

 

         大家可以看到，羽化这个Demo用的东西也不多，这是前期的一个Demo，还不算完整，如果有机会给大家分享下羽化现在的Demo。

 

2.摇杆区域制作

         触摸屏发展至今，羽化见过最好大的移动摇杆莫过于“混乱与秩序”的移动摇杆了，本身摇杆制作并不困难，主要是学习下这种为玩家带来方便的思维模式，先把代码送上：

Rocker.js：

[javascript] view
plaincopyprint?

  1. //移动速度  
  2. var Speed : float = 0.05;  
  3. //视角转动速度  
  4. var Speed_L : float = 0.1;  
  5. //角色  
  6. var Role : Transform;  
  7. //人称视角  
  8. var Player_true : Transform;  
  9. //攻击预设  
  10. var AttackPrafab : Transform;  
  11. //攻击方向  
  12. var AttackRange : Transform;  
  13.   
  14. //第一点按下的初始点  
  15. private var PO_X : int = 0;  
  16. private var PO_Y : int = 0;  
  17. //第二点按下的初始点  
  18. private var PT_X : int = 0;  
  19. private var PT_Y : int = 0;  
  20. //判断人是否移动  
  21. static var PR_M : boolean = false;  
  22. //触摸点的记录  
  23. private var PM_X : int = 0;  
  24. private var PM_Y : int = 0;  
  25. //第二点按下的初始点  
  26. private var PS_X : int = 0;  
  27. private var PS_Y : int = 0;  
  28. //触摸点与中心点的距离  
  29. private var M_X : int = 0;  
  30. private var M_Y : int = 0;  
  31. //中心的坐标   
  32. private var PC_X : int = 0;  
  33. private var PC_Y : int = 0;  
  34. //旋转变量  
  35. private var touchDeltaPosition : Vector2;  
  36. //两点静态和动态距离  
  37. private var Distance : int = 0;  
  38. private var Distance_D : int = 0;   
  39. //记录摄像机距离  
  40. static var Camera_Record : float = -2.0;  
  41. //两点的角度  
  42. static var Angles : int = 0;  
  43. //战斗焦点  
  44. static var Focus : boolean = false;  
  45. //打击点  
  46. private var hit : RaycastHit;  
  47. //敌人方位  
  48. private var Enemie : Vector3;  
  49. //攻击模式范围  
  50. private var Range : float = 6.0;  
  51. //记录时间  
  52. private var CreationTime : double = -10.0;  
  53. //处于攻击动作  
  54. private var Attacking : boolean = false;  
  55. //Test  
  56. static var Test = 0.0;  
  57.   
  58. function Update()  
  59. {  
  60. //记录游戏时间  
  61.     //Test = Time.time;  
  62. //战斗状态  
  63.     if(Focus)  
  64.     {  
  65.         if(Vector3.Distance(transform.position,Enemie) > Range)  
  66.         {  
  67.             Focus = false;  
  68.             Camera.main.depth = -1;  
  69.             return;  
  70.         }  
  71.         Camera.main.depth = -3;  
  72.         transform.LookAt(Enemie);  
  73.         Player_true.transform.LookAt(Enemie);  
  74.     }  
  75. //攻击预设  
  76.     if(Time.time > (CreationTime + 0.5) && Role.animation.IsPlaying("Attack") && Attacking)  
  77.     {  
  78.         Instantiate(AttackPrafab, AttackRange.transform.position,Quaternion.identity);  
  79.         Attacking = false;  
  80.     }  
  81. //单点触摸时  
  82.     if (Input.touchCount == 1)  
  83.     {  
  84.         Player_Move();  
  85.         Attack();  
  86.         //退出  
  87.         if(Input.GetTouch(0).position.y > Screen.height - 50 && Input.GetTouch(0).position.x > Screen.width - 50)  
  88.         {  
  89.             Application.Quit();  
  90.         }  
  91.     }  
  92. //多点触摸时  
  93.     else if (Input.touchCount == 2)  
  94.     {  
  95.         Player_Move();  
  96.         Player_Look();  
  97.         Attack();  
  98.     }  
  99. }  
  100.   
  101. //角色移动和静态视角  
  102. function Player_Move()  
  103. {  
  104.     switch(Input.GetTouch(0).phase)  
  105.     {  
  106.         case TouchPhase.Began:        
  107.             PO_X = Input.GetTouch(0).position.x;  
  108.             PO_Y = Input.GetTouch(0).position.y;  
  109.             PC_X = PO_X;  
  110.             PC_Y = PO_Y;  
  111.               
  112.             var ray = Camera.main.ScreenPointToRay (Input.GetTouch(0).position);  
  113.             if (Physics.Raycast (ray, hit))   
  114.             {  
  115.                 if(hit.collider.gameObject.tag == "Enemies")  
  116.                 {  
  117.                     Focus = true;     
  118.                     Enemie = hit.transform.position;  
  119.                 }  
  120.                 else if((PO_X > 200 || PO_Y > 200) && (PO_X < Screen.width - 100 || PO_Y > 100))  
  121.                 {  
  122.                     Focus = false;    
  123.                     Camera.main.depth = -1;  
  124.                 }  
  125.             }  
  126.             break;  
  127.         case TouchPhase.Moved:  
  128.             PM_X = Input.GetTouch(0).position.x;  
  129.             PM_Y = Input.GetTouch(0).position.y;  
  130.             if(PO_X < 200 && PO_Y < 200 && PO_X > 0 && PO_Y > 0)  
  131.             {  
  132.                 PR_M = true;  
  133.             }  
  134.             else if(Input.touchCount == 1)  
  135.             {  
  136.                 touchDeltaPosition = Input.GetTouch(0).deltaPosition;  
  137.                 //视角限制  
  138.                 if(Player_true.transform.localEulerAngles.x <= 60 || Player_true.transform.localEulerAngles.x >= 310)  
  139.                 {  
  140.                     Player_true.transform.Rotate(Vector3(touchDeltaPosition.y,touchDeltaPosition.x,0) * Time.deltaTime * 100 * Speed_L, Space.World);  
  141.                 }  
  142.                 else if(Player_true.transform.localEulerAngles.x < 310 && Player_true.transform.localEulerAngles.x > 200)  
  143.                 {  
  144.                     Player_true.transform.localEulerAngles.x = 311;  
  145.                 }  
  146.                 else if(Player_true.transform.localEulerAngles.x > 60 && Player_true.transform.localEulerAngles.x < 200)  
  147.                 {  
  148.                     Player_true.transform.localEulerAngles.x = 59;  
  149.                 }  
  150.                 Player_true.transform.localEulerAngles.z = 0;  
  151.             }  
  152.             break;  
  153.         case TouchPhase.Ended:  
  154.             PO_X = 0;  
  155.             PO_Y = 0;  
  156.             PM_X = 0;  
  157.             PM_Y = 0;  
  158.             PC_X = 0;  
  159.             PC_Y = 0;  
  160.             PR_M = false;  
  161.             Role.animation.Stop("Run");  
  162.             Role.animation.Stop("Back");  
  163.             Role.animation.Stop("Right");  
  164.             Role.animation.Stop("Left");  
  165.             Role.animation.PlayQueued("Wait", QueueMode.CompleteOthers);  
  166.             break;  
  167.     }  
  168.   
  169.     if(PR_M)  
  170.     {  
  171.         M_X = PM_X - PC_X;  
  172.         M_Y = PM_Y - PC_Y;  
  173.         //求距离  
  174.         Distance = Mathf.Sqrt((M_X * M_X) + (M_Y * M_Y));  
  175.         //求角度  
  176.         Angles = Mathf.Atan2(M_X, M_Y)* Mathf.Rad2Deg;  
  177.           
  178.         if(Distance >= 50)  
  179.         {  
  180.             PC_X = PC_X*15/16 + PM_X/16;  
  181.             PC_Y = PC_Y*15/16 + PM_Y/16;  
  182.         }  
  183.           
  184.         //最大速度限制  
  185.         if(M_X > 40)  
  186.         {  
  187.             M_X = 40;  
  188.         }  
  189.         else if(M_X < -40)  
  190.         {  
  191.             M_X = -40;  
  192.         }  
  193.         if(M_Y > 50)  
  194.         {  
  195.             M_Y = 50;  
  196.         }  
  197.         else if(M_Y < -30)  
  198.         {  
  199.             M_Y = -30;  
  200.         }  
  201.           
  202.         //移动判断和优化  
  203.         if(Angles>=-45 && Angles <=45)  
  204.         {  
  205.             Role.animation.CrossFade("Run");  
  206.             if(Angles>=-20 && Angles <=20)  
  207.             {  
  208.                 M_X = 0;  
  209.             }  
  210.         }  
  211.         else if(Angles>=135 || Angles <=-135)  
  212.         {  
  213.             Role.animation.CrossFade("Back");  
  214.             if(Angles <=-160 || Angles>=160)  
  215.             {  
  216.                 M_X = 0;  
  217.             }  
  218.         }  
  219.         else if(Angles > 45 && Angles < 135)  
  220.         {  
  221.             Role.animation.CrossFade("Right");  
  222.             if(Angles>=70 && Angles <=110)  
  223.             {  
  224.                 M_Y = 0;  
  225.             }  
  226.         }  
  227.         else if(Angles > -135 && Angles < -45)  
  228.         {  
  229.             Role.animation.CrossFade("Left");  
  230.             if(Angles>=-110 && Angles <=-70)  
  231.             {  
  232.                 M_Y = 0;  
  233.             }  
  234.         }  
  235.           
  236.           
  237.         //转身  
  238.         transform.localRotation = Quaternion.Euler(0, Player_true.transform.localEulerAngles.y, 0);  
  239.         //var target = Quaternion.Euler (0, Player_true.transform.localEulerAngles.y, 0);  
  240.         //transform.rotation = Quaternion.Slerp(transform.rotation, target, Time.deltaTime * 2);  
  241.           
  242.         //移动  
  243.         transform.Translate(M_X * Time.deltaTime * Speed,0, M_Y * Time.deltaTime *Speed);  
  244.     }  
  245. }  
  246.   
  247. //游戏移动视角  
  248. function Player_Look()  
  249. {  
  250.     switch(Input.GetTouch(1).phase)  
  251.     {  
  252.         case TouchPhase.Began:   
  253.             PT_X = Input.GetTouch(1).position.x;  
  254.             PT_Y = Input.GetTouch(1).position.y;  
  255.             M_X = PO_X - PT_X;  
  256.             M_Y = PO_Y - PT_Y;  
  257.             Distance = Mathf.Sqrt((M_X * M_X) + (M_Y * M_Y));  
  258.             break;  
  259.         case TouchPhase.Moved:  
  260.             PS_X = Input.GetTouch(1).position.x;  
  261.             PS_Y = Input.GetTouch(1).position.y;  
  262.             if(PR_M && !Focus)  
  263.             {  
  264.                 touchDeltaPosition = Input.GetTouch(1).deltaPosition;  
  265.                 Player_true.transform.Rotate(Vector3(0,touchDeltaPosition.x,0) * Time.deltaTime * 160 * Speed_L, Space.World);  
  266.                 Player_true.transform.Rotate(Vector3(touchDeltaPosition.y,0,0) * Time.deltaTime * 90 * Speed_L, Space.World);  
  267.                 Player_true.transform.localEulerAngles.z = 0;  
  268.             }  
  269.             else if((PO_X > 200 || PO_Y > 200) && (PT_X > 200 || PT_Y > 200))  
  270.             {  
  271.                 M_X = PS_X - PM_X;  
  272.                 M_Y = PS_Y - PM_Y;  
  273.                 Distance_D = Mathf.Sqrt((M_X * M_X) + (M_Y * M_Y));  
  274.                 if(Distance - Distance_D > 20 && Camera.main.transform.localPosition.z <= 0)  
  275.                 {  
  276.                     Camera.main.transform.localPosition.z += 0.1;  
  277.                     Camera_Record = Camera.main.transform.localPosition.z;  
  278.                     Distance = Distance_D;  
  279.                 }  
  280.                 else if(Distance - Distance_D < -20 && Camera.main.transform.localPosition.z >= -4)  
  281.                 {  
  282.                     Camera.main.transform.localPosition.z -= 0.1;  
  283.                     Camera_Record = Camera.main.transform.localPosition.z;  
  284.                     Distance = Distance_D;  
  285.                 }  
  286.             }  
  287.             break;  
  288.         case TouchPhase.Ended:  
  289.             PT_X = 0;  
  290.             PT_Y = 0;  
  291.             PS_X = 0;  
  292.             PS_Y = 0;  
  293.             Distance = 0;  
  294.             Distance_D = 0;  
  295.             break;  
  296.     }  
  297. }  
  298.   
  299. //攻击判断  
  300. function Attack()  
  301. {  
  302.     //普通攻击  
  303.     if(Input.GetTouch(0).position.y < 100 && Input.GetTouch(0).position.x > Screen.width - 100 && !(Role.animation.IsPlaying("Attack")))  
  304.     {  
  305.         Role.animation.Play("Attack");  
  306.         Role.animation.CrossFadeQueued("Wait", 0.3,QueueMode.CompleteOthers);  
  307.         CreationTime = Time.time;  
  308.         Attacking = true;  
  309.     }  
  310.     //移动攻击  
  311.     else if(PR_M && Input.GetTouch(1).position.y < 100 && Input.GetTouch(1).position.x > Screen.width - 100 && !(Role.animation.IsPlaying("Attack")))  
  312.     {  
  313.         PR_M = false;  
  314.         Role.animation.CrossFadeQueued("Attack", 0.3, QueueMode.PlayNow);  
  315.         Role.animation.CrossFadeQueued("Wait", 0.3, QueueMode.CompleteOthers);  
  316.         CreationTime = Time.time;  
  317.         Attacking = true;  
  318.     }  
  319. }  
  320.   
  321. function OnGUI ()   
  322. {  
  323.     GUI.Box (Rect(0,Screen.height - 200,200,200), "Rocker");  
  324.     GUI.Box (Rect(Screen.width - 50,0,50,50), "Quit");  
  325.     GUI.Box (Rect(Screen.width - 100,Screen.height - 100,100,100), "Attack");  
  326. }  

 

 

         啊，好长，其实也不多，就300行+，上面有羽化的一些注释，大家可以看看这个脚本，Rocker是绑在Player上的，大家可以从上一张图看到，羽化见了两个Player，一个叫Player_True的物体其实是一个空物体里面放置了一些基本东西包括光和摄像机，旋转视角的时候就是旋转的Player_True，其中的好处只有用过的人才能了解吧～　～。羽化使用了预设制作攻击，这是个权益之计，以后说不定会改，这里最多判断了两个点的触控情况，羽化是分别判断的，这是吸取了前一个游戏的经验，这样不会乱，因为移动，攻击，转视角全部如果写在一个判断里面会造成很多冲突，羽化深有体会。

 

3.视角限制设计

         前面部分羽化用不了半天就完成了，后面的视角限制花了将近２天时间，当然个人能力有限也是原因吧。这是我这次博客的重头，如何运用射线，我们主要说说Physics.Raycast这个脚本的应用，在Unity帮助文档里面提到了，这里羽化尝试了下，最好使用Raycast
(origin : Vector3,direction : Vector3,out
hitInfo : RaycastHit,distance : float = Mathf.Infinity,layerMask
: int = kDefaultRaycastLayers)，这个方法，别的不一定靠谱。。。有的地面会莫名其妙穿过去。

CameraZoom.js：

[javascript] view
plaincopyprint?

  1. var Up : Transform;  
  2. private var Forward : boolean = false;  
  3. private var Back : boolean = false;  
  4.   
  5. function Update ()   
  6. {  
  7.     //通过向下和前后激光判断视角  
  8.     var layerMask = 1 << 2;  
  9.     layerMask = ~layerMask;  
  10.       
  11.     var hit : RaycastHit;  
  12.       
  13.     //向前激光　判断中间阻挡的镜头靠近  
  14.     if(Physics.Raycast (transform.position, Camera.main.transform.TransformDirection (Vector3.forward), hit, (-Camera.main.transform.localPosition.z)))   
  15.     {  
  16.         Forward = true;  
  17.         var distanceToForward = hit.distance;  
  18.         if(Camera.main.transform.localPosition.z < - 0.5)  
  19.         {  
  20.             Camera.main.transform.localPosition.z += 0.05;  
  21.         }  
  22.     }  
  23.     else  
  24.     {  
  25.         Forward = false;  
  26.     }  
  27.       
  28.     //向后激光　判断后退时靠墙的镜头拉近  
  29.     if(Physics.Raycast (transform.position, Camera.main.transform.TransformDirection (Vector3.forward * (-1)), hit, 0.2,layerMask))   
  30.     {  
  31.         Back = true;  
  32.         var distanceToBack = hit.distance;  
  33.         if(distanceToBack > 0.1)  
  34.         {  
  35.             Back = false;  
  36.         }  
  37.     }  
  38.       
  39.     //向下激光　用于判断下拉镜头的拉近  
  40.     if (Physics.Raycast (transform.position, -Vector3.up, hit , (-2) * Rocker.Camera_Record, layerMask))  
  41.     {  
  42.         var distanceToGround = hit.distance;  
  43.         //print(distanceToGround);  
  44.     }  
  45.     if(distanceToGround < 0.1)  
  46.     {  
  47.         Camera.main.transform.localPosition.z += 0.1;  
  48.     }  
  49.     else if(Camera.main.transform.localPosition.z > Rocker.Camera_Record && distanceToGround > 0.2 && !Back && !Forward)  
  50.     {  
  51.         Camera.main.transform.localPosition.z -= 0.02;  
  52.         Camera.main.transform.localPosition.y = 0.6;  
  53.     }  
  54.       
  55.     if(!Rocker.Focus)  
  56.     {  
  57.         transform.LookAt(Up);  
  58.     }  
  59. }  
  60.   
  61. function OnTriggerStay (other : Collider)   
  62. {  
  63.     if (/*other.attachedRigidbody &&*/ Camera.main.transform.localPosition.z < - 0.4)   
  64.     {  
  65.         Camera.main.transform.localPosition.z += 0.02;  
  66.     }  
  67.     Back = true;  
  68. }  
  69.   
  70. function OnTriggerExit (other : Collider)   
  71. {  
  72.     Back = false;  
  73. }  

        首先，羽化开始认为只有一个射线就可以搞定了，结果一个射线什么都判断不了，后来羽化仔细想了想就写成了三个射线，加上一个判断，终于效果出现了，话说羽化在摄像机设置Collider，是怕一个不小心，玩家把整个地图看透了-0-　如果你想视角更舒畅点可以把other.attachedRigidbody的注释去掉。这里有个函数layerMask是判断射线穿过那个层的，以后肯定用得上，1<<2代码射线只能穿过前两层。

 

4.简单的战斗部分

       战斗部分很简单，做一个攻击预设，触发攻击动作时就产生预设，在极短时间给怪物造成伤害。绝大多数代码都在移动部分了，这里看看一个简单的AI。

AI.js：

[javascript] view
plaincopyprint?

  1. var range = 4;  
  2. var Player : Transform;  
  3. private var health = 10;  
  4.   
  5. function Update()   
  6. {  
  7.     Discover();  
  8. }  
  9.   
  10. function OnTriggerEnter (other : Collider)   
  11. {  
  12.     if (other.attachedRigidbody)   
  13.     {  
  14.         if(other.gameObject.tag == "Attack")  
  15.         {  
  16.             Rocker.Test = 10.2;  
  17.             transform.Find("Small").animation.CrossFade("Hit");  
  18.             transform.Find("Small").animation.CrossFadeQueued("Wait", 0.3,QueueMode.CompleteOthers);  
  19.             health--;  
  20.             if(health <= 0)  
  21.             {  
  22.                 transform.Find("Small").animation.CrossFade("Dead");  
  23.                 Rocker.Focus = false;  
  24.                 Camera.main.depth = -1;  
  25.                 transform.tag = "Dead";  
  26.             }  
  27.         }  
  28.     }  
  29. }  
  30.   
  31. function Discover()  
  32. {  
  33.     var layerMask = 1 << 3;  
  34.     layerMask = ~layerMask;  
  35.       
  36.     if(Vector3.Distance(transform.position,Player.position) > range)  
  37.     {  
  38.         return false;  
  39.     }  
  40.       
  41.     var hit : RaycastHit;  
  42.     if(Physics.Linecast(transform.position, Player.position,hit,layerMask))  
  43.     {  
  44.         if(hit.collider.gameObject.tag == "Player" && !(transform.Find("Small").animation.IsPlaying("Dead")))  
  45.         {  
  46.             transform.LookAt(Player);  
  47.             return true;  
  48.         }  
  49.         else  
  50.         {  
  51.             return false;  
  52.         }  
  53.     }  
  54.       
  55.     return true;  
  56. }  

       怪物在一定范围内会发现你，面朝向敌人，简单的AI，可以添加怪物行走等，这就看大家对自己什么要求了，当玩家点击怪物后会进入战斗视角，这时的移动时围绕怪物的，是不是很像Fable~ ~羽化的Demo就初步完成了，最后来张截图。

 

自己认为视角做得很棒，有什么不足还望指出~ ~

 本文转自羽化：http://blog.csdn.net/libeifs/article/details/6696424

APK下载地址：

http://dl.dbank.com/c0bbqt1p13

时间： 2024-09-17 04:25:10

[unity for android]第三人称视角研究的相关文章

[Unity3d]第一人称和第三人称视角完美切换

最近一直在搞3D漫游,在第一人称和第三人称视角切换碰到些问题,视角的例子我是导入的官方的character controller包,不得不佩服官方脚本语言的写法,看了一下写的很完美,新手估计比较难看懂,里面涉及到一些角度,还有向量等的计算,这就要求有一定的图形学的基础,我将官方的第一人称视角和第三人称视角结合了一下,但发现还是不那么容易,不仅仅只是简单的摄像机的切换和position以及rotation的赋值而已,当然这种方法适合第三人称切换至第一人称,而第一人称切换至第三人称你会发现根本方向就

[unity3d]第三人称视角相关脚本

//第三人称摄像机更随 var cameraTransform : Transform; //跟随相机 private var _target : Transform; //跟随物体 // The distance in the x-z plane to the target var distance = 7.0; //相机距离物理的距离 // the height we want the camera to be above the target var height = 3.0; //相机距

虚幻3引擎第三人称射击游戏《新纪元》发布

<新纪元(EPOCH)>是一款来自一只新的 Android平台开发团队Uppercut的作品,以世界末日为题材的射击类游戏,采用虚幻引擎打造,有着惊人的图形效果.<新纪元>主要采用掩护+射击为基础的操作方式以及过肩式的第三人称视角,玩家操作一台充满未知科幻的机械士兵.作为一款科幻射击游戏,开发商更加突出了科幻色彩,通过手指在屏幕的简单滑动就能做出绚丽的射击动作.新纪元新纪元新纪元就如同其他采用 虚幻3引擎的游戏如真实拳击和狂野之血一样,<新纪元>在图形效果上有着极为出色

《怪物射击2》评测：第三人称射击游戏新王者

第三人称射击游戏因其简单的玩法.直观的视角获得了玩家的青睐,其中<奇幻射击>.<僵尸之林>等作品更成为装机必备的精品游戏.今天推荐给大家的<怪物射击2>(Monster Shooter 2)就是这一类型的作品,小编个人认为它已经超越了<奇幻射击>和<僵尸之林>,成为安卓平台第三人称射击新王者.<怪物射击2>是<怪物射击>的续作,但在两者之间还夹着一个资料片--<怪物射击:失落破坏>.因此这一系列一共有三款游戏,

Android性能优化案例研究（下）

转自 http://www.importnew.com/4065.html 译者前言:在Android性能优化案例研究(上)中,作者Romain Guy将Falcon Pro这款应用作为例子,通过Android现有的工具追踪和分析了其隐藏的性能问题(重绘).下篇作者将会带来如何解决此类问题的方法和思路. 去掉冗余的图层 为 了去掉重绘我们必须首先理解它从哪里产生的.这就轮到Hierarchy Viewer和Tracer for OpenGL大显身手的时候了.Hierarchy Viewer是AD

求大神看看 unity导出android工程报错！！急！！！！

问题描述 求大神看看 unity导出android工程报错!!急!!!! CommandInvokationFailure: Android Asset Packaging Tool failed. See the Console for details. E:adt-bundle-windows-x86_64-20140702sdkbuild-tools21.1.1aapt.exe package -v -f -F raw.ap_ -A raw -0 """" s

感性第三人称射击网游《Squadflow》2011年公测

韩国游戏厂商Hanbit(韩光)日前宣布,旗下感性第三人称射击网游<Squadflow>团队从即日起对外募集研发人员,游戏预计于2011年内展开公测. 女主角-莉亚 <Squadflow>是一款诉求温暖感性背景的第三人称射击网游,游戏的背景建立在一座废弃的未来城市中,机器人在偶然间救起了女主角莉亚而展开了故事.<Squadflow>与传统的射击游戏不同,本作重在剧情的铺陈,随着玩家使命任务的走向不同,可以体验到不一样的游戏内容. Gstar2010上的现场试玩视频 去年

androidjavaclass-关于Unity调用android的jar包中的接口

问题描述 关于Unity调用android的jar包中的接口 void Update () { AndroidJavaClass jc = new AndroidJavaClass ("com.unity3d.player.UnityPlayer"); AndroidJavaObject jo = jc.GetStatic ("currentActivity"); int i = jo.Call ("Max",new object[]{10,20

第三人称射击网游《DIZZEL》二测开启游戏内容量升级

由韩国游戏大厂NEOWiz自行研发的第三人称射击网游<DIZZEL>日前即将展开二测,游戏内容更为丰富. <DIZZEL>是一款标榜残酷.血腥动作的射击网游,利用掩体进行战斗和使用各种刀具进行近距离战斗是其的主要特征.该游戏于去年12月第一次亮相,而在下月初即将开启的二测上,NEOWiz宣布将提升游戏的速度感和打击感,并以丰富内容为目的进行了进一步开发. <DIZZEL>的背景设定在未来时代,长期的战争和环境灾害使得地球逐渐荒芜.国家的权力系统崩溃,随之世界各地出现了小