Final Projects

Fall 1998


291 Fighter

291 Fighter will be a side view, 1 on 1, arcade action melee. There are 4 characters to choose from, each with their own special qualities and moves including: fireballs, jumping, ducking, blocking, punching, and more! Fights occur in 320x200x256 colors against a scrolling bitmapped background. Fights may occur as Human vs Human over a network (using NetBios), Human vs AI, or Tournament fashion with multiple Humans in a ladder tournament. Human input may come from keyboard or joystick.
Fight291 Writeup

  • Mike Stall: Main Game Engine
  • Francesco Spadini: Networking, Input Control
  • Paul Niemczyk: Graphics Engine
  • Jayson Valluzzi: Sound

291 Mission Impossible

291 Mission Impossible will be a two-dimensional game, and you are a ECE 291 student named Tomy. Here`s the story, You`ve been sitting in the lab working on the MP for hours. The MP deadline is TOMORROW, and you`re still working on the "InitBuffer"?!! Time is running out, so you wanna "steal" the code from your classmate while he`s dozing off..... (**NOTE:This is just a story....**)In order to *finish* your MP you have to copy the whole MP, while some TAs will be walking around in the lab, so WATCH OUT! The TAs will be controlled by artificial intellegence. They will walk back and forth in the lab. To complete the mission, Tomy has to download the MP to the disk from his classmate`s computer. If any of the TAs see him doing that, he`ll get kick out from the class, game over! Also, number of TAs and their speed increase as time`s running out.

Features:
graphics 320x200x256
8-bit sound effects
different AI levels
Mission Writeup

  • Ka Chun Ma: Graphics
  • Ryan Tam: AI
  • Shoko Oono: Gamemain
  • Richard Rittis: Sound

291 Pro-Am

We plan to implement a racing game based on the popular Nintendo game R/C Pro-Am. Gameplay will involve the player`s car being able to rotate isometrically in the center of the screen as the racetrack scrolls in the background according to the orientation and acceleration of the car. Unlike the original, ours will be a 2-player game over a network connection.

  • Scrolling isometric animation.
  • MIDI and WAV sound.
  • 2-Player network game capability.
  • AI computer players.
  • Map editor.
  • 291ProAm Writeup

    • Preston White: Graphics/GamePlay
    • Jon Moeller: Sound/Gameplay
    • Mike Basil: Gameplay
    • Mark Smith: Networking/Graphics

    291 Punch Out

    We plan to implement the Nintendo game "Mike Tyson`s Punch Out" but in assembly. The goal of this game will be to not only be able to play the single player game, but to network it as well. Some of the new features that we plan to add will be new views of the ring, as well as new shots of the fighters themselves. The goal of this is to simulate a 3-D looking forum. Another interesting aspect of the gameplay will be the usage of the gamepad. It is also a goal of ours to be able to change the face of you opponent (if you are networking) to whatever face you want.
    Punch Writeup

    • Samir Shah: Intro/Images
    • Neeta Rao: Sounds/Networking
    • Andrew Chen: Networking/Game Pad Control
    • Tom Detwiler: Gameplay/AI

    3 and 4 D plotting

    The purpose of this project will be to create 3 and 4 dimensional plots of functions.

    The basic program will allow a user to plot a 3D function and view it from a changing perspective (to be controlled from keyboard)

    Advanced features will include: animation of a 3D plot to allow a 4th dimension, addition of mouse as perspective input, implementation of more advanced functions (exponentials, sinusoidals, etc), ability to display multiple functions on a single graph.

    Tasks will include: function evaluation (take function, give an array of polygons which describe the surface), 3D plotting (display the array of polygons, from a given perspective), general engine (function input, animation, user input of perspective, etc)
    Plot3D Writeup

    • Graham Field: To be determined
    • Wong Yau Nang: To be determined
    • Phillip Jones: To be determined

    3-Alarm

    Our game will be based on a text graphics game called PYRO II (available at the link). Our version will be done in 640x480x256 with a four screen scrolling playfield. The playfield will be rendered from 3D free rotating texture mapped cubical object primitives. Explosion and fire will move, rotate, and destroy these objects, increasing the players score. The sound system will mix soundtrack and multiple sound samples, on the fly. The game engine will operate on a message structure to simplify design of AI and network play. We plan to minimize the use of stored images and at the same time increase the entertainment value of the game by modeling in code graphic effects such as fire, explosions, smoke, etc. The large memory requirement of the graphics and sound will be simplified by implementing our code in protected mode, using Tran`s freeware Dos extender.
    3alarm Writeup

    • Steve Holstein: PMODE, Game Engine. Graphic FX
    • Azra Jaganjac: SoundTrack, Game Play
    • Damir Orucevic: Graphic FX
    • Fa Yoeu: Sound FX, Graphic FX

    Ants

    Not just another 3/4 view continuous time RPG game. This game will be centered around Ants! Yes Ants. The object of this game in simple terms is to `survive`. You will be the leader of a great Ant clan, from which you`ve been separated in a gust of wind. You must find your way home. You will fight other creatues on the way back. If we have time, you will meet frienldy units and be able to control them. In single player mode the object of the game is to get home. In multiplayer mode you will have teammates. The game will have 8bit Soundblaster sound and will be done in 640x480x256. If time permits we will add in the multiplayer element. Mouse controled 2D scrollable world with multiple levels, a tile-based engine with 3d capabilities. Enemies have AI.
    Ants Writeup

    • David Wentzlaff: Graphics driver, Game integration
    • Scott Altoff: User Interface, Primary Loops
    • Douglas Armstrong: 3D Graphics, expanded memory, files, map
    • Kiran Sreekantham: AI, Data Structures

    Arkapic

    Imagine a first-person Arkanoid-style game whose object is to uncover pictures rather than just destroy blocks. The playfield will consist of four layers of tiles, the first of which is a blank, concealing layer. Underlying layers will portray pictures from several possible categories. By moving a "paddle" around the screen, the trajectory of a ball bouncing between the screen and the playfield will be determined and the stricken tile will be removed. When the player can guess the content of the entire picture the score is stored and a correct guess resets the game. We plan to use a double frame-buffer and Z-Buffer for smooth, accurate portrayal of the layered screen, implement mouse control for the paddle, and use PCX files for the tile graphics. Challenging aspects of the project will include collision detection between objects, determining ball trajectories, and representing a "ball" in perspective.
    Arkapic Writeup

    • Dave Booth: Sound and main program
    • Slawek Ciapala: Graphics/perspective transformations
    • Steve Behling: Trajectory calculations and animation
    • Timur Katatas: Input control and collision detection

    Cube Wars!

    Cube Wars! will be based on the SNES puzzle classic, Tetris Attack and will come with several additions and improvements.

    The players begins with a well filled with random colored blocks. They are equipped with a two block cursor which flips blocks under it. If a match of three or more colors is made horizontally or vertically, the blocks disappear. In addition, if more than three blocks have been removed, the other player is bombarded by "garbage blocks". These actions can be chained to form larger, and more numerous garbage blocks. The goal of this project will be to create a game which presents refined gameplay using current Win32 technologies.

    Features:
    • Networked play -- play head to head over TCP/IP
    • New blocks -- several new block types will be added to add variety.
    • 16-bit SVGA graphics
    CubeWars Writeup

    • Scott Mosier: animation subsystem, integration
    • Geeven Singh: sound effect mixing, music
    • Peter Olson: AI, networking
    • Christopher Fester: game logic
    • Sankalp Acharya: options, program flow, AI

    Cuzzie the Caterpillar

    Soon after she was born, Cuzzie fell from a wet leaf where she had been eating voraciously, into the grass below. Unable to find her way way back up into the trees, she was taken in by a family of earthworms during a terrible storm. She had a happy childhood, but always knew that she was different. When her brothers and sisters would ask her why she wanted to see the world above ground so badly, the only explanation she could give was "Because." This and her fuzzy appearance explain why everybody called her Cuzzie. As we join her, she has just set out once and for all to see the world above, and face the many dangers and adventures that await her there. If you don`t think this game sounds violent, just remember the last time you squashed a bug. Now, imagine that you`re the bug.
    cuzzie Writeup

    • Mike Kasper: Movement and strategy.
    • James Oliver: Enemies and obstacles.
    • Andrew Kreps: Levels and sound.

    Defender

    We are going to base our game on the classic Atari game Defender. The game for those of you that don`t know is a side-scrolling(left and right) spaceship shooting game. The object is to defeat the aliens at each level before they can take over the planet...thus moving to the next level. Enemy AI throughout the game as well as different weapons and bonuses. Our game will include both joystick and keyboard support as well as cool sound effects. All this combines into one of the greatest games ever!!!
    defender Writeup

    • Mike Wigdzinski: Sound, Game control
    • Brian Smith: AI
    • Mike Link: Graphics
    • Justin Lewis: Graphics

    ECE NINJAS

    ECE NINJA will be a two-player game where ECE majors realize they need more space, and decide to take over DCL. The game will feature two students (with resemblence to two of the ECE291 TA`s) who will fight off all CS students who would prevent them from reaching their goal. The game will scroll, as the main characters move from Everitt to DCL.

    We will use the Z-Buffer from MP4 to ensure that a character will not be drawn over by another. We will have one modification of the Z-Buffer which will be to allow an InitBuffer-type function that will write a background to the SCRbuffer unconditionally, and set all values in the Z-Buffer to be 255.

    The game will allow two-dimensional moving, along with a jump in the third dimension. Combat will include punching, jump-kicking, and throwing of objects (Such as a Ninja CD-ROM). Enemy players will be controlled using simple AI.

    Ninja Writeup

    • Aron Fay: Game Engine and Control
    • Lijoy philipose: Player Graphics and Control
    • Derrick Baker: Sound and AI
    • Jaimin Soni: Background Graphics and Scrolling

    JICE`s Run-Time Racers

    This will be a race among all programming languages. War of the languages!!! The human player will be the Assembly Mobile, and the other AI routines will be named C-Mobile, Fortran Mobile, Basic Mobile, etc. There will be point and time bonuses. Running over (picking up) certain items like a RAM chip, resistors, capacitors, intel symbol, etc. can be used for point bonuses. Time bonuses are possible only through the pick-up of a clock symbol. Obstacles are included in this game also. Such obstacles include undefined variable , mismatch arguments, char-to-int warnings, etc. This will result in points taken away. Objective: be the first to terminate successfully. i.e. Don`t: lose to another (AI) player, or run over an infinite loop symbol or segmentation fault.
    Jice Writeup

    • John Smolen: Sound/Graphics
    • Eilleen Berganos: User Interface
    • Charlinda Catchings: Game Play
    • Il-sun Park: AI

    Kung Fuuls

    We will be working on a 2D multiplayer game with a working name Kung Fuuls. Players will be divided into two clans clashed in a mortal battle. The objective of the game will be to fight your way in to the enemy stronghold and assasinate the enemy clan leader. The action of the game will take place on a scrollable 2D map with multiple ways of entry into the enemy base. Players from the opposite clans will be able to engage in a kung-fu style hand-to-hand combat. Death of a player will result in moving him back to the starting position. Players will be able to aquire skills through combat. Other enhancements possible, if time permits.

    Features:

    - 2D, tile-based, scrollable graphics
    - Multiplayer network game support
    - Sound effects
    Project environment:
    - 486 instruction set
    - Protected mode using a DOS extender
    - SVGA mode (possible enhancement)
    KungFu Writeup

    • Sebastian Magda: graphics, project integration
    • Ken Moy: networking
    • Mike Ni: graphics
    • Cheng Kok Hong: sound

    Pocket Billiards

    We will implement a game of 8-ball between Fast Eddie and Domino Fatz. A player will be able to shoot by choosing a radian direction from the cue ball, the speed of the cue ball, and any reverse or top spin on the cue ball. The user will see the player`s arm move the stick foward and back. The user will hit the key when the arm is all the way back to hit it the hardest. Any contact with other balls should cause the balls to move, governed by the law of physics. The player will be shown hitting the cue ball, and the layout of the table will be shown from an overhead view. Gambling will take place, and if you cannot pay your bill, Moose and Rocko might break your thumbs!
    8ball Writeup

    • Matt Rafacz: Graphics
    • Lori Haegele: GameFlow
    • Quinn Butler: Physics
    • Ervin Warner: Mouse/Sound

    Revenge of the Enginerds

    There will be multiple missions all taking place at the U of I campus for our hero, the enginerd. The game will have a top down view. You will have to walk around the campus avoiding obstacles ( O&M trucks and UPS trucks) to complete the mission. We will have have midi and wave file sound possibly with automatic configuration for sound cards. We will have scrolling backgrounds which include the North Campus. It will run in 320x200x256 graphics mode.
    RotE Writeup

    • Michael Drzal: graphics
    • Ryan Ruwe: Sound
    • Nathan Schneider: game play and control

    Road Warrior

    Road Warrior will be an overhead view, scrolling, 2D racing/shooter game based on the movie Road Warrior. The objective of the game will be to score points by destroying opponent cars while collecting powerups to maintain your car, including gas and ammunition. Your vehicle will have multiple weapons at its disposal. Midi sound, 320x200x256 res and color, enemy AI, and sound effects for now. Possibly joystick and/or multiplayer support.
    RoadWar Writeup

    • Mike Leib: Game flow, AI
    • Chris Berry: Joystick, Graphics
    • Dave Barenie: Gameplay
    • Jason Miller: Graphics
    • Nate Nuyles: Sound

    RoboRally

    We plan to implement a game based on a board game called RoboRally by Wizards of the Coast.

    The objective of the game is to use "instruction cards" to program a robot at the beginning of each round to move around a factory floor. The goal is to make your robot reach checkpoint flags before other players` robots do. Laser cannons, conveyor belts, pits and other robots are only a few of the obstacles your robot must navigate.

    As far as I know, no computer version of this game exists.
    The official rules by Wizards of the Coast are listed here.

    Things we plan to implement:
    2D-Overhead view of the playing field
    VGA Graphics
    8-bit Sound effects
    Multi-Player Support
    Basic AI
    Network play

    If time permits, we plan to implement the following:
    Background theme music
    16-bit sound effects
    SVGA Graphics
    Advanced AI

    Rally Writeup

    • Jesse Chen: Game AI
    • Long Truong: Networking
    • Michael Urman: Sound
    • Scott Mikula: Graphics

    Sparky`s Quest

    You are an unhappy electron named Sparky trying to prove your potential. You must take the path of least resistance to meet your perfect proton match. You will encounter many hazards along the way including deadly resistors, inductors, and capacitors, etc trying to thwart your quest for happiness. If Sparky reaches the other side with the least resistance possible, he will achieve ultimate happiness. The basic game will be a test of finding shortest paths on a map but with a twist! There will be electronic components that behave differently or could all together burn up! 640X480, 8 bit color, sound effects and animations will be used to display a view of the map, an algorithm for random map generation will be coded, and an algorithm for shortest path determination will be written. 4-team members sufficient for completion hopefully.
    Sparky Writeup

    • Rob Barton: animation, graphics
    • Sandip Roy: path algorithms and map generation
    • Ben Wild: sound effects
    • Ken Leung: input, graphics

    Star Fleet Academy: Interceptor Design

    For your final project for ECE 291, Elementary Craft Engineering: Interceptor Design, you must design an interceptor class starship given the materials list given to you. You may design the craft from scratch, or modify one of the included designs. Your craft will then be tested against those of other cadets, in which one individual from each team will have control of the entire vessel through a remote console. Remember, the goal of this project is to design a remotely manned interceptor. The main goal of this project is to design the starcraft. Determining which engines, computers, etc to use is one factor. Certain scripting of the workings of the craft must be done as well. The HUD which displays the action in 3D may be based on an existing rendering engine depending on time constraints. This is so as to concentrate on the logic of the craft design and real-time interactions.
    startrek Writeup

    • Jeffrey J. Cook: Ship logic and functionality
    • Jason Helmers: AI
    • Lucas Myslinski: Sound, Menuing
    • Angela Thelen: Graphics, Networking

    Steel Tracks

    Networked game that allows at most 4 human players. Each player will be represented as a tank and his view is in the first person (a la Quake). There will also be several AI tanks roaming the screen. The playing field is an arena with several elevated structures and different types of walls. Goal: To get the most points after three rounds by eliminating opponents. Scoring is 5 pts for last survivor, 2 pts for destroying a human opponent, and 1 pt for destroying a computer AI. When destroyed, that player is out for the duration of the round, but will see an overhead view of the rest of the players until the end of the round. Player with most points at the end of three rounds wins. Each game will have a 3D first person display, an overhead map, network play, moving walls, and three different tanks to choose from, and random features to keep the arena changing.
    SteelTrx Writeup

    • Mo Hanif: sound
    • Tim Parker: 3D Engine, Networking
    • Amit Mathur: graphics
    • Karim Taj: graphics

    Thak

    "Thak" revolves around our central character, namely a caveman named Thak (imagine that). The game itself is an overhead, real-time, multiplayer strategy game, similar to that of the Command and Conquer, StarCraft genre. Each player begins the game controlling Thak, and a hut where cavemen can be trained. Thak himself is not a warrior. He builds walls. Warriors carry clubs and they do all the attacking.
    The objective of our game is to protect Thak at all costs. You are allowed to build up to 5 cavemen at a time, allowing you to make several cavemen, lose them, and make more. Walls can be used to blockade the enemy and protect your cavemen. To win the game, though, you need to kill your opponent`s Thak. Mouse and keyboard controls allow you to join Thak in his prehistoric quest to kick some cave-butt. Please see the web page for more information.
    Thak Writeup

    • Matt Wood: Concept/Graphics/Gameplay
    • Tim Zadigian: Sound Design/Gameplay
    • Dan Mueller: Mouse and Keyboard/Movement/Gameplay
    • Mike DelGuidice: Networking/Gameplay

    Zelda 291

    Zelda 291 is a two-dimensional tile-based game based on the classic NES game, The Legend of Zelda. The goal of the game is to get your character, Link, from the beginning of the dungeon to the end, where he must defeat the dread beast Lockwamentus and free ECE majors everywhere from the pain and torture of assembly programming.

    The game will run in Mode X with a resolution of 320 x 240, square pixels and page-flipping instead of double buffering.

    Improvements & Additions

    • Much more aggressive AI; each enemy has a field of vision, and when Link comes within a certain distance from a monster, it will chase him down. Also, each enemy slain in a room increases the field of vision of all the other enemies.
    • Improved graphics - no more 4-color sprites!
    • Body Checking - Link doesn`t sit in the corner and weep like a child when he gets hurt; running into a foe hurts the enemy just as much as it does him!
    Zelda291 Writeup

    • Will Grzanich: Graphics & Animation
    • Kevin Moore: Sound & Music
    • Benjamin J. Jefferson: Input, Introduction
    • Barry Huntley: Artificial Intelligence, Debugging
    • Anirban Chatterjee: Internal Game Logic