2022软工K班结对编程任务

[王长彬032002227]

2022软工K班结对编程任务

Github链接

Bilibili链接

一、结对探索（4分）

1.1 队伍基本信息（1分）

结对编号：27；队伍名称：丸子馋冰淇淋；

学号	姓名	作业博客链接	具体分工
032002227	王长彬	https://bbs.csdn.net/topics/608611162	前端、后端接口、交互式页面、AI算法、数据计算
032002234	许锦欣	https://bbs.csdn.net/topics/608610696	原型设计、UI素材制作、视频制作、页面布局优化、前端

1.2 描述结对的过程（1分）

很自然就组一队了。经常一起吃饭，一起上课，擅长的技能点也不一样。

1.3 非摆拍的两人在讨论设计或结对编程过程的照片（2分）

二、原型设计（16分）

2.1 原型工具的选择（2分）

墨刀（yyds/简洁易上手）、ProKnockout 、Procreate、即时设计（figma）、iconpark。

2.2 遇到的困难与解决办法（3分）

困难：
1、素材查找：网上的资源很多但也很杂，想要找到心仪的素材需要花费一定的时间。

​ 解决办法：先找到喜欢的游戏页面布局进行模仿，通过ProKnockout 进行抠图和素材编辑，Procreate自行绘画素材，小图标从阿里图标库下载。

​ 2、动态组件的实现：之前没有使用过墨刀，了解了一下基础操作就开始原型设计了，动态组件需要添加不同状态和不同事件，刚开始有点乱不能实现理想效果。

​ 解决办法：熟能生巧，经过不断尝试之后领悟了其中的逻辑，就可以很好的解决页面动画、标签页中的嵌套等。

收获：最直接的收获就是学会了原型设计以及墨刀的使用，这是以前没有的技能（技能点加一）；然后发现原型设计除了页面UI外还有相关逻辑功能，可以很好地在实现程序前理清编程思路，提高编程效率。

2.3 原型作品链接（5分） （静态原型作品得2分，交互性强的原型作品得5分）

原型作品链接

小程序体验版二维码（看到很多人在申请体验小程序，这里更新解释一下因为这个服务器已经没有在跑项目了，所以目前这个小程序不大可以玩，等卑微学长考完研后一定再启动，到时候上线正式版的😭😭，不好意思呀）

2.4 原型界面图片展示 （6分） （尽可能图文并茂地在此处介绍你们队伍设计的各功能模块，创新点也在此处展示说明）

• 1、欢迎页面和游戏主页(游戏自带bgm，可点击左上角按钮静音)

• 2、三种游戏模块

a. 本地对战

b. 人机对战

c. 在线对战

• 3、排行榜

• 4、规则

• 5、创新点

  • 规则添加操作提示功能
  • 页面设计结合闽南酒桌文化摇骰子和九宫格选定火锅主题

三、编程实现（14分）

3.1 网络接口的使用（2分）

• 主要使用Websocket和python的channels模块进行网口的配置，具体如下：

• 在setting中配置asgi和channel。

  ASGI_APPLICATION = "Double_dice_end.asgi.application"
  CHANNEL_LAYERS = {
      "default": {
          "BACKEND": "channels.layers.InMemoryChannelLayer",
      }
  }
  

• 在asgi中添加application，用来分别处理http请求和websocket请求(记得添加交换机路径routing)。

  from django.core.asgi import get_asgi_application
  from channels.routing import ProtocolTypeRouter, URLRouter
  from . import routing
  
  application = ProtocolTypeRouter({
      "http": get_asgi_application(),
      "websocket": URLRouter(routing.websocket_urlpatterns)
  })
  

• routing中添加path(ready是匹配房间等待，123是房间号，consumers和ready分别是对应的websocket处理)。

  from django.urls import re_path
  
  from api import consumers
  from api import ready
  
  websocket_urlpatterns = [
      # xxxxx/room/x1
      re_path(r'room/123/', consumers.ChatConsumer.as_asgi()),
      re_path(r'room/ready/', ready.Waiting.as_asgi()),
  ]
  

• 最后用 websocket_connect 建立连接，websocket_receive接收客户端消息，然后通过redis返回即可，注意，最好一定用websocket_disconnect断开与客户机的连接，当然客户机也可以用socketonclose来断开连接。

3.2 代码组织与内部实现设计（类图）（2分）

前端：

后端：

