Cauchy's Blog

港硕回顾

Sun, 17 Aug 2025 00:00:00 GMT

随着港硕学业的告终，也是时候做一篇回顾谈谈感想了。

Review-HK: study and life#

🔮 为什么读#

故事要拉回大学时光。从大一我就在思考自己想做什么或者不想做什么，我也从来没有想过留学。因为读的计算机嘛，通常大家会有几条路可以选，本科就业、读研深造（国内考研/保研）、考公等。一开始参与了一个大创小组，只是为了学点东西。我们的大创是一个小型的科研，做的对抗攻击相关的，老师对我们挺严格，印象是要我们把吴恩达的机器学习和深度学习、李飞飞的CS231N的网课刷一遍，并跟着实验去敲代码。我其实也很不容易地把视频看完并做了一些笔记，现在找不到笔记了hhh，但我没做实验。那会刷网课就挺难顶的了，是因为内容比较多，我兴致也不是很高的样子。反正就是整个项目感受到了科研的冰山一角，读论文也让我很痛苦，也不喜欢写论文，做实验反而还好。那个时候我就知道自己不太适合走科研这条路，或者是这种推着我必须去做什么必须有什么成果的节奏吧。身边很多朋友都进了实验室，我就在想本科就业这条路，所以之后的学习我都没有刻意去卷绩点，而是尽量去学习，学到多少是多少，尤其是自己想学的，就要认真学；不喜欢的也不用勉强自己去拿高分。课设接触过很多前端相关的部分，也有学unity游戏方面的，但我们的课更多是AI方向的多，不得不学的东西。

大三那会就在纠结，是去学游戏开发还是去做前端，两个都是我比较感兴趣的，但自己做的相关项目和游戏开发靠不上边。大三下6月份左右吧，觉得很迷茫啊，于是发现了留学这条路，就自己去收集信息了解各种东西。留学读硕士的话，分授课硕（Taught Postgraduate, Master）和科研硕（哲学硕士，Mphil, Master of Philosophy），还有phd这种。授课硕的特点是面向就业，学制短，学费高昂，上课或者完成项目修满学分就能毕业。科研硕比phd还难申请一些，学费比较便宜、甚至会有工资，反正就是真正搞科研，进组干活，要写论文的。一般我们计算机，美英新港吧，考虑到经济条件和我想体验的东西，我直接就把地点框在了香港。从很久以前就对香港有一种莫名的情愫，广东人嘛，广东话也很有亲切感，以前也是看tvb大的，觉得自己无论如何都想去香港体验一番。学费贵是贵，家里愿意支持我去读，我很感激。

当时还和一位欣赏且喜欢的老师聊天，问我要不要gap一年，我不知道我想做什么，又担心赶不及申请。她就说如果不是身体因素，没有必要gap，可以边读边去思考。她在我眼里是一位很优秀的独立女性！我就听了她的话，在期末结束以后，好好做准备去了。总结起来是，一想去香港，二想体验留学生活，三想留时间去思考和发现自己想做什么，四顺便拿个硕士学位（给就业留后路）。

🥛申请过程#

要申留学，要考语言成绩、自己准备资料申请院校（ps, cv, 推荐信）、可能要准备笔试面试。很多人是提前一年就在准备了，我那会决定要留学已经差不多7月了，9月很多院校就开放申请了。虽然没有特意卷绩点，还好我们老师给分都不错，转换过去我gpa大概是3.7/4的样子，并不是我多厉害，我排名还不够院前50%，但也够我申请不错的学校和专业了。语言考的雅思，我挑的院校和专业对语言要求不高，最高要求的是6.5(5.5)，自学了一个月左右，不花钱刷的机考题，有朋友陪我临急抱佛脚练口语，最后的成绩就是6.5(5.5)，本人口语5.5是非常合理的事情哈哈哈。分不在高，够用就行。ps、cv都是自己找资料自己写的，推荐信磨蹭了我好久，一是不好意思麻烦我的老师，二是我自己写不出来，最后去找了个代写。最后所有资料准备完成的时候是十月初国庆后了。参考往年的申请经验帖子，这个时候不早也不晚，很是适合。很可惜这一年cuhk10月就收满了9月的申请的生源，我算申请晚了。hku（太贵且要笔面）和hkust（太卷、适合科研）我都不太指望。就到11和12月申请city和poly，poly的话应该也申晚了，city破天荒的12月才开申请，专收我们这种落榜生是吧。最后也是被city收留了，今天回头看，学校不在于名声有多好，更在于合适，尤其对我这种有特别目的的人，我很喜欢这所学校。

📗学习过程#

整体给我的课程难度是类似我的本科吧。很不习惯这种快节奏、全英授课、以及小组作业和pre。Sem A为了留后面的时间去实习规划，就猛猛选了18学分6门课，一周上3天，每天两门课的样子，期末难顶到差点崩溃。Sem B选了6学分2门课+3学分的project（和ST3学分，加起来6学分的project）。project不需要到学校去，ST 结束在8月，毕业时间在10月。我其实住在深圳 (吃住更舒适成本更低)，港深通勤上课，多数是有课才去学校，按我的规划，sem B结束了就没有去学校的课程了。

这里也罗列一些上过的课。

code	comment	score
CS5187	项目是CV内容，老师尽量讲得没那么枯燥，给分不错	A-
CS5222	必修，计网，教材和本科一样，考试开卷，没怎么花精力在这课上	A-
CS5351	必修，软工，学习了一些敏捷开发、软件需求等东西，小组作业，大佬带我飞，不喜欢这门课，考试很抽象	A-
CS5481	必修，数据工程，类似python数据处理分析，小组作业，大佬带我飞，本人考试一坨	B+
CS5487	ML，机器学习数学理论，花的精力最多的一门课，课后花了很多时间和朋友去理解做数学题，老师讲得也很好，很喜欢安东尼，非常有收获。小组作业，朋友捞了我，因为我实在精力分配不过来了。这门课也有phd同上	A
CS6382	算法分析与博弈论，很抽象但有趣的一门课，很多听不懂的东西，虽然有一些算法基础，但还是差太远了。这门课也有phd同上，phd朋友带飞。本人考试依旧烂烂	B
CS5182	CG，游戏开发入门必学，本科学院没开这门课，一直想学，还是挺有趣的，就是考试不嘻嘻，作业不嘻嘻，小组作业，队友好	B+
CS5188	VR，学UE5的开发，因为项目自己做，设备又不好接vr设备，后面摆烂了，考试也很抽象，考得犄角旮旯的，不嘻嘻	B
CS6520	Project。自行联系导师，类似做本科毕设，选了题以后就自己捣鼓，没怎么再联系导师，可能对方也觉得我只是授课硕，不想花精力在我身上。我的是科研向的，回想起本科毕设做LLM相关的痛苦。后来觉得咬咬牙做完就算了。大家互相走个流程吧。	IP

要说学到了什么知识，肯定还是很有限的，和本科一样自学为主，不用的话更是忘得飞快。交到了很好的朋友，大家一起做小组作业以后，很多小组合作都是同一批人，大家也会互相讨论很多事情。都是缘分啊，一开始在群里混眼熟，组队的时候，都是大家来找我，项目中我只能做到一个类似PM的作用，实际干活我才是被带飞的人，有时候也有愧于他们，觉得自己干活还是不太够。我读得挺累的，大部分时间挺认真在学的，也有被自身精神困扰无法专注学习的时候，但总算熬了过来。

别说，神仙还是挺多的。有时候很难想象你和什么目标的人在一起读书。有的是很巨婴，纯伸手党，有什么问题自己不去搜索，不去查，一直在问，那么多信息呢，你读计算机不会获取和筛选信息，你到底在读什么。问就算了，有时候回答了，对方还会怀疑你，继续问别人。有的是家长代操，搞不清是谁在读书，家长来找我们同学，问各种细节，怎么选课之类的，这…你们开心就好。当然也不乏小组作业推卸责任，直接摆烂，或者去买代做的人。后来只在8人小群里交流，不在大群和他们讨论了。大家各有各的前程吧。

⛵️ 生活和课余#

去学校上课，能看见很多活动。很有意思的校园生活，本科如果在这种环境学习，发展应该也很不错的。期间有两次港星来校唱歌，我都没空去看，错过了很多有趣活动。

不过在ST，我上了一个MHFA的课程，精神健康急救课程，大概是学习一些抑郁症、焦虑症、重性精神病等的知识，以及我们身边遇到这样的人，我们能做什么。有机会的话，再单独拎出来写吧（大概没有）。学到一个很重要的知识点，非批判性沟通。其实我觉得，无论对方是不是患有精神问题的人，非批判性沟通都是一个很实用的沟通技巧。难就难在非批判性。在一个案例中，老师扮演一个失恋引发抑郁情绪的人，由我们来和她沟通。很多人，给出的做法或者没有什么用的安慰话，如“你想开一些啦，不就是失恋而已，没什么大不了的”，“被分手了而已，大不了就再找一个，我自己也谈过几个”，“不要为了一棵树放弃整片森林”，等等诸如此类的话。我因为不知道讲什么，所以也讲的很糟糕。我经历过这种情绪，也曾有人对我说过那样的话，我只觉得不被理解，且更难受了。我知道要先接纳对方的情绪，陪伴，拥抱对方。言语上感觉说什么都不太对，我其实很在乎自己说的话对对方有什么影响，于是就会导致沉默的发生。不过，沉默在这种场景是可以接受的，无需担忧。就像过去我的一些朋友比较成熟地处理我的问题时，我也在学习着怎么成熟地处理自己的事情，以及日后遇到和我遭遇的人，我应该怎么做。

港校人文关怀（心理教育、性教育等）做得真的很不错，科普也很好，很值得内地的学校去学习。以及，也没有一堆行政上烦人的事。

平日也不乏一些追星生活，比如去看演唱会，去serrini开的树店（山道63号B）那里看书，那里虽然小巧，但她很用心布置，去到有愉悦的氛围。有一次带朋友去看，还见到她了www，我当场宕机，很拘谨，因为她好像不喜欢被粉丝合照之类的，我担心自己会冒犯到她。她真的就是温柔知心大姐姐，我好喜欢。经常也能在广告牌上见到自己喜欢的明星。

有时候也会去city walk，看艺术展这些，文化是真的做得很好。线下的包容，和线上的骂战可是两种截然不同的场景，让人直呼人类物种多样性。

啊对！聊点吃的。我们饭堂做得挺不错的，特别表扬中餐厅的早茶（本广州人认可），性价比高。南山邨的AC4也不错，cuhk的饭堂也好吃，虽然我在港吃最多的还是麦当劳，便宜不踩雷。相比于内地，香港吃吃玩玩都好贵，吃得也没说比内地好吃多少，适合旅游吃点内地不容易吃到的异域美食，如一兰拉面。总体上，我还是最喜欢“食在广州”。

🌳成长#

这一年，慢慢地理解了什么是独立的自我。尽管还在学习的路上，比过去的很多想法都成熟了很多，也接纳了很多的自我。想清楚了一些自己的需求，追求。精神力提升了，面对情绪也更加地从容。很多痛苦都来得恰到好处，想明白了，就完成了一个课题。想不明白的，修炼到了，也能明白了。明白了他人的课题是他人的责任，我只负责自己的，有些事也帮不来。人活着是要为了自己的，不是为了外物，而我现在依然在寻找这样的东西，能完全不依赖外界，又能强力支撑我活下去的东西。自我方面的一个小目标是，达到“她哪里需要一个男人了”的境界，自我比较完满的程度吧。缘，妙不可言，总是会有巧合的好事出现在我面前，能做的就是不放弃，坚定自我走下去了。当然也希望，身边的好朋友们都能过得好，都能过上大家想要的生活。

也更加坚定了自己要走什么样的路，父母支持，自己也乐意去做的话，就放手去做吧。做自己想做的事，又不会伤害到他人和自我，我想就是一件很幸福的事了。路上会有很多塞壬的歌声，虽然我不能像船员们屏蔽掉，但也应该学习奥德修斯用某种束缚来闯过去。不管现实会不会对我这种理想主义者重重一击，过程才是最重要的。二十几岁，真实打拼的好年纪啊哈哈！💪

[转] 日麻ML250213：堀慎吾复盘南三局电报

Sat, 15 Feb 2025 00:00:00 GMT

这场对局，堀慎吾面对三家围攻，手上没有安牌的情况下，电报了和了打点最低的小林刚选手，为自己后面避四和逆二争夺了机会。转载此文主要用于收藏学习，侵删。

原文链接：https://note.com/fuchan0722/n/nbde58b510bd5

译文链接：https://www.bilibili.com/opus/1034025574272598051

原作者：堀慎吾；译：AA；校对：若葉柚祈老师。

有能力的话，还是去原文链接支持一下新狗:heart_eyes:

提到的人名互译：

小林刚 - 刚子（刚桑）；浅见真纪 - 妈咪（浅见桑）；松ヶ瀬隆弥 - 厨子（松）；

これが地獄か#

你好，我是堀。

在前几天的MLeague比赛中，我在比赛中被夹在两面立直和进攻之间，向刚桑放铳了1000点。

今天，我想详细解释一下当时的想法。

顺便说一下，我为什么突然想到要写这样的笔记呢？和平时一样，须田前辈这个对我研究颇为热心的前辈问起了我的想法。像往常一样，我在LINE上记录了当时的想法，结果写着写着发现字数越来越多，完全变成自己写文章的节奏了嘛！

须田前辈把我的想法整理成文字，再加上一些感伤的元素，写成一篇好文章。但问题是，竹◯房从中赚钱，我却一分钱也拿不到！这简直是不可接受的！

我感到非常愤怒。不过，如果仔细想想，这种愤怒可能有10%是因为这件事，而90%是因为我最近运气不好，没中竞马。不，如果考虑到愤怒本身可能也源于竞马的不顺，那么可以说，100%是因为竞马的不顺。

写这篇付费笔记这件事，基本上就等于我在竞马上栽了。我可不是因为生气才写笔记的，真正的原因是我最近在竞马上一直不顺。

首先，请看这个过于恶梦的场景。

厨子和妈咪立直，刚子副露

场况是，我被两家立直夹在中间，而且场上也有1p的暗杠。更糟糕的是，我的手牌不仅没有一张现物，而且所有牌都不能过两家，简直陷入了地狱般的局面。这难道就是麻将人的墓地吗？

唯一的安慰是，除了红宝牌外，所有的dora已经显露出来了。而且刚子的牌河看起来很像听牌。

要是扑克的话，我肯定直接fold不玩了，但麻将可没这选项，只能一点点分析局势。

首先，妈咪在4位的厨子立直的一发巡就切了5万，然后切了3饼立直，之后又暗杠了1饼。

在这种情况下，我们无法确定1p原本是不是暗刻。可能是从113p摸到1p后听牌，也可能原本就有111p，而3p则是与其他牌组成面子的一部分。

仅凭这些信息，我们无法得到太多线索。但有一点可以确定的是，

从场况看，在厨子立直后一发巡，她打出了5m，而这张牌正好是两家无筋。这表明她很可能有一个比较完整的一向听形状。

也就是说，如果她是以113p的形状摸到1p而听牌的，那么剩下的部分应该是愚形，这意味着另一边的搭子几乎可以确定是两面搭子。

是113p

接下来我们来看一下先制立直的厨子

是的，就是这个……没办法，完全没有任何信息。唯一能知道的现物能过，真遗憾。

接下来是刚子。

顺便提一下，在麻将中，相比立直，副露（吃、碰、杠）能提供更多的信息。

原因是，门前清时，玩家通常是摸到一张牌后再打出一张，因此如果只是看出牌，很难判断他实际摸到了什么。

而在副露的情况下，会在鸣牌的瞬间就必须打出一张牌。也就是说，我们可以知道他拿到了什么牌，还能判断出哪张牌对他来说已经没用了。这些信息在门前清的情况下是几乎是无法得知的。

刚子用两面的34m吃了5m打出了8m

吃了5m在这里打出了8m

首先，思考“这张8m是什么？”是解读对手手牌时的最基本思路。如果详细分类的话，可能会有各种情况，但大致来说，只有以下三种可能性：

关联牌
安全牌，或者是手牌的形状已经确定了，只是根据安全度的优先级有意保留，或者说是无奈之下留下的牌
虽然没有直接关联，但为了形成新的好搭子而保留的孤立牌。

基本上就是这三种情况，有时1和2的因素会同时存在，或者2和3的因素同时存在。

而这次刚子的情况，他在切8m之前先切了发，这是一张相对安全的现物牌，并且在这之前还切了6p这张孤牌，而6p比8m更优秀。

此外，他还吃了5m。如果他手里持有5678m这样的连搭，那么6p比8m更有价值作为孤张，这种可能性可以排除。

也就是说，上述三种分类中的2和3的情况被完全否定了，因此可以100%确定这是关联牌。

接下来就要思考它与什么有关。

由于7m现了3张，并且他用34m吃了5m，然后切了8m，所以很容易想到他可能持有两张6m，形成了668m的形状。

换句话说，他副露前的手牌形状很可能是34668m。

顺便说一下，以这种情况作为例子，假设：

这种25m和47s两面听牌的情况，基本上这个8m是不需要的，因此不会特意留下8m而去切掉更安全的发。

之所以特意加上“基本上”，是因为在某些特殊情况下是有可能发生的。

比如，当其中一组两面搭子非常弱的时候。

例如，如果摸到7m，可能会选择放弃薄弱的两面搭子，或者切掉6m，转为单骑听牌，这就是一种例外情况。

同样，如果56s部分是愚形搭子，那么也可能会出现类似的情况。

但这次，8s已经现了4张，且切了2p、6p、3s等，这些信息表明并不存在愚形搭子的部分。

为了让初学者也能理解，我来进一步解释：

在这种情况下，从34668万46饼或68饼这样的手牌中，是不会切掉6饼的。因为在这种情况下，8万是为了优化手牌形状而保留的牌，但如果在此时反而破坏手牌形状，就变成了让人费解的选择。

除非8m特别安全，否则这种情况不会发生。而这次，在切6p的时候，8m并不是一张安全的牌，因此可以断定，手牌中并不存在筒子的愚形搭子。

同样，索子方面，已经切了23s，且8s已经出现了4张，因此从34668m 357s这样的手牌中，几乎不会选择留下8m而切掉3s，从而缩小自己的听牌范围。所以，索子方面也几乎不存在坎张的愚形搭子。

更何况，即使存在愚形搭子，也不一定会选择留下8m。

虽然前面的说明有点长，但通过以上分析，可以推测8m是从668m中切掉的。所以，第一步就是去想6m会不会是双碰待牌。

是的，接下来就要用到我常说的双碰的另一边是？这个思考方式。在这种情况下，只有三种可能性。

是5s、7s、白板这三种。

为了方便初学者理解，我再详细解释一下。

初学者可能会想，如果某张牌只出现了两张，那么是不是任何牌都有可能作为双碰呢？比如5饼或7饼，如果手牌是34668万556p或者34668万677饼的一向听，那么除非做了奇怪的选择，比如特意切掉6饼，否则这种情况是不存在的。当然，正常情况下会切掉8万来保留两面听，对吧？

即使8m是安全牌，如果要保留它，也一定会确保两面听的形状。

那么4饼或8饼呢？这种情况也基本上不存在。因为切掉6饼的时候，7万已经切了两张。如果手牌是34668m446p或34668m688p，而7万已经切了两张，且5饼或7饼没有被切掉，那么正常情况下应该切掉8万，而不是6饼。

当然，这次的情况是6p和8m的安全性有所差异，并且4位的上家已经切掉了7m，基本可以预期他会继续切7m，因此不能说完全没有可能，但从概率上来看，这种情况仍然较低。

回到正题，我之前提到6m的双碰只有三种可能性，但这三种候选牌（5s、7s、白）中，白板之外的两张都只出现了一枚，并且是较为常见的搭子牌，因此概率相对较低。

另外，如果以5s或7s作为听牌目标，那么手牌的结构会变得非常局促和受限。

例如，若通过345m吃牌形成一组，再加上66m和55s两组，那么手牌的剩余部分会极为受限，因此这种可能性较低。

所以，我的第一反应是：刚桑可能是跟白组成双碰。

然而，双碰的待牌候选牌很少，仅凭这一点还不足以作为选择切牌的判断依据，因此我决定进一步关注其他可能性。

