The next assignment, in extend to last one, requires me to transform the bixi thinggie to a set of weapons. It is actually up to me to do how many of them. I went to a family trip during new year break, in the middle of production, which was inevitable :p. Rather than rush it to the end, I and my professor agree that I will take the time to polish one weapon to perfect.

Let’s go back to some earlier sketch:

The whole bixi thing is a laser pod. The canons are embedded into a monument and stood at the back of the bixi shell. The end result will be sth like this:

 and this…

Thanks to an art history trip happened shortly before this, I got some insight of the canon body pattern.

General process. From the previous assignment, I got some idea on the workflow. And this time I want to further explore different ways of working, including actually sculpting the surface and making use of bump map for the detail. The bigger middle ring with sandy surface is actually sculpted with a mask image. The flower motif medelions are made with bump map. Obviously bump map look a lot better :p

Last time Kevin did a great job on his jade pillar. I think I can give it a try too. Why not? I put a dragon at the mouth of the canon. The sculpting was so much fun. I was on fire.

And the result of the whole thing:

Very quickly proceed to the monument and bring the whole thing together. I was kind of having trouble on the lighting. Last time I was using object based lighting for the bixi texture. But this time didn’t. When I bring them all together, the bixi part was extremely dim. The lighting utility in mudbox is quite primitive. It took me sometime to figure out how to brighten the lower bixi, while not over lightening the upper shinny canon.

ENOUGH MUDBOX! NEXTTIME! ZBRUSH FINALLY!

I am modelling the foundation with Maya still, feeling more controlled with that.

SEND TO MUDBOX yeah. oh no. problems. Time to clean up. I might need to correct my way of modelling somehow.

How is it look like in Mudbox, and final results. I should not say Mudbox is an easy tool. But it is extremely easy to start with. The interface is pretty much intuitive. It has photoshop layering mechanic. We worked together in the lab one night. Everybody are their first time with the tool. Everybody share what they got. And the other day everybody were happy. The body texture is imitating some kind of rough granite.

Finally the monument at the back. The characters are actually sculpted with the mask tool and an image as stensil! not BUMPED!

I did not make it to the weapons and laser pods. Let’s leave it to a later assignment which i will make weapon.

Can’t believe I complete the production in just two days, including learning the tool!

final render:

After a bit of extruding, scaling and finally putting the “rod” to lattice deformer. Yay there you go!

Lattice deformer is extremely handy to create organic form after you have the basic form. The only thing I am worrying about is the faces may have crossed by each other if the distortion is over while i am not paying attention.

While I am kicking off my unwrapping journey, ultimately unwillingly, Melissa brought us interesting tool to look at: the Mudbox. As the assignment did not specify any restriction on method. why not try sth new! I am always happy to hv potential shortcut.

This is insane. I felt like the effort we put in early quarters in texturing with photoshop were wasted. Of course the case is not like that. But this painting way and the brushes are just too easy. Mudbox even has an interface similar to photoshop, particularly the layer part, but in 3D. I KNOW! THEY ARE ALL JUST TOOLS!

Container City (proposed name)

Container City is a 3D puzzle game inspired by an architectural project: Container Tower by Ova Studio. In the game, the player controls containers, which are units of a building, to fit into a structure. The structure is a building where residents will move in. The better the structure is satisfying the requests of the residents, the higher the popularity of a structure, hence more residents will move in and more money can be earned. The player can also design, sell and trade their containers with other players through social networks. The player will gradually build up a collection of buildings, which display as a city.

Vision: Container City becomes the most active social game in the world.

Platform: Smartphones, iOS and Android. Network access is not required but recommended.

Player(s): Mainly single, but player can interact with other players online.

Genre: Puzzle, Simulation (GOD game), Strategy, Social, Casual game.

Target audience: ages from 16 to 30. Elder teens to adult, male or female.

Background

Container Tower is an architectural project of OVA Studio. A Container Tower is constructed by fully portable and customizable units. Along with a core units utilized with an elevator, the containers in the shape of cargo are slotted horizontally into a grid made of steel beams. The containers can be built somewhere else and assembled on-site. They are fully portable and flexible. A container can be removed on demand, shipped to other places and fitted into other similar structure. The containers are also fully customizable within the given form factor. They can be manipulated into different functional modules, including but not limited to: residential, office, shop and leisure. Customers can design their own combinations and slot the design into the structure efficiently.