3.3 说明算法的关键与关键实现部分流程图（2分）

算法的关键：

# 先判断棋子数, 和自己以及对手能下哪
        my_num = 0
        enemy_num = 0
        index = -1
        my_empty = []
        enemy_empty = []
        for j in range(0, 9):
            if int(My_chess[j]) != 0:
                my_num = my_num + 1
            else:
                my_empty.append(j)
            if int(Enemy_chess[j]) != 0:
                enemy_num = enemy_num + 1
            else:
                enemy_empty.append(j)

        # 如果棋子数小于6
        if my_num < 5:
            # 先判断能否消（1不消，2成对消）,其余尽量都消
            for j in range(0, 9):
                if int(Dice) == Enemy_chess[j]:
                    if int(Dice) == 1:
                        pass
                    elif int(Dice) == 2:
                        dict = {}
                        for i in range(j % 3, 9, 3):
                            if dict.get(Enemy_chess[i]) is None:
                                dict[Enemy_chess[i]] = 1
                            else:
                                dict[Enemy_chess[i]] += 1

                        if int(dict[Dice]) >= 2:
                            for empty in my_empty:
                                if empty == j % 3 or empty == j % 3 + 3 or empty == j % 3 + 6:
                                    index = empty
                                    break
                            break
                        else:
                            pass
                    else:
                        dict = {}
                        for i in range(j % 3, 9, 3):
                            if dict.get(Enemy_chess[i]) is None:
                                dict[Enemy_chess[i]] = 1
                            else:
                                dict[Enemy_chess[i]] += 1

                        if dict.get(Dice) is not None:
                            for empty in my_empty:
                                if empty == j % 3 or empty == j % 3 + 3 or empty == j % 3 + 6:
                                    index = empty
                                    break
                            break
                        else:
                            pass
            if index != -1:
                return Response({"index": index, "dice": int(Dice)})

            # 如果不能消，则判断是否可以成对（5，6先不成对），尽量不要先成三对，容易被消
            for j in range(0, 9):
                if int(Dice) == My_chess[j]:
                    if int(Dice) == 5 or int(Dice) == 6:
                        pass
                    else:
                        dict = {}
                        for i in range(j % 3, 9, 3):
                            if dict.get(My_chess[i]) is None:
                                dict[My_chess[i]] = 1
                            else:
                                dict[My_chess[i]] += 1

                        if dict.get(Dice) is not None:
                            if int(dict[Dice]) <= 1:
                                for empty in my_empty:
                                    if empty == j % 3 or empty == j % 3 + 3 or empty == j % 3 + 6:
                                        index = empty
                                        break
                                break
                        else:
                            pass
            if index != -1:
                return Response({"index": index, "dice": Dice})

            # 如果是5，6且不能成对，则下自己空位最多的那列,否则5，6下对方空位最少的一列，1，2，3，4下对方较多的那列
            # 自己的空位
            col1_nullnum = 0
            col2_nullnum = 0
            col3_nullnum = 0
            for empty in my_empty:
                if empty == 0 or empty == 3 or empty == 6:
                    col1_nullnum += 1
                if empty == 1 or empty == 4 or empty == 7:
                    col2_nullnum += 1
                if empty == 2 or empty == 5 or empty == 8:
                    col3_nullnum += 1

            # 对方的空位
            enemy_col1_nullnum = 0
            enemy_col2_nullnum = 0
            enemy_col3_nullnum = 0
            for empty in enemy_empty:
                if empty == 0 or empty == 3 or empty == 6:
                    enemy_col1_nullnum += 1
                if empty == 1 or empty == 4 or empty == 7:
                    enemy_col2_nullnum += 1
                if empty == 2 or empty == 5 or empty == 8:
                    enemy_col3_nullnum += 1

            if col1_nullnum > col2_nullnum and col1_nullnum > col3_nullnum:
                for empty in my_empty:
                    if empty == 0 or empty == 3 or empty == 6:
                        index = empty
                        return Response({"index": index, "dice": Dice})
            elif col2_nullnum > col1_nullnum and col2_nullnum > col3_nullnum:
                for empty in my_empty:
                    if empty == 1 or empty == 4 or empty == 7:
                        index = empty
                        return Response({"index": index, "dice": Dice})
            elif col3_nullnum > col2_nullnum and col3_nullnum > col1_nullnum:
                for empty in my_empty:
                    if empty == 2 or empty == 5 or empty == 8:
                        index = empty
                        return Response({"index": index, "dice": Dice})
            elif col1_nullnum == col2_nullnum and col3_nullnum < col1_nullnum:
                if int(Dice) == 5 or int(Dice) == 6:
                    if enemy_col1_nullnum >= enemy_col2_nullnum:
                        for empty in my_empty:
                            if empty == 1 or empty == 4 or empty == 7:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    else:
                        for empty in my_empty:
                            if empty == 0 or empty == 3 or empty == 6:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                else:
                    if enemy_col1_nullnum >= enemy_col2_nullnum:
                        for empty in my_empty:
                            if empty == 0 or empty == 3 or empty == 6:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    else:
                        for empty in my_empty:
                            if empty == 1 or empty == 4 or empty == 7:
                                index = empty
                                return Response({"index": index, "dice": Dice})
            elif col1_nullnum == col3_nullnum and col2_nullnum < col1_nullnum:
                if int(Dice) == 5 or int(Dice) == 6:
                    if enemy_col1_nullnum >= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 2 or empty == 5 or empty == 8:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    else:
                        for empty in my_empty:
                            if empty == 0 or empty == 3 or empty == 6:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                else:
                    if enemy_col1_nullnum >= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 0 or empty == 3 or empty == 6:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    else:
                        for empty in my_empty:
                            if empty == 2 or empty == 5 or empty == 8:
                                index = empty
                                return Response({"index": index, "dice": Dice})
            elif col2_nullnum == col3_nullnum and col1_nullnum < col2_nullnum:
                if int(Dice) == 5 or int(Dice) == 6:
                    if enemy_col2_nullnum >= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 2 or empty == 5 or empty == 8:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    else:
                        for empty in my_empty:
                            if empty == 1 or empty == 4 or empty == 7:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                else:
                    if enemy_col2_nullnum >= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 1 or empty == 4 or empty == 7:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    else:
                        for empty in my_empty:
                            if empty == 2 or empty == 5 or empty == 8:
                                index = empty
                                return Response({"index": index, "dice": Dice})
            # 三行列数都一样，5，6下对方列最小的，1，2，3，4下较多的
            elif col2_nullnum == col1_nullnum == col3_nullnum:
                if int(Dice) == 5 or int(Dice) == 6:
                    if enemy_col1_nullnum >= enemy_col2_nullnum and enemy_col2_nullnum <= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 1 or empty == 4 or empty == 7:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    elif enemy_col2_nullnum >= enemy_col1_nullnum and enemy_col1_nullnum <= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 0 or empty == 3 or empty == 6:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    elif enemy_col2_nullnum >= enemy_col3_nullnum and enemy_col3_nullnum <= enemy_col1_nullnum:
                        for empty in my_empty:
                            if empty == 2 or empty == 5 or empty == 8:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                else:
                    if enemy_col1_nullnum >= enemy_col2_nullnum and enemy_col1_nullnum >= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 0 or empty == 3 or empty == 6:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    elif enemy_col2_nullnum >= enemy_col1_nullnum and enemy_col2_nullnum >= enemy_col3_nullnum:
                        for empty in my_empty:
                            if empty == 1 or empty == 4 or empty == 7:
                                index = empty
                                return Response({"index": index, "dice": Dice})
                    elif enemy_col3_nullnum >= enemy_col2_nullnum and enemy_col3_nullnum >= enemy_col1_nullnum:
                        for empty in my_empty:
                            if empty == 2 or empty == 5 or empty == 8:
                                index = empty
                                return Response({"index": index, "dice": Dice})
            if index != -1:
                return Response({"index": index})

        # 如果棋子数>=6
        # 看看什么时候差最大就下哪
        elif my_num >= 5:
            now_my_point, now_enemy_point = CalculateScore(My_chess, Enemy_chess)
            for empty in my_empty:
                My_chess[empty] = int(Dice)
                new_my_point, new_enemy_point = CalculateScore(My_chess, Enemy_chess)
                if new_my_point - new_enemy_point > now_my_point - now_enemy_point:
                    now_my_point = new_my_point
                    now_enemy_point = new_enemy_point
                    index = empty
                My_chess[empty] = 0

            return Response({"index": index, "dice": Dice})
        elif my_num == 8:
            return Response({"index": my_empty[0], "dice": Dice})

