与同学的结对软件工程

结对成员：

                          姓名：王刚德     学号：201303011130

                          姓名：徐文涛     学号：201303011161              

            我们的心得：

                   软件工程第二次作业的结对编程，我和我的队友万炼炼设计了一个基于unity3d的魔方游戏，通过在网上边学习边操作的方式，了解了unity3d游戏引擎的基本机制， 同时也深刻体会到要做出一个软件，团队合作的重要性。在这次结对编程中，我主要担任的是代码的编写，以及游戏逻辑的设计。万炼炼同学主要负责的是游戏资源的管理，以及游戏的整体设计。unity是一款强大的3d游戏引擎，目前市面上大部分流行的3d游戏都可以用u3d来设计，我们设计的魔方游戏虽然简单，但也付出了一定的心血，其中涉及到对每一层魔方的旋转，还包括横向旋转和竖向旋转。在游戏中还要兼顾到玩家的体验，比如在游戏中可以旋转视图来让玩家更好地来观察魔方的几个面的变化。

主要的脚本程序：

 

[csharp] view plaincopy
 
  1. #endregion    
  2.      
  3.     #region Easing Curves  
  4.       
  5.     private float linear(float start, float end, float value){  
  6.         return Mathf.Lerp(start, end, value);  
  7.     }  
  8.       
  9.     private float clerp(float start, float end, float value){  
  10.         float min = 0.0f;  
  11.         float max = 360.0f;  
  12.         float half = Mathf.Abs((max - min) / 2.0f);  
  13.         float retval = 0.0f;  
  14.         float diff = 0.0f;  
  15.         if ((end - start) < -half){  
  16.             diff = ((max - start) + end) * value;  
  17.             retval = start + diff;  
  18.         }else if ((end - start) > half){  
  19.             diff = -((max - end) + start) * value;  
  20.             retval = start + diff;  
  21.         }else retval = start + (end - start) * value;  
  22.         return retval;  
  23.     }  
  24.   
  25.     private float spring(float start, float end, float value){  
  26.         value = Mathf.Clamp01(value);  
  27.         value = (Mathf.Sin(value * Mathf.PI * (0.2f + 2.5f * value * value * value)) * Mathf.Pow(1f - value, 2.2f) + value) * (1f + (1.2f * (1f - value)));  
  28.         return start + (end - start) * value;  
  29.     }  
  30.   
  31.     private float easeInQuad(float start, float end, float value){  
  32.         end -= start;  
  33.         return end * value * value + start;  
  34.     }  
  35.   
  36.     private float easeOutQuad(float start, float end, float value){  
  37.         end -= start;  
  38.         return -end * value * (value - 2) + start;  
  39.     }  
  40.   
  41.     private float easeInOutQuad(float start, float end, float value){  
  42.         value /= .5f;  
  43.         end -= start;  
  44.         if (value < 1) return end / 2 * value * value + start;  
  45.         value--;  
  46.         return -end / 2 * (value * (value - 2) - 1) + start;  
  47.     }  
  48.   
  49.     private float easeInCubic(float start, float end, float value){  
  50.         end -= start;  
  51.         return end * value * value * value + start;  
  52.     }  
  53.   
  54.     private float easeOutCubic(float start, float end, float value){  
  55.         value--;  
  56.         end -= start;  
  57.         return end * (value * value * value + 1) + start;  
  58.     }  
  59.   
  60.     private float easeInOutCubic(float start, float end, float value){  
  61.         value /= .5f;  
  62.         end -= start;  
  63.         if (value < 1) return end / 2 * value * value * value + start;  
  64.         value -= 2;  
  65.         return end / 2 * (value * value * value + 2) + start;  
  66.     }  
  67.   
  68.     private float easeInQuart(float start, float end, float value){  
  69.         end -= start;  
  70.         return end * value * value * value * value + start;  
  71.     }  
  72.   
  73.     private float easeOutQuart(float start, float end, float value){  
  74.         value--;  
  75.         end -= start;  
  76.         return -end * (value * value * value * value - 1) + start;  
  77.     }  
  78.   
  79.     private float easeInOutQuart(float start, float end, float value){  
  80.         value /= .5f;  
  81.         end -= start;  
  82.         if (value < 1) return end / 2 * value * value * value * value + start;  
  83.         value -= 2;  
  84.         return -end / 2 * (value * value * value * value - 2) + start;  
  85.     }  
  86.   
  87.     private float easeInQuint(float start, float end, float value){  
  88.         end -= start;  
  89.         return end * value * value * value * value * value + start;  
  90.     }  
  91.   
  92.     private float easeOutQuint(float start, float end, float value){  
  93.         value--;  
  94.         end -= start;  
  95.         return end * (value * value * value * value * value + 1) + start;  
  96.     }  
  97.   
  98.     private float easeInOutQuint(float start, float end, float value){  
  99.         value /= .5f;  
  100.         end -= start;  
  101.         if (value < 1) return end / 2 * value * value * value * value * value + start;  
  102.         value -= 2;  
  103.         return end / 2 * (value * value * value * value * value + 2) + start;  
  104.     }  
  105.   
  106.     private float easeInSine(float start, float end, float value){  
  107.         end -= start;  
  108.         return -end * Mathf.Cos(value / 1 * (Mathf.PI / 2)) + end + start;  
  109.     }  
  110.   
  111.     private float easeOutSine(float start, float end, float value){  
  112.         end -= start;  
  113.         return end * Mathf.Sin(value / 1 * (Mathf.PI / 2)) + start;  
  114.     }  
  115.   
  116.     private float easeInOutSine(float start, float end, float value){  
  117.         end -= start;  
  118.         return -end / 2 * (Mathf.Cos(Mathf.PI * value / 1) - 1) + start;  
  119.     }  
  120.   
  121.     private float easeInExpo(float start, float end, float value){  
  122.         end -= start;  
  123.         return end * Mathf.Pow(2, 10 * (value / 1 - 1)) + start;  
  124.     }  
  125.   
  126.     private float easeOutExpo(float start, float end, float value){  
  127.         end -= start;  
  128.         return end * (-Mathf.Pow(2, -10 * value / 1) + 1) + start;  
  129.     }  
  130.   
  131.     private float easeInOutExpo(float start, float end, float value){  
  132.         value /= .5f;  
  133.         end -= start;  
  134.         if (value < 1) return end / 2 * Mathf.Pow(2, 10 * (value - 1)) + start;  
  135.         value--;  
  136.         return end / 2 * (-Mathf.Pow(2, -10 * value) + 2) + start;  
  137.     }  
  138.   
  139.     private float easeInCirc(float start, float end, float value){  
  140.         end -= start;  
  141.         return -end * (Mathf.Sqrt(1 - value * value) - 1) + start;  
  142.     }  
  143.   
  144.     private float easeOutCirc(float start, float end, float value){  
  145.         value--;  
  146.         end -= start;  
  147.         return end * Mathf.Sqrt(1 - value * value) + start;  
  148.     }  
  149.   
  150.     private float easeInOutCirc(float start, float end, float value){  
  151.         value /= .5f;  
  152.         end -= start;  
  153.         if (value < 1) return -end / 2 * (Mathf.Sqrt(1 - value * value) - 1) + start;  
  154.         value -= 2;  
  155.         return end / 2 * (Mathf.Sqrt(1 - value * value) + 1) + start;  
  156.     }  
  157.   
  158.       
  159.     private float easeInBounce(float start, float end, float value){  
  160.         end -= start;  
  161.         float d = 1f;  
  162.         return end - easeOutBounce(0, end, d-value) + start;  
  163.     }  
  164.   
  165.     private float easeOutBounce(float start, float end, float value){  
  166.         value /= 1f;  
  167.         end -= start;  
  168.         if (value < (1 / 2.75f)){  
  169.             return end * (7.5625f * value * value) + start;  
  170.         }else if (value < (2 / 2.75f)){  
  171.             value -= (1.5f / 2.75f);  
  172.             return end * (7.5625f * (value) * value + .75f) + start;  
  173.         }else if (value < (2.5 / 2.75)){  
  174.             value -= (2.25f / 2.75f);  
  175.             return end * (7.5625f * (value) * value + .9375f) + start;  
  176.         }else{  
  177.             value -= (2.625f / 2.75f);  
  178.             return end * (7.5625f * (value) * value + .984375f) + start;  
  179.         }  
  180.     }  
  181.       
  182.     private float easeInOutBounce(float start, float end, float value){  
  183.         end -= start;  
  184.         float d = 1f;  
  185.         if (value < d/2) return easeInBounce(0, end, value*2) * 0.5f + start;  
  186.         else return easeOutBounce(0, end, value*2-d) * 0.5f + end*0.5f + start;  
  187.     }  
  188.       
  189.   
  190.     private float easeInBack(float start, float end, float value){  
  191.         end -= start;  
  192.         value /= 1;  
  193.         float s = 1.70158f;  
  194.         return end * (value) * value * ((s + 1) * value - s) + start;  
  195.     }  
  196.   
  197.     private float easeOutBack(float start, float end, float value){  
  198.         float s = 1.70158f;  
  199.         end -= start;  
  200.         value = (value / 1) - 1;  
  201.         return end * ((value) * value * ((s + 1) * value + s) + 1) + start;  
  202.     }  
  203.   
  204.     private float easeInOutBack(float start, float end, float value){  
  205.         float s = 1.70158f;  
  206.         end -= start;  
  207.         value /= .5f;  
  208.         if ((value) < 1){  
  209.             s *= (1.525f);  
  210.             return end / 2 * (value * value * (((s) + 1) * value - s)) + start;  
  211.         }  
  212.         value -= 2;  
  213.         s *= (1.525f);  
  214.         return end / 2 * ((value) * value * (((s) + 1) * value + s) + 2) + start;  
  215.     }  
  216.   
  217.     private float punch(float amplitude, float value){  
  218.         float s = 9;  
  219.         if (value == 0){  
  220.             return 0;  
  221.         }  
  222.         if (value == 1){  
  223.             return 0;  
  224.         }  
  225.         float period = 1 * 0.3f;  
  226.         s = period / (2 * Mathf.PI) * Mathf.Asin(0);  
  227.         return (amplitude * Mathf.Pow(2, -10 * value) * Mathf.Sin((value * 1 - s) * (2 * Mathf.PI) / period));  
  228.     }  
  229.       
  230.       
  231.     private float easeInElastic(float start, float end, float value){  
  232.         end -= start;  
  233.           
  234.         float d = 1f;  
  235.         float p = d * .3f;  
  236.         float s = 0;  
  237.         float a = 0;  
  238.           
  239.         if (value == 0) return start;  
  240.           
  241.         if ((value /= d) == 1) return start + end;  
  242.           
  243.         if (a == 0f || a < Mathf.Abs(end)){  
  244.             a = end;  
  245.             s = p / 4;  
  246.             }else{  
  247.             s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);  
  248.         }  
  249.           
  250.         return -(a * Mathf.Pow(2, 10 * (value-=1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p)) + start;  
  251.     }         
  252.       
  253.       
  254.     private float easeOutElastic(float start, float end, float value){  
  255.       
  256.         //Thank you to rafael.marteleto for fixing this as a port over from Pedro's UnityTween  
  257.         end -= start;  
  258.           
  259.         float d = 1f;  
  260.         float p = d * .3f;  
  261.         float s = 0;  
  262.         float a = 0;  
  263.           
  264.         if (value == 0) return start;  
  265.           
  266.         if ((value /= d) == 1) return start + end;  
  267.           
  268.         if (a == 0f || a < Mathf.Abs(end)){  
  269.             a = end;  
  270.             s = p / 4;  
  271.             }else{  
  272.             s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);  
  273.         }  
  274.           
  275.         return (a * Mathf.Pow(2, -10 * value) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p) + end + start);  
  276.     }         
  277.       
  278.       
  279.     private float easeInOutElastic(float start, float end, float value){  
  280.         end -= start;  
  281.           
  282.         float d = 1f;  
  283.         float p = d * .3f;  
  284.         float s = 0;  
  285.         float a = 0;  
  286.           
  287.         if (value == 0) return start;  
  288.           
  289.         if ((value /= d/2) == 2) return start + end;  
  290.           
  291.         if (a == 0f || a < Mathf.Abs(end)){  
  292.             a = end;  
  293.             s = p / 4;  
  294.             }else{  
  295.             s = p / (2 * Mathf.PI) * Mathf.Asin(end / a);  
  296.         }  
  297.           
  298.         if (value < 1) return -0.5f * (a * Mathf.Pow(2, 10 * (value-=1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p)) + start;  
  299.         return a * Mathf.Pow(2, -10 * (value-=1)) * Mathf.Sin((value * d - s) * (2 * Mathf.PI) / p) * 0.5f + end + start;  
  300.     }         
  301.     /* GFX47 MOD END */  
  302.      
  303.     #endregion    
  304.      
  305.     #region Deprecated and Renamed  
  306.  
  307.     #endregion  
  308. }   

 

 

