• Dots
  • Breakout
  • Number Munchers
  • Connect Four
  • AstroBob
  • Space Invaders
  • Missile Command
  • Tron
  • AntSim
  • Lewdicrous Adventures
  • Adventures of Alex Rosay
  • Video Poker
  • Biplanes
  • Monopoly
  • Pokemon
  • Football
  • Battle Royale 2011

Dots (Clayton Evans '11)
ScreenShot

UML



Dots is a simple two player game. Players take turns drawing lines between dots on a 10 by 10 grid. The object of the game is to complete as many complete boxes as possible. The game I made has a grid of white dots on a black background. Upon running the program, players can choose between a game with another human or a game with a computer. Players are then prompted for their name and a color for their squares (either red, green, or blue). A status bar at the bottom of the JFrame displays the current score and the player’s names and colors, along with the name of the player who’s turn it is.

Instructions:
Take turns drawing lines. To draw a line, click on two adjacent dots. Lines can only be drawn between two dots right next to each other in either the vertical or horizontal direction. Completing a box with a line causes your sore to increment by one, the square to be filled in with your color, and an opportunity to draw another line.

Interesting Features
1. The GUI is homemade, with help from Chapter 12 in Headfirst Java and code from the Java API.

2. Mouse clicks are honed into the exact pixel locations of the dots by an algorithm. Since the dots are spaced 50 pixels apart, the algorithm starts by taking the remainder of the mouse click value divided by 50. If this remainder is less than 25, the mouse click is closer to the multiple of 50 either to the left of (in the x direction) or above (in the y direction) it. In this case the value of the click is divided by 50 (which lops off the remainder) and then multiplied again by 50 to get the exact pixel location of the nearest dot. If the remainder is greater than 50, the mouse click is divided by 50 (again, to lop off the remainder), incremented by 1, and then multiplied by 50 to get the exact pixel location of the dot to the right of (x direction) or above (y direction) it.

3. An inner class in the Board class extends JPanel and allows for the formation of the GUI.


Breakout (Diego Morales '11)
ScreenShot

UML



Breakout! is my version of the popular Brickbreaker, Breakout, etc. games where the user controls a paddle ("a" to move left and "d" to move right) to bounce a ball  into bricks or blocks to earn points. I chose to make certain changes for GridWorld such as switching the usual paddle with a character I like to call Paddle Monster  featured on the game controller. Also, I substituted the abyss that is usually below  the paddle with Spikeys to destroy the ball and end the game. Generally, though,  the game plays the same as any of the other brick-breaking games.

The directions are shown at the top of the GridWorld GUI. Move the Paddle Monster such to hit the ball into the bricks and earn points. Certain bricks are worth more than others, so aim for the textured bricks instead of the simple colored bricks. Because the GUI is GridWorld, the game makes steps. The speed can be adjusted in-game. Also, the direction of the ball can be seen by its shading. The physics is pretty coin-flip based, or random, so be very careful to watch the direction and the movement of the ball. Enjoy!

Interesting Features:
1. I used GridWorld for this project, and I read about it extensively from online sources.
2. Also, because I used GridWorld, the player can create objects in-game by simply clicking on a grid space and picking from the options. Through this control, the player can edit the game anyway he or she likes such as adding balls or bricks or even spikeys.


Number Munchers (Sean Harger '11)
ScreenShot
ScreenShot

UML



Number Munchers is based off of an original DOS game by MECC which was released in 1991. I have many memories playing the game when I was in grade school, and these were the root of my inspiration for redeveloping it. I learned a great deal about programming and logic in the development process. I hope you enjoy playing it.

In Number Munchers, you play as a Muncher and your goal is to eat as many correct numbers as possible. The correct number criteria is listed at the top of the game board for each level. Each correct answer earns you points. Each incorrect answer causes you to lose a life. Avoid Troggles who will eat you if you land on their space. If you are eaten by a Troggle, you lose a life. Safety Squares are spots indicated by corner brackets where Troggles cannot enter. Use the Arrow Keys to move the Muncher. Use the Space Bar to eat a number. The escape key pauses the game.

All of the code for the game is original code using the Java API. Credit for all images and the game concept go to MECC.

Instructions if running .app executable (Mac OS X only):

1. Download the "Mac Application" zip file. The file should automatically extract upon download.
2. Drag "Number Munchers.app" to your Applications folder.
3. Double click "Number Munchers.app" to run the application.
Instructions if running from BlueJ project file:
1. download the "Source Code" zip file. The file should automatically extract upon download.
2. open the "Number Munchers" folder and open the "package.bluej" filewith BlueJ.
3. run the application by right clicking the "Driver" class and clicking the main method.
4. IMPORTANT: input {"JAR"} in the arguments box before you click "Ok" to run the application.

Some Interesting Features:
1. Custom created GUI using java.swing and java.awt packages. All images and drawings were all individually painted onto the GameFrame JFrame window.
2. The Safety Square and every Troggle refresh based on a Timer. A Timer sets a specific task to perform (refreshSafetySquare and autoMove) repeatedly over a specified interval of time. Each Timer creates a separate thread so each Troggle is essentially moving independently of what is happening in the rest of the code.
3. The Prime numbers are actually indexed before the filling of the game board. A method goes through all the possible prime numbers for the game and figures out which numbers in that range are prime. A array of booleans stores whether the index of the array is a prime number. For example, primesIndex[3] would be true and primesIndex[4] would be false.
4. The Game is dynamic in the sense that parameters can be set using a GameDefs file. The GameDefs file keeps track of the minimum and maximum numbers for a specified difficulty level. There is no way for the user to create and use a definitions file at the moment, but it is possible for you to modify the source code to add any definitions that you prefer.
5. The Game class acts as the main hub for the program. It serves as a place where objects can call back to get references to other objects to which methods can be called on. It is extremely important because it avoids having to send all of the object references to each class while allowing those remote objects to call methods on any object created within the game.


Connect Four (R.K. Smith '11)
ScreenShot

UML



The Game of ConnectFour is run in a way similar to playing the Hasbro game of Connect Four in real life. The players objective is to connect four pieces while simultaneously blocking the opponent from connecting four of his/her/its pieces.

The objective of ConnectFour, is simply, to connect four pieces before the other player. This can be done in either a row, column, or upwards or downwards diagonal. As long as neither player has allowed the other to connect four pieces, then the game continues. A computer or another player can be the opponent in the game.

The game is played through input in JOptionPane windows that prompt the player throughout the game. The first prompt box asks to play a computer or another person, enter “C” for computer or “H” for a human. The computer moves at random and uses black pieces. If playing another player, the first player will be prompted to move through JOptionPane and then chooses a column, 1-7. His piece falls to the lowest available row in the column, and then the second player moves. The game automatically checks to see if four pieces have been connected, and announces which player has won. A final JOptionPane input box opens and asks if the players wish to play again. If yes, a new grid is created for play.

Some interesting features include the remarkable intelligence of the Computer player. Also, the entire game is run through JOptionPane windows. A third special feature is the ability to play either the computer or another human player at ConnectFour.


AstroBob (Allan Morales '11)
ScreenShot

UML



StarGatherer_AstroBob is a hybrid snake game based from the original known as “Nibbles” from the mid 1970s. The game itself is very addictive and one of the first games I had played.The game logic is simple. You control AstroBob with the arrow keys to gather stars. Each time the player gets a star, a new one will respawn at a random location. At certain intervals based on multiples, point objects will also appear at random locations to further increment the player’s score. But be aware! Also at a certain interval, meteors will appear as obstructions in random locations. The player must avoid the rock barrier, these meteors, and AstroBob’s tail or else “Game Over”.

Credit for the music goes to the amazing makers of the popular XBOX 360 / iphone arcade game “The Impossible Game”. The pictures I got from Google Images. Most of this code is original using Java and GridWorld API. The AePlayWave and SoundRunnable classes were borrowed from Cameron Mott.

==========
Point System
==========
Stars = 100
SpaceCrystal = 250
ShootingStar = 500
Planet = 1000

At this point, a screen will pop up showing the player’s total score, how many times the player gathered a certain point object, and a “thank you” message. Then pressing OK, the window will close and a new one will open telling the player interesting facts and my personal message.

=============
Interesting Facts
=============
1. The only reason this zip file is bigger than most games is because of the music files.
Each .wav file is 25 MB each and some memory is allocated for the .gif images.
Trimidium sounds like an metal but it is not. But think about it, anything that sounds like a metal has an -ium suffix such as Europium and Californium. By the way, those last two are actually real man-made chemicals.

2. A shooting star isn't actually a star at all. The streaks of light that we see are actually caused by meteoroids entering our planetís atmosphere.

3. A star known as Betelgeuse in the constellation Orion has about 20 times the mass of the Sun, but itís 1,000 times larger.

4. Ishimura is actually the name for a spaceship from the popular XBOX 360 game Dead Space.

5. This is a computer science project in the best class--Mr. Lew's Period 6 AP Computer Science--at Loyola High School. Created by Allan Richmond 'Arich' Morales @ 2010-11. And music by the creators of the popular Xbox Live Arcade game / Iphone game app 'The Impossible Game'

====
Bugs
====
There are problems with the putSelfInGrid(grid, location) for certain methods of the game, which causes forced game over. A version 1.2 will be up hopefully soon to fix this bug.


Space Invaders (Wadsworth Williams '11)
ScreenShot

UML



Description:
Based on the classic 1978 arcade game, Space Invaders is a simple single player game of magnified importance. As the sole defender of Earth, you must destroy the invaders before they completely destroy your world. The fate of the Earth is in your hands.

Instructions:
The game is played by moving your ship, the white rectangle, with the left and right arrow keys. To fire your missiles, press the up arrow keys. The invaders move down the screen and fire missiles randomly at you. Your lives counter is in the upper left hand portion of the screen, and every time you are hit by a red missile your lives are decremented. You lose the game by running out of lives or allowing the invaders to reach Earth, the bottom of the screen. You are able to hide for safety under the green blocks.

Interesting Features:
The timer feature that puts the same “jagged feel” to the game as the original Space Invaders. The GUI is home made, and the movement and shooting method for the invaders works well and is simplified.


Missile Command (Chris Gaines '11)
ScreenShot

UML



Missile Command is a classic arcade game in which you attempt to defend your cities against an endless onslaught of missiles. The goal of the game is to survive as long as possible and gain as many points as you can. You are able to shoot missiles at the incoming missiles, which is how you accumulate points. Your point total and the current level you are on is displayed in the top left and top right, respectively. The longer you last, the greater the level and the faster and more numerous the incoming missiles become. See if you can beat 100,000 points!

Instructions:
Click to shoot a missile to defend your cities. Note, because of the restrictions on mouse-listeners you may need to double click to be sure that a missile fires. Last as long a possible.

Special Features
1) Made with its own GUI and has sound ;).


Tron (Charlie Menne '11)
ScreenShot

UML



Summary of Game: Tron
Tron is based off one of the Tron games, “Light Cycles”. I decided to make the game Tron after the movie Tron Legacy came out in theaters. I really enjoyed the remake of Tron and was inspired to make the game. In the game Tron, there is a grid with four players. There are three light cycles, basically motorcycles, players and one human player. Each motorcycle is given a color which leaves behind a colored line which acts like a wall. The goal is to avoid the walls of the grid as well as avoid the lines of the other light cycles. The last player alive wins the game.

Interesting Features
1. The computers AI is pretty smart, and is programmed to avoid the walls of the grid and the lines of other players. The AI was helped created and produced by CHRIS GAINES (Loyola class of 2011).
2. The game uses a Thread (sleepTimer) to control the speed of the game.

AntSim (Travis Johnson '11)
ScreenShot

UML

AntSim is not so much a game as a simulator of AI behavior in reaction to environmental conditions. The original inspiration comes from various ant simulators online and the Wikipedia page on ants. As it turns out, this game turned into as much an experiment in memory management as it was a simulator of AI. Unfortunately, this may have resulted in a problem which prevents macs from playing this game. Though so far no PC has had any trouble running the simulator, no mac has successfully run the sim.

The premise of this simulator is that ants behave according to a few simple rules. Ants behave based on their surroundings; however, they can also communicate with each other through scent trails. For the program execution, each ant individually decides how to act each time it moves. First off, the ant continues to follow any scent path it is already following or continues to head to any destination it is heading towards. If the ant is doing neither of these things, it checks its surroundings to decide how to move, placing different weight on different objects in its surroundings. If no decision can be made based on the surroundings then the ant moves randomly.

Interesting Features:
1. The simulator has a basic “Run Game” button that starts and pauses the simulator, while exiting the opened window will end the simulation.
2. The GUI itself borrows code from the Head First course book, though it is nonetheless originally written code due to the altering necessary for properly displaying the ants.
3. The Landscape class keeps track of all of the Actors on it with a 2DArray of ArrayLists in order to contain many ants in the same position; however, this results in the game overloading if the field size gets to large.
4. The Parameters Interface can customize how the ants interact with their surroundings, giving them criteria by which to weigh their surroundings and move.

Lewdicrous Adventures (Alex Rosay '11)
ScreenShot

UML



Summary of Game:
Mr. Lew is the ultimate enemy of senioritis. He will not allow us to be free. The students are charging for freedom now. Mr. Lew is trying to stop them using Lew Jugs, Personal Points, and Rube Goldberg Machines.
In Lewdicrous Adventures, you play as a Mr. Lew and your goal is to Lew Jug as many students as possible. The score is on the screen. Each jug earns you points and money. It costs $5000 to use a Rube Goldberg Machine that will clear the board. Each student that passes Mr. Lew loses you a life. There are walls to also help you and you can regenerate them by spending money. Click to send out the Lew Jugs and Personal Points.
All of the code for the game is original code using the Java API except for Brian Yi’s sound codes( U’ll hear the song when you play it ). Credit for all images go to google images.

Some Interesting Features:
1. Custom created GUI using java.swing and java.awt packages. All images and drawings were all individually painted onto the GameFrame JFrame window.
2. The Lew Jugs and Personal Points can only Jug one student and can be fired really fast using mouse Listeners and Mr. Lew is moved by the mouse.
3. The Rube Goldberg Machine clears the entire board.
4. Student faces are generate randomly and more than one object can appear at once. In fact technically unlimited can spawn but it is based on a random generator calling upon an ArrayList of students.
5. All the faces are faces of my beautiful classmates. They all have different move methods based on the character.
6. The walls have health and they lose their health when a face is on it and can regain health if the player chooses to do that.

Adventures of Alex Rosay (Brian Yi '11)
ScreenShot

UML



Summary of the Game:
Adventures of Alex Rosay is based off of the real life person Alex Rosay. The game is an original game that involves Alex shooting lightning at various monsters in order to kill them. The monsters are just snails but you kill them to get points. In order to stay alive you have to dodge the incoming ball. If the ball hits you three times you lose. Try to get the highest score possible. The score and health are displayed in the top left hand corner.

Some Interesting Features:
1. The GUI is custom made and it involves the use of JPanels.
2. You can only shoot one lightning at a time in order to keep people from spamming.
3. All pictures are from Google and uploaded pictures by Alex Rosay.
4. The game lags a little bit in the beginning but it speeds up later.
5. All my code is written in the screen class.
6. The code for sound and other functions are attained from Java API and Head First Java


Video Poker (Alex Monroe '11)
VideoPoker.zip
ScreenShot

UML



Video Poker is a simple poker game of five card draw versus a computer opponent. The human player starts with a 100 bankroll. He then makes a bet of a value less than his bankroll and uses the JOptionPane panels to discard the cards he does not want, and picks up cards to refill his hand. Then, the computer player performs this process on its own using its algorithm. The player doubles his bet if his hand is better than the computer’s, but the player loses his bet if his or hand is worse than the computer’s.

Instructions for Running
Select void main( String[] args ) from the PlayTheGame class. When GridWorld starts, click “run” to begin the game. Type in a bet, then select “Yes” or “No” to control which cards you keep. Try to get the best possible hand by keeping cards of the same rank or going for a straight or a flush. Then, wait for the computer to play and see the result. Repeat until you run out of money.

Interesting Features
The deck acts as one deck and not a shoe. This means that each card can only be used once during a hand. The deck is reshuffled after each hand. The computer player uses a simple AI system to check its own hand and then decide which cards to keep.
The majority of hand analysis stems from different orders that the hand can be sorted in. For example, the AI uses a helper method that sorts the hand by putting any paired cards first, followed by the unpaired cards in descending order. Sorting methods such as this one made the processing of hands much easier.

Biplanes (Morris Blaustein '11)
ScreenShot

UML



Biplanes was original produced by Mattel Electronics for its Intellevision video game system in 1981. Several years ago, I bought an intellevision emulator for the playstation 2 platform. I really enjoyed playing Biplanes on the PS2 emulator and created this new version of Biplanes to revitalize its awesomeness.

Biplanes has 2 game modes: the original battle mode and the exciting time trial mode. Each mode has updated graphics and can be played for hours upon hours upon hours.
In battle mode, 2 planes compete against each other to get to the score limit of 15. To score a point, the opposing players plane has to be destroyed. To destroy the opposing plane, a player has the ability to shoot missiles. Also, a point can be scored by destroying the weather ballon that drifts up randomly.
In time trial mode, players compete to survive the longest while random missiles fall from the sky. As time passes, more and more missiles begin to fall, and surviving becomes harder and harder.

Some Interesting Features:
1) The 2 cheats for the Blue Plane - clicking "K" will launch 3 missiles and clicking "L" will drop a homing missile from the top of the screen.
2) The gravity factor - used in the code to determine a flying object's speed.
3) Building the string of the image file based on the plane's angle every time the graphics update - ( "BluePlane" + bluePlane.getPlaneAngle() + ".png" )

Monopoly (Henry Anderson '11)
ScreenShot

UML



Monopoly is a familiar game to most, but here is a brief summary. Each player chooses a token (in my game the human is the Dog and the computer is the Shoe), which is moved around the perimeter of the board based on dice rolls. Each player starts with $1500. Every time a player lands on a property, he may buy it. If he chooses to forgo the opportunity, the property is auctioned off to the highest bidder. If a property is owned by an opponent, the player must pay rent. If all properties of a certain color are owned by one player, their rent increases and the player (or AI) has the option to buy houses, which greatly increase rent. Occasionally, the AI will request a trade, and the payer may respond by selecting which properties to trade, and whether any money should be involved. The AI may then accept or deny this trade. Chance cards and tax spaces further alter the player’s bankrolls. If a player is bankrupt at any time, he loses.

Interesting Features:
1. Monopoly is based in GridWorld, which is less flexible than a custom built GUI, but has some advantages with piece movement. Overriding step() allows game to take on a turn-based format.
2. Heavy use of static variables to allow the many classes to influence the dog and shoe’s bankrolls and allow easy access to ArrayLists of properties.
3. JOptionPane messages control most of the player’s choices in the game, from auction bids and property purchases to house purchases and trades.
4. Computer’s AI decides whether it will purchase a property, how much it will bid in an auction, whether it will buy houses on its monopoly properties, and whether it will accept a trade offer.

Pokemon (Anthony Pimentel '11)
ScreenShot

UML



Pokémon is easily one of the most popular Nintendo games ever created. If you have not played it before, it consists of a Pokémon trainer navigating a world full of enemy Pokémon, allies, and competing trainers. Allies provide some sort of useful aid in the game, like healing the player’s Pokémon or refilling the player’s items. When the trainer encounters an enemy (either encountered from the wild or from an opposing trainer), the Pokémon enter a battle in which they take turns attacking each other. When a wild enemy Pokémon’s health reaches zero, the battle is over, but when a trainer’s Pokémon’s health reaches zero, the next Pokémon in his or her party is brought out. The game is won when the player defeats his or her rival.

Instructions:
Control the player’s movement by typing W, A, S, or D in the controller frame. To interact with one of the other characters on the screen, type K. The Pokemon button in the controller frame allows you to see the stats of all the Pokemon in your party. The Item button allows you to use six items to improve your Pokemon’s stats. You choose which Pokemon to use the item on using a new JOptionPane window. When a battle starts, use the attack buttons to use an attack on your opponent.

Some Interesting Features:
1. The player cycles future steps and past steps to avoid “eating” the floor.
2. The attack method takes into account the strengths and weaknesses of the different types and some of them make sense in reality (e.g. Fire is string against Grass, Water is strong against Fire, etc.)
3. The world that the player lives in was created using GridWorld, but the battle scenarios were created by using the java.swing and java.awt packages.
4.There are some secrets in the game that give the player some (possibly unfair) advantages against all the other Pokémon.

Football (Jack Bush '11)
ScreenShot

UML



JBFL: The Jack Bush Football League is a football simulator between two teams, the Jets and the Saints, in which they will do battle on the virtual gridiron that I have created. The picking of plays is simple, both side of the ball pick either a run defense or offense or a pass defense or offense. The main difference between picking defensive pass or run is the activity of the Linebackers. The Linebackers will act as defensive lineman if the play is a run, and as defensive backs if the defensive play is pass. The program, through probability, will decide what happens within the play from how many yard the Runningback gets to if the play ends in either a competition or an interception.
Instructions:
These instructions are simple. The Saints always start with the ball, so the player playing as the saints will pick either an offensive pass or run, and then the defense, the Jets, pick either a defensive pass or run. these roles switch when the teams switch.

Interesting Features:
1. I found all of the stats either from Yahoo! Sports or Madden, these stats cause the outcome of the play.
2. Finding the probability of each play is found by a certain homemade algorithm. The algorithm generates a random number and from that compares it to a stat that has been retrieved from the Madden game itself.


The "Battle Royale" 2011
ScreenShot

UML



The 2011 BattleRoyale winner was Henry Anderson's "CleverNameCritter"! The BattleRunner and BattleGrid were written by Allan R. Morales. The BattleRunner allows for easy instantiation of multiple "Critters" from each player. The BattleGrid allows the user to specify the dimensions of the Grid at compile-time.

*AP is a registered trademark of the College Board.
* AP is a registered trademark of the College Board
2007-2013 Michael Lew
projectsAPCS