也就是说，是否有其他原因导致他留下了8m。想到这里，我脑海中浮现出了两种可能性：

第一种：8m并不是668m的一部分，而是作为坎张的辅助牌的唯一一种情况，即手牌是344568m。

第二种：情况是，虽然手牌包含668m，但7m成为了关键进张，即手牌形态为22234668m。

存在这两种牌型真的很重要，因为原本在麻将中，去读这种用了很多张牌的牌型并不是有效的做法。

读牌是在可能成立的牌型越多，实际越容易真的读对牌型，而能被特定到的牌越多，这种牌型实际出现的概率越低。

依赖这种读牌，本质上就是依赖不确定的东西，这通常被称为“主观臆断”

然而，这次的情况比较特殊：双碰听牌的候选牌很少，而且从枚数上来讲能用的牌不多，再加上在使用特定牌的数量较多的情况下，能够发现两种稀有的听牌形状，这一点非常重要。

为什么重要呢？因为如果刚桑的手牌是这两种形状之一，那么当他听牌时，除非是白板后付，否则几乎可以肯定他的听牌是6p的周围牌。原因很简单，因为其他几乎所有牌对小林刚来说都是安全的。

有人可能会问：“这有什么重要的？”

其实，在这个局面下，如果能通过点炮来结束这一局，我会非常乐意这么做。

我已经无法和牌了，如果让竞争对手和牌，我的局势只会更糟。现在我还面对着一个包含暗杠的两家立直的局面，而我的手牌简直是地狱一般。”

再看一下地狱吧（bushi）

进一步来说，如果小林刚的待牌是6P周围的牌话，那么这意味着从我的视角来看，6p已经出现了4张，7p变成了no chance，至少对于好型率很高的妈咪来说，7p不会成为铳牌。

假设小林刚是白板的后付，从手牌构成上来说，他很有可能持有另一张6p。此时，对我而言最好的结果就是让小林刚胡牌……怀抱着一丝希望，我切出了7p。拜托了刚桑！希望能和到这张牌。

就算刚桑没和到，也希望不要从其他家哪里听到胡！的声音……拜托了……我闭上眼睛，切出了寄托着希望的7p。

「ロン」

我猛地一惊，但那声音源头毫无疑问是没有任何感情的机器人声音。

果然，麻将是戒不掉的啊

因为赛马失利，生气地来写付费专栏的hori真可爱呢！

想起第一次去赛马，哈哈挑的马跑了倒数第一，倒一也是一啊！当时和朋友算，14中1的概率已经是赛马里最高的了，大概是百分之7。买前三的组合的概率也很小，C143=1364C_{14}^3=\frac{1}{364}C143=3641，大约只有千分之2而已！当然，赛马有很多其他因素可以参考，但从概率上讲，咱们还是远离赌博 😄

回到这篇文章。当时看比赛直播的时候，觉得他好幸运，点了个最小的。没想到背后竟然有如此多的思考，而且这一打竟然是电报，真的很佩服。麻将真的很有趣！

Final: 粒子系统与流动效果

Thu, 05 Jan 2023 00:00:00 GMT

作业简介：

粒子效果制作(Particle System)

ps: 多图警告！加载时间可能较长，有加速器会快一些，思维导图可新建页面打开图片看大图。

粒子效果制作#

一、设计要求#

粒子效果制作，必须带一个控制组件，控制粒子呈现效果。

二、项目地址#

https://github.com/Cauchyoooo/3DGameDesign/tree/main/hw8/Assets

三、效果展示图#

show

四、写在前面#

Unity实现特效的方式多种多样，这里主要使用的是内置粒子系统(Particle System)。还有一种更高级的Visual Effect Graph(VFX Graph) 。课上听和做对粒子系统有初步的了解。课后又对每个模块仔细地再阅读，跟着一些视频实践了一番，增加了不少的理解。感觉还是有自己的理解后，才能更好地制作自己的五毛特效。特效这方面感觉和美术更相关，搭配好的素材能制作出更丰富的东西。

这个特效，暂且称之为“雨云弹”特效吧。制作的灵感来源于《Splatoon 3》的大招墨雨云，因为做得不咋像就不放图了。用的是默认素材，真的是有手就能做。代码部分参考了之前做的射箭部分，主要用于获取并抛掷球体。当球体与地面碰撞时，触发该特效并销毁球体，也算是有一个控制组件呈现粒子特效啦^-^。

那让我们开始吧。

五、粒子系统模块简介#

:lollipop:

模块总结图#

ParticleSystem

打“√”的模块是初始粒子系统默认勾选的，也是基本必须模块；打下划线的模块是“雨云弹”所用到的。
这些模块都可以通过脚本 ParticleSystem.xx 来访问使用。事实上，这里没有用脚本访问使用粒子系统，因为初始就直观地设定好了粒子效果，也无需在过程中修改它。

:feet:

部分模块使用方法#

如果能看懂英文的，可以通过鼠标在英文上悬停以了解功能介绍。这里只介绍部分常用的。

仿真执行控制窗口

用于控制粒子系统在场景的播放演示，可以看到场景中的粒子属性如粒子数量、速度区间等。

win
- Play - 播放；Restart - 重置；Stop - 停止播放；Playback Speed - 播放速度；Playback Time - 已播放时间；
  
  Resimulate - 勾选后，粒子效果的更新会同步到仿真窗口；
Main 模块

main
- 右边有三角形的都是下拉列表，可以更改选项或模式。右上角的”＋“号，可以选择显示所有模块或勾选的模块。
- Duration - 粒子一次发射多久(若是循环模式，则为每轮发射时长)；Looping - 是否循环播放；
  
  Start Delay - 延迟多久发射；Start Lifetime - 粒子生命周期(存活多久)；Start Speed - 初始速度；
  
  Start Size - 初始大小；Start Rotation - 初始旋转角度；Start Color - 初始颜色；
  
  Stop Action - 当粒子效果结束时，可以选择使该对象自动销毁等
Curve 面板

当进行“大小数值”设置时，选择带有Curve的模式就会出现一条线，如果高亮该线就可以在Curve面板编辑它，不高亮时不代表没有应用，只是没有显示在面板里。

curve
- 最下方是一些系统预设，可通过实践来理解变化趋势。
- 面板左上角的数值是峰值。
- 在线上右键可以Add Key(新建关键帧)，右键Key可以编辑它的比例（如峰值是10，Edit Key的Value为0.3，则数值大小为3）。
Gradient Editor 线性编辑器

当进行颜色设置，选择“Gradient”模式时，点击色条可打开编辑。

gradient
- Mode可以选择Blend或者Fixed，这个两端选择不同颜色，自己尝试一下就知道区别，一般使用Blend模式，过渡比较自然。
- 在色条上方或下方左键即可创建一个帧(小箭头)，点击它可编辑颜色或透明度。
- 色条上方的帧用于设置透明度，越黑表示越透明，Alpha为透明度数值(RGBA的A)，A越接近0越透明，Location表示在色条处于什么位置。
- 色条下方的帧用于设置颜色，经典的颜色面板，一看就懂。
- Presets 有个 New，可以把当前的set保存为预设，方便重复使用。
Emission 模块

粒子发射大致有3种方式，随时间发射、随距离变化发射、特定时间点发射，这三种模式可叠加使用。

emission
- Rate over Time 为每秒发射的粒子数量。
- Rate over Distance 为每发生单位距离变化发射的粒子数量。尾迹的制作很常用。
- Burst模块可控制特定时间点(Time)发射的粒子数量(Count)，Cycles表示发射轮次，Interval表示轮次间隔时间，Probability表示发射的可能概率。
Shape 模块

Shape 用于描述发射器的形状，即粒子沿着什么样的形状发射出去的。不同的shape会有不同的属性设置，在Texture上方的那部分。这里给出一些自己的理解例子。

shape
- 默认的Shape是Cone(圆锥)，将其Angle设为0就是圆柱，修改Thickness可以呈现环状。
- Sphere是球状发射，Hemisphere是半球状发射，可用于一些需要中心向外发散的3d效果。
- Box是盒装发射，也比较常用。修改Scale形成一定范围，粒子速度设为很小，在体积发射时，可以营造类似萤火虫等氛围感。
- Circle圆、Edge边都是二维图形，也常用。圆可以作中心向外发散的2d效果，边可以作一些刀锋效果。
Trails 模块

如果会用GameObject的Trail，这个是相通的。可以用于制作拖尾效果。本人对这个也是初步了解状态，只会做很简陋的效果。

trail
- Mode模式选择：Particles是对每个粒子单独使用；Ribbon是通过粒子间连接形成。
- Paricles模式：Ratio表示粒子会应用Trail的百分比；Lifetime为Trail的生命周期；Die with Particles表示是否随粒子销毁而销毁。
- Ribbon模式：Ribbon count表示连线的数量，注意这个数量不要超过粒子发射的数量。

其他模块就不做介绍了，大多数看手册都能理解的。

六、“雨云弹”制作#

由于写详细教程会使篇幅太长，此处只放出相关参数图片。

个人通用的制作思路是：整体形状->发射的时间、数量及速度->主要效果->颜色调整。

“雨云弹”结构图#

“雨云弹”分为四个部分：①上升雾，②云，③雨，④雨滴溅射。

对象结构图

注：

Transform 组件参数放进模块参数图里供作参考。
每个效果都不需要更改默认的Renderer渲染模块，勾上就行。

:foggy:

1 上升雾#

设计要点#

整体呈圆柱状上升喷射；
向上喷射速度快时间短，要有”嘭“的感觉；
有雾的绵密感。

效果图#

模块参数图#

Transform

1transform
Main

1main
Emission

1emission
Shape

1shape
Color over Lifetime

1color

:cloud:

2 云#

设计要点#

整体呈中心水平向外扩散；
云的消散有渐隐效果；
云的运动有波动感。

效果图#

cloud

模块参数图#

Transform

2transform
Main

2main
Emission

2emission
Shape

2shape
Velocity over Lifetime

2velocity
Color over Lifetime

2color
Size over Lifetime

2size

:cloud_with_rain:

3 雨#

设计要点#

整体呈圆柱形向下喷射；
雨的下落要迅速，呈线状；
雨碰撞地面触发雨滴溅射效果。

效果图#

down

模块参数图#

Transform

3transform
Main

3main
Emission

3emission
Shape

3shape
Size over Lifetime

3size
Collision

3collision
Sub Emitters

需做好“4 雨滴溅射”部分再勾选修改该模块。

3sub
Trails

3trail

:watermelon:

4 雨滴溅射#

设计要点#

整体呈中心斜向上向外溅射；
雨滴溅射碰撞地面有反弹效果，营造动感。

效果图#

circle

模块参数图#

Transform

4transform
Main

4main
Emission

4emission
Shape

4shape
Color over Lifetime

4color
Size over Lifetime

4size
Noise

4noise
Collision

4collision

:star:

注：

还有一件事，因为我在Rain空对象挂了一个只用Main的ParticleSystem组件，修改了生命周期，并将Stop Action设置为Destroy，效果类似于这个粒子播放xx时长，结束了这个对象就会自动销毁。因为在粒子系统触发脚本(ParticleTrigger)中，当球体与地面碰撞，这个粒子系统会作为预制件实例化，每撞一次就会实例化一次，如果不及时销毁就会一直在那里，但其实它播放一次就不再用了。

当然，如果不带这个组件，处理方式也可以修改为，一开始就在场景初始化这个粒子系统，并设置不播放，每检测碰撞，就对这个空对象下挂载的三个粒子系统进行同时播放一次。我觉得比较麻烦，就采取了第一种方法，这在性能方面可能有所增加。

5main

七、其他部分制作#

1 背景#

由5个带上黑色材质球的Plane简单拼凑组成，注意Plane的朝向并检查是否带有碰撞器。用于粒子系统碰撞及颜色衬托。

2 球体#

一个带有Trail子对象的球体，组件勾上碰撞器，加入刚体和碰撞检测的脚本，设置如下图。

ball
球体的Trail拖尾效果做得比较简陋，设置如下图。

btrail

3 相机#

新建Camera，通过ctrl+shift+f将当前场景的视角作为Camera的视角，这里添加了俯视DownCamera和仰视UpCamera的视角。通过脚本添加预制件及视角切换。

八、部分代码#

代码部分参考了之前做的射箭部分，主要用于获取并抛掷球体，也不是主要部分。

设计模式采用课堂上的设计模式，参考的UML图如下。画的很好了，这里就不重新画了。

design

代码结构图#

日常上代码结构图，dddd。

Scripts

ParticleTrigger#

粒子系统触发脚本。在球体碰撞的位置实例化粒子系统预制件Rain，它会自动播放的。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class ParticleTrigger : MonoBehaviour
6
{
7
    void OnCollisionEnter(Collision other)
8
    {
9
        GameObject Rain = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/Rain"));
10
        Rain.transform.position = new Vector3(this.transform.position.x,0,this.transform.position.z);
11
        this.gameObject.tag = "Finish";
12
    }
13
}

BallFlyAction#

球体飞行运动。在初始给一个瞬间的力以添加初速度，然后给一个持续向下的力模拟重力。模拟一个斜向上抛体运动。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class BallFlyAction : SSAction
6
{
7
    private Vector3 force = new Vector3(0,80f,30f);
8
    private Vector3 gravity = new Vector3(0,-0.3f,0);
9
    // public float speed;
10
    public static BallFlyAction GetBallFlyAction(){
11
        BallFlyAction action = ScriptableObject.CreateInstance<BallFlyAction>();
12
        return action;
13
    }
14

15
    public override void Start(){
16

17
        gameObject.GetComponent<Rigidbody>().isKinematic = false;
18
        gameObject.GetComponent<Rigidbody>().velocity = Vector3.zero;
19
        gameObject.GetComponent<Rigidbody>().AddForce(force,ForceMode.Impulse);
20
    }
21

22
    public override void Update()
23
    {
24
        if (this.gameObject.tag == "Finish"){
25
            this.destroy = true;
26
        }
27
        gameObject.GetComponent<Rigidbody>().AddForce(gravity,ForceMode.Impulse);
28
    }
29

30
}

展开收起

Interface#

包括IUserController与ISceneController,分别对应用户操作接口与场景行为接口。

Init是获取球体，Shoot是发射球体，ChangeView用于切换视角，IsBallNull用于判断是否获取了球体；

LoadResource是实例化背景及相机。

1
public interface IUserAction
2
{
3
    void Init();
4
    void Shoot();
5
    void ChangeView(char c);
6
    bool IsBallNull();
7
}
8

9
public interface ISceneController
10
{
11
    void LoadResource();
12
}

SceneController#

场景控制器。用于控制整个场景，实现用户操作接口与场景行为接口。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class SceneController : MonoBehaviour, IUserAction, ISceneController
6
{
7
    BallFactory factory;
8
    public BallActionManager actionManager;
9
    public myUserGUI userGUI;
10
    public GameObject ball = null;
11
    public Camera mainCamera;
12
    public Camera upCamera;
13
    public Camera downCamera;
14

15
    void Start()
16
    {
17
        Director director = Director.getInstance();
18
        director.currentSceneController = this;
19
        gameObject.AddComponent<BallFactory>();
20
        factory = Singleton<BallFactory>.Instance;
21
        actionManager = gameObject.AddComponent<BallActionManager>() as BallActionManager;
22
        userGUI = gameObject.AddComponent<myUserGUI>() as myUserGUI;
23
        mainCamera = Camera.main;
24
        LoadResource();
25
    }
26

27
    public void LoadResource()
28
    {
29
        GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/Background"));
30
        upCamera = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/UpCamera")).GetComponent<Camera>();
31
        downCamera = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/DownCamera")).GetComponent<Camera>();
32
        ChangeView('z');
33
    }
34

35
    public void ChangeView(char c)
36
    {
37
        if(c == 'z'){
38
            mainCamera.enabled = true;
39
            upCamera.enabled = false;
40
            downCamera.enabled = false;
41
        }
42
        else if(c == 'x'){
43
            mainCamera.enabled = false;
44
            upCamera.enabled = true;
45
            downCamera.enabled = false;
46
        }
47
        else{
48
            mainCamera.enabled = false;
49
            upCamera.enabled = false;
50
            downCamera.enabled = true;
51
        }
52
    }
53

54
    public void Init()
55
    {
56
        if(ball == null){
57
            ball = factory.GetBall();
58
        }
59
    }
60

61
    public void Shoot()
62
    {
63
        actionManager.MoveBall(ball);
64
        ball = null;
65
    }
66

67
    public void Update()
68
    {
69
        factory.FreeBall();
70
    }
71

72
    public bool IsBallNull(){
73
        return (ball == null);
74
    }
75
}

展开收起

myUserGUI#

用户界面。用于监测按键及控制说明。按z,x,c可以切换视角，space可以获取球体，j可以发射球体。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class myUserGUI : MonoBehaviour
6
{
7
    private IUserAction action;
8
    GUIStyle titleStyle = new GUIStyle();
9
    GUIStyle textStyle = new GUIStyle();
10
    void Start(){
11
        action = Director.getInstance().currentSceneController as IUserAction;
12

13
        titleStyle.normal.textColor = new Color(0.9f, 0.65f, 0.99f, 1);
14
        titleStyle.normal.background = null;
15
        titleStyle.fontSize = 30;
16
        titleStyle.alignment = TextAnchor.MiddleCenter;
17

18
        textStyle.normal.textColor = Color.white;
19
        textStyle.normal.background = null;
20
        textStyle.fontSize = 20;
21
    }
22
    void Update(){
23
        if(!action.IsBallNull()){
24
            if (Input.GetKeyDown(KeyCode.J)) action.Shoot();
25
        }
26
        if (Input.GetKeyDown(KeyCode.Space)) action.Init();
27
        if (Input.GetKeyDown(KeyCode.Z)) action.ChangeView('z');
28
        if (Input.GetKeyDown(KeyCode.X)) action.ChangeView('x');
29
        if (Input.GetKeyDown(KeyCode.C)) action.ChangeView('c');
30
    }
31

32
    void OnGUI() {
33
        GUI.Label(new Rect(Screen.width-200, 5, 200, 50), "粒子效果展示", titleStyle);
34
        GUI.Label(new Rect(12, 12, 200, 50), "视角切换：z, x, c", textStyle);
35
        GUI.Label(new Rect(12, 42, 200, 50), "取物：space", textStyle);
36
        GUI.Label(new Rect(12, 72, 200, 50), "发射：j", textStyle);
37
    }
38
}

展开收起

九、小结#

做粒子特效，除了灵感，理解也很重要，即使是默认素材，也能作出很多花样。
内置粒子系统还可用于做粒子流编程，作出一些流体效果，这里没有深入研究。
主要是学习了模块面板的使用，没怎么用api控制粒子系统，对api还不太熟悉。

十、参考#

HW7: 模型与动画

Sun, 18 Dec 2022 00:00:00 GMT

作业简介：

智能巡逻兵(动画、订阅/发布模式)

智能巡逻兵#

设计要求#

创建一个地图和若干巡逻兵（使用动画）；
每个巡逻兵走一个3-5个边的凸多边形，位置数据是相对地址。即每次确定下一个目标位置，用自己当前位置为原点计算；
巡逻兵碰撞到障碍物，则会自动选下一个点为目标；
巡逻兵在设定范围内感知到玩家，会自动追击玩家；
失去玩家目标后，继续巡逻；
计分：玩家每次甩掉一个巡逻兵计一分，与巡逻兵碰撞游戏结束；

程序设计要求#

必须使用订阅与发布模式传消息
工厂模式生产巡逻兵

项目地址#

https://github.com/Cauchyoooo/3DGameDesign/tree/main/hw7/Assets

效果展示图#

地图展示

map

游戏展示

game

玩法#

你是一个狐狸妈咪，你在和你的7个小狐狸宝贝玩捉迷藏。你有一堆烦人的动物朋友，分别为猩猩、老虎和鸽子，你一靠近他们，他们就会追着你喋喋不休。要是被它们逮到，你就会被他们烦死。你要做的是快速地绕开你的烦人朋友，找到你的所有宝贝狐狸们。方向键控制行进，按住左shift键进行加速，鼠标右键移动视角。

1. 预制件制作#

本次作业选用了Asset store里的资源包《Quirky Series Vol.2 [v1.3]》。

角色主要分为3类：Player玩家：大狐狸；巡逻兵：其他动物；可拾取物体：小狐狸。

