步骤

1. 获得UE在Github上源代码的访问权，需要把自己的Github账号与UE账号绑定。

2. 下载虚幻引擎源代码，下载后先解压，做到第2步，先不要设置其他。

3. Chaos破坏系统概述，根据这个文档修改 UE4Editor.Target.cs ，添加需要的行。

   这里我按照官网的设置后边都会有运行error打不开引擎，下面这行最后的词我依然保持Shared才能用 “BuildEnvironment = TargetBuildEnvironment.Shared;” 。这个问题好像有点玄学，这个论坛帖子报告了两种设置各有成功和失败的情况，所以都尝试了一下。

4. 根据上面文档继续编译引擎，运行 Setup.bat 和 GenerateProjectFiles.bat 。

5. 打开生成的ue4.sln，设置 Development Editor ，然后Build。这样编译后的文件需要从VS里按F5运行UE的Editor，也可以找到Debug文件夹直接打开UEEditor.exe，但是不能脱离VS项目运行，那样应该需要编译release版本，尝试了一下没有成功，本文最后有一些记录。

6. 运行后，新建并打开项目，设置Chaos插件，也就是文档里的第7步。重启编辑器，就可以找到Chaos面板了。

顺便一提，大部分UE的中文文档，只需要把对应英文文档链接里的en-US改成zh-CN就好啦～

关于打包release版本的引擎，过程中搜到一个小工具叫PyUE4Builder，也是个好评如潮的工具，然而当时这个小工具只支持到4.24，想打包4.25的但是改了一些设置都失败了。还有一个是UE4-Binary-Builder，看样子这个更新比较勤快，需要的小伙伴可以参考最新的文档试试。

The basic idea is that there are many version of our world we live and they are always there, all we need is just a portal to enter it, and regardless of what AR device we are using. So these AR worlds are consistent, and have location based contents to either provide useful information, or help entertain the users.

The development of this demo consists of the following sections:

Cyberpunk Postprocess

Postprocess in Unreal is a way of image processing, the difference is the process is more suitable for dealing with real-time rendering output of 3D geometry, with the depth buffer of the 3D scene.
Here since I have a portal, the postprocess effect sometimes need to be applied partially on the screen (refer to portal section in the following, ensure the effects are the same). So I did all the post process in the post process material, directly apply to the CameraImage texture. The processes are:

1. Apply color grading lookup table got from photoshop. Applying color grading in Photoshop is easy and strong, but Unreal does not provide much image processing functions built-in in shaders, so Color Lookup Table (LUT) is a very convenient way to applying pre-defined color grading in Unreal materials.
2. Get the bright areas and blur them, to create the feeling of neon lights.
3. Add very thin moving fog texture.
4. Add LOMO style darker edge and corner to the screen output.
   

Portal Effect and Function

The portal function demoed here used Scene Color behind translucent for cyberpunk image color grading, and Scene Capture function for capturing the holo cat, grids and planes, then add them together.
The visual effect for portal is a combination of circling particles, ribbon particle trails, and event triggered particle sparks.

Hologram Cat

The cat is from my personal asset library collected. The cat was well rigged and animated, with all animations in one take. What I did for the animation this time is separating and importing the animations, creating the animation state machine and blueprint, and add character blueprint for it with simple logic and triggers.
The shader of the holo cat is done from scratch. It consists of the following parts:

1. Screen aligned dots showing it’s a virtual animal projected by high tech;
2. Semi-random glitches make it more a cyber buggy feeling.

The tutorial of this glitching hologram cat is available in this post.

Other Hologram Effects

Grid, holo arrow on the road, and cat adoption advertisement panels, are all simple dynamic material effects to add a bit feeling to the cyberpunk world for this demo.

预览：

视频来自B站，Youtube请戳 https://youtu.be/g0UudcrQWCc

不稳定的全息模型材质全图，点击查看大图：

预览：

视频来自B站，Youtube请戳 https://youtu.be/lytFmqqbp9k

跳动线条材质全图，点击查看大图：

预览：

视频来自B站，Youtube请戳 https://youtu.be/_nkGncZxtww

冰材质全图，点击查看大图：

星空水晶材质全图，点击查看大图：

预览：

视频来自B站，Youtube请戳 https://youtu.be/K0qudPjWKLI

材质全图，点击查看大图：

要求是做个泡泡材质，能够表现泡泡厚度，并且有上下高光，如图：

这么鲜艳的色彩、一致的pattern，应该是p的图，不过看着确实挺好看挺合理的。。

• 边缘厚度，使用fresnel进行一定计算生成。
• 上下的高光，我认为光源在上方，上方的高光是光源照射上方内表面的反光，下方的光则是下方泡泡内表面的反光。Shader里使用向量LightDir表示虚拟光源，水平向下flip表示下方的虚拟光源，计算反光。
• 使用cubemap表示环境反光。
• 使用一张水波normal图，在世界坐标下计算模型vertices的位移，使泡泡变形。

使用UE 4.22 Preview7：

Welcome any thoughts :D

开发技术系列

1. Epic Unreal https://www.unrealengine.com/en-US/blog/epic-games-launches-epic-megagrants-new-unreal-engine-technology-and-epic-online-services-at-gdc-2019

   • UE 4.22已经支持Nvidia RTX开发。

   • 实时渲染堪比影视了解一下，运用了RTX https://youtu.be/Qjt_MqEOcGM

   • Epic Games store https://www.epicgames.com/ 也不是新闻了

   • 炫耀大规模物理模拟的一个Demo https://youtu.be/fnuWG2I2QCY ，该系统将在4.23发布测试版。

   • 上面这个视频现场使用6个还是8个屏幕拼接而成的大屏游戏体验，然而问了几个员工好像并不知道是不是用的新的nDisplay。。。

2. Unity https://blogs.unity3d.com/2019/03/19/the-heretic-megacity-release-real-time-ray-tracing-and-more-news-from-gdc-2019/

   • RTX, shader graph, new VFX system, …

3. Google Stadia https://store.google.com/magazine/stadia

   • 云游戏，不需要再专门去买PS4等主机，即可玩主机大作

   • YouTube互动接口

   • Style Transfer，利用机器学习，将一张图片的风格实时应用到游戏中。

   • Google的展台有AR的吃豆人，一种是基于现实地图将道路作为吃豆人的路径，另一种是4个人在一个方形区域内将手机作为吃豆人角色吃空中的豆子躲空中的怪。

   • 
   • 还有AR密室逃脱，使用的是手机，传递信息，然后屋内特定物品的图案在手机中会显示不同的结果。
   • 记得还有一个大型多人破坏游戏。。。建造很像是玩家一号，然而目前只有一种玩法就是破坏。。能实时看到别人的破坏。没找到照片记录O.O

4. Microsoft Game Stack https://developer.microsoft.com/en-us/games，80%的展台都是关于Data&AI，并看不懂。。有一个讲Graphics的，貌似是对游戏针对相应显卡进行加速优化。

5. Intel Odyssey https://gameplay.intel.com/?odyssey=True

   • 未来图形与视觉计算。英特尔好像将要发布自家的独显了。

6. Simplygon https://www.simplygon.com/

   • LOD生成与减面神器，现场演示把几十万面的模型树生成卡片树，只有千面
   • 今儿跟美术小伙伴试了一下，对于物体的剪影保持还是很不错的

7. InstaLOD https://instalod.com/

   • 各种场景模型游戏流程优化工具

8. Substance Alchemist https://www.allegorithmic.com/products/substance-alchemist

   • 比Substance Designer更简单，还能直接根据照片生成相应贴图。

9. 亚马逊的Lumberyard https://aws.amazon.com/lumberyard/downloads/

   • 今年感觉带来了惊喜，三年下来从当初连做个prototype都被嫌弃的引擎，到现在看上去功能方便了不少，感叹亚马逊的耐心。三年来一直无法跟主流引擎相提并论，硬是靠亚马逊的强大的宣传和坚持不懈追赶上来。不过还没有实际用过，不敢说真的追赶上来了。。
   • 很早该引擎就有跟Twitch的结合，直播观看者可以投票为直播玩家做出游戏内选择。
   • 种菜系统留下了深刻印象。。

输入系列

