Assignment #1: Building A Game Using Engine Components

Transcription

1 CSUS COLLEGE OF ENGINEERING AND COMPUTER SCIENCE Department of Computer Science CSc 165 Computer Game Architecture and Implementation Spring 2012 John Clevenger Assignment #1: Building A Game Using Engine Components Introduction Due: Thursday, February 23 rd (2 weeks) The objective of this assignment is to learn how to use game engine components to build a simple game. You are to create a simple 3D game, relying on existing game engine components to supply much of the underlying functionality while implementing some of the functionality yourself. The assignment assumes you will use the Simple Adaptable Game Engine (SAGE) provided to the class 1. Later in the semester you will be asked to develop a game of your own design. For this assignment you are to implement a game called 3D Treasure Hunt. In this game the player uses a keyboard and a game controller (e.g. an Xbox controller, guitar, or other device) to fly around in a 3D world collecting treasures. A treasure is collected (and removed from the game) when the player flys the camera into it (that is, when the camera location collides with the treasure object). The game must run in full-screen mode, with the game HUD displaying values showing the game score (see below) and the elapsed time. Your goal should be to create a simple game that meets the requirements. In particular, you should avoid the temptation to create a complex, fancy game; the goal here is to learn how to interface with the game engine and to implement some pieces of the engine. There will be plenty of time later for creating the next blockbuster game Game Program Requirements Your game should be defined by extending the class sage.app.basegame and overriding methods initsystem(), initgame() and update(). All logic for your game should be contained in these three methods, or in other user-written game classes. The game must run in Full-Screen Exclusive Mode (FSEM). The program must include your own implementation of a DisplaySystem class. Your DisplaySystem class must implement the SAGE interface IDisplaySystem (although you may find that many of the methods can have empty bodies for now). You may use the SAGE JOGLRenderer class for the renderer invoked by your DisplaySystem. 1 Anyone who wishes to try using another game engine, or to develop the necessary components on your own, must see me before attempting to do so; it s important to make sure that you understand the magnitude of what you are proposing to do relative to the limited time in which you have to do it. 1

2 You should use sage.scene.shape objects for your game objects (treasures) 2. Note that the default size of SAGE shapes varies; you may have to invoke scale() to get some objects to be sized as desired. (Note however that changing the scale of an object does not automatically update the default BoundingVolume associated with the object.) The game initialization code should create a number of objects of different types, randomly positioned in the world. You may manipulate the various object attributes (e.g. color) however you like to make the game more interesting. Your game must support player input actions handled by Action classes written by you (that is, you must write classes which implement sage.input.action.iaction and your game must utilize InputManager.associateAction() to associate input device actions with your Action classes). At least the following key mappings must be provided (you may provide additional mappings if you like): A/S/W/D: move camera left/right/forward/backward respectively. Note that all camera motions are relative to the camera s current UVN axes; thus for example the S key moves the camera in the direction of the camera s U axis while the W key moves the camera in the direction of its N axis. Left-arrow / Right-arrow: rotate the camera in the positive or negative direction around its V axis ( yaw ). Up-arrow / Down-arrow: rotate the camera in the positive or negative direction around its U axis ( pitch ). ESCAPE: quit the game. At least the following controller input mappings must be provided (you may provide additional mappings if you like): X-axis: move the camera left and right in the same manner as the A and S Y-axis: move the camera forward and backward in the same manner as the W and D RX-axis: yaw the camera around its V axis in the same manner as the Left- and Rightarrow RY-axis: pitch the camera around its U axis in the same manner as the Up- and Downarrow The game must include at least two HUD (Heads-Up Display) elements: the current score and the elapsed time in seconds. Each HUD element must be implemented using a class which extends sage.scene.hudobject. You may use sage.scene.hudstring (which extends HUDObject) to do this, or you may implement your own class extending HUDObject. You may decide on the specific scoring algorithm (that is, how the player improves the score). A simple method is to just count the number of treasures collected. A more interesting method is to set up a timer which periodically adds new treasure objects to the world and to compute the score as a ratio: the number of treasures the player has 2 You could instead define your own object classes, but they would have to extend sage.scene.scenenode in order to be renderable by SAGE and this is a non-trivial mechanism; we will be covering it later. 2

