Playing with Atoms

The Atoms of Total War : Rome II

In this game there a 6 core game atoms that when blended together provide a fluid experience that is both fun to play in the short term and provides a long lasting experience over the course of an entire game.

Empire Management:

Empire management is broken up into protons which are:

1. Empire management requires preparation in the form of planning your actions. 
2. The solid core mechanic is to manage your empire successfully.
3. There is a a range of challenges that you must complete on the empire level, including food management.
4. These challenges require various skill sets.
5. There is a feedback system provided through a empire score ranking.
6. Failure to properly manage your empire will result in disaster.

Province Management: 

Province management is broken up into protons which are:

1. province management requires preparation in order to decide what buildings to construct and what troops to raise in any one province, with the former effecting the latter.
2. The solid core mechanic is to create a province that can run by itself without too much micromanagement.
3. There are a range of challenges presented to the player including dealing with unhappy provinces which can lead to a rebellion, and provincial tax rate management.
4. These challenges require a good deal of though process and can often rely on your empire management as input factors.
5. The feedback system is provided through your province happiness and income.
6. Failure here would be denoted by losing your province to a rebellion or even a province that does not generate enough income caused by building to many buildings that effect on of the feedback values.

Economy: 

Economy management is broken up into protons which are:

1. Preparation is required in the form of thought on what type of economy you want to have.
2. The solid core mechanic is money because everything revolves around money. Well and food.
3. There a range of challenges thrown at the player from food shortages to insufficient tax revenue.
4. A player has different ways to deal with these challenges.
5. The way in which a player handles the challenges can effect the overall game.
6. There is a feedback system in place by listing your budget and food stocks.
7. The mastery problem is dealt with because there are effective and less effective techniques each harder to learn, but once a player masters them going back would be bad for the game.
8. Failure can result in food shortages which make regions unhappy, weaken armies and bankruptcy. \

Diplomacy:

Diplomacy management is broken up into protons which are:

1. Diplomacy management requires preparation because the player needs to carefully consider who he wants as allies, enemies or neutral relations with it.
2. The solid core mechanic is to manage your diplomatic relations in such a way that you can successfully defend your empire.
3. The AI will be provide a range of diplomatic challenges.
4. A range of diplomatic options are open to the player to deal with these options.
5. Unfortunately there is not much skill in using the abilities.
6. A feedback system is in place in the form of AI relations to you.
7. The mastery problem is not dealt with because there are a limited number of options and the AI responds to them the same.
8. Failure to have effective diplomacy would result wars that can cost you troops and regions.

Military Strategy: 

Military Strategy is broken up into protons which are:

1. Preparation is required to raise armies and decide on what campaigns you will undertake and how many at a time.
2. The routes you choose to move your troops and the locations you decide to attack will effect the battles so locations will be important.
3. The core mechanic is moving your troops around and placing them in strategic positions to benefit your cause the best.
4. There are a wide range of challenges associated with military strategy around placement and movement of your armies, as well as knowledge collection on your enemies and allies.
5. The player is given different tools to solve the various situations he will in. 
6. The better able the player is able to use the tools he has at his disposal the better his empire will preform
7. The mastery problem is dealt with because if a player uses poor strategies that are easy to learn they will not be as effective as harder to master by more effect strategies.
8. Failure can result in the loss of a region or armies which can set a player back greatly.

Military Tactics: 

Military Tactics is broken up into protons which are:

1. Preparation is required on the battle field so you can inflict many enemy causalities while minimizing your own. A player needs to deploy his troops intelligently.
2. The physical locations on the map will effect the battle outcome.
3. The solid core mechanic is the battle itself, everything revolves around it.
4. There are a range of challenges that the player will face that vary based on terrain, weather, buildings and the nation you are fighting.
5. A range of different abilities is required to solve the different challenges put forth.
6. Depending on the skill of the player he will be able to perform the abilities better.
7. The feedback system is in place in the form of a battle results screen.
8. The mastery problem is dealt with because if a player uses poor strategies that are easy to learn they will not be as effective as harder to master by more effect strategies.
9. Failure can result in the loss of a battle and many casualties which can also result in the loss of a city.

Grind Quest: Objectives

A list of my favorite games in no particular order:

Total War Series: The objective of this game is become the most power nation in the game, you achieve this through military, financial or shrew diplomatic means.

Diablo II: The objective of this game is to defeat the forces and hell and save the world from destruction.

Settlers of Catan: The objective of this game is to acquire 10 victory points before any other player. You achieve this by building villages & cities, gathering resources, building roads and raising armies.