1. Ultrahaptics https://www.ultrahaptics.com/

   • 传感器追踪手的gesture，利用超声波在空气中形成触摸到物体的一种技术。

   • 有unity的plugin，做了UE的intergration但没有完整plugin。

   • 他们的体验是将VR游戏相结合，有两种，一种是就人站在机器前不动的故事体验，所有互动都在一个机器上进行；一种是叫cave，在里面定点布置一些产品，然后在VR里玩家可以走到不同位置体验水流、火烧、火魔法球等。
   • 触摸感很像电流扰动，因此体验内容也偏向于魔法球、水流、火焰的感受。有一幕将手穿越魔法门的感觉也特别好。
   • 离形成smooth surface的触摸感还有一段距离。

2. Pico Zense https://www.pico-interactive.com/zense

   • TOF深度相机，有各种大小模块可集成，最远检测距离10米
   • Pico air light 互动投影，可以与特定实物互动，也可以作为屏幕投影所有安卓app。

3. Vuelosophy http://vuelosophy.io/

   • 较小巧的眼动追踪，便携版本据说比Tobii Eye便宜很多。

4. Microsoft Xbox Adaptive Controller https://www.xbox.com/en-US/xbox-one/accessories/controllers/xbox-adaptive-controller

   • 最上面有一排接口，可以把市面上常用的手柄插在对应的位置，这个Adaptive手柄就会自动帮忙map相应的手柄键。这两个大大的圆可以map到A/B, X/Y, …

5. Tap https://www.tapwithus.com/

   • 一款戴在手上的键盘，通过敲击不同的手指或手指组合，输入对应的字母，也可以自定义输入键。
   • 不禁想起了几年前的Myo臂环，穿在胳膊上利用肌肉运动识别手势的，然而去搜了一下发现18年10月起该公司就停止生产和销售Myo了，略有可惜，期待他们的新产品。

6. Sensoryx VR手套 http://www.sensoryx.com/

   • 仅需在头显前加一个传感器，带上特制手套，就能在VR游戏中识别双手。

7. VICON 动作捕捉 https://www.vicon.com/products/camera-systems/vantage

   • 动捕软件 https://www.vicon.com/products/software/shogun

   • 可实时捕捉到游戏中，立即作出评分反馈等

8. Optitrack https://optitrack.com/

   • 老牌动捕系统

9. 还有Xsens，骑自行车的VR等

其他

1. Magic Leap https://www.magicleap.com/

   • 在Unity与UE区域分别有两个体验区，一开馆就得去排队。。排了UE区的体验。体验内容是跟一个虚拟妹子一起做贴画。
   • 
   • 感觉很适合虚拟管家或虚拟女友，人物距离感挺不错。
   • 就是视野感觉小，出了眼前的方形显示屏就没有画面的，虚拟人或物必须在正前方才容易看见。
   • 略微有彩虹纹，貌似是浮雕光栅成像原理的因素。

2. bHaptics https://www.bhaptics.com/

   • Tactsuit体感衣，在VR FPS中如果身上部位被击中，该部位会产生震动。
   • 跟小伙伴稍微yy了一下，未来这些sensor应该会更加精细与密集，并且能够制造一定压力，才能做出玩家一号那种体感衣吧。
   • 做出来以后，应用最广的应该不是游戏业。。。

3. Genvid, Interactive Streaming Engine https://www.genvidtech.com/

   • 互动直播观战引擎，在游戏开发时添加相应SDK，比如添加过个观战摄像机，在直播间的观众们就可以选择想要观看的摄像机。也能尝试点击游戏中的各种信息，实时查看游戏数据。
   • 目前支持引擎Unity和Unreal，直播平台Twitch和YouTube。
   • 记得英雄联盟S8的直播就启用了互动观赛系统，应该是一类的。

4. imvu https://secure.imvu.com/welcome/ftux/

   • 看上去像一个类似第二人生的在线多人虚拟社区？玩家可以自己上传角色模型、衣物模型贴图、场景等，然后标价卖给别的玩家，并且货币可以与真是货币兑换。

   • 貌似有手机app。那么渲染质量就十分有限了，看宣传上觉得不如第二人生。不过很高兴看到类似社区正在涌现。

   • 小伙伴推荐了一个叫Zepeto的app，同样的手机在线虚拟社区。
   • 那么趁机安利一下Sansar，多人VR在线虚拟社区 https://www.sansar.com/

5. Pico VR https://www.pico-interactive.com/g2-4k

   • 4K的便携式VR头显。在5G来临的时代，我觉得会是一个VR设备和体验的大爆发，尤其是便携VR将会疯狂涌现，相应的应用也会得到大幅发展。

6. 3D Avatar SDK from a single selfie https://avatarsdk.com/

   • 从一张照片建立3D人物模型，还能自动补偿后背的发型。

7. Deep Motion Neuron https://deepmotion.com/neuron

   • 自动化动画生成工具，将实时视频转换为模型动画的工具。免费试用30天：GDC19

8. 小小牛 WanderPainter https://wonderpainter.net/

   • 可以将画的任何封闭图形进行二维rig，并添加基础动画走、跑、跳等，可以快速将自制角色应用于游戏中。

9. Kronos Workstation Ciara https://ciaratech.com/products/workstations/

   • 贼贵的电脑。。但网页打不开
   • 

这篇之前时间的post都是搬运之前的博客，保留了时间戳。虽然看着当时做的东西很挫。。。不过也是成长的见证吧！留下了！～

(Adding ‘not real Sun’ is to prevent if any misusage in science related things)

No particles used.

There are two separated Meshes: the sun sphere and a plane. No vertex animation. The quad plane performs the atmosphere. It splits the Sun from the center and is set to billboard inside the material. Below is the material snapshots for reference.

The Sun sphere:

Three Noise nodes are used to make the basic bright area, black dots, and upper bright gas. Noise are based on local position and time to get some change overtime. To make it less consume I’m considering using noise maps instead of Noise node, but currently wondering how to deal with the uv arrangement of sphere to make the noise textures looks seamless when changing.

The Plane:

It is a simple solution that I rotated one texture by two different directions and speeds, and used sine function for different changing opacities.

Sometimes you can see very bright storm appear – this is controlled by a blueprint to randomly place a small storm mesh at the surface of the sun sphere, in order to make a bright storm and looks 3D.

Welcome any thoughts :D

Do you know what day was it?

It’s March 20, 2015. A solar eclipse happened on that day, and astronaut Samantha Cristoforetti on the International Space Station took the following picture. So that’s why I put ISS there in the video. Did you see the black shadow dot on earth by the moon?

Also that day was the Spring Equinox, the stars’ position is also according to the date.

Git repo

This is an in-class solo project in Shader Development class, using OpenGL.

Basic structure:

• Mainer.cpp

• VertexShaderTest.glsl

• VertexShaderCodeNoLight.glsl

• FragmentShaderTest.glsl

• FragmentShaderCodeNoLight.glsl

• Camera.h

• Camera.cpp

• Primitives

  • ShapeData.h

  • ShapeGenerator.h

  • ShapeGenerator.cpp

  • Vertex.h

  • TeapotData.h

• Renderer

  • BufferInfo.h
  • Geometry.h
  • Geometry.cpp
  • MeRenderer.h
  • MeRenderer.cpp
  • Renderable.h
  • Renderable.cpp
  • ShaderProgramInfo.h

Platform: PC

Engine (given): Unreal

Theme: Iteration on Brute Force

Audience: Gamers 20-40

My contribution to the project

In this project I perdormed as a Technical Artist. At first I was the only artist, and my team decided to use the minimal art style so that I can work more on tech-art things. After the personnel change we got another artist Cody, so after that I mainly focus on the effects inside the game. Specific works I have done are showed as follow:

• Growing effects and particle effects inside the game
• Map build
• UI assets
• HowToPlay video (together with Ray)
• Help publish the game

Different things to do next time

This time I really worked as a tech artist. I’m not very good at art work compare to other artists, but this time I found out what role is the most suitable for me. I forcused on the effects of arts, use program methods to make it better. These are still basic tech-art things, but they really enlightened me. So next time I should try more tech-art things to help the artists work better. I am really happy when doing my work.

Things I learned from participating in this process

Positive lessons:

The first thing is of course my attribution of Tech-Artist. I can apply the knowledge I got from my tech-art class to our game, and try to figure out how a tech-artist can do in a real game project. I didn’t need to do the art things I’m not familiar with, but help to make the art work better. That’s the best thing.

Second is the great communication between team members. This time our team got a good communication with each other. We had clear feature lists, and clear assignments for each member. Due to the great efficiency, we had playable version in every sprint, and discussed together what we could do better in the next version. That a very awesome experience.

Third is that our game got good number of downloads. Though not the most among all the groups, this still gave us confidence. Some downloaders also gave us feedbacks on the gameplay and art styles. Then we found that our game still need many improvement. So it is very important to test our game by normal players so that we can found some problems that we take for granted.