组件设置#

点开Jungle Vol.1/Prefabs/RedPanda_LOD1，可以看到如图所示。为了简化模型，没有使用带有Lod Group的prefabs，这里选取的是较为精细的lod1。

对于Player玩家来说，我们只需要在最外层的父对象挂一个rigidbody就行，碰撞检测的部分由其他碰撞体实现。该rigidbody属性如下图所示。这里为了方便没有使用重力。注意到Constraints处勾选了几项，是因为在调试过程中，遇到了碰撞抖动问题。本次作业角色移动没有利用物理学，碰撞后受力就会发生奇怪的运动。这里采取锁定刚体旋转和部分位移的方式解决。

对于巡逻兵来说，在最外层的父对象挂上rigidbody和两个脚本（一个是属性脚本，一个是检测玩家碰撞的脚本）。这里的rigidbody和上述设置类似。创建Collider空子对象，挂上一个方盒碰撞器并设为触发器，再挂上一个用于检测玩家范围的脚本。巡逻兵大体都也是这样做。差异只在属性脚本和检测范围上面。

对于拾取的物体来说，父对象挂一个碰撞器并设为触发器，再挂一个检测玩家碰撞的脚本即可。这里没有用mesh碰撞器，觉得拾取范围可以模糊一点。

动画控制器制作#

点开官方的AC_Red Panda(Animator Controller)，我们可以看到有两个层，一个是控制整体动作，一个是控制眼睛动作。其中，整体动作可以直接通过Inspector预览，而眼睛动作需要将模型拖到Inspector才可预览，也可直接先在官方给出的Demo场景中预览。

为了简单起见，本作业只用到了其中很少的动作。

下图是Player的动画控制器，包含三个bool类型参数：存活live、是否行走isWalk、是否奔跑isRun。动作只有默认状态Idle、行走Walk、奔跑Run及死亡Death。这里Idle到Exit的过渡没有条件，会被系统自动忽略。

下图是Idle过渡到Walk的设置。注意，这里的动作大多没有Exit Time，因为满足过渡条件时，如进入行走、进入攻击等动作变化需要马上执行，不需要等待上一个动作做完。

下图是巡逻兵的动画控制器，这个更简单，其实只有行走和攻击两种状态，不过在游戏结束时，我们还是让它进入到静止状态的Idle。这里只是给出一个例子，不同的模型要匹配相应的模型动作，不然执行时模型会变成动画控制器的那个 (别问怎么知道的，问就是干过这种蠢事)。

下图是拾取的物体的动画控制器，由于动作比较简单，也加入了眼睛的变化。没被找到时，就坐在原地哭唧唧，被找到后就高兴跳起来。

到此，角色的预制件就做得差不多了。后面就是根据实际情况，还要去预先设计并记录一下巡逻兵属性脚本的数据值。

2. 场景制作#

场景分两部分，摄像机Camera和地图Map。为了方便加载，这个地图是预先摆好并保存为预制件。

地图部分如下图，是Map空对象下放了子对象墙体地板等组成的。子对象部分有4类：Wall、InnerWall、Plane、Area，分别代表四面围墙、内部障碍墙、地板和各巡逻区域。Wall和InnerWall都是普通的Cube对象，Plane就是Plane对象，Area则是空对象挂上一个Box Collider和一个区域检测的脚本。位置摆放及数值等都是本人自己设计的，没什么好讲的。(这里有扇墙是假的)

然后，我们将第一步做的预制件先放在想要放的位置，记录位置数据等。因为要求用工厂模式生成巡逻兵，拾取的物体也顺便通过该模式生成了。

摄像机是使用Main Camera，为了可以通过鼠标控制视角，并跟随玩家，挂上一个Camera Flow脚本。确定好Player的初始位置，就可以确定好摄像机的初始位置了。

到此，预制部分就全部做完了，可以开始写代码了。

3. 代码解析#

代码框架图#

(本人还是不太习惯用UML图，思维导图既能帮助我整理结构，又能标记完成情况等，比较方便。)

Patrol

Models部分#

Camera Flow

摄像机跟随脚本，网络上挺多这样的模板的，这里也是随便参考了一个。因为视角只希望在水平方向移动，不希望上下或者前后移动，这里的RotateAround就只是绕着跟随的目标的Y轴旋转。

1
public class CameraFlow : MonoBehaviour
2
{
3
    public GameObject target;
4

5
    Vector3 offset;
6

7
    void Start()
8
    {
9
        offset = this.transform.position - target.transform.position;
10
    }
11

12
    // Update is called once per frame
13
    void Update()
14
    {
15
        this.transform.position = target.transform.position + offset;
16
        Rotate();
17
        Scale();
18
    }
19
    //缩放
20
    private void Scale()
21
    {
22
        float dis = offset.magnitude;
23
        dis += Input.GetAxis("Mouse ScrollWheel") * 5;
24
        if (dis < 3 || dis > 20)
25
        {
26
            return;
27
        }
28
        offset = offset.normalized * dis;
29
    }
30
    //左右移动
31
    private void Rotate()
32
    {
33
        if (Input.GetMouseButton(1))
34
        {
35
            Vector3 pos = this.transform.position;
36
            this.transform.RotateAround(target.transform.position, Vector3.up, Input.GetAxis("Mouse X") * 10);
37
            //  更新相对差值
38
            offset = this.transform.position - target.transform.position;
39
        }
40
    }
41
}

展开收起

Enemy Data

巡逻兵属性。每个数据的含义如注释所写。在工厂模式生成的时候，初始化数值。

1
public class EnemyData : MonoBehaviour
2
{
3
    public int AreaID;                      //  Enemy巡逻区域序号
4
    public bool isFollow = false;           // 是否跟随玩家
5
    public int CurID = -1;                  //  当前玩家所在区域序号
6
    public GameObject player;               //  玩家游戏对象
7
    public int kind;                        //  巡逻类型 3/4/5边
8
    public Vector3 startPos;                //  Enemy初始位置
9
    public Vector3 lu;                      //  Enemy巡逻区域左上角坐标
10
    public Vector3 rd;                      //  Enemy巡逻区域右下角坐标
11
}

Patrol Detection

巡逻检测，玩家进入范围就追捕，走出范围就停止追捕。

1
public class PatrolDetection : MonoBehaviour
2
{
3
    void OnTriggerEnter(Collider collider)
4
    {
5
        EnemyData parent = this.gameObject.transform.parent.GetComponent<EnemyData>();
6
      //玩家进入Enemy追捕范围，开始追捕
7
        if (collider.gameObject.tag == "Player")
8
        {
9
            //启动追捕模式
10
            parent.isFollow = true;
11
            //将追捕对象设置为玩家
12
            parent.player = collider.gameObject;
13
        }
14
    }
15
    void OnTriggerExit(Collider collider)
16
    {
17
        EnemyData parent = this.gameObject.transform.parent.GetComponent<EnemyData>();
18
        //玩家跑出Enemy追捕范围/玩家跑出Enemy管控范围，结束追捕
19
        if (collider.gameObject.tag == "Player" || parent.AreaID != parent.CurID)
20
        {
21
            //关闭追捕模式
22
            parent.isFollow = false;
23
            //将追捕对象设置为空
24
            parent.player = null;
25
        }
26
    }
27
}

展开收起

Other Detection

1
// 检测玩家与巡逻兵碰撞
2
public class PlayerDetection : MonoBehaviour
3
{
4
    void OnCollisionEnter(Collision other)
5
    {
6
        //当玩家与巡逻兵相撞
7
        if (other.gameObject.tag == "Player")
8
        {
9
            //玩家死亡
10
            other.gameObject.GetComponent<Animator>().SetBool("live",false);
11
            //Enemy发动攻击
12
            this.GetComponent<Animator>().SetTrigger("attack_tri");
13
            //游戏结束
14
            Singleton<GameEventManager>.Instance.playerGameOver();
15
        }
16
    }
17
}
18

19
// 检测被拾取的物体(Baby)是否被碰撞(拾取)
20
public class BabyDetection : MonoBehaviour
21
{
22
    void OnTriggerEnter(Collider collider)
23
    {
24
        if (collider.gameObject.tag == "Player" && this.gameObject.activeSelf)
25
        {
26
            this.gameObject.GetComponent<Animator>().SetBool("isFind",true);
27
            this.gameObject.GetComponent<BoxCollider>().enabled = false;
28
            Singleton<GameEventManager>.Instance.reduceBabyNum();
29
        }
30
    }
31
}
32

33
// 区域标志、检测玩家进入哪个区域
34
public class AreaDetection : MonoBehaviour
35
{
36
    public int AreaID = 0;
37
    FirstSceneController sceneController;
38

39
    void Start()
40
    {
41
        sceneController = Director.getInstance().currentSceneController as FirstSceneController;
42
    }
43

44
    void OnTriggerEnter(Collider collider){
45
        if(collider.gameObject.tag == "Player"){
46
            sceneController.CurID = AreaID;
47
        }
48
    }
49
}

展开收起

Actions部分#

这里只介绍巡逻动作的脚本。

Enemy Walk Action

通过在矩形画凸多边形，在多边形上任意取点。多边形取点逻辑如下图所示。橙色边为给定的巡逻大范围。三角形则在紫色、绿色及黄色三条线段依次任取点；四边形则在紫色、绿色、黄色、蓝色四条线段上依次任取点；五边形则在紫色、绿色、右侧粉色、粉色定点、上方粉色，四条线段加一个定点依次取点。忽略边界的小概率实践，形成的轨迹就是指定的凸多边形。

也许会留意到轨迹周围有一段留白，那是为了避免巡逻兵在指定轨迹上行走，碰上障碍物原地不动的情况设置的。

1
public class EnemyWalkAction : SSAction
2
{
3
    private int kind = 4;                           //  多边形边数
4
    // 运动范围为(areaDown,areaUp),(areaLeft,areaRight)
5
    private float areaLeft = 0;
6
    private float areaUp = 0;
7
    private float areaRight = 0;
8
    private float areaDown = 0;
9
    private float moveSpeed = 1.8f;                 //  移动速度
10
    private bool isReach = true;                    //  是否到达目的地
11
    private EnemyData enemyData;                    //  Enemy数据
12
    private List<Vector3> path = new List<Vector3>();   //存储路径点
13
    private int curTar = 0;     //  当前目标地索引
14

15
    private EnemyWalkAction() { }
16
    public static EnemyWalkAction GetSSAction(int k, Vector3 start, Vector3 lu, Vector3 rd)
17
    {
18
        EnemyWalkAction action = CreateInstance<EnemyWalkAction>();
19
        action.kind = k;
20
        action.areaLeft = lu.x;
21
        action.areaRight = rd.x;
22
        action.areaUp = lu.z;
23
        action.areaDown = rd.z;
24
        action.initPath();
25

26
        return action;
27
    }
28
    Vector3 getPoint(float left, float right, float down, float up){
29
        Vector3 res= new Vector3(0,0,0);
30
        if(left==right){    //竖线
31
            res.x = left;
32
            res.z = Random.Range(down,up);
33
        }
34
        else if(down==up){
35
            res.x = Random.Range(left,right);
36
            res.z = down;
37
        }
38
        else{
39
            res.x = Random.Range(left,right);
40
            res.z = Random.Range(down,up);
41
        }
42
        return res;
43
    }
44
    void initPath()
45
    {
46
        float midx = (areaLeft+areaRight)/2;
47
        float midz = (areaUp+areaDown)/2;
48
        path.Add(getPoint(areaLeft+2f,areaLeft+2f,areaDown+2f,areaUp-2f));
49
        path.Add(getPoint(areaLeft+2f,areaRight-2f,areaDown+2f,areaDown+2f));
50
        // 三角形
51
        if(kind==3){
52
            path.Add(getPoint(areaRight-2f,areaRight-2f,midz,areaUp-2f));
53
        }
54
        // 四边形
55
        else if(kind==4){
56
            path.Add(getPoint(areaRight-2f,areaRight-2f,areaDown+2f,areaUp-2f));
57
            path.Add(getPoint(areaLeft+2f,areaRight-2f,areaUp-2f,areaUp-2f));
58
        }
59
        // 五边形
60
        else if(kind==5){
61
            float quax = (midx+areaRight)/2;
62
            float quaz = (midz+areaUp)/2;
63
            path.Add(getPoint(areaRight-2f,areaRight-2f,areaDown+2f,midz));
64
            path.Add(new Vector3(quax,0,quaz));
65
            path.Add(getPoint(areaLeft+2f,midx,areaUp-2f,areaUp-2f));
66
        }
67
    }
68

69
    void goPatrol()
70
    {
71
        if(isReach){
72
            curTar ++;
73
            curTar %= kind;
74
            isReach = false;
75
        }
76
        this.transform.LookAt(path[curTar]);
77
        // 只要很接近地点就相当于到了
78
        float distance = Vector3.Distance(transform.position, path[curTar]);
79
        if (distance > 0.9)
80
        {
81
            transform.position = Vector3.MoveTowards(this.transform.position, path[curTar], moveSpeed * Time.deltaTime);
82
        }
83
        else{
84
            isReach = true;
85
        }
86
    }
87

88

89
    public override void Update()
90
    {
91
        // 巡逻移动
92
        goPatrol();
93
        // 如果巡逻兵需要跟随玩家并且玩家就在巡逻兵所在的区域，巡逻动作停止
94
        if (enemyData.isFollow && enemyData.CurID == enemyData.AreaID)
95
        {
96
            this.destroy = true;
97
            this.callback.SSActionEvent(this, 0, this.gameObject);
98
        }
99
    }
100
    public override void Start()
101
    {
102
        this.gameObject.GetComponent<Animator>().SetBool("isWalk", true);
103
        enemyData = this.gameObject.GetComponent<EnemyData>();
104
    }
105
}

展开收起

Controllers部分#

First Scene Controller

简单讲一下场景控制器。实现了消息订阅，实现了用户动作接口和场景动作接口。其中，有一个需要注意的点是 Restart 使用了SceneManager.LoadScene();，可以加载指定场景，比较方便。

1
public class FirstSceneController : MonoBehaviour, IUserAction, ISceneController
2
{
3
    public PropFactory factory;                              // Enemy和Baby工厂
4
    public ScoreController scoreController;                  // 记分员
5
    public EnemyActionManager manager;                       // 运动管理器
6
    public myUserGUI userGUI;                                // 用户界面
7
    public int CurID = -1;                                   // 当前玩家所于检测区域的序号
8
    public GameObject player;                                // 玩家
9
    public Camera cam;                                       // 主相机
10
    public float moveSpeed = 5;                              // 玩家移动速度
11
    public float rotateSpeed = 250f;                         // 玩家旋转速度
12
    private List<GameObject> enemies;                        // 场景中Enemy列表
13
    private List<GameObject> babies;                         // 场景Baby列表
14
    private bool isGameOver = false;                         // 游戏是否结束
15

16
    void Update()
17
    {
18
        for (int i = 0; i < enemies.Count; i++)
19
        {
20
            enemies[i].gameObject.GetComponent<EnemyData>().CurID = CurID;
21
        }
22
        // Baby收集完毕
23
        if(scoreController.getBabyNum() == 0)
24
        {
25
            GameOver();
26
        }
27
    }
28
    void Start()
29
    {
30
        Director director = Director.getInstance();
31
        director.currentSceneController = this;
32
        gameObject.AddComponent<PropFactory>();
33
        factory = Singleton<PropFactory>.Instance;
34
        manager = gameObject.AddComponent<EnemyActionManager>() as EnemyActionManager;
35
        scoreController = gameObject.AddComponent<ScoreController>() as ScoreController;
36
        userGUI = gameObject.AddComponent<myUserGUI>() as myUserGUI;
37
        LoadResource();
38
        cam.GetComponent<CameraFlow>().target = player;
39

40
    }
41

42
    public void LoadResource()
43
    {
44
        Instantiate(Resources.Load<GameObject>("Prefabs/Map"));
45
        player = Instantiate(Resources.Load("Prefabs/Player"), new Vector3(0, 0, 0), Quaternion.identity) as GameObject;
46
        babies = factory.getBabies();
47
        enemies = factory.getEnemies();
48

49
        // 所有巡逻兵移动
50
        for (int i = 0; i < enemies.Count; i++)
51
        {
52
            manager.Walk(enemies[i]);
53
        }
54
    }
55

56

57
    // 玩家移动
58
    public void movePlayer(float tranX, float tranZ, bool isShift)
59
    {
60
        if(!isGameOver)
61
        {
62
            if (tranX != 0 || tranZ != 0)
63
            {
64
                player.GetComponent<Animator>().SetBool("isWalk", true);
65
                // 如果shift加速
66
                if (isShift){
67
                    player.GetComponent<Animator>().SetBool("isRun", true);
68
                    moveSpeed = 10;
69
                }
70
                else{
71
                    player.GetComponent<Animator>().SetBool("isRun", false);
72
                    moveSpeed = 5;
73
                }
74
            }
75
            else
76
            {
77
                player.GetComponent<Animator>().SetBool("isWalk", false);
78
                return;
79
            }
80
            // 移动和旋转
81
            player.transform.Translate(0, 0, tranZ * moveSpeed * Time.deltaTime);
82
            player.transform.Rotate(0, tranX * rotateSpeed * Time.deltaTime, 0);
83

84
            // 防止碰撞带来的移动
85
            if (player.transform.localEulerAngles.x != 0 || player.transform.localEulerAngles.z != 0)
86
            {
87
                player.transform.localEulerAngles = new Vector3(0, player.transform.localEulerAngles.y, 0);
88
            }
89
            if (player.transform.position.y != 0)
90
            {
91
                player.transform.position = new Vector3(player.transform.position.x, 0, player.transform.position.z);
92
            }
93
        }
94
    }
95

96
    public int getScore()
97
    {
98
        return scoreController.getScore();
99
    }
100

101
    public int getBabyNum()
102
    {
103
        return scoreController.getBabyNum();
104
    }
105
    public bool getGameOver()
106
    {
107
        return isGameOver;
108
    }
109
    public void Restart()
110
    {
111
        SceneManager.LoadScene("Scenes/startScene");
112
    }
113

114
    void OnEnable()
115
    {
116
        GameEventManager.scoreChange += addScore;
117
        GameEventManager.gameOverChange += GameOver;
118
        GameEventManager.babyChange += reduceBabyNum;
119
    }
120
    void OnDisable()
121
    {
122
        GameEventManager.scoreChange -= addScore;
123
        GameEventManager.gameOverChange -= GameOver;
124
        GameEventManager.babyChange -= reduceBabyNum;
125
    }
126

127
    void reduceBabyNum()
128
    {
129
        scoreController.reduceBaby();
130
    }
131
    void addScore()
132
    {
133
        scoreController.addScore();
134
    }
135
    void GameOver()
136
    {
137
        isGameOver = true;
138
        factory.stopEnemies();
139
        manager.DestroyAllAction();
140
    }
141
}

展开收起

Others部分#

Game Event Manager

订阅/发布模式（又叫观察者模式，事件-代理机制，事件的代理模型）。

1
public class GameEventManager : MonoBehaviour
2
{
3
    //  分数变化
4
    public delegate void ScoreEvent();
5
    public static event ScoreEvent scoreChange;
6
    //  游戏结束
7
    public delegate void GameOverEvent();
8
    public static event GameOverEvent gameOverChange;
9
    //  Baby数量
10
    public delegate void BabyEvent();
11
    public static event BabyEvent babyChange;
12

13
    //  分数变化
14
    public void playerEscape()
15
    {
16
        if (scoreChange != null)
17
        {
18
            scoreChange();
19
        }
20
    }
21
    //  游戏结束
22
    public void playerGameOver()
23
    {
24
        if (gameOverChange != null)
25
        {
26
            gameOverChange();
27
        }
28
    }
29
    //  Baby数量
30
    public void reduceBabyNum()
31
    {
32
        if (babyChange != null)
33
        {
34
            babyChange();
35
        }
36
    }
37
}

展开收起

delegate关键字定义了函数类型ScoreEvent、GameOverEvent、BabyEvent等的代理类型。静态变量scoreChange、gameOverChange、babyChange就是相应的“被订阅的主题”。

如下图 FirstSceneController 里的调用，+= 部分表示左边的函数一被调用，就会通知所有带有右边函数的对象要进行调用右边的函数，相当于右边订阅了左边。而 -= 就代表取消订阅了。