In the game the player is creating his own container tower through challenge. The player will see various residents gradually move in and receive rent from them as feedback. The player will develop an emotional attachment by owning and managing his own creation. The ownership and reward are the positive reinforcement to encourage the player to play the game. The progress of the player can be measured by continuous growth of the city and the growing income rate. He is also motivated by competing on a leaderboard with the coins he have.

Philosophy of Design

The game is designed based on the following philosophy.

Control and Ownership:

Casual games like Tiny Tower have their magic in hooking the players to keep playing. First there is certain randomness that the player will not get his desirable items too easily. To seek for more control, a player will follow a given progression. Second, as the player created his collection after overcoming challenges, he can go back and admire his own collection. There is a sense of completion received by the player. But the game does not stop. The player will move onto other layers of gameplay and motivated in some other ways.

Motivation:

Competition is one of the major motivations used in this game. All the progress is concluded into a metric and it is put on a leaderboard. The player will figure out a strategy and habit of his own to achieve better performance in order to compete with players around the world and friends.

Social game

By linking the player to the city of their friends, he will be provoked by his envy when he sees something his friends own but he does not. On the other hand he will feel superior if he owns something his friends do not. Players can also work together to achieve more.

The players will extend the magic circle of the game from virtual world to real world by group discussion. Social game can get into the everyday life of the players and the players will keep going back to the game in order to maintain the circle. The clichés and psychology in social game can enrich this game dramatically.

Overview

This game is inspired by the pre-built and on-site assembles properties of the Container Tower. The player will launch a unit, see it flies toward an empty slot on the structure, and stop its movement at a right timing to fit it in an appropriate place. The tension of the player is created by two factors:

1. Chance of misplacement. Player needs to stop the moving containers at a right timing, or it will be misplaced, or even worst, lost permanently.
2. Randomly appeared containers. Each container has its value and the placement of the container should somehow fulfill the request of the residents in order to increase popularity (performance). The player pays to enter construction mode, but the containers are given to the player randomly. As each container is valuable, how to manage the placement becomes a challenge to the player.

The player gains more control to the container as he progresses.

Residents start to show up and move into the tower. The player will see they wander around everywhere in the tower. They will ask the player to solve their request occasionally. If they are satisfied, Satisfaction points are offered to the player. Resident’s satisfaction increases income amount and rate of residents moving-in, as a reward to the player. The Player uses coins earned to buy one-time assist items, upgrade and specific types of containers, resulting more accurate management of the containers. The difficulty shifts from controlling the containers to managing the residents strategically, so as to increase income.

The containers are categorized into 4: residential, office, shop and leisure. Residents will request based on these functions. For example a resident will request an office and garden next to his apartment. However, any new resident will request for an apartment first. Shop containers will also attract non-residents to come and add income to the player.

City Layer

The game will move to a higher layer as the player completes a utilized building. The player can move around the map and start another building according to residents’ request. The residents start to request for moving their apartments around the world. The requests from residents are offered randomly but within a frame of the player’s progress. The city will soon grow into a building collection gallery of the player. The player can anytime revisit and edit each of them. Settled residents generate continuously income for the player.

Decoration Layer

The containers have their own skin which comes randomly. The player can pay a tiny amount of coins in order to re-skin it instantly, or pay more coins in the market to buy a desirable container. However the skin is almost totally an appearance issue. Only a few residents will request for specific type of skin, and those requests only come after the player reaches certain progress.

A furniture shop will be offered to the player after a patch. The player can buy furniture to decorate the interior and exterior of each of the containers. Again, it only affects the appearance of the containers. But the decorated container will become the player’s own collection. The player can share and trade with his friends to earn more income, or simply show off.

Market Layer

The Online Market shows the containers posted for sell by players around the world. Container bought in the market will be stored and ready to be used. The player can also post their containers for sell in here.

Gameplay

Initialize:

At the beginning of the game the player will start in a tutorial stage in building mode. A resident shows up at the left bottom tells the player he wants a basic apartment to live in. An empty frame of a container tower stands in the middle of the screen. A basic apartment container appears at one side. The player is guided to place it. If the player fails to do that, new container will appear until the player succeeds at least one time. When the player fails, the resident will be scared and collapses, and returns to normal as another container shows up. The resident thanks the player with a pop up dialogue after his success and moves in. The player will see him wandering around the apartment. The player continues building until ten random containers are used up. The player will move onto an inventory screen and guided to buy another 10 random containers in order to enter the building mode again. The player is told that if a request of a resident is satisfied, the SATISFACTION meter will rise. More residents will move in the tower according to the meter. It is basically the end of the tutorial mode.

Instructional rules:

The player taps the rotation wheel at the bottom to turn the structure 90 degrees.