3 collected so far vs. the total number of treasures that have been placed in the world (so the score goes up as the player collects treasures but goes down each time a new treasure gets added to the world because the player s percentage has decreased). The game must display world axes showing where the world origin is located. The X axis should be red, the Y axis green, and the Z axis blue. The world axes must initially be visible. You may add an input command to toggle the axes off/on, but this is not required. (The simplest way to toggle the axes is to just remove them from the game world using the BaseGame method removegameworldobject(), and later add them back with addgameworldobject().) Coding Requirements Your code should be organized using Java packages. As the semester progresses you will be developing two sets of code: code for different games, and code comprising game engine routines which will replace corresponding SAGE routines. Therefore you will need at least two packages: one named (say) games which houses different games you develop, and one named (say) mygameengine which houses game engine components which you develop to replace SAGE routines. (You might wish to choose a better name for your engine than mygameengine ; that s up to you.) Since you will be developing several games and multiple game engine components during the semester, you should use subpackages in your games and gameengine packages to house various related elements. For example, classes which are part of the Treasure Hunt game itself would go in package games.treasurehunt while classes which are part of your game engine (e.g. DisplaySystem) would go in package mygameengine.display (in the case of DisplaySystem). Your code should follow the Java convention that package names always start with a lower-case letter. Look through the SAGE package structure for additional insights. It is a requirement that your program run correctly when invoked from a command prompt using the command java a1.starter. Note that this means your Starter class must be contained in a package named a1 and that it must contain the required public static void main(string [] args) Java method. Note however that the rest of your code does not need to be (and should not be) contained in package a1. The Starter code in package a1 must simply import the game from the separate games.xxx package and execute it by invoking its start() method. Additional Notes The SAGE engine was designed to help with the development of game engine components; you should take advantage of this. For example, this assignment requires you to develop a display system class. This class already exists in SAGE, so you can use the SAGE version to test your program: simply changing your game so that it imports the class sage.display.displaysystem instead of your version from your package mygameengine.display allows you to see what your program does when it has a working display system implementation plugged in. As another example, SAGE has a variety of IAction implementations for camera controls (in sage.input.action); you can test whether your code is working correctly by plugging in the corresponding SAGE 3

4 IAction class. (Of course, you must submit the completed program using YOUR implementations, not those in SAGE ) If you do not have a controller that implements the X, Y, RX, and RY axes you may check one out from me for a short time for testing purposes. You may use the SAGE InputManager class; you do not have to write your own input manager. If you are going to work on your own machine you will need to install on it both SAGE and the various support packages SAGE needs (this include the JOGL OpenGL package, the graphicslib3d library, and the JInput package). All of these can be obtained by downloading the file JavaGaming.zip on my 165 web page; see the README.TXT file in that zip file for installation instructions. Treasures are collected by running into them with the camera. This means you must do collision detection between the camera location and the bounding volumes of the treasure shapes. SAGE provides a BoundingVolume for most of its shapes (those which do not do this state that fact in their JavaDoc header comments). See the sample in the Lecture Notes for details on how to detect collisions and remove objects from the gameworld. You will find several classes in the graphicslib3d library (which comes with SAGE) that will likely be helpful. These include Point3D (a 3D point), Vector3D (a 3D vector) and Matrix3D (a 4x4 transformation matrix). Note that every SAGE shape (sage.scene.scenenode) contains a set of three Matrix3D objects which specify respectively the current translation, rotation and scaling transformations applied to the object. These transformations can be obtained/modified with the appropriate getter/setter methods (the transforms are referred to as local transforms; so for example to get the current translation of an object you would call getlocaltranslation()). Note that there are also other transforms in SAGE shapes called world transforms; your program should not mess with these (we ll see later what they are for). See the SAGE JavaDoc which comes with the installed system for further details. It is a requirement that your program run correctly on a machine in RVR 5029 when invoked from a command prompt using the command java a1.starter. I will test it that way after you hand it in; you should test it that way before you hand it in. 4

5 Deliverables Submit to SacCT a single ZIP file containing (1) your Java source code files; (2) the compiled (.class) files for each of your Java source files; (3) a short Player s Guide document (MS-Word, PDF, or Text) describing how your game works, including what all the player input commands do and how the scoring works. Note that the submitted files must be organized in the proper hierarchy in the ZIP file (that is, the.class files must be contained within the appropriate subdirectories). All submitted work must be strictly your own. (Later in the semester you will be given the opportunity to do game development with a partner; this assignment is to be done on your own). Be sure to take note of the requirement (stated in the course syllabus) for keeping a backup copy of all work. JC:jc 2/8/12 5