这里的playerEscape()等函数是一个接口，当调用时，就在告诉记分员要计分addScore()了。

Views部分#

myUserGUI

用户界面，也是大同小异。

这里主要是为了提到一个悬浮提示的小制作。格式如下，其中tipStyle为可选

1
GUI.Button(new Rect(0,0,0,0), new GUIContent("提示", "提示内容"));
2
GUI.Label(new Rect(1,1,1,1), GUI.tooltip[, tipStyle]);

第一次知道，IMGUI里的内容可以使用 \n 来换行。

1
public class myUserGUI : MonoBehaviour
2
{
3
    private IUserAction action;
4
    private GUIStyle scoreNumStyle = new GUIStyle();
5
    private GUIStyle scoreTextStyle = new GUIStyle();
6
    private GUIStyle scoreShadowStyle = new GUIStyle();
7
    private GUIStyle titleStyle = new GUIStyle();
8
    private GUIStyle shadowStyle = new GUIStyle();
9
    private GUIStyle tipStyle = new GUIStyle();
10

11
    void Start ()
12
    {
13
        action = Director.getInstance().currentSceneController as IUserAction;
14
        scoreNumStyle.normal.textColor = new Color(1,0.92f,0.016f,1);
15
        scoreNumStyle.fontSize = 30;
16
        scoreTextStyle.normal.textColor = new Color(0, 0, 0, 1);
17
        scoreTextStyle.fontSize = 30;
18
        scoreShadowStyle.normal.textColor = new Color(1,1,1,0.4f);
19
        scoreShadowStyle.fontSize = 30;
20
        titleStyle.normal.textColor = new Color(0.47F,0.4F,0.93F,1);
21
        titleStyle.fontSize = 40;
22
        shadowStyle.normal.textColor = new Color(1,1,1,0.5f);
23
        shadowStyle.fontSize = 40;
24
        tipStyle.normal.textColor = new Color(0.54f,0.27f,0.04f,1);
25
        tipStyle.fontSize = 18;
26

27
    }
28

29
    void Update()
30
    {
31
        //获取方向键的偏移量
32
        float tranX = Input.GetAxis("Horizontal");
33
        float tranZ = Input.GetAxis("Vertical");
34
        bool isShift = Input.GetKey(KeyCode.LeftShift);
35
        //移动玩家
36
        action.movePlayer(tranX, tranZ, isShift);
37
    }
38
    private void OnGUI()
39
    {
40
        GUI.skin.button.fontSize = 20;
41
        GUI.Label(new Rect(10, 5, 200, 50), "分数:", scoreTextStyle);
42
        GUI.Label(new Rect(9, 4, 200, 50), "分数:", scoreShadowStyle);
43
        GUI.Label(new Rect(90, 5, 200, 50), action.getScore().ToString(), scoreNumStyle);
44
        GUI.Label(new Rect(Screen.width - 245, 5, 200, 50), "剩余小狐狸数:", scoreTextStyle);
45
        GUI.Label(new Rect(Screen.width - 246, 4, 200, 50), "剩余小狐狸数:", scoreShadowStyle);
46
        GUI.Label(new Rect(Screen.width - 50, 5, 50, 50), action.getBabyNum().ToString(), scoreNumStyle);
47
        if(action.getGameOver() && action.getBabyNum() != 0)
48
        {
49
            GUI.Label(new Rect(Screen.width / 2 - 80, Screen.height / 2 - 100, 100, 100), "游戏结束", titleStyle);
50
            GUI.Label(new Rect(Screen.width / 2 - 78, Screen.height / 2 - 98, 100, 100), "游戏结束", shadowStyle);
51
            if (GUI.Button(new Rect(Screen.width / 2 - 50, Screen.height / 2 , 100, 50), "重新开始"))
52
            {
53
                action.Restart();
54
                return;
55
            }
56
        }
57
        else if(action.getBabyNum() <= 0)
58
        {
59
            GUI.Label(new Rect(Screen.width / 2 - 80, Screen.height / 2 - 100, 100, 100), "恭喜胜利", titleStyle);
60
            GUI.Label(new Rect(Screen.width / 2 - 78, Screen.height / 2 - 98, 100, 100), "恭喜胜利", shadowStyle);
61
            if (GUI.Button(new Rect(Screen.width / 2 - 50, Screen.height / 2 , 100, 50), "重新开始"))
62
            {
63
                action.Restart();
64
                return;
65
            }
66
        }
67

68
        GUI.Button(new Rect(Screen.width / 2 - 50 ,10, 100, 50), new GUIContent("提示规则", "按WSAD或方向键移动\n按左Shift键进行加速\n成功躲避猛兽追捕加1分\n找到所有小狐狸即可获胜\n鼠标右键实现视角转动"));
69
        GUI.Label(new Rect(Screen.width / 2 - 80 ,80, 150, 120), GUI.tooltip, tipStyle);
70
    }
71

72
}

展开收起

小结#

学会了动画控制器的使用；
理解了订阅/发布模式；
了解到了碰撞抖动、IMGUI的悬浮提示做法等。
Player与一个被拾取物体的碰撞按道理只会触发一次。碰撞很偶尔会出现两次的情况，没有解决这个bug。
巡逻兵没有加变速功能，且探测范围设置较小，游戏难度比较低。

HW6: 物理系统与碰撞

Sun, 04 Dec 2022 00:00:00 GMT

作业简介：

打靶游戏（涉及刚体物理学、碰撞）

打靶游戏#

靶对象为5环，按环记分；
箭对象，射中后要插在靶上；射中后，箭对象产生颤抖效果，到下一次射击或1秒以后；
游戏仅一轮，无限trials；添加一个风向和强度标志，提高难度。

项目地址：

https://github.com/Cauchyoooo/3DGameDesign/tree/main/hw6/Assets

效果展示图：

代码框架图：

射箭游戏

1、预制件制作#

靶子

1个空对象作为父对象，包含5个圆柱体(Cylinder)。通过前后位置的摆放，可以在正面形成环状视觉效果。

空对象上只挂载刚体组件rigidbody，碰撞检测选择连续的Continus。

圆柱子对象则挂载MeshCollider，并勾选Convex和其下的Is Trigger让其有碰撞检测功能。

1个空对象作为父对象，包含1个长方体(Cube)箭头、1个圆柱体(Cylinder)箭身、3个长方体(Cube)箭尾。

空对象同样只挂载刚体组件rigidbody，注意勾选使用重力Use Gravity及使用动力学Is Kinematic。碰撞检测选择动态连续Continuous Dynamic。

子对象只在箭头挂载碰撞器与箭头脚本。**注意：**如果箭头长度太短，又配合高速运动的话，碰撞检测很有可能会出现异常，比如一次性检测到多个或者少检测到几个。

这样，主要的预制件就做好了。这里还做了一个背景板的预制件，附带了碰撞器效果，使射出靶范围的箭能停在“墙”上。

2、部分代码解析#

arrowScript

箭头脚本：检测箭与靶子的碰撞。

这里利用靶子的圆柱组件Tag来识别打到哪个环，从而计分。为避免多次碰撞，加入cnt计数限制只计分一次碰撞。碰撞完成后，将箭的空对象的刚体属性更改为is Kinematic，且速度归零；箭的tag改为”Hit“，用于触发抖动运动。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class arrowScript : MonoBehaviour
6
{
7
    public int cnt = 0;
8
    private string ColliderTag;
9
    private ScoreController scoreController;
10

11
    void OnTriggerEnter(Collider tar) {
12
        cnt++;
13
        if(cnt>1) return;
14
        ColliderTag = tar.gameObject.tag;
15
        Rigidbody parent = this.gameObject.transform.parent.gameObject.GetComponent<Rigidbody>();
16
        parent.isKinematic = true;
17
        parent.velocity = Vector3.zero;
18
        parent.gameObject.tag = "Hit";
19
        scoreController.Record(ColliderTag);
20
    }
21

22
    public void reset(){
23
        cnt = 0;
24
    }
25

26
    void Awake(){
27
        scoreController = (ScoreController)FindObjectOfType(typeof(ScoreController));
28
    }
29
}

展开收起

CCFlyAction

箭飞行运动：传入wind和force参数，来控制箭上施加的物理学的力。rot参数根据wind参数，增加自旋效果。为确保Tremble抖动运动值运行一次，这里加入了isTrem判断。只有运行完飞行运动且Tag为”Hit”的物体才会发生抖动。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class CCFlyAction : SSAction
6
{
7
    public Vector3 force;
8
    public Vector3 wind;
9
    private Vector3 rot = new Vector3(0,0,0);
10
    private bool isTrem = false;
11

12
    public static CCFlyAction GetCCFlyAction(Vector3 _wind, Vector3 _force){
13
        CCFlyAction action = ScriptableObject.CreateInstance<CCFlyAction>();
14
        action.force = _force;
15
        action.wind = _wind;
16
        action.rot.z = _wind.x;
17
        return action;
18
    }
19

20
    public override void Start(){
21
        isTrem = false;
22
        gameObject.transform.LookAt(force);
23
    gameObject.GetComponent<Rigidbody>().isKinematic = false;
24
    gameObject.GetComponent<Rigidbody>().AddForce(force, ForceMode.Impulse);
25
    gameObject.GetComponent<Rigidbody>().velocity = Vector3.zero;
26
    gameObject.GetComponent<Rigidbody>().AddForce(force + wind, ForceMode.Impulse);
27
        gameObject.GetComponent<Rigidbody>().angularVelocity = rot;
28
    }
29

30
    public override void Update(){}
31

32
    public override void FixedUpdate()
33
    {
34
        this.gameObject.GetComponent<Rigidbody>().AddForce(wind, ForceMode.Force);
35
        if (this.gameObject.tag == "Hit" && isTrem == false){
36
            this.callback.SSActionEvent(this, this.gameObject);
37
            isTrem = true;
38
        }
39
        if (transform.position.y < -10 || transform.position.z > -6.7) {
40
            this.destroy = true;
41
        }
42
    }
43

44
}

展开收起

CCTrembleAction

箭抖动运动：抖动时间为0.5秒，通过箭的轻微上下运动来模拟抖动效果。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class CCTrembleAction : SSAction
6
{
7
    float radian = 0;
8
  float per_radian = 3f;
9
  float radius = 0.01f;
10
  Vector3 old_pos;
11
  public float left_time = 0.5f;
12

13
  public override void Start(){
14
        old_pos = transform.position;
15
    }
16
  public static CCTrembleAction GetSSAction(){
17
    CCTrembleAction tremble = CreateInstance<CCTrembleAction>();
18
    return tremble;
19
  }
20
  public override void Update(){
21
    left_time -= Time.deltaTime;
22
    if (left_time <= 0){
23
      transform.position = old_pos;
24
      this.destroy = true;
25
      this.callback.SSActionEvent(this);
26
    }
27
    radian += per_radian;
28
    float dy = Mathf.Cos(radian) * radius;
29
    transform.position = old_pos + new Vector3(0, dy, 0);
30
  }
31
  public override void FixedUpdate(){}
32

33
}

展开收起

ArrowFactory

箭工厂：用于生成与回收箭。这里是相当于最多生成10支箭，用完了则回收最先用的箭来用。生成箭或利用回收的箭时，记得恢复箭的初始属性。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class ArrowFactory : MonoBehaviour
6
{
7
    public GameObject arrow = null;
8
    List<GameObject> used;
9
    Queue<GameObject> free;
10

11

12
    void Start()
13
    {
14
        used = new List<GameObject>();
15
        free = new Queue<GameObject>();
16

17
    }
18

19
    public GameObject GetArrow(){
20
        if(free.Count == 0){
21
            arrow = Instantiate(Resources.Load<GameObject>("Prefabs/arrow"));
22
        }
23
        else{
24
            arrow = free.Dequeue();
25
            arrow.gameObject.SetActive(true);
26
            arrow.gameObject.tag = "Untagged";
27
            arrow.gameObject.transform.Find("head").gameObject.SetActive(true);
28
            arrow.gameObject.transform.Find("body").gameObject.SetActive(true);
29
            arrow.gameObject.transform.Find("head").GetComponent<arrowScript>().reset();
30
        }
31
        arrow.transform.position = new Vector3(0, 2.5f, -12.5F);
32
        used.Add(arrow);
33
        return arrow;
34
    }
35

36

37
    public void FreeArrow(){
38
        if(used.Count<=10)
39
            return;
40
        for(int i=0; i<used.Count; i++){
41
            if(used[i].gameObject.transform.position.y <= -10 || used[i].gameObject.transform.position.z >= -5 || used[i].gameObject.tag == "Hit"){
42
                used[i].GetComponent<Rigidbody>().isKinematic = true;
43
                used[i].gameObject.SetActive(false);
44
                used[i].transform.position =  new Vector3 (0, 2.5f, -12.5f);
45
                free.Enqueue(used[i]);
46
                used.Remove(used[i]);
47
                break;
48
            }
49
        }
50
    }
51
}

展开收起

RoundController

场景控制器：加载资源（靶子、墙体等），生成风，移动箭等的功能实现。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class RoundController : MonoBehaviour, ISceneController, IUserAction
6
{
7
    ArrowFactory factory;
8
    public CCActionManager actionManager;
9
    public ScoreController scoreController;
10
    public myUserGUI userGUI;
11

12
    public GameObject target;
13
    public GameObject arrow;
14
    public bool isStart = false;
15
    public string windTag = "";
16

17
    private float wind_directX;
18
  private float wind_directY;
19

20
    void Start()
21
    {
22
        Director director = Director.getInstance();
23
        director.currentSceneController = this;
24
        gameObject.AddComponent<ArrowFactory>();
25
        factory = Singleton<ArrowFactory>.Instance;
26
        actionManager = gameObject.AddComponent<CCActionManager>() as CCActionManager;
27
        scoreController = gameObject.AddComponent<ScoreController>() as ScoreController;
28
        userGUI = gameObject.AddComponent<myUserGUI>() as myUserGUI;
29
        LoadResource();
30
    }
31

32
    public void LoadResource()
33
    {
34
        target = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/target"));
35
        GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/wall"));
36

37
    }
38

39
    void Update()
40
    {
41
        if(isStart) {
42
            factory.FreeArrow();
43
        }
44
    }
45

46
    public void Init(){
47
        if(arrow == null){
48
            wind_directX = Random.Range(-4, 4);
49
      wind_directY = Random.Range(-4, 4);
50
            CreateWind();
51
            arrow = factory.GetArrow();
52
        }
53
    }
54

55
    public void moveBow(Vector3 mousePos){
56
        if(!isStart)
57
            return;
58
        arrow.transform.LookAt(mousePos * 30);
59
    }
60

61
    public void shootArrow(Vector3 force){
62
        if(isStart)
63
    {
64
      Vector3 wind = new Vector3(wind_directX, wind_directY, 0);
65
      actionManager.MoveArrow(arrow, wind, force * 10);
66
      arrow = null;
67
    }
68
    }
69
    public bool GetStart(){
70
        return isStart;
71
    }
72

73
    public string GetWind()
74
    {
75
        return windTag;
76
    }
77

78

79
    public void Begin()
80
    {
81
        isStart = true;
82
    }
83

84
    public int GetScore()
85
    {
86
        return scoreController.score;
87
    }
88

89
    public void CreateWind(){
90
        string Horizontal = "", Vertical = "", level = "";
91
        if (wind_directX > 0) {
92
            Horizontal = "西";
93
        } else if (wind_directX <= 0) {
94
            Horizontal = "东";
95
        }
96
        if (wind_directY > 0) {
97
            Vertical = "南";
98
        } else if (wind_directY <= 0) {
99
            Vertical = "北";
100
        }
101
        if ((wind_directX + wind_directY) / 2 > -1 && (wind_directX + wind_directY) / 2 < 1)
102
    {
103
      level = "1 级";
104
    }
105
    else if ((wind_directX + wind_directY) / 2 > -2 && (wind_directX + wind_directY) / 2 < 2)
106
    {
107
      level = "2 级";
108
    }
109
    else if ((wind_directX + wind_directY) / 2 > -3 && (wind_directX + wind_directY) / 2 < 3)
110
    {
111
      level = "3 级";
112
    }
113
    else if ((wind_directX + wind_directY) / 2 > -5 && (wind_directX + wind_directY) / 2 < 5)
114
    {
115
      level = "4 级";
116
    }
117
        windTag = Horizontal + Vertical + "风" + " " + level;
118

119
    }
120

121
    public bool isArrowNull(){
122
        return (arrow != null);
123
    }
124

125

126
}

展开收起

ScoreController

计分器：利用靶子上带有碰撞器的物体的tag来计分。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class ScoreController : MonoBehaviour
6
{
7
    public int score;
8

9
    public void Start(){
10
        score = 0;
11
    }
12

13
    public void Record(string ColliderTag){
14
        if(ColliderTag == "10"){
15
            score+=10;
16
        }
17
        else if(ColliderTag == "8"){
18
            score+=8;
19
        }
20
        else if(ColliderTag == "6"){
21
            score+=6;
22
        }
23
        else if(ColliderTag == "4"){
24
            score+=4;
25
        }
26
        else if(ColliderTag == "2"){
27
            score+=2;
28
        }
29

30
    }
31

32
    public void Reset(){
33
        score = 0;
34
    }
35
}

展开收起

3、小结#

要区分物理学与运动学，Rigidbody与isKinematic等的使用。
要区分各种碰撞检测模式，Discrete、Continus、Continus Dynamic等，有性能上的差异。
碰撞异常要思考：物体是否启用碰撞器、碰撞检测模式是否正确、物体运动是否过于高速、物体碰撞器体积是否过小等。
熟悉Rigidbody的一些属性与使用，方便实现物理运动效果。

HW5: 与游戏世界交互

Sun, 13 Nov 2022 00:00:00 GMT

作业简介：
1.自定义组件：涉及SciptableObject
2.编程实践（Hit UFO）：涉及工厂模式

一、自定义组件#

用自定义组件定义几种飞碟，做成预制

这里借用资源商店的Sets - Gems里的prefab（都是宝石呀）作为飞碟原型。

先利用 ScriptableObject 设定飞碟的属性

1
[System.Serializable]
2
public class Attributes{
3
    [Tooltip("大小")]
4
    public int size;
5
    [Tooltip("速度")]
6
    public int speed;
7
    [Tooltip("得分")]
8
    public int score;
9
}
10

11
[CreateAssetMenu(fileName = "DiskItem", menuName = "(ScritableObject)DiskItem")]
12
public class DiskItem : ScriptableObject
13
{
14
    public string Name;
15
    public string Desc;
16
    [Tooltip("飞碟属性")]
17
    public Attributes attributes;
18
}

展开收起

分数与对应的属性如下表所示:

分数	大小	速度
1	2	15
2	1	17
5	1	20
9	1	35

形状颜色与之匹配的分数规则如下图所示：

再利用Monobehavior脚本为各飞碟附上相应属性

1
public class Test : MonoBehaviour
2
{
3
    public DiskItem diskItem;
4
}

这样，我们自定义的预制件就做好了。

:space_invader:

二、编程实践#

项目地址：https://github.com/Cauchyoooo/3DGameDesign/tree/main/hw5/Assets

编写一个简单的鼠标打飞碟游戏
- 游戏有多个round，每个round包括数次trial；
- 每个trial的飞碟属性（色彩、大小、发射位置、速度、角度）及同时出现的个数都可能不同；
- 每个trial的飞碟有随机性，总体难度随round上升；
- 鼠标点中得分，得分规则按飞碟属性不同计算，规则可自定义。
要求：
- 使用带缓存的工厂模式管理不同飞碟的生产与回收，该工厂必须是场景单实例的！具体实现可参考资源Singleton模板类；
- 尽可能使用前面MVC结构实现人机交互与游戏模型分离。

简单工厂#

简单工厂又称为工厂方法，即类一个方法能够得到一个对象实例，使用者不需要知道该实例如何构建、初始化等细节。

游戏对象的创建与销毁高成本，必须减少销毁次数。
屏蔽创建与销毁的业务逻辑，是程序易于扩展。

在Unity中，工厂方法+单实例+对象池 通常都是同时一起用。这里给出一个设计例子：

其中：

DiskFactory 类是一个单实例类，用钱买场景单实例创建
DiskFactory 类有工厂方法 GetDisk 产生飞碟，有回收方法 FreeDisk
DiskFactory 使用模板模式根据预制和规则制作飞碟
对象模板包括飞碟对象与飞碟数据

