Author: Yuanhang Wu

I will render the animation with octane, so my best choice is Maxon Cinema 4D. Then I do a test on scene rendering.

The scene is now basically set up.

I start by adding sunlighting inside the scene. I will let the sun shine in through the window.

I chose an evening sun because the light can only cover the entire table when the sun angle is minimal. And I adjusted the colour of the sunlight to be warm.

The next step is to add textures to all other items. And This step took me most of the week.

The image below is the final result of the week.

Worth mentioning is this desk mat. This texture is from a personal project of mine in the past.

This map subtly enriches the details of the ground and keeps the picture from being monotonous.

Modelling will continue this week.

The next one is the pegboard.

I also used Houdini here cuz it is more efficient than Maya.

Compared with shutters, pegboards are much more straightforward.

The first is to create a cube. And use grouprange node to select the points that need to be hollowed out.

Then we use our old friend copytopoint node to clone.

Then is the boolean.

The next step is to export these two objects. This pegboard can be directly exported as an obj object.

But shutters are dynamic rather than static. Then I first considered exporting it as fbx. But this shutter is not bound, so I cached it as an alembic file.

This week I spent the most time on project 1.

Next week I will figure out the texture and start animating.

I started scene modelling this week.

Maya is the primary tool I use for modelling.

For some other special items, I used Houdini for procedural modelling. such as shutters and pegboards

First, I built a general scene in Maya, such as determining the location of the wall and the ground.

The second is to determine the height of the desktop.

For the desk, I refer to the dimensions of IKEA. Because I want to make sure that keyboards, monitors and other things have the correct size.

As for the display, I measured the size of the monitor. And modelled in Maya.

The model of the keyboard is downloaded by me on Sketchfab.

Next are the shutters. I would like the shutters to fluctuate over time so that the shadows can also move. But if I model each shutter in Maya, I must keyframe each shutter. So Houdini is a better choise.

The first node is to create a cube and transform it into the shape pointed by the red arrow.

The following two nodes are to bend the slice on two sides.

And here we have a slice of shutters.

But we still need the hole on these slices and the cable connecting them.

But before I start boolean. I need to create a group of this slice.

And I am going to use the node called copytopoints.

The node copytopoints has two input: meshes to clone and point to attach.

Points are generated by segmenting a line segment.

Then I perform a boolean operation on the two to get the following result.

Then I can use a transform node to control each slice rotation.

I used a sin expression here to make each slice fluctuate over time.

fit10 (sin($FF),-1,1,-21,10)

fit10 expression is used to map a range. Sin expression is a wave between -1 and 1.

And -21 and 10 is the new range that used to replace -1 and 1.

After determining the content of the storyboard, I first started with the scene design. Because I wanted the whole animation style to be like a stop motion animation, I put the scene on the table.

Since then, I have referenced a lot of tabletops and hand-drawn the desk designs.

My first consideration is that the tabletop can’t have too many lights and meshes. Because I have to consider the rendering time, after all, the time of the job is limited.

Here is my design.

There is a window behind the desk and a shutter in front of the window.

The sun will cast a lovely shadow on the table through the shutter.

The monitor in the middle will also play videos.

The keyboard on the desktop will be used for character interaction.

The pegboard is used to add detail to the scene.

Problems occurred in the process of material collection.

Rat as a character model is too rare in the existing animation industry.

All models I can find on SketchUp are not too accurate or not good-looking.

None of these models fit my requirements.

So I changed the storyboard to storyboard 2.0

The new storyboard tells the story of a toy figure.

The protagonist discovered a treasure during the expedition, but the treasure was kept inside a glass. For the scene here, I kept the setting of Storyboard 1.0. The protagonist pulled the trigger after hesitating, and the glass shattered. But unexpectedly, protagonists are actually prey.

Project_01

<1,0,0 Birds>

Project_02

<Hunter>

https://vimeo.com/722190600

Working on the Storyboard

This storyboard tells a story about gun violence.

A mouse tries to get the cheese by smashing a glass bottle with a rifle after finding it. The inspiration here comes from the cartoon Tom and Jerry. But the mouse didn’t expect its partner hid behind the cheese, so the mouse who shot it accidentally killed its partner.

The story is straightforward and looks well implemented.

I divided the content of the storyboard into the following parts:

1 Build the materials needed in the scene, such as models of cheese and jars.

2 Download or mode the ret character model.

3 animate them in Maya.

4 Simulating glass breaking in houdini.

5 Render in octane.

Procedural Art

The earliest ideas came from some mottled patterns, and when you put circles of different colours together, it often makes for some quite beautiful patterns. But this tends to look a bit monotonous. Dynamic art may look more interesting.

(Windows Bubbles)

Also, there is a kind of moving bubble between the screensavers from Windows that is very interesting.

By combining the two types. Also, add a way to make the bubbles feel more active.

Turning a normal bubble into a nesting of bubbles and bubbles. The bubbles inside can move the bubbles outside.