Negative lessons:

First is that we lose a team member. This is a terrible feeling that we lost one of our main programmers. In real world we may not be such lucky to find another great programmer. It’s really bad feeling.

Second is that, as a technical artist, I still failed to implement the skeleton animation from Maya to Unreal. Finally due to time limitation, we decide to not use it.

Third is that we seemed to have some AI misunderstanding during our development. This is maybe because of our language expression. But finally we all got them done.

Scene preview:

User interface:

See how it works on Youtube:

Python scripts sample:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495

"""
SnowWorld.py

Using particles to generate a beautiful snowy scene.

__author__ = "Vega Bai"
__copyright__ = "Copyright 2015, Vega Bai"
__version__ = "1.0.5"
__maintainer__ = "Vega Bai"
__email__ = "vegabeyond@gmail.com"
__status__ = "Updating"

logs: 
    v1.0.5: 12-19-2015, add error captions
    v1.0.4: 12-19-2015, add collisions; delete animation length option
    v1.0.3: 12-16-2015, add particle render type - cloud
    v1.0.2: 12-9-2015, add texture sequence
    v1.0.1: 12-2-2015, add log function
    
instructions:
    1. click on the plane
    2. click 'Select Start Plane' button
    3. if you want to use a specific image as snowflake texture, browse and select the image, then turn on the 'Use file as texture' checkbox. if you don't turn on the checkbox, the particle will be rendered as white cloud type
    4. if you want to use more than one image to texture different particles, then turn on the 'Use file Sequence' checkbox. then the file browsered just now will be set as the start of the file sequence. make sure to name the textures in 'image.n' format. for example, 'snow.1'
    5. set values of 'Average Size', 'Density', 'MaxHeight'
    6. set values of 'Direction Vector'
    7. if you want to make collisions between other objects and the particles, select those objects and then click 'Select Object Collide With' button, and turn on 'Make Collision' checkbox 
    8. click 'Run' to start generating the snowy scene

"""

import pymel.core as pm
import random
import logging
import os

FILE_PATH_OV = 'filePathOv'  # save the file path
snowPath = ''

# setup a logger
logger = logging.getLogger(__name__)
hdlr = logging.handlers.RotatingFileHandler('SnowWorldLog.txt', maxBytes = 100000)
hdlr.setLevel(logging.DEBUG)
format = ('%(asctime)s, module=%(module)s, message=%(message)s')
formatter = logging.Formatter(format)
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)


def run(sliderSize, sliderDensity, sliderHeight, textSequence, ckboxTexture, ckboxSequence, ckboxCover, directionX, directionY, directionZ, snowPieceBrowser):
    '''
    This function is the main function to generate the snowy scene.
    
    Args:
        avgSize from sliderSize: The average size of all snow piece
        density from sliderDensity: The density of the snow
        maxDistance from sliderHeight: The highest distance the user want the snow to fall
        snowTexture from ckboxTexture: Whether using the texture for snowflakes
        snowSequence from textSequence: The length of the sequence of images as texture
        directionX: directionX of gravity field
        directionY: directionX of gravity field
        directionZ: directionX of gravity field
        
        coverFlag(coverObj) from ckboxCover: Decide whether the snow will cover the models and which models to cover
        windFlag(windDirection, windStrength): Decide whether there are winds and the directions and strength
        
    GLobal variables used:
        startArea: The surface area the user want the snow fall from
        snowPath: The file path of the snowflake texture
        coverObj: The objects the particles will make collision with
        
    Result: 
        a generated snowy scene animation
        
    Return: 
        none
    
    '''
    ## check whether the user has selected the start Area    
    if isset('startArea') == 0:        
        logger.error('Please choose a plane to start snow!')
        pm.PopupError('Please choose a plane to start snow!')
        return
    ## check whether the user has selected the objects to make collision with
    if ckboxCover.getValue():
        if isset('coverObj') == 0:
            logger.error('Please select the objects to make collision with!')
            pm.PopupError('Please select the objects to make collision with!')
            return
    ## check whether the user has selected files for textures
    snowPath = snowPieceBrowser.getText()
    if ckboxTexture.getValue():
        if snowPath == '':            
            logger.error('Please select the images for textures!')
            pm.PopupError('Please select the images for textures!')
            return            
        
    logger.info('Start generating the snowy scene')

    snowSize = sliderSize.getValue()
    snowDensity = sliderDensity.getValue()
    snowHeight = sliderHeight.getValue()
    
    snowTexture = ckboxTexture.getValue()
    snowSequenceTmp = textSequence.getText()
    snowSequence = int(snowSequenceTmp)
    gdXs = directionX.getText()
    gdYs = directionY.getText()
    gdZs = directionZ.getText()
    
    gdX = float(gdXs)
    gdY = float(gdYs)
    gdZ = float(gdZs)

    pm.playbackOptions(ps = 0.4)
    
    offsetSize = snowSize * 0.3
    minSize = snowSize - offsetSize
    maxSize = snowSize + offsetSize
    
    
    startFace = startArea
    emitter1 = pm.emitter(startFace, sro = True, type = 'surface', rate = snowDensity, minDistance = 0.5, mxd = 1)
    particle_snow2 = pm.particle()
    pm.connectDynamic(particle_snow2, em = emitter1)
    
    ## using image textures for particles
    if ckboxTexture.getValue():
        logger.info(' particle render type: sprite ')
        pm.setAttr('%s.particleRenderType'%particle_snow2[0], 5)
        pm.addAttr(particle_snow2[1], internalSet = True, longName = 'spriteTwist', attributeType = 'float', minValue = -180, maxValue = 180, defaultValue = 0.0)
        pm.addAttr(particle_snow2[1], internalSet = True, ln = 'spriteScaleX', dv = 0.2)
        pm.addAttr(particle_snow2[1], internalSet = True, ln = 'spriteScaleY', dv = 0.2)
        pm.addAttr(particle_snow2[1], internalSet = True, ln = 'spriteNum', at = 'long', dv = 1)
        pm.addAttr(particle_snow2[1], internalSet = True, ln = 'useLighting', at = 'bool',dv = False)
    
        shader2 = pm.shadingNode('lambert', asShader = True)
        file_node2 = pm.shadingNode('file', asTexture = True)
        pm.setAttr('%s.fileTextureName'%file_node2, snowPath, type = 'string')
        shading_group2 = pm.sets(renderable = True, noSurfaceShader = True, empty = True)
        pm.setAttr('%s.ambientColor'%shader2, 1.0, 1.0, 1.0, type = 'double3')
        pm.connectAttr('%s.outColor'%shader2, '%s.surfaceShader'%shading_group2, force = True)
        pm.connectAttr('%s.outColor'%file_node2, '%s.color'%shader2, force = True)
        pm.connectAttr('%s.outTransparency'%shader2, '%s.surfaceShader'%shading_group2, force = True)
        pm.connectAttr('%s.outTransparency'%file_node2, '%s.transparency'%shader2, force = True)
        pm.sets(shading_group2, e = True, forceElement = '%s'%particle_snow2[0])
        
        if ckboxSequence.getValue():
            pm.setAttr('%s.useFrameExtension'%file_node2, 1)
            pm.setAttr('%s.useHardwareTextureCycling'%file_node2, 1)
            pm.setAttr('%s.endCycleExtension'%file_node2, snowSequence)
         
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleXPP')
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleXPP0')
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleYPP')
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteScaleYPP0')
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteTwistPP')
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteTwistPP0') 
        pm.dynExpression(particle_snow2[1], s = 'spriteScaleXPP = rand(%f,%f);\nspriteScaleYPP = spriteScaleXPP;\nspriteTwistPP = rand(0,30);'%(minSize, maxSize), c = True)
        
        if ckboxSequence.getValue():
            pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteNumPP')
            pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'spriteNumPP0')
            pm.dynExpression(particle_snow2[1], s = 'spriteScaleXPP = rand(%f,%f);\nspriteScaleYPP = spriteScaleXPP;\nspriteTwistPP = rand(0,30);\nspriteNumPP = rand(0,%f);\nspriteNumPP = (spriteNumPP+1)%%%f;'%(minSize, maxSize, snowSequence, snowSequence+1), c = True) 
    ## don't using textures
    else:
        logger.info(' particle render type: cloud ')
        pm.setAttr('%s.particleRenderType'%particle_snow2[0], 8)
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'radiusPP')
        pm.addAttr(particle_snow2[1], dataType = 'doubleArray', ln = 'radiusPP0')
        pm.addAttr(particle_snow2[1], dataType = 'vectorArray', ln = 'rgbPP')
        pm.addAttr(particle_snow2[1], dataType = 'vectorArray', ln = 'rgbPP0')        
        pm.dynExpression(particle_snow2[1], s = 'radiusPP = rand(%f,%f);\nrgbPP = <<1,1,1>>;'%(minSize, maxSize), c = True)
    
    ## if make collision
    if ckboxCover.getValue():
        for j in range(len(coverObj)):
            pm.collision(coverObj[j], particle_snow2[1], r = 0, f = 1)
    
    ## add gravity
    snowGravity = pm.gravity('%s'%particle_snow2[0], dx = gdX, dy = gdY, dz = gdZ, magnitude = 1.0)
    pm.connectDynamic('%s'%particle_snow2[0], f = snowGravity)    
    
    
    logger.info('Scene generation finished!')
    return