实现效果#

代码框架#

其中标注了固定模板的类是基本与前几次作业使用的代码一致，除了Singleton是本次作业新增的。

Singleton代码如下：

1
public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
2
{
3
    protected static T instance;
4

5
    public static T Instance{
6
        get{
7
            if(instance == null){
8
                instance = (T)FindObjectOfType(typeof(T));
9
                if(instance == null){
10
                    Debug.LogError(
11
                        "An instance of "+
12
                        typeof(T)+
13
                        " is needed in the scene, but there is none."
14
                    );
15
                }
16
            }
17
            return instance;
18
        }
19
    }
20
}

展开收起

主要代码#

CCFlyAction

用于飞行动作。通过改变游戏对象position的z轴来实现其移动，也加入了游戏对象自己旋转。当z轴坐标不大于-20时，理解为飞出屏幕，销毁处理。

1
public class CCFlyAction : SSAction
2
{
3
    public float speed;
4
    public static CCFlyAction GetCCFlyAction(float s){
5
        CCFlyAction action = ScriptableObject.CreateInstance<CCFlyAction>();
6
        action.speed = s;
7
        return action;
8
    }
9

10
    public override void Start(){}
11

12
    public override void Update()
13
    {
14
        //飞碟已经被"销毁"
15
        if (this.transform.gameObject.activeSelf == false) {
16
            Debug.Log("Hit Destroy");
17
            this.destroy = true;
18
            this.callback.SSActionEvent(this);
19
            return;
20
        }
21
        if(this.transform.position.z <= -20){
22
            Debug.Log("Out Destroy");
23
            this.destroy = true;
24
            this.callback.SSActionEvent(this);
25
            return;
26
        }
27

28
        transform.position -= new Vector3(0, 0, speed * Time.deltaTime);
29
        transform.Rotate(new Vector3(0, 10 * Time.deltaTime, 30 * Time.deltaTime));
30
    }
31
}

展开收起

CCActionManager

用于管理飞行动作。注：其中这里的Update()不需要实现，则不要new，否则不能进入基类已编写好的Update()函数。

1
public class CCActionManager : SSActionManager, ISSActionCallback
2
{
3
    public RoundController sceneController;
4
    public CCFlyAction action;
5
    public DiskFactory factory;
6

7
    protected new void Start()
8
    {
9
        sceneController = (RoundController)Director.getInstance().currentSceneController;
10
        sceneController.actionManager = this;
11
        factory = Singleton<DiskFactory>.Instance;
12
    }
13

14
    // protected new void Update(){}
15

16
    public void SSActionEvent(
17
        SSAction source,
18
        SSActionEventType events = SSActionEventType.Completed,
19
        int intParam = 0,
20
        string strParam = null,
21
        Object objectParam = null) {
22
            factory.freeDisk(source.transform.gameObject);
23
    }
24

25
    public void MoveDisk(GameObject disk) {
26
        action = CCFlyAction.GetCCFlyAction((float)disk.GetComponent<Test>().diskItem.attributes.speed);
27
        RunAction(disk, action, this);
28
    }
29
}

展开收起

IUserAction & ISceneController

用户动作及场景动作的接口。两者共用一个getHit()来检测用户点击场景的游戏对象。

1
public interface IUserAction
2
{
3
    void gameOver();
4
    void getHit();
5
    void Restart();
6
}
7

8
public interface ISceneController
9
{
10
    void LoadResource();
11
    void getHit();
12
}

DiskFactory

飞碟工厂。used用于存储创造出来的飞碟，free用于要销毁的飞碟。由于飞碟对象使用我们前面制作的预制件，所以只需要使用及对不同round做一些处理即可。

对于第一轮，只会出现1分与2分的飞碟；第二轮只会出现1分、2分与5分的飞碟；第三轮往后会出现所有种类的飞碟。要注意飞碟加分与扣分的区别。飞碟的出生位置，随轮数增加而中心向外扩。

1
public class MyException : System.Exception
2
{
3
    public MyException(){}
4
    public MyException(string message) : base(message){}
5
}
6

7
public class DiskFactory : MonoBehaviour
8
{
9
    List<GameObject> used;
10
    List<GameObject> free;
11
    System.Random rand;
12

13
    void Start()
14
    {
15
        used = new List<GameObject>();
16
        free = new List<GameObject>();
17
        rand = new System.Random();
18
    }
19

20
    void Update(){}
21

22
    public string getDiskName(int seed){
23
        if(seed == 1)
24
            return "Prefabs/Bomb1a";
25
        if(seed == 2)
26
            return "Prefabs/Bomb1b";
27
        if(seed == 3)
28
            return "Prefabs/Bomb1c";
29
        if(seed == 4)
30
            return "Prefabs/Disk1a";
31
        if(seed == 5)
32
            return "Prefabs/Disk1b";
33
        if(seed == 6)
34
            return "Prefabs/Disk1c";
35
        if(seed == 7)
36
            return "Prefabs/Disk2a";
37
        if(seed == 8)
38
            return "Prefabs/Disk2b";
39
        if(seed == 9)
40
            return "Prefabs/Bomb5a";
41
        if(seed == 10)
42
            return "Prefabs/Disk5a";
43
        if(seed == 11)
44
            return "Prefabs/Bomb5b";
45
        if(seed == 12)
46
            return "Prefabs/Disk5b";
47
        if(seed == 13)
48
            return "Prefabs/Bomb9";
49
        if(seed == 14)
50
            return "Prefabs/Disk9";
51
        return "Error";
52
    }
53

54
    public GameObject createDisk(int round){
55
        GameObject disk;
56
        int right=7;
57
        if(round == 1)
58
            right = 7;
59
        else if(round == 2)
60
            right = 10;
61
        else
62
            right = 14;
63

64
        if(free.Count != 0){
65
            disk = free[0];
66
            free.Remove(disk);
67
        }
68
        else{
69
            string getName = getDiskName(rand.Next(1,right+1));
70
            disk = GameObject.Instantiate(Resources.Load(getName, typeof(GameObject))) as GameObject;
71
        }
72
        int roundX = round*10;
73
        int roundY = round*6;
74
        int roundZ = 100+round*20;
75
        disk.transform.position = new Vector3(rand.Next(-roundX,roundX+1), rand.Next(-roundY,roundY+1), rand.Next(80,roundZ));
76

77
        int scale = disk.GetComponent<Test>().diskItem.attributes.size;
78
        disk.transform.localScale = new Vector3(scale, scale, scale);
79

80
        used.Add(disk);
81
        disk.SetActive(true);
82
        Debug.Log("Generate disk success");
83
        return disk;
84
    }
85

86
    public void freeDisk(GameObject disk){
87
        disk.SetActive(false);
88
        if (!used.Contains(disk)) {
89
            throw new MyException("Try to remove a item from a list which doesn't contain it.");
90
        }
91
        Debug.Log("Free disk success");
92
        used.Remove(disk);
93
        free.Add(disk);
94
    }
95
}

展开收起

RoundController

局数控制器。相当于之前的FirstController。实现了用户行为与场景行为的接口。实现了每局产生飞碟的函数。每个round会有4次发射，每次发射6个飞碟，发射间隔会根据round增加而减小。利用射线碰撞检测鼠标点击飞碟。注：预制件中的飞碟必须要加入collider碰撞器。否则无法检测射线碰撞。

1
public class RoundController : MonoBehaviour, ISceneController, IUserAction
2
{
3
    int round = 1;
4
    int currDisk = 0;
5
    int max_round = 5;
6
    float timer = 1.0f;
7
    GameObject disk;
8
    DiskFactory factory;
9
    public CCActionManager actionManager;
10
    public ScoreController scoreController;
11
    public myUserGUI userGUI;
12

13
    void Start()
14
    {
15
        Director director = Director.getInstance();
16
        director.currentSceneController = this;
17
        director.currentSceneController.LoadResource();
18
        gameObject.AddComponent<DiskFactory>();
19
        factory = Singleton<DiskFactory>.Instance;
20
        actionManager = gameObject.AddComponent<CCActionManager>() as CCActionManager;
21
        scoreController = gameObject.AddComponent<ScoreController>() as ScoreController;
22
        userGUI = gameObject.AddComponent<myUserGUI>() as myUserGUI;
23

24
    }
25
    // No need to loadresource
26
    public void LoadResource(){}
27

28
    void Update()
29
    {
30
        if(userGUI.mode == 0)
31
            return;
32
        getHit();
33
        gameOver();
34
        if(round>max_round)
35
            return;
36
        timer -= Time.deltaTime;
37
        if(timer<=0 ){
38
            for(int i=0; i<6;i++){
39
                disk = factory.createDisk(round);
40
                actionManager.MoveDisk(disk);
41
            }
42
            currDisk+=6;
43
            if(round<=max_round)
44
                userGUI.round = round;
45
            timer = (float)(4-round*0.5);
46
            if(currDisk%24 == 0){
47
                round++;
48
                timer = 10.0F;
49
            }
50
        }
51
    }
52

53
    public void gameOver()
54
    {
55
        if (round > max_round && actionManager.RemainActionCount() == 0)
56
            userGUI.gameMessage = "Game Over!";
57
    }
58

59
    public void getHit()
60
    {
61
        // 按钮设置 名为“Fire1”监听鼠标点击
62
        if (Input.GetButtonDown("Fire1")) {
63
            Debug.Log("Fire pressed");
64
      Camera ca = Camera.main;
65
      Ray ray = ca.ScreenPointToRay(Input.mousePosition);
66

67
      RaycastHit hit;
68
      if (Physics.Raycast(ray, out hit)) {
69
                Debug.Log(hit.transform.gameObject.name);
70
                scoreController.Record(hit.transform.gameObject);
71
                hit.transform.gameObject.SetActive(false);
72
      }
73
        }
74
    }
75

76
    public void Restart(){
77
        round = 1;
78
        currDisk = 0;
79
        timer = 1.0F;
80
        scoreController.Reset();
81
        userGUI.Reset();
82
    }
83

84
}

展开收起

ScoreController

分数控制器。用于简单的计分功能。由于预制件中扣分的飞碟的score属性已经为负，此处的Record函数的score直接加就可以了。

1
public class ScoreController : MonoBehaviour
2
{
3
    public int score;
4
    public RoundController roundController;
5
    public myUserGUI userGUI;
6
    void Start()
7
    {
8
        roundController = (RoundController)Director.getInstance().currentSceneController;
9
        roundController.scoreController = this;
10
        userGUI = this.gameObject.GetComponent<myUserGUI>();
11
    }
12

13
    public void Record(GameObject disk){
14
        score += disk.GetComponent<Test>().diskItem.attributes.score;
15
        userGUI.score = score;
16
    }
17

18
    public void Reset(){
19
        score = 0;
20
    }
21
}

展开收起

myUserGUI

用户界面。分为主界面mainMenu和游玩界面gameStart。

1
public class myUserGUI : MonoBehaviour
2
{
3
    public int mode;
4
    public int score;
5
    public int round;
6
    public string gameMessage;
7
    private IUserAction action;
8
    public GUIStyle titleStyle, textStyle;
9
    private int menu_w = Screen.width/5, menu_h = Screen.height/5;
10

11
    void Start()
12
    {
13
        mode = 0;
14
        gameMessage = "";
15
        action = Director.getInstance().currentSceneController as IUserAction;
16

17
        titleStyle = new GUIStyle();
18
        titleStyle.normal.textColor = Color.white;
19
        titleStyle.normal.background = null;
20
        titleStyle.fontSize = 50;
21
        titleStyle.alignment = TextAnchor.MiddleCenter;
22

23
        textStyle = new GUIStyle();
24
        textStyle.normal.textColor = Color.white;
25
        textStyle.normal.background = null;
26
        textStyle.fontSize = 20;
27
        textStyle.alignment = TextAnchor.MiddleCenter;
28

29
    }
30

31
    void Update(){}
32

33
    void OnGUI()
34
    {
35
        GUI.skin.button.fontSize = 35;
36
        switch(mode){
37
            case 0:
38
                mainMenu();
39
                break;
40
            case 1:
41
                gameStart();
42
                break;
43
        }
44
    }
45

46
    void mainMenu()
47
    {
48
        GUI.Label(new Rect(Screen.width / 2 - menu_w * 0.5f, Screen.height * 0.1f, menu_w, menu_h), "Hit UFO", titleStyle);
49
        bool button = GUI.Button(new Rect(Screen.width / 2 - menu_w * 0.5f, Screen.height * 3 / 7, menu_w, menu_h), "Start");
50
        if (button) {
51
            mode = 1;
52
        }
53
    }
54

55
    void gameStart()
56
    {
57
        GUI.Label(new Rect(Screen.width/2-100, Screen.height/2-60, 200, 50), gameMessage, titleStyle);
58
        GUI.Label(new Rect(0, 0, 100, 50), "Score: " + score, textStyle);
59
        GUI.Label(new Rect(Screen.width-100, 0, 100, 50), "Round: " + round, textStyle);
60
        if (gameMessage == "Game Over!") {
61
      if (GUI.Button(new Rect(Screen.width/2-100, Screen.height/2, 200, 50), "Restart")) {
62
        action.Restart ();
63
      }
64
    }
65
    }
66

67
    public void Reset()
68
    {
69
        score = 0;
70
        round = 1;
71
        mode = 0;
72
        gameMessage = "";
73
    }
74

75
}

展开收起

HW4: 游戏对象与图形基础

Sat, 05 Nov 2022 00:00:00 GMT

作业简介：
1.基本操作演练（游戏场景）
2.编程实践

一、基本操作演练#

下载Fantasy Skybox FREE，构建自己的游戏场景（含天空、光源、音效、地形）

scene

写一个简单的总结，总结游戏对象的使用

目前学习到的一些游戏对象包括：3D Object里的基本物体和Terrain、Light、Camera、Skybox、Audio。每个GameObject都有Transform属性来设置位置旋转大小等。

基本物体（Cube、Sphere之类的）：单纯的物体，通过添加材质更改外观，添加各种组件实现功能。
Terrain：地面，通过Terrain自带的编辑工具可以编辑地形，如更改地形大小，修改地形高度，给地形“上色”，还可以添加树木花草等。我们更多地会选择使用别人做好现成的素材。

terrain1

terrain2
Light：灯光。光影的合理设置能更好地表达3D环境的颜色与情绪。有平行光、聚光灯、点光源、区域光等，不同光有不同属性面板。

如点光源这个面板，我们能看到像颜色、阴影等设置。

Light
Camera：摄影机。第一人称游戏可以作为玩家的眼睛，第三人称游戏可以跟随玩家运动。多摄像机是制造效果的重要手段。摄像机属性面板如下：

Camera

各属性说明可参考官方文档：https://docs.unity.cn/cn/2021.3/Manual/class-Camera.html
Skybox：天空盒（一种材料）。根据shader着色器的类型不同，需要配置不同的天空盒素材。如Skybox/Cubemap是一个圆形图片、Mobile/Skybox是6面图片、Skybox/Panoramic是一张全景图。制作好天空盒材质后，可以放到Camera的Skybox部件中。

skybox

skybox2
Audio：音源。可利用Audio Source在场景中播放声音，利用附着在角色对象上的Audio Listener监听场景中的声音。Audio Source可以设置为3D，听起来有立体的效果。通过混响等技巧可以产生更复杂的效果。

audio

二、编程实践#

牧师与魔鬼动作分离版+设计一个裁判类（当游戏到达结束条件时，通知场景控制器游戏结束）

项目地址：https://github.com/Cauchyoooo/3DGameDesign/tree/main/hw4/Assets/Scripts

对比上一个版本的一些区别：

将动作抽离出来形成一个动作管理器
增加了裁判类通知游戏结束
增加了计时器功能
游戏结束会在船靠岸之后才提示弹出来

实际效果如下图：

anime

1 动作管理器的设计#

uml

通过门面模式（控制器模式）输出组合好的几个动作，供原来程序调用。
通过组合模式实现动作组合，按组合模式设计方法
接口回调（函数回调）实现管理者与被管理者解耦
通过模板方法，让使用者减少对动作管理过程细节的要求
优点：
- 程序更能适应需求变化
- 对象更容易被复用
- 程序更易于维护

1.动作基类(SSAction)

SSAction是动作的基类，其他动作类都继承于它。
ScriptableObject是不需要绑定GameObject对象的可编程基类。这些对象受Unity引擎场景管理。
protected 防止用户自己new抽象的对象
使用virtual申明虚方法，通过重写实现多态。
利用接口(ISSActionCallback)实现消息通知，避免与动作管理者直接依赖

1
public class SSAction : ScriptableObject
2
{
3
    public bool enable = true;
4
    public bool destroy = false;
5

6
    public GameObject gameObject {get; set;}
7
    public Transform transform {get; set;}
8
    public ISSActionCallback callback {get; set;}
9

10
    protected SSAction(){}
11

12
    public virtual void Start()
13
    {
14
        throw new System.NotImplementedException();
15
    }
16

17
    public virtual void Update()
18
    {
19
        throw new System.NotImplementedException();
20
    }
21
}

展开收起

2.动作管理基类(SSActionManager)

该类实现所有动作的基本管理，CCActionManager会继承于它。
利用一个动作字典来进行动作的运行，先将waitingAdd中的动作加入字典中，运行动作后，再将它加入到waitingDelete中销毁。由于字典是线程不安全的，如果控制好队列，如每次最多存在一个动作，就不会导致动作的混乱。
提供了添加新动作的方法RunAction。该方法把游戏对象与动作绑定，并绑定该动作事件的消息接受者。

1
public class SSActionManager : MonoBehaviour {
2
    //动作集，以字典形式存在
3
    private Dictionary<int, SSAction> actions = new Dictionary<int, SSAction>();
4
    //等待被加入的动作队列(动作即将开始)
5
    private List<SSAction> waitingAdd = new List<SSAction>();
6
    //等待被删除的动作队列(动作已完成)
7
    private List<int> waitingDelete = new List<int>();
8

9
    protected void Update()
10
    {
11
        //将waitingAdd中的动作保存
12
        foreach (SSAction ac in waitingAdd)
13
            actions[ac.GetInstanceID()] = ac;
14
        waitingAdd.Clear();
15

16
        //运行被保存的事件
17
        foreach (KeyValuePair<int, SSAction> kv in actions)
18
        {
19
            SSAction ac = kv.Value;
20
            if (ac.destroy)
21
            {
22
                waitingDelete.Add(ac.GetInstanceID());
23
            }
24
            else if (ac.enable)
25
            {
26
                ac.Update();
27
            }
28
        }
29

30
        //销毁waitingDelete中的动作
31
        foreach (int key in waitingDelete)
32
        {
33
            SSAction ac = actions[key];
34
            actions.Remove(key);
35
            Destroy(ac);
36
        }
37
        waitingDelete.Clear();
38
    }
39

40
    //准备运行一个动作，将动作初始化，并加入到waitingAdd
41
    public void RunAction(GameObject gameObject, SSAction action, ISSActionCallback manager)
42
    {
43
        action.gameObject = gameObject;
44
        action.transform = gameObject.transform;
45
        action.callback = manager;
46
        waitingAdd.Add(action);
47
        action.Start();
48
    }
49

50
    protected void Start()
51
    {
52

53
    }
54
}

展开收起

3.动作事件接口定义(ISSActionCallback)

接口作为接收通知对象的抽象类型，所有事件管理者都必须实现该接口，来实现事件调度。
事件类型定义，使用了枚举变量。

1
public enum SSActionEventType:int {Started, Completed}
2
public interface ISSActionCallback
3
{
4
    //回调函数
5
    void SSActionEvent(
6
        SSAction source,
7
        SSActionEventType events = SSActionEventType.Completed,
8
        int intParam = 0,
9
        string strParam = null,
10
        Object objectParam = null
11
    );
12
}

4.简单动作实现(CCMoveToAction)

实现移动动作，将物体移动到目标位置，并通知任务完成。
让Unity创建动作类，确保内存正确回收。
override 多态，c++必须申明重写，java则默认重写。