Survive: The objective is to get the highest point value people to safety before the island is destroyed.

Empire Earth: The objective of this game at its most basic level is to defeat your opponent(s) on the field of battle.

Dungeon Siege: The objective of this game is to prevent the destruction of the world by the forces of evil.

Zombie Flux: The objective of this game is to be the player to who completes the current goal that changes and the game progressed.

Small World: The objective of this game is to collect money from provinces over the course of the game, at the end the richest person wins.

Minecraft:  There is no single objective to this game, you basically set your own objective based on what you want to achieve. For mean I like making complicated machine with redstone in Vanilla minecraft.

Pandemic: The objective of this game is to purge the world of various diseases and viruses.

Starcraft: The objective of this game at its most basic level is to defeat your opponent(s) on the field of battle.

Ticket to ride: The objective of this game is to collect the most victory points by building long railroads.

Civilization Series: The objective of this game is to rule the world through various means, whether by conquest, cultural or space race means.

So the first thing you will notice is I picked 13 games, in order for you to get a better picture of the type of games that I enjoy.

So what games do I enjoy, aside from breaking them down into real time strategy and role playing games, I tend to enjoy games that have epic goals like civilization and total war where games can take many weeks or months of time to complete. The strategy of these games really appeal to me. Of course I am a huge fan of real time strategy games, and I only listed two above, but really I have never met an real time strategy that I do not like. My favorite part of real time strategy is the story element, although I also enjoy the online competitive play. When it comes to liking role playing games I have more selective tastes, I prefer the more traditional older ones, than the new ones which try and do something new. The best ones are the ones that channel dungeons and dragons. Of course Minecraft gets it's own special category where I can basically do whatever I want, I prefer to play around with redstone and creating adventure maps. Nest we come to board games and card games. I am a huge fan of these types of games, the best times being playing them at my cottage with friends and family while enjoying some beer and the like. There are several categories that I like. There are the games where you have to collect victory points over a set period of time using various means, this appeals to me because I like the strategy and competition involved. There are also games like pandemic where the players are all competing against the system in order to obtained victory, the teamwork really appeals to me in this case. One of my favorite games is zombie flux where you are a human trying to survive the zombie apocalypse. The game is a funny more than a serious game, with lots of jokes hidden throughout the cards. Survive is another good game where you play as a group of survivors trying to escape the the destruction of Atlantis to the surrounding islands, you have to navigate the dangerous seas filled with sea monsters, whales and sharks.

That pretty much wraps up my favorite games and why I like them.  

A Course as a Game, Awesome!

Introduction:

Let’s start off by talking about how excited I am about how Game Design II is being run; I am a huge proponent of bringing games into the class room. I strongly believe that this course will be a blast to participate in. One of the reasons I am really excited is because I am looking towards doing a masters focusing in on Serious Games and Education. I will be watching this class closely and taking plenty of notes that I can reference in the future.

This course is formatted as a game where we the students create our characters and enter the world know as the “classroom” where we will have to complete quests, slay monsters and craft wondrous creations in order to gain fame and fortune in the form of experience on the long path to our ultimate goal of being a Game Design God.

Details:

We each get to create a basic character, which includes a name, class, and a set of skills that embodies the character.

There are 20 levels that we can earn as we gain more experience, each of these levels has a title that our character will carry with them as a badge of honour. As we level up we also can acquire additional skills for our character.

There are a total of 19 (currently) different tasks we can complete in order to earn experience for our characters.

We are required to form a guild

Issues:

Any new idea is not without growing pains and there are some here from reading over the course design.

I am concerned that the experience is not any kind of mathematical function for increasing progress, the numbers are intelligently, but almost randomly picked.

I am also concerned with how many experience items are weighted, and while I understand that some kind system is required, I do not believe weighted experience is always the best option. I would prefer using an approach where the goal for each task is more clearly defined which would remove uncertainty from some of the tasks. Now some of the tasks are well suited to weighted experience; for example the final game design presentation.

I would also like to see more diversity in the ways to earn experience and to have more options, where players have multiple ways to reach the max level much like in most Massively multiplayer Online Role Playing Games.

Conclusion:

Overall I think this course is going to be a good test case and a lot will be learned and changed as the course goes on. I am really looking forward to this course and it is going to be a fun ride.

Why Raw Input?

Lets talk about RAWINPUT and why it is a useful tool for any game engine programmer to understand.

So what is RAWINPUT?
Well it is an alternative to using the standard method Windows input method, it provides methods for not only accessing the keyboard and mouse, but any HID device.

Before the RAWINPUT API was implemented you had to according to MSDN:

To get input from the unsupported HIDs, an application had to do many things: open the device, manage the shared mode, periodically read the device or set up the I/O completion port, and so forth. The raw input model and the associated APIs were developed to allow simple access to raw input from all input devices, including the keyboard and mouse.

RAWINPUT is different that the standard windows input which relies on posted messages which means only devices that Windows implements handling for can be handled. With RAWINPUT the user needs to according to MSDN.

for raw input an application must register the devices it wants to get data from. Also, the application gets the raw input through the WM_INPUT message.

Lets talk about how to implement a basic RAWINPUT setup in code.

This assumes you are already using the Windows API for creating and opening a window and have a basic knowledge of the Windows API.

The first thing you need to do is register the input devices, for this example I will be sticking to just the mouse and the keyboard.

      RAWINPUTDEVICE keyboard;  
      RAWINPUTDEVICE mouse;  
      keyboard.usUsagePage = 0x01;  
      keyboard.usUsage = 0x06;  
      keyboard.dwFlags = NULL;  
      keyboard.hwndTarget = hWnd;  
      mouse.usUsagePage = 0x01;  
      mouse.usUsage = 0x02;  
      mouse.dwFlags = NULL;  
      mouse.hwndTarget = hWnd;  
      if(!RegisterRawInputDevices(&keyboard, 1, sizeof(RAWINPUTDEVICE)))  
      {  
           Logger::getInstance()->write("Failed to register the keyboard device");  
      }  
      if(!RegisterRawInputDevices(&mouse, 1, sizeof(RAWINPUTDEVICE)))  
      {  
           Logger::getInstance()->write("Failed to register the mouse device");  
      }  

After this you need to handle the input as part of the windows loop. All you need to do here is add an additional case to handle WM_INPUT, then you can break up the input into a type and pass it off to whatever handlers you want.

    case WM_INPUT:  
           {  
                RAWINPUT InputData;  
                UINT DataSize = sizeof(RAWINPUT);  
                GetRawInputData((HRAWINPUT)lParam,  
                                    RID_INPUT,  
                                    &InputData,  
                                    &DataSize,  
                                    sizeof(RAWINPUTHEADER));  
                if(InputData.header.dwType == RIM_TYPEKEYBOARD)  
                {  
                     // Pass InputData.data.keyboard to your keyboard handler
                }  
                if(InputData.header.dwType == RIM_TYPEMOUSE)  
                {  
                     // Pass InputData.data.mouse to your keyboard handler. 
                }  
                return 0;  
           }  