def  isset(v):
    '''
    This function is for check whether a variable is available.
    
    Args:
        v: the string name of the variable
    Returns:
        0: the variable is not set
        1: the variable is set
    '''
    try :  
        if (eval(v)):
            logger.info('%s defined correctly.'%v)
    except NameError:  
        return   0   
    else :  
        return   1 

def selectObj(selType):
    '''
    This function gets the selected object.
    
    Args:
        selType: decide which kind of object the function will return
            0 - object name
            1 - select start area
            2 - select cover objects
    
    Returns:
        object: the name of the selected object
    
    Raises:
        ValueError: will return nothing
    '''
    global snowPiece
    global startArea
    global startAreaIndex
    global coverObj

    selObj = pm.selected()
    
    ### judge if there is object selected
    if not selObj:
        pm.PopupError("No object selected!")
        logger.error('No object selected!')
        return
    
    ### select object
    if selType == 0:
        snowObj = selObj
        logger.info('obj OK: %s' %snowObj)
        return snowObj

    ### select plane that the snow starts
    elif selType == 1:
        startArea = selObj[0]
        logger.info('plane OK: %s' % startArea)
        return startArea
    
    ### select objects that the particle would collide with
    elif selType == 2:
        coverObj = selObj
        logger.info('cover objects OK: %s' % coverObj)
        return coverObj
    
    return
    
## two dunctions for browser the file    
def getPath(control):
    '''
    This function is to get the file path of a file from the file browser.
    
    Results:
        If success, run updatePath()
        If failure, return None
            
    Returns:
        None
            
    '''    
    source = pm.fileDialog2(fileMode = 1,
                            fileFilter = '*.png',
                            caption = 'Pick A File To Import'
                            )
    if source:
        # put browsed path into field
        control.setFileName(source[0])
        
        # run update on field
        updatePath(control)
    else:
        return None
    
def updatePath(control):
    '''
    This function gets the updated the file path.
    
    Results:
        save the new file path to optionVar[FILE_PATH_OV]
        
    Returns:
        none
        
    '''       
    # get the value of the field
    text = control.getText()
    path = text
    
    # save the optionVar
    pm.optionVar[FILE_PATH_OV] = path
    
    logger.info('FIle path loaded: %s'%path)
        
def ui():
    '''
    This is the main ui function of generating the snowy scene.
        
    Returns:
        none
        
    '''   
    winTitle = 'Snow World'
    winName = 'winSnowWorld'
    winWidth = 300
    winHeight = 260
    
    if pm.window(winName, exists = True):
        pm.deleteUI(winName)
    
    snowWin = pm.window(winName,
                       title = winTitle,
                       widthHeight = (winWidth, winHeight)
                       )
    colLayoutMain = pm.columnLayout(adj = True)
    

    ### select start area button
    buttonSelArea = pm.button(label = 'Select Start Plane',
                              width = 100,
                              command = pm.Callback(selectObj, 1)
                              )
    ### select single snow piece model dialog
    snowPieceBrowser = pm.textFieldButtonGrp(buttonLabel = 'Browser',
                                             label = 'Snow Piece to import:',
                                             columnWidth3 = (110, 50, 50),
                                             adj = 2,
                                             ann = 'Enter A File Path'
                                             )
    snowPieceBrowser.buttonCommand(pm.Callback(getPath, snowPieceBrowser))
    snowPieceBrowser.changeCommand(pm.Callback(updatePath, snowPieceBrowser))
    snowPiecePath = ''
    if FILE_PATH_OV in pm.optionVar:
        snowPiecePath = pm.optionVar[FILE_PATH_OV]    
    if snowPiecePath:
        snowPieceBrowser.setFileName(snowPiecePath)
    
    ### layout for texture checkbox
    rowLayoutCkBox = pm.rowLayout(nc = 2,
                                  cw2 = (120, 30),
                                  co2 = (20, 20),
                                  parent = colLayoutMain
                                  )     
    pm.text(label = ' ',
            font = 'fixedWidthFont',
            parent = rowLayoutCkBox
            )    
    #### checkbox for whether to use textures for snow pieces
    ckboxTexture = pm.checkBox(label = 'Use file as texture',
                               value= True, 
                               parent = rowLayoutCkBox
                               )   
    
    ### layout for texture sequence checkbox
    rowLayoutCkBox2 = pm.rowLayout(nc = 3,
                                    cw3 = (120, 40, 30),
                                    co3 = (20, 20, 20),
                                    parent = colLayoutMain
                                    ) 
    pm.text(label = 'Number of Files:',
            font = 'fixedWidthFont',
            parent = rowLayoutCkBox2
            )
    textSequence = pm.textField('Input',
                              tx = '1',
                              font = 'fixedWidthFont',
                              backgroundColor = (0, 0, 0),
                              parent = rowLayoutCkBox2
                              )
    #### checkbox for whether to use textures sequences
    ckboxSequence = pm.checkBox(label = 'Use file sequence',
                                value= True, 
                                parent = rowLayoutCkBox2
                                )      
    
    ### slider for average size of snowpiece
    sliderSize = pm.floatSliderGrp(label = 'Avg Size',
                                   field = True,
                                   minValue = 0.01,
                                   maxValue = 10.0,
                                   fieldMinValue = 0.01,
                                   fieldMaxValue = 10.0,
                                   value = 1,
                                   cw3 = (60, 40, 200),
                                   adj = 3,
                                   parent = colLayoutMain
                                   )
    
    ### slider for density of snow
    sliderDensity = pm.floatSliderGrp(label = 'Density',
                                      field = True,
                                      minValue = 0.1,
                                      maxValue = 5.0,
                                      fieldMinValue = 0.1,
                                      fieldMaxValue = 5.0,
                                      value = 1,
                                      cw3 = (60, 40, 200),
                                      adj = 3,
                                      parent = colLayoutMain
                                      )
    ### slider dor max height
    sliderHeight = pm.floatSliderGrp(label = 'Max Height',
                                     field = True,
                                     minValue = 1,
                                     maxValue = 100,
                                     fieldMinValue = 1,
                                     fieldMaxValue = 100,
                                     value = 10,
                                     cw3 = (60, 40, 200),
                                     adj = 3,
                                     parent = colLayoutMain
                                     )
    ### select the snow direction
    rowLayoutAngle = pm.rowLayout(nc = 6,
                                  cw6 = (110, 45, 20, 45, 20, 45),
                                  co6 = (0, 0, 0, 0, 0, 0),
                                  parent = colLayoutMain
                                  )
    pm.text(label = 'Direction Vector:       X',
            parent = rowLayoutAngle
            )

    directionX = pm.textField('DVX',
                              tx = '0.000',
                              parent = rowLayoutAngle
                              )
    pm.text(label = '   Y',
            parent = rowLayoutAngle
            )
    directionY = pm.textField('DVY',
                              tx = '-1.000',
                              parent = rowLayoutAngle
                              )    
    pm.text(label = '   Z',
            parent = rowLayoutAngle
            )
    directionZ = pm.textField('DVZ',
                              tx = '0.000',
                              parent = rowLayoutAngle
                              )    

    ### layout for cover objects options
    rowLayoutCover = pm.rowLayout(nc = 2,
                                  cw2 = (150, 150),
                                  co2 = (20, 20),
                                  parent = colLayoutMain
                                  )
    buttonCover = pm.button(label = 'Select Objects Collide With',
                            width = 150,
                            command = pm.Callback(selectObj, 2),
                            parent = rowLayoutCover
                            )
    ckboxCover = pm.checkBox(label = 'Make Collision',
                             value= True, 
                             parent = rowLayoutCover
                             )    
    
    ### layout for start generation button and cancel button
    rowLayoutButton = pm.rowLayout(nc = 2,
                                   cw2 = ((winWidth/2), (winWidth/2)),
                                   co2 = (40, 20),
                                   parent = colLayoutMain
                                   )
    buttonStart = pm.button(label = 'Start Snow!',
                            width = 100
                            )
    buttonStart.setCommand(pm.Callback(run,
                                       sliderSize = sliderSize,
                                       sliderDensity = sliderDensity,
                                       sliderHeight = sliderHeight,
                                       textSequence = textSequence,
                                       ckboxTexture = ckboxTexture,
                                       ckboxSequence = ckboxSequence,
                                       ckboxCover = ckboxCover,
                                       directionX = directionX,
                                       directionY = directionY,
                                       directionZ = directionZ,
                                       snowPieceBrowser = snowPieceBrowser
                                       )
                           )
    buttonCancel = pm.button(label = 'Cancel',
                             width = 100,
                             command = pm.Callback(snowWin.delete)
                             )
    snowWin.show()
    snowWin.setWidthHeight((winWidth, winHeight))
                            
    logger.info('UI launched')
    return