1
public class CCMoveToAction : SSAction
2
{
3

4
    public Vector3 target; //目的地
5
    public float speed; //速度
6

7
    private CCMoveToAction(){}
8

9
    //生产函数(工厂模式)
10
    public static CCMoveToAction GetSSAction(Vector3 target, float speed)
11
    {
12
        CCMoveToAction action = ScriptableObject.CreateInstance<CCMoveToAction>();
13
        action.target = target;
14
        action.speed = speed;
15
        return action;
16
    }
17

18
    public override void Start(){}
19

20
    public override void Update()
21
    {
22
        //判断是否符合移动条件
23
        if (this.gameObject == null || this.transform.position == target)
24
        {
25

26
            this.destroy = true;
27
            this.callback.SSActionEvent(this);
28
            return;
29
        }
30
        //移动
31
        this.transform.position = Vector3.MoveTowards(this.transform.position, target, speed * Time.deltaTime);
32
    }
33
}

展开收起

5.顺序动作组合类实现(CCSequenceAction)

实现一个动作组合序列，顺序播放动作。
让动作组合继承抽象动作SSAction，能够进一步组合；实现回调接收，能接受被组合动作的事件。
创建一个动作顺序执行序列，-1表示无限循环，start开始动作。
SSActionEvent 收到当前动作执行完成，推下一个动作，如果完成一次循环，减次数。如完成，通知该动作的管理者。
Start 执行动作前，为每个动作注入当前动作游戏对象，并将自己作为动作事件的接收者。
OnDestroy 如果自己被注销，应该释放自己管理的动作。这里不会被注销，因此没有实现该功能。
这是标准的组合设计模式。被组合对象和组合对象同属一种类型。通过该模式，我们能实现几乎满足所有越位需要、非常复杂的动作管理。

1
public class CCSequenceAction : SSAction, ISSActionCallback
2
{
3
    public List<SSAction> sequence; //动作序列
4
    public int repeat = -1; //重复次数
5
    public int start = 0; //动作开始指针
6

7
    //生产函数(工厂模式)
8
    public static CCSequenceAction GetSSAction(int repeat, int start, List<SSAction> sequence)
9
    {
10
        CCSequenceAction action = ScriptableObject.CreateInstance<CCSequenceAction>();
11
        action.repeat = repeat;
12
        action.sequence = sequence;
13
        action.start = start;
14
        return action;
15
    }
16

17
    public override void Start()
18
    {
19
        foreach (SSAction action in sequence)
20
        {
21
            action.gameObject = this.gameObject;
22
            action.transform = this.transform;
23
            action.callback = this;
24
            action.Start();
25
        }
26
    }
27

28
    public override void Update()
29
    {
30
        if (sequence.Count == 0)
31
            return;
32
        if (start < sequence.Count)
33
            sequence[start].Update();
34
    }
35

36
    //回调处理，当有动作完成时触发
37
    public void SSActionEvent(
38
        SSAction source,
39
        SSActionEventType events = SSActionEventType.Completed,
40
        int Param = 0,
41
        string strParam = null,
42
        Object objectParam = null)
43
    {
44
        source.destroy = false;
45
        this.start++;
46
        if (this.start >= sequence.Count)
47
        {
48
            this.start = 0;
49
            if (repeat > 0)
50
                repeat--;
51
            if (repeat == 0)
52
            {
53
                this.destroy = true;
54
                this.callback.SSActionEvent(this);
55
            }
56
        }
57
    }
58

59
    void OnDestroy()
60
    {
61
        //TODO: Something
62
    }
63
}

展开收起

6.动作组合管理(CCActionManager)

上一版本的moveable脚本拆分到这个类和FirstController的方法中，实现船和角色的移动管理。

1
// 将原来移动的方法 放在这里
2
public class CCActionManager : SSActionManager, ISSActionCallback
3
{
4
    //是否正在运动
5
    private bool isMoving = false;
6
    //船移动动作类
7
    public CCMoveToAction moveBoatAction;
8
    //人移动动作类(需要组合)
9
    public CCSequenceAction moveRoleAction;
10
    //控制器
11
    public FirstController controller;
12

13
    protected new void Start()
14
    {
15
        controller = (FirstController)Director.getInstance().currentSceneController;
16
        controller.actionManager = this;
17
    }
18

19
    public bool IsMoving()
20
    {
21
        return isMoving;
22
    }
23

24
    //移动船
25
    public void MoveBoat(GameObject boat, Vector3 target, float speed)
26
    {
27
        if (isMoving)
28
            return;
29
        isMoving = true;
30
        moveBoatAction = CCMoveToAction.GetSSAction(target, speed);
31
        this.RunAction(boat, moveBoatAction, this);
32
    }
33

34
    //移动人
35
    public void MoveRole(GameObject role, Vector3 mid_destination, Vector3 destination, int speed)
36
    {
37
        if (isMoving)
38
            return;
39
        isMoving = true;
40
        moveRoleAction = CCSequenceAction.GetSSAction(0, 0, new List<SSAction>
41
            {   CCMoveToAction.GetSSAction(mid_destination, speed),
42
                CCMoveToAction.GetSSAction(destination, speed) });
43
        this.RunAction(role, moveRoleAction, this);
44
    }
45

46
    //回调函数
47
    public void SSActionEvent(SSAction source,
48
    SSActionEventType events = SSActionEventType.Completed,
49
    int intParam = 0,
50
    string strParam = null,
51
    Object objectParam = null)
52
    {
53
        isMoving = false;
54
    }
55
}

展开收起

2 部分控制类的设计#

1.最高层控制器(FirstController)

这里仅展示有增改的函数方法，增添了一个裁判反馈信息JudgeCallback，实现裁判类的回调函数。
将原有检测游戏状态的check函数抽离给裁判类JudgeController处理。
处理了原有可移动脚本moveable的一些部分，利于与动作管理器结合。

1
public class FirstController : MonoBehaviour, ISceneController, IUserAction
2
{
3
    readonly Vector3 waterPos = new Vector3(0,0.5F,0);
4
    public CCActionManager actionManager;
5
    public JudgeController judgeController;
6
    public CoastController startCoast;
7
    public CoastController endCoast;
8
    public BoatController boat;
9
    private myCharacterController[] characters;
10
    myUserGUI userGUI;
11
    public bool isRunning;
12
    public float time;
13

14
    public void JudgeCallback(bool _isRunning, string message)
15
    {
16
        userGUI.gameMessage = message;
17
        userGUI.time = (int)time;
18
        this.isRunning = _isRunning;
19
    }
20

21
    void Start ()
22
    {
23
        Director director = Director.getInstance();
24
        director.currentSceneController = this;
25
        userGUI = gameObject.AddComponent<myUserGUI>() as myUserGUI;
26
        actionManager = gameObject.AddComponent<CCActionManager>() as CCActionManager;
27
        judgeController = gameObject.AddComponent<JudgeController>() as JudgeController;
28
        characters = new myCharacterController[6];
29
        isRunning = true;
30
        time = 60;
31
        LoadResources();
32
    }
33

34
    public void moveBoat(){
35
        if(isRunning == false || actionManager.IsMoving())
36
            return;
37
        if(boat.isEmpty())
38
            return;
39
        string direct = boat.getDirection();
40
        Vector3 destination = boat.getPosition();
41
        if (direct == "End") {
42
      boat.setDirection("Start");
43
    }
44
    else {
45
      boat.setDirection("End");
46
    }
47
        actionManager.MoveBoat(boat.getGameobj(), destination, 20);
48
    }
49

50
    public void ClickCharacter(myCharacterController cC){
51
        if(isRunning == false || actionManager.IsMoving())
52
            return;
53
        if(cC.isOnBoat()){
54
            CoastController coast;
55
            if(boat.getDirection()=="Start")
56
                coast = startCoast;
57
            else
58
                coast = endCoast;
59

60
            boat.getOffBoat(cC.getName());
61
            Vector3 destination = coast.getEmptyPosition();
62
            Vector3 middle = destination;
63
            if (destination.y < cC.GetGameObject().transform.position.y) {
64
          middle.y = cC.GetGameObject().transform.position.y;
65
        }
66
        else {
67
          middle.x = cC.GetGameObject().transform.position.x;
68
        }
69
            // cC.moveTo(coast.getEmptyPosition());
70
            actionManager.MoveRole(cC.GetGameObject(), middle, destination, 20);
71
            cC.getOnCoast(coast);
72
            coast.getOnCoast(cC);
73
        }
74
        else{
75
            CoastController coast = cC.getCoastController();
76
            if(boat.getEmptyIndex () == -1 || coast.getDirection() != boat.getDirection())
77
                return;
78
            coast.getOffCoast(cC.getName());
79
            Vector3 destination = boat.getEmptyPosition();
80
            Vector3 middle = destination;
81
            if (destination.y < cC.GetGameObject().transform.position.y) {
82
          middle.y = cC.GetGameObject().transform.position.y;
83
        }
84
        else {
85
          middle.x = cC.GetGameObject().transform.position.x;
86
        }
87
            actionManager.MoveRole(cC.GetGameObject(), middle, destination, 20);
88
            // cC.moveTo(boat.getEmptyPosition());
89
            cC.getOnBoat(boat);
90
            boat.getOnBoat(cC);
91
        }
92
    }
93

94
    public void Restart(){
95
        //boat 移动归位
96
        if(boat.getDirection()=="End"){
97
            Vector3 destination = boat.getPosition();
98
            actionManager.MoveBoat(boat.getGameobj(), destination, 20);
99
        }
100
        boat.reset();
101
        startCoast.reset();
102
        endCoast.reset();
103
        for(int i=0;i<characters.Length;i++)
104
            characters[i].reset();
105
        isRunning = true;
106
        time = 60;
107
    }
108

109
}

展开收起

2.裁判类(JudgeController)

实现原有FristController的check函数功能，检测游戏状态，在游戏结束时用过回调信息通知FirstController。

1
public class JudgeController : MonoBehaviour {
2
    public FirstController mainController;
3
    public CoastController startCoast;
4
    public CoastController endCoast;
5
    public BoatController boat;
6

7

8
    void Start()
9
    {
10
        this.mainController = (FirstController)Director.getInstance().currentSceneController;
11
        this.startCoast = mainController.startCoast;
12
        this.endCoast = mainController.endCoast;
13
        this.boat = mainController.boat;
14

15
    }
16

17
    void Update()
18
    {
19
        if (!mainController.isRunning)
20
            return;
21
        if(!boat.isStop())
22
            return;
23
        if (mainController.time <= 0)
24
        {
25
            mainController.JudgeCallback(false, "Game Over!");
26
            return;
27
        }
28

29
        this.gameObject.GetComponent<myUserGUI>().gameMessage = "";
30

31
        int startPriest = 0;
32
        int endPriest = 0;
33
        int startDevil = 0;
34
        int endDevil = 0;
35

36
        int[] startCount = startCoast.getNum();
37
        startPriest += startCount[0];
38
        startDevil += startCount[1];
39

40
        int[] endCount = endCoast.getNum();
41
        endPriest += endCount[0];
42
        endDevil += endCount[1];
43

44
        if(endDevil+endPriest ==6){
45
            mainController.JudgeCallback(false, "You Win!");
46
            return;
47
        }
48

49
        int[] boatCount = boat.getNum();
50
        if(boat.getDirection() == "End"){
51
            endPriest += boatCount[0];
52
            endDevil += boatCount[1];
53
        }
54
        else{
55
            startPriest += boatCount[0];
56
            startDevil += boatCount[1];
57
        }
58

59
        if(startPriest<startDevil && startPriest>0){
60
            mainController.JudgeCallback(false, "Game Over!");
61
            return;
62
        }
63
        if(endPriest<endDevil && endPriest>0){
64
            mainController.JudgeCallback(false, "Game Over!");
65
            return;
66
        }
67
    }
68
}

展开收起

HW3: 空间与运动

Sun, 23 Oct 2022 00:00:00 GMT

作业简介： 1.简答题（涉及游戏对象运动） 2.编程实践
ps. GIF图片加载比较慢

一、简答题#

游戏对象运动的本质是什么？

游戏对象随着每一帧而发生的空间位置（相对的或绝对的）、旋转角度及缩放的变化。

用三种以上方法实现物体的抛物线运动。

抛物线运动的实质是一个方向匀速运动，与其垂直的一个方向进行匀加速运动。

效果图：

parabola

法一：对transform.position分方向加变化值

1
void Update()
2
    {
3
        if(frame<=60){  //运行60帧
4
            //向下的方向 匀变速
5
            this.transform.position += Vector3.down * Time.deltaTime * v;
6
            //向左的方向 匀速
7
            this.transform.position += Vector3.left * Time.deltaTime * 2f;
8

9
            this.transform.Rotate(0f,0f,1f,Space.Self); //每帧旋转 1°
10
            v+=0.1f; //加速度为0.1
11
            frame++;
12
        }
13
    }

法二：对transform.position整体方向加变化值

1
void Update()
2
    {
3
        if(frame<=60){  //运行60帧
4
          // 注意正负区分方向
5
            Vector3 change = new Vector3(-Time.deltaTime*2f, -Time.deltaTime *v, 0f);
6
            this.transform.position += change;
7

8
            this.transform.Rotate(0f,0f,1f,Space.Self); //每帧旋转 1°
9
            v+=0.1f;
10
            frame++;
11
        }
12
    }

法三：对transform.position应用transform.Translate函数

1
void Update()
2
    {
3
        if(frame<=60){  //运行60帧
4
            Vector3 change = new Vector3(-Time.deltaTime*2f, -Time.deltaTime *v, 0f);
5
            this.transform.Translate(change,Space.World);
6

7
      // transform.Translate默认是相对于变换的本地轴(Space.Self)来应用该移动
8
      // 坐标变换有所区别，不是很好分辨方向
9
            // Vector3 change = new Vector3(-Time.deltaTime *v,Time.deltaTime*2f,0f);
10
            // this.transform.Translate(change);
11

12
            this.transform.Rotate(0f,0f,1f,Space.Self); //每帧旋转 1°
13
            v+=0.1f;
14
            frame++;
15
        }
16
    }

展开收起

写一个程序，实现完整的太阳系，其他星球围绕太阳的转速必须不一样，且不在一个法平面上。

这里的实现方式是写了个脚本，将围绕太阳旋转的星球都加入这个脚本，然后手动设置不同星球的自传和公转的速度。

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
public class planetAround : MonoBehaviour
6
{
7
    public GameObject target;
8
    public float selfround = 1f; //自转速度
9
    public float pubaround = 1f; //公转速度
10

11
    void Update()
12
    {
13
        this.transform.Rotate(Vector3.up * Time.deltaTime *selfround);
14
        this.transform.RotateAround(target.transform.position, Vector3.up, 5 * pubaround * Time.deltaTime);
15
    }
16
}

展开收起

实际效果：

二、编程实践#

试玩游戏界面

游戏规则：

游戏开始时，在河岸的一边有3个牧师与3个魔鬼，他们都想过到河的另一边。
只有一艘小船，小船每次最多乘两个人，且必须有一个人船才能动。
玩家可以点击牧师或魔鬼让他们上下船，点击船来使船在两岸往返。
如果在某一河岸牧师的数量少于魔鬼的数量（包括停在岸边船上人的数量），牧师被杀死，游戏失败。
使牧师与魔鬼都到达对岸时，游戏胜利。

Object#

Object	Num
河岸(Coast)	2
河水(Water)	1
船(Boat)	1
牧师(Priest)	3
恶魔(Devil)	3

UserAction#

Action	Condition	Effect
点击岸上角色	船在相应的河岸，船上人数少于2人	角色上船
点击船上角色	无	角色上岸
点击船	船上有至少一个角色	船移动到另一岸
点击Restart	游戏结束	重新开始游戏

Prefabs#

涉及的材质与部分预制来源于Assest Store。

河岸(Coast)

河水(Water)

船(Boat)

牧师(Priest)

恶魔(Devil)

MVC框架#

Map

主要代码#

项目地址：https://github.com/Cauchyoooo/3DGameDesign/tree/main/hw3/Assets

Director#

采用单例模式，在运行时才创建Director实例，若已创建该实例不会重复创建。

1
public class Director : System.Object
2
{
3
    private static Director _instance;
4

5
    public ISceneController currentSceneController { get; set;}
6

7
    public static Director getInstance()
8
    {
9
        if(_instance == null){
10
            _instance = new Director();
11
        }
12
        return _instance;
13
    }
14
}

ISceneController#

场记接口，用于加载场景资源。

1
public interface ISceneController
2
{
3
  void LoadResources();
4
}

IUserAction#

用户操作接口，用于记录可能的用户操作。这里将上述的4个行为转化为以下3个。

1
public interface IUserAction
2
{
3
    void ClickCharacter(myCharacterController charactorController);
4
    void moveBoat();
5
    void Restart();
6
}

Moveable#

可移动脚本，具有该组件的游戏对象才可以移动。

1
public class Moveable : MonoBehaviour
2
{
3
    readonly float moveSpeed = 20;
4
    /// 0->not moving 1->moving to middle 2->moving to destination
5
    int moveStatus;
6
    Vector3 destination;
7
    Vector3 middle;
8

9
    void Update() {
10
    if (moveStatus == 1) {
11
      transform.position = Vector3.MoveTowards (transform.position, middle, moveSpeed * Time.deltaTime);
12
      if (transform.position == middle) {
13
        moveStatus = 2;
14
      }
15
    }
16
        else if (moveStatus == 2) {
17
      transform.position = Vector3.MoveTowards (transform.position, destination, moveSpeed * Time.deltaTime);
18
      if (transform.position == destination) {
19
        moveStatus = 0;
20
      }
21
    }
22
  }
23
  public void setDestination(Vector3 d) {
24
    destination = d;
25
    middle = d;
26
    /// Moving Boat
27
    if (d.y == transform.position.y) {
28
      moveStatus = 2;
29
    }
30
    /// Move character from coast to boat
31
    else if (d.y < transform.position.y) {
32
      middle.y = transform.position.y;
33
    }
34
    /// Move character from boat to coast
35
    else {
36
      middle.x = transform.position.x;
37
    }
38
    moveStatus = 1;
39
  }
40

41
  public void reset() {
42
    moveStatus = 0;
43
  }
44
}

展开收起

CoastController#

河岸控制器，用于创建河岸及涉及河岸的各种操作

1
public class CoastController
2
{
3
  readonly GameObject coast;
4
  readonly Vector3 startPos = new Vector3(9,1,0);
5
  readonly Vector3 endPos = new Vector3(-9,1,0);
6
  readonly Vector3[] positions;
7
  /// direction : Start or End
8
  readonly string direction;
9

10
  /// change frequently
11
  myCharacterController[] passengerPlaner;
12

13
  public CoastController(string direc) {
14
    positions = new Vector3[] {new Vector3(6.5F,2.0F,0), new Vector3(7.5F,2.0F,0), new Vector3(8.5F,2.0F,0),
15
      new Vector3(9.5F,2.0F,0), new Vector3(10.5F,2.0F,0), new Vector3(11.5F,2.0F,0)};
16

17
    passengerPlaner = new myCharacterController[6];
18

19
    if (direc == "Start") {
20
      coast = Object.Instantiate (Resources.Load ("Prefabs/Coast", typeof(GameObject)), startPos, Quaternion.identity, null) as GameObject;
21
      coast.name = "Start";
22
            coast.tag = "Start";
23
      direction = "Start";
24
    }
25
        else if(direc == "End"){
26
      coast = Object.Instantiate (Resources.Load ("Prefabs/Coast", typeof(GameObject)), endPos, Quaternion.identity, null) as GameObject;
27
      coast.name = "End";
28
            coast.tag = "End";
29
      direction = "End";
30
    }
31
  }
32

33
  public int getEmptyIndex() {
34
    for (int i = 0; i < passengerPlaner.Length; i++) {
35
      if (passengerPlaner [i] == null) {
36
        return i;
37
      }
38
    }
39
    return -1;
40
  }
41

42
  public Vector3 getEmptyPosition() {
43
    Vector3 pos = positions [getEmptyIndex ()];
44
        if(direction == "End")
45
            pos.x *= -1;
46
    return pos;
47
  }
48

49
  public void getOnCoast(myCharacterController cC) {
50
    int index = getEmptyIndex ();
51
    passengerPlaner [index] = cC;
52
  }
53

54
  public myCharacterController getOffCoast(string passengerName) {
55
    for (int i = 0; i < passengerPlaner.Length; i++) {
56
      if (passengerPlaner [i] != null && passengerPlaner [i].getName () == passengerName) {
57
        myCharacterController cC = passengerPlaner [i];
58
        passengerPlaner [i] = null;
59
        return cC;
60
      }
61
    }
62
    return null;
63
  }
64

65
  public string getDirection() {
66
    return direction;
67
  }
68

69
  public int[] getNum() {
70
    int[] count = {0, 0};
71
    for (int i = 0; i < passengerPlaner.Length; i++) {
72
      if (passengerPlaner [i] == null)
73
        continue;
74
      /// 0->priest, 1->devil
75
      if (passengerPlaner [i].getType () == 0) {
76
        count[0]++;
77
      }
78
            else {
79
        count[1]++;
80
      }
81
    }
82
    return count;
83
  }
84

85
  public void reset() {
86
    passengerPlaner = new myCharacterController[6];
87
  }
88
}