在游戏的基础上我们还添加了快捷输入公式功能，能够让你在输入公式过后魔方自动执行步骤。由于这只是基础版的，游戏也只是开发出了一个雏形，后来可以添加一些计时功能，或者能够网络对战。

 

      第一次结对的，感触算是认识到了：

       1）两个人一起写，代码质量可以得到很大的保证，避免犯很多小错误，细节考虑更全面，代码风格也可以保持一致。而且我相信完全可以提高工作效率，因为当有另外一个人就坐在你身边负责审查你的代码的时候，你是不可能忽略他的。

　　 2）同时最起码有两个人熟悉这一段代码，这对代码以后的维护，项目的运营都是很有好处的。

　　 3）当你在另一个开发伙伴身边坐下并一起工作的时候，你总可以从他身上学到一些诀窍和技术。这样，参与的双方都可以快速的学习进步。

　　 4）两个员工之间当面相互的交流，很直接，很容易碰出火花。很多人看来，程序员似乎是一个很木讷的人，但实际上很多时候，程序员只是觉得跟你没有共同语言，熟称的看不起你的智商（我认为程序员是一个很自傲又很自卑的群体，但这个跟本文没有关系）。但如果跟对方有相应的互动，程序员可以表现的很善谈，很自信。这样，世界上就有多了一对基佬。多美好的事

这个结对编程过程中，我和同伴轮流编程，轮流检测，轮流查阅资料，由于是自带的3d引擎，感觉也比较耗性能，特别是3d渲染，还有对每一帧的更新也比较吃cpu和显卡，程序自身比较简单，这次能够在unity3d上运行一个小小成功算是一种学习吧。

posted @ 2015-05-16 23:59  德者天下  阅读(253)  评论(9)  编辑  收藏  举报