算法流程图：

3.4 贴出重要的/有价值的代码片段并解释（2分）

本来是想用TensorFlow训练一个机器人出来的，但是这种方法属实费时又费力，然后玩了好几把发现，这个游戏并不是那么看重算法，如果说游戏是100%的话，那么技巧只占10%，而经验和运气占90%，所以我用我的经验手写了一下的代码（主要就是前3，4个棋子的时候不要追求差值最大，而是求稳算法）：

 if my_num < 5:
            # 先判断能否消（1不消，2成对消）,其余尽量都消
            for j in range(0, 9):
                if int(Dice) == Enemy_chess[j]:
                    if int(Dice) == 1:
                        pass
                    elif int(Dice) == 2:
                        dict = {}
                        for i in range(j % 3, 9, 3):
                            if dict.get(Enemy_chess[i]) is None:
                                dict[Enemy_chess[i]] = 1
                            else:
                                dict[Enemy_chess[i]] += 1

                        if int(dict[Dice]) >= 2:
                            for empty in my_empty:
                                if empty == j % 3 or empty == j % 3 + 3 or empty == j % 3 + 6:
                                    index = empty
                                    break
                            break
                        else:
                            pass
                    else:
                        dict = {}
                        for i in range(j % 3, 9, 3):
                            if dict.get(Enemy_chess[i]) is None:
                                dict[Enemy_chess[i]] = 1
                            else:
                                dict[Enemy_chess[i]] += 1

                        if dict.get(Dice) is not None:
                            for empty in my_empty:
                                if empty == j % 3 or empty == j % 3 + 3 or empty == j % 3 + 6:
                                    index = empty
                                    break
                            break
                        else:
                            pass
            if index != -1:
                return Response({"index": index, "dice": int(Dice)})

            # 如果不能消，则判断是否可以成对（5，6先不成对），尽量不要先成三对，容易被消
            for j in range(0, 9):
                if int(Dice) == My_chess[j]:
                    if int(Dice) == 5 or int(Dice) == 6:
                        pass
                    else:
                        dict = {}
                        for i in range(j % 3, 9, 3):
                            if dict.get(My_chess[i]) is None:
                                dict[My_chess[i]] = 1
                            else:
                                dict[My_chess[i]] += 1

                        if dict.get(Dice) is not None:
                            if int(dict[Dice]) <= 1:
                                for empty in my_empty:
                                    if empty == j % 3 or empty == j % 3 + 3 or empty == j % 3 + 6:
                                        index = empty
                                        break
                                break
                        else:
                            pass
            if index != -1:
                return Response({"index": index, "dice": Dice})