instructions:

1. click on the plane
2. click ‘Select Start Plane’ button
3. if you want to use a specific image as snowflake texture, browse and select the image, then turn on the ‘Use file as texture’ checkbox. if you don’t turn on the checkbox, the particle will be rendered as white cloud type
4. if you want to use more than one image to texture different particles, then turn on the ‘Use file Sequence’ checkbox. then the file browsered just now will be set as the start of the file sequence. make sure to name the textures in ‘image.n’ format. for example, ‘snow.1’
5. set values of ‘Average Size’, ‘Density’, ‘MaxHeight’
6. set values of ‘Direction Vector’
7. if you want to make collisions between other objects and the particles, select those objects and then click ‘Select Object Collide With’ button, and turn on ‘Make Collision’ checkbox
8. click ‘Run’ to start generating the snowy scene

logs:
v1.0.5: 12-19-2015, add error captions
v1.0.4: 12-19-2015, add collisions; delete animation length option
v1.0.3: 12-16-2015, add particle render type - cloud
v1.0.2: 12-9-2015, add texture sequence
v1.0.1: 12-2-2015, add log function

Platform(Given): Mobile

Engine(Given): Unity

Theme(Given): Film-Noir, Totalitarian, Dystopian, Tyrannical (Kim Jong-Un)

Audience(Given): Inter-city youth

This time the process is not smooth as previous games. At first we tried to make a shooting game that the main character hold a gun walking on a dark street, and kill enemies who are selling guns and drugs and wanted to kill him. We even finished the core gameplay mechanic. But when the first pitch we got advice from others that since our audience is inner city youth - teenagers without educated and easily attracted by violence and drugs - which may cause bad influence in the real world, we considered to change our main gameplay. We originally have two weeks, but then we have only one week - actually less than 5 days to finish The Modus Room.

My contribution to the project

In this project I perform as the only artist in our team. Yes it’s the same team as the previous game. My major contributin is the art works of the game. Specific aet works are showed as follow:

• UI including start screen background, buttons(some of them were not put in the final version due to the lack of time)
• The house, including the building and furnitures inside
• Trailer animation
• Also a character with animation for our first idea, but dropped

I also took part in our discussion on the two ideas we had, and voted for escape room the second time.

Different things to do next time

After three times of art work training, I’m now getting more and more familiar with art works in games. But I still need to improve a lot. I didn’t get professional art training, so sometimes lack the sense of combine colors, such as this time I finally found that I dark grey would look better than pure black. I think I have talked a lot with our teams this time, but I still need to communicate more next time.

Also about the idea change, members in the team should all think twice about whether the idea is feasible. We need to think critically about it next time, to avoid such things from happening again.

Things I learned from participating in this process

This time many things left me deep impression.

Positive lessons:

First thing is team running. We are the same team as the previous one, so we have known each other more. It seems that we communicate more free with each other this time. Also two of our programmers didn’t know unity very much last time, but they have got some idea about it this time, and that’s also why we can nearly finish the prototype in such a short time.

Second is our programmers’ hard work. They work very hard, and tried their best to finish the game in time. And they are very willing to communicate with the team.

Third is testing. This time the playable version came out more rapidly so we could see and test the game from time to time. I still have the test version installed on my phone.

Negative lessons:

First is that we are more aware about the importance of team stay together. We were late to choose the seats, so we had to saperate to different places. So every meeting seems so pracious. And during the day we are always surrounded by different teams with their meetings. It’s not good for team works. And I think we didn’t handle it very good.

Second is that we are sometimes late for class. We always wanted to start meeting when the class is on, but often not all of us arrived including me for some reasons, so we just postponed the meeting. So after the meeting we usually didn’t have enough time in class. Though we had done better than before, this was still a big problem.

Third is that we didn’t have enough game design thing. We didn’t get agreed on the same ideas for puzzles to put in the game. Though our producer uploaded a design doc for puzzles for reference, we changed a lot in the final game without discussion, and so many of my assets were not used. Well this is actually still the problem of communication. We need someone to maintain the level things and design the puzzles carefully.

The word “punk” comes from punk rock, which is a rock music genre developed between 1974 and 1976. The term ”punk” was first used in relation to rock music by some American critics to describe garage bands and their devotees. Punk bands typically use short or fast-paced songs, with hard-edged melodies and singing style, stripped-sown instrumentation, so people use punk rock to express their emotions, and often with political, anti-establishment lyrics. They took root in local scenes that tended to reject association with the mainstream. So we can almost see what’s the feeling of “cyberpunk”. Cyberpunk is a subgenre of science fiction in a future setting, which often center on a conflict among artificial intelligences and megacorporations. That future is often called the antithesis of the generally utpian visions. Megacprporations, cyberspace and hackers are always the basic setting in such stories.

So we can see that the world of Android inherited nearly all the elements of cyberpunk. Four megacorporation - Haas-Bioroid, Jinteki, NBN, and Weyland Consortium - dominate nearly all essential aspect of human life, and three groups of runners - Anarchs, Criminals, and Shapers - as hackers trying to hack in to the megacorporations’ servers and reveal their crimes. Figure 2 shows three runners from the core game card set.

Such cyberpunk setting fits the main topic of Android: NetRunner very well. The games is played in a cyberspace, which the runner make runs to the corporations’ servers. Runners use programs, varius, hardware resources to improve his hacking ability, while corporations upgrad and build ice outside to protect servers. It is exactly like what the corporations and hackers do in the real world. To some extent the story is also a hard sic-fi story, which means its settings are very accurate or have a lot of technical details. We can find many terms of professional like install programs, trace and icebreaker which are really used in the real world.

The story of the world of Android is very long, which uses five books including the identity trilogy to describe the whole world. I haven’t read them. But there are also background stories for each megacorporation and runner in the rule book as those cards publised. We can see that the three groups of runners has their own skill sets and goals to pursue. Also each runner in the same group is different characterized, which can be found in the following extension packs. Their skills also are related to their settings. Such as Noise, his skill is to trash the top card of R&D of the Corp whenever he installs a virus program, just like his bold and uninhibited character in the story, he easily hacked into the Corp for a lot of times, but no one could find the evidence.

Some cards that are not the main runner character also has their own stories. Like showed in Figure 4(a), Bernice Mai is a professional in NBN, who is pro at trace. Runners invading the server under her manage all risk the danger of being traced and locked. So on the card, she has the trace strength of 5 - a very high strength - that the runner has to pay a lot to upgrad his varius or just get locked and receive the damage.

Some cards together can tell a whole story. Figure 4(b) is the identity card of a Shaper called Nasir Meidan. He is good at trading - to trade what he want with his hack skill. So his skill is to lose all credits in his credit pool but gain the credits equal to the rez cost of that ice that would be more valuable to him. The event card Social Engineering (Figure 4(c)) tells the story that he tried a very clever way and get the tickets through trading, to get into the Beanstalk, where he can travel to other places of the solar system through Challenger spaceships.

These are just some cards. I think that we can find many cards that make up the whole world of Android. The designers found out the point of each character, and give their cards the skills which just shows their personalization. This is a very great way to help illustrate the big scene of the main topic.

Besides, the art pictures on each card is also drawn in the style of cyberpunk. With clear bounded metal colors, and high-tech assets, we can nearly smell the taste of computers. They drawn every card differently, and made the picture related to the topic and background story. This is also very helpful to the players to get into the game very quickly.