The player can decide the colour and number of bubbles.

To make the whole collision process surprising, the direction and force of movement are created randomly. This way each collision is unpredictable.

Feedback

The majority of players found the collision method interesting.

Some players wanted to be able to manipulate the direction of the collision.

Some players would like to have more choices of the colour palettes.

So, it is possible to add the option of automatic collision and manual collision to the game, with players. On the basis of this prototype, it might be possible to allow players to export these versions to be designed as screensavers or desktops.

Unity Engine

Personal aims and objectives

The game is a very simple game where the objective is to get the ball to the end of the level and to pass the level.

Most physics-based games are controlled via the keyboard, but the mouse was chosen as a way to change the input method.

In the end, the drag-and-drop method was chosen, which allows the player to control the direction and force of the shot. The first levels are relatively easy, as the player just keeps shooting towards the end. In the later levels, the player has to control the ball as carefully as possible to avoid obstacles and reach the end.

Feedback from playtesting

I asked my friends to playtest the game.

By observing their performance, I found that they were very comfortable with the drag-and-drop style of control and that it was easy to pick up and play the character in a few minutes.

In terms of level design, there was no problem with the difficulty design. Players generally responded that the third level was a little difficult.

It was also suggested that there could be some adjustments.

As a prototype to test this approach. I think it’s still very good. There is still a lot to improve in terms of level design. If we would create another mechanic in levels that could interact with a drag-and-drop shooting method. I think that could definitely make the game more interesting.

No component

For developing a game without a component there is actually still a big challenge.

This is because the history of the game is old enough. There are all sorts of different no component games from all countries. It seems that all games that can be thought of have basically been discovered by everyone. There are basically two types of games. Linguistic games and games that use body language.

I think the most fundamental behaviour of people in these games is interaction.

People communicate with each other through words or body language.

Through these messages, they compete or cooperate to achieve the same goal. For example, saying the same word.

I wanted my game to be easy to test, so I set the number of players to two.

The rules of the game are very simple

After a countdown of three, each player reaches out a hand. The player needs to points with one finger in one of four directions: up, down, left or right. Two players choose their direction at the same time. If the directions are different, then continue and restart the countdown again. If the directions are the same, the players need to clap as quickly as possible. The first person to clap wins. If someone makes a mistake and claps when the directions are different, he loses.

Tips: Some misdirection techniques can be used in this game, such as moving the hand downwards but actually pointing the thumb upwards.

I would still really like to improve this prototype or come up with some new ideas for a no component game. I think I need more feedback to help me improve it.

Avoid and Collect

Personal aims and objectives

The game is a avoid and collect game. Since the theme was already in place, I hoped to be creative. After playing several games in the genre, I didn’t choose to innovate in terms of avoiding and collecting items, as many games already do it very well. So, I decided to try to be creative in terms of mechanics.

In my game, I have deconstructed the whole theme.

So, the left half of the game is about dodging and the right half is about collecting.

Often in this type of game, the player controls one character.

This time the player has to control two characters that move simultaneously.

I hope that this will create a different kind of experience for the player.

Feedback

Some of the players are good at this type of gameplay, they can do both screens at the same time and find it more interesting, they expect to have more areas to control, 3-4 screens or something like that.

Some players are not so good at this type of action and feel it is a strange way of doing things. They tend to concentrate on one screen only.

Taking these comments into account, I adjusted the levels a bit and separated collecting and dodging as much as possible. The player-controlled character is perfectly safe on the levels where he collects. So even if the player is not comfortable with this way of controlling, the game can be played at a slow pace.

Narrative

The starting point of the game is the future of the game designer.

A large part of this game is actually part of my anxious thoughts right now. I don’t know what I’m going to do in the future.

Even if I can master some skills as an indie game designer, will I be able to continue as an indie game designer afterwards. I wanted to use this game to document this part of my thoughts.

Ideas: Even if you learn about game design now, you may not necessarily get into a game-related career afterwards.

If you are lucky enough to be in a game-related industry, or if you get into a company, there is a good chance that you will follow someone else’s idea for a game. Life will gradually remain the same, it would make people unable to escape from such a whirlpool. Eventually, it’s just about working for money. If you are really lucky to become an indie game designer, the first thing you will worry about is whether you are able to design and implement a game on your own and make a living out of it.

There are many challenges, but not so many that can be reflected in the game. There are only four endings, one for success and one for failure at a game company or as an indie game designer.

At the branching options for the good and bad endings, the player is not given any other hints and is expected to choose purely by luck, as if you never know what will happen next in life.

Feedback

Those who have played the game have had more fun with the relatively short game animations.

The more curious players will try a few more times to check out all the endings.

Most people like this game.

Interactive Picture

Personal aims and objectives

I saw some animations of anthropomorphic characters and I thought about some interesting ideas for keyboards.

What would happen if the keys on the keyboard were anthropomorphized and met each other.