3.5 性能分析与改进（2分） （描述你改进的思路，展示性能分析图和程序中消耗最大的函数）

由上图可以看出，消耗最大的是 WaitForSingleObject函数，就是主线程等待hHandle对应的线程（因为算法几乎是O（n）所以消耗量并不是很大）。

改进思路：线程等待，暂且没有想到方法改进，但是代码优化还是可以做到的。

3.6 单元测试（2分） （展示出项目部分单元测试代码，并说明测试的函数，构造测试数据的思路）

对于所有的返回数值，前端使用console方法打印，后端则使用try和print进行测试：

构造测试数据的思路：拆分模块，单独查看数据测试，从不同的request进行信息的处理返回，还有特例。

3.7 贴出GitHub的代码签入记录，合理记录commit信息（2分）

四、总结反思（11分）

4.1 本次任务的PSP表格（2分）

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	7740	5410
·Estimate	·估计这个任务需要多少时间	7740	5410
Development	开发	7500	5110
·Analysis	·需求分析（包括学习新技术）	680	200
·Design Spec	·生成设计文档	500	200
·Design Review	·设计复审	300	340
·Coding Standard	·代码规范（为目前的开发制定合适的规范）	400	460
·Design	·具体设计	1000	1200
·Coding	·具体编码	4200	2360
·Code Review	·代码复审	120	80
·Test	·测试（自我测试，修改代码，提交修改）	300	350
Reporting	报告	240	300
·Test Repor	·测试报告	60	50
·Size Measurement	·计算工作量	60	50
·Postmortem & Process Improment Plan	·事后总结，并提出过程改进计划	120	200
	·合计	7740	5410

4.2 学习进度条（每周追加）（2分）

• 王长彬