After playing the game and enjoying the beautiful pictures, I’m now very interested in the whole Android world. I’ll try to read the whole story later.

My contribution to the project

In this project I perform as the only artist in our team. So my major contribution is the art works of the game. Specific art works are showed as follow:

• Concept scene as the loading screen of the game
• Assets such as factories, trees, and animals
• User interface components
• LOGO of the game
• Trailer animations

Besides the specific art works, I also discussed with my team together of the game concept.

Different things to do next time

Next time we are still in the same team, and the art work is more challenging. I’ll need to design the characters. And for the game world will be bigger next time, I’ll need to talk about many more details with programers, so I need to communicate with my team more. Since we have the experience of the previous prototype, I think it will be easier next time.

Things I learned from participating in this process

From each experience of making a prototype I can always benefit a lot. So does this time.

Positive lessons:

First thing is Trello. This time we tried to use Trello to trace our works. Trello is a kind of online sticker board. This is a very good way to trace the process of our work. And it is very clear that every one has his own works. Like we have four programers, if I need to talk to someone of the art work he needs, I can simply check the trello stickers and find who is in charge of that part.

Second is seeking advice from experts. Because it is a serious game, we need to make sure what we showed is the correct information to the audience. Our producer Leigh contacted many experts in biological and environmental field, and finally we met an expert from environment school. He confirmed our idea, and gave us some great references. I think that we should always find some experts for advice, not only for pure serious games, because we always want to deliver the information exactly what we want, and they will really help a lot.

Well the last is about my work myself. This is the first time that I need to take in charge of all the art works in the team, and I’m not very good at the 3D modeling skill. I tried my best, learned modeling things through tutorials and asking the other artists, and finally I’m satisfied with my job. Thanks a lot to Kamchai, Cody, and Chloe. I’ve learnt that feel free to learn from others if you are really not that good.

Negative lessons:

Well the first is about our team communication. I have to say that I didn’t know what the programers wanted to make what the game would look like until the last day I saw the nearly finished one. Though I made the concept picture, I didn’t tell them what I expect the game to look like before. And it was a bit late to modify that time. And when I finished some art assets, I think I need response from them, not only ‘You did good’. So I need to communicate with them more.

The second is about our meetings. Sometimes we cannot express us very clearly that we still have different understandings after the meetings. But this phenomenon is getting better and better as the time flows.

The main difference of LCG from CCG and TCG1 is that players know what they will get from each version of expansion. There is no randomize in cards. Expansions of most CCGs and TCGs have random cards in each card bag, including a few rare and strong cards, so players need to buy many the same version expansion to get the card they want. Or they can trading with the others in TCGs, buy the specific card of exchange with each other. Because of rareness, some good cards have a very high value in the market, for example, Magic: The Gathering. Pure CCGs like HearthStone are without trading system.

They are all different from regular card games, which has only one version of deck. And also different from DBG - Deck Building Game, of which the majority of the deck is built during the game instead of before the game. Like Dominion, players use their first version of deck to buy the card they want in the game. TCG, CCG, and LCG all have continuous expansions. They keep giving players new cards, help rebuilding their decks, give them new game experience. I think it’s a really good idea to expand the game’s life span. Dominion also have expansions, but not frequently as LCGs. For DBG and TCG, new expansion always mean new environment or new version.They usually cost one year or more for expansion, with many kinds of new cards.

More expansions means more profit. For TCG and CCG,they can also sell single rare cards for a very high expense1. But this would lead to bad experience that players with not very much money always do not have powerful decks, make the game unbalanced. That’s exactly what I heard frommany Magic player friends. But - yes, they are still Magic players. They also told me that Magic is such a good game with long time history, which make it a perfect system, a huge card pool, and good balanced. And the most important thing is, the tules are very simple to learn. The only thing that make some players give up is the price.

Compare to TCG, NetRunner seems to have a great advantage on price. Because of no rare cards, players, players just need spend some money to buy the cheap expansions they need. This help the balance not influenced very much by whether you have much money. And FFG can continuous profit from the cheap but large selling expansions. Also to some extent it is more friendly to new players. Since the profit-model on LCGs is driven by capturing new players rather than keeping players who have already “bought-in”, we can see that FFG is also tempting to push their talent towards different games and away from Netrunner.

Then, why apply LCG to NetRunner? I think there are several reasons. First,NetRunner do not have a theme with great background story. Those kind of cards are always TCGs or regular themed card games. Only the methods to play makes it easier to expand. Second, the theme cyberpunk comes from the developing technology today, so that it can always add in some new functions just as the real new technology applies. And third, NetRunner is not their first LCG, and won’t be the last. As is said before, FFG is trying to apply more LCGs in the future, to profit more.

Also this busness mode has impact on the game itself too. Because of choosing LCG, FFG won’t put all powerful cards in the same version of expansion. On forums we can always see some players introducing the best cards in each expansion. And under this mode, FFG can also expand every aspects of the game - the characters, funtions, and playing mode, etc. FFG has their won designers and artists, and their card games are famous for beautiful vision design and high quality components, which also apply to NetRunner.

Most kind of TCGs do not have a online version, because it may cause the phenomenon of sockpuppets all over the server in order to get and sell rare cards. But LCGs can have a online version. Till now the online game of NetRunner is still developped by players2. Online version is very convenient to get familiar with the rules and decks, and to test the decks.

User interface:

See how it works on Youtube:

Python scripts sample:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

"""
SnowPiece.py

examples of proper usage of logging module

__author__ = "Vega Bai"
__copyright__ = "Copyright 2015, Vega Bai"
__version__ = "1.0.1"
__maintainer__ = "Vega Bai"
__email__ = "vegabaixuan@gmail.com"
__status__ = "Practise"

"""

import pymel.core as pm

def select_obj(selType):
    ### global varibles
    global snow_obj
    global from_point
    global from_point_index
    global to_point
    global to_point_index
    sel_obj = pm.selected()
    
    ### judge if there is object selected
    if not sel_obj:
        pm.PopupError("No object selected!")
        return
    
    ### select object
    if selType == 0:
        snow_obj = sel_obj
        print 'obj OK'
        print snow_obj
        return snow_obj

    ### select destination point
    elif selType == 2:
        to_point = sel_obj[0]
        to_point_index = to_point.index()
        print to_point_index
        return to_point_index

    
def on_click_run(slider_scale, slider_angle, slider_level, snow_win):
    ### get values from sliders
    snow_scale = slider_scale.getValue()
    snow_angle = slider_angle.getValue()
    snow_level = slider_level.getValue()       

    ### list for 1/6 snow piece
    snow_list = []
    snow_list.append(snow_obj)
    
    ### list for 6 parts of the snow piece
    snow_joint_list = []
    
    ### rename the origin object
    pm.rename(snow_obj, 's0')

    ### draw 1/6 snow piece
    for i in range(1, snow_level):
        tmp = pm.duplicate(snow_list[i-1])
        snow_list.append(tmp[0])
        pm.rotate(snow_list[i], 0, snow_angle, 0, r = True)
        pm.scale(snow_list[i], snow_scale, 1, snow_scale, r = True)
        pos = pm.xform('%s.vtx[%d]'%(snow_list[i], to_point_index), q = 1, t = 1, ws = 1)
        pm.xform(snow_list[i], t = (pos[0], 0, pos[2]), ws = 1)

    ### unite the 1/6 snow piece
    tmpunit = snow_list[0]
    for i in range(1, snow_level):
        print tmpunit, i
        tmpunit = pm.polyUnite(tmpunit, snow_list[i])
        
    ### draw all 6 parts
    snow_joint_list.append(tmpunit[0])
    for i in range(1, 6):
        tmp = pm.duplicate(tmpunit[0])
        snow_joint_list.append(tmp)
        pm.rotate(tmp, 0, 60*i, 0, r = True)     
        
    ### unite the whole snow piece
    snow_final = snow_joint_list[0]
    for i in range(1,6):
        snow_final = pm.polyUnite(snow_final, snow_joint_list[i])
    
    ### delete the menu window
    snow_win.delete()
    
    return