The player holds and drags the container horizontally and vertically to aim at a desirable slot.

The player single taps any empty space to launch the container. Single taps again to stop. The container will snap into the grid automatically.

If the container is stopped too early or lately, it falls. If the container hits an existing container at the edge, it also falls. Fallen containers are lost forever unless they are retrieved with an item.

When there is a resident’s request, the player does not need to respond to it immediately. But there will only be one request at a time for each tower. If the request is fulfilled, the resident will thank the player with a pop up dialogue box. Satisfaction increases after the player confirms and closes the dialogue box.

A pop up dialogue box shows when there is resident moving in. The player will see the resident wanders around after he taps confirm and closes the dialogue box.

Rent from the residents will be generated at the end of each day in real life (or the first time the player starts the game in each day). Rare residents received randomly at a low chance or through special request increase the total amount of rent received each time.

City View:

City view is unlocked as the first apartment is 80% filled with containers. The first resident (in the tutorial) will request to move to another city. The player will be guided to buy item-“container unslotter” from the item shop. Only container with at least one side facing void space can be unslotted, so the player may need to redo several times. Unslotted containers are stored in the inventory. The player can use them to start the building mode anytime they want for free. The player will see the city view. In here he can tap the second city to unlock for free to start another tower. The player selects the unslotted container from the inventory and slots them in the new tower to earn the satisfaction points. The game moves on.

In city view, the player can buy new city to start new tower. But each time a new city is bought, the next one will be more expensive to buy.

The player can go back to each tower he built to add or unslot containers. Each tower has its own resident’s request and each can have one at a time.

Item shop:

In here the player can buy one-time-use items and tools. They are mainly tools to assist the player in building and controlling the containers. They are not free. As the player gains money more effectively (as he progress), the items are no longer expensive compare to how they appeared at first. The player will buy and use the items more frequently at later stage. Bought items will appear in the inventory. The player needs to choose them before entering building mode in order to use them.

The items are as follow:

Unslotter – $100 – removes a container and places it into inventory. If an apartment with resident living in is taken down, the resident will stay with the container, but will not pay the rent

Unslotter ultima – $ 5000 – returns all containers in a tower to the inventory

Freezer lv1 – $100 – slows down the next container slightly

Freezer lv2 – $1000 – slows down all containers slightly before exiting building mode

Time machine lv1- $1500 – slows down the next container significantly

Time machine lv2- $15000 – slows down all containers significantly before exiting building mode

Safe net lv1 – $1000 – protects the next container from losing permanently. Fallen container returns to the inventory

Safe net lv2 – $ 10000 – protects all containers from losing permanently before exiting building mode

Rental ads – $ 10000 – boosts satisfaction by 50 for half an hour. More frequently the residents move in and shop in facilities

Repossession officer – $5000 – kicks a resident out of a container. The resident will be lost permanently

Initiator – $5000 – initializes a tower into its primitive state. All containers and residents will be lost permanently

God’s Hand – $100000 – retrieves the last lost container.

Resident and request:

Normal residents move in randomly. But there are special rare residents that move in with a less chance. They have special personality such as paying higher rent, requesting more frequently, requesting with a pattern, generate more satisfaction point, etc. Bellows are examples:

Busy business man – always request to move in between cities.

Oil King – Ultra rare resident. Pay the highest rent. Appears only after the player acquired more than 5 cities. Moves into apartment attached to 10+ leisure containers.

Big family – Pay high rent. Requests to attach 5 apartment containers to each other.

Shopaholic – only requests shops attachment. Shop rapidly.

Property reviewer – various requests, but generates more satisfaction than other residents.

Requests can be categorized into 3:

1. To particular types of containers near each other.
2. To move a container or set or containers to other city
3. To decorate a container in a specific way, eg, put certain furniture in. (will not appear before decoration is unlocked)

Friends and network:

In this menu the player will connect with Game Center and Facebook to see a list of friends also playing this game and visit their city. The player can also invite friends to join the game and share his city and tower view to social network.

Online Market:

The player can browse the containers the other players worldwide posted on the board for sell. The earning rate and residents’ abilities are also shown. The player can also sell the containers from his inventory. Notes that residents can be sold along with the apartment they are resting in.

Leader Board:

Money is the major measurement of progress throughout the game. This metric is put onto a leader board to compete against all the players worldwide. At later state of the game, spending on items are no longer any obstacles to the player but necessity. The player invests money in expanding the city (acquiring more cities), kicks out residents who pay less rent, and creates combination of containers to maximize income/day. The ranking on the leader board can change dramatically after each action the player plays.