In order to handle the input data you need check what value the Vkey variable is. Here is a condensed list of the most common keys. for a more complete list check Here. The following is for the keyboard.

  0x08 // BACKSPACE key            
  0x09 // TAB key            
  0x0C // CLEAR key            
  0x0D // ENTER key       
      if(MakeCode == 0x1C && Flags == (RI_KEY_MAKE|RI_KEY_E0) || Flags == (RI_KEY_BREAK|RI_KEY_E0)) // Right Input Key       
      else if(MakeCode == 0x1C && Flags == (RI_KEY_MAKE|!RI_KEY_E0) || Flags == (RI_KEY_BREAK|!RI_KEY_E0)) // Left Input Key            
  0x10 // SHIFT key  
      if(MakeCode == 0x2A) // Left Shift  
      else if (MakeCode == 0x36) // Right Shift            
  0x11 // CTRL key  
      if (MakeCode == 0x1D && Flags == (RI_KEY_MAKE|RI_KEY_E0) || Flags == (RI_KEY_BREAK|RI_KEY_E0)) // Right Control  
      else if (MakeCode == 0x1D && Flags == (RI_KEY_MAKE|!RI_KEY_E0) || Flags == (RI_KEY_BREAK|!RI_KEY_E0)) // Left Control            
  0x12 // ALT key  
      if (MakeCode == 0x38 && Flags == (RI_KEY_MAKE|RI_KEY_E0) || Flags == (RI_KEY_BREAK|RI_KEY_E0)) // Right Alt  
      else if (MakeCode == 0x38 && Flags == (RI_KEY_MAKE|!RI_KEY_E0) || Flags == (RI_KEY_BREAK|!RI_KEY_E0)) // Left Alt  
  0x13 // PAUSE key            
  0x14 // CAPS LOCK key            
  0x1B // ESC key       
  0x20 // SPACEBAR       
  0x21 // PAGE UP key       
  0x22 // PAGE DOWN key       
  0x23 // END key       
  0x24 // HOME key       
  0x25 // LEFT ARROW key       
  0x26 // UP ARROW key       
  0x27 // RIGHT ARROW key                 
  0x28 // DOWN ARROW key            
  0x2C // PRINT SCREEN key            
  0x2D // INS key            
  0x2E // DEL key            
  0x30 // 0 key            
  0x31 // 1 key       
  0x32 // 2 key            
  0x33 // 3 key            
  0x34 // 4 key            
  0x35 // 5 key       
  0x36 // 6 key       
  0x37 // 7 key       
  0x38 // 8 key       
  0x39 // 9 key            
  0x41 // A key       
  0x42 // B key  
  0x43 // C key  
  0x44 // D key  
  0x45 // E key  
  0x46 // F key  
  0x47 // G key  
  0x48 // H key  
  0x49 // I key  
  0x4A // J key  
  0x4B // K key  
  0x4C // L key  
  0x4D // M key  
  0x4E // N key  
  0x4F // O key  
  0x50 // P key  
  0x51 // Q key  
  0x52 // R key  
  0x53 // S key  
  0x54 // T key  
  0x55 // U key  
  0x56 // V key  
  0x57 // W key  
  0x58 // X key  
  0x59 // Y key  
  0x5A // Z key  
  0x60 // Numeric keypad 0 key  
  0x61 // Numeric keypad 1 key  
  0x62 // Numeric keypad 2 key  
  0x63 // Numeric keypad 3 key  
  0x64 // Numeric keypad 4 key  
  0x65 // Numeric keypad 5 key  
  0x66 // Numeric keypad 6 key  
  0x67 // Numeric keypad 7 key  
  0x68 // Numeric keypad 8 key  
  0x69 // Numeric keypad 9 key  
  0x6A // Multiply key  
  0x6B // Add key  
  0x6D // Subtract key  
  0x6E // Decimal key  
  0x6F // Divide key  
  0x70 // F1 key       
  0x71 // F2 key  
  0x72 // F3 key  
  0x73 // F4 key  
  0x74 // F5 key  
  0x75 // F6 key  
  0x76 // F7 key  
  0x77 // F8 key  
  0x78 // F9 key  
  0x79 // F10 key  
  0x7A // F11 key  
  0x7B // F12 key       
  0x90 // NUM LOCK key  
  0x91 // SCROLL LOCK key  
  0xBA // Windows 2000 for the US standard keyboard, the ';' key  
  0xBB // Windows 2000 for any country/region, the '=+' key  
  0xBC // Windows 2000 for any country/region, the ',<' key  
  0xBD // Windows 2000 for any country/region, the '-_' key  
  0xBE // Windows 2000 for any country/region, the '.>' key  
  0xBF // Windows 2000 for the US standard keyboard, the '/?' key  
  0xC0 // Windows 2000 for the US standard keyboard, the '`~' key  
  0xDB // Windows 2000 for the US standard keyboard, the '[{' key  
  0xDC // Windows 2000 for the US standard keyboard, the '\|' key  
  0xDD // Windows 2000 for the US standard keyboard, the ']}' key  
  0xDE // Windows 2000 for the US standard keyboard, the 'single-quote/double-quote' key  

 For the mouse you will need these codes.

 case 0x0001: // Left mouse button down  
 case 0x0002: // Left mouse button up  
 case 0x0004: // Right mouse button down  
 case 0x0008: // Right mouse button up  
 case 0x0010: // Middle mouse button (three-button mouse) down  
 case 0x0020: // Middle mouse button (three-button mouse) up  
 case 0x0040: // Windows 2000: X1 mouse button down  
 case 0x0080: // Windows 2000: X1 mouse button up  
 case 0x100: // Windows 2000: X2 mouse button down  
 case 0x0200: // Windows 2000: X2 mouse button up  
 case 0x0400: // Mouse Wheel            

You should handle these in any way you see fit, but everything above will get you started in implementing RAWINPUT into your engine.

For additional information visit MSDN RAW INPUT

Bloom in Soaring Steele

One of the shader effects that we have implemented in our game Soaring Steele is a bloom effect, this effect is great because it helps being our game to life because for the most part you are flying through the bright sky with the sun beating down.

Definition:

Bloom (sometimes referred to as light bloom or glow) is a computer graphics effect used in video games, demos and high dynamic range rendering (HDR) to reproduce an imaging artifact of real-world cameras. The effect produces fringes (or feathers) of light extending from the borders of bright areas in an image, contributing to the illusion of an extremely bright light overwhelming the camera or eye capturing the scene. (Wikipedia)

Before and After Comparison:

C++ Code Sample:

Here is an example of how I integrate bloom into my draw loop.

Steps: 

1. Draw the Scene to an Frame Buffer Object
2. Draw the Frame Buffer Object with a Bright Pass Shader
3. Blur the Bright Pass using a two pass Gaussian blur
4. Combine the Bright/Blur pass and the Scene pass together and draw as the final image.

1:  particleBase->bind();  
2:    
3:            Scene::draw3D();  
4:    
5:            particleBase->unbind();  
6:    
7:            particleBrightPass->bind();  
8:    
9:                 BrightPass->begin();  
10:    
11:                      BrightPass->setUniform("luminance",luminance);  
12:                      BrightPass->setUniform("middleGrey",middleGrey);  
13:                      BrightPass->setUniform("threshold",threshold);  
14:    
15:                      glActiveTexture(GL_TEXTURE0);  
16:                      glBindTexture(GL_TEXTURE_2D,particleBase->getColourTexture(0));  
17:                      BrightPass->setUniform("particlebase",0);  
18:    
19:                      particleBase->draw();  
20:                   
21:                 BrightPass->end();  
22:    
23:            particleBrightPass->unbind();  
24:    
25:            guassian1DBlurX();  
26:            guassian1DBlurY();  
27:    
28:            combinePass->bind();  
29:    
30:                 CombinePass->begin();  
31:    
32:                      glActiveTexture(GL_TEXTURE0);  
33:                      glBindTexture(GL_TEXTURE_2D,particleBase->getColourTexture(0));  
34:                      CombinePass->setUniform("baseInput",0);  
35:    
36:                      glActiveTexture(GL_TEXTURE1);  
37:                      glBindTexture(GL_TEXTURE_2D,particleGuassianTwoPassYBlur->getColourTexture(0));  
38:                      CombinePass->setUniform("adjustmentInput",1);  
39:    
40:                      particleGuassianTwoPassYBlur->draw();       
41:    
42:                 CombinePass->end();  
43:    
44:            combinePass->unbind();  
45:    
46:            combinePass->draw(1);  

Shaders:

Bright Pass:

Here is where I apply the bright pass.

 #version 330  
 in vec2 uv0;  
 out vec4 colour;  
 uniform sampler2D particlebase;  
 uniform float luminance = 1;  
 uniform float middleGrey = 1;  
 uniform float threshold = 1;  
 void main()  
 {  
      vec3 color = texture2D(particlebase,uv0).rgb;  
      colour *= (middleGrey / luminance);  
      colour *= (1.0 + (colour / (threshold * threshold) ));  
      colour -= 0.5;  
      colour /= (1.0 + (colour * colour));  
      colour.rgb = color;  
 }  

X Pass Guassian Blur:

In this pass I take the result of the bright pass and blur it along the x axis.

 #version 330  
 vec2 uv0[5];  
 float weights[5];  
 in vec2 uv1;  
 out vec4 colour;  
 uniform sampler2D brightpassInput;  
 uniform vec2 pixelSize;  
 vec3 GuassianBlur()  
 {  
      vec3 result = vec3(0.0);  
      for(int i = 0; i < 5; i++)  
      {  
           result += texture2D(brightpassInput,uv0[i]).rgb * weights[i];  
      }  
      return result;  
 }  
 void CalculateUvs_Weights()  
 {  
      uv0[0] = uv1 + vec2(-pixelSize.x*2,0);  
      uv0[1] = uv1 + vec2(-pixelSize.x,0);  
      uv0[2] = uv1 + vec2(0,0);  
      uv0[3] = uv1 + vec2(pixelSize.x,0);  
      uv0[4] = uv1 + vec2(pixelSize.x*2,0);  
      weights[0] = 0.01330373 / 0.47365426;  
      weights[1] = 0.11098164 / 0.47365426;  
      weights[2] = 0.22508352 / 0.47365426;  
      weights[3] = 0.11098164 / 0.47365426;  
      weights[4] = 0.01330373 / 0.47365426;  
 }  
 void main()  
 {  
      CalculateUvs_Weights();  
      colour.rgb = GuassianBlur();  
 }  

Y Pass Gaussian Blur:

In this pass I blur the x pass, along the y axis.

 #version 330  
 vec2 uv0[5];  
 float weights[5];  
 in vec2 uv1;  
 out vec4 colour;  
 uniform sampler2D brightpassInput;  
 uniform vec2 pixelSize;  
 vec3 GuassianBlur()  
 {  
      vec3 result = vec3(0.0);  
      for(int i = 0; i < 5; i++)  
      {  
           result += texture2D(brightpassInput,uv0[i]).rgb * weights[i];  
      }  
      return result;  
 }  
 void CalculateUvs_Weights()  
 {  
      uv0[0] = uv1 + vec2(0,pixelSize.y*2);  
      uv0[1] = uv1 + vec2(0,pixelSize.y);  
      uv0[2] = uv1 + vec2(0,0);  
      uv0[3] = uv1 + vec2(0,-pixelSize.y);  
      uv0[4] = uv1 + vec2(0,-pixelSize.y*2);  
      weights[0] = 0.01330373 / 0.47365426;  
      weights[1] = 0.11098164 / 0.47365426;  
      weights[2] = 0.22508352 / 0.47365426;  
      weights[3] = 0.11098164 / 0.47365426;  
      weights[4] = 0.01330373 / 0.47365426;  
 }  
 void main()  
 {  
      CalculateUvs_Weights();  
      colour.rgb = GuassianBlur();  
 }  

Combine Pass:
Finally I combine the two passed using a screen filter.

 #version 330  
 in vec2 uv0;  
 uniform sampler2D baseInput;  
 uniform sampler2D adjustmentInput;  
 out vec4 colour;  
 vec3 screen(vec3 color1, vec3 color2)  
 {  
      return (1.0 - ((1.0 - color1) * (1.0 - color2)) );  
 }  
 void main()  
 {  
      vec3 colorA = texture2D(baseInput,uv0).rgb;  
      vec3 colorB = texture2D(adjustmentInput,uv0).rgb;  
      colour.rgb = screen(colorA,colorB);  
 }  

In Season

Presents

So for this game we decided to stay as close to the core mechanic outlined as possible.  We decided to make a game that was an education memory game that will teach people the fresh fruits and vegetables that are in season.

Our inspiration for this game comes a lot from Gin, and a little bit from Go Fish. We decided to make a simple model where players draw cards and create sets of matching fruits and vegetables.

Goal:

The goal of the game is to collect as many different sets of fruits and vegetables as possible.

Each month of the year has a specific group of fruits and vegetables that make up a set.

Fruit and vegetables may belong to more than one set (mirroring how a fruit or vegetable is in season several months a year).

A month set is considered "complete" when a player holds the necessary fruits and vegetables for that month.

For example, if you collect five fruits or veggies that are part of the January set, you have succesfully gained one set.

The player with the most sets when the game is over wins!

Rules:

Each player starts with 4 cards, a random player goes first

Steps in a turn:

                First:

                                Draw a card from the deck

                Second:

                                Check to see if he you a complete set of 5 cards

                                If you do, play that set face up, in front of you. This set is considered complete.

                                Draw until you have 4 cards - the turn is now over

                                If you do not have set after drawing a card, proceed to step Three

                Third:

                                Choose a card at random from another players hand

                                Choose a card from your hand (not at random) to give back to the other player

                                If a set is made, play that set and draw until you have 4 cards - the turn is now over

                                If no set is made even still, your turn is over.

A random selection of my favorites fresh fruits and vegetables:

 

 

 
  

Dance Dance Simon

Presents

Overview:
For are final prototype we decided to recreate the single player party game Simon into a multiplayer party dancing game.

We came up with this idea by looking at the game requirements and thinking about party games we have played in the past, Simon seems like a natural choice to build a base off of. The next step was we wanted to incorporate the video into our game so we developed a simple console application to randomly pick and play a user defined number of videos in a row that are individual moves from Chaiyya Chaiyya video.

The game functions much like the game Simon in that the moves keep repeating, with a break in between for the players to copy the moves.

Dance Dance Simon Rules:

The game is intended as an icebreaker to be used at parties, social gatherings, etc.

The game operates similarly to the game “Simon” where a computer plays a pattern based on four buttons (Red, blue, green, yellow).  It is the player’s job to return that same pattern.  Successfully repeating the computer’s pattern adds one button to the list of patterns, scaling up the difficulty.  It is a single player memory game.

Similarly, our game hopes to turn this into a multiplayer dancing game. 

Setup:

·         All players stand facing the Leader.

·         The “Leader” may be: a person, a video, a drawing, or any other representation of dance moves

o   We have provided a program that randomizes dance moves based on clips from the actual Chaiyaa Chaiyaa dance scene

How to Play:

·         The leader starts by showing one dance move

o   All players must repeat the same move. 

o   If any player fails to do so, they are out

·         The leader repeats the first dance move, then adds a new one

o   All players must repeat this dance move sequence

o   Any player who fails to repeat the move is out

·         The leader repeats the previous dance sequence, and adds a new move