def ui():
    win_title = 'Draw A Snowpiece'
    win_name = 'snow_window'
    win_width = 300
    win_height = 160

    if pm.window(win_name, exists = True):
        pm.deleteUI(win_name)

    ### create the menu window
    snow_win = pm.window(win_name,
                         title = win_title,
                         widthHeight = (win_width, win_height),
                         sizeable = False
                         )
    col_layout1 = pm.columnLayout(adj = True)  
    row_layout1 = pm.rowLayout(nc = 2,
                               cw2 = ((win_width/2-10), (win_width/2+10)),
                               parent = col_layout1
                               ) 
    
    ### select object button
    button_sel_obj = pm.button(label = 'Select Object',
                               width = 100,
                               command = pm.Callback(select_obj, 0)
                               ) 
    ### select destination point button
    button_sel_end_point = pm.button(label = 'Select Destination Point',
                                     width = 130,
                                     command = pm.Callback(select_obj, 2)
                                     )
    
    ### slider for scale
    slider_scale = pm.floatSliderGrp(label = 'Scale',
                                     field = True,
                                     minValue = -2.0,
                                     maxValue = 2.0,
                                     fieldMinValue = -2.0,
                                     fieldMaxValue = 2.0,
                                     value = 0.5,
                                     cw3 = (40, 50, 200),
                                     adj = 3,
                                     parent = col_layout1
                                     )
    ### slider for angle
    slider_angle = pm.floatSliderGrp(label = 'Angle',
                                     field = True,
                                     minValue = -30,
                                     maxValue = 30,
                                     fieldMinValue = -30,
                                     fieldMaxValue = 30,
                                     value = 0,
                                     cw3 = (40, 50, 200),
                                     adj = 3,
                                     parent = col_layout1
                                     )
    ### slider for level
    slider_level = pm.intSliderGrp(label = 'Level',
                                     field = True,
                                     minValue = 0,
                                     maxValue = 10,
                                     fieldMinValue = 0,
                                     fieldMaxValue = 10,
                                     value = 4,
                                     cw3 = (40, 50, 200),
                                     adj = 3,
                                     parent = col_layout1
                                     ) 
    ### layout for run button and cancel button
    row_layout2 = pm.rowLayout(nc = 2,
                               cw2 = ((win_width/2), (win_width/2)),
                               co2 = (20, 20),
                               parent = col_layout1
                               )
    button_run = pm.button(label = 'Run',
                           width = 100
                           )
    button_run.setCommand(pm.Callback(on_click_run,
                                      slider_scale = slider_scale,
                                      slider_angle = slider_angle,
                                      slider_level = slider_level,
                                      snow_win = snow_win
                                      )
                          )
    
    button_cancel = pm.button(label = 'Cancel',
                              width = 100,
                              command = pm.Callback(snow_win.delete)
                              )
    snow_win.show()
    snow_win.setWidthHeight((win_width, win_height))

My contribution to the project

In this project I performed as one of the artists. Another artist is Wesley. We separated art works. The specific things I had done were:

• Draw the LOGO, game-start screen, and game-over screen
• Draw the background
• Draw some of the assets

Besides the specific art works, I also discussed with my team together of the game concept and level design things.

Different things to do next time

In the next project, I found that I will be the only artist in our team. So I think I will need to decide the art style of our game, and design the characters, which was done by Wesley this time. And also in the following projects when I am acting as an artist, I would communicate more with our producer and programmers.

And next time I think we artists should give out a concept picture of the ideal game. Especially when there is not much time left for the programmers to build the ideal game world. It would be very helpful.

Things I learned from participating in this process

This time we are more familiar with the process of making a game prototype. We had learned from the previous one, but this time we also found some new lessons both positive and negative.

Positive lessons:

First is about the work assignments. This time we always held a short metting before every class, talking about what we had done and what we needed to do in the following two or more days. We set deadline for our each assignment. So our goals were so clear that we do not need to be confused about it, which made our work very effective.

Second, we set a very challenging goal at the very first - using Html5 to realize 2.5D isometric environment, which pushed us very hard during the process. We learned to draw new things from digital tutorials, as well as programmers tried hard to figure out how to code with Html5. What we had done is beyond our imagination of one month before.

The third I think is about our game concept. We found Zaxxon is enough playful just try to survive during the move, so we removed the combat system, made it a speed game, and added some powerups to make it more exciting. I love the iteration idea very much. And we also used no inputs besides the arrow keys. We all loved the idea, so that we could put more passion in the game.

Negative lessons:

Well the first is that we were too ambitious. Work of artists seems not that difficult, but work of the programmers did. We designed many aspects of the game, but what we realized is not that much. Our expectation was too perfect for a prototype. So finally we do not have enough time to finish all we wanted.

Second, we didn’t have a specific level design. We didn’t discuss about it very detail and just used the first design, which was also modified during the level build in programs. I think the level design is the core content of a game beside the core play method. So in my opinion I think we should put more emphasis on level design, which would make it a game.

Third, think about our artists’ work. Actually we didn’t do it very satisfied - some animations was not very good, and some assets had shadows while some not, which seems a bit weird. We will try to do better next time.

Game Overview

This game is about the story between corporations and hackers. It’s actually a Living Card Game. Not like the TCG games I played before, in NetRunner the two players play different characters - corporation and hacker. Corporation cannot play against corporation, and hacker cannot play against hacker.

As a student of computer science before, I have to say that NetRunner performs a highly similar situation towards the real hacking thing. The corporation needs to build servers and protect them with ices while the hacker using his resources to hack the corp’s server. Making runs is always exciting and adventurous.

Play The Game

For the corporation, the main work is to use his clicks to build servers and advance them, protect them with ice - like firewalls of our computer. In servers there is a type of card called Agenda, which the player can get score from them when they are fully advanced. The corp can also install and advance other type of cards in servers to make the hacker confused. Every turn the corp is forced to draw a card and get three initial clicks.

In the original deck pack, there are four corporation identities to choose. Each identity has a unique skill that can be applied during the whole game. Each identity has 28 special cards for him, and there are 22 general cards for all of them. There are two ways for the corp to win: get seven points first, or kill the hacker. The corp can do damages to the hacker and force him to drop cards from grip, and once the hacker has no card to drop, he will die.

For the hacker, the main work is to use his resources to invade the corp’s servers and steal the unfully advanced Agenda cards and get score from it in his limited clicks. The player installs virus programs on hardware, using these virus to break the ices outside the server when making a run, try getting the Agendas as well as avoiding himself from being damaged. The hacker has four initial clicks every turn.

There are three original identities for the hacker to choose, and also each has a unique skill to help him invade more easily or protect him from damages. Each identity has 33 special cards for him, and there are 15 general cards for all of them. The hacker can win through the following two ways: get seven score first, or when the corp has no card to draw.

Thoughts After Playing

NetRunner is a game full of strategies and mind games. The corp needs to determine whether to install Agendas or others, to install what kind of ices, to get credits or draw cards - these all will affect the game results. The hacker may bet on which server to invade that he can get the most benefits. Sometimes luck is very important - I once invaded a server at the beginning turn when there was no ices, and I got two Agendas with each values three agenda points. I don’t like this. But most of the time, you can still hold your fortune.

Like Magic: The Gathering, NetRunner doesn’t limit the number of cards in your deck, but put a restriction on the total agenda points inside. Though for corps they will lose when they have no card to draw in R&D, it’s not a very good idea to build a very huge deck, because larger deck means more Agenda points, so it also increases the chances for the hacker to steal an Agenda.

There are many expansion packs of NetRunner now, and the company FFG is still designing new cards for the game. To some extent, to get all the cards you want is a big purchase. But unlike many TCGs, LCG games do not have randomized rare cards, which reduces the unbalance caused by purchasing abilities.

There are also many functions in NetRunner like Tag and Trace. The corp can trace the hacker and tag him, which is not a good sign for the hacker. And different Counters, to help perform the function of the original cards. Well actually NetRunner is the most complicated card game I’ve ever played. That’s also why I love it very much now.

My contribution to the project

The specific contributions are:

• Name the game
• Program the AI of all the snails
• Program the snail counter
• Program the boss level, including the AI of the dragon, motion of the fireballs, and the fight actions in the level.
• Package the program files to the excutable version

Besides these, I gave advice to our artists on the art features of Chinese style. And we programmers always work together to solve problems we met during the period.

Different things to do next time

Actually because there are three engineers in our team, and I was not familiar with the pygame before, most of the works like build the program frame of the whole project was done by Sudeep, who is more familiar with pygame. I was a bit lazy. I think if I can travel back now I’ll try to learn more of pygame and share more work with our engineers. So as in the future.

Also, as a technical artist, I may try to be an artist some time.

Things I learned from participating in this process

This is the first time I join a team and make our own games. So the experience is very precious for me to get through the process of making a game prototype.

Positive lessons:

First, as an engineer, I learned to seperate all the things we need to program and make a standard of the connection ports. Then we can work independently. We made the file versions and changes made to them clearly so that we can combine them together correctly. That’s the source control, which is the basic thing for programers to work together efficiently.

