Game Design Document

1.

Game Design Document
Ski Course
Rajveer Singh
Table of Contents
Overview 4
Introduction 4
Game Structure 4
Control 4
Scoring 5
Task Points 5
Perception 5
Touch 6
Other senses and self-assessment 6
Actions 6
Movement 6
Pick-up/drop: 6
Fighting: 6
Communication: 7
Perception: 7
Universe Simulation 7
Physical Universe 7
Surfaces 7
Particles 7
Terrain - Vegetation - Materials 8
Game Elements 9
Inanimate objects 10
Landscape 10
Levels 10

2.

Gameplay………………………………………………………………………………………………. 10
References 12
Overview
Introduction
Welcome to the Game Design Document for our upcoming skiing game! In this document, we
will outline the vision, gameplay mechanics, features, and technical specifications for our
exciting new game.
Game Overview
Our skiing game will provide players with a thrilling and immersive experience, allowing
them to race down some of the world's most challenging slopes. The game will be designed
for all levels of players, from beginners to experienced skiers, and will feature a variety of
game modes, including time trials, race challenges, and freestyle events.
Game Structure
Control
Players will control their skiers using a combination of buttons and joystick controls. The game will
feature a realistic physics engine, allowing players to experience the thrill of skiing down a mountain
while having to manage their speed, turns, and jumps. The game will also incorporate various obstacles,
such as trees, rocks, and other skiers, which will add an additional level of difficulty to the gameplay.

3.

Scoring
Features
Our skiing game will feature a wide range of features, including:
Multiple Game Modes - Players will be able to choose from a variety of game modes,
including time trials, race challenges, and freestyle events.
Customization - Players will be able to customize their skiers, including their outfits,
skis, and equipment.
Multiplayer - The game will feature online multiplayer, allowing players to compete
against each other from around the world.
Achievements - Players will be able to unlock various achievements by completing
specific objectives and challenges in the game.
In-Game Store - The game will feature an in-game store where players can purchase
new equipment, upgrades, and items.
Technical Specifications
Our skiing game will be developed using the Unity game engine and will be available on PC, consoles,
and mobile devices. The game will feature high-quality graphics, sound effects, and music, providing
players with an immersive and engaging experience. The game will also be optimized for different
platforms, ensuring that players can enjoy smooth and responsive gameplay regardless of their device.
Engine: The game will be developed using the Unity engine.
Platform: The game will be available on PC, consoles, and mobile devices.
Graphics: The game will feature high-quality graphics, including realistic snow effects and character
animations.
Sound: The game will feature a variety of sound effects, including realistic skiing sounds and music.
Optimization: The game will be optimized for different platforms, ensuring smooth and responsive
gameplay.
Skiing Iterface
The game gives the user a first person view , as if they were actually skiing in real world, the
game will also feature camera movement that corresponds to the movement of the mouse, also
the game will provide an immersive experience through graphics and colors.

4.

Environment & Texture
A skiing game environment texture would likely include various
elements to create a realistic and immersive skiing experience.
The texture would include a snowy landscape, with varying shades
of white, gray, and blue to create depth and contrast. The texture
might also include trees, rocks, and other natural elements to add
to the visual appeal of the game environment.
In addition to the natural elements, the texture might also include
man-made structures such as ski lodges, ski lifts, and other
buildings found at ski resorts. These structures would be designed
to blend seamlessly with the natural environment, creating a
cohesive and believable game world.
Finally, the texture would also include various visual effects, such
as falling snow, fog, and other weather effects, to enhance the
realism and immersion of the game environment. These effects
would be carefully designed to create a dynamic and engaging
game environment that draws players in and keeps them engaged.
Universe Simulation
Terrain generation: The game would
generate a ski slope with varying
terrain, including bumps, jumps, and
obstacles. The slope would be
generated using a combination of
algorithms and hand-crafted
elements to create a natural and
believable environment.

5.

Physics engine: The game would use
a physics engine to simulate the
movement of the skier and their
interactions with the environment.
This would include factors such as
gravity, momentum, friction, and air
resistance.
Player controls: The player would
control the skier using a combination
of buttons and joystick controls. The
controls would allow the player to
control their speed, turn, and
perform tricks and jumps.
Trick system: The game would
feature a trick system that allows
players to perform spins, flips, and
grabs to earn points and increase
their score.
Scoring system: The game would
feature a scoring system that
rewards players for completing
challenges, performing tricks, and
winning races.

6.