第N 周	新增代码 （行）	累计代码 （行）	本周学习耗 时(小时)	累计学习耗时 （小时）	重要成长
1	274	274	28	28	帮助学习了UI原型设计、figma的使用，以及创建了后端框架，学习了django的使用
2	801	1075	30	58	建立服务器redis和代理nginx，撰写了ai接口，分数计算接口，每列的接口，初步完成了本地对战和AI对战（视图view层和配置虚拟交换机）
3	703	1778	32	90	撰写在线对战接口，建立数据库和排队机制，单元测试、性能分析和测试数据，最后撰写文档（ORM框架下的SQL，Websocket）

• 许锦欣

第N 周	新增代码 （行）	累计代码 （行）	本周学习耗 时(小时)	累计学习耗时 （小时）	重要成长
1	0	0	28	28	原型设计能力、寻找素材能力upupup
2	2299	2299	30	58	uniapp搭建前端框架，进行相关页面的编写
3	1687	3986	32	90	完成剩余页面，进行测试和优化

4.3 最初想象中的产品形态、原型设计作品、软件开发成果三者的差距如何？（2分）

页面样式差不多，但交互动画和用户体验和最初想象的还是有差距的，原型设计页面的看起来比较丝滑，而自己做的有一点点笨笨的哈哈哈哈，但是总的来说实现的还不错，除了时间原因，最核心的还是能力不够硬，继续加油叭！！！

4.4 评价你的队友（2分）

小欣：

值得学习的地方：

​ 1、一个特别认真的女孩纸，我们的UI大师，UI界面也许不是班上最好看的，但是是纯手绘的界面（难得啊），全都是小欣同学做的，而且平常经常会挤出时间来赶工完成作业。

​ 2、前端的知识比较牢固（前端的码字调试运行基本都是她做的，页面的布局debug也要花很久的时间，虽然还有一些小瑕疵，但是三周我们已经不错啦~（我觉得））。

​ 3、视频做的也很棒。

需要改进的地方：唯一缺点就是比较马虎哈哈哈哈哈，代码的排版和可读性偏弱，经常偷懒copy自己的代码然后忘了改参数。

​

小彬：

​ 值得学习的地方：

​ 1、他对代码规范很注重，包括命名和注释等，我也跟着改进了很多我的前端代码可读性；

​ 2、待人耐心友好，有团队协作意识。我们分工明确，但如果我的部分遇到问题他也会来一起商量解决，也会经常鼓励写着写着就出bug的我，并经常督促我快点完成任务。

​ 3、学习和执行能力比我强，要向优秀的同学看齐，多加提高自己的效率upupup。

​ 需要改进的地方：总体来说挺完美的，合作体验良好。少骂我就更好了。

4.5 结对编程作业心得体会（3分）

小欣：

• 这次作业难度还是有的，我们选择了做微信小程序，而我开发方面主要负责前端，我暑假有简单学习了下uniapp，但没有实践过，感觉这次的作业就是很好地促进我更好地理解和使用uniapp，完成后还是很有成就感的。

• 对于小程序一个困难就是不同手机尺寸的页面自适应，刚开始使用flex布局，但发现图片没有自适应，搜索后发现有小程序特有的自适应单位rpx；uniapp组件的使用也研究了一会；还有微信本身的api的使用，比如背景音乐的实现；还有一些重启就能解决的奇怪问题😭。

• 结对编程和个人编程还是很不一样的，可以多一人一起商量研究，做出来的作品感觉会更完善，当然明确地分工很重要，可以互相督促。很开心完成了一个之前没做过的游戏类小程序（虽然打这句话的时候还是有点困），但总体还是满足感比较大✌！

小彬：

• 作业难度还可以，主要就是每次遇到一个bug就可以百度，然后又新学到了一些知识（比如在单元测试的时候发现wx的request请求里面的处理是异步进行的，这就意味着如果需要返回数据非常有可能是乱序的，就是你后面的代码和前面需要返回的数据的请求是同时进行的，就没有带参数request，然后我试着去改变其同步进行，用了大佬写的promise，但是效果不是很好，所以就在success返回里面执行下一个request，一试，好像是可行的，而且代码的鲁棒性还不错，是稳定的）