展开收起

BoatController#

船控制器，用于创建船及涉及船的各种操作。

1
public class BoatController
2
{
3
    readonly GameObject boat;
4
  readonly Moveable moveScript;
5
  readonly Vector3 startPosition = new Vector3 (5, 1, 0);
6
  readonly Vector3 endPosition = new Vector3 (-5, 1, 0);
7
  readonly Vector3[] startPositions;
8
  readonly Vector3[] endPositions;
9

10
  /// change frequently
11
    string direction;
12
  myCharacterController[] passenger = new myCharacterController[2];
13

14
  public BoatController() {
15
    direction = "Start";
16

17
    startPositions = new Vector3[] { new Vector3 (4.5F, 1.1F, 0), new Vector3 (5.5F, 1.1F, 0) };
18
    endPositions = new Vector3[] { new Vector3 (-5.5F, 1.1F, 0), new Vector3 (-4.5F, 1.1F, 0) };
19

20
    boat = Object.Instantiate (Resources.Load ("Prefabs/Boat", typeof(GameObject)), startPosition, Quaternion.identity, null) as GameObject;
21
    boat.name = "boat";
22
        boat.tag = "Boat";
23

24
    moveScript = boat.AddComponent (typeof(Moveable)) as Moveable;
25
    boat.AddComponent (typeof(Click));
26
  }
27

28
  public void Move() {
29
    if (direction == "End") {
30
      moveScript.setDestination(startPosition);
31
      direction = "Start";
32
    }
33
    else {
34
      moveScript.setDestination(endPosition);
35
      direction = "End";
36
    }
37
  }
38

39
  public int getEmptyIndex() {
40
    for (int i = 0; i < passenger.Length; i++) {
41
      if (passenger [i] == null) {
42
        return i;
43
      }
44
    }
45
    return -1;
46
  }
47

48
  public bool isEmpty() {
49
    for (int i = 0; i < passenger.Length; i++) {
50
      if (passenger [i] != null) {
51
        return false;
52
      }
53
    }
54
    return true;
55
  }
56

57
  public Vector3 getEmptyPosition() {
58
    Vector3 pos;
59
    int emptyIndex = getEmptyIndex ();
60
    if (direction == "End") {
61
      pos = endPositions[emptyIndex];
62
    }
63
    else {
64
      pos = startPositions[emptyIndex];
65
    }
66
    return pos;
67
  }
68

69
  public void getOnBoat(myCharacterController characterCtrl) {
70
    int index = getEmptyIndex ();
71
    passenger [index] = characterCtrl;
72
  }
73

74
  public myCharacterController getOffBoat(string passenger_name) {
75
    for (int i = 0; i < passenger.Length; i++) {
76
      if (passenger [i] != null && passenger [i].getName () == passenger_name) {
77
        myCharacterController charactorCtrl = passenger [i];
78
        passenger [i] = null;
79
        return charactorCtrl;
80
      }
81
    }
82
    return null;
83
  }
84

85
  public GameObject getGameobj() {
86
    return boat;
87
  }
88

89
  public string getDirection() {
90
    return direction;
91
  }
92

93
  public int[] getNum() {
94
    int[] count = {0, 0};
95
    for (int i = 0; i < passenger.Length; i++) {
96
      if (passenger [i] == null)
97
        continue;
98
      /// 0->priest, 1->devil
99
      if (passenger [i].getType () == 0) {
100
        count[0]++;
101
      }
102
      else {
103
        count[1]++;
104
      }
105
    }
106
    return count;
107
  }
108

109
  public void reset() {
110
    moveScript.reset ();
111
    if (direction == "End") {
112
      Move ();
113
    }
114
    passenger = new myCharacterController[2];
115
  }
116
}

展开收起

myCharacterController#

角色控制器，用于创建牧师(Priest)与魔鬼(Devil)，及涉及角色的各种操作。

1
public class myCharacterController
2
{
3
    readonly GameObject character;
4
  readonly Moveable moveScript;
5
  readonly Click click;
6
  /// 0->priest, 1->devil
7
  readonly int characterType;
8
  /// change frequently
9
  bool _isOnBoat;
10
  CoastController coastController;
11

12
  public myCharacterController(string _character) {
13
    if (_character == "Priest") {
14
      character = Object.Instantiate (Resources.Load ("Prefabs/Priest", typeof(GameObject)), Vector3.zero, Quaternion.Euler(0, 180, 0), null) as GameObject;
15
      characterType = 0;
16
    }
17
        else {
18
      character = Object.Instantiate (Resources.Load ("Prefabs/Devil", typeof(GameObject)), Vector3.zero, Quaternion.Euler(0, 180, 0), null) as GameObject;
19
      characterType = 1;
20
    }
21
    moveScript = character.AddComponent (typeof(Moveable)) as Moveable;
22

23
    click = character.AddComponent (typeof(Click)) as Click;
24
    click.setController (this);
25
  }
26

27
  public void setName(string name) {
28
    character.name = name;
29
  }
30

31
    public void setTag(string tag) {
32
    character.tag = tag;
33
  }
34

35
  public void setPosition(Vector3 pos) {
36
    character.transform.position = pos;
37
  }
38

39
  public void moveTo(Vector3 destination) {
40
    moveScript.setDestination(destination);
41
  }
42

43
  public int getType() {
44
    return characterType;
45
  }
46

47
  public string getName() {
48
    return character.name;
49
  }
50

51
    public string getTag() {
52
    return character.tag;
53
  }
54

55
  public void getOnBoat(BoatController boat) {
56
    coastController = null;
57
    character.transform.parent = boat.getGameobj().transform;
58
    _isOnBoat = true;
59
  }
60

61
  public void getOnCoast(CoastController coast) {
62
    coastController = coast;
63
    character.transform.parent = null;
64
    _isOnBoat = false;
65
  }
66

67
  public bool isOnBoat() {
68
    return _isOnBoat;
69
  }
70

71
  public CoastController getCoastController() {
72
    return coastController;
73
  }
74

75
  public void reset() {
76
    moveScript.reset ();
77
    coastController = (Director.getInstance ().currentSceneController as FirstControllor).startCoast;
78
    getOnCoast (coastController);
79
    setPosition (coastController.getEmptyPosition ());
80
    coastController.getOnCoast (this);
81
  }
82
}

展开收起

FirstController#

最高层控制器，实现场记接口、用户行动接口的功能。

1
public class FirstController : MonoBehaviour, ISceneController, IUserAction
2
{
3
    readonly Vector3 waterPos = new Vector3(0,0.5F,0);
4
    public CoastController startCoast;
5
    public CoastController endCoast;
6
    public BoatController boat;
7
    private myCharacterController[] characters;
8
    myUserGUI userGUI;
9

10
    void Start ()
11
    {
12
        Director director = Director.getInstance();
13
        director.currentSceneController = this;
14
        userGUI = gameObject.AddComponent<myUserGUI>() as myUserGUI;
15
        characters = new myCharacterController[6];
16
        LoadResources();
17
    }
18

19
    public void LoadResources(){
20
        GameObject water = Instantiate(Resources.Load("Prefabs/Water", typeof(GameObject)), waterPos, Quaternion.identity, null) as GameObject;
21
        water.name = "water";
22
        water.tag = "Water";
23

24
        startCoast = new CoastController("Start");
25
        endCoast = new CoastController("End");
26
        boat = new BoatController();
27

28
        for(int i=0;i<3;i++){
29
            myCharacterController priest = new myCharacterController("Priest");
30
            priest.setName("Priest "+i);
31
            priest.setTag("Priest");
32
            priest.setPosition(startCoast.getEmptyPosition());
33
            priest.getOnCoast(startCoast);
34
            startCoast.getOnCoast(priest);
35
            characters[i] = priest;
36
        }
37

38
        for(int i=0;i<3;i++){
39
            myCharacterController devil = new myCharacterController("Devil");
40
            devil.setName("Devil "+i);
41
            devil.setTag("Devil");
42
            devil.setPosition(startCoast.getEmptyPosition());
43
            devil.getOnCoast(startCoast);
44
            startCoast.getOnCoast(devil);
45
            characters[i+3] = devil;
46
        }
47
    }
48

49
    public void moveBoat(){
50
        if(boat.isEmpty())
51
            return;
52
        boat.Move();
53
        userGUI.status = checkGameOver();
54
    }
55

56
    public void ClickCharacter(myCharacterController cC){
57
        if(cC.isOnBoat()){
58
            CoastController coast;
59
            if(boat.getDirection()=="Start")
60
                coast = startCoast;
61
            else
62
                coast = endCoast;
63

64
            boat.getOffBoat(cC.getName());
65
            cC.moveTo(coast.getEmptyPosition());
66
            cC.getOnCoast(coast);
67
            coast.getOnCoast(cC);
68
        }
69
        else{
70
            CoastController coast = cC.getCoastController();
71
            if(boat.getEmptyIndex () == -1 || coast.getDirection() != boat.getDirection())
72
                return;
73
            coast.getOffCoast(cC.getName());
74
            cC.moveTo(boat.getEmptyPosition());
75
            cC.getOnBoat(boat);
76
            boat.getOnBoat(cC);
77
        }
78

79
        userGUI.status = checkGameOver();
80
    }
81

82
    /// -1->lose 0->unfinish 1->win
83
    int checkGameOver(){
84
        int startPriest = 0;
85
        int endPriest = 0;
86
        int startDevil = 0;
87
        int endDevil = 0;
88

89
        int[] startCount = startCoast.getNum();
90
        startPriest += startCount[0];
91
        startDevil += startCount[1];
92

93
        int[] endCount = endCoast.getNum();
94
        endPriest += endCount[0];
95
        endDevil += endCount[1];
96

97
        if(endDevil+endPriest ==6)
98
            return 1;
99

100
        int[] boatCount = boat.getNum();
101
        if(boat.getDirection() == "End"){
102
            endPriest += boatCount[0];
103
            endDevil += boatCount[1];
104
        }
105
        else{
106
            startPriest += boatCount[0];
107
            startDevil += boatCount[1];
108
        }
109

110
        if(startPriest<startDevil && startPriest>0)
111
            return -1;
112
        if(endPriest<endDevil && endPriest>0)
113
            return -1;
114

115
        return 0;
116

117

118
    }
119

120
    public void Restart(){
121
        boat.reset();
122
        startCoast.reset();
123
        endCoast.reset();
124
        for(int i=0;i<characters.Length;i++)
125
            characters[i].reset();
126
    }
127
}

展开收起

Click#

点击脚本，检测船和角色是否被点击，从而进行移动的操作。其中，角色和船必须含有碰撞体的组件，不然无法监听对象是否被点击。

1
public class Click : MonoBehaviour
2
{
3
    IUserAction userAction;
4
    myCharacterController characterController;
5

6
    public void setController(myCharacterController cC){
7
        characterController = cC;
8
    }
9

10
    void Start(){
11
        userAction = Director.getInstance().currentSceneController as IUserAction;
12
    }
13

14
    void OnMouseDown(){
15
        if(gameObject.tag == "Boat")
16
            userAction.moveBoat();
17
        else if(gameObject.tag == "Priest" || gameObject.tag == "Devil")
18
            userAction.ClickCharacter(characterController);
19
        Debug.Log("Click");
20
    }
21
}

展开收起

myUserGUI#

游戏结束的界面设计。

1
public class myUserGUI : MonoBehaviour
2
{
3
    private IUserAction action;
4
    public int status = 0;
5
    GUIStyle style;
6
    GUIStyle buttonStyle;
7

8
    void Start(){
9
        action = Director.getInstance ().currentSceneController as IUserAction;
10

11
    style = new GUIStyle();
12
    style.fontSize = 40;
13
    style.alignment = TextAnchor.MiddleCenter;
14

15
    buttonStyle = new GUIStyle("button");
16
    buttonStyle.fontSize = 30;
17
    }
18

19
    void OnGUI() {
20
    if (status == -1) {
21
      GUI.Label(new Rect(Screen.width/2-50, Screen.height/2-85, 100, 50), "Gameover!", style);
22
      if (GUI.Button(new Rect(Screen.width/2-70, Screen.height/2, 140, 70), "Restart", buttonStyle)) {
23
        status = 0;
24
        action.Restart ();
25
      }
26
    }
27
        else if(status == 1) {
28
      GUI.Label(new Rect(Screen.width/2-50, Screen.height/2-85, 100, 50), "You win!", style);
29
      if (GUI.Button(new Rect(Screen.width/2-70, Screen.height/2, 140, 70), "Restart", buttonStyle)) {
30
        status = 0;
31
        action.Restart ();
32
      }
33
    }
34
  }
35
}

展开收起

实现效果#

PandD

有待改进#

没有添加角色行走的动画，及制作朝向
河水和船等动画也没有制作
没有加1min的倒计时
游戏失败没有等船到岸之后弹出来

HW2: 离散仿真引擎基础

Tue, 04 Oct 2022 00:00:00 GMT

作业简介： 1.简答题（涉及GameObject, Transform, Assets, Prefabs, Component, MonoBehaviour等） 2.编程实践（仅允许使用IMGUI构建UI，训练数据-控制分离的编程思维） 3.思考题（涉及游戏设计模式）

一、简答题#

解释游戏对象(GameObjects)和资源(Assets)的区别与联系

GameObjects：是 Unity 中的基础对象，表示角色、道具和景物。它们本身并没有取得多大作为，但它们充当组件(Component)的容器，而组件可实现功能。

我们可以看到GameObject列表下有各种属性的对象，包括空属性对象、3D对象、效果、灯光等

Assets：表示 Unity 项目中用来创建游戏或应用的任何项；也可以代表项目中的视觉或音频元素，例如 3D 模型、纹理、精灵、音效或音乐；还可以表示更抽象的项目，例如任何用途的颜色渐变、动画遮罩或任意文本或数字数据。

我们可以看到Assets创建下有很多类型的资源，如C#脚本，着色器，预制件等。

简单地理解，游戏对象是真正加入到游戏场景里的实体，类似一个空盒子，需要向里面添加各种组件来实功能。资源是创建或外导入的各种数据，可以应用到不同游戏对象身上，可以只是存储在项目里，不一定会使用到当前的游戏场景中。
下载几个游戏案列，分别总结资源、对象组织和结构（指资源的目录组织结构与游戏对象树的层次结构）

这里用作展示的是官方的游戏教程里的资源与对象的组织和结构。

我们可以看到资源一般是按用途来分的，不同的文件夹存放不同类别的资源，包括音频、角色、环境、脚本、预制件、场景等，这里还可以看到模型资源里的环境精灵是按颜色来分类的，脚本里面按使用场景分类。

游戏对象主要是根据功能不同分类的，可以看到第一个游戏对象树有UI画布、摄像机、角色、格子、敌人等分支，第二个游戏对象树则是利用空对象来写分割线区分结构。

养成合理分类资源与游戏对象的好习惯，能让我们更高效地制作游戏。
编写一个代码，使用 debug 语句来验证 MonoBehaviour 基本行为或事件触发的条件
- 基本行为包括 Awake() Start() Update() FixedUpdate() LateUpdate()
- 常用事件包括 OnGUI() OnDisable() OnEnable()
“MonoBehaviour 类是一个基类，所有 Unity 脚本都默认派生自该类。MonoBehaviour 类允许您启动、停止和管理协程。MonoBehaviour 类提供对大量事件消息的访问，允许您根据项目中当前发生的情况执行代码。”

MonoBehaviour 方法简介
- Awake：在加载脚本实例时调用，无论该脚本是否启用，初始化脚本时都会调用。其在 Start 前调用
- Start：在首次调用任何 Update 方法之前启用脚本时，在帧上调用
- Update：如果启用了 MonoBehaviour，则每帧调用 Update
- FixedUpdate：具有物理系统的频率；每个固定帧率帧调用该函数；在 FixedUpdate之后，进行Physics系统计算。帧率可以通过 Time.fixedDeltaTime 来访问。与Update相互独立。
- LateUpdate：如果启用了 Behaviour（指可启用或禁用的组件），则每帧在Update调用后调用 LateUpdate，对于安排脚本的执行顺序很有用。
- OnGUI：系统调用 OnGUI 来渲染和处理 GUI 事件，是唯一可以实现**“即时模式”GUI (IMGUI)**系统来渲染和处理 GUI 事件的函数。OnGUI 实现可以每帧调用多次（每个事件调用一次），若MonoBehaviour 的 enabled 属性设置为 false，则不会调用 OnGUI()。
- OnDisable：该函数在行为被禁用时调用。当对象销毁时也会调用该函数，它可用于任何清理代码。当编译完成后重新加载脚本时，将调用 OnDisable，并在加载脚本后调用 OnEnable。
- OnEnable：该函数在对象变为启用和激活状态时调用。
代码验证：
1 public class Hello : MonoBehaviour 2 { 3 void Awake() {Debug.Log("Awake");} 4 5 void Start() {Debug.Log("Start");} 6 7 void Update() {Debug.Log("Update");} 8 9 void FixedUpdate() {Debug.Log("Fixed");} 10 11 void OnGUI() {Debug.Log("OnGUI");} 12 13 void OnEnable() {Debug.Log("Enabled");} 14 15 void OnDisable() {Debug.Log("Disabled");} 16 }
展开收起
查找脚本手册，了解 GameObjects, Transform, Component 对象
- 分别翻译官方对三个对象的描述(Description)
- 描述下图中 table 对象(实体)的属性、table 的 Transform 的属性、table 的部件
- 用UML图描述三者的关系
官方描述
- GameObject 是 Unity 中的基础对象，表示角色、道具和景物，可以被用来表示所有可以存在于场景中的事物。它是Unity中场景的建筑块，可作为决定GameObject外观功能的功能组件的容器。在脚本中，GameObject类提供了一个可以在代码中使用的方法集合，包括查找、建立连接和在它们之间发送消息，以及添加或移除附加到 GameObject 的组件和设置它们在场景中与状态有关的值。
- Transform 用于存储游戏对象的位置、旋转、缩放和父子化状态。每个游戏对象始终附加一个变换组件，无法删除变换组件或创建没有变换组件的游戏对象。
- Component 是每个GameObject的功能部分，它包含一些可编辑的属性，可以通过编辑这些属性来定义GameObject的行为。
图

Table的GameObject属性包含Tag(标签)、Layer(层)、Static(是否静态)、勾选框(是否活动)、属性名； Table的Transform属性包含Position(坐标)、Rotation(旋转角)、Scale(大小)； Table的Component属性包括Cube(Mesh Filter)、Mesh Renderer、Box Collider、RIgidbody、Hello(Script)、Red(Material)。

UML图
资源预设(Prefabs)与对象克隆(clone)
- 预设(Prefabs)有什么好处?
  
  Unity 的Prenfabs系统允许创建、配置和存储游戏对象及其所有组件、属性值和子游戏对象作为可重用资源。预制件资源充当模板，在此模板的基础之上可以在场景中创建新的预制件实例。这可以避免重复制作的无用功，提高资源复用率，节省资源空间。
- 预设与对象克隆(clone or copy or Instantiate of Unity Object)关系?
  
  预设本身不需要有实例化的游戏对象，而克隆需要复制实例化的游戏对象。预设也更方便进行批量修改。
- 制作table预制，写一段代码将table预制资源实例化成游戏对象
```
1
public class hello:MonoBehaviour
2
{
3
  void Start()
4
  {
5
    GameObject table = (GameObject)Resources.Load("table");
6
    table = Instantiate(table);
7

8
    table.transform.parent = this.transform;
9
    table.transform.position = new Vector3(0,0,0);
10
  }
11
}
```

二、编程实践#

源码地址：https://github.com/Cauchyoooo/3DGameDesign/blob/main/hw2/MineGame.cs