Multiplayer: The game would feature
online multiplayer, allowing players
to compete against each other in
real-time. The multiplayer mode
would include various game modes,
including races and freestyle events.
Customization: Players would be able
to customize their skier, including
their outfit, skis, and equipment.
Customization would be available
through an in-game store, which
would offer various items for
purchase.
Artificial intelligence: The game
would feature artificial intelligence
to simulate the behavior of other
skiers on the slope. This would
create a more dynamic and
challenging game environment for
the player.

7.

Audio and visual effects: The game
would feature high-quality graphics
and sound effects, including realistic
skiing sounds and music. Visual
effects would also include simulation
of snow-fall and environmental
effects.
Game Elements
Here are some key game elements
that that are there in my skiing
game:
Terrain: The game would feature
various types of terrain, including
slopes, moguls, jumps, and
obstacles, all of which the player
would need to navigate while skiing
down the mountain.

8.

Physics engine: The physics engine
would simulate the skier's
movements, including their speed,
momentum, turning, and the effects
of gravity, wind resistance, and
friction. This would make the skiing
experience more realistic and
challenging.
Player controls: The player would
control the skier's movements using
a combination of buttons and
joystick controls. These controls
would allow the player to turn, jump,
and perform tricks such as spins,
grabs, and flips.
Trick system: The game would
feature a trick system that allows
the player to perform various types
of tricks and stunts. Performing
tricks successfully would earn the
player points and increase their
score.

9.

Racing: The game would feature
racing modes, where the player
would compete against other skiers
to reach the finish line first. The
player would need to navigate
through the course as quickly as
possible, while avoiding obstacles
and performing tricks to gain a
speed boost.
Challenges: The game would feature
various challenges that the player
could complete to earn rewards and
increase their score. These
challenges could include performing
specific tricks, skiing through gates
or checkpoints, or achieving a
certain score.
Customization: Players would be able
to customize their skier's
appearance, including their outfit,
skis, and equipment. This would
allow players to create their own
unique skiing character.

10.

Artificial intelligence: The game
would feature artificial intelligence
that controls other skiers on the
mountain. These AI-controlled skiers
would act as obstacles and
competition for the player, adding to
the challenge of the game.
Multiplayer: The game would feature
online multiplayer modes, allowing
players to compete against each
other in real-time. These modes
could include races, challenges, and
freestyle events.
Audio and visual effects: The game
would feature high-quality graphics
and sound effects, including realistic
skiing sounds and music. Visual
effects would also include weather
effects such as falling snow and fog,
which would add to the realism and
immersion of the game.
Playing Of The Skiing Game
To play a skiing game, you will typically need a compatible gaming device or platform such as a PC,
gaming console, or mobile device. Once you have the device or platform, follow these general steps to
play a skiing game:
Choose the game mode: My skiing games offer different game modes such as freestyle, racing, and

11.

challenges. Select the game mode that you want to play.
Choose your skier: If the game offers customization options, choose your skier's appearance, outfit, skis,
and equipment.
Familiarize yourself with the controls: Each skiing game has its own set of controls. Take some time to
understand how to control your skier. This will typically include buttons or joystick controls to turn,
speed up, slow down, and perform tricks.
Navigate the course: Depending on the game mode, you may need to navigate a course that features
various types of terrain, such as slopes, moguls, jumps, and obstacles. Use your controls to navigate the
course, avoid obstacles, and perform tricks.
Perform tricks: Many skiing games offer a trick system that allows you to perform various types of tricks
such as spins, grabs, and flips. To perform tricks, you will typically need to press specific button or
joystick combinations.
Score points: Scoring points is an important part of skiing games. Points are typically earned by
completing challenges, performing tricks, and reaching the finish line quickly. Your score will be
displayed on the screen.
Multiplayer: If the game has multiplayer options, you can compete against other players online. Choose
the multiplayer mode and start competing with other players in real-time.
Audio and visual effects: Many skiing games feature high-quality graphics and sound effects, including
realistic skiing sounds and music. The visual effects may include weather effects such as falling snow and
fog, which add to the realism and immersion of the game.
Enjoy the game: Above all, the most important thing is to enjoy playing the skiing game! Have fun,
challenge yourself, and try to improve your skills and score with each playthrough.
References
• "SSX 3" (Electronic Arts): This game was released for multiple platforms in 2003 and is often
cited as a classic skiing game. It features various game modes, tricks, and customization options
that could serve as inspiration for a new skiing game.
• "Alpine Skiing" (Greentube): This skiing game was released in 2019 and features realistic skiing
physics, various skiing challenges, and multiplayer options.
• "Steep" (Ubisoft): This game was released in 2016 and features open-world skiing, snowboarding,
and wingsuiting. It also includes multiplayer modes and a trick system.
• "Snow" (Poppermost Productions): This game was released in 2013 and features skiing and
snowboarding in an open world. It includes multiplayer modes, a trick system, and customization
options.
• "Amped 3" (2K Sports): This game was released in 2005 for Xbox 360 and features
snowboarding, skiing, and sledding. It includes a trick system, customization options, and a
humorous storyline.