Balance and Progress:

This game is set up to have a higher difficulty at first. The player does not have much income. Random containers are more affordable. A container is launched with a high speed. The player has less control at first because the assistant items are all quite expensive to them at this state. After his city grows to a level he has regular income, he can afford to buy more items in order to build more accurately. At the later state, the cost of the items is no longer a matter to the player. The player gain better control in the building mode. The challenge in this mode becomes minimal. The game dynamic shifted to management and competition. The income will go on increasing. (refer to graph 1)

Graph 1.

Graph 2 explain how exactly is the game dynamic shifting. Income in the game mainly comes from resident’s rent and shop’s earning. At the first half of the game, the total number of residents and shops can be boosted by acquiring more towers. The player will receive occasionally rare and powerful residents but the growth of the income is generally stable, until the number of towers reaches its maximum. The player has already gained a good control in building a tower. The player will start optimizing his tower by exploring more efficient earning combination of apartment and shops, and more powerful residents. The player will take down older structure he built in earlier stage of the game and create new ones. He will also kick out (or sell) residents who are not good enough (not generative enough). In result of that, the income somehow drops, but rises shortly after. The player will also be more aggressive in earning, so that he can get to higher place on the leaderboard.

Graph 2.

References

Stack3D. This game is kind of a 3D Tetris game which a player rotates the base to catch Tetris blocks falling from above, and eliminate by completing a row. This game is a major reference in the appearance of the building mode. This game and Container City are similar in the way they show a structure in 3D and the player fit 3D blocks into the structure.

Tower Bloxx. This game is an endless height building game. A player tap to release a block hang swinging by a giant clamp. The player overcomes challenge by learning how to get a best timing to release a block. After each building, the player will move to a city view to see all the building he built. The performance of the player is reflected by total number of residents move into the blocks. The player can take down worst blocks and rebuilt again. This game is a reference model for the building mode and city view gameplay mode.

Tiny Tower. This game is also an endless building game by Nimbblebit in 2011. This game has almost every properties of the items in the game come in randomly. A player has almost no way to control what they can get even by paying cash or in-game cash. The player is hooked by the adorable little residents in pixel style, a well-controlled pace of progress and their desire on getting their desirable items. This game is surprisingly successful and it becomes well received.

Restaurant City. This is a facebook social game by Playfish in 2006. This game is a simplified management and building game, which player collects ingredient to level the dishes in the restaurant, serves customer to earn coins and decorates the interior as he wish. This game is a reference for its social gameplay elements.

I also made use of a game idea I created last quarter as the content. It is a game that the player hit and replace obstacles on the map with good road, so that a truck can pass through to send resource to poor villages. I simplified it to a demo within a given time frame.

If a frame is already working, it requires courage to start changing the code. It is sad to see errors come out again. The worst case is I added many lines of codes but the program is not running in any ways and I cannot change it back. For this biggest program I have ever made in this quarter, I back up a version each time I successfully implemented a features. The process is as follow:

1. Tile map (last time) + Keyboard control character

2. Character with animation

3. Collision and logic <- change a tile to something else when touching it

4. Create the sprite sheet for the tiles and walkcycle of the character

5. Add another class for the truck and load an image into it

6. Make the truck move.

This is how the game looks like at the moment:

However I did not reached step 6 before the deadline. But that should not be hard. I can reuse the code for collision detection from the character.

Knowing what is going on with the code is actually very enjoyable.

Clipping a sprite:

No wonder why each time I was looking for animation for sprite, it always comes in a sprite sheet. I needed to crop each of them out with photoshop in order to import into Scratch. That is because the image can only be loaded once, and reused many times in the program. If any animation is involved, only the clipping plane is being moved (or the image behind the clipping mask is being moved), instead of swapping the whole image into something else. The following code is the animation for the dot (character). It has multiple frames when it is facing left and multiple frames when it is facing right respectively. Same method is repeated for the truck and the tiles. But the tile is a bit different. It is clipped according to its type. Changing the type of the tile is actually changing the position of the image.

clipsRight[ 0 ].x = 0;
clipsRight[ 0 ].y = 0;
clipsRight[ 0 ].w = DOT_WIDTH;
clipsRight[ 0 ].h = DOT_HEIGHT;

clipsRight[ 1 ].x = DOT_WIDTH;
clipsRight[ 1 ].y = 0;
clipsRight[ 1 ].w = DOT_WIDTH;
clipsRight[ 1 ].h = DOT_HEIGHT;