这里是利用IMGUI做了一个扫雷小游戏。运行窗口大小为Full HD(1920x1080)

实现的效果如下图

数据定义部分代码：

1
 // Data
2
    private int[,] control_arr = new int[16,20]; //用于记录雷和数字 -1是雷 0是空 其他是周围的雷数
3
    private int[,] show_arr = new int[16,20]; //用于记录格子可见性 0是可见 1是不可见
4
    private int[,] mark_arr = new int[16,20]; //用于玩家标记雷 标记雷为1 此时按钮不可点击
5

6
    private int mine_num = 60; //用于记录剩余雷数
7
    private int wrong = 0; //用于记录标错的雷数
8
    private int time = 0; //用于记录用时
9
    private float tmptime = 0; //用于记录上一帧时间(不会重复初始化)
10
    private int state = 0; //0为挖矿模式，1为标记模式 输了为-1，赢了为-2
11

12
    // Controls Style
13
    GUIStyle smileStyle = new GUIStyle();
14
    GUIStyle mineStyle = new GUIStyle();
15
    GUIStyle[] numStyle = new GUIStyle[8]; //记录数字1-8的格式
16
    GUIStyle state0 = new GUIStyle();
17
    GUIStyle state1 = new GUIStyle();
18
    GUIStyle worl = new GUIStyle();
19
    GUIStyle txt = new GUIStyle();

展开收起

由于不是很想利用Texture2D导入图片素材，这里用的是IMGUI里简陋的GUIStyle()，配合可显示的Unicode符号食用。

数据初始启动部分代码：

1
void Start () {
2
        // 对图标格式的初始化
3
        smileStyle.fontSize=50;
4
        smileStyle.normal.textColor=Color.yellow;
5
        smileStyle.alignment=TextAnchor.MiddleCenter;
6

7
        mineStyle.fontSize=20;
8
        mineStyle.normal.textColor=Color.red;
9
        mineStyle.alignment=TextAnchor.MiddleCenter;
10

11
        state0.fontSize=20;
12
        state0.normal.textColor=Color.red;
13
        state0.alignment=TextAnchor.MiddleCenter;
14

15
        state1.fontSize=20;
16
        state1.normal.textColor=Color.black;
17
        state1.alignment=TextAnchor.MiddleCenter;
18

19
        worl.fontSize = 50;
20
        worl.normal.textColor = Color.red; //win=red / lose=blue
21
        worl.alignment=TextAnchor.MiddleCenter;
22

23
        txt.fontSize = 30;
24
        txt.normal.textColor=Color.white;
25
        txt.alignment=TextAnchor.MiddleCenter;
26

27
        for(int i=0;i<8;i++){
28
            numStyle[i] = new GUIStyle();
29
            numStyle[i].fontSize = 20;
30
            numStyle[i].alignment = TextAnchor.MiddleCenter;
31
        }
32
        numStyle[0].normal.textColor=Color.blue; //数字1红色
33
        numStyle[1].normal.textColor=Color.green; //数字2蓝色
34
        numStyle[2].normal.textColor=Color.red; //数字3蓝色
35
        numStyle[3].normal.textColor=new Color(1.00f,0.84f,0.00f,1.00f); //数字4蓝色
36
        numStyle[4].normal.textColor=new Color(0.63f,0.13f,0.94f,1.00f); //数字5紫色
37
        numStyle[5].normal.textColor=new Color(1.00f,0.38f,0.00f,1.00f); //数字6橙色
38
        numStyle[6].normal.textColor=new Color(1.00f,0.75f,0.80f,1.00f); //数字7粉色
39
        numStyle[7].normal.textColor=Color.black; //数字8黑色
40

41
        Init(); //游戏参数初始化
42
    }

展开收起

由于GUIStyle在游戏过程中，基本不会有何变化，就放在Start()函数调用初始化。

游戏参数初始化代码：

1
void Init() {
2
        // 时间，雷数等参数初始化
3
        time = 0;
4
        mine_num = 60;
5
        wrong = 0;
6
        state = 0;
7

8
        for(int i=0;i<16;i++){
9
            for(int j=0;j<20;j++){
10
                // 格子可见性初始化
11
                show_arr[i,j] = 0;
12
            }
13
        }
14

15
        // 雷区初始化
16
        clearMine();
17
        InitMine();
18
    }

展开收起

每局新游戏开始前的初始化函数，要把各种参数归零，并重新随机生成雷区。

雷区初始化代码：

1
void InitMine(){
2
        //初始化数字和雷区
3
        int num=0;
4
        while (num<60)
5
        {
6
            int x=Random.Range(0,16);
7
            int y=Random.Range(0,20);
8
            if(control_arr[x,y]==0){
9
                control_arr[x,y] = -1;
10
                num++;
11
            }
12
        }
13

14
        for(int i=0;i<16;i++){
15
            for(int j=0;j<20;j++){
16
                if(control_arr[i,j]>-1){
17
                    //左边
18
                    if(i>0 && control_arr[i-1,j]==-1)
19
                        control_arr[i,j]++;
20
                    //右边
21
                    if(i<15 && control_arr[i+1,j]==-1)
22
                        control_arr[i,j]++;
23
                    //上方
24
                    if(j>0 && control_arr[i,j-1]==-1)
25
                        control_arr[i,j]++;
26
                    //下方
27
                    if(j<19 && control_arr[i,j+1]==-1)
28
                        control_arr[i,j]++;
29
                    //左上角
30
                    if(i>0 && j>0 && control_arr[i-1,j-1]==-1)
31
                        control_arr[i,j]++;
32
                    //右下角
33
                    if(i<15 && j<19 && control_arr[i+1,j+1]==-1)
34
                        control_arr[i,j]++;
35
                    //右上角
36
                    if(i<15 && j>0 && control_arr[i+1,j-1]==-1)
37
                        control_arr[i,j]++;
38
                    //左下角
39
                    if(i>0 && j<19 && control_arr[i-1,j+1]==-1)
40
                        control_arr[i,j]++;
41
                }
42
            }
43
        }
44
    }
45

46
    void clearMine(){
47
        for(int i=0;i<16;i++){
48
            for(int j=0;j<20;j++){
49
                control_arr[i,j]=0;
50
                mark_arr[i,j]=0;
51
            }
52
        }
53
    }

展开收起

clearMine()函数会把上一局的标记去除，雷全部清除，且格子值全部设为0，配合生成雷的函数InitMine()，InitMine()初始化雷的位置(值为-1)后，会通过循环得出每个格子的数字（周围一圈的雷数）。

OnGUI()循环代码：

1
void OnGUI() {
2
        GUI.Box(new Rect(720,180,480,720),"");
3
            // 生成smile按钮 for restart
4
            if(GUI.Button(new Rect(935,220,50,50), "☺",smileStyle)){
5
                Debug.Log("Push Smile");
6
                if(state>=0)
7
                    Init();
8
            }
9
            // 生成挖雷按钮
10
            if(GUI.Button(new Rect(1000,200,50,50), "挖",state0)){
11
                state = 0;
12
                state0.normal.textColor=Color.red;
13
                state1.normal.textColor=Color.black;
14

15
            }
16

17
            // 生成标记按钮
18
            if(GUI.Button(new Rect(1000,240,50,50), "标",state1)){
19
                state = 1;
20
                state0.normal.textColor=Color.black;
21
                state1.normal.textColor=Color.red;
22

23
            }
24
            //显示剩余雷数
25
            GUI.Button(new Rect(736,220,160,60), "剩余雷数:"+mine_num.ToString());
26

27
            //显示时间
28
            GUI.Button(new Rect(1050,220,130,60), "用时(s):"+time.ToString());
29

30
            // 每个大小28*28
31
            // 生成可点击扫雷按钮
32
            for(int i=0;i<16;i++){
33
                for(int j=0;j<20;j++){
34
                    if(show_arr[i,j]==1)    continue;
35
                    // 标记的格子可取消标记
36
                    if(mark_arr[i,j]==1){
37
                        if(GUI.Button(new Rect(736+i*28,300+j*28,28,28),"✯")){
38
                            if(state == 1){
39
                                mark_arr[i,j] = 0;
40
                                mine_num++;
41
                                if (control_arr[i,j]<0)
42
                                    wrong--;
43
                            }
44
                        }
45
                        continue;
46
                    }
47

48
                    if(GUI.Button(new Rect(736+i*28,300+j*28,28,28),"")){
49
                        // 按下按钮的行为
50
                        if(state == 1){
51
                            mark_arr[i,j] = 1;
52
                            mine_num--;
53
                            if (control_arr[i,j]>-1)
54
                                wrong++;
55
                            if (mine_num==0)
56
                            {
57
                                if(wrong>0){
58
                                    showAllMine();
59
                                    state = -1; //lose
60
                                }
61
                                else{
62
                                    state = -2; //win
63
                                }
64

65
                            }
66
                        }
67
                        else{
68
                            if(mark_arr[i,j]==0){
69
                                show_arr[i,j]=1;
70
                                if(control_arr[i,j]==0)
71
                                    showEmpty(i,j);
72
                                if(control_arr[i,j]<0){
73
                                    showAllMine();
74
                                    state = -1; //lose
75
                                }
76
                            }
77
                        }
78
                    }
79
                }
80
            }
81
            // 显示数字和雷
82
            for(int i=0;i<16;i++){
83
                for(int j=0;j<20;j++){
84
                    if(show_arr[i,j]==0)    continue; //
85
                    int ctlnum = control_arr[i,j];
86
                    if(ctlnum==0){
87
                        GUI.Label(new Rect(736+i*28,300+j*28,28,28)," ");
88
                    }
89
                    else if(ctlnum>0){
90
                        GUI.Label(new Rect(736+i*28,300+j*28,28,28),ctlnum.ToString(),numStyle[ctlnum-1]);
91
                    }
92
                    else{
93
                        GUI.Label(new Rect(736+i*28,300+j*28,28,28),"✵",mineStyle);
94
                    }
95
                }
96
            }
97

98
        if(state<0){
99
            GUI.Box(new Rect(810,420,300,240),"");
100
            if(GUI.Button(new Rect(910,630,100,20), "Restart"))
101
                Init();
102
            if(state == -1){
103
                worl.normal.textColor =  Color.blue;
104
                GUI.Label(new Rect(910,440,100,50), "LOSE", worl);
105
            }
106
            else{
107
                worl.normal.textColor =  Color.red;
108
                GUI.Label(new Rect(910,440,100,50), "WIN", worl);
109
            }
110
            int endnum = 60 - mine_num - wrong;
111
            GUI.Label(new Rect(910,510,100,50), "扫雷数："+endnum.ToString(), txt);
112
            GUI.Label(new Rect(910,560,100,50), "总用时："+time.ToString(), txt);
113

114
            tmptime = Mathf.Floor(Time.fixedTime);
115
        }
116
        else{
117
            //计时
118
            if(Mathf.Floor(Time.fixedTime)-tmptime==1){
119
                tmptime = Mathf.Floor(Time.fixedTime);
120
                time++;
121
            }
122
        }
123

124
    }

展开收起

由于IMGUI的控件部分只能在OnGUI()函数使用，因此这里会写的比较冗杂，嵌套也比较多。这里利用Time类来辅助我们计时。

其他相关代码：

1
void showAllMine(){
2
        for(int i=0;i<16;i++){
3
            for(int j=0;j<20;j++){
4
                if(control_arr[i,j]==-1){
5
                    show_arr[i,j]=1;
6
                }
7
            }
8
        }
9
    }
10

11
    // 递归显示无雷区域
12
    void showEmpty(int i,int j){
13
        // 遇到被标记的非雷 直接翻开
14
        if(mark_arr[i,j]==1){
15
            mark_arr[i,j]=0;
16
            mine_num++;
17
        }
18
        show_arr[i,j]=1;
19
        if(control_arr[i,j]>0)
20
            return;
21

22
        if(i>0 && show_arr[i-1,j]==0)
23
            showEmpty(i-1,j);
24
        if(i<15 && show_arr[i+1,j]==0)
25
            showEmpty(i+1,j);
26
        if(j>0 && show_arr[i,j-1]==0)
27
            showEmpty(i,j-1);
28
        if(j<19 && show_arr[i,j+1]==0)
29
            showEmpty(i,j+1);
30
        if(i>0 && j>0 && show_arr[i-1,j-1]==0)
31
            showEmpty(i-1,j-1);
32
        if(i<15 && j<19 && show_arr[i+1,j+1]==0)
33
            showEmpty(i+1,j+1);
34
        if(i<15 && j>0 && show_arr[i+1,j-1]==0)
35
            showEmpty(i+1,j-1);
36
        if(i>0 && j<19 && show_arr[i-1,j+1]==0)
37
            showEmpty(i-1,j+1);
38

39
    }

展开收起

showAllMine()函数是使用在踩雷情况，把剩下的雷也显示出来；showEmpty()函数是在扫雷过程中，如果遇到一个连续空白无雷区，会把没有数字(周围一圈没有雷)的区域及围绕它们的数字显示出来。

小结

在写控件Style的时候，感觉这也不太好设置，那也不太好设置，默认的Style风格又不太适用，整体看起来勉强过得去，有的按钮周围没有边框(比如“标”和“挖”)，就是皮肤设置的问题，做不出想要的风格，多少有点痛苦。可能还是乖乖导入Texture2D会更美观一些，但也要耗费时间去找合适的素材。
制作计时器的时候，因为OnGUI()调用频率，以及Time可以获取从游戏启动的时间，就想到了这个先floor()，再比较有无变化的这个方法计时。其他的一些协程或是延时调用的方法看起来都比较复杂，不太好实现。
关于利用Button按钮控件的“标”和“挖”来实现标雷和挖格子。似乎是在IMGUI中没能找到控件比较广泛的按键功能，只能监听到按钮被点击，无法监听是被左键或是右键点击又或是按键按下或松开这种，因此实现起来有点怪怪的并且有些麻烦。
利用自定义状态值state来表示不同的游戏状态，能帮助更好地实现这个游戏功能。

三、思考题#

微软XNA引擎的Game对象屏蔽了游戏循环的细节，并使用一组虚方法让继承者完成它们，我们称这种设计为“模板方法模式”。
- 为什么是“模板方法”模式而不是“策略模式”呢？
  
  **模板方法模式：**一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。
  
  **策略模式：**是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。
  
  — 微软XNA引擎的Game对象屏蔽了游戏循环的细节，用虚方法让继承者完成它们，更强调继承重写，明显更符合模板方法模式。

将优先对象组成树形结构，每个节点都是游戏对象（或数）。

尝试解释组合模式(Composite Pattern /一种设计模式)。

将对象组合成树形结构以表示”部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

使用 BroadcastMessage() 方法，向子对象发送消息。写出 BroadcastMessage() 的伪代码。

1
public class BcM : MonoBehaviour
2
{
3
  public GameObject pobject;
4
  void Update () {
5
    pobject.BroadcastMessage("dbug","inputstr",SendMessageOptions.RequireReceiver);
6
  }
7
}
8

9
public class c1 : MonoBehaviour
10
{
11
    void dbug(){
12
        Debug.Log("c1");
13
    }
14
}
15

16
public class c2 : MonoBehaviour
17
{
18
    void dbug(string str){
19
        Debug.Log("c2:"+str);
20
    }
21
}

展开收起

一个游戏对象用于许多部件描述不同方面的特征。我们设计坦克游戏对象不是继承于 GameObject 对象，而是 GameObject 添加一组行为部件(Component)。
- 这是什么设计模式？
  
  装饰器模式?
- 为什么不用继承设计特殊的游戏对象？
  
  由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。使用继承的话，扩展不够灵活。

参考资料：策略模式，模板模式，组合模式，装饰器模式，桥接模式，u3d计时器，IMGUI

HW1: 游戏的本质

Tue, 06 Sep 2022 00:00:00 GMT

“功能游戏/严肃游戏”是什么？#

“Serious games induce some kind of affective or motor learning (understood in very broad sense) at any level. Put more simply: serious games are used for more than entertainment.” (Susi et al. 2007, Breuer & Bente, 2010).

从严肃游戏较早的提出看，严肃游戏不仅仅用于娱乐，或者说主要不是为了娱乐。用一个词语来比喻就是“寓教于乐”，但包含的领域不只是教育，还可能包含运动、商业、安全、军事、模拟等。但细想来看，那么非严肃游戏是不是就是纯娱乐性质的游戏呢？从小到大，我玩过许多游戏，感觉很多游戏都不是纯娱乐，比如经典的益智游戏《扫雷》，可以有助于我们锻炼思维与反应能力，那它们又是不是都是严肃游戏呢？“严肃”一词显然不是那么好理解，而“功能游戏”是我国引入“严肃游戏”时的别称，是为了让人们更好地理解这个概念。我个人的理解是，这个功能游戏在设计之初就已经带有某种功能目的，而它的载体就是游戏，是同时具有娱乐性的。而注重功能性且能平衡好娱乐性的游戏，我觉得应该就能称得上是好的功能游戏。

参考文章：EduTech Wiki；Wikipedia；知乎文章(带有个人主观性)

分享游戏：《みんなで空気読み》#

🍵 我个人比较喜欢的一款严肃游戏是日本游戏公司G-MODE制作的《みんなで空気読み》（又名《阅读空气》或《大家一起察言观色》），PC版于2020年在steam平台上线。目前该系列有3部，还有一部online版本可以和其他玩家在线游玩。实际上，早在2013年左右，我就已经在塞班系统上玩过这款游戏，它当时就给我留下了深刻印象。当然，那个时候我还在念小学，玩不太明白。

🍪 “空気読み”直译过来是“读空气”，也是网络词汇“KY”(不会读空气)的由来。这个意思跟我们中文的“察言观色”或者“有眼力见儿”差不多。玩家在普通的“察言观色”模式需要做的是根据氛围，快速地判断需要作出反应。操作很简单，通过键盘上的上下左右与空格键控制即可，由于什么时候用什么按键游戏没有说明，要自己去思考探索。

🍮 玩法这么普通，横跨这么多年又上线不同平台，有它的道理。我认为这款游戏的创新点在于其功能性，而其功能性又在于教育，玩家通过游玩这款游戏可以注意到一些生活小细节，了解到一些日本的文化等。比如说，在日本，地铁的站位和地区有关，东京地区习惯“左站右行”，而大阪地区习惯“左行右站”；你要和一位牛头朋友(代表忌口)去吃饭，有烧肉和寿司两个选项，就需要避开含牛量较高的烧肉了；当你作为一名老师上公开课问问题时，台下几位同学都举手了，但只有一位同学看起来很高兴，就需要思考点他了… 每玩完5个场景，会给你一个反馈，例如5个都做对了(官方做法)，会告诉你“简单明了地做到了察言观色”；玩完所有场景后，会给你一个六边形结果反馈，包含决心、同情心、适应能力、责任感、敏捷思维及运用能力6个方面。

🧊 这看起来像心理测试的游戏，有功能性的同时，当然也不失趣味性。尽管操作很简单，但是每个场景可以作出的反应是多样性的，有些甚至都不太能想到，当你做出来的时候，会get到这种幽默感。比如说，你在一个电视节目要举一个牌子，左方会有一个标题，右边有个人，正常想法是可以举左边、右边或者上面，一些神奇的操作就是不断切换左上右按键，你就会把这个牌子转起来。除了普通测试的“察言观色”模式，有可以让你无限装疯卖傻、随心所欲各种捣蛋的“不察言观色”模式，有可以和朋友本地快(ben)乐(bi)玩(hu)耍(ou)的“双人察言观色”模式，可以浏览所有场景的“剧情模式”，还有满足收集癖的成就系统“秘密”，以及看到自己在“察言观色”模式的过往表现的“以前的你”。

🍜 我一个比较深刻的感受是，可以帮助玩家更好地认识自我和理解社会的氛围。尽管各种场景都更贴近日本文化，由于一些礼仪的共通性，我们还是能很好地体会。在做出各种行为的时候，可能这个举动是可以帮助到他人的，但是自己会不会不开心；“不麻烦他人”又是不是一直都是好的；又应该选择做一个怎样的人等等。通过对比不同时期(一般是隔半年以上)的反馈结果，也能看到自己的一些变化，更好地去认识自己与了解自己。还有一点是，这款严肃游戏很好地结合教育、心理、文化等方面，对于我们东方注重礼仪的社会，是非常有价值的。