Second, we are a team, so we tried to make the team communication to be as convenient as possible. We had a shared drive folder and all the thing were uploaded into it, so that we can keep updated. We mail to each other whether there is something need to be discussed. And we talk about our project everytime the prototype class starts. Our team members are very nice too.

Third, I have to say about our artists’ excellent work. They are Tara and Kamchai. They have very good art skills, and finish all the art materials we need in time. Their passion and enthusiasm were surely a great encourage to the whole team. So I learned that being positive is very important in the project process. We all kept energetic and made out the game in our minds.

Negative lessons:

There are surely something we need to improve in the future. There are also three things I think that is most urgent to be improved. First is that we didn’t have a design document. All the works were assigned orally, and sometimes I actually do not know what’s the next step. We need to make goals. Second, we uploaded all the files to the drive, but didn’t classify them very well, that we always needed to ask where to find a specific file. Third is that we are always hungry before one o’clock when the class ends.

Design & Development. Using CSS + HTML5 + Javascript.

This was a team work, with two partners from Industry Design College designed the page, and I was the programmer to make it true. We aimed to find a UI mode of collocation on cell phones. We compared many different modes, and finally chose my idea of using a round menu. We all agreed that this idea would make users feel more interesting, and our user experience test proved it. It feels really good to using your techniques to make more fun. During the process I applied the object-oriented concepts – the ‘ring’ is a class and can be used on different themes besides pizza DIY through just replacing the icons.

Code sample:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

// icon click function
iconClick: function(index, total) {
this.changeColor(index, FR.MenuRound.currentIcon);
var base = FR.MenuRound.currentIcon - index;

if (!base) {
FR.MenuRound.showIndexList(index);
return;
}
var isNext;
// judge the direction of rotation
if (base > 0) isNext = base >= total / 2 ? true : false;
else isNext = base >= -total / 2 ? true : false;

var n = 1;
if (isNext) {
while (1) {
var obj = (FR.MenuRound.currentIcon + (n++)) % total;
FR.MenuRound.animQueen.push(obj);
if (obj == index) break;
}
} else {
while (1) {
var obj = (FR.MenuRound.currentIcon == 0 ? total : FR.MenuRound.currentIcon) - (n++) % total;
obj = obj < 0 ? total + obj : obj;
FR.MenuRound.animQueen.push(obj);
if (obj == index) break;
}
}
// if the waiting list is empty, call the rotate function
if (FR.MenuRound.animQueen.length == Math.abs(n - 1)) {
FR.MenuRound.rollRotate();
}
// try to use the setTimeOut function but failed
// setTimeOut("FR.MenuRound.showIndexList("+index+")",5000);
// setTimeout("alert('5seconds!')",5000);

FR.MenuRound.showIndexList(index);

},

changeColor: function(index, preIndex) {
var indexSrc = document.getElementById('fr_icon_'+index).src;
var preIndexSrc = document.getElementById('fr_icon_'+preIndex).src;
if((index == preIndex) && (indexSrc == FR.MenuRound.itemsSelect[index].icon)) return;
if(index == preIndex) {document.getElementById('fr_icon_'+index).src = FR.MenuRound.itemsSelect[index].icon;return;}
if(preIndexSrc == FR.MenuRound.items[preIndex].icon) {
document.getElementById('fr_icon_'+index).src = FR.MenuRound.itemsSelect[index].icon;
return;
}
document.getElementById('fr_icon_'+index).src = FR.MenuRound.itemsSelect[index].icon;
document.getElementById('fr_icon_'+preIndex).src = FR.MenuRound.items[preIndex].icon;
},

/*
* to show the effect of the UI design, make specific treatment. 
* So this function doesn't contain much techques.
*/
showIndexList: function(index){ 
if(index == -1){
document.getElementById('panelBg').style.visibility = "hidden";
for(var i = 0; i < 3; i++) {
document.getElementById('meat_'+i).style.visibility = "hidden";
}
for(var i = 0; i < 4; i++){
document.getElementById('vegetables_'+i).style.visibility = "hidden";
}
} 
else if(index == 0) {
document.getElementById('panelBg').style.visibility = "visible"; 
for(var i = 0; i < 3; i++)
document.getElementById('meat_'+i).style.visibility = "visible";
for(var i = 0; i < 4; i++){
if(getComputedStyle(document.getElementById('vegetables_'+i)).visibility == "visible"){
document.getElementById('vegetables_'+i).style.visibility = "hidden";
}
}

}
else if(index == 1) {
document.getElementById('panelBg').style.visibility = "visible";
for(var i = 0; i < 3; i++) {
document.getElementById('meat_'+i).style.visibility = "hidden";
}
for(var i = 0; i < 4; i++)
document.getElementById('vegetables_'+i).style.visibility = "visible";
}
else {
document.getElementById('panelBg').style.visibility = "hidden";
for(var i = 0; i < 3; i++) {
document.getElementById('meat_'+i).style.visibility = "hidden";
}
for(var i = 0; i < 4; i++){
document.getElementById('vegetables_'+i).style.visibility = "hidden";
} 
} 
},

iconClick2: function(index, listIndex){

var da = new Array(2);
var ta = new Array(2);
var aa = this.a;
var randPic = document.createElement('div');
randPic.id = listIndex + '_' + index;
randPic.style.position = 'relative';
for(var i = 0; i < 2; i++) 
{
da[i] = Math.random(); 
ta[i] = Math.random() * 2 * Math.PI - Math.PI;

var img = new Image();
if(listIndex == 0) img.src = FR.MenuRound.items0[index].icon;
else if(listIndex == 1) img.src = FR.MenuRound.items1[index].icon;
img.style.position = 'absolute';
img.style.left = 1.6 * aa + 0.9 * aa * da[i] * Math.cos(ta[i]) + 'px';
img.style.top = 1.6 * aa + 0.9 * aa * da[i] * Math.sin(ta[i]) + 'px';
img.style.width = 20 + 'px';
img.style.height = 20 + 'px';
img.style.zIndex = 15;
$(img).rotate(ta[i] * 0.5 / Math.PI * 360);
randPic.appendChild(img);
}
document.getElementById(this.id).appendChild(randPic);
},

// the rotate function
rollRotate: function() {
this.stepA = this.angle / this.steps;
this.steps = parseInt(this.time / this.speed);
this.counter = 1;
var sA = 6;
var tA = this.angle;

var quantity = this.items.length;
var a = this.a;
var b = this.b;
var iconWidth = this.iconWidth;
var iconHeight = this.iconHeight;
/*
* judge the direction of rotation
* or it may get wrong when continuously clicking
*/
var isNext = (this.currentIcon + 1) % quantity == this.animQueen[0] ? true : false;
FR.MenuRound.fr_interval = setInterval(function() {
if (FR.MenuRound.counter > FR.MenuRound.steps) {
clearInterval(FR.MenuRound.fr_interval);
FR.MenuRound.currentIcon = FR.MenuRound.animQueen.shift();

for(var i = 0; i < 6; i++) 
{
if(isNext)
{
FR.MenuRound.iconA[i] = FR.MenuRound.iconA[i] + tA;
}
else FR.MenuRound.iconA[i] = FR.MenuRound.iconA[i] - tA;

}
if (FR.MenuRound.animQueen.length != 0) FR.MenuRound.rollRotate();
return;
}
for (var j = 0; j != quantity; j++) {
var i = j;

var icon = document.getElementById('fr_icon_' + (FR.MenuRound.currentIcon + i) % quantity);

var x = y = 0;
if(isNext)
{
FR.MenuRound.iconA[i] = FR.MenuRound.iconA[i] - sA;

}
else
{
FR.MenuRound.iconA[i] = FR.MenuRound.iconA[i] + sA;

}
x = a + a * Math.cos(FR.MenuRound.iconA[i] / 360 * 2 * Math.PI);
y = b + b * Math.sin(FR.MenuRound.iconA[i] / 360 * 2 * Math.PI);

FR.MenuRound.setZoomLevel(icon, x, y);
FR.MenuRound.setRotation(icon, FR.MenuRound.iconA[i]);
// animation ends
if (FR.MenuRound.counter == FR.MenuRound.steps) {
icon.rawX = x;
icon.rawY = y; 
}
}
FR.MenuRound.counter++;

}, this.speed);

},

// set the picture's rotation itself
setRotation: function(icon, theta) {
$(icon).rotate(theta + 90);
},

Files: Pizza DIY