clipsRight[ 2 ].x = DOT_WIDTH * 2;
clipsRight[ 2 ].y = 0;
clipsRight[ 2 ].w = DOT_WIDTH;
clipsRight[ 2 ].h = DOT_HEIGHT;

…

clipsLeft[ 0 ].x = 0;
clipsLeft[ 0 ].y = DOT_HEIGHT;
clipsLeft[ 0 ].w = DOT_WIDTH;
clipsLeft[ 0 ].h = DOT_HEIGHT;

clipsLeft[ 1 ].x = DOT_WIDTH;
clipsLeft[ 1 ].y = DOT_HEIGHT;
clipsLeft[ 1 ].w = DOT_WIDTH;
clipsLeft[ 1 ].h = DOT_HEIGHT;

…

 <– the sprite sheet of the character

 <– sprite sheet for the tiles

 Sprite Animation

In each fps of the running program, the sprites are re-evaluate according to its number of frame, then move the frame by 1. In the following code, a function apply_surface is called in each frame in order to render the image with its clipping box and mask. A simple logic is applied to determine it is left or right and pass it to the function. When right or left key is pressed, the x position is added by a positive or negative velocity. Facing left or right can be determined by the direction of the velocity. And the frame of the sprite is looped. It is following the same logic as in Scratch.

if( status == DOT_RIGHT )

{
apply_surface( box.x – camera.x, box.y – camera.y, dot, screen, &clipsRight[ frame ] );

}
else if( status == DOT_LEFT )
{
apply_surface( box.x – camera.x, box.y – camera.y, dot, screen, &clipsLeft[ frame ] );

}

Collision

The collision checking function is surprisingly similar to the one I made for Bomberman I made for previous assignment with Scratch, like comparing the x and y of object a and b to see whether they are overlapping and at which side. But this time the logic blocks are code in the form of function. Another function touches_wall is calling the check collision function and determine what the character is actually touching and return true or false. The original calling is to stop the character by adding and deducting the speed at once when it hit a wall-type tile. I change it to changing the tile type of the tile it hit. I was trying to create a new tile to replace the old tile. But that did not work. And changing the tile type is the right way to achieve the effect I want.

bool touches_wall( SDL_Rect box, Tile *tiles[] )
{
//Go through the tiles
for( int t = 0; t < TOTAL_TILES; t++ )
{
//If the tile is a wall type tile
if( ( tiles[ t ]->get_type() >= TILE_CENTER ) && ( tiles[ t ]->get_type() <= TILE_TOPLEFT ) )
{
//If the collision box touches the wall tile
if( check_collision( box, tiles[ t ]->get_box() ) == true )
{

//return true;
tiles[ t ]->type = 0;

}
}
}

//If no wall tiles were touched
return false;
}

 Load image

loading an image is more complicated than I think. At first I simply copy all the codes for the character and replace all the variables with the truck’s one — without test running it. After I completed, it somehow did not work well. The truck image clashes the memory of the tile and everything messed up. I went back to a back up file and started up from the beginning step by step. But it already took me several hours. T_T

===================division======================

At the beginning of the quarter I started from Scratch, using ready made logic block without knowing what is within. After a quarter of learning, I can finally repeat the process with codes and library. Of course if I can do the same with a easier way, why do I need a more complicated way? But it is a learning process. I feel like I can program whatever game I need to make now!

I intended to make this assignment a test of the logic I planed for my own other project. It is a pipe connecting game which a player can tap and rotate a pipe tile to connect them into a complete water way. The logic is not limited by the platform, if I can test it out and make that an assignment, why not? Smart hah!

We need to start with a flow chart this time. I have that every time so no worry. I have a brief lecture from my professor and he told me I can save many work if I replace the array with a class and make use of function with the class. I should have learn that when I was learning Java and I sort of need that for Actionsript 3.0 seven years ago. But at that time this was not covered in the course and I was into something else so I terminated my progress in learning programming. I know that I need to learn that some point in my life and this is the chance.

The product is a simplified pipe attack with just one row. I am testing out the logic so rows number does not matter. Everything is going smoothly until I am parsing a class into a function. I admit that my foundation is not good. This code simply don’t work:

output(a[]);

But at this moment I need to move on, so I went to plan B. Using switch can solve the issue. The logic still remain the same. But I am not making the process into a neat and tidy function. If I am making more rows I may have to copy and paste the logic to infinity. This is how it became:

The game runs like this: first input the row which the rotating tile belongs to. In here we have just one row, so A. Then the column. If they are all horizontal, you win.