o   All players must repeat this dance sequence

o   Any player who fails to repeat the move is out

·         The game continues until there is one person left.  This person is declared the winner

   Game File Download: https://www.dropbox.com/s/5six2y8gzbq5ada/DanceDanceSimonFinal.7z

A Starry Night : Whodunit - Murder He Worte

PRESENTS

BASED ON THEMES DERIVED FROM

A STARRY NIGHT BY VINCENT VAN GOGH

So for our Second Prototype game we had a lot of fun developing it. We deiced to make our own Whodunit type game as a bases for telling a story. Essentially we have created a framework for players to play through a murder mystery in the town based in A Starry Night. We decided as a group the themes that best represented the painting are dark and depressing so we used that as a base for the Whodunit, by crafting characters and mechanics that will fill that role.

Concept:

We started out with the basic concept of a Whodunit murder mystery since that at its heart is a story driven book, we took this concept because it allowed us the amount of control we required to guide players through the game with our themes intact. We eventually released the control we had into one of the players who will play a "Van Gogh" which is essentially a Game Master. He leads the players through the game providing answers to there questions and providing them with clues, he controls the important facts about the game.

Rules:

•             Players will decide on a player to be the 'Van Gogh'. The Van Gogh acts as a game master and narrator for the game. The VG will then choose one of the 11 characters to be a murderer and one to be a victim. They will then create a plot as simple or complicated as they want using the rest of the characters. Use sample plot as a template.
• 
  
•       Every player picks a character bio card (this is their character) and places their token in the town square.
• 
  
•       The objective of the game is for players to successfully discover which of the 11 characters is the murderer.
• 
  
•             The game will begin with the Van Gogh telling the players who the murder victim is and suspicious details about the townspeople that may or may not be relevant to the murder. The type and amount of information given is completely up to the Van Gogh.
• 
  
•       Players gather information about the murder in two ways: Talking to characters and investigating areas around the town. Only one of these actions may be done each turn.

•      Players can talk to any of the 11 characters to gather information on the murder. This is done by asking the Van Gogh any question they want that they feel is relevant to the crime. All characters have things that anger them. Trying to determine motive is a good place to start.
• 
  
•       Players may also talk to other players, but there is no guarantee that other players will share information or even tell the truth.
• 
  
•       Players may also investigate any of the places in the town in an attempt to discover clues about the murder. The players must justify to the Van Gogh why they are investigating certain places. If the Van Gogh determines an investigation to be 'successful', a player is rewarded with a clue card, which has valuable information on the murder.

• *It is important to note that this game is a very role-playing 'table talking game. The Van Gogh will always tell the truth, but may withhold certain information depending on how justified you are in asking what you are asking.

•      After every player has had a turn, the game advances to the next night. Every three nights, the Van Gogh picks another character (not being played) to fall victim to their murderer.

•     The game progresses until a player is confident that they know who the murderer is and what the murder weapon was. The player will make their accusation at the beginning of their turn. If they are correct, the game is over. If they are incorrect, they are out of the game.

The Van Gogh Role Tips:

This is intended as a reference guide for the Van Gogh of the story.  Remember, the Van Gogh is the most important player; they set up the game, and are usually the host of the party.  They are the god within the machine, all-knowing.   They need to be good at improvisation, because some story arcs will appear out of thin air!