• 终于把结对编程作业ddl做完了✌！虽然还有很多bug和小瑕疵，但是自己玩的时候还是感觉很满足的，有点做项目的感觉了，我之前没想到最后一周单元测试需要花这么多时间的，然后一测，还是出现了很多之前没想到的bug，然后花了挺多的时间去一一解决，最终总算是有了一个稍微能玩的游戏哈哈哈哈，不过还是感觉时间太赶了害，我想着debug完把程序部署到linux服务器上的，因为windows服务器的nginx不大好用，经常失败，所以目前只能在同一片局域网下对战（云服务器要💴，只有限时的呜呜呜😭）。

• 开发过程中模块还是有出现挺多问题的，比如AI对战时候没有考虑到的情况，在线对战时怎么分房间进入问题。只能一一调试了，用前端和后端分别测试（害~ 所以才说软件测试真的也是很复杂的，因为测试出错前后端都得debug，然后又不知道哪里出错了只能重新理一遍代码的思路）

• 总的来说还是学到了软件开发时的框架吧，之前只学了对着黑黑的shell执行脚本和服务器搭建，对这种有交互的页面下能看到自己的成果真是太好了！肯定是会对未来的软件开发方面有所帮助的，明白开发的流程，以及每个团队的成员的分工协作，受益良多（还有就是赶工ddl真的是痛并快乐着，感觉学到了，但又感觉还不快点，不然来不及啦！）。

​ ——END——

[林英杰032002321]

UI就让人眼前一亮，一款以美食、火锅为主题的游戏，游戏以美食为主题，新颖、别具一格。画风美观可爱，排版布局合理有致。
作品整体的完成度真的很高，肉眼可见的用心和努力。创意,源自生活。多多联想生活中的点滴，说不定会成为别具一格的主意。

[陈佳敏032002104]

1.原型太好看，整体色系给人很舒服的感觉，而且很有创意，爱了爱了
2.还有音乐可以选择开启或关闭很细节，有考虑到不同人的需求
3.结合了"二锅头"，独具一格

[黄森0320002313]

首先是介绍视频做的太好看了，就不像学生做一样，就像真的公司或者团队发的产品。产品名二锅骰也很有创意，也结合到后面游戏的元素，把棋盘变成锅，非常有创新点，游戏选项也很有创意，整体的设计就是太绝了。把骰子转换为蔬菜的创意也很有趣，排行榜以及规则页面完成的也很有趣很好看，完成度非常的高。学习到了很多，被push到，做的太好啦。

[刘金柱032002322]

游戏的UI设计很吸引人，看馋了，十分的优秀。
对战中的体验很棒，实时显示总分和每行分数的设计让玩家能更直观地了解对战进度。对战的过程因为UI的设计变得也很有趣，感觉像是吃火锅时下菜，游戏设计很有创意。排行榜以及规则页面完成的也很有趣很好看，完成度非常的高。

[吴宇驰112000927]

超级好看的UI，页面设计太有创意了，功能也十分的完整

[梁晨凯032002619]

1.ui设计做得很可爱，让人眼前一亮，与其他组的风格可以说是完全不同
2.游戏的完成度也非常好，各种功能基本上都实现了

[许仁彬032002639]

ui设计很有创意，视频制作不是单纯录屏而是详细介绍，观感很好。

[黄伟华032002409]

大佬牛逼！看了之后脑子里想的四个字。
首先小程序叫二锅骰，ui界面做的简直是太棒了，骰子原型都是好吃的（看得很馋）很符合游戏名。
功能非常齐全，实现了很多队都没有实现的在线匹配对战功能。
结算界面还可以进入排行榜观看。
很有让人眼前一亮的感觉，会很想玩。

[吴凡032002432]

整体美术有创意很赞，功能完善完成度很高，视频介绍也十分用心，算法部分详细很厉害，整部作品都值得学习

[李若彤032002123]

最让我惊喜的就是做出的这个联机功能，虽然只是局域网内的联机，但是里面的匹配机制和排行榜我很喜欢。

[吴兴元032004127]

UI设计风格非常可爱，让玩家眼前一亮，据说还是手绘设计，实在是让人叹服，值得学习。
背景音乐也相当不错，比较舒缓，与UI风格相适配。
功能相当完善丰富，值得学习。

[王文昊102192101]

个人认为完成度最好的一组，设计风格高度统一，细节做的也特别好，给跪了。

[杨智宏032002436]

1.单看UI就能爱死！！！连骰子都有自己的味道（香味溢出了屏幕哈哈哈），设计的风格治好了我的直女审美；
2.AI算法一看就是在玩足够多局的基础上才设计出来的；“那么技巧只占10%，而经验和运气占90%”这句话总结得太精辟了！
3.游戏各个功能的设计都特别饱满，能在这么短时间内做到趋于完美的程度实属不易，可见队友配合相当默契&花了好多心思~
4.在线对战的实现取个经www！