For example, if ctrl+z can be used to undo an action, then when ctrl and z meet, they will return to the previous position.

I thought this would be an interesting way of inputting and a game that would show people some of the shortcuts they don’t often use. In the process of making it, I found that it would take a very long time to animate each of the shortcuts separately, so I ended up changing the format. Instead of animations, the shortcuts are shown in the text.

Feedback

In the process of making it, I found that it would take a very long time to animate each of the shortcuts separately, so I ended up changing the format. Instead of animations, the shortcuts are shown in the text.

Feedback

Some people thought it was a fun little piece of work and people generally liked it.

There are still a few key combinations that can be entered and players would like to have more combinations.

If I had enough time, I would prefer to create some interesting animations for the shortcuts.

This Showreel is recorded by live gameplay.

溯 Reverse

Sun Anqing(Game Design)

Wang Zixuan(Game Design)

Wang Zhiming(Game Design)

Yu Tong(Game Design)

Yan Xue(3D Animation)

Wu Yuanhang(3D Animation)

Download: https://anqing.itch.io/reverse

=============================================

First-person controllers require the Camera to respond to mouse movements (X Y).

This function sounds easy, but not because I debugged it for hours.

First, I break down this function into 3 parts.

• Mouse horizontal movement pan the camera.
• Mouse vertical movemnet control the camera looking up and looking down.
• Set a limite to camera vertical rotation angle. (Prevents the camera from being able to rotate infinitely vertically)

 void Cam_Rotate()//mouse control camera looking around
    {
        float h = Input.GetAxis("Mouse X");
        float v = Input.GetAxis("Mouse Y");
        if (h != 0)
        {
            this.gameObject.transform.Rotate(0, h * Time.fixedDeltaTime * RotateSpeed, 0);//RotateSpeed is a folat variate
        }
        if (v != 0)//Actually it a stuped way to set a limit to the camera rotation anglem, because i used 4 if here.
        {
            if (FirstPersonControllerCamera.transform.rotation.eulerAngles.x< AngleLimit && FirstPersonControllerCamera.transform.rotation.eulerAngles.x<180)
            {
                FirstPersonControllerCamera.transform.Rotate(v * Time.fixedDeltaTime * -RotateSpeed, 0, 0);//set camera rotate
            }
            else if (FirstPersonControllerCamera.transform.rotation.eulerAngles.x > (360- AngleLimit) && FirstPersonControllerCamera.transform.rotation.eulerAngles.x >180)
            {
                FirstPersonControllerCamera.transform.Rotate(v * Time.fixedDeltaTime * -RotateSpeed, 0, 0);
            }
            else if (FirstPersonControllerCamera.transform.rotation.eulerAngles.x <=(360- AngleLimit) && FirstPersonControllerCamera.transform.rotation.eulerAngles.x > 180)
            {
                FirstPersonControllerCamera.transform.Rotate(0.5f, 0, 0);
            }
            else if (FirstPersonControllerCamera.transform.rotation.eulerAngles.x >= AngleLimit && FirstPersonControllerCamera.transform.rotation.eulerAngles.x < 180)
            {
                FirstPersonControllerCamera.transform.Rotate(-0.5f, 0, 0);
            }
        }
    }

The code above works but can not satisfy my demands. Because the solution I achieve setting the angle limit is when the angle achieves the maximum value, the angle will sub 0.1 degrees. So the play will find the view shaking when they try to look up or looking down, just like the video below.

However, Github gave me a suggestion to use the method (Mathf.Clamp) provided by Unity Engine. As we can see in the video below, the view is more shaking.

void CameraRotate()//mouse control camera looking around
    {
        YLimited += MouseY * Time.deltaTime * RotateSpeed;
        FirstPersonCamera.transform.localRotation = Quaternion.Euler(Mathf.Clamp(YLimited, 45, 135), 0.0f, 0.0f);
        transform.Rotate(0, MouseX * Time.deltaTime * RotateSpeed, 0);
    }

As we can see in the code above. Mathf.Clamp limit the
variate Withing 45 and 135, And this solution will not cause any view shaking.

Some notes I made during the building of the FPP controller.

1.

There is the controller layers screenshot.

The character is the FirstPersonCamera’s parent. FirstPersonCamera is an empty object used to adjust the angle of the Camera. Because without this empty object, the Camera looks up 10 degrees, the Camera’s rotation is 350 degrees, and the Camera looks down 10 degrees, the rotation of the Camera is -10 degrees. In this way, I can not use Mathf.Clamp.

When the mouse movement is horizontal, the character will rotate around the Y-axis. The empty object FirstPersonCamera will rotate around the X-axis when vertical mouse movement.

Ok, I have achieved the first function.

After the function Camera looks around, here I come to the translation.

First, I break down this function into 2 parts.

• The player is grounded.
• The player is not grounded.

The second condition is easy to figure out, just set the character translation on Y-axis negative direction until the player is grounded.

Only if the character is grounded