• To do beforehand:
• Scene of Crime:  Specify the location of the murdered person.  It can be anywhere as long as it is not the town square.  As an example, use the graveyard.
• Murderer:  Each player can hypothetically be a murderer.  Make sure you specify who the murderer is beforehand, so that you can’t accidentally change it halfway through.  Also give the player a reason to murder.  Don’t have the priest randomly kill the widow without explaining why he might do that.  Some player relations are listed on the Bio sheets.  For advanced players, you can make a murderer as well as an accomplice.  To start, it is recommended to use the Baker on his own as the murderer.
• Back story:  Create some back story for the NPCs that you’ll be controlling.  This back story is basically just what the character was doing night of the murder, so possible alibis.  These change from game to game.  We recommend having something like the priest saw the town drunk get outrageously drunk the night of the murder and pass out in the park.  Also, have something like the baker’s assistant was out of town that night on a delivery.  Use your imagination, you tell the story!
• Clues in the area:  Make sure you think about some clues and where they are going to be found in the game map.  For instance, if the dead body was found to be poisoned, and the baker happens to have an empty bottle of poison in his garbage, it looks extremely suspicious.  Similarly, if there are only male footprints at the scene of the crime, it is unlikely that the murderer was a female.  If the clues provided aren't good enough, take one of the blank ones and write something down!
• To do during:
• Make sure people tell good stories.  If someone says “I search the area for clues” give them a poor clue at best.  But, if they say something like “I meticulously search the main path to the cemetery, looking for footprints”, award that player with exactly what he was looking for.  Remember, this game is just as much about storytelling as it is murder mystery and role playing.
• Just because someone asks a question, doesn't mean you need to answer it.  If a player challenges an NPC saying unimaginative like, “Did you murder him?”, feel free to create a story workaround so that you don’t have to answer it, such as: “I get so offended at you slandering my good name that I punch you in the face and knock you out”.  This is to discourage people asking easy questions.  However, should you choose to actually give an answer, it MUST BE TRUE.
• Someone looks for a clue that you don’t have?  Let’s say a player looks around in a bush to find poison berries, which could be a murder weapon.  You could tell the player he finds nothing, or for advanced players, feed him a false clue by taking a second write down the poison berries on one of the blank clue cards provided!   Be careful of this though, you need to keep track of the clues players find, and how they relate to the game. 
• Slow game?  Kill a character!   If you find that the game is slowing down and the players aren't making much progress, you have the option to kill off an NPC every 3 turns.  This helps the player by adding a new murder scene where you can plant new clues.  Also, it decreases the amount of possible suspects, helping out the players.

Character Bios:

Name:	Basile Chaput
Gender:	Male
Occupation	Butcher
Age:	32
Height:	5 foot 4
Important Relations:	Has a secret crush on the candlestick maker
Facts:	Likes to walk alone at night No one knows where he gets his meat Is a vegetarian

Name:	Léo Gosselin
Gender:	Male
Occupation	Town Drunk
Age:	40
Height:	6 Feet
Important Relations:	Brother of the widow On good terms with constable
Facts:	Occasionally passes out in the graveyard or park Sometimes gets arrested for public indecency, drunkenness, etc.  Used to be a soldier

Name:	Guy Tailler
Gender:	Male
Occupation	Baker
Age:	28
Height:	4 foot  11
Important Relations:	Is crushed on by the candlestick maker Frequently employs the services of the courtesan
Facts:	Severe Napoleon complex Binge eats his own pastries Used to make cakes for royalty, quit because he was ridiculed for his height

Name:	Jérémie Archambault
Gender:	Male
Occupation	Gravedigger
Age:	22
Height:	6 foot 2
Important Relations:	Married to the Baker’s Assistant Doesn't get along well with the Priest
Facts:	Extremely emotional Works at nighttime as a gravedigger Often falls asleep on the job, making Father Benoit dislike him somewhat Falls asleep in the graves he digs.  Can talk his way out of any situation, smooth talker
Name:	Léandre Gagnier
Gender:	Male
Occupation	Constable
Age:	35
Height:	5 foot 8
Important Relations:	Mutual respect with town drunk Doesn't trust the gravedigger
Facts:	Bad judge of character Nighttime vigilante Can’t talk to women
Name:	Marion Archambault
Gender:	Female
Occupation	Baker’s assistant
Age:	20
Height:	5 foot 6
Important Relations:	Good friends with candlestick maker Married to the gravedigger
Facts:	Gossips often with the candlestick maker Unintentionally flirty Does deliveries for the baker.

Name:	Suzanne Lapointe
Gender:	Female
Occupation	Courtesan
Age:	26
Height:	5 foot 4
Important Relations:	Has a crush on the gravedigger Is frequently employed by the baker
Facts:	Extremely insightful Knows everyone’s secrets Is very good at keeping them

Name:	Geneveve Janvier
Gender:	Female
Occupation	Candlestick maker
Age:	21
Height:	5 foot 7
Important Relations:	Has a crush on the baker Is good friends with the baker’s assistant
Facts:	Has recently put on weight and is insecure about it Short temper Very affectionate about her cats

Name:	Pétronille Chastain
Gender:	Female
Occupation	Widow
Age:	45
Height:	5 foot 2
Important Relations:	Sister of the town drunk Good friends with Father Benoit
Facts:	Religious Has a loyal dog Indifferent Is a polite old lady

Name:	Father Francois Benoit
Gender:	Male
Occupation	Priest
Age:	50
Height:	5 foot 10
Important Relations:	Dislikes the gravedigger Good friends with the widow Thinks the courtesan will spend eternity in hell
Facts:	Has as wooden leg Angry when people miss church Carries holy water with him at all times.

Clues:

These are the predefined clues we provide to the "Van Gogh", he can also create his own clues on the blank cards we provide.