12.

13.

These are a few Game Related Codes
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class UIController : MonoBehaviour {
private Text textTotalScoreOnHUD;

14.

private Text textLevelScoreOnHUD;
private Text textForwardOnHUD;
private Text textMoveOnHUD;
private Text textScoreOnHUD;
private Text textTimeBonusOnHUD;
// Use this for initialization
void Start () {
textTotalScoreOnHUD = GameObject.Find("Canvas/TextTotalScore").GetComponent<Text>();
textLevelScoreOnHUD = GameObject.Find("Canvas/TextLevelScore").GetComponent<Text>();
textForwardOnHUD = GameObject.Find("Canvas/TextForward").GetComponent<Text>();
textMoveOnHUD = GameObject.Find("Canvas/TextMove").GetComponent<Text>();
textScoreOnHUD = GameObject.Find("Canvas/TextScore").GetComponent<Text>();
textTimeBonusOnHUD = GameObject.Find("Canvas/TextTimeBonus").GetComponent<Text>();
textTotalScoreOnHUD.text = "Total Score: " + DataDictionary.getDD().gettotalScore();
textLevelScoreOnHUD.text = "Current Level Score: ";
textForwardOnHUD.text = "Press the 'w' key to ski";
textMoveOnHUD.text = "Steer using the mouse and 'a' and 'd' keys";
textScoreOnHUD.text = "Steer through flags and pick up snowballs to earn points";
textTimeBonusOnHUD.text = "Time Bonus: ";
textForwardOnHUD.enabled = false;
textMoveOnHUD.enabled = false;
textScoreOnHUD.enabled = false;
}
// Update is called once per frame
void Update () {
// Game is running
if (DataDictionary.getDD().getisPlaying())
{

15.

textLevelScoreOnHUD.text = "Current Level Score: " + DataDictionary.getDD().getlevel1Score();
updateTimeBonus();
if (!DataDictionary.getDD().gethasShownInstructions())
{
forward();
DataDictionary.getDD().sethasShownInstructions(true);
}
} else
{
// Game is not running
textTotalScoreOnHUD.text = "Total Score: " + DataDictionary.getDD().gettotalScore();
textTimeBonusOnHUD.enabled = false;
textLevelScoreOnHUD.enabled = false;
textMoveOnHUD.text = "Press 'q' to quit";
textMoveOnHUD.enabled = true;
StartCoroutine("endCoroutine");
}
}
IEnumerator endCoroutine()
{
while (!Input.GetKeyDown("q"))
yield return null;
Debug.Log("Quitting app");
Application.Quit();
}
private void updateTimeBonus()
{
int t = (int) Math.Round(100 - 2*Time.timeSinceLevelLoad);

16.

textTimeBonusOnHUD.text = "Time Bonus: " + t;
DataDictionary.getDD().settimeBonus(t);
}
/// <summary>
/// Displays information on how to move forward
/// </summary>
private void forward()
{
textForwardOnHUD.enabled = true;
StartCoroutine("forwardCoroutine");
}
IEnumerator forwardCoroutine()
{
while (!Input.GetKeyDown("w"))
yield return null;
textForwardOnHUD.enabled = false;
StartCoroutine("moveCoroutine");
}
/// <summary>
/// Displays moving directions for 5 seconds
/// </summary>
/// <returns></returns>
IEnumerator moveCoroutine()
{
textMoveOnHUD.enabled = true;
yield return new WaitForSeconds(5);
StartCoroutine("scoreCoroutine");
textMoveOnHUD.enabled = false;

17.

}
/// <summary>
/// Displays how to score points
/// </summary>
/// <returns></returns>
IEnumerator scoreCoroutine()
{
textScoreOnHUD.enabled = true;
yield return new WaitForSeconds(5);
textScoreOnHUD.enabled = false;
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace UnityStandardAssets.Characters.FirstPerson
{
public class TargetHit : MonoBehaviour
{
private static int targetScore = 100;
private static int snowballScore = 5;
private AudioSource pickup;
private Rigidbody playerObject;
// Use this for initialization
void Start()
{
pickup = GameObject.Find("AudioSourceSnowball").GetComponent<AudioSource>();
playerObject = GameObject.Find("RigidBodyFPSController").GetComponent<Rigidbody>();

18.

}
// Update is called once per frame
void Update()
{
}
public static void hitTarget()
{
//Debug.Log("Target Hit! Add score!");
int currscore = DataDictionary.getDD().getlevel1Score();
//Debug.Log("currscore= " + currscore);
DataDictionary.getDD().setlevel1Score(currscore + targetScore);
//System.Threading.Thread.Sleep(500);
}
public static void hitSnowball()
{
int currscore = DataDictionary.getDD().getlevel1Score();
DataDictionary.getDD().setlevel1Score(currscore + snowballScore);
}
private void OnTriggerEnter(Collider other)
{
// Level over
if (other.gameObject.name == "FinalTarget")
{
// Add level1score and timeBonus to totalscore
DataDictionary.getDD().setisPlaying(false);
int currscore = DataDictionary.getDD().getlevel1Score();
currscore += DataDictionary.getDD().gettimeBonus();
int tscore = DataDictionary.getDD().gettotalScore();

19.

DataDictionary.getDD().settotalScore(tscore + currscore);
playerObject.constraints = RigidbodyConstraints.FreezePosition;
return;
}
if (other.gameObject.name.StartsWith("Snowball"))
{
hitSnowball();
Destroy(other.gameObject);
pickup.Play();
return;
}
if (!DataDictionary.getDD().hitListContains(other.gameObject.name))
{
hitTarget();
DataDictionary.getDD().addhitList(other.gameObject.name);
}
}
}
}
[14:44, 4/26/2023] Bhai: using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class ObstacleHitController : MonoBehaviour {
private Text obstacleTextOnHUD;
private bool first = true;
// Use this for initialization
void Start () {

20.

obstacleTextOnHUD = GameObject.Find("Canvas/TextObstacle").GetComponent<Text>();
obstacleTextOnHUD.text = "Watch out for obstacles!";
obstacleTextOnHUD.enabled = false;
}
// Update is called once per frame
void Update () {
if (!DataDictionary.getDD().getisPlaying() && first == true)
{
first = false;
int sc = DataDictionary.getDD().getlevel1Score() + DataDictionary.getDD().gettimeBonus();
obstacleTextOnHUD.text…
[14:44, 4/26/2023] Bhai: using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System;
using System.Collections.Generic;
//using System.Net;
public class DataDictionary : MonoBehaviour
{
public static DataDictionary dd;
// declare data to save across scenes here
private bool isPlaying = true;
private int levelNumber = 1;
private int totalScore = 0;
private int level1Score = 0;
private bool hasShownInstructions = false;
private int timeBonus = 0;
private List<string> hitList = new List<string>();

21.

// Use this for initialization
void Awake()
{
if (dd == null)
{
DontDestroyOnLoad(gameObject);
dd = this;
Debug.Log("DataDictionary::Awake: Application.persistentDataPath = [" +
Application.persistentDataPath + "]");
init();
}
else if (dd != this)
{
Destroy(gameObject); // singleton pattern - do not allow more than one instance
}
}
private void init()
{
Debug.Log("DataDictionary::init(): Initializing.");
}
public static DataDictionary getDD()
{
if (dd == null)
{
Debug.Log("DataDictionary::getDD(): DataDictionary set to null! Fatal error.");
// TODO what do we do if DD does not exist?
}
return dd;
}

22.

// add setters and getters here
public int gettotalScore()
{
return totalScore;
}
public void settotalScore(int value)
{
totalScore = value;
}
public int getlevel1Score()
{
return level1Score;
}
public void setlevel1Score(int value)
{
level1Score = value;
}
public bool gethasShownInstructions()
{
return hasShownInstructions;
}
public void sethasShownInstructions(bool x)
{
hasShownInstructions = x;
}
public int gettimeBonus()
{
return timeBonus;

23.

}
public void settimeBonus(int value)
{
timeBonus = value;
}
public bool getisPlaying()
{
return isPlaying;
}
public void setisPlaying(bool value)
{
isPlaying = value;
}
public void addhitList(string value)
{
hitList.Add(value);
}
public void clearhitList()
{
hitList.Clear();
}
public bool hitListContains(string value)
{
bool ret = hitList.Contains(value);
return ret;
}
} // ends DataDictionary class