[朱智浩032002542]

原型很cute，闽南人必须给你赞一个，同学好努力，哭了，向你学习

[麥芷菱031902340]

UI设计页面太太太好看了，没想到可以有这么可爱的画风，很吸引人
新骰子放的位置让我有点蒙圈，但问题不大
B站视频讲的很清晰

[王长彬032002227]

@kevinkex 哈哈哈哈哈哈，谢谢~

[kevinkex]

原型超赞

[许锦欣032002234]

@曾毅楷032002339 可爱！

[林毅032002626]

@曾毅楷032002339 把作业中的游戏规则重新绘制使之契合主题，在这次作业成品中确实很少见！很nice！

[曾毅楷032002339]

可爱！
功能一应俱全，并且很流畅；界面很讨人喜欢，骰子的绘制很别出心裁，用了火锅料作为点数的绘制，和产品若合一契；游戏规则的介绍也单独绘制，使颜色、字体风格符合产品主题，别有用心。
棋子数作为判断的一个点是我们没有想到的，给了我一些灵感回头可以优化我的那个傻ai。
博客做的很用心，视频也做得很好，很赞！！是一个很优秀的作品！

[许锦欣032002234]

@郭君濠032002608 一起加油学！！！

[郭君濠032002608]

光是看UI就让人眼前一亮，一款以美食、火锅为主题的游戏，无论背景图片还是模式选择等内容均为手绘设计，非常优秀，值得学习。同时可以手动开关闭背景音乐，很可惜没有在视频中听到游戏音乐，有机会也要上手玩一玩。视频制作也很用心，使用了配音，很好地介绍了小程序的功能。
有登录功能，可以实现在线对战，也很不错。结算页面也可以进入排行榜，这确实是很重要的一点，我却没想到，学到了。另外，游戏规则的制作也很用心，自己制作了与游戏风格相符的规则样式。在游戏过程中，放置在棋盘上的骰子也是独具风格，应该也是自己绘制出来的，真的厉害。同时，游戏的锅底也有选择功能。每一方面都想到了，有很多我可以学习的地方。
在小程序设计中使用了框架，功能实现的很完整。而对于我这样的小白来说，只能面向百度编程，不仅做不到面面俱到，很多应有的功能没能实现，而且功能实现的也很粗糙。看到这个优秀的作品，不禁让我开始反思自己的不足之处，以及学习的不够努力。

[许锦欣032002234]

@林庭星032002419 二锅头指越玩（吃）越上头

[林庭星032002419]

吃吃吃，看完想吃火锅了，骰子好可爱，都是吃的，但是与此同时，有一个严肃的问题，这个游戏不适合晚上玩，猪瘾会犯。
“二锅头”，哈哈哈哈哈哈哈，谐音梗怎么会不好笑呢？但是还是想偷偷问下，二锅头跟火锅有什么关系？火锅配酒越喝越有？
整个作品风格统一，而且很注重用户体验，除了规则还有操作说明，完成度是非常高高高的！
b站视频语音讲解，条理清楚，很nice！

[许锦欣032002234]

@陈佳亮102192111 收到优化建议很棒的建议！

[陈佳亮102192111]

1、整体完成度很高，每个功能做的都很饱满。
2、UI界面设计，很好看，很可爱，而且还是自己手绘的，点个赞，整个界面的布局很合理，是我目前看到的小程序的界面中，最好的一个，也是最像一款小游戏的小游戏哈哈哈，可以看出来很用心，骰子的图片也是用的食物，很有自己的特色。规则是我目前看到的唯一一个没有贴评测组给的图，或者简单的写几行文字，而是贴合自己的小程序，这一点值得我学习。
3、交互设计上，开局有提示谁先手，这一点很好，提高了人机交互的友好性。但是还是可以再稍微优化一下，比如对应玩家轮次可以再考虑一个显眼的方式，小游戏大家会更趋向于“傻瓜式”，仅仅开局给出一个轮次可能还是不太够，可能我有点吹毛求疵了，然后同点的骰子，以及消除骰子个人认为可以再加一点有趣的形式来增加用户的体验。
4、视频做的也很不错。
5、结对协作的模式也比较合理。