commit 2c31e23d1387caf5ba5f4e470f10f5bbadc8e83f
parent 0ad01c199f183dd0fa9c9a0f2f158030c114ad06
Author: mpizzzle <michael.770211@gmail.com>
Date: Sat, 2 Mar 2019 13:59:37 +0000
renaming entry point class names
Diffstat:
18 files changed, 3944 insertions(+), 3944 deletions(-)
diff --git a/Link/src/Link.java b/Link/src/Link.java
@@ -0,0 +1,536 @@
+import java.awt.Color;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.JFrame;
+
+/* Copyright (c) Mary Percival 2003 */
+/* Link game Created May 2003 */
+
+public class Link extends JFrame implements KeyListener, Runnable {
+ private static final long serialVersionUID = 136423218680421502L;
+ // all member variables 'static' because shared with the enemy action thread
+ static LinkArea area;
+ static boolean finished = false;
+ static boolean ingame = false;
+ static boolean juststarted = false;
+ static int level = 0;
+ static Point[] enemyPositions;
+ static Point playerPosition;
+ static Point[][] obstaclePositions;
+ static int direction[];
+ static Thread timer;
+ static int enemyNumber = 1, enemiesRemaining = 1, obstacleNumber = 1;
+ static boolean herocrouching = false;
+ static final int MAXLEVELS = 1;
+ static final int levellengths[] = new int[MAXLEVELS];
+ boolean hasWeaponOut = false;
+
+ static int LEFT = -1;
+ static int RIGHT = 1;
+
+ // the next 2 constants are overridden in init once we know the screen size
+ static int RIGHTEDGE = 789;
+ static int BOTTOMEDGE = 800;
+ //
+ static Point IMAGESIZE = new Point(152, 107);
+ static Point HEROPOS = new Point(63, 28);
+ static final int LEFTEDGE = -15;
+ static final int TOPEDGE = -10;
+ static final int FALLAMOUNT = 16; // amount he falls each time interval
+ static final int RISEAMOUNT = 16; // amount he rises each time interval
+ static int GROUNDLEVEL = 500;
+ static int XAMOUNT = 5;
+ static int YAMOUNT = 5;
+ static int JUMPAMOUNT = 70;
+ static final int X = 1;
+ static final int Y = 2;
+ static final int NOT = 3;
+ static final int DELAY = 60;
+
+ static int heroImageNo = 0;
+ static final int OBSTACLEIMAGES = 1;
+ static final int HEROIMAGES = 4;
+ static Image[] heroImages = new Image[HEROIMAGES];
+ static Image[] obstacleImages = new Image[OBSTACLEIMAGES]; // obstacles don't move
+ static int obstacleImageNo[];
+ static boolean heroleft = false;
+ static boolean jumping = false;
+ static Point warpzone;
+ // static boolean superjump = false;
+ static final int JUMPDURATION = 5;
+ static final int SUPERJUMPDURATION = 8;
+ static final int LEFTOFOBSTACLE = 27;
+ static final int RIGHTOFOBSTACLE = 33;
+ static int[] keysdown = new int[4];
+ static final int LEFTDOWN = 0;
+ static final int RIGHTDOWN = 1;
+ static final int DOWNDOWN = 2;
+ static final int SPACEDOWN = 3;
+
+ static final int OBSTACLEHEIGHT = 42;
+ boolean onTheWayUp = false;
+ static int startPosY = GROUNDLEVEL;
+
+ public static void main(String[] args) {
+ Link Link = new Link();
+
+ Link.setLayout(null);
+ Link.setBackground(Color.white);
+ Link.setSize(RIGHTEDGE, BOTTOMEDGE);
+
+ area = new LinkArea(Link);
+ Link.add(area);
+ XAMOUNT = 12;
+ YAMOUNT = 12;
+ //RIGHTEDGE = (Link.getBounds().width / XAMOUNT) * XAMOUNT + LEFTEDGE;
+ //BOTTOMEDGE = Link.getBounds().height - 1;
+ Link.setVisible(true);
+ //area.setBounds(0, 0, Link.getBounds().width, BOTTOMEDGE);
+ area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
+ area.setVisible(true);
+
+ Link.addKeyListener(Link);
+ area.addKeyListener(Link);
+ area.requestFocus();
+
+ levellengths[0] = RIGHTEDGE;
+ obstacleImages[0] = area.obstacle;
+
+ timer = new Thread(Link);
+ timer.start();
+ }
+
+ synchronized void faceRight() {
+ heroImages[0] = area.herostand;
+ heroImages[1] = area.hero1;
+ heroImages[2] = area.herostand;
+ heroImages[3] = area.hero2;
+ heroImageNo = 0;
+ heroleft = false;
+ }
+
+ synchronized void faceLeft() {
+ heroImages[0] = area.herostandleft;
+ heroImages[1] = area.hero1left;
+ heroImages[2] = area.herostandleft;
+ heroImages[3] = area.hero2left;
+ heroImageNo = 0;
+ heroleft = true;
+ }
+
+ synchronized void getSwordOut() {
+ hasWeaponOut = true;
+ if (heroleft) {
+ heroImages[0] = area.heroswordleft;
+ heroImages[1] = area.heroswordleft;
+ heroImages[2] = area.heroswordleft;
+ heroImages[3] = area.heroswordleft;
+ } else {
+ heroImages[0] = area.heroswordright;
+ heroImages[1] = area.heroswordright;
+ heroImages[2] = area.heroswordright;
+ heroImages[3] = area.heroswordright;
+ }
+ heroImageNo = 0;
+ }
+
+ synchronized void getShieldOut() {
+ hasWeaponOut = true;
+ if (heroleft) {
+ heroImages[0] = area.heroshieldleft;
+ heroImages[1] = area.heroshieldleft;
+ heroImages[2] = area.heroshieldleft;
+ heroImages[3] = area.heroshieldleft;
+ } else {
+ heroImages[0] = area.heroshieldright;
+ heroImages[1] = area.heroshieldright;
+ heroImages[2] = area.heroshieldright;
+ heroImages[3] = area.heroshieldright;
+ }
+ heroImageNo = 0;
+ }
+
+ synchronized void putWeaponAway() {
+ hasWeaponOut = false;
+ if (heroleft)
+ faceLeft();
+ else
+ faceRight();
+ }
+
+ synchronized void standStill() {
+ heroImageNo = 0;
+ }
+
+ public void doLevel(int level) {
+ // this runs one 'level'
+ juststarted = true;
+
+ System.out.println("Started level " + level);
+
+ // position Hero at the bottom left
+ playerPosition = new Point(LEFTEDGE, GROUNDLEVEL);
+ faceRight();
+
+ // initialise obstacle states
+ obstacleImageNo = new int[obstacleNumber];
+ obstacleImageNo[0] = 0;
+
+ // initialise the arrays of enemies, etc
+ enemyPositions = new Point[enemyNumber];
+ obstaclePositions = new Point[MAXLEVELS][obstacleNumber];
+ direction = new int[enemyNumber];
+ for (int i = 0; i < enemyNumber; i++) {
+ enemyPositions[i] = new Point(RIGHTEDGE, GROUNDLEVEL);
+ direction[i] = LEFT;
+ }
+ for (int i = 0; i < obstacleNumber; i++) {
+ switch (level) {
+ case 1:
+ obstaclePositions[level - 1][i] = new Point((RIGHTEDGE + 15) / 2, GROUNDLEVEL);
+ System.out.println("Obstacle positioned at (" + (RIGHTEDGE - LEFTEDGE) / 2 + ", " + GROUNDLEVEL + ")");
+ break;
+ default:
+ }
+ }
+
+ // position the warp zone at the end of the level
+ warpzone = new Point(levellengths[level - 1], GROUNDLEVEL);
+
+ // paint the panel here
+ // area.repaint();
+ ingame = true;
+ }
+
+ Point randomPosition() {
+ return new Point((int) (Math.random() * RIGHTEDGE) / XAMOUNT * XAMOUNT,
+ (int) (Math.random() * BOTTOMEDGE) / YAMOUNT * YAMOUNT);
+ }
+
+ boolean isPlayerPosition(Point p) {
+ return (p.x == playerPosition.x && p.y == playerPosition.y);
+ }
+
+ boolean isEnemyPosition(Point p) {
+ for (int i = 0; i < enemyNumber; i++) {
+ if (p.x == enemyPositions[i].x && p.y == enemyPositions[i].y)
+ return (true);
+ }
+ return (false);
+ }
+
+ boolean isObstaclePosition(Point p) {
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstacleX(p) != -1 && isObstacleY(p) != -1) {
+ return (true);
+ }
+ }
+ return (false);
+ }
+
+ boolean checkIfBlockingObstacle(Point p) {
+ boolean result = false;
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstacleX(p) != -1 && isBlockingObstacleY(p) != -1) {
+ // piranhaPopping[i] = false;
+ result = true;
+ }
+ // else piranhaPopping[i] = true;
+ }
+ if (!result)
+ startPosY = GROUNDLEVEL;
+ return (result);
+ }
+
+ int isObstacleX(Point p) {
+ int obstaclex;
+ for (int i = 0; i < obstacleNumber; i++) {
+ // if x is >= obstacleposition - (LEFTOFOBSTACLE) and x <= obstacleposition +
+ // (RIGHTOFOBSTACLE)
+ obstaclex = obstaclePositions[level - 1][i].x;
+ if (p.x >= (obstaclex - LEFTOFOBSTACLE) && p.x <= (obstaclex + RIGHTOFOBSTACLE))
+ return (i); // return the number of the matching obstacle
+ }
+ return (-1);
+ }
+
+ int isBlockingObstacleY(Point p) {
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (p.y <= obstaclePositions[level - 1][i].y - OBSTACLEHEIGHT)
+ return (i);
+ }
+ return (-1);
+ }
+
+ int isObstacleY(Point p) {
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (p.y > obstaclePositions[level - 1][i].y - OBSTACLEHEIGHT)
+ return (i);
+ }
+ return (-1);
+ }
+
+ public void finished() {
+ finished = true;
+ System.exit(0);
+ }
+
+ int randomMove() {
+ // return + or - value (randomly)
+ if (Math.random() >= 0.5)
+ return (24);
+ else
+ return (-24);
+ }
+
+ private synchronized void incKeysDown(int whichone) {
+ keysdown[whichone] = 1;
+ }
+
+ private synchronized void decKeysDown(int whichone) {
+ keysdown[whichone] = 0;
+ }
+
+ // this class will use just the key pressed event
+ @Override
+ public void keyPressed(KeyEvent e) {
+ if (ingame) {
+ if (!((e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_RIGHT && playerPosition.x >= (RIGHTEDGE - XAMOUNT)))) {
+ // valid move: move the player and then move the enemies
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ herocrouching = true;
+ incKeysDown(DOWNDOWN);
+ } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ incKeysDown(LEFTDOWN);
+ leftPressed();
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ incKeysDown(RIGHTDOWN);
+ rightPressed();
+ } else if (e.getKeyCode() == KeyEvent.VK_SPACE) {
+ // System.out.println("Jump when jumping is " + jumping);
+ if (!jumping) {
+ // incKeysDown(SPACEDOWN);
+ startPosY = playerPosition.y;
+ jumping = true;
+ onTheWayUp = true;
+ }
+ } else if (e.getKeyCode() == KeyEvent.VK_Z) {
+ getSwordOut();
+ } else if (e.getKeyCode() == KeyEvent.VK_X) {
+ getShieldOut();
+ }
+ if (isEnemyPosition(playerPosition)) {
+ System.out.println("The Player ran into an enemy!! Press the Enter key to restart the level");
+ ingame = false;
+ }
+ // area.repaint();
+ // System.out.println("Hero's position = (" + playerPosition.x + ", " +
+ // playerPosition.y + ")");
+ System.out.println(" ");
+ } // if valid key press
+ } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+ doLevel(++level);
+ }
+ }
+
+ void leftPressed() {
+ if (!herocrouching) {
+ // superjump = true; // if jumping
+ // if Hero was facing right, turn him left
+ if (!heroleft && !hasWeaponOut)
+ faceLeft();
+ else {
+ // if the target position is not occupied by a obstacle...
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstaclePosition(new Point(playerPosition.x - XAMOUNT, playerPosition.y)))
+ return; // can't move
+ }
+ playerPosition.x -= XAMOUNT;
+ incrementHeroImage();
+ }
+ }
+ }
+
+ void rightPressed() {
+ if (!herocrouching) {
+ // superjump = true; // if jumping
+ // if Hero was facing left, turn him right
+ if (heroleft && !hasWeaponOut)
+ faceRight();
+ else {
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstaclePosition(new Point(playerPosition.x + XAMOUNT, playerPosition.y)))
+ return; // can't move
+ }
+ playerPosition.x += XAMOUNT;
+ incrementHeroImage();
+ }
+ }
+ }
+
+ @Override
+ public void run() {
+ while (true) {
+ if (juststarted) {
+ try {
+ Thread.sleep(750);
+ } catch (Exception e) {
+ }
+ area.repaint();
+ juststarted = false;
+ }
+ try {
+ Thread.sleep(DELAY);
+ } catch (InterruptedException e) {
+ }
+ if (ingame) {
+ // System.out.println("Run: BEFORE: Hero's position = (" + playerPosition.x + ",
+ // " + playerPosition.y + ")");
+ if (keysdown[LEFTDOWN] == 0 && keysdown[RIGHTDOWN] == 0
+ && keysdown[DOWNDOWN] == 0 /*
+ * && keysdown[SPACEDOWN] == 0
+ */)
+ standStill();
+
+ if (keysdown[LEFTDOWN] > 0)
+ leftPressed();
+ else if (keysdown[RIGHTDOWN] > 0)
+ rightPressed();
+
+ // for each obstacle, cycle through the piranha pictures
+ for (int i = 0; i < obstacleNumber; i++) {
+ incrementObstacleImage(i);
+ }
+
+ /*
+ * // for each enemy, move the enemy in the direction it was going for (int i=0;
+ * i < enemyPositions.length; i++) { if (!deadHero(enemyPositions[i])) {
+ * enemyPositions[i] = move(enemyPositions[i], direction[i]); } // if there is a
+ * obstacle at that position, fall into it and decrement count of enemies // and
+ * set that enemy's position to -1, -1 if
+ * (isObstaclePosition(enemyPositions[i])) {
+ * System.out.println("A enemy fell into a obstacle");
+ *
+ * enemyPositions[i] = new Point(-1, -1); enemiesRemaining--;
+ * System.out.println(enemyNumber-enemiesRemaining + " down, " +
+ * enemiesRemaining + " to go..."); } // if player is caught by a enemy or all
+ * enemies are gone, end the game if (isPlayerPosition(enemyPositions[i])) {
+ * System.out.
+ * println("\"Mmm! Brains...\". The Player is dead. Press the Enter key to restart the level"
+ * ); level--; // because it will be incremented in a minute and we want to stay
+ * on the same 'level' ingame = false; } } if (enemiesRemaining == 0) {
+ * System.out.
+ * println("All the enemies are gone -- you won!! Press the Enter key to start the next level"
+ * ); enemyNumber++; if (obstacleNumber > 2) obstacleNumber--; ingame = false; }
+ */
+ if (onTheWayUp) {
+ // System.out.println("OnTheWayUp. Start Y Position =" + startPosY);
+ if (playerPosition.y > startPosY - JUMPAMOUNT)
+ playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
+ else {
+ onTheWayUp = false;
+ }
+ } else {
+ int obstacleno = isObstacleX(playerPosition);
+ if (obstacleno == -1) { // no obstacle at this position
+ if (onTheWayUp == false) {
+ if (playerPosition.y < startPosY)
+ playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
+ else
+ jumping = false;
+ }
+ } else {
+ Point obstaclepos = obstaclePositions[level - 1][obstacleno];
+ // if hero's y position <= obstacle's height
+ if (playerPosition.y <= (obstaclepos.y - OBSTACLEHEIGHT)) { // can't land on the obstacle if
+ // just < (??!)
+ // allow hero to land on the obstacle
+ // System.out.println("Allow Hero to land (or stay) on obstacle");
+ jumping = false;
+ playerPosition = new Point(playerPosition.x, obstaclepos.y - OBSTACLEHEIGHT);
+ // if the piranha was up, Hero dies
+ if (obstacleImages[obstacleImageNo[obstacleno]] != area.obstacle) {
+ System.out.println("Hero dies!!");
+ ingame = false;
+
+ }
+ /*
+ * else { // otherwise stop this Piranha piranhaPopping[obstacleno] = false; }
+ */
+ } else {
+ if (onTheWayUp == false) {
+ if (playerPosition.y < startPosY)
+ playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
+ else
+ jumping = false;
+ }
+ }
+ }
+ }
+ checkIfBlockingObstacle(playerPosition);
+ // System.out.println("Run: AFTER: Hero's position = (" + playerPosition.x + ",
+ // " + playerPosition.y + ")");
+ area.repaint();
+ }
+ }
+ }
+
+ synchronized void incrementObstacleImage(int i) {
+ obstacleImageNo[i]++;
+ if (obstacleImageNo[i] == OBSTACLEIMAGES)
+ obstacleImageNo[i] = 0;
+ }
+
+ synchronized void incrementHeroImage() {
+ heroImageNo++;
+ if (heroImageNo == HEROIMAGES)
+ heroImageNo = 0;
+ }
+
+ Point move(Point start, int direction) {
+ return (new Point(start.x + direction, start.y));
+ }
+
+ boolean deadHero(Point p) {
+ return (p.x == -1 && p.y == -1);
+ }
+
+ @Override
+ public void keyReleased(KeyEvent e) {
+ // boolean needrepaint = false;
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ herocrouching = false;
+ decKeysDown(DOWNDOWN);
+ // needrepaint = true;
+ }
+ /*
+ * else if (e.getKeyCode() == KeyEvent.VK_SPACE) { decKeysDown(SPACEDOWN); }
+ */
+ else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ decKeysDown(LEFTDOWN);
+ // superjump = false;
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ decKeysDown(RIGHTDOWN);
+ // superjump = false;
+ } else
+ putWeaponAway();
+ // if (needrepaint) area.repaint();
+ }
+
+ @Override
+ public void keyTyped(KeyEvent e) {
+ }
+
+ synchronized Image getHeroImage() {
+ return (heroImages[heroImageNo]);
+ }
+
+ synchronized Image getObstacleImage(int obstaclenum) {
+ return (obstacleImages[obstacleImageNo[obstaclenum]]);
+ }
+
+}
diff --git a/Link/src/LinkArea.java b/Link/src/LinkArea.java
@@ -12,7 +12,7 @@ public class LinkArea extends JPanel {
private static final long serialVersionUID = 635033554190094921L;
static final int FLOORLEVEL = 587;
static final int FLOORWIDTH = 150;
- LinkGame myApplet = null;
+ Link myApplet = null;
Image yellowgem;
Image spider;
Image obstacle;
@@ -38,7 +38,7 @@ public class LinkArea extends JPanel {
Image blob;
MediaTracker mt = null;
- public LinkArea(LinkGame parent) {
+ public LinkArea(Link parent) {
mt = new MediaTracker(parent);
myApplet = parent;
yellowgem = load(myApplet, "yellowgem.gif");
@@ -79,7 +79,7 @@ public class LinkArea extends JPanel {
}
}
- Image load(LinkGame parent, String picture) {
+ Image load(Link parent, String picture) {
try {
Image im = ImageIO.read(new File("../Assets/" + picture));
checkImage(im, picture);
@@ -107,12 +107,12 @@ public class LinkArea extends JPanel {
* g.drawImage(floor,pos, FLOORLEVEL,Color.black, null); }
*/
- if (LinkGame.obstaclePositions != null) {
+ if (Link.obstaclePositions != null) {
// show the obstacles
- for (int i = 0; i < LinkGame.obstaclePositions.length; i++) {
+ for (int i = 0; i < Link.obstaclePositions.length; i++) {
obstacleimage = myApplet.getObstacleImage(i);
- g.drawImage(obstacleimage, LinkGame.obstaclePositions[LinkGame.level - 1][i].x,
- LinkGame.obstaclePositions[LinkGame.level - 1][i].y - 4, Color.white, null);
+ g.drawImage(obstacleimage, Link.obstaclePositions[Link.level - 1][i].x,
+ Link.obstaclePositions[Link.level - 1][i].y - 4, Color.white, null);
}
}
@@ -122,7 +122,7 @@ public class LinkArea extends JPanel {
* myApplet.enemyPositions[i].x, myApplet.enemyPositions[i].y,null); } }
*/
// draw Hero (on top of preceding images)
- if (LinkGame.playerPosition != null) {
+ if (Link.playerPosition != null) {
// show the player
Image herosimage = myApplet.getHeroImage();
/*
@@ -130,7 +130,7 @@ public class LinkArea extends JPanel {
* herocrouchleft; else herosimage = herocrouch; } if (myApplet.jumping) { if
* (myApplet.heroleft) herosimage = herojumpleft; else herosimage = herojump; }
*/
- g.drawImage(herosimage, LinkGame.playerPosition.x, LinkGame.playerPosition.y, /* Color.white, */ null);
+ g.drawImage(herosimage, Link.playerPosition.x, Link.playerPosition.y, /* Color.white, */ null);
}
/*
* // draw warp image (on top of Hero) if (myApplet.warpzone != null) { // show
diff --git a/Link/src/LinkGame.java b/Link/src/LinkGame.java
@@ -1,536 +0,0 @@
-import java.awt.Color;
-import java.awt.Image;
-import java.awt.Point;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-
-import javax.swing.JFrame;
-
-/* Copyright (c) Mary Percival 2003 */
-/* Link game Created May 2003 */
-
-public class LinkGame extends JFrame implements KeyListener, Runnable {
- private static final long serialVersionUID = 136423218680421502L;
- // all member variables 'static' because shared with the enemy action thread
- static LinkArea area;
- static boolean finished = false;
- static boolean ingame = false;
- static boolean juststarted = false;
- static int level = 0;
- static Point[] enemyPositions;
- static Point playerPosition;
- static Point[][] obstaclePositions;
- static int direction[];
- static Thread timer;
- static int enemyNumber = 1, enemiesRemaining = 1, obstacleNumber = 1;
- static boolean herocrouching = false;
- static final int MAXLEVELS = 1;
- static final int levellengths[] = new int[MAXLEVELS];
- boolean hasWeaponOut = false;
-
- static int LEFT = -1;
- static int RIGHT = 1;
-
- // the next 2 constants are overridden in init once we know the screen size
- static int RIGHTEDGE = 789;
- static int BOTTOMEDGE = 800;
- //
- static Point IMAGESIZE = new Point(152, 107);
- static Point HEROPOS = new Point(63, 28);
- static final int LEFTEDGE = -15;
- static final int TOPEDGE = -10;
- static final int FALLAMOUNT = 16; // amount he falls each time interval
- static final int RISEAMOUNT = 16; // amount he rises each time interval
- static int GROUNDLEVEL = 500;
- static int XAMOUNT = 5;
- static int YAMOUNT = 5;
- static int JUMPAMOUNT = 70;
- static final int X = 1;
- static final int Y = 2;
- static final int NOT = 3;
- static final int DELAY = 60;
-
- static int heroImageNo = 0;
- static final int OBSTACLEIMAGES = 1;
- static final int HEROIMAGES = 4;
- static Image[] heroImages = new Image[HEROIMAGES];
- static Image[] obstacleImages = new Image[OBSTACLEIMAGES]; // obstacles don't move
- static int obstacleImageNo[];
- static boolean heroleft = false;
- static boolean jumping = false;
- static Point warpzone;
- // static boolean superjump = false;
- static final int JUMPDURATION = 5;
- static final int SUPERJUMPDURATION = 8;
- static final int LEFTOFOBSTACLE = 27;
- static final int RIGHTOFOBSTACLE = 33;
- static int[] keysdown = new int[4];
- static final int LEFTDOWN = 0;
- static final int RIGHTDOWN = 1;
- static final int DOWNDOWN = 2;
- static final int SPACEDOWN = 3;
-
- static final int OBSTACLEHEIGHT = 42;
- boolean onTheWayUp = false;
- static int startPosY = GROUNDLEVEL;
-
- public static void main(String[] args) {
- LinkGame linkGame = new LinkGame();
-
- linkGame.setLayout(null);
- linkGame.setBackground(Color.white);
- linkGame.setSize(RIGHTEDGE, BOTTOMEDGE);
-
- area = new LinkArea(linkGame);
- linkGame.add(area);
- XAMOUNT = 12;
- YAMOUNT = 12;
- //RIGHTEDGE = (linkGame.getBounds().width / XAMOUNT) * XAMOUNT + LEFTEDGE;
- //BOTTOMEDGE = linkGame.getBounds().height - 1;
- linkGame.setVisible(true);
- //area.setBounds(0, 0, linkGame.getBounds().width, BOTTOMEDGE);
- area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
- area.setVisible(true);
-
- linkGame.addKeyListener(linkGame);
- area.addKeyListener(linkGame);
- area.requestFocus();
-
- levellengths[0] = RIGHTEDGE;
- obstacleImages[0] = area.obstacle;
-
- timer = new Thread(linkGame);
- timer.start();
- }
-
- synchronized void faceRight() {
- heroImages[0] = area.herostand;
- heroImages[1] = area.hero1;
- heroImages[2] = area.herostand;
- heroImages[3] = area.hero2;
- heroImageNo = 0;
- heroleft = false;
- }
-
- synchronized void faceLeft() {
- heroImages[0] = area.herostandleft;
- heroImages[1] = area.hero1left;
- heroImages[2] = area.herostandleft;
- heroImages[3] = area.hero2left;
- heroImageNo = 0;
- heroleft = true;
- }
-
- synchronized void getSwordOut() {
- hasWeaponOut = true;
- if (heroleft) {
- heroImages[0] = area.heroswordleft;
- heroImages[1] = area.heroswordleft;
- heroImages[2] = area.heroswordleft;
- heroImages[3] = area.heroswordleft;
- } else {
- heroImages[0] = area.heroswordright;
- heroImages[1] = area.heroswordright;
- heroImages[2] = area.heroswordright;
- heroImages[3] = area.heroswordright;
- }
- heroImageNo = 0;
- }
-
- synchronized void getShieldOut() {
- hasWeaponOut = true;
- if (heroleft) {
- heroImages[0] = area.heroshieldleft;
- heroImages[1] = area.heroshieldleft;
- heroImages[2] = area.heroshieldleft;
- heroImages[3] = area.heroshieldleft;
- } else {
- heroImages[0] = area.heroshieldright;
- heroImages[1] = area.heroshieldright;
- heroImages[2] = area.heroshieldright;
- heroImages[3] = area.heroshieldright;
- }
- heroImageNo = 0;
- }
-
- synchronized void putWeaponAway() {
- hasWeaponOut = false;
- if (heroleft)
- faceLeft();
- else
- faceRight();
- }
-
- synchronized void standStill() {
- heroImageNo = 0;
- }
-
- public void doLevel(int level) {
- // this runs one 'level'
- juststarted = true;
-
- System.out.println("Started level " + level);
-
- // position Hero at the bottom left
- playerPosition = new Point(LEFTEDGE, GROUNDLEVEL);
- faceRight();
-
- // initialise obstacle states
- obstacleImageNo = new int[obstacleNumber];
- obstacleImageNo[0] = 0;
-
- // initialise the arrays of enemies, etc
- enemyPositions = new Point[enemyNumber];
- obstaclePositions = new Point[MAXLEVELS][obstacleNumber];
- direction = new int[enemyNumber];
- for (int i = 0; i < enemyNumber; i++) {
- enemyPositions[i] = new Point(RIGHTEDGE, GROUNDLEVEL);
- direction[i] = LEFT;
- }
- for (int i = 0; i < obstacleNumber; i++) {
- switch (level) {
- case 1:
- obstaclePositions[level - 1][i] = new Point((RIGHTEDGE + 15) / 2, GROUNDLEVEL);
- System.out.println("Obstacle positioned at (" + (RIGHTEDGE - LEFTEDGE) / 2 + ", " + GROUNDLEVEL + ")");
- break;
- default:
- }
- }
-
- // position the warp zone at the end of the level
- warpzone = new Point(levellengths[level - 1], GROUNDLEVEL);
-
- // paint the panel here
- // area.repaint();
- ingame = true;
- }
-
- Point randomPosition() {
- return new Point((int) (Math.random() * RIGHTEDGE) / XAMOUNT * XAMOUNT,
- (int) (Math.random() * BOTTOMEDGE) / YAMOUNT * YAMOUNT);
- }
-
- boolean isPlayerPosition(Point p) {
- return (p.x == playerPosition.x && p.y == playerPosition.y);
- }
-
- boolean isEnemyPosition(Point p) {
- for (int i = 0; i < enemyNumber; i++) {
- if (p.x == enemyPositions[i].x && p.y == enemyPositions[i].y)
- return (true);
- }
- return (false);
- }
-
- boolean isObstaclePosition(Point p) {
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstacleX(p) != -1 && isObstacleY(p) != -1) {
- return (true);
- }
- }
- return (false);
- }
-
- boolean checkIfBlockingObstacle(Point p) {
- boolean result = false;
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstacleX(p) != -1 && isBlockingObstacleY(p) != -1) {
- // piranhaPopping[i] = false;
- result = true;
- }
- // else piranhaPopping[i] = true;
- }
- if (!result)
- startPosY = GROUNDLEVEL;
- return (result);
- }
-
- int isObstacleX(Point p) {
- int obstaclex;
- for (int i = 0; i < obstacleNumber; i++) {
- // if x is >= obstacleposition - (LEFTOFOBSTACLE) and x <= obstacleposition +
- // (RIGHTOFOBSTACLE)
- obstaclex = obstaclePositions[level - 1][i].x;
- if (p.x >= (obstaclex - LEFTOFOBSTACLE) && p.x <= (obstaclex + RIGHTOFOBSTACLE))
- return (i); // return the number of the matching obstacle
- }
- return (-1);
- }
-
- int isBlockingObstacleY(Point p) {
- for (int i = 0; i < obstacleNumber; i++) {
- if (p.y <= obstaclePositions[level - 1][i].y - OBSTACLEHEIGHT)
- return (i);
- }
- return (-1);
- }
-
- int isObstacleY(Point p) {
- for (int i = 0; i < obstacleNumber; i++) {
- if (p.y > obstaclePositions[level - 1][i].y - OBSTACLEHEIGHT)
- return (i);
- }
- return (-1);
- }
-
- public void finished() {
- finished = true;
- System.exit(0);
- }
-
- int randomMove() {
- // return + or - value (randomly)
- if (Math.random() >= 0.5)
- return (24);
- else
- return (-24);
- }
-
- private synchronized void incKeysDown(int whichone) {
- keysdown[whichone] = 1;
- }
-
- private synchronized void decKeysDown(int whichone) {
- keysdown[whichone] = 0;
- }
-
- // this class will use just the key pressed event
- @Override
- public void keyPressed(KeyEvent e) {
- if (ingame) {
- if (!((e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_RIGHT && playerPosition.x >= (RIGHTEDGE - XAMOUNT)))) {
- // valid move: move the player and then move the enemies
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- herocrouching = true;
- incKeysDown(DOWNDOWN);
- } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- incKeysDown(LEFTDOWN);
- leftPressed();
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- incKeysDown(RIGHTDOWN);
- rightPressed();
- } else if (e.getKeyCode() == KeyEvent.VK_SPACE) {
- // System.out.println("Jump when jumping is " + jumping);
- if (!jumping) {
- // incKeysDown(SPACEDOWN);
- startPosY = playerPosition.y;
- jumping = true;
- onTheWayUp = true;
- }
- } else if (e.getKeyCode() == KeyEvent.VK_Z) {
- getSwordOut();
- } else if (e.getKeyCode() == KeyEvent.VK_X) {
- getShieldOut();
- }
- if (isEnemyPosition(playerPosition)) {
- System.out.println("The Player ran into an enemy!! Press the Enter key to restart the level");
- ingame = false;
- }
- // area.repaint();
- // System.out.println("Hero's position = (" + playerPosition.x + ", " +
- // playerPosition.y + ")");
- System.out.println(" ");
- } // if valid key press
- } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
- doLevel(++level);
- }
- }
-
- void leftPressed() {
- if (!herocrouching) {
- // superjump = true; // if jumping
- // if Hero was facing right, turn him left
- if (!heroleft && !hasWeaponOut)
- faceLeft();
- else {
- // if the target position is not occupied by a obstacle...
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstaclePosition(new Point(playerPosition.x - XAMOUNT, playerPosition.y)))
- return; // can't move
- }
- playerPosition.x -= XAMOUNT;
- incrementHeroImage();
- }
- }
- }
-
- void rightPressed() {
- if (!herocrouching) {
- // superjump = true; // if jumping
- // if Hero was facing left, turn him right
- if (heroleft && !hasWeaponOut)
- faceRight();
- else {
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstaclePosition(new Point(playerPosition.x + XAMOUNT, playerPosition.y)))
- return; // can't move
- }
- playerPosition.x += XAMOUNT;
- incrementHeroImage();
- }
- }
- }
-
- @Override
- public void run() {
- while (true) {
- if (juststarted) {
- try {
- Thread.sleep(750);
- } catch (Exception e) {
- }
- area.repaint();
- juststarted = false;
- }
- try {
- Thread.sleep(DELAY);
- } catch (InterruptedException e) {
- }
- if (ingame) {
- // System.out.println("Run: BEFORE: Hero's position = (" + playerPosition.x + ",
- // " + playerPosition.y + ")");
- if (keysdown[LEFTDOWN] == 0 && keysdown[RIGHTDOWN] == 0
- && keysdown[DOWNDOWN] == 0 /*
- * && keysdown[SPACEDOWN] == 0
- */)
- standStill();
-
- if (keysdown[LEFTDOWN] > 0)
- leftPressed();
- else if (keysdown[RIGHTDOWN] > 0)
- rightPressed();
-
- // for each obstacle, cycle through the piranha pictures
- for (int i = 0; i < obstacleNumber; i++) {
- incrementObstacleImage(i);
- }
-
- /*
- * // for each enemy, move the enemy in the direction it was going for (int i=0;
- * i < enemyPositions.length; i++) { if (!deadHero(enemyPositions[i])) {
- * enemyPositions[i] = move(enemyPositions[i], direction[i]); } // if there is a
- * obstacle at that position, fall into it and decrement count of enemies // and
- * set that enemy's position to -1, -1 if
- * (isObstaclePosition(enemyPositions[i])) {
- * System.out.println("A enemy fell into a obstacle");
- *
- * enemyPositions[i] = new Point(-1, -1); enemiesRemaining--;
- * System.out.println(enemyNumber-enemiesRemaining + " down, " +
- * enemiesRemaining + " to go..."); } // if player is caught by a enemy or all
- * enemies are gone, end the game if (isPlayerPosition(enemyPositions[i])) {
- * System.out.
- * println("\"Mmm! Brains...\". The Player is dead. Press the Enter key to restart the level"
- * ); level--; // because it will be incremented in a minute and we want to stay
- * on the same 'level' ingame = false; } } if (enemiesRemaining == 0) {
- * System.out.
- * println("All the enemies are gone -- you won!! Press the Enter key to start the next level"
- * ); enemyNumber++; if (obstacleNumber > 2) obstacleNumber--; ingame = false; }
- */
- if (onTheWayUp) {
- // System.out.println("OnTheWayUp. Start Y Position =" + startPosY);
- if (playerPosition.y > startPosY - JUMPAMOUNT)
- playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
- else {
- onTheWayUp = false;
- }
- } else {
- int obstacleno = isObstacleX(playerPosition);
- if (obstacleno == -1) { // no obstacle at this position
- if (onTheWayUp == false) {
- if (playerPosition.y < startPosY)
- playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
- else
- jumping = false;
- }
- } else {
- Point obstaclepos = obstaclePositions[level - 1][obstacleno];
- // if hero's y position <= obstacle's height
- if (playerPosition.y <= (obstaclepos.y - OBSTACLEHEIGHT)) { // can't land on the obstacle if
- // just < (??!)
- // allow hero to land on the obstacle
- // System.out.println("Allow Hero to land (or stay) on obstacle");
- jumping = false;
- playerPosition = new Point(playerPosition.x, obstaclepos.y - OBSTACLEHEIGHT);
- // if the piranha was up, Hero dies
- if (obstacleImages[obstacleImageNo[obstacleno]] != area.obstacle) {
- System.out.println("Hero dies!!");
- ingame = false;
-
- }
- /*
- * else { // otherwise stop this Piranha piranhaPopping[obstacleno] = false; }
- */
- } else {
- if (onTheWayUp == false) {
- if (playerPosition.y < startPosY)
- playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
- else
- jumping = false;
- }
- }
- }
- }
- checkIfBlockingObstacle(playerPosition);
- // System.out.println("Run: AFTER: Hero's position = (" + playerPosition.x + ",
- // " + playerPosition.y + ")");
- area.repaint();
- }
- }
- }
-
- synchronized void incrementObstacleImage(int i) {
- obstacleImageNo[i]++;
- if (obstacleImageNo[i] == OBSTACLEIMAGES)
- obstacleImageNo[i] = 0;
- }
-
- synchronized void incrementHeroImage() {
- heroImageNo++;
- if (heroImageNo == HEROIMAGES)
- heroImageNo = 0;
- }
-
- Point move(Point start, int direction) {
- return (new Point(start.x + direction, start.y));
- }
-
- boolean deadHero(Point p) {
- return (p.x == -1 && p.y == -1);
- }
-
- @Override
- public void keyReleased(KeyEvent e) {
- boolean needrepaint = false;
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- herocrouching = false;
- decKeysDown(DOWNDOWN);
- needrepaint = true;
- }
- /*
- * else if (e.getKeyCode() == KeyEvent.VK_SPACE) { decKeysDown(SPACEDOWN); }
- */
- else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- decKeysDown(LEFTDOWN);
- // superjump = false;
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- decKeysDown(RIGHTDOWN);
- // superjump = false;
- } else
- putWeaponAway();
- // if (needrepaint) area.repaint();
- }
-
- @Override
- public void keyTyped(KeyEvent e) {
- }
-
- synchronized Image getHeroImage() {
- return (heroImages[heroImageNo]);
- }
-
- synchronized Image getObstacleImage(int obstaclenum) {
- return (obstacleImages[obstacleImageNo[obstaclenum]]);
- }
-
-}
diff --git a/Mario/src/Mario.java b/Mario/src/Mario.java
@@ -0,0 +1,1509 @@
+
+/* Copyright (c) Mary Percival 2003 */
+/* Mario game Created May 2003 */
+
+import java.awt.Color;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.JFrame;
+
+public class Mario extends JFrame implements KeyListener, Runnable {
+ private static final long serialVersionUID = 7030451342808203557L;
+ boolean easymode = true;
+ static int MAXLEVEL = 9;
+ static int level = 0;
+
+ // the levels so far are:
+ // 1 beginner level: 1 piranha & 1 goomba
+ // 2 introducing green koopa
+ // 3 more of the same
+ // 4 introducing red koopa (flying)
+ // 5 more and harder
+ // 6 ?
+ // 7 ?
+ // 8 ?
+ // 9 ?
+
+ static int LEFT = 1;
+ static int RIGHT = 0;
+ // the next 2 constants are overridden in init once we know the screen size
+ static int RIGHTEDGE = 789;
+ static int BOTTOMEDGE = 800;
+ static int PAGEWIDTH = 741;
+
+ static Point IMAGESIZE = new Point(152, 107);
+ static final int LEFTEDGE = -45;
+ static final int TOPEDGE = -10;
+ static int GROUNDLEVEL = 503;
+ static int startPosY;
+ static int JUMPAMOUNT = 90;
+ static int BOUNCEAMOUNT = 90;
+ static final int FALLAMOUNT = 16; // amount he falls each time interval
+ static final int RISEAMOUNT = 16; // amount he rises each time interval
+ static final int XAMOUNT = 12;
+
+ static final int X = 1;
+ static final int Y = 2;
+ static final int NOT = 3;
+ static final int DELAY = 50;
+
+ static final int OBSTACLEIMAGES = 19;
+ static final int HEROIMAGES = 4;
+ static final int ENEMYIMAGES = 3;
+
+ // ----------------------------------------------------------------------------------------------
+ // ENEMY TYPES
+ // ----------------------------------------------------------------------------------------------
+ static final int ENEMYTYPES = 15; // goomba, koopa red, koopa green, koopa red flying, banzai, wiggler, boo,
+ // fireboo,bobomb,warship,yeti,chainchomp,atom
+ static final int GOOMBA = 0;
+ static final int KOOPARED = 1;
+ static final int KOOPAGREEN = 2;
+ static final int KOOPAREDFLYING = 3;
+ static final int BANZAI = 4;
+ static final int WIGGLER = 5;
+ static final int BOO = 6;
+ static final int FIREBOO = 7;
+ static final int BOBOMB = 8;
+ static final int BULLET = 9;
+ static final int WARSHIP = 10;
+ static final int YETI = 11;
+ static final int FLYER = 12;
+ static final int CHOMP = 13;
+ static final int ATOM = 14;
+
+ // enemy positions (height)
+ static final int GOOMBAHEIGHT = GROUNDLEVEL + 55;
+ static final int KOOPAREDHEIGHT = GROUNDLEVEL + 39;
+ static final int KOOPAGREENHEIGHT = GROUNDLEVEL + 39;
+ static final int KOOPAREDFLYINGHEIGHT = GROUNDLEVEL - 16;
+ static final int BANZAIHEIGHT = GROUNDLEVEL - 90;
+ static final int WIGGLERHEIGHT = GROUNDLEVEL + 16;
+ static final int BOOHEIGHT = GROUNDLEVEL - 7;
+ static final int FIREBOOHEIGHT = GROUNDLEVEL - 7;
+ static final int BOBOMBHEIGHT = GROUNDLEVEL + 5;
+ static final int BULLETHEIGHT = GROUNDLEVEL + 55;
+ static final int WARSHIPHEIGHT = GROUNDLEVEL + 100;
+ static final int YETIHEIGHT = GROUNDLEVEL;
+ static final int FLYERHEIGHT = GROUNDLEVEL - 20;
+ static final int CHOMPHEIGHT = GROUNDLEVEL - 55;
+ static final int ATOMHEIGHT = GROUNDLEVEL + 40;
+ static int enemyHeight[] = new int[ENEMYTYPES];
+
+ static final int enemySize[] = { 27, 42, 42, 42, 172, 75, 37, 37, 74, 8, 152, 86, 86, 75, 25 };
+ static final int enemyTopSpace[] = { 4, 13, 13, 0, 0, 10, 6, 6, 7, 0, 20, 8, 17, 10, 0 };
+
+ static final int SPACE_FROM_X_TO_MARIO = 55;
+ static final int MARIOHEIGHT = 86;
+ static final int MARIOOFFSET = 21;
+ static final int MARIOCROUCHOFFSET = 39;
+ static final int MARIOSTANDINGSIZE = 65;
+ static final int MARIOCROUCHINGSIZE = 45;
+
+ static final int JUMPDURATION = 5;
+ static final int SUPERJUMPDURATION = 8;
+ static final int MARIOLEFTOFOBSTACLE = 45; // fudge factor because Mario image is diff size to obstacle image
+ static final int MARIORIGHTOFOBSTACLE = 10; // fudge factor because Mario image is diff size to obstacle image
+ static final int ENEMYLEFTOFOBSTACLE = 16; // fudge factor for enemy images
+ static final int ENEMYRIGHTOFOBSTACLE = 49; // >49 causes panic!
+ static final int MARIOLEFTOFENEMY = 73;
+ static final int MARIORIGHTOFENEMY = -23;
+
+ static final int LEFTDOWN = 0;
+ static final int RIGHTDOWN = 1;
+ static final int DOWNDOWN = 2;
+ static final int SPACEDOWN = 3;
+
+ static final int OBSTACLEHEIGHT = 42;
+ static final int TALLOBSTACLEDIFF = 28;
+ static final int OBSTACLEWIDTH = 86;
+ static int GROUNDDIFF = 605 - GROUNDLEVEL;
+
+ // all member variables 'static' because shared with the enemy action thread
+ static MarioArea area;
+ static Thread timer;
+ static boolean finished = false;
+ static boolean ingame = false;
+ static boolean juststarted = true;
+ static Point warpzone;
+ static int[] keysdown = new int[4];
+ static Point[] enemyPositions;
+ static Point playerPosition;
+ static Point[] obstaclePositions;
+ static boolean[] piranhaPopping; // one for each obstacle
+ static boolean[] hasPiranha; // one for each obstacle
+ static boolean[] isTall; // one for each obstacle
+ static int enemyDirection[];
+ static int enemyNumber = 1, enemiesRemaining = 1, obstacleNumber = 1;
+ static boolean herocrouching = false;
+ static boolean onTheWayUp = false;
+ static boolean bouncing = false;
+ static boolean wasbouncing = false;
+ static boolean dead = false;
+ static int page = 0;
+ static int heroImageNo = 0;
+ static int enemyImageNo[];
+ static int levellength = 1482;
+ static Image[] heroImages = new Image[HEROIMAGES];
+ static Image[] obstacleImages = new Image[OBSTACLEIMAGES]; // pipe, piranhapeep, piranha peepy etc
+ static Image[] squished = new Image[ENEMYTYPES]; // squished images for each enemy type
+ static Image[][][] enemyImages = new Image[ENEMYTYPES][2][ENEMYIMAGES]; // left right left right or whatever
+ static int obstacleImageNo[]; // what is the current image for obstacle n
+ static Image[][] enemyImage = new Image[ENEMYTYPES][ENEMYIMAGES];// what is the current image for enemy n?
+ static Image floors[] = new Image[MAXLEVEL];
+ static int enemyType[]; // what is the type of enemy n?
+ static boolean enemyDead[]; // is enemy n dead?
+ static boolean heroleft = false;
+ static boolean jumping = false;
+ static int enemyMove[] = new int[ENEMYTYPES];
+ boolean somethingChangedSinceRepaint = false;
+
+ // *************************************************************
+ public static void main(String[] args) {
+ Mario Mario = new Mario();
+ Mario.setLayout(null);
+ Mario.setBackground(Color.white);
+ Mario.setSize(RIGHTEDGE, BOTTOMEDGE);
+ area = new MarioArea(Mario);
+ Mario.add(area);
+ //RIGHTEDGE = (Mario.getBounds().width / XAMOUNT) * XAMOUNT + LEFTEDGE;
+ //BOTTOMEDGE = Mario.getBounds().height - 1;
+ Mario.setVisible(true);
+ area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
+ //GROUNDLEVEL = Mario.getBounds().height - GROUNDDIFF;
+ //GROUNDLEVEL = BOTTOMEDGE;// - GROUNDDIFF;
+ startPosY = GROUNDLEVEL;
+ //MarioArea.FLOORLEVEL = Mario.getBounds().height - MarioArea.FLOORDIFF;
+ area.setVisible(true);
+
+ Mario.addKeyListener(Mario);
+ area.addKeyListener(Mario);
+ area.requestFocus();
+
+ obstacleImages[0] = area.obstacle;
+ obstacleImages[1] = area.obstacle;
+ obstacleImages[2] = area.obstacle;
+ obstacleImages[3] = area.obstacle;
+ obstacleImages[4] = area.piranhapeepo;
+ obstacleImages[5] = area.piranhapeep;
+ obstacleImages[6] = area.piranhapeepy;
+ obstacleImages[7] = area.piranha1;
+ obstacleImages[8] = area.piranha1;
+ obstacleImages[9] = area.piranha1;
+ obstacleImages[10] = area.piranha2; //
+ obstacleImages[11] = area.piranha2; //
+ obstacleImages[12] = area.piranha2; //
+ obstacleImages[13] = area.piranhapeepy; //
+ obstacleImages[14] = area.piranhapeep; //
+ obstacleImages[15] = area.piranhapeepo;
+ obstacleImages[16] = area.obstacle; //
+ obstacleImages[17] = area.obstacle; //
+ obstacleImages[18] = area.obstacle; //
+
+ enemyImages[GOOMBA][RIGHT][0] = area.goomba;
+ enemyImages[GOOMBA][RIGHT][1] = area.goomba2;
+ enemyImages[GOOMBA][LEFT][0] = area.goombaleft;
+ enemyImages[GOOMBA][LEFT][1] = area.goomba2left;
+
+ enemyImages[KOOPARED][RIGHT][0] = area.kooparedleft;
+ enemyImages[KOOPARED][RIGHT][1] = area.kooparedleft;
+ enemyImages[KOOPARED][LEFT][0] = area.koopared;
+ enemyImages[KOOPARED][LEFT][1] = area.koopared;
+
+ enemyImages[KOOPAGREEN][RIGHT][0] = area.koopagreen;
+ enemyImages[KOOPAGREEN][RIGHT][1] = area.koopagreen;
+ enemyImages[KOOPAGREEN][LEFT][0] = area.koopagreenleft;
+ enemyImages[KOOPAGREEN][LEFT][1] = area.koopagreenleft;
+
+ enemyImages[KOOPAREDFLYING][RIGHT][0] = area.kooparedfleft;
+ enemyImages[KOOPAREDFLYING][RIGHT][1] = area.kooparedfleft;
+ enemyImages[KOOPAREDFLYING][LEFT][0] = area.kooparedf;
+ enemyImages[KOOPAREDFLYING][LEFT][1] = area.kooparedf;
+
+ enemyImages[BANZAI][RIGHT][0] = area.Banzai;
+ enemyImages[BANZAI][RIGHT][1] = area.Banzai;
+ enemyImages[BANZAI][LEFT][0] = area.Banzai;
+ enemyImages[BANZAI][LEFT][1] = area.Banzai;
+
+ enemyImages[WIGGLER][RIGHT][0] = area.Wiglerright;
+ enemyImages[WIGGLER][RIGHT][1] = area.Wiglerright1;
+ enemyImages[WIGGLER][RIGHT][2] = area.Wiglerright2;
+ enemyImages[WIGGLER][LEFT][0] = area.Wiglerleft;
+ enemyImages[WIGGLER][LEFT][1] = area.Wiglerleft1;
+ enemyImages[WIGGLER][LEFT][2] = area.Wiglerleft2;
+
+ enemyImages[BOO][RIGHT][0] = area.Boo2;
+ enemyImages[BOO][RIGHT][1] = area.Boo2;
+ enemyImages[BOO][LEFT][0] = area.Boo1;
+ enemyImages[BOO][LEFT][1] = area.Boo1;
+
+ enemyImages[FIREBOO][RIGHT][0] = area.Fireboo2;
+ enemyImages[FIREBOO][RIGHT][1] = area.Fireboo2;
+ enemyImages[FIREBOO][LEFT][0] = area.Fireboo1;
+ enemyImages[FIREBOO][LEFT][1] = area.Fireboo1;
+
+ enemyImages[BOBOMB][LEFT][0] = area.Bobomb;
+ enemyImages[BOBOMB][LEFT][1] = area.Bobomb2;
+ enemyImages[BOBOMB][RIGHT][0] = area.Bobombf;
+ enemyImages[BOBOMB][RIGHT][1] = area.Bobombf2;
+
+ enemyImages[BULLET][LEFT][0] = area.Bullet;
+ enemyImages[BULLET][LEFT][1] = area.Bullet;
+ enemyImages[BULLET][RIGHT][0] = area.Bullet;
+ enemyImages[BULLET][RIGHT][1] = area.Bullet;
+
+ enemyImages[WARSHIP][LEFT][0] = area.Warship1;
+ enemyImages[WARSHIP][LEFT][1] = area.Warship2;
+ enemyImages[WARSHIP][RIGHT][0] = area.Warship1;
+ enemyImages[WARSHIP][RIGHT][1] = area.Warship2;
+
+ enemyImages[YETI][LEFT][0] = area.Yetil1;
+ enemyImages[YETI][LEFT][1] = area.Yetil2;
+ enemyImages[YETI][RIGHT][0] = area.Yetir1;
+ enemyImages[YETI][RIGHT][1] = area.Yetir2;
+
+ enemyImages[FLYER][LEFT][0] = area.p1fl;
+ enemyImages[FLYER][LEFT][1] = area.p2fl;
+ enemyImages[FLYER][RIGHT][0] = area.p1fr;
+ enemyImages[FLYER][RIGHT][1] = area.p2fr;
+
+ enemyImages[CHOMP][LEFT][0] = area.chainchomp1;
+ enemyImages[CHOMP][LEFT][1] = area.chainchomp2;
+ enemyImages[CHOMP][RIGHT][0] = area.chainchomp1;
+ enemyImages[CHOMP][RIGHT][1] = area.chainchomp2;
+
+ enemyImages[ATOM][LEFT][0] = area.Atom1;
+ enemyImages[ATOM][LEFT][1] = area.Atom2;
+ enemyImages[ATOM][RIGHT][0] = area.Atom1;
+ enemyImages[ATOM][RIGHT][1] = area.Atom2;
+
+ enemyMove[GOOMBA] = 5;
+ enemyMove[KOOPARED] = 5;
+ enemyMove[KOOPAGREEN] = 5;
+ enemyMove[KOOPAREDFLYING] = 8;
+ enemyMove[BANZAI] = 16;
+ enemyMove[WIGGLER] = 15;
+ enemyMove[BOO] = 5;
+ enemyMove[FIREBOO] = 10;
+ enemyMove[BOBOMB] = 5;
+ enemyMove[BULLET] = 10;
+ enemyMove[WARSHIP] = 20;
+ enemyMove[YETI] = 5;
+ enemyMove[FLYER] = 10;
+ enemyMove[CHOMP] = 0;
+ enemyMove[ATOM] = 1;
+
+ enemyHeight[GOOMBA] = 40;
+ enemyHeight[KOOPARED] = 33;
+ enemyHeight[KOOPAGREEN] = 33;
+ enemyHeight[KOOPAREDFLYING] = 33;
+ enemyHeight[BANZAI] = 60;
+ enemyHeight[WIGGLER] = 33;
+ enemyHeight[BOO] = 33;
+ enemyHeight[FIREBOO] = 33;
+ enemyHeight[BOBOMB] = 33;
+ enemyHeight[BULLET] = 5;
+ enemyHeight[WARSHIP] = 50;
+ enemyHeight[YETI] = 33;
+ enemyHeight[FLYER] = 50;
+ enemyHeight[CHOMP] = 60;
+ enemyHeight[ATOM] = 22;
+
+ squished[GOOMBA] = area.squishedgoomba;
+ squished[KOOPARED] = area.redshell;
+ squished[KOOPAGREEN] = area.greenshell;
+ squished[KOOPAREDFLYING] = area.koopared;
+ squished[BANZAI] = area.Banzai; // not actually used
+ squished[WIGGLER] = area.Wiglerleft; // not actually used
+ squished[BOO] = area.Boo1;
+ squished[FIREBOO] = area.Fireboo1;
+ squished[BOBOMB] = area.Bobomb;
+ squished[BULLET] = area.Bullet;
+ squished[WARSHIP] = area.Warship2;
+ squished[YETI] = area.Yetil1;
+ squished[FLYER] = area.p1fl;
+ squished[CHOMP] = area.chainchompdead;
+ squished[ATOM] = area.Atom1;
+
+ for (int i = 0; i < MAXLEVEL; i++) {
+ floors[i] = area.floor4;
+ }
+
+ floors[0] = area.floor4;
+ floors[1] = area.floor5;
+ floors[2] = area.floor3;
+ floors[3] = area.floor7;
+ floors[4] = area.floor8;
+ floors[5] = area.floor9;
+ floors[6] = area.floor2;
+ floors[7] = area.floor6;
+ floors[8] = area.Floor10;
+
+ timer = new Thread(Mario);
+ timer.start();
+
+ }
+
+ synchronized void faceRight() {
+ heroImages[0] = area.herostand;
+ heroImages[1] = area.hero1;
+ heroImages[2] = area.herostand;
+ heroImages[3] = area.hero2;
+ heroImageNo = 0;
+ heroleft = false;
+ }
+
+ synchronized void faceLeft() {
+ heroImages[0] = area.herostandleft;
+ heroImages[1] = area.hero1left;
+ heroImages[2] = area.herostandleft;
+ heroImages[3] = area.hero2left;
+ heroImageNo = 0;
+ heroleft = true;
+ }
+
+ synchronized void enemyFaceRight(int enemyno) {
+ enemyImage[enemyno][0] = enemyImages[enemyType[enemyno]][RIGHT][0];
+ enemyImage[enemyno][1] = enemyImages[enemyType[enemyno]][RIGHT][1];
+ if (enemyType[enemyno] == WIGGLER)
+ enemyImage[enemyno][2] = enemyImages[enemyType[enemyno]][RIGHT][2];
+ enemyDirection[enemyno] = RIGHT;
+ }
+
+ synchronized void enemyFaceLeft(int enemyno) {
+ enemyImage[enemyno][0] = enemyImages[enemyType[enemyno]][LEFT][0];
+ enemyImage[enemyno][1] = enemyImages[enemyType[enemyno]][LEFT][1];
+ if (enemyType[enemyno] == WIGGLER)
+ enemyImage[enemyno][2] = enemyImages[enemyType[enemyno]][LEFT][2];
+ enemyDirection[enemyno] = LEFT;
+ }
+
+ synchronized void enemyDie(int enemyno) {
+ // displayStatus();
+ enemyImage[enemyno][0] = squished[enemyType[enemyno]];
+ enemyImage[enemyno][1] = squished[enemyType[enemyno]];
+ if (enemyType[enemyno] == WIGGLER)
+ enemyImage[enemyno][2] = squished[enemyType[enemyno]];
+ }
+
+ synchronized void standStill() {
+ heroImageNo = 0;
+ }
+
+ public void doLevel(int level) {
+ // this runs one 'level'
+ juststarted = true;
+ dead = false;
+
+ // position Hero at the bottom left
+ playerPosition = new Point(LEFTEDGE, GROUNDLEVEL);
+ faceRight();
+
+ // *********** THIS STUFF DEPENDS WHAT LEVEL YOU ARE ON ************
+ switch (level) {
+ case 1:
+ obstacleNumber = 4; // 4 pipes for level 1
+ enemyNumber = 1;
+ levellength = 1482; // 2 pages
+ break;
+ case 2:
+ obstacleNumber = 11;
+ enemyNumber = 5;
+ levellength = 2964; // 4 pages
+ break;
+ case 3:
+ obstacleNumber = 13;
+ enemyNumber = 8;
+ levellength = 2223; // 3 pages
+ break;
+ case 4:
+ obstacleNumber = 11;
+ enemyNumber = 12;
+ levellength = 4446; // 6 pages
+ break;
+ case 5:
+ obstacleNumber = 17;
+ enemyNumber = 13;
+ levellength = 5928; // 8 pages
+ break;
+ case 6:
+ obstacleNumber = 14;
+ enemyNumber = 1;
+ levellength = 5928; // 8 pages
+ break;
+ case 7:
+ obstacleNumber = 14;
+ enemyNumber = 6;
+ levellength = 3705; // 5 pages
+ break;
+ case 8:
+ obstacleNumber = 16;
+ enemyNumber = 9;
+ levellength = 5928; // 8 pages
+ break;
+ case 9:
+ obstacleNumber = 6;
+ enemyNumber = 9;
+ levellength = 3705; // 5 pages
+ break;
+ case 10:
+ obstacleNumber = 29;
+ enemyNumber = 0;
+ levellength = 4446; // 6 pages
+ default:
+ System.out.println("Level " + level + " has not yet been implemented");
+ }
+
+ enemyImage = new Image[enemyNumber][ENEMYIMAGES];// what is the current image for enemy n?
+ // initialise piranha states
+ obstacleImageNo = new int[obstacleNumber];
+ hasPiranha = new boolean[obstacleNumber];
+ piranhaPopping = new boolean[obstacleNumber];
+ isTall = new boolean[obstacleNumber];
+
+ // initialise the arrays of enemies, etc
+ enemyPositions = new Point[enemyNumber];
+ enemyType = new int[enemyNumber];
+ enemyDead = new boolean[enemyNumber];
+ obstaclePositions = new Point[obstacleNumber];
+ enemyDirection = new int[enemyNumber];
+ enemyImageNo = new int[enemyNumber];
+
+ for (int i = 0; i < enemyNumber; i++) {
+ enemyImageNo[i] = 0;
+ }
+
+ switch (level) {
+ // ---------------------------------
+ // LEVEL 1
+ // ---------------------------------
+ case 1:
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ if (i == 0) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ } else {
+ if (i == 3)
+ isTall[i] = true;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ }
+ }
+ obstaclePositions[0] = new Point(400, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(950, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(1245, GROUNDLEVEL); // 1255 for adjacent
+ obstaclePositions[3] = new Point(1320, GROUNDLEVEL);
+
+ enemyPositions[0] = new Point(1000, GOOMBAHEIGHT);
+ enemyType = new int[] { GOOMBA };
+ break;
+ // -----------------------------------------------
+ // LEVEL 2
+ // -----------------------------------------------
+ case 2:
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ if (i == 2 || i == 7 || i == 8) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ } else {
+ if (i == 4 || i == 6 || i == 10)
+ isTall[i] = true;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ }
+ }
+
+ // PAGE 1
+ obstaclePositions[0] = new Point(150, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(225, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(300, GROUNDLEVEL);
+ // PAGE 2
+ obstaclePositions[3] = new Point(891, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(966, GROUNDLEVEL);
+ // PAGE 3
+ obstaclePositions[5] = new Point(1632, GROUNDLEVEL);
+ obstaclePositions[6] = new Point(1707, GROUNDLEVEL);
+ obstaclePositions[7] = new Point(1782, GROUNDLEVEL);
+ // PAGE 4
+ obstaclePositions[8] = new Point(2373, GROUNDLEVEL);
+ obstaclePositions[9] = new Point(2743, GROUNDLEVEL);
+ obstaclePositions[10] = new Point(2818, GROUNDLEVEL);
+
+ enemyType = new int[] { KOOPAGREEN, GOOMBA, GOOMBA, GOOMBA, GOOMBA };
+ enemyPositions[0] = new Point(375, KOOPAGREENHEIGHT);
+ enemyPositions[1] = new Point(1041, GOOMBAHEIGHT);
+ enemyPositions[2] = new Point(1141, GOOMBAHEIGHT);
+ enemyPositions[3] = new Point(1882, GOOMBAHEIGHT);
+ enemyPositions[4] = new Point(2473, GOOMBAHEIGHT);
+ break;
+ // -----------------------------------------------
+ // LEVEL 3
+ // -----------------------------------------------
+ case 3:
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ if (i == 4)
+ isTall[i] = true;
+ if (i != 4 && i != 11 && i != 12) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ } else {
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ }
+ }
+ // PAGE 1
+ obstaclePositions[0] = new Point(50, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(130, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(210, GROUNDLEVEL);
+
+ obstaclePositions[3] = new Point(540, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(620, GROUNDLEVEL);
+ obstaclePositions[5] = new Point(700, GROUNDLEVEL);
+ // PAGE 2
+ obstaclePositions[6] = new Point(850, GROUNDLEVEL);
+ obstaclePositions[7] = new Point(925, GROUNDLEVEL);
+ obstaclePositions[8] = new Point(1000, GROUNDLEVEL);
+ obstaclePositions[9] = new Point(1075, GROUNDLEVEL);
+ obstaclePositions[10] = new Point(1150, GROUNDLEVEL);
+ obstaclePositions[11] = new Point(1350, GROUNDLEVEL);
+
+ // PAGE 3
+ obstaclePositions[12] = new Point(2000, GROUNDLEVEL);
+
+ enemyType = new int[] { KOOPAGREEN, GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA };
+
+ enemyPositions[0] = new Point(365, KOOPAGREENHEIGHT);
+ enemyPositions[1] = new Point(420, GOOMBAHEIGHT);
+ enemyPositions[2] = new Point(495, GOOMBAHEIGHT);
+ enemyPositions[3] = new Point(1250, GOOMBAHEIGHT);
+ enemyPositions[4] = new Point(1500, GOOMBAHEIGHT);
+ enemyPositions[5] = new Point(1575, GOOMBAHEIGHT);
+ enemyPositions[6] = new Point(1650, GOOMBAHEIGHT);
+ enemyPositions[7] = new Point(1725, GOOMBAHEIGHT);
+
+ break;
+ // -----------------------------------------------
+ // LEVEL 4
+ // -----------------------------------------------
+ case 4:
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ if (i == 2 || i == 5 || i == 7 || i == 8 || i == 9 || i == 10) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ } else {
+ if (i == 1 || i == 4 || i == 6)
+ isTall[i] = true;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ }
+ }
+
+ // PAGE 1
+ obstaclePositions[0] = new Point(185, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(370, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(700, GROUNDLEVEL);
+ // PAGE 2
+ obstaclePositions[3] = new Point(900, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(1300, GROUNDLEVEL);
+ // PAGE 3
+ obstaclePositions[5] = new Point(1500, GROUNDLEVEL);
+ obstaclePositions[6] = new Point(1750, GROUNDLEVEL);
+ obstaclePositions[7] = new Point(2000, GROUNDLEVEL);
+ // PAGE 4
+
+ // PAGE 5
+ obstaclePositions[8] = new Point(3064, GROUNDLEVEL);
+ obstaclePositions[9] = new Point(3264, GROUNDLEVEL);
+ // PAGE 6
+ obstaclePositions[10] = new Point(4100, GROUNDLEVEL);
+
+ enemyType = new int[] { KOOPARED, KOOPARED, KOOPAREDFLYING, GOOMBA, GOOMBA, GOOMBA, GOOMBA, KOOPAREDFLYING,
+ KOOPARED, KOOPARED, KOOPARED, FLYER };
+
+ enemyPositions[0] = new Point(470, KOOPAREDHEIGHT);
+ enemyPositions[1] = new Point(520, KOOPAREDHEIGHT);
+
+ enemyPositions[2] = new Point(1000, KOOPAREDFLYINGHEIGHT);
+ enemyPositions[3] = new Point(1400, GOOMBAHEIGHT);
+
+ enemyPositions[4] = new Point(2230, GOOMBAHEIGHT);
+ enemyPositions[5] = new Point(2280, GOOMBAHEIGHT);
+ enemyPositions[6] = new Point(2320, GOOMBAHEIGHT);
+
+ enemyPositions[7] = new Point(3600, KOOPAREDFLYINGHEIGHT);
+
+ enemyPositions[8] = new Point(3710, KOOPAREDHEIGHT);
+ enemyPositions[9] = new Point(3760, KOOPAREDHEIGHT);
+ enemyPositions[10] = new Point(3810, KOOPAREDHEIGHT);
+ enemyPositions[11] = new Point(3500, FLYERHEIGHT);
+
+ break;
+ // -----------------------------------------------
+ // LEVEL 5
+ // -----------------------------------------------
+ case 5:
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ if (i == 0 || i == 2 || i == 4 || i == 10 || i == 11 || i == 14 || i == 16) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ } else {
+ if (i == 1 || i == 3 || i == 6 || i == 7 || i == 8 || i == 9 || i == 12 || i == 15)
+ isTall[i] = true;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ }
+ }
+ // page1
+ obstaclePositions[0] = new Point(150, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(300, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(600, GROUNDLEVEL);
+ // page2
+ obstaclePositions[3] = new Point(800, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(900, GROUNDLEVEL);
+ // page3
+ obstaclePositions[5] = new Point(1600, GROUNDLEVEL);
+ obstaclePositions[6] = new Point(1700, GROUNDLEVEL);
+ obstaclePositions[7] = new Point(1800, GROUNDLEVEL);
+ obstaclePositions[8] = new Point(1900, GROUNDLEVEL);
+ obstaclePositions[9] = new Point(2000, GROUNDLEVEL);
+ // page4
+ obstaclePositions[10] = new Point(2400, GROUNDLEVEL);
+ // page5
+ obstaclePositions[11] = new Point(3100, GROUNDLEVEL);
+ obstaclePositions[12] = new Point(3200, GROUNDLEVEL);
+ // page6
+ obstaclePositions[13] = new Point(3850, GROUNDLEVEL);
+ obstaclePositions[14] = new Point(3950, GROUNDLEVEL);
+ obstaclePositions[15] = new Point(4050, GROUNDLEVEL);
+ // page7
+ // NONE\\
+ // page8
+ obstaclePositions[16] = new Point(5550, GROUNDLEVEL);
+
+ enemyType = new int[] { KOOPAREDFLYING, GOOMBA, GOOMBA, KOOPAGREEN, KOOPAREDFLYING, KOOPAGREEN, KOOPAGREEN,
+ KOOPAGREEN, KOOPAREDFLYING, KOOPAREDFLYING, GOOMBA, GOOMBA, GOOMBA };
+
+ enemyPositions[0] = new Point(450, KOOPAREDFLYINGHEIGHT);
+ enemyPositions[1] = new Point(700, GOOMBAHEIGHT);
+ enemyPositions[2] = new Point(1000, GOOMBAHEIGHT);
+ enemyPositions[3] = new Point(1100, KOOPAGREENHEIGHT);
+ enemyPositions[4] = new Point(2100, KOOPAREDFLYINGHEIGHT);
+ enemyPositions[5] = new Point(2500, KOOPAGREENHEIGHT);
+ enemyPositions[6] = new Point(2600, KOOPAGREENHEIGHT);
+ enemyPositions[7] = new Point(2700, KOOPAGREENHEIGHT);
+ enemyPositions[8] = new Point(3400, KOOPAREDFLYINGHEIGHT);
+ enemyPositions[9] = new Point(3600, KOOPAREDFLYINGHEIGHT);
+ enemyPositions[10] = new Point(4700, GOOMBAHEIGHT);
+ enemyPositions[11] = new Point(4800, GOOMBAHEIGHT);
+ enemyPositions[12] = new Point(4800, GOOMBAHEIGHT);
+ break;
+ // -----------------------------------------------
+ // LEVEL 6
+ // -----------------------------------------------
+ case 6:
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ if (i == 2 || i == 3 || i == 4 || i == 5 || i == 7 || i == 10 || i == 11) {
+ isTall[i] = true;
+ } else {
+ if (i == 13) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ }
+
+ }
+ }
+ obstaclePositions[0] = new Point(350, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(1091, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(1191, GROUNDLEVEL);
+ obstaclePositions[3] = new Point(1600, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(1675, GROUNDLEVEL);
+ obstaclePositions[5] = new Point(1750, GROUNDLEVEL);
+ obstaclePositions[6] = new Point(2500, GROUNDLEVEL);
+ obstaclePositions[7] = new Point(2600, GROUNDLEVEL);
+ obstaclePositions[8] = new Point(2700, GROUNDLEVEL);
+ obstaclePositions[9] = new Point(3975, GROUNDLEVEL);
+ obstaclePositions[10] = new Point(4050, GROUNDLEVEL);
+ obstaclePositions[11] = new Point(4150, GROUNDLEVEL);
+ obstaclePositions[12] = new Point(4225, GROUNDLEVEL);
+ obstaclePositions[13] = new Point(5550, GROUNDLEVEL);
+
+ enemyPositions[0] = new Point(-400, BANZAIHEIGHT);
+ enemyType[0] = BANZAI;
+
+ break;
+
+ // -----------------------------------------------
+ // LEVEL 7
+ // -----------------------------------------------
+ case 7:
+
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ if (i == 1 || i == 2 || i == 8) {
+ isTall[i] = true;
+ } else {
+ if (i == 0 || i == 3 || i == 5 || i == 7 || i == 9 || i == 10 || i == 11) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ }
+ }
+ }
+ obstaclePositions[0] = new Point(250, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(350, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(450, GROUNDLEVEL);
+ obstaclePositions[3] = new Point(550, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(800, GROUNDLEVEL);
+ obstaclePositions[5] = new Point(1000, GROUNDLEVEL);
+ obstaclePositions[6] = new Point(1200, GROUNDLEVEL);
+ obstaclePositions[7] = new Point(1400, GROUNDLEVEL);
+ obstaclePositions[8] = new Point(1800, GROUNDLEVEL);
+ obstaclePositions[9] = new Point(2400, GROUNDLEVEL);
+ obstaclePositions[10] = new Point(2550, GROUNDLEVEL);
+ obstaclePositions[11] = new Point(2700, GROUNDLEVEL);
+ obstaclePositions[12] = new Point(3100, GROUNDLEVEL);
+ obstaclePositions[13] = new Point(3600, GROUNDLEVEL);
+
+ enemyType = new int[] { GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA, WIGGLER };
+ enemyPositions[0] = new Point(900, GOOMBAHEIGHT);
+ enemyPositions[1] = new Point(1100, GOOMBAHEIGHT);
+ enemyPositions[2] = new Point(1300, GOOMBAHEIGHT);
+ enemyPositions[3] = new Point(1600, GOOMBAHEIGHT);
+ enemyPositions[4] = new Point(2000, GOOMBAHEIGHT);
+ enemyPositions[5] = new Point(3250, WIGGLERHEIGHT);
+ break;
+ // -----------------------------------------------
+ // LEVEL 8
+ // -----------------------------------------------
+ case 8:
+
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ if (i == 2 || i == 3 || i == 4 || i == 6 || i == 8 || i == 11) {
+ isTall[i] = true;
+ } else {
+ if (i == 0 || i == 1 || i == 10 || i == 12 || i == 13) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ }
+ }
+ }
+
+ obstaclePositions[0] = new Point(100, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(650, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(1000, GROUNDLEVEL);
+ obstaclePositions[3] = new Point(1075, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(1150, GROUNDLEVEL);
+ obstaclePositions[5] = new Point(1500, GROUNDLEVEL);
+ obstaclePositions[6] = new Point(1575, GROUNDLEVEL);
+ obstaclePositions[7] = new Point(1650, GROUNDLEVEL);
+ obstaclePositions[8] = new Point(1725, GROUNDLEVEL);
+ obstaclePositions[9] = new Point(1800, GROUNDLEVEL);
+ obstaclePositions[10] = new Point(2500, GROUNDLEVEL);
+ obstaclePositions[11] = new Point(3400, GROUNDLEVEL);
+ obstaclePositions[12] = new Point(4000, GROUNDLEVEL);
+ obstaclePositions[13] = new Point(4075, GROUNDLEVEL);
+ obstaclePositions[14] = new Point(5275, GROUNDLEVEL);
+ obstaclePositions[15] = new Point(5775, GROUNDLEVEL);
+
+ enemyType = new int[] { BOO, FIREBOO, GOOMBA, BOO, GOOMBA, FIREBOO, GOOMBA, GOOMBA, BOBOMB };
+
+ enemyPositions[0] = new Point(350, BOOHEIGHT);
+ enemyPositions[1] = new Point(900, FIREBOOHEIGHT);
+ enemyPositions[2] = new Point(1200, GOOMBAHEIGHT);
+ enemyPositions[3] = new Point(1900, BOOHEIGHT);
+ enemyPositions[4] = new Point(2600, GOOMBAHEIGHT);
+ enemyPositions[5] = new Point(3500, FIREBOOHEIGHT);
+ enemyPositions[6] = new Point(4175, GOOMBAHEIGHT);
+ enemyPositions[7] = new Point(4250, GOOMBAHEIGHT);
+ enemyPositions[8] = new Point(5375, BOBOMBHEIGHT);
+ break;
+ case 9:
+ enemyType = new int[] { FLYER, GOOMBA, GOOMBA, KOOPAREDFLYING, KOOPAREDFLYING, KOOPAREDFLYING,
+ KOOPAREDFLYING, KOOPAREDFLYING, CHOMP };
+
+ enemyPositions[0] = new Point(400, FLYERHEIGHT);
+ enemyPositions[1] = new Point(950, GOOMBAHEIGHT);
+ enemyPositions[2] = new Point(1000, GOOMBAHEIGHT);
+ enemyPositions[3] = new Point(1300, KOOPAREDFLYINGHEIGHT - 10);
+ enemyPositions[4] = new Point(1500, KOOPAREDFLYINGHEIGHT - 10);
+ enemyPositions[5] = new Point(1700, KOOPAREDFLYINGHEIGHT - 10);
+ enemyPositions[6] = new Point(1900, KOOPAREDFLYINGHEIGHT - 10);
+ enemyPositions[7] = new Point(2100, KOOPAREDFLYINGHEIGHT - 10);
+ enemyPositions[8] = new Point(2850, CHOMPHEIGHT);
+
+ for (int i = 0; i < obstacleNumber; i++) {
+
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ if (i == 0 || i == 3 || i == 5) {
+ isTall[i] = true;
+ } else {
+ if (i == 1 || i == 2 || i == 4) {
+ piranhaPopping[i] = true;
+ hasPiranha[i] = true;
+ }
+ }
+ }
+
+ obstaclePositions[0] = new Point(200, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(900, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(1100, GROUNDLEVEL);
+ obstaclePositions[3] = new Point(2400, GROUNDLEVEL);
+ obstaclePositions[4] = new Point(2550, GROUNDLEVEL);
+ obstaclePositions[5] = new Point(2700, GROUNDLEVEL);
+
+ default:
+
+ }
+
+ for (int j = 0; j < enemyNumber; j++) {
+ enemyFaceRight(j);
+ enemyDead[j] = false;
+ }
+
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (hasPiranha[i]) { // pick a random image number between 0 and 18 (inclusive)
+ obstacleImageNo[i] = (int) (Math.random() * 18) / 1;
+ } else
+ obstacleImageNo[i] = 0;
+ }
+
+ // position the warp zone at the end of the level
+ warpzone = new Point(levellength, GROUNDLEVEL);
+ // *********** END OF STUFF THAT DEPENDS WHAT LEVEL YOU ARE ON ************
+
+ ingame = true;
+ System.out.println("Started level " + level);
+ }
+
+ boolean isPlayerPosition(Point p) {
+ return (p.x == playerPosition.x && p.y == playerPosition.y);
+ }
+
+ int isEnemyPosition(Point p) {
+ for (int i = 0; i < enemyNumber; i++) {
+ if (isEnemyX(p) != -1 && isEnemyY(p) != -1 && !enemyDead[i])
+ return (i);
+ }
+ return (-1);
+ }
+
+ boolean isObstaclePosition(Point p, boolean forMario) {
+ int obby;
+ for (int i = 0; i < obstacleNumber; i++) {
+ obby = isObstacleX(p, forMario);
+ if (obby != -1 && isObstacleY(p, obby, forMario) != -1) {
+ return (true);
+ }
+ }
+ return (false);
+ }
+
+ boolean checkIfBlockingObstacle(Point p) {
+ boolean result = false;
+ int obby;
+ obby = isObstacleX(p, true);
+ if (obby != -1 && isBlockingObstacleY(p, obby)) {
+ piranhaPopping[obby] = false;
+ result = true;
+ }
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (i != obby || !result) {
+ if (hasPiranha[i])
+ piranhaPopping[i] = true;
+ }
+ }
+ if (!result)
+ startPosY = GROUNDLEVEL;
+ return (result);
+ }
+
+ int isObstacleX(Point p, boolean forMario) {
+ int obstaclex;
+ for (int i = 0; i < obstacleNumber; i++) {
+ // if x is >= obstacleposition - (MARIOLEFTOFOBSTACLE) and x <= obstacleposition
+ // + (MARIORIGHTOFOBSTACLE)
+ obstaclex = obstaclePositions[i].x;
+ if (forMario) {
+ if (p.x >= (obstaclex - MARIOLEFTOFOBSTACLE) && p.x <= (obstaclex + MARIORIGHTOFOBSTACLE))
+ return (i); // return the number of the matching obstacle
+ } else {
+ if (p.x >= (obstaclex - ENEMYLEFTOFOBSTACLE) && p.x <= (obstaclex + ENEMYRIGHTOFOBSTACLE))
+ return (i); // return the number of the matching obstacle
+ }
+ }
+ return (-1);
+ }
+
+ boolean isBlockingObstacleY(Point p, int obstaclenumber) {
+ if (isTall[obstaclenumber]) {
+ if (p.y <= obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
+ // System.out.println(s+": Yes");
+ return (true);
+ }
+ } else {
+ if (p.y <= obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
+ // System.out.println(s+": Yes");
+ return (true);
+ }
+ }
+ // System.out.println(s+": No");
+ return (false);
+ }
+
+ int isObstacleY(Point p, int obstaclenumber, boolean forMario) {
+ if (isTall[obstaclenumber]) {
+ if (p.y > obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
+ return (obstaclenumber);
+ }
+ } else {
+ if (p.y > obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
+ return (obstaclenumber);
+ }
+ }
+ return (-1);
+ }
+
+ int isEnemyX(Point p) {
+ int enemyx;
+ for (int i = 0; i < enemyNumber; i++) {
+ // if x is >= enemyposition - (LEFTOFENEMY) and x <= enemyposition +
+ // (RIGHTOFENEMY)
+ enemyx = enemyPositions[i].x;
+ // System.out.println("Player got by enemy if " +
+ // p.x + " >= " + (enemyx - MARIOLEFTOFENEMY) + " && " + p.x + " <= " + (enemyx
+ // + MARIORIGHTOFENEMY));
+ if (p.x >= (enemyx - MARIOLEFTOFENEMY) && p.x <= (enemyx + MARIORIGHTOFENEMY) && !enemyDead[i])
+ return (i); // return the number of the matching enemy
+ }
+ return (-1);
+ }
+
+ int isEnemyY(Point p) {
+ int offset = herocrouching ? MARIOCROUCHOFFSET : MARIOOFFSET;
+ for (int i = 0; i < enemyNumber; i++) {
+ if (!enemyDead[i] && ((p.y + offset <= enemyPositions[i].y + enemySize[enemyType[i]])
+ && (p.y + MARIOHEIGHT) >= enemyPositions[i].y))
+ return (i);
+ }
+ return (-1);
+ }
+
+ public void finished() {
+ finished = true;
+ System.exit(0);
+ }
+
+ public String getAppletInfo() {
+ return ("Mario Game");
+ }
+
+ int randomMove() {
+ // return + or - value (randomly)
+ if (Math.random() >= 0.5)
+ return (24);
+ else
+ return (-24);
+ }
+
+ private synchronized void incKeysDown(int whichone) {
+ keysdown[whichone] = 1;
+ }
+
+ private synchronized void decKeysDown(int whichone) {
+ keysdown[whichone] = 0;
+ }
+
+ // this class will use just the key pressed event
+ public void keyPressed(KeyEvent e) {
+ if (e.getKeyCode() == KeyEvent.VK_F1) {
+ displayStatus();
+ }
+ if (ingame) {
+ if (!(e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))) {
+
+ // valid move: move the player and then move the enemies
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ herocrouching = true;
+ incKeysDown(DOWNDOWN);
+ setSomethingChangedSinceRepaint(true);
+ } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ incKeysDown(LEFTDOWN);
+ leftPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ incKeysDown(RIGHTDOWN);
+ rightPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ } else if (e.getKeyCode() == KeyEvent.VK_SPACE) {
+ if (!jumping) {
+ startPosY = playerPosition.y;
+ jumping = true;
+ onTheWayUp = true;
+ setSomethingChangedSinceRepaint(true);
+ }
+ }
+ if (somethingChangedSinceRepaint) {
+ area.repaint();
+ }
+ } // if valid key press
+ } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+ if (level == MAXLEVEL || dead)
+ doLevel(level);
+ else
+ doLevel(++level);
+ page = 0;
+ area.repaint();
+ }
+ }
+
+ /* synchronized */ void setSomethingChangedSinceRepaint(boolean val) {
+ somethingChangedSinceRepaint = val;
+ }
+
+ void leftPressed(boolean skid) {
+ if (!herocrouching) {
+ // if Hero was facing right, turn him left
+ if (!heroleft)
+ faceLeft();
+ else {
+ // if the target position is not occupied by a obstacle...
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstaclePosition(new Point(playerPosition.x - XAMOUNT, playerPosition.y), true))
+ return; // can't move
+ }
+ playerPosition.x -= XAMOUNT;
+ if (!skid)
+ incrementHeroImage();
+ }
+ }
+ }
+
+ void rightPressed(boolean skid) {
+ if (!herocrouching) {
+ if ((playerPosition.x + SPACE_FROM_X_TO_MARIO) >= (warpzone.x + 4)) {
+ // level complete!
+ ingame = false;
+ } else {
+ // if Hero was facing left, turn him right
+ if (heroleft)
+ faceRight();
+ else {
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstaclePosition(new Point(playerPosition.x + XAMOUNT, playerPosition.y), true))
+ return; // can't move
+ }
+ playerPosition.x += XAMOUNT;
+ // System.out.println("Mario's x position is " + playerPosition.x);
+ if (!skid)
+ incrementHeroImage();
+ }
+ }
+ }
+ }
+
+ boolean anythingVisibleChanged() {
+ return (somethingChangedSinceRepaint);
+ }
+
+ public void run() {
+ boolean odd = true; // only change piranha image every other cycle
+ while (true) {
+ if (juststarted) {
+ try {
+ Thread.sleep(750);
+ } catch (Exception e) {
+ }
+ area.repaint();
+ juststarted = false;
+ }
+ try {
+ Thread.sleep(DELAY);
+ } catch (InterruptedException e) {
+ }
+ if (ingame) {
+ if (keysdown[LEFTDOWN] == 0 && keysdown[RIGHTDOWN] == 0 && keysdown[DOWNDOWN] == 0)
+ standStill();
+
+ if (keysdown[LEFTDOWN] > 0) {
+ leftPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ } else if (keysdown[RIGHTDOWN] > 0) {
+ rightPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ }
+
+ if (!odd) {
+ // for each obstacle, cycle through the piranha pictures
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (piranhaPopping[i]) {
+ incrementObstacleImage(i);
+ if (isVisibleObstacle(i))
+ setSomethingChangedSinceRepaint(true);
+ }
+ }
+ }
+ odd = !odd;
+
+ // for each enemy, move the enemy in the direction it was going
+ for (int i = 0; i < enemyNumber; i++) {
+ // TODO if there is a fatal obstacle at that position, fall into it and
+ // decrement count of enemies
+ // and set that enemy's position to -1, -1
+ /*
+ * if (isObstaclePosition(enemyPositions[i])) {
+ * System.out.Println("A enemy fell into a obstacle");
+ *
+ * enemyPositions[i] = new Point(-1, -1); enemiesRemaining--;
+ * System.out.Println(enemyNumber-enemiesRemaining + " down, " +
+ * enemiesRemaining + " to go..."); }
+ */
+ // if there is a non-fatal obstacle
+ if (isObstaclePosition(enemyPositions[i], false) && enemyType[i] != BANZAI) {
+ // change direction
+ changeDirection(i);
+ if (isVisibleEnemy(i))
+ setSomethingChangedSinceRepaint(true);
+ }
+ if (!enemyDead[i]) {
+ enemyPositions[i] = move(i, enemyPositions[i], enemyDirection[i], odd);
+ if (isVisibleEnemy(i))
+ setSomethingChangedSinceRepaint(true);
+ }
+
+ // if player is caught by a enemy, end the game
+ int enemyno = isEnemyPosition(playerPosition);
+ if (enemyno > -1) {
+ int NEEDTOBEABOVE = enemyPositions[enemyno].y + enemyTopSpace[enemyno] - MARIOHEIGHT;
+ if (easymode)
+ NEEDTOBEABOVE = enemyPositions[enemyno].y - enemyHeight[enemyType[enemyno]];
+ if ((!onTheWayUp && (playerPosition.y <= NEEDTOBEABOVE)) && enemyType[enemyno] != BANZAI) {
+ // player may have squished an enemy
+ if (enemyType[enemyno] == KOOPAREDFLYING) {
+ enemyType[enemyno] = KOOPARED;
+ enemyPositions[enemyno].y = KOOPAREDHEIGHT;
+ if (enemyDirection[enemyno] == LEFT)
+ enemyFaceLeft(enemyno);
+ else
+ enemyFaceRight(enemyno);
+ } else {
+ enemyDead[enemyno] = true;
+ enemyDie(enemyno);
+ }
+ // player bounces
+ bouncing = true;
+ startPosY = playerPosition.y;
+ setSomethingChangedSinceRepaint(true);
+ } else {
+ int offset = herocrouching ? MARIOCROUCHOFFSET : MARIOOFFSET;
+ if (playerPosition.y > NEEDTOBEABOVE && (playerPosition.y
+ + offset <= enemyPositions[enemyno].y + enemySize[enemyType[enemyno]])) {
+ die();
+ setSomethingChangedSinceRepaint(true);
+ }
+ }
+ }
+ }
+ if (!dead) {
+ if (onTheWayUp) {
+ if (playerPosition.y > startPosY - JUMPAMOUNT) {
+ playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
+ setSomethingChangedSinceRepaint(true);
+ } else {
+ onTheWayUp = false;
+ }
+ } else if (bouncing) {
+ if (playerPosition.y > startPosY - BOUNCEAMOUNT) {
+ playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
+ setSomethingChangedSinceRepaint(true);
+ } else {
+ bouncing = false;
+ wasbouncing = true;
+ }
+ } else {
+ int obstacleno = isObstacleX(playerPosition, true);
+ if (obstacleno == -1) { // no obstacle at this position
+ if (!onTheWayUp && !bouncing) {
+ if (playerPosition.y < startPosY) {
+ playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
+ if (playerPosition.y >= GROUNDLEVEL && floorIsIcy()) {
+ if (!wasbouncing) {
+ if (heroleft)
+ skidLeft();
+ else
+ skidRight();
+ }
+ }
+ wasbouncing = false;
+ setSomethingChangedSinceRepaint(true);
+ } else
+ jumping = false;
+ }
+ } else {
+ Point obstaclepos = obstaclePositions[obstacleno];
+ // if hero's y position <= obstacle's height
+ int thisObstacleHeight = isTall[obstacleno] ? OBSTACLEHEIGHT + TALLOBSTACLEDIFF
+ : OBSTACLEHEIGHT;
+ if (playerPosition.y <= (obstaclepos.y - thisObstacleHeight) && // can't land on the
+ // obstacle if just < (??!)
+ (playerPosition.y + FALLAMOUNT >= (obstaclepos.y - thisObstacleHeight))) {
+ // allow hero to land on the obstacle
+ jumping = false;
+ if (playerPosition.y != obstaclepos.y - thisObstacleHeight)
+ setSomethingChangedSinceRepaint(true);
+ playerPosition = new Point(playerPosition.x, obstaclepos.y - thisObstacleHeight);
+ // if the piranha was up, Hero dies
+ if (obstacleImages[obstacleImageNo[obstacleno]] != area.obstacle) {
+ die();
+ } else {
+ // otherwise stop this Piranha
+ piranhaPopping[obstacleno] = false;
+ }
+ } else {
+ if (!onTheWayUp && !bouncing) {
+ if (playerPosition.y < startPosY) {
+ setSomethingChangedSinceRepaint(true);
+ playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
+ if (playerPosition.y >= GROUNDLEVEL && floorIsIcy()) {
+ if (!wasbouncing) {
+ if (heroleft)
+ skidLeft();
+ else
+ skidRight();
+ }
+ }
+ wasbouncing = false;
+ } else
+ jumping = false;
+ }
+ }
+ }
+ }
+ if (!dead) {
+ checkIfBlockingObstacle(playerPosition);
+ if (playerPosition.y > GROUNDLEVEL)
+ playerPosition.y = GROUNDLEVEL;
+ }
+ if (anythingVisibleChanged()) {
+ area.repaint();
+ }
+ } else {
+ if (!area.showingMessage)
+ area.repaint();
+ }
+ }
+ }
+ }
+
+ boolean isVisibleObstacle(int i) {
+ // TODO - this probably needs fixing when obstacle is near page boundary
+ return ((obstaclePositions[i].x >= page * PAGEWIDTH) && (obstaclePositions[i].x < (page + 1) * PAGEWIDTH));
+ }
+
+ boolean isVisibleEnemy(int i) {
+ // TODO - this probably needs fixing when enemy is near page boundary
+ return ((enemyPositions[i].x >= page * PAGEWIDTH) && (enemyPositions[i].x < (page + 1) * PAGEWIDTH)
+ && !enemyDead[i]);
+ }
+
+ void changeDirection(int enemyno) {
+ if (enemyDirection[enemyno] == LEFT) {
+ enemyFaceRight(enemyno);
+ } else {
+ enemyFaceLeft(enemyno);
+ }
+ }
+
+ synchronized void die() {
+ System.out.println("The Player is dead. Press the Enter key to restart the level");
+ ingame = false;
+ dead = true;
+ displayStatus();
+ }
+
+ synchronized void incrementObstacleImage(int i) {
+ obstacleImageNo[i]++;
+ if (obstacleImageNo[i] == OBSTACLEIMAGES)
+ obstacleImageNo[i] = 0;
+ }
+
+ synchronized void incrementHeroImage() {
+ heroImageNo++;
+ if (heroImageNo == HEROIMAGES)
+ heroImageNo = 0;
+ }
+
+ synchronized void incrementEnemyImage(int i) {
+ enemyImageNo[i]++;
+ if (enemyType[i] == WIGGLER) {
+ if (enemyImageNo[i] > (ENEMYIMAGES - 1))
+ enemyImageNo[i] = 0;
+ } else {
+ if (enemyImageNo[i] > (ENEMYIMAGES - 2))
+ enemyImageNo[i] = 0;
+ }
+ }
+
+ Point move(int enemyNo, Point start, int direction, boolean odd) {
+ if (odd)
+ incrementEnemyImage(enemyNo);
+ if (direction == LEFT) {
+ return (new Point(start.x - enemyMove[enemyType[enemyNo]], start.y));
+ } else {
+ return (new Point(start.x + enemyMove[enemyType[enemyNo]], start.y));
+ }
+ }
+
+ public void keyReleased(KeyEvent e) {
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ herocrouching = false;
+ decKeysDown(DOWNDOWN);
+ } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ if (floorIsIcy()) {
+ skidLeft();
+ }
+ decKeysDown(LEFTDOWN);
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ if (floorIsIcy()) {
+ skidRight();
+ }
+ decKeysDown(RIGHTDOWN);
+ }
+ }
+
+ public void keyTyped(KeyEvent e) {
+ }
+
+ synchronized Image getHeroImage() {
+ return (heroImages[heroImageNo]);
+ }
+
+ synchronized Image getObstacleImage(int obstaclenum) {
+ return (obstacleImages[obstacleImageNo[obstaclenum]]);
+ }
+
+ synchronized Image getEnemyImage(int enemyno) {
+ return (enemyImage[enemyno][enemyImageNo[enemyno]]);
+ }
+
+ boolean floorIsIcy() {
+ return (floors[level - 1] == area.icefloor);
+ }
+
+ void skidLeft() {
+ for (int i = 0; i < 6; i++) {
+ leftPressed(true);
+ try {
+ Thread.sleep(7);
+ } catch (Exception e) {
+ }
+ area.repaint();
+ }
+ }
+
+ void skidRight() {
+ for (int i = 0; i < 6; i++) {
+ rightPressed(true);
+ area.repaint();
+ try {
+ Thread.sleep(7);
+ } catch (Exception e) {
+ }
+ }
+ }
+
+ void displayStatus() {
+ /*
+ * // when a certain F Key is pressed, display positions of Mario, // all pipes
+ * and all enemies and the end flag (warp zone) System.out.println("--------");
+ * System.out.println("Mario is " + (dead? "dead" : "alive")); if (dead) { int
+ * enemyno = isEnemyPosition(playerPosition);
+ * System.out.println("Mario was killed by enemy " + enemyno); }
+ * System.out.println("In game is " + ingame); System.out.println("Mario is " +
+ * (onTheWayUp? "on the way up" : "not on the way up"));
+ * System.out.println("Mario's position is (" + playerPosition.x + ", " +
+ * playerPosition.y + ")");
+ * System.out.println("Mario's visible left, bottom co-ordinates are " +
+ * (playerPosition.x + 55) + " and " + (playerPosition.y + MARIOHEIGHT));
+ * System.out.println("Mario is on page " + page +
+ * " (which shows x positions from " + (page*PAGEWIDTH) + " to " +
+ * ((page+1)*PAGEWIDTH) + ")"); System.out.println("Screen bounds are (" +
+ * getBounds().width + ", " + getBounds().height + ")"); System.out.println("");
+ * for (int enemy=0; enemy < enemyNumber; enemy++) { System.out.println("Enemy "
+ * + enemy + " is " + enemyTypeString(enemyType[enemy]) + " and is " +
+ * (enemyDead[enemy] ? " " : "not ") + "dead"); System.out.println("Enemy " +
+ * enemy + " is at position (" + enemyPositions[enemy].x + ", " +
+ * enemyPositions[enemy].y+") and has size " + enemySize[enemyType[enemy]]); }
+ * //System.out.println(""); //for (int obstacle=0; obstacle < obstacleNumber;
+ * obstacle++) { // System.out.println("Obstacle " + obstacle +
+ * " is at position (" + obstaclePositions[obstacle].x + // ", " +
+ * obstaclePositions[obstacle].y+")"); //} System.out.println("");
+ * System.out.println("The warp zone is positioned at (" + warpzone.x + ", " +
+ * warpzone.y + ")"); System.out.println("========");
+ */
+ }
+
+ String enemyTypeString(int fortype) {
+ switch (fortype) {
+ case GOOMBA:
+ return ("GOOMBA");
+ case KOOPARED:
+ return ("KOOPA RED");
+ case KOOPAGREEN:
+ return ("KOOPA GREEN");
+ case KOOPAREDFLYING:
+ return ("KOOPA RED FLYING");
+ case BANZAI:
+ return ("BANZAI");
+ case WIGGLER:
+ return ("WIGGLER");
+ case BOO:
+ return ("BOO");
+ case FIREBOO:
+ return ("FOREBOO");
+ case BOBOMB:
+ return ("BOBOMB");
+ case BULLET:
+ return ("BULLET");
+ case WARSHIP:
+ return ("WARSHIP");
+ case YETI:
+ return ("YETI");
+ case FLYER:
+ return ("FLYER");
+ default:
+ return ("Unknown type (" + fortype + ")");
+ }
+ }
+
+ void changePageIfNecessary() {
+ if (playerPosition.x == LEFTEDGE)
+ return;
+ if ((playerPosition.x + SPACE_FROM_X_TO_MARIO) > (page * PAGEWIDTH + RIGHTEDGE - XAMOUNT)) {
+ // System.out.println("Change page up: (" + playerPosition.x+ "+" +
+ // SPACE_FROM_X_TO_MARIO+ ") > (" + page+ "*" + PAGEWIDTH + "+" + RIGHTEDGE +
+ // "-" + XAMOUNT + ")");
+ page++;
+ } else if ((playerPosition.x + SPACE_FROM_X_TO_MARIO) - (page * PAGEWIDTH) < (LEFTEDGE + XAMOUNT)) {
+ // System.out.println("Change page down: (" + playerPosition.x+ "+" +
+ // SPACE_FROM_X_TO_MARIO+ ")-(" + page+ "*" + PAGEWIDTH + ") < (" + LEFTEDGE+
+ // "+" + XAMOUNT+")");
+ page--;
+ }
+ }
+}
diff --git a/Mario/src/MarioArea.java b/Mario/src/MarioArea.java
@@ -15,7 +15,7 @@ public class MarioArea extends JPanel implements ActionListener {
static int FLOORLEVEL = 589;
static final int FLOORWIDTH = 150;
static int FLOORDIFF = 605 - FLOORLEVEL;
- MarioGame myApplet = null;
+ Mario myApplet = null;
Image mariotitle;
Image icefloor;
Image floor2;
@@ -109,7 +109,7 @@ public class MarioArea extends JPanel implements ActionListener {
MediaTracker mt = null;
boolean showingMessage = false;
- public MarioArea(MarioGame parent) {
+ public MarioArea(Mario parent) {
mt = new MediaTracker(parent);
myApplet = parent;
upmushroom = load(parent, "1up!mushroom.gif");
@@ -210,7 +210,7 @@ public class MarioArea extends JPanel implements ActionListener {
Floor10 = load(parent, "mariofloor10.gif");
}
- Image load(MarioGame parent, String picture) {
+ Image load(Mario parent, String picture) {
try {
Image im = ImageIO.read(new File("../Assets/" + picture));
checkImage(im, picture);
@@ -249,67 +249,67 @@ public class MarioArea extends JPanel implements ActionListener {
g.setColor(Color.black);
// paint the floor
- if (MarioGame.floors[MarioGame.level - 1] != null) {
+ if (Mario.floors[Mario.level - 1] != null) {
for (int pos = 0; pos < w; pos += FLOORWIDTH) {
- g.drawImage(MarioGame.floors[MarioGame.level - 1], pos, FLOORLEVEL, Color.black, null);
+ g.drawImage(Mario.floors[Mario.level - 1], pos, FLOORLEVEL, Color.black, null);
}
}
- if (!MarioGame.juststarted) {
- if (MarioGame.obstaclePositions != null) {
+ if (!Mario.juststarted) {
+ if (Mario.obstaclePositions != null) {
myApplet.changePageIfNecessary();
// show the obstacles from right to left (because pipes have white space to
// their left but not their right)
- for (int i = MarioGame.obstacleNumber - 1; i >= 0; i--) {
+ for (int i = Mario.obstacleNumber - 1; i >= 0; i--) {
obstacleimage = myApplet.getObstacleImage(i);
- if (MarioGame.isTall[i])
+ if (Mario.isTall[i])
obstacleimage = tallobstacle; // only one image for this for now
g.drawImage(obstacleimage,
- MarioGame.obstaclePositions[i].x - (MarioGame.page * MarioGame.PAGEWIDTH),
- MarioGame.obstaclePositions[i].y, Color.white, null);
+ Mario.obstaclePositions[i].x - (Mario.page * Mario.PAGEWIDTH),
+ Mario.obstaclePositions[i].y, Color.white, null);
}
}
// show the enemies
- if (MarioGame.enemyPositions != null) {
- for (int i = 0; i < MarioGame.enemyNumber; i++) {
+ if (Mario.enemyPositions != null) {
+ for (int i = 0; i < Mario.enemyNumber; i++) {
// if (!myApplet.enemyDead[i]) {
enemyimage = myApplet.getEnemyImage(i);
- g.drawImage(enemyimage, MarioGame.enemyPositions[i].x - (MarioGame.page * MarioGame.PAGEWIDTH),
- MarioGame.enemyPositions[i].y, null);
+ g.drawImage(enemyimage, Mario.enemyPositions[i].x - (Mario.page * Mario.PAGEWIDTH),
+ Mario.enemyPositions[i].y, null);
// }
}
}
// draw Hero (on top of preceding images)
- if (MarioGame.playerPosition != null) {
+ if (Mario.playerPosition != null) {
// show the player
Image herosimage = myApplet.getHeroImage();
- if (MarioGame.herocrouching) {
- if (MarioGame.heroleft)
+ if (Mario.herocrouching) {
+ if (Mario.heroleft)
herosimage = herocrouchleft;
else
herosimage = herocrouch;
}
- if (MarioGame.jumping) {
- if (MarioGame.heroleft)
+ if (Mario.jumping) {
+ if (Mario.heroleft)
herosimage = herojumpleft;
else
herosimage = herojump;
}
- g.drawImage(herosimage, MarioGame.playerPosition.x - (MarioGame.page * MarioGame.PAGEWIDTH),
- MarioGame.playerPosition.y, /* Color.white, */ null);
+ g.drawImage(herosimage, Mario.playerPosition.x - (Mario.page * Mario.PAGEWIDTH),
+ Mario.playerPosition.y, /* Color.white, */ null);
}
}
// draw warp image (on top of Hero)
- if (MarioGame.warpzone != null) {
+ if (Mario.warpzone != null) {
// show the warp zone at the end of the level
- g.drawImage(herowarp, MarioGame.warpzone.x - (MarioGame.page * MarioGame.PAGEWIDTH), MarioGame.warpzone.y,
+ g.drawImage(herowarp, Mario.warpzone.x - (Mario.page * Mario.PAGEWIDTH), Mario.warpzone.y,
Color.white, null);
}
- if (MarioGame.ingame == false && !MarioGame.juststarted) {
- if (MarioGame.dead) {
+ if (Mario.ingame == false && !Mario.juststarted) {
+ if (Mario.dead) {
// Hero is dead
g.drawImage(herodead, myApplet.getBounds().width / 2, getBounds().height / 2, Color.white, null);
} else {
diff --git a/Mario/src/MarioGame.java b/Mario/src/MarioGame.java
@@ -1,1509 +0,0 @@
-
-/* Copyright (c) Mary Percival 2003 */
-/* Mario game Created May 2003 */
-
-import java.awt.Color;
-import java.awt.Image;
-import java.awt.Point;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-
-import javax.swing.JFrame;
-
-public class MarioGame extends JFrame implements KeyListener, Runnable {
- private static final long serialVersionUID = 7030451342808203557L;
- boolean easymode = true;
- static int MAXLEVEL = 9;
- static int level = 0;
-
- // the levels so far are:
- // 1 beginner level: 1 piranha & 1 goomba
- // 2 introducing green koopa
- // 3 more of the same
- // 4 introducing red koopa (flying)
- // 5 more and harder
- // 6 ?
- // 7 ?
- // 8 ?
- // 9 ?
-
- static int LEFT = 1;
- static int RIGHT = 0;
- // the next 2 constants are overridden in init once we know the screen size
- static int RIGHTEDGE = 789;
- static int BOTTOMEDGE = 800;
- static int PAGEWIDTH = 741;
-
- static Point IMAGESIZE = new Point(152, 107);
- static final int LEFTEDGE = -45;
- static final int TOPEDGE = -10;
- static int GROUNDLEVEL = 503;
- static int startPosY;
- static int JUMPAMOUNT = 90;
- static int BOUNCEAMOUNT = 90;
- static final int FALLAMOUNT = 16; // amount he falls each time interval
- static final int RISEAMOUNT = 16; // amount he rises each time interval
- static final int XAMOUNT = 12;
-
- static final int X = 1;
- static final int Y = 2;
- static final int NOT = 3;
- static final int DELAY = 50;
-
- static final int OBSTACLEIMAGES = 19;
- static final int HEROIMAGES = 4;
- static final int ENEMYIMAGES = 3;
-
- // ----------------------------------------------------------------------------------------------
- // ENEMY TYPES
- // ----------------------------------------------------------------------------------------------
- static final int ENEMYTYPES = 15; // goomba, koopa red, koopa green, koopa red flying, banzai, wiggler, boo,
- // fireboo,bobomb,warship,yeti,chainchomp,atom
- static final int GOOMBA = 0;
- static final int KOOPARED = 1;
- static final int KOOPAGREEN = 2;
- static final int KOOPAREDFLYING = 3;
- static final int BANZAI = 4;
- static final int WIGGLER = 5;
- static final int BOO = 6;
- static final int FIREBOO = 7;
- static final int BOBOMB = 8;
- static final int BULLET = 9;
- static final int WARSHIP = 10;
- static final int YETI = 11;
- static final int FLYER = 12;
- static final int CHOMP = 13;
- static final int ATOM = 14;
-
- // enemy positions (height)
- static final int GOOMBAHEIGHT = GROUNDLEVEL + 55;
- static final int KOOPAREDHEIGHT = GROUNDLEVEL + 39;
- static final int KOOPAGREENHEIGHT = GROUNDLEVEL + 39;
- static final int KOOPAREDFLYINGHEIGHT = GROUNDLEVEL - 16;
- static final int BANZAIHEIGHT = GROUNDLEVEL - 90;
- static final int WIGGLERHEIGHT = GROUNDLEVEL + 16;
- static final int BOOHEIGHT = GROUNDLEVEL - 7;
- static final int FIREBOOHEIGHT = GROUNDLEVEL - 7;
- static final int BOBOMBHEIGHT = GROUNDLEVEL + 5;
- static final int BULLETHEIGHT = GROUNDLEVEL + 55;
- static final int WARSHIPHEIGHT = GROUNDLEVEL + 100;
- static final int YETIHEIGHT = GROUNDLEVEL;
- static final int FLYERHEIGHT = GROUNDLEVEL - 20;
- static final int CHOMPHEIGHT = GROUNDLEVEL - 55;
- static final int ATOMHEIGHT = GROUNDLEVEL + 40;
- static int enemyHeight[] = new int[ENEMYTYPES];
-
- static final int enemySize[] = { 27, 42, 42, 42, 172, 75, 37, 37, 74, 8, 152, 86, 86, 75, 25 };
- static final int enemyTopSpace[] = { 4, 13, 13, 0, 0, 10, 6, 6, 7, 0, 20, 8, 17, 10, 0 };
-
- static final int SPACE_FROM_X_TO_MARIO = 55;
- static final int MARIOHEIGHT = 86;
- static final int MARIOOFFSET = 21;
- static final int MARIOCROUCHOFFSET = 39;
- static final int MARIOSTANDINGSIZE = 65;
- static final int MARIOCROUCHINGSIZE = 45;
-
- static final int JUMPDURATION = 5;
- static final int SUPERJUMPDURATION = 8;
- static final int MARIOLEFTOFOBSTACLE = 45; // fudge factor because Mario image is diff size to obstacle image
- static final int MARIORIGHTOFOBSTACLE = 10; // fudge factor because Mario image is diff size to obstacle image
- static final int ENEMYLEFTOFOBSTACLE = 16; // fudge factor for enemy images
- static final int ENEMYRIGHTOFOBSTACLE = 49; // >49 causes panic!
- static final int MARIOLEFTOFENEMY = 73;
- static final int MARIORIGHTOFENEMY = -23;
-
- static final int LEFTDOWN = 0;
- static final int RIGHTDOWN = 1;
- static final int DOWNDOWN = 2;
- static final int SPACEDOWN = 3;
-
- static final int OBSTACLEHEIGHT = 42;
- static final int TALLOBSTACLEDIFF = 28;
- static final int OBSTACLEWIDTH = 86;
- static int GROUNDDIFF = 605 - GROUNDLEVEL;
-
- // all member variables 'static' because shared with the enemy action thread
- static MarioArea area;
- static Thread timer;
- static boolean finished = false;
- static boolean ingame = false;
- static boolean juststarted = true;
- static Point warpzone;
- static int[] keysdown = new int[4];
- static Point[] enemyPositions;
- static Point playerPosition;
- static Point[] obstaclePositions;
- static boolean[] piranhaPopping; // one for each obstacle
- static boolean[] hasPiranha; // one for each obstacle
- static boolean[] isTall; // one for each obstacle
- static int enemyDirection[];
- static int enemyNumber = 1, enemiesRemaining = 1, obstacleNumber = 1;
- static boolean herocrouching = false;
- static boolean onTheWayUp = false;
- static boolean bouncing = false;
- static boolean wasbouncing = false;
- static boolean dead = false;
- static int page = 0;
- static int heroImageNo = 0;
- static int enemyImageNo[];
- static int levellength = 1482;
- static Image[] heroImages = new Image[HEROIMAGES];
- static Image[] obstacleImages = new Image[OBSTACLEIMAGES]; // pipe, piranhapeep, piranha peepy etc
- static Image[] squished = new Image[ENEMYTYPES]; // squished images for each enemy type
- static Image[][][] enemyImages = new Image[ENEMYTYPES][2][ENEMYIMAGES]; // left right left right or whatever
- static int obstacleImageNo[]; // what is the current image for obstacle n
- static Image[][] enemyImage = new Image[ENEMYTYPES][ENEMYIMAGES];// what is the current image for enemy n?
- static Image floors[] = new Image[MAXLEVEL];
- static int enemyType[]; // what is the type of enemy n?
- static boolean enemyDead[]; // is enemy n dead?
- static boolean heroleft = false;
- static boolean jumping = false;
- static int enemyMove[] = new int[ENEMYTYPES];
- boolean somethingChangedSinceRepaint = false;
-
- // *************************************************************
- public static void main(String[] args) {
- MarioGame marioGame = new MarioGame();
- marioGame.setLayout(null);
- marioGame.setBackground(Color.white);
- marioGame.setSize(RIGHTEDGE, BOTTOMEDGE);
- area = new MarioArea(marioGame);
- marioGame.add(area);
- //RIGHTEDGE = (marioGame.getBounds().width / XAMOUNT) * XAMOUNT + LEFTEDGE;
- //BOTTOMEDGE = marioGame.getBounds().height - 1;
- marioGame.setVisible(true);
- area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
- //GROUNDLEVEL = marioGame.getBounds().height - GROUNDDIFF;
- //GROUNDLEVEL = BOTTOMEDGE;// - GROUNDDIFF;
- startPosY = GROUNDLEVEL;
- //MarioArea.FLOORLEVEL = marioGame.getBounds().height - MarioArea.FLOORDIFF;
- area.setVisible(true);
-
- marioGame.addKeyListener(marioGame);
- area.addKeyListener(marioGame);
- area.requestFocus();
-
- obstacleImages[0] = area.obstacle;
- obstacleImages[1] = area.obstacle;
- obstacleImages[2] = area.obstacle;
- obstacleImages[3] = area.obstacle;
- obstacleImages[4] = area.piranhapeepo;
- obstacleImages[5] = area.piranhapeep;
- obstacleImages[6] = area.piranhapeepy;
- obstacleImages[7] = area.piranha1;
- obstacleImages[8] = area.piranha1;
- obstacleImages[9] = area.piranha1;
- obstacleImages[10] = area.piranha2; //
- obstacleImages[11] = area.piranha2; //
- obstacleImages[12] = area.piranha2; //
- obstacleImages[13] = area.piranhapeepy; //
- obstacleImages[14] = area.piranhapeep; //
- obstacleImages[15] = area.piranhapeepo;
- obstacleImages[16] = area.obstacle; //
- obstacleImages[17] = area.obstacle; //
- obstacleImages[18] = area.obstacle; //
-
- enemyImages[GOOMBA][RIGHT][0] = area.goomba;
- enemyImages[GOOMBA][RIGHT][1] = area.goomba2;
- enemyImages[GOOMBA][LEFT][0] = area.goombaleft;
- enemyImages[GOOMBA][LEFT][1] = area.goomba2left;
-
- enemyImages[KOOPARED][RIGHT][0] = area.kooparedleft;
- enemyImages[KOOPARED][RIGHT][1] = area.kooparedleft;
- enemyImages[KOOPARED][LEFT][0] = area.koopared;
- enemyImages[KOOPARED][LEFT][1] = area.koopared;
-
- enemyImages[KOOPAGREEN][RIGHT][0] = area.koopagreen;
- enemyImages[KOOPAGREEN][RIGHT][1] = area.koopagreen;
- enemyImages[KOOPAGREEN][LEFT][0] = area.koopagreenleft;
- enemyImages[KOOPAGREEN][LEFT][1] = area.koopagreenleft;
-
- enemyImages[KOOPAREDFLYING][RIGHT][0] = area.kooparedfleft;
- enemyImages[KOOPAREDFLYING][RIGHT][1] = area.kooparedfleft;
- enemyImages[KOOPAREDFLYING][LEFT][0] = area.kooparedf;
- enemyImages[KOOPAREDFLYING][LEFT][1] = area.kooparedf;
-
- enemyImages[BANZAI][RIGHT][0] = area.Banzai;
- enemyImages[BANZAI][RIGHT][1] = area.Banzai;
- enemyImages[BANZAI][LEFT][0] = area.Banzai;
- enemyImages[BANZAI][LEFT][1] = area.Banzai;
-
- enemyImages[WIGGLER][RIGHT][0] = area.Wiglerright;
- enemyImages[WIGGLER][RIGHT][1] = area.Wiglerright1;
- enemyImages[WIGGLER][RIGHT][2] = area.Wiglerright2;
- enemyImages[WIGGLER][LEFT][0] = area.Wiglerleft;
- enemyImages[WIGGLER][LEFT][1] = area.Wiglerleft1;
- enemyImages[WIGGLER][LEFT][2] = area.Wiglerleft2;
-
- enemyImages[BOO][RIGHT][0] = area.Boo2;
- enemyImages[BOO][RIGHT][1] = area.Boo2;
- enemyImages[BOO][LEFT][0] = area.Boo1;
- enemyImages[BOO][LEFT][1] = area.Boo1;
-
- enemyImages[FIREBOO][RIGHT][0] = area.Fireboo2;
- enemyImages[FIREBOO][RIGHT][1] = area.Fireboo2;
- enemyImages[FIREBOO][LEFT][0] = area.Fireboo1;
- enemyImages[FIREBOO][LEFT][1] = area.Fireboo1;
-
- enemyImages[BOBOMB][LEFT][0] = area.Bobomb;
- enemyImages[BOBOMB][LEFT][1] = area.Bobomb2;
- enemyImages[BOBOMB][RIGHT][0] = area.Bobombf;
- enemyImages[BOBOMB][RIGHT][1] = area.Bobombf2;
-
- enemyImages[BULLET][LEFT][0] = area.Bullet;
- enemyImages[BULLET][LEFT][1] = area.Bullet;
- enemyImages[BULLET][RIGHT][0] = area.Bullet;
- enemyImages[BULLET][RIGHT][1] = area.Bullet;
-
- enemyImages[WARSHIP][LEFT][0] = area.Warship1;
- enemyImages[WARSHIP][LEFT][1] = area.Warship2;
- enemyImages[WARSHIP][RIGHT][0] = area.Warship1;
- enemyImages[WARSHIP][RIGHT][1] = area.Warship2;
-
- enemyImages[YETI][LEFT][0] = area.Yetil1;
- enemyImages[YETI][LEFT][1] = area.Yetil2;
- enemyImages[YETI][RIGHT][0] = area.Yetir1;
- enemyImages[YETI][RIGHT][1] = area.Yetir2;
-
- enemyImages[FLYER][LEFT][0] = area.p1fl;
- enemyImages[FLYER][LEFT][1] = area.p2fl;
- enemyImages[FLYER][RIGHT][0] = area.p1fr;
- enemyImages[FLYER][RIGHT][1] = area.p2fr;
-
- enemyImages[CHOMP][LEFT][0] = area.chainchomp1;
- enemyImages[CHOMP][LEFT][1] = area.chainchomp2;
- enemyImages[CHOMP][RIGHT][0] = area.chainchomp1;
- enemyImages[CHOMP][RIGHT][1] = area.chainchomp2;
-
- enemyImages[ATOM][LEFT][0] = area.Atom1;
- enemyImages[ATOM][LEFT][1] = area.Atom2;
- enemyImages[ATOM][RIGHT][0] = area.Atom1;
- enemyImages[ATOM][RIGHT][1] = area.Atom2;
-
- enemyMove[GOOMBA] = 5;
- enemyMove[KOOPARED] = 5;
- enemyMove[KOOPAGREEN] = 5;
- enemyMove[KOOPAREDFLYING] = 8;
- enemyMove[BANZAI] = 16;
- enemyMove[WIGGLER] = 15;
- enemyMove[BOO] = 5;
- enemyMove[FIREBOO] = 10;
- enemyMove[BOBOMB] = 5;
- enemyMove[BULLET] = 10;
- enemyMove[WARSHIP] = 20;
- enemyMove[YETI] = 5;
- enemyMove[FLYER] = 10;
- enemyMove[CHOMP] = 0;
- enemyMove[ATOM] = 1;
-
- enemyHeight[GOOMBA] = 40;
- enemyHeight[KOOPARED] = 33;
- enemyHeight[KOOPAGREEN] = 33;
- enemyHeight[KOOPAREDFLYING] = 33;
- enemyHeight[BANZAI] = 60;
- enemyHeight[WIGGLER] = 33;
- enemyHeight[BOO] = 33;
- enemyHeight[FIREBOO] = 33;
- enemyHeight[BOBOMB] = 33;
- enemyHeight[BULLET] = 5;
- enemyHeight[WARSHIP] = 50;
- enemyHeight[YETI] = 33;
- enemyHeight[FLYER] = 50;
- enemyHeight[CHOMP] = 60;
- enemyHeight[ATOM] = 22;
-
- squished[GOOMBA] = area.squishedgoomba;
- squished[KOOPARED] = area.redshell;
- squished[KOOPAGREEN] = area.greenshell;
- squished[KOOPAREDFLYING] = area.koopared;
- squished[BANZAI] = area.Banzai; // not actually used
- squished[WIGGLER] = area.Wiglerleft; // not actually used
- squished[BOO] = area.Boo1;
- squished[FIREBOO] = area.Fireboo1;
- squished[BOBOMB] = area.Bobomb;
- squished[BULLET] = area.Bullet;
- squished[WARSHIP] = area.Warship2;
- squished[YETI] = area.Yetil1;
- squished[FLYER] = area.p1fl;
- squished[CHOMP] = area.chainchompdead;
- squished[ATOM] = area.Atom1;
-
- for (int i = 0; i < MAXLEVEL; i++) {
- floors[i] = area.floor4;
- }
-
- floors[0] = area.floor4;
- floors[1] = area.floor5;
- floors[2] = area.floor3;
- floors[3] = area.floor7;
- floors[4] = area.floor8;
- floors[5] = area.floor9;
- floors[6] = area.floor2;
- floors[7] = area.floor6;
- floors[8] = area.Floor10;
-
- timer = new Thread(marioGame);
- timer.start();
-
- }
-
- synchronized void faceRight() {
- heroImages[0] = area.herostand;
- heroImages[1] = area.hero1;
- heroImages[2] = area.herostand;
- heroImages[3] = area.hero2;
- heroImageNo = 0;
- heroleft = false;
- }
-
- synchronized void faceLeft() {
- heroImages[0] = area.herostandleft;
- heroImages[1] = area.hero1left;
- heroImages[2] = area.herostandleft;
- heroImages[3] = area.hero2left;
- heroImageNo = 0;
- heroleft = true;
- }
-
- synchronized void enemyFaceRight(int enemyno) {
- enemyImage[enemyno][0] = enemyImages[enemyType[enemyno]][RIGHT][0];
- enemyImage[enemyno][1] = enemyImages[enemyType[enemyno]][RIGHT][1];
- if (enemyType[enemyno] == WIGGLER)
- enemyImage[enemyno][2] = enemyImages[enemyType[enemyno]][RIGHT][2];
- enemyDirection[enemyno] = RIGHT;
- }
-
- synchronized void enemyFaceLeft(int enemyno) {
- enemyImage[enemyno][0] = enemyImages[enemyType[enemyno]][LEFT][0];
- enemyImage[enemyno][1] = enemyImages[enemyType[enemyno]][LEFT][1];
- if (enemyType[enemyno] == WIGGLER)
- enemyImage[enemyno][2] = enemyImages[enemyType[enemyno]][LEFT][2];
- enemyDirection[enemyno] = LEFT;
- }
-
- synchronized void enemyDie(int enemyno) {
- // displayStatus();
- enemyImage[enemyno][0] = squished[enemyType[enemyno]];
- enemyImage[enemyno][1] = squished[enemyType[enemyno]];
- if (enemyType[enemyno] == WIGGLER)
- enemyImage[enemyno][2] = squished[enemyType[enemyno]];
- }
-
- synchronized void standStill() {
- heroImageNo = 0;
- }
-
- public void doLevel(int level) {
- // this runs one 'level'
- juststarted = true;
- dead = false;
-
- // position Hero at the bottom left
- playerPosition = new Point(LEFTEDGE, GROUNDLEVEL);
- faceRight();
-
- // *********** THIS STUFF DEPENDS WHAT LEVEL YOU ARE ON ************
- switch (level) {
- case 1:
- obstacleNumber = 4; // 4 pipes for level 1
- enemyNumber = 1;
- levellength = 1482; // 2 pages
- break;
- case 2:
- obstacleNumber = 11;
- enemyNumber = 5;
- levellength = 2964; // 4 pages
- break;
- case 3:
- obstacleNumber = 13;
- enemyNumber = 8;
- levellength = 2223; // 3 pages
- break;
- case 4:
- obstacleNumber = 11;
- enemyNumber = 12;
- levellength = 4446; // 6 pages
- break;
- case 5:
- obstacleNumber = 17;
- enemyNumber = 13;
- levellength = 5928; // 8 pages
- break;
- case 6:
- obstacleNumber = 14;
- enemyNumber = 1;
- levellength = 5928; // 8 pages
- break;
- case 7:
- obstacleNumber = 14;
- enemyNumber = 6;
- levellength = 3705; // 5 pages
- break;
- case 8:
- obstacleNumber = 16;
- enemyNumber = 9;
- levellength = 5928; // 8 pages
- break;
- case 9:
- obstacleNumber = 6;
- enemyNumber = 9;
- levellength = 3705; // 5 pages
- break;
- case 10:
- obstacleNumber = 29;
- enemyNumber = 0;
- levellength = 4446; // 6 pages
- default:
- System.out.println("Level " + level + " has not yet been implemented");
- }
-
- enemyImage = new Image[enemyNumber][ENEMYIMAGES];// what is the current image for enemy n?
- // initialise piranha states
- obstacleImageNo = new int[obstacleNumber];
- hasPiranha = new boolean[obstacleNumber];
- piranhaPopping = new boolean[obstacleNumber];
- isTall = new boolean[obstacleNumber];
-
- // initialise the arrays of enemies, etc
- enemyPositions = new Point[enemyNumber];
- enemyType = new int[enemyNumber];
- enemyDead = new boolean[enemyNumber];
- obstaclePositions = new Point[obstacleNumber];
- enemyDirection = new int[enemyNumber];
- enemyImageNo = new int[enemyNumber];
-
- for (int i = 0; i < enemyNumber; i++) {
- enemyImageNo[i] = 0;
- }
-
- switch (level) {
- // ---------------------------------
- // LEVEL 1
- // ---------------------------------
- case 1:
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- if (i == 0) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- } else {
- if (i == 3)
- isTall[i] = true;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- }
- }
- obstaclePositions[0] = new Point(400, GROUNDLEVEL);
- obstaclePositions[1] = new Point(950, GROUNDLEVEL);
- obstaclePositions[2] = new Point(1245, GROUNDLEVEL); // 1255 for adjacent
- obstaclePositions[3] = new Point(1320, GROUNDLEVEL);
-
- enemyPositions[0] = new Point(1000, GOOMBAHEIGHT);
- enemyType = new int[] { GOOMBA };
- break;
- // -----------------------------------------------
- // LEVEL 2
- // -----------------------------------------------
- case 2:
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- if (i == 2 || i == 7 || i == 8) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- } else {
- if (i == 4 || i == 6 || i == 10)
- isTall[i] = true;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- }
- }
-
- // PAGE 1
- obstaclePositions[0] = new Point(150, GROUNDLEVEL);
- obstaclePositions[1] = new Point(225, GROUNDLEVEL);
- obstaclePositions[2] = new Point(300, GROUNDLEVEL);
- // PAGE 2
- obstaclePositions[3] = new Point(891, GROUNDLEVEL);
- obstaclePositions[4] = new Point(966, GROUNDLEVEL);
- // PAGE 3
- obstaclePositions[5] = new Point(1632, GROUNDLEVEL);
- obstaclePositions[6] = new Point(1707, GROUNDLEVEL);
- obstaclePositions[7] = new Point(1782, GROUNDLEVEL);
- // PAGE 4
- obstaclePositions[8] = new Point(2373, GROUNDLEVEL);
- obstaclePositions[9] = new Point(2743, GROUNDLEVEL);
- obstaclePositions[10] = new Point(2818, GROUNDLEVEL);
-
- enemyType = new int[] { KOOPAGREEN, GOOMBA, GOOMBA, GOOMBA, GOOMBA };
- enemyPositions[0] = new Point(375, KOOPAGREENHEIGHT);
- enemyPositions[1] = new Point(1041, GOOMBAHEIGHT);
- enemyPositions[2] = new Point(1141, GOOMBAHEIGHT);
- enemyPositions[3] = new Point(1882, GOOMBAHEIGHT);
- enemyPositions[4] = new Point(2473, GOOMBAHEIGHT);
- break;
- // -----------------------------------------------
- // LEVEL 3
- // -----------------------------------------------
- case 3:
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- if (i == 4)
- isTall[i] = true;
- if (i != 4 && i != 11 && i != 12) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- } else {
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- }
- }
- // PAGE 1
- obstaclePositions[0] = new Point(50, GROUNDLEVEL);
- obstaclePositions[1] = new Point(130, GROUNDLEVEL);
- obstaclePositions[2] = new Point(210, GROUNDLEVEL);
-
- obstaclePositions[3] = new Point(540, GROUNDLEVEL);
- obstaclePositions[4] = new Point(620, GROUNDLEVEL);
- obstaclePositions[5] = new Point(700, GROUNDLEVEL);
- // PAGE 2
- obstaclePositions[6] = new Point(850, GROUNDLEVEL);
- obstaclePositions[7] = new Point(925, GROUNDLEVEL);
- obstaclePositions[8] = new Point(1000, GROUNDLEVEL);
- obstaclePositions[9] = new Point(1075, GROUNDLEVEL);
- obstaclePositions[10] = new Point(1150, GROUNDLEVEL);
- obstaclePositions[11] = new Point(1350, GROUNDLEVEL);
-
- // PAGE 3
- obstaclePositions[12] = new Point(2000, GROUNDLEVEL);
-
- enemyType = new int[] { KOOPAGREEN, GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA };
-
- enemyPositions[0] = new Point(365, KOOPAGREENHEIGHT);
- enemyPositions[1] = new Point(420, GOOMBAHEIGHT);
- enemyPositions[2] = new Point(495, GOOMBAHEIGHT);
- enemyPositions[3] = new Point(1250, GOOMBAHEIGHT);
- enemyPositions[4] = new Point(1500, GOOMBAHEIGHT);
- enemyPositions[5] = new Point(1575, GOOMBAHEIGHT);
- enemyPositions[6] = new Point(1650, GOOMBAHEIGHT);
- enemyPositions[7] = new Point(1725, GOOMBAHEIGHT);
-
- break;
- // -----------------------------------------------
- // LEVEL 4
- // -----------------------------------------------
- case 4:
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- if (i == 2 || i == 5 || i == 7 || i == 8 || i == 9 || i == 10) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- } else {
- if (i == 1 || i == 4 || i == 6)
- isTall[i] = true;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- }
- }
-
- // PAGE 1
- obstaclePositions[0] = new Point(185, GROUNDLEVEL);
- obstaclePositions[1] = new Point(370, GROUNDLEVEL);
- obstaclePositions[2] = new Point(700, GROUNDLEVEL);
- // PAGE 2
- obstaclePositions[3] = new Point(900, GROUNDLEVEL);
- obstaclePositions[4] = new Point(1300, GROUNDLEVEL);
- // PAGE 3
- obstaclePositions[5] = new Point(1500, GROUNDLEVEL);
- obstaclePositions[6] = new Point(1750, GROUNDLEVEL);
- obstaclePositions[7] = new Point(2000, GROUNDLEVEL);
- // PAGE 4
-
- // PAGE 5
- obstaclePositions[8] = new Point(3064, GROUNDLEVEL);
- obstaclePositions[9] = new Point(3264, GROUNDLEVEL);
- // PAGE 6
- obstaclePositions[10] = new Point(4100, GROUNDLEVEL);
-
- enemyType = new int[] { KOOPARED, KOOPARED, KOOPAREDFLYING, GOOMBA, GOOMBA, GOOMBA, GOOMBA, KOOPAREDFLYING,
- KOOPARED, KOOPARED, KOOPARED, FLYER };
-
- enemyPositions[0] = new Point(470, KOOPAREDHEIGHT);
- enemyPositions[1] = new Point(520, KOOPAREDHEIGHT);
-
- enemyPositions[2] = new Point(1000, KOOPAREDFLYINGHEIGHT);
- enemyPositions[3] = new Point(1400, GOOMBAHEIGHT);
-
- enemyPositions[4] = new Point(2230, GOOMBAHEIGHT);
- enemyPositions[5] = new Point(2280, GOOMBAHEIGHT);
- enemyPositions[6] = new Point(2320, GOOMBAHEIGHT);
-
- enemyPositions[7] = new Point(3600, KOOPAREDFLYINGHEIGHT);
-
- enemyPositions[8] = new Point(3710, KOOPAREDHEIGHT);
- enemyPositions[9] = new Point(3760, KOOPAREDHEIGHT);
- enemyPositions[10] = new Point(3810, KOOPAREDHEIGHT);
- enemyPositions[11] = new Point(3500, FLYERHEIGHT);
-
- break;
- // -----------------------------------------------
- // LEVEL 5
- // -----------------------------------------------
- case 5:
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- if (i == 0 || i == 2 || i == 4 || i == 10 || i == 11 || i == 14 || i == 16) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- } else {
- if (i == 1 || i == 3 || i == 6 || i == 7 || i == 8 || i == 9 || i == 12 || i == 15)
- isTall[i] = true;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- }
- }
- // page1
- obstaclePositions[0] = new Point(150, GROUNDLEVEL);
- obstaclePositions[1] = new Point(300, GROUNDLEVEL);
- obstaclePositions[2] = new Point(600, GROUNDLEVEL);
- // page2
- obstaclePositions[3] = new Point(800, GROUNDLEVEL);
- obstaclePositions[4] = new Point(900, GROUNDLEVEL);
- // page3
- obstaclePositions[5] = new Point(1600, GROUNDLEVEL);
- obstaclePositions[6] = new Point(1700, GROUNDLEVEL);
- obstaclePositions[7] = new Point(1800, GROUNDLEVEL);
- obstaclePositions[8] = new Point(1900, GROUNDLEVEL);
- obstaclePositions[9] = new Point(2000, GROUNDLEVEL);
- // page4
- obstaclePositions[10] = new Point(2400, GROUNDLEVEL);
- // page5
- obstaclePositions[11] = new Point(3100, GROUNDLEVEL);
- obstaclePositions[12] = new Point(3200, GROUNDLEVEL);
- // page6
- obstaclePositions[13] = new Point(3850, GROUNDLEVEL);
- obstaclePositions[14] = new Point(3950, GROUNDLEVEL);
- obstaclePositions[15] = new Point(4050, GROUNDLEVEL);
- // page7
- // NONE\\
- // page8
- obstaclePositions[16] = new Point(5550, GROUNDLEVEL);
-
- enemyType = new int[] { KOOPAREDFLYING, GOOMBA, GOOMBA, KOOPAGREEN, KOOPAREDFLYING, KOOPAGREEN, KOOPAGREEN,
- KOOPAGREEN, KOOPAREDFLYING, KOOPAREDFLYING, GOOMBA, GOOMBA, GOOMBA };
-
- enemyPositions[0] = new Point(450, KOOPAREDFLYINGHEIGHT);
- enemyPositions[1] = new Point(700, GOOMBAHEIGHT);
- enemyPositions[2] = new Point(1000, GOOMBAHEIGHT);
- enemyPositions[3] = new Point(1100, KOOPAGREENHEIGHT);
- enemyPositions[4] = new Point(2100, KOOPAREDFLYINGHEIGHT);
- enemyPositions[5] = new Point(2500, KOOPAGREENHEIGHT);
- enemyPositions[6] = new Point(2600, KOOPAGREENHEIGHT);
- enemyPositions[7] = new Point(2700, KOOPAGREENHEIGHT);
- enemyPositions[8] = new Point(3400, KOOPAREDFLYINGHEIGHT);
- enemyPositions[9] = new Point(3600, KOOPAREDFLYINGHEIGHT);
- enemyPositions[10] = new Point(4700, GOOMBAHEIGHT);
- enemyPositions[11] = new Point(4800, GOOMBAHEIGHT);
- enemyPositions[12] = new Point(4800, GOOMBAHEIGHT);
- break;
- // -----------------------------------------------
- // LEVEL 6
- // -----------------------------------------------
- case 6:
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- if (i == 2 || i == 3 || i == 4 || i == 5 || i == 7 || i == 10 || i == 11) {
- isTall[i] = true;
- } else {
- if (i == 13) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- }
-
- }
- }
- obstaclePositions[0] = new Point(350, GROUNDLEVEL);
- obstaclePositions[1] = new Point(1091, GROUNDLEVEL);
- obstaclePositions[2] = new Point(1191, GROUNDLEVEL);
- obstaclePositions[3] = new Point(1600, GROUNDLEVEL);
- obstaclePositions[4] = new Point(1675, GROUNDLEVEL);
- obstaclePositions[5] = new Point(1750, GROUNDLEVEL);
- obstaclePositions[6] = new Point(2500, GROUNDLEVEL);
- obstaclePositions[7] = new Point(2600, GROUNDLEVEL);
- obstaclePositions[8] = new Point(2700, GROUNDLEVEL);
- obstaclePositions[9] = new Point(3975, GROUNDLEVEL);
- obstaclePositions[10] = new Point(4050, GROUNDLEVEL);
- obstaclePositions[11] = new Point(4150, GROUNDLEVEL);
- obstaclePositions[12] = new Point(4225, GROUNDLEVEL);
- obstaclePositions[13] = new Point(5550, GROUNDLEVEL);
-
- enemyPositions[0] = new Point(-400, BANZAIHEIGHT);
- enemyType[0] = BANZAI;
-
- break;
-
- // -----------------------------------------------
- // LEVEL 7
- // -----------------------------------------------
- case 7:
-
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- if (i == 1 || i == 2 || i == 8) {
- isTall[i] = true;
- } else {
- if (i == 0 || i == 3 || i == 5 || i == 7 || i == 9 || i == 10 || i == 11) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- }
- }
- }
- obstaclePositions[0] = new Point(250, GROUNDLEVEL);
- obstaclePositions[1] = new Point(350, GROUNDLEVEL);
- obstaclePositions[2] = new Point(450, GROUNDLEVEL);
- obstaclePositions[3] = new Point(550, GROUNDLEVEL);
- obstaclePositions[4] = new Point(800, GROUNDLEVEL);
- obstaclePositions[5] = new Point(1000, GROUNDLEVEL);
- obstaclePositions[6] = new Point(1200, GROUNDLEVEL);
- obstaclePositions[7] = new Point(1400, GROUNDLEVEL);
- obstaclePositions[8] = new Point(1800, GROUNDLEVEL);
- obstaclePositions[9] = new Point(2400, GROUNDLEVEL);
- obstaclePositions[10] = new Point(2550, GROUNDLEVEL);
- obstaclePositions[11] = new Point(2700, GROUNDLEVEL);
- obstaclePositions[12] = new Point(3100, GROUNDLEVEL);
- obstaclePositions[13] = new Point(3600, GROUNDLEVEL);
-
- enemyType = new int[] { GOOMBA, GOOMBA, GOOMBA, GOOMBA, GOOMBA, WIGGLER };
- enemyPositions[0] = new Point(900, GOOMBAHEIGHT);
- enemyPositions[1] = new Point(1100, GOOMBAHEIGHT);
- enemyPositions[2] = new Point(1300, GOOMBAHEIGHT);
- enemyPositions[3] = new Point(1600, GOOMBAHEIGHT);
- enemyPositions[4] = new Point(2000, GOOMBAHEIGHT);
- enemyPositions[5] = new Point(3250, WIGGLERHEIGHT);
- break;
- // -----------------------------------------------
- // LEVEL 8
- // -----------------------------------------------
- case 8:
-
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- if (i == 2 || i == 3 || i == 4 || i == 6 || i == 8 || i == 11) {
- isTall[i] = true;
- } else {
- if (i == 0 || i == 1 || i == 10 || i == 12 || i == 13) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- }
- }
- }
-
- obstaclePositions[0] = new Point(100, GROUNDLEVEL);
- obstaclePositions[1] = new Point(650, GROUNDLEVEL);
- obstaclePositions[2] = new Point(1000, GROUNDLEVEL);
- obstaclePositions[3] = new Point(1075, GROUNDLEVEL);
- obstaclePositions[4] = new Point(1150, GROUNDLEVEL);
- obstaclePositions[5] = new Point(1500, GROUNDLEVEL);
- obstaclePositions[6] = new Point(1575, GROUNDLEVEL);
- obstaclePositions[7] = new Point(1650, GROUNDLEVEL);
- obstaclePositions[8] = new Point(1725, GROUNDLEVEL);
- obstaclePositions[9] = new Point(1800, GROUNDLEVEL);
- obstaclePositions[10] = new Point(2500, GROUNDLEVEL);
- obstaclePositions[11] = new Point(3400, GROUNDLEVEL);
- obstaclePositions[12] = new Point(4000, GROUNDLEVEL);
- obstaclePositions[13] = new Point(4075, GROUNDLEVEL);
- obstaclePositions[14] = new Point(5275, GROUNDLEVEL);
- obstaclePositions[15] = new Point(5775, GROUNDLEVEL);
-
- enemyType = new int[] { BOO, FIREBOO, GOOMBA, BOO, GOOMBA, FIREBOO, GOOMBA, GOOMBA, BOBOMB };
-
- enemyPositions[0] = new Point(350, BOOHEIGHT);
- enemyPositions[1] = new Point(900, FIREBOOHEIGHT);
- enemyPositions[2] = new Point(1200, GOOMBAHEIGHT);
- enemyPositions[3] = new Point(1900, BOOHEIGHT);
- enemyPositions[4] = new Point(2600, GOOMBAHEIGHT);
- enemyPositions[5] = new Point(3500, FIREBOOHEIGHT);
- enemyPositions[6] = new Point(4175, GOOMBAHEIGHT);
- enemyPositions[7] = new Point(4250, GOOMBAHEIGHT);
- enemyPositions[8] = new Point(5375, BOBOMBHEIGHT);
- break;
- case 9:
- enemyType = new int[] { FLYER, GOOMBA, GOOMBA, KOOPAREDFLYING, KOOPAREDFLYING, KOOPAREDFLYING,
- KOOPAREDFLYING, KOOPAREDFLYING, CHOMP };
-
- enemyPositions[0] = new Point(400, FLYERHEIGHT);
- enemyPositions[1] = new Point(950, GOOMBAHEIGHT);
- enemyPositions[2] = new Point(1000, GOOMBAHEIGHT);
- enemyPositions[3] = new Point(1300, KOOPAREDFLYINGHEIGHT - 10);
- enemyPositions[4] = new Point(1500, KOOPAREDFLYINGHEIGHT - 10);
- enemyPositions[5] = new Point(1700, KOOPAREDFLYINGHEIGHT - 10);
- enemyPositions[6] = new Point(1900, KOOPAREDFLYINGHEIGHT - 10);
- enemyPositions[7] = new Point(2100, KOOPAREDFLYINGHEIGHT - 10);
- enemyPositions[8] = new Point(2850, CHOMPHEIGHT);
-
- for (int i = 0; i < obstacleNumber; i++) {
-
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- if (i == 0 || i == 3 || i == 5) {
- isTall[i] = true;
- } else {
- if (i == 1 || i == 2 || i == 4) {
- piranhaPopping[i] = true;
- hasPiranha[i] = true;
- }
- }
- }
-
- obstaclePositions[0] = new Point(200, GROUNDLEVEL);
- obstaclePositions[1] = new Point(900, GROUNDLEVEL);
- obstaclePositions[2] = new Point(1100, GROUNDLEVEL);
- obstaclePositions[3] = new Point(2400, GROUNDLEVEL);
- obstaclePositions[4] = new Point(2550, GROUNDLEVEL);
- obstaclePositions[5] = new Point(2700, GROUNDLEVEL);
-
- default:
-
- }
-
- for (int j = 0; j < enemyNumber; j++) {
- enemyFaceRight(j);
- enemyDead[j] = false;
- }
-
- for (int i = 0; i < obstacleNumber; i++) {
- if (hasPiranha[i]) { // pick a random image number between 0 and 18 (inclusive)
- obstacleImageNo[i] = (int) (Math.random() * 18) / 1;
- } else
- obstacleImageNo[i] = 0;
- }
-
- // position the warp zone at the end of the level
- warpzone = new Point(levellength, GROUNDLEVEL);
- // *********** END OF STUFF THAT DEPENDS WHAT LEVEL YOU ARE ON ************
-
- ingame = true;
- System.out.println("Started level " + level);
- }
-
- boolean isPlayerPosition(Point p) {
- return (p.x == playerPosition.x && p.y == playerPosition.y);
- }
-
- int isEnemyPosition(Point p) {
- for (int i = 0; i < enemyNumber; i++) {
- if (isEnemyX(p) != -1 && isEnemyY(p) != -1 && !enemyDead[i])
- return (i);
- }
- return (-1);
- }
-
- boolean isObstaclePosition(Point p, boolean forMario) {
- int obby;
- for (int i = 0; i < obstacleNumber; i++) {
- obby = isObstacleX(p, forMario);
- if (obby != -1 && isObstacleY(p, obby, forMario) != -1) {
- return (true);
- }
- }
- return (false);
- }
-
- boolean checkIfBlockingObstacle(Point p) {
- boolean result = false;
- int obby;
- obby = isObstacleX(p, true);
- if (obby != -1 && isBlockingObstacleY(p, obby)) {
- piranhaPopping[obby] = false;
- result = true;
- }
- for (int i = 0; i < obstacleNumber; i++) {
- if (i != obby || !result) {
- if (hasPiranha[i])
- piranhaPopping[i] = true;
- }
- }
- if (!result)
- startPosY = GROUNDLEVEL;
- return (result);
- }
-
- int isObstacleX(Point p, boolean forMario) {
- int obstaclex;
- for (int i = 0; i < obstacleNumber; i++) {
- // if x is >= obstacleposition - (MARIOLEFTOFOBSTACLE) and x <= obstacleposition
- // + (MARIORIGHTOFOBSTACLE)
- obstaclex = obstaclePositions[i].x;
- if (forMario) {
- if (p.x >= (obstaclex - MARIOLEFTOFOBSTACLE) && p.x <= (obstaclex + MARIORIGHTOFOBSTACLE))
- return (i); // return the number of the matching obstacle
- } else {
- if (p.x >= (obstaclex - ENEMYLEFTOFOBSTACLE) && p.x <= (obstaclex + ENEMYRIGHTOFOBSTACLE))
- return (i); // return the number of the matching obstacle
- }
- }
- return (-1);
- }
-
- boolean isBlockingObstacleY(Point p, int obstaclenumber) {
- if (isTall[obstaclenumber]) {
- if (p.y <= obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
- // System.out.println(s+": Yes");
- return (true);
- }
- } else {
- if (p.y <= obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
- // System.out.println(s+": Yes");
- return (true);
- }
- }
- // System.out.println(s+": No");
- return (false);
- }
-
- int isObstacleY(Point p, int obstaclenumber, boolean forMario) {
- if (isTall[obstaclenumber]) {
- if (p.y > obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
- return (obstaclenumber);
- }
- } else {
- if (p.y > obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
- return (obstaclenumber);
- }
- }
- return (-1);
- }
-
- int isEnemyX(Point p) {
- int enemyx;
- for (int i = 0; i < enemyNumber; i++) {
- // if x is >= enemyposition - (LEFTOFENEMY) and x <= enemyposition +
- // (RIGHTOFENEMY)
- enemyx = enemyPositions[i].x;
- // System.out.println("Player got by enemy if " +
- // p.x + " >= " + (enemyx - MARIOLEFTOFENEMY) + " && " + p.x + " <= " + (enemyx
- // + MARIORIGHTOFENEMY));
- if (p.x >= (enemyx - MARIOLEFTOFENEMY) && p.x <= (enemyx + MARIORIGHTOFENEMY) && !enemyDead[i])
- return (i); // return the number of the matching enemy
- }
- return (-1);
- }
-
- int isEnemyY(Point p) {
- int offset = herocrouching ? MARIOCROUCHOFFSET : MARIOOFFSET;
- for (int i = 0; i < enemyNumber; i++) {
- if (!enemyDead[i] && ((p.y + offset <= enemyPositions[i].y + enemySize[enemyType[i]])
- && (p.y + MARIOHEIGHT) >= enemyPositions[i].y))
- return (i);
- }
- return (-1);
- }
-
- public void finished() {
- finished = true;
- System.exit(0);
- }
-
- public String getAppletInfo() {
- return ("Mario Game");
- }
-
- int randomMove() {
- // return + or - value (randomly)
- if (Math.random() >= 0.5)
- return (24);
- else
- return (-24);
- }
-
- private synchronized void incKeysDown(int whichone) {
- keysdown[whichone] = 1;
- }
-
- private synchronized void decKeysDown(int whichone) {
- keysdown[whichone] = 0;
- }
-
- // this class will use just the key pressed event
- public void keyPressed(KeyEvent e) {
- if (e.getKeyCode() == KeyEvent.VK_F1) {
- displayStatus();
- }
- if (ingame) {
- if (!(e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))) {
-
- // valid move: move the player and then move the enemies
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- herocrouching = true;
- incKeysDown(DOWNDOWN);
- setSomethingChangedSinceRepaint(true);
- } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- incKeysDown(LEFTDOWN);
- leftPressed(false);
- setSomethingChangedSinceRepaint(true);
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- incKeysDown(RIGHTDOWN);
- rightPressed(false);
- setSomethingChangedSinceRepaint(true);
- } else if (e.getKeyCode() == KeyEvent.VK_SPACE) {
- if (!jumping) {
- startPosY = playerPosition.y;
- jumping = true;
- onTheWayUp = true;
- setSomethingChangedSinceRepaint(true);
- }
- }
- if (somethingChangedSinceRepaint) {
- area.repaint();
- }
- } // if valid key press
- } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
- if (level == MAXLEVEL || dead)
- doLevel(level);
- else
- doLevel(++level);
- page = 0;
- area.repaint();
- }
- }
-
- /* synchronized */ void setSomethingChangedSinceRepaint(boolean val) {
- somethingChangedSinceRepaint = val;
- }
-
- void leftPressed(boolean skid) {
- if (!herocrouching) {
- // if Hero was facing right, turn him left
- if (!heroleft)
- faceLeft();
- else {
- // if the target position is not occupied by a obstacle...
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstaclePosition(new Point(playerPosition.x - XAMOUNT, playerPosition.y), true))
- return; // can't move
- }
- playerPosition.x -= XAMOUNT;
- if (!skid)
- incrementHeroImage();
- }
- }
- }
-
- void rightPressed(boolean skid) {
- if (!herocrouching) {
- if ((playerPosition.x + SPACE_FROM_X_TO_MARIO) >= (warpzone.x + 4)) {
- // level complete!
- ingame = false;
- } else {
- // if Hero was facing left, turn him right
- if (heroleft)
- faceRight();
- else {
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstaclePosition(new Point(playerPosition.x + XAMOUNT, playerPosition.y), true))
- return; // can't move
- }
- playerPosition.x += XAMOUNT;
- // System.out.println("Mario's x position is " + playerPosition.x);
- if (!skid)
- incrementHeroImage();
- }
- }
- }
- }
-
- boolean anythingVisibleChanged() {
- return (somethingChangedSinceRepaint);
- }
-
- public void run() {
- boolean odd = true; // only change piranha image every other cycle
- while (true) {
- if (juststarted) {
- try {
- Thread.sleep(750);
- } catch (Exception e) {
- }
- area.repaint();
- juststarted = false;
- }
- try {
- Thread.sleep(DELAY);
- } catch (InterruptedException e) {
- }
- if (ingame) {
- if (keysdown[LEFTDOWN] == 0 && keysdown[RIGHTDOWN] == 0 && keysdown[DOWNDOWN] == 0)
- standStill();
-
- if (keysdown[LEFTDOWN] > 0) {
- leftPressed(false);
- setSomethingChangedSinceRepaint(true);
- } else if (keysdown[RIGHTDOWN] > 0) {
- rightPressed(false);
- setSomethingChangedSinceRepaint(true);
- }
-
- if (!odd) {
- // for each obstacle, cycle through the piranha pictures
- for (int i = 0; i < obstacleNumber; i++) {
- if (piranhaPopping[i]) {
- incrementObstacleImage(i);
- if (isVisibleObstacle(i))
- setSomethingChangedSinceRepaint(true);
- }
- }
- }
- odd = !odd;
-
- // for each enemy, move the enemy in the direction it was going
- for (int i = 0; i < enemyNumber; i++) {
- // TODO if there is a fatal obstacle at that position, fall into it and
- // decrement count of enemies
- // and set that enemy's position to -1, -1
- /*
- * if (isObstaclePosition(enemyPositions[i])) {
- * System.out.Println("A enemy fell into a obstacle");
- *
- * enemyPositions[i] = new Point(-1, -1); enemiesRemaining--;
- * System.out.Println(enemyNumber-enemiesRemaining + " down, " +
- * enemiesRemaining + " to go..."); }
- */
- // if there is a non-fatal obstacle
- if (isObstaclePosition(enemyPositions[i], false) && enemyType[i] != BANZAI) {
- // change direction
- changeDirection(i);
- if (isVisibleEnemy(i))
- setSomethingChangedSinceRepaint(true);
- }
- if (!enemyDead[i]) {
- enemyPositions[i] = move(i, enemyPositions[i], enemyDirection[i], odd);
- if (isVisibleEnemy(i))
- setSomethingChangedSinceRepaint(true);
- }
-
- // if player is caught by a enemy, end the game
- int enemyno = isEnemyPosition(playerPosition);
- if (enemyno > -1) {
- int NEEDTOBEABOVE = enemyPositions[enemyno].y + enemyTopSpace[enemyno] - MARIOHEIGHT;
- if (easymode)
- NEEDTOBEABOVE = enemyPositions[enemyno].y - enemyHeight[enemyType[enemyno]];
- if ((!onTheWayUp && (playerPosition.y <= NEEDTOBEABOVE)) && enemyType[enemyno] != BANZAI) {
- // player may have squished an enemy
- if (enemyType[enemyno] == KOOPAREDFLYING) {
- enemyType[enemyno] = KOOPARED;
- enemyPositions[enemyno].y = KOOPAREDHEIGHT;
- if (enemyDirection[enemyno] == LEFT)
- enemyFaceLeft(enemyno);
- else
- enemyFaceRight(enemyno);
- } else {
- enemyDead[enemyno] = true;
- enemyDie(enemyno);
- }
- // player bounces
- bouncing = true;
- startPosY = playerPosition.y;
- setSomethingChangedSinceRepaint(true);
- } else {
- int offset = herocrouching ? MARIOCROUCHOFFSET : MARIOOFFSET;
- if (playerPosition.y > NEEDTOBEABOVE && (playerPosition.y
- + offset <= enemyPositions[enemyno].y + enemySize[enemyType[enemyno]])) {
- die();
- setSomethingChangedSinceRepaint(true);
- }
- }
- }
- }
- if (!dead) {
- if (onTheWayUp) {
- if (playerPosition.y > startPosY - JUMPAMOUNT) {
- playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
- setSomethingChangedSinceRepaint(true);
- } else {
- onTheWayUp = false;
- }
- } else if (bouncing) {
- if (playerPosition.y > startPosY - BOUNCEAMOUNT) {
- playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
- setSomethingChangedSinceRepaint(true);
- } else {
- bouncing = false;
- wasbouncing = true;
- }
- } else {
- int obstacleno = isObstacleX(playerPosition, true);
- if (obstacleno == -1) { // no obstacle at this position
- if (!onTheWayUp && !bouncing) {
- if (playerPosition.y < startPosY) {
- playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
- if (playerPosition.y >= GROUNDLEVEL && floorIsIcy()) {
- if (!wasbouncing) {
- if (heroleft)
- skidLeft();
- else
- skidRight();
- }
- }
- wasbouncing = false;
- setSomethingChangedSinceRepaint(true);
- } else
- jumping = false;
- }
- } else {
- Point obstaclepos = obstaclePositions[obstacleno];
- // if hero's y position <= obstacle's height
- int thisObstacleHeight = isTall[obstacleno] ? OBSTACLEHEIGHT + TALLOBSTACLEDIFF
- : OBSTACLEHEIGHT;
- if (playerPosition.y <= (obstaclepos.y - thisObstacleHeight) && // can't land on the
- // obstacle if just < (??!)
- (playerPosition.y + FALLAMOUNT >= (obstaclepos.y - thisObstacleHeight))) {
- // allow hero to land on the obstacle
- jumping = false;
- if (playerPosition.y != obstaclepos.y - thisObstacleHeight)
- setSomethingChangedSinceRepaint(true);
- playerPosition = new Point(playerPosition.x, obstaclepos.y - thisObstacleHeight);
- // if the piranha was up, Hero dies
- if (obstacleImages[obstacleImageNo[obstacleno]] != area.obstacle) {
- die();
- } else {
- // otherwise stop this Piranha
- piranhaPopping[obstacleno] = false;
- }
- } else {
- if (!onTheWayUp && !bouncing) {
- if (playerPosition.y < startPosY) {
- setSomethingChangedSinceRepaint(true);
- playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
- if (playerPosition.y >= GROUNDLEVEL && floorIsIcy()) {
- if (!wasbouncing) {
- if (heroleft)
- skidLeft();
- else
- skidRight();
- }
- }
- wasbouncing = false;
- } else
- jumping = false;
- }
- }
- }
- }
- if (!dead) {
- checkIfBlockingObstacle(playerPosition);
- if (playerPosition.y > GROUNDLEVEL)
- playerPosition.y = GROUNDLEVEL;
- }
- if (anythingVisibleChanged()) {
- area.repaint();
- }
- } else {
- if (!area.showingMessage)
- area.repaint();
- }
- }
- }
- }
-
- boolean isVisibleObstacle(int i) {
- // TODO - this probably needs fixing when obstacle is near page boundary
- return ((obstaclePositions[i].x >= page * PAGEWIDTH) && (obstaclePositions[i].x < (page + 1) * PAGEWIDTH));
- }
-
- boolean isVisibleEnemy(int i) {
- // TODO - this probably needs fixing when enemy is near page boundary
- return ((enemyPositions[i].x >= page * PAGEWIDTH) && (enemyPositions[i].x < (page + 1) * PAGEWIDTH)
- && !enemyDead[i]);
- }
-
- void changeDirection(int enemyno) {
- if (enemyDirection[enemyno] == LEFT) {
- enemyFaceRight(enemyno);
- } else {
- enemyFaceLeft(enemyno);
- }
- }
-
- synchronized void die() {
- System.out.println("The Player is dead. Press the Enter key to restart the level");
- ingame = false;
- dead = true;
- displayStatus();
- }
-
- synchronized void incrementObstacleImage(int i) {
- obstacleImageNo[i]++;
- if (obstacleImageNo[i] == OBSTACLEIMAGES)
- obstacleImageNo[i] = 0;
- }
-
- synchronized void incrementHeroImage() {
- heroImageNo++;
- if (heroImageNo == HEROIMAGES)
- heroImageNo = 0;
- }
-
- synchronized void incrementEnemyImage(int i) {
- enemyImageNo[i]++;
- if (enemyType[i] == WIGGLER) {
- if (enemyImageNo[i] > (ENEMYIMAGES - 1))
- enemyImageNo[i] = 0;
- } else {
- if (enemyImageNo[i] > (ENEMYIMAGES - 2))
- enemyImageNo[i] = 0;
- }
- }
-
- Point move(int enemyNo, Point start, int direction, boolean odd) {
- if (odd)
- incrementEnemyImage(enemyNo);
- if (direction == LEFT) {
- return (new Point(start.x - enemyMove[enemyType[enemyNo]], start.y));
- } else {
- return (new Point(start.x + enemyMove[enemyType[enemyNo]], start.y));
- }
- }
-
- public void keyReleased(KeyEvent e) {
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- herocrouching = false;
- decKeysDown(DOWNDOWN);
- } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- if (floorIsIcy()) {
- skidLeft();
- }
- decKeysDown(LEFTDOWN);
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- if (floorIsIcy()) {
- skidRight();
- }
- decKeysDown(RIGHTDOWN);
- }
- }
-
- public void keyTyped(KeyEvent e) {
- }
-
- synchronized Image getHeroImage() {
- return (heroImages[heroImageNo]);
- }
-
- synchronized Image getObstacleImage(int obstaclenum) {
- return (obstacleImages[obstacleImageNo[obstaclenum]]);
- }
-
- synchronized Image getEnemyImage(int enemyno) {
- return (enemyImage[enemyno][enemyImageNo[enemyno]]);
- }
-
- boolean floorIsIcy() {
- return (floors[level - 1] == area.icefloor);
- }
-
- void skidLeft() {
- for (int i = 0; i < 6; i++) {
- leftPressed(true);
- try {
- Thread.sleep(7);
- } catch (Exception e) {
- }
- area.repaint();
- }
- }
-
- void skidRight() {
- for (int i = 0; i < 6; i++) {
- rightPressed(true);
- area.repaint();
- try {
- Thread.sleep(7);
- } catch (Exception e) {
- }
- }
- }
-
- void displayStatus() {
- /*
- * // when a certain F Key is pressed, display positions of Mario, // all pipes
- * and all enemies and the end flag (warp zone) System.out.println("--------");
- * System.out.println("Mario is " + (dead? "dead" : "alive")); if (dead) { int
- * enemyno = isEnemyPosition(playerPosition);
- * System.out.println("Mario was killed by enemy " + enemyno); }
- * System.out.println("In game is " + ingame); System.out.println("Mario is " +
- * (onTheWayUp? "on the way up" : "not on the way up"));
- * System.out.println("Mario's position is (" + playerPosition.x + ", " +
- * playerPosition.y + ")");
- * System.out.println("Mario's visible left, bottom co-ordinates are " +
- * (playerPosition.x + 55) + " and " + (playerPosition.y + MARIOHEIGHT));
- * System.out.println("Mario is on page " + page +
- * " (which shows x positions from " + (page*PAGEWIDTH) + " to " +
- * ((page+1)*PAGEWIDTH) + ")"); System.out.println("Screen bounds are (" +
- * getBounds().width + ", " + getBounds().height + ")"); System.out.println("");
- * for (int enemy=0; enemy < enemyNumber; enemy++) { System.out.println("Enemy "
- * + enemy + " is " + enemyTypeString(enemyType[enemy]) + " and is " +
- * (enemyDead[enemy] ? " " : "not ") + "dead"); System.out.println("Enemy " +
- * enemy + " is at position (" + enemyPositions[enemy].x + ", " +
- * enemyPositions[enemy].y+") and has size " + enemySize[enemyType[enemy]]); }
- * //System.out.println(""); //for (int obstacle=0; obstacle < obstacleNumber;
- * obstacle++) { // System.out.println("Obstacle " + obstacle +
- * " is at position (" + obstaclePositions[obstacle].x + // ", " +
- * obstaclePositions[obstacle].y+")"); //} System.out.println("");
- * System.out.println("The warp zone is positioned at (" + warpzone.x + ", " +
- * warpzone.y + ")"); System.out.println("========");
- */
- }
-
- String enemyTypeString(int fortype) {
- switch (fortype) {
- case GOOMBA:
- return ("GOOMBA");
- case KOOPARED:
- return ("KOOPA RED");
- case KOOPAGREEN:
- return ("KOOPA GREEN");
- case KOOPAREDFLYING:
- return ("KOOPA RED FLYING");
- case BANZAI:
- return ("BANZAI");
- case WIGGLER:
- return ("WIGGLER");
- case BOO:
- return ("BOO");
- case FIREBOO:
- return ("FOREBOO");
- case BOBOMB:
- return ("BOBOMB");
- case BULLET:
- return ("BULLET");
- case WARSHIP:
- return ("WARSHIP");
- case YETI:
- return ("YETI");
- case FLYER:
- return ("FLYER");
- default:
- return ("Unknown type (" + fortype + ")");
- }
- }
-
- void changePageIfNecessary() {
- if (playerPosition.x == LEFTEDGE)
- return;
- if ((playerPosition.x + SPACE_FROM_X_TO_MARIO) > (page * PAGEWIDTH + RIGHTEDGE - XAMOUNT)) {
- // System.out.println("Change page up: (" + playerPosition.x+ "+" +
- // SPACE_FROM_X_TO_MARIO+ ") > (" + page+ "*" + PAGEWIDTH + "+" + RIGHTEDGE +
- // "-" + XAMOUNT + ")");
- page++;
- } else if ((playerPosition.x + SPACE_FROM_X_TO_MARIO) - (page * PAGEWIDTH) < (LEFTEDGE + XAMOUNT)) {
- // System.out.println("Change page down: (" + playerPosition.x+ "+" +
- // SPACE_FROM_X_TO_MARIO+ ")-(" + page+ "*" + PAGEWIDTH + ") < (" + LEFTEDGE+
- // "+" + XAMOUNT+")");
- page--;
- }
- }
-}
diff --git a/Pong/src/Pong.java b/Pong/src/Pong.java
@@ -0,0 +1,246 @@
+
+/* Copyright (c) Mike Percival 2004 */
+/* Pong game Created April 2004 */
+
+import java.awt.Color;
+import java.awt.Point;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.JFrame;
+
+public class Pong extends JFrame implements KeyListener, Runnable {
+ private static final long serialVersionUID = 1018529427970832700L;
+ // all member variables 'static' because shared with the ball action thread
+ private static PongArea area;
+ private static boolean ingame = false;
+ private boolean juststarted = false;
+ private static int level = 1;
+ protected static Point[] ballPositions;
+ protected static Point playerPosition;
+ private static Thread balls;
+
+ protected static int ballNumber = 1;
+ protected static int RIGHTEDGE = 800;
+ protected static final int LEFTEDGE = 0;
+ protected static final int TOPEDGE = 0;
+ protected static int BOTTOMEDGE = 800;
+ protected static int BALL_XAMOUNT = 3;
+ protected static int BALL_YAMOUNT = 3;
+ protected static int PLAYER_XAMOUNT = 12;
+ protected static int PLAYER_YAMOUNT = 12;
+ private static final int DELAY = 15;
+ boolean[] goingLeft, goingRight, goingUp, goingDown;
+ boolean deadball = false;
+ int timeSinceLastBall = 0;
+
+ public static void main(String[] args) {
+ Pong Pong = new Pong();
+
+ Pong.setLayout(null);
+ Pong.setBackground(Color.black);
+ Pong.setSize(RIGHTEDGE, BOTTOMEDGE);
+ Pong.area = new PongArea(Pong);
+ Pong.add(area);
+ //RIGHTEDGE = Pong.getBounds().width - 1;
+ //BOTTOMEDGE = Pong.getBounds().height - 1;
+ Pong.setVisible(true);
+ area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
+ area.setVisible(true);
+
+ Pong.addKeyListener(Pong);
+ area.addKeyListener(Pong);
+ area.requestFocus();
+
+ balls = new Thread(Pong);
+ balls.start();
+
+ //EventQueue.invokeLater(Pong);
+ }
+
+ public void doLevel(int level) {
+ // this runs one 'level'
+ // create arrays of ball balls here.
+ // Maybe each level will have different numbers?
+ juststarted = true;
+ deadball = false;
+ ballNumber = 1;
+ ballPositions = new Point[ballNumber];
+ goingLeft = new boolean[ballNumber];
+ goingRight = new boolean[ballNumber];
+ goingUp = new boolean[ballNumber];
+ goingDown = new boolean[ballNumber];
+
+ for (int i = 0; i < ballNumber; i++) {
+ ballPositions[i] = new Point(0, 0);
+ goingLeft[i] = true;
+ goingRight[i] = false;
+ goingUp[i] = false;
+ goingDown[i] = true;
+ }
+
+ // System.out.println("Started level " + level);
+
+ // randomly position 1 player, x balls
+ playerPosition = new Point(RIGHTEDGE - 20, 0);
+
+ for (int i = 0; i < ballNumber; i++) {
+ ballPositions[i] = randomPosition();
+ }
+
+ // paint the panel here
+ area.repaint();
+ ingame = true;
+ }
+
+ private Point randomPosition() {
+ Point p = new Point((int) (Math.random() * RIGHTEDGE) / BALL_XAMOUNT * BALL_XAMOUNT, (int) 0);
+ if (p.x >= RIGHTEDGE * 2 / 3)
+ p.x = p.x - RIGHTEDGE / 3;
+
+ return (p);
+ }
+
+ synchronized void addABall() {
+ System.out.println("ADD A BALL!");
+ Point[] newBallPos = new Point[ballNumber + 1];
+ boolean[] newgl = new boolean[ballNumber + 1], newgr = new boolean[ballNumber + 1],
+ newgu = new boolean[ballNumber + 1], newgd = new boolean[ballNumber + 1];
+
+ for (int i = 0; i < ballNumber; i++) {
+ newBallPos[i] = new Point(ballPositions[i]);
+ newgl[i] = goingLeft[i];
+ newgr[i] = goingRight[i];
+ newgu[i] = goingUp[i];
+ newgd[i] = goingDown[i];
+ }
+
+ newBallPos[ballNumber] = randomPosition();
+ newgl[ballNumber] = true;
+ newgr[ballNumber] = false;
+ newgu[ballNumber] = false;
+ newgu[ballNumber] = true;
+ ballPositions = newBallPos;
+ goingLeft = newgl;
+ goingRight = newgr;
+ goingUp = newgu;
+ goingDown = newgd;
+ ballNumber++;
+ }
+
+ void seeIfBallHitWallFloorOrCeiling(int ballno) {
+ if (ballPositions[ballno].x <= 0) { // ball hit the left wall
+ goingRight[ballno] = true;
+ goingLeft[ballno] = false;
+ } else if (ballPositions[ballno].y <= 0) {// ball hit the ceiling
+ goingUp[ballno] = false;
+ goingDown[ballno] = true;
+ } else if (ballPositions[ballno].y >= BOTTOMEDGE - BALL_YAMOUNT) {// ball hit the floor
+ goingDown[ballno] = false;
+ goingUp[ballno] = true;
+ } else if (ballPositions[ballno].x >= RIGHTEDGE) { // ball reached the right edge
+ deadball = true;
+ level--; // because it will be incremented in a minute and we want to stay on the same
+ // 'level'
+ ingame = false;
+ System.out.println("LOZER!");
+ }
+ }
+
+ private boolean isPlayerPosition(Point p) {
+ return (p.x >= playerPosition.x && p.y >= playerPosition.y && p.y <= playerPosition.y + 154);
+ }
+
+ private Point moveBall(int ballno, Point original) {
+ Point result = new Point(original);
+ if (goingLeft[ballno])
+ result.x = result.x - BALL_XAMOUNT;
+ else if (goingRight[ballno])
+ result.x = result.x + BALL_XAMOUNT;
+
+ if (goingUp[ballno])
+ result.y = result.y - BALL_YAMOUNT;
+ else if (goingDown[ballno])
+ result.y = result.y + BALL_YAMOUNT;
+ if (isPlayerPosition(result)) {
+ goingRight[ballno] = false;
+ goingLeft[ballno] = true;
+ } else
+ seeIfBallHitWallFloorOrCeiling(ballno);
+
+ return (result);
+ }
+
+ // this class will use just the key pressed event
+ @Override
+ public void keyPressed(KeyEvent e) {
+ if (ingame) {
+ if (!((e.getKeyCode() == KeyEvent.VK_DOWN && playerPosition.y >= (BOTTOMEDGE - PLAYER_YAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_UP && playerPosition.y <= (TOPEDGE + PLAYER_YAMOUNT)))) {
+ // valid move: move the player and then move the balls
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ playerPosition.y += PLAYER_YAMOUNT;
+ } else if (e.getKeyCode() == KeyEvent.VK_UP) {
+ playerPosition.y -= PLAYER_YAMOUNT;
+ }
+
+ for (int i = 0; i < ballNumber; i++) {
+ if (isPlayerPosition(ballPositions[i])) {
+ goingRight[i] = false;
+ goingLeft[i] = true;
+ }
+ }
+ area.repaint();
+ } // if valid key press
+ } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+ doLevel(level++);
+ }
+ }
+
+ @Override
+ public void run() {
+ while (true) {
+ if (juststarted) {
+ try {
+ Thread.sleep(750);
+ } catch (Exception e) {
+ }
+ juststarted = false;
+ }
+
+ try {
+ Thread.sleep(DELAY);
+ } catch (InterruptedException e) {
+ }
+
+ if (ingame) {
+ timeSinceLastBall += DELAY;
+ // System.out.println(String.valueOf(timeSinceLastBall));
+ if (timeSinceLastBall >= 10000) {
+ addABall();
+ timeSinceLastBall = 0;
+ }
+
+ // for each ball, move the ball closer to the player
+ for (int i = 0; i < ballPositions.length; i++) {
+ if (!deadball) {
+ ballPositions[i] = moveBall(i, ballPositions[i]);
+ }
+ if (isPlayerPosition(ballPositions[i])) {
+ goingRight[i] = false;
+ goingLeft[i] = true;
+ }
+ }
+ area.repaint();
+ }
+ }
+ }
+
+ @Override
+ public void keyReleased(KeyEvent e) {
+ }
+
+ @Override
+ public void keyTyped(KeyEvent e) {
+ }
+}
diff --git a/Pong/src/PongArea.java b/Pong/src/PongArea.java
@@ -13,12 +13,12 @@ import javax.swing.JPanel;
public class PongArea extends JPanel implements ActionListener {
private static final long serialVersionUID = -842988339431434549L;
- PongGame myApplet = null;
+ Pong myApplet = null;
Image paddle;
Color[] colours = new Color[] { Color.white, Color.blue, Color.green, Color.red, Color.yellow };
int colourno = 0;
- public PongArea(PongGame parent) {
+ public PongArea(Pong parent) {
myApplet = parent;
try {
paddle = ImageIO.read(new File("../Assets/paddle.gif"));
@@ -40,22 +40,22 @@ public class PongArea extends JPanel implements ActionListener {
g.fillRect(0, 0, w, h);
g.setColor(Color.black);
- if (PongGame.playerPosition != null) {
+ if (Pong.playerPosition != null) {
// show the player's paddle
// g.drawString("|", myApplet.playerPosition.x, myApplet.playerPosition.y);
- g.drawImage(paddle, PongGame.playerPosition.x, PongGame.playerPosition.y, Color.black, null);
+ g.drawImage(paddle, Pong.playerPosition.x, Pong.playerPosition.y, Color.black, null);
// show the ball
colourno = 0;// <-------remove this for confusion mode!
- for (int i = 0; i < PongGame.ballPositions.length; i++) {
- if (PongGame.ballPositions[i].x > -1)
+ for (int i = 0; i < Pong.ballPositions.length; i++) {
+ if (Pong.ballPositions[i].x > -1)
// g.drawImage(pongImage, myApplet.ballPositions[i].x,
// myApplet.ballPositions[i].y,null);
g.setColor(colours[colourno++]);
if (colourno >= colours.length)
colourno = 0;
- g.drawString("O", PongGame.ballPositions[i].x, PongGame.ballPositions[i].y);
+ g.drawString("O", Pong.ballPositions[i].x, Pong.ballPositions[i].y);
}
}
}
diff --git a/Pong/src/PongGame.java b/Pong/src/PongGame.java
@@ -1,246 +0,0 @@
-
-/* Copyright (c) Mike Percival 2004 */
-/* Pong game Created April 2004 */
-
-import java.awt.Color;
-import java.awt.Point;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-
-import javax.swing.JFrame;
-
-public class PongGame extends JFrame implements KeyListener, Runnable {
- private static final long serialVersionUID = 1018529427970832700L;
- // all member variables 'static' because shared with the ball action thread
- private static PongArea area;
- private static boolean ingame = false;
- private boolean juststarted = false;
- private static int level = 1;
- protected static Point[] ballPositions;
- protected static Point playerPosition;
- private static Thread balls;
-
- protected static int ballNumber = 1;
- protected static int RIGHTEDGE = 800;
- protected static final int LEFTEDGE = 0;
- protected static final int TOPEDGE = 0;
- protected static int BOTTOMEDGE = 800;
- protected static int BALL_XAMOUNT = 3;
- protected static int BALL_YAMOUNT = 3;
- protected static int PLAYER_XAMOUNT = 12;
- protected static int PLAYER_YAMOUNT = 12;
- private static final int DELAY = 15;
- boolean[] goingLeft, goingRight, goingUp, goingDown;
- boolean deadball = false;
- int timeSinceLastBall = 0;
-
- public static void main(String[] args) {
- PongGame pongGame = new PongGame();
-
- pongGame.setLayout(null);
- pongGame.setBackground(Color.black);
- pongGame.setSize(RIGHTEDGE, BOTTOMEDGE);
- PongGame.area = new PongArea(pongGame);
- pongGame.add(area);
- //RIGHTEDGE = pongGame.getBounds().width - 1;
- //BOTTOMEDGE = pongGame.getBounds().height - 1;
- pongGame.setVisible(true);
- area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
- area.setVisible(true);
-
- pongGame.addKeyListener(pongGame);
- area.addKeyListener(pongGame);
- area.requestFocus();
-
- balls = new Thread(pongGame);
- balls.start();
-
- //EventQueue.invokeLater(pongGame);
- }
-
- public void doLevel(int level) {
- // this runs one 'level'
- // create arrays of ball balls here.
- // Maybe each level will have different numbers?
- juststarted = true;
- deadball = false;
- ballNumber = 1;
- ballPositions = new Point[ballNumber];
- goingLeft = new boolean[ballNumber];
- goingRight = new boolean[ballNumber];
- goingUp = new boolean[ballNumber];
- goingDown = new boolean[ballNumber];
-
- for (int i = 0; i < ballNumber; i++) {
- ballPositions[i] = new Point(0, 0);
- goingLeft[i] = true;
- goingRight[i] = false;
- goingUp[i] = false;
- goingDown[i] = true;
- }
-
- // System.out.println("Started level " + level);
-
- // randomly position 1 player, x balls
- playerPosition = new Point(RIGHTEDGE - 20, 0);
-
- for (int i = 0; i < ballNumber; i++) {
- ballPositions[i] = randomPosition();
- }
-
- // paint the panel here
- area.repaint();
- ingame = true;
- }
-
- private Point randomPosition() {
- Point p = new Point((int) (Math.random() * RIGHTEDGE) / BALL_XAMOUNT * BALL_XAMOUNT, (int) 0);
- if (p.x >= RIGHTEDGE * 2 / 3)
- p.x = p.x - RIGHTEDGE / 3;
-
- return (p);
- }
-
- synchronized void addABall() {
- System.out.println("ADD A BALL!");
- Point[] newBallPos = new Point[ballNumber + 1];
- boolean[] newgl = new boolean[ballNumber + 1], newgr = new boolean[ballNumber + 1],
- newgu = new boolean[ballNumber + 1], newgd = new boolean[ballNumber + 1];
-
- for (int i = 0; i < ballNumber; i++) {
- newBallPos[i] = new Point(ballPositions[i]);
- newgl[i] = goingLeft[i];
- newgr[i] = goingRight[i];
- newgu[i] = goingUp[i];
- newgd[i] = goingDown[i];
- }
-
- newBallPos[ballNumber] = randomPosition();
- newgl[ballNumber] = true;
- newgr[ballNumber] = false;
- newgu[ballNumber] = false;
- newgu[ballNumber] = true;
- ballPositions = newBallPos;
- goingLeft = newgl;
- goingRight = newgr;
- goingUp = newgu;
- goingDown = newgd;
- ballNumber++;
- }
-
- void seeIfBallHitWallFloorOrCeiling(int ballno) {
- if (ballPositions[ballno].x <= 0) { // ball hit the left wall
- goingRight[ballno] = true;
- goingLeft[ballno] = false;
- } else if (ballPositions[ballno].y <= 0) {// ball hit the ceiling
- goingUp[ballno] = false;
- goingDown[ballno] = true;
- } else if (ballPositions[ballno].y >= BOTTOMEDGE - BALL_YAMOUNT) {// ball hit the floor
- goingDown[ballno] = false;
- goingUp[ballno] = true;
- } else if (ballPositions[ballno].x >= RIGHTEDGE) { // ball reached the right edge
- deadball = true;
- level--; // because it will be incremented in a minute and we want to stay on the same
- // 'level'
- ingame = false;
- System.out.println("LOZER!");
- }
- }
-
- private boolean isPlayerPosition(Point p) {
- return (p.x >= playerPosition.x && p.y >= playerPosition.y && p.y <= playerPosition.y + 154);
- }
-
- private Point moveBall(int ballno, Point original) {
- Point result = new Point(original);
- if (goingLeft[ballno])
- result.x = result.x - BALL_XAMOUNT;
- else if (goingRight[ballno])
- result.x = result.x + BALL_XAMOUNT;
-
- if (goingUp[ballno])
- result.y = result.y - BALL_YAMOUNT;
- else if (goingDown[ballno])
- result.y = result.y + BALL_YAMOUNT;
- if (isPlayerPosition(result)) {
- goingRight[ballno] = false;
- goingLeft[ballno] = true;
- } else
- seeIfBallHitWallFloorOrCeiling(ballno);
-
- return (result);
- }
-
- // this class will use just the key pressed event
- @Override
- public void keyPressed(KeyEvent e) {
- if (ingame) {
- if (!((e.getKeyCode() == KeyEvent.VK_DOWN && playerPosition.y >= (BOTTOMEDGE - PLAYER_YAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_UP && playerPosition.y <= (TOPEDGE + PLAYER_YAMOUNT)))) {
- // valid move: move the player and then move the balls
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- playerPosition.y += PLAYER_YAMOUNT;
- } else if (e.getKeyCode() == KeyEvent.VK_UP) {
- playerPosition.y -= PLAYER_YAMOUNT;
- }
-
- for (int i = 0; i < ballNumber; i++) {
- if (isPlayerPosition(ballPositions[i])) {
- goingRight[i] = false;
- goingLeft[i] = true;
- }
- }
- area.repaint();
- } // if valid key press
- } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
- doLevel(level++);
- }
- }
-
- @Override
- public void run() {
- while (true) {
- if (juststarted) {
- try {
- Thread.sleep(750);
- } catch (Exception e) {
- }
- juststarted = false;
- }
-
- try {
- Thread.sleep(DELAY);
- } catch (InterruptedException e) {
- }
-
- if (ingame) {
- timeSinceLastBall += DELAY;
- // System.out.println(String.valueOf(timeSinceLastBall));
- if (timeSinceLastBall >= 10000) {
- addABall();
- timeSinceLastBall = 0;
- }
-
- // for each ball, move the ball closer to the player
- for (int i = 0; i < ballPositions.length; i++) {
- if (!deadball) {
- ballPositions[i] = moveBall(i, ballPositions[i]);
- }
- if (isPlayerPosition(ballPositions[i])) {
- goingRight[i] = false;
- goingLeft[i] = true;
- }
- }
- area.repaint();
- }
- }
- }
-
- @Override
- public void keyReleased(KeyEvent e) {
- }
-
- @Override
- public void keyTyped(KeyEvent e) {
- }
-}
diff --git a/Reaper/src/Reaper.java b/Reaper/src/Reaper.java
@@ -0,0 +1,818 @@
+import java.awt.Color;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.JFrame;
+
+//* Copyright (c) Mary Percival 2003 */
+/* Reaper game Created May 2003 */
+
+public class Reaper extends JFrame implements KeyListener, Runnable {
+ private static final long serialVersionUID = -3998951090286400255L;
+ boolean easymode = true;
+ static int MAXLEVEL = 1;
+ static int level = 1;
+
+ // the levels so far are:
+ // 1 beginner level: 4 fire hydrants & 1 runner
+
+ static int LEFT = 1;
+ static int RIGHT = 0;
+ // the next 2 constants are overridden in init once we know the screen size
+ static int RIGHTEDGE = 789;
+ static int BOTTOMEDGE = 900;
+ static int PAGEWIDTH = 741;
+
+ static Point IMAGESIZE = new Point(152, 107);
+ static final int LEFTEDGE = 0;
+ static final int TOPEDGE = -10;
+ static int GROUNDLEVEL = 503;
+ static int startPosY;
+ static int JUMPAMOUNT = 70;
+ static int BOUNCEAMOUNT = 48;
+ static final int FALLAMOUNT = 16; // amount he falls each time interval
+ static final int RISEAMOUNT = 16; // amount he rises each time interval
+ static final int XAMOUNT = 12;
+
+ static final int X = 1;
+ static final int Y = 2;
+ static final int NOT = 3;
+ static final int DELAY = 50;
+
+ static final int OBSTACLEIMAGES = 1; // static obstacles - unlike reaper obstacles
+ static final int HEROIMAGES = 4;
+ static final int PREYIMAGES = 3;
+
+ // ----------------------------------------------------------------------------------------------
+ // PREY TYPES
+ // ----------------------------------------------------------------------------------------------
+ static final int PREYTYPES = 1; // runner
+ static final int RUNNER = 0;
+
+ // prey positions (height)
+ static final int RUNNERHEIGHT = GROUNDLEVEL - 20;
+ static int preyHeight[] = new int[PREYTYPES];
+
+ static final int preySize[] = { 27 };
+ static final int preyTopSpace[] = { 4 };
+
+ static final int SPACE_FROM_X_TO_REAPER = 55;
+ static final int REAPERHEIGHT = 86;
+ static final int REAPEROFFSET = 21;
+ static final int REAPERCROUCHOFFSET = 39;
+ static final int REAPERSTANDINGSIZE = 65;
+ static final int REAPERCROUCHINGSIZE = 45;
+
+ static final int JUMPDURATION = 5;
+ static final int SUPERJUMPDURATION = 8;
+ static final int REAPERLEFTOFOBSTACLE = 45; // fudge factor because Reaper image is diff size to obstacle image
+ static final int REAPERRIGHTOFOBSTACLE = 10; // fudge factor because Reaper image is diff size to obstacle image
+ static final int PREYLEFTOFOBSTACLE = 33; // fudge factor for prey images
+ static final int PREYRIGHTOFOBSTACLE = 7; // >49 causes panic!
+ static final int REAPERLEFTOFPREY = 73;
+ static final int REAPERRIGHTOFPREY = -23;
+
+ static final int LEFTDOWN = 0;
+ static final int RIGHTDOWN = 1;
+ static final int DOWNDOWN = 2;
+ static final int SPACEDOWN = 3;
+
+ static final int OBSTACLEHEIGHT = 42;
+ static final int TALLOBSTACLEDIFF = 28;
+ static final int OBSTACLEWIDTH = 40;
+ int GROUNDDIFF = 605 - GROUNDLEVEL;
+
+ // all member variables 'static' because shared with the prey action thread
+ static ReaperArea area;
+ static Thread timer;
+ static boolean finished = false;
+ static boolean ingame = false;
+ static boolean juststarted = true;
+ static Point warpzone;
+ static int[] keysdown = new int[4];
+ static Point[] preyPositions;
+ static Point playerPosition;
+ static Point[] obstaclePositions;
+ static boolean[] piranhaPopping; // one for each obstacle
+ static boolean[] hasPiranha; // one for each obstacle
+ static boolean[] isTall; // one for each obstacle
+ static int preyDirection[];
+ static int preyNumber = 1, preyRemaining = 1, obstacleNumber = 1;
+ static boolean reapercrouching = false;
+ static boolean onTheWayUp = false;
+ static boolean bouncing = false;
+ static boolean wasbouncing = false;
+ static boolean dead = false;
+ static int page = 0;
+ static int reaperImageNo = 0;
+ static int preyImageNo[];
+ static int levellength = 1482;
+ static Image[] reaperImages = new Image[HEROIMAGES];
+ static Image[] obstacleImages = new Image[OBSTACLEIMAGES]; // obstacle, piranhapeep, piranha peepy etc
+ static Image[] squished = new Image[PREYTYPES]; // squished images for each prey type
+ static Image[][][] preyImages = new Image[PREYTYPES][2][PREYIMAGES]; // left right left right or whatever
+ static int obstacleImageNo[]; // what is the current image for obstacle n
+ static Image[][] preyImage = new Image[PREYTYPES][PREYIMAGES];// what is the current image for prey n?
+ static Image floors[] = new Image[MAXLEVEL];
+ static int preyType[]; // what is the type of prey n?
+ static boolean preyDead[]; // is prey n dead?
+ static boolean reaperleft = false;
+ static boolean jumping = false;
+ static int preyMove[] = new int[PREYTYPES];
+ boolean somethingChangedSinceRepaint = false;
+
+ // *************************************************************
+ public static void main(String[] args) {
+ Reaper Reaper = new Reaper();
+
+ Reaper.setLayout(null);
+ Reaper.setBackground(Color.white);
+ Reaper.setSize(RIGHTEDGE, BOTTOMEDGE);
+
+ area = new ReaperArea(Reaper);
+ Reaper.add(area);
+ //RIGHTEDGE = (Reaper.getBounds().width / XAMOUNT) * XAMOUNT + LEFTEDGE;
+ //BOTTOMEDGE = Reaper.getBounds().height - 1;
+ Reaper.setVisible(true);
+ area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
+ //GROUNDLEVEL = Reaper.getBounds().height - Reaper.GROUNDDIFF;
+ startPosY = GROUNDLEVEL;
+ //ReaperArea.FLOORLEVEL = Reaper.getBounds().height - ReaperArea.FLOORDIFF;
+ area.setVisible(true);
+
+ Reaper.addKeyListener(Reaper);
+ area.addKeyListener(Reaper);
+ area.requestFocus();
+
+ for (int i = 0; i < OBSTACLEIMAGES; i++) {
+ obstacleImages[i] = area.obstacle;
+ }
+
+ preyImages[RUNNER][RIGHT][0] = area.runner;
+ preyImages[RUNNER][RIGHT][1] = area.runner2;
+ preyImages[RUNNER][LEFT][0] = area.runnerleft;
+ preyImages[RUNNER][LEFT][1] = area.runner2left;
+
+ preyMove[RUNNER] = 5;
+ preyHeight[RUNNER] = 40;
+ squished[RUNNER] = area.squishedrunner;
+
+ // for (int i=0; i < MAXLEVEL; i++) {
+ // floors[i] = area.floor4;
+ // }
+
+ timer = new Thread(Reaper);
+ timer.start();
+
+ }
+
+ synchronized void faceRight() {
+ reaperImages[0] = area.reaperstand;
+ reaperImages[1] = area.reaper1;
+ reaperImages[2] = area.reaperstand;
+ reaperImages[3] = area.reaper2;
+ reaperImageNo = 0;
+ reaperleft = false;
+ }
+
+ synchronized void faceLeft() {
+ reaperImages[0] = area.reaperstandleft;
+ reaperImages[1] = area.reaper1left;
+ reaperImages[2] = area.reaperstandleft;
+ reaperImages[3] = area.reaper2left;
+ reaperImageNo = 0;
+ reaperleft = true;
+ }
+
+ synchronized void preyFaceRight(int preyno) {
+ preyImage[preyno][0] = preyImages[preyType[preyno]][RIGHT][0];
+ preyImage[preyno][1] = preyImages[preyType[preyno]][RIGHT][1];
+ preyDirection[preyno] = RIGHT;
+ }
+
+ synchronized void preyFaceLeft(int preyno) {
+ preyImage[preyno][0] = preyImages[preyType[preyno]][LEFT][0];
+ preyImage[preyno][1] = preyImages[preyType[preyno]][LEFT][1];
+ preyDirection[preyno] = LEFT;
+ }
+
+ synchronized void preyDie(int preyno) {
+ // displayStatus();
+ preyImage[preyno][0] = squished[preyType[preyno]];
+ preyImage[preyno][1] = squished[preyType[preyno]];
+ }
+
+ synchronized void standStill() {
+ reaperImageNo = 0;
+ }
+
+ public void doLevel(int level) {
+ // this runs one 'level'
+ juststarted = true;
+ dead = false;
+
+ // position reaper at the bottom left
+ playerPosition = new Point(LEFTEDGE, GROUNDLEVEL);
+ faceRight();
+
+ // *********** THIS STUFF DEPENDS WHAT LEVEL YOU ARE ON ************
+ switch (level) {
+ case 1:
+ obstacleNumber = 4; // 4 obstacles for level 1
+ preyNumber = 1;
+ levellength = 1482; // 2 pages
+ break;
+ default:
+ System.out.println("Level " + level + " has not yet been implemented");
+ }
+ preyImage = new Image[preyNumber][PREYIMAGES];// what is the current image for prey n?
+ // initialise piranha states
+ obstacleImageNo = new int[obstacleNumber];
+ hasPiranha = new boolean[obstacleNumber];
+ piranhaPopping = new boolean[obstacleNumber];
+ isTall = new boolean[obstacleNumber];
+
+ // initialise the arrays of prey, etc
+ preyPositions = new Point[preyNumber];
+ preyType = new int[preyNumber];
+ preyDead = new boolean[preyNumber];
+ obstaclePositions = new Point[obstacleNumber];
+ preyDirection = new int[preyNumber];
+ preyImageNo = new int[preyNumber];
+
+ for (int i = 0; i < preyNumber; i++) {
+ preyImageNo[i] = 0;
+ }
+
+ switch (level) {
+ // -----------------------------------------------
+ // LEVEL 1
+ // -----------------------------------------------
+ case 1:
+ for (int i = 0; i < obstacleNumber; i++) {
+ isTall[i] = false;
+ piranhaPopping[i] = false;
+ hasPiranha[i] = false;
+ }
+ obstaclePositions[0] = new Point(400, GROUNDLEVEL);
+ obstaclePositions[1] = new Point(950, GROUNDLEVEL);
+ obstaclePositions[2] = new Point(1245, GROUNDLEVEL); // 1255 for adjacent
+ obstaclePositions[3] = new Point(1320, GROUNDLEVEL);
+
+ preyPositions[0] = new Point(1000, RUNNERHEIGHT);
+ preyType = new int[] { RUNNER };
+ break;
+ // -----------------------------------------------
+ // LEVEL 2
+ // -----------------------------------------------
+ default:
+
+ }
+
+ for (int j = 0; j < preyNumber; j++) {
+ preyFaceRight(j); // in this game all the 'prey' are fleeing to the right
+ preyDead[j] = false;
+ }
+
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (hasPiranha[i]) { // pick a random image number between 0 and 18 (inclusive)
+ obstacleImageNo[i] = (int) (Math.random() * 18) / 1;
+ } else
+ obstacleImageNo[i] = 0;
+ }
+
+ // position the warp zone at the end of the level
+ warpzone = new Point(levellength, GROUNDLEVEL);
+ // *********** END OF STUFF THAT DEPENDS WHAT LEVEL YOU ARE ON ************
+
+ ingame = true;
+ System.out.println("Started level " + level);
+ }
+
+ boolean isPlayerPosition(Point p) {
+ return (p.x == playerPosition.x && p.y == playerPosition.y);
+ }
+
+ int isEnemyPosition(Point p) {
+ for (int i = 0; i < preyNumber; i++) {
+ if (isEnemyX(p) != -1 && isEnemyY(p) != -1 && !preyDead[i])
+ return (i);
+ }
+ return (-1);
+ }
+
+ boolean isObstaclePosition(Point p, boolean forReaper) {
+ int obby;
+ for (int i = 0; i < obstacleNumber; i++) {
+ obby = isObstacleX(p, forReaper);
+ if (obby != -1 && isObstacleY(p, obby, forReaper) != -1) {
+ return (true);
+ }
+ }
+ return (false);
+ }
+
+ boolean checkIfBlockingObstacle(Point p) {
+ boolean result = false;
+ int obby;
+ obby = isObstacleX(p, true);
+ if (obby != -1 && isBlockingObstacleY(p, obby)) {
+ piranhaPopping[obby] = false;
+ result = true;
+ }
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (i != obby || !result) {
+ if (hasPiranha[i])
+ piranhaPopping[i] = true;
+ }
+ }
+ if (!result)
+ startPosY = GROUNDLEVEL;
+ return (result);
+ }
+
+ int isObstacleX(Point p, boolean forReaper) {
+ int obstaclex;
+ for (int i = 0; i < obstacleNumber; i++) {
+ // if x is >= obstacleposition - (REAPERLEFTOFOBSTACLE) and x <=
+ // obstacleposition + (REAPERRIGHTOFOBSTACLE)
+ obstaclex = obstaclePositions[i].x;
+ if (forReaper) {
+ if (p.x >= (obstaclex - REAPERLEFTOFOBSTACLE) && p.x <= (obstaclex + REAPERRIGHTOFOBSTACLE))
+ return (i); // return the number of the matching obstacle
+ } else {
+ if (p.x >= (obstaclex - PREYLEFTOFOBSTACLE) && p.x <= (obstaclex + PREYRIGHTOFOBSTACLE))
+ return (i); // return the number of the matching obstacle
+ }
+ }
+ return (-1);
+ }
+
+ boolean isBlockingObstacleY(Point p, int obstaclenumber) {
+ // String s = "Is Reaper blocking obstacle " + obstaclenumber + " which is " +
+ // (isTall[obstaclenumber] ? "" : "not ") + "tall";
+ if (isTall[obstaclenumber]) {
+ if (p.y <= obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
+ // System.out.println(s+": Yes");
+ return (true);
+ }
+ } else {
+ if (p.y <= obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
+ // System.out.println(s+": Yes");
+ return (true);
+ }
+ }
+ // System.out.println(s+": No");
+ return (false);
+ }
+
+ int isObstacleY(Point p, int obstaclenumber, boolean forReaper) {
+ if (isTall[obstaclenumber]) {
+ if (p.y > obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
+ return (obstaclenumber);
+ }
+ } else {
+ if (p.y > obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
+ return (obstaclenumber);
+ }
+ }
+ return (-1);
+ }
+
+ int isEnemyX(Point p) {
+ int preyx;
+ for (int i = 0; i < preyNumber; i++) {
+ // if x is >= preyposition - (LEFTOFPREY) and x <= preyposition + (RIGHTOFPREY)
+ preyx = preyPositions[i].x;
+ // System.out.println("Player got by prey if " +
+ // p.x + " >= " + (preyx - REAPERLEFTOFPREY) + " && " + p.x + " <= " + (preyx +
+ // REAPERRIGHTOFPREY));
+ if (p.x >= (preyx - REAPERLEFTOFPREY) && p.x <= (preyx + REAPERRIGHTOFPREY) && !preyDead[i])
+ return (i); // return the number of the matching prey
+ }
+ return (-1);
+ }
+
+ int isEnemyY(Point p) {
+ int offset = reapercrouching ? REAPERCROUCHOFFSET : REAPEROFFSET;
+ for (int i = 0; i < preyNumber; i++) {
+ if (!preyDead[i] && ((p.y + offset <= preyPositions[i].y + preySize[preyType[i]])
+ && (p.y + REAPERHEIGHT) >= preyPositions[i].y))
+ return (i);
+ }
+ return (-1);
+ }
+
+ int randomMove() {
+ // return + or - value (randomly)
+ if (Math.random() >= 0.5)
+ return (24);
+ else
+ return (-24);
+ }
+
+ private synchronized void incKeysDown(int whichone) {
+ keysdown[whichone] = 1;
+ }
+
+ private synchronized void decKeysDown(int whichone) {
+ keysdown[whichone] = 0;
+ }
+
+ // this class will use just the key pressed event
+ @Override
+ public void keyPressed(KeyEvent e) {
+ if (e.getKeyCode() == KeyEvent.VK_F1) {
+ displayStatus();
+ }
+ if (ingame) {
+ if (!(e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))) {
+
+ // valid move: move the player and then move the prey
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ reapercrouching = true;
+ incKeysDown(DOWNDOWN);
+ setSomethingChangedSinceRepaint(true);
+ } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ incKeysDown(LEFTDOWN);
+ leftPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ incKeysDown(RIGHTDOWN);
+ rightPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ } else if (e.getKeyCode() == KeyEvent.VK_SPACE) {
+ if (!jumping) {
+ startPosY = playerPosition.y;
+ jumping = true;
+ onTheWayUp = true;
+ setSomethingChangedSinceRepaint(true);
+ }
+ }
+ if (somethingChangedSinceRepaint) {
+ area.repaint();
+ }
+ } // if valid key press
+ } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+ if (level == MAXLEVEL || dead)
+ doLevel(level);
+ else
+ doLevel(++level);
+ page = 0;
+ area.repaint();
+ }
+ }
+
+ /* synchronized */ void setSomethingChangedSinceRepaint(boolean val) {
+ somethingChangedSinceRepaint = val;
+ }
+
+ void leftPressed(boolean skid) {
+ if (!reapercrouching) {
+ // if Hero was facing right, turn him left
+ if (!reaperleft)
+ faceLeft();
+ else {
+ // if the target position is not occupied by a obstacle...
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstaclePosition(new Point(playerPosition.x - XAMOUNT, playerPosition.y), true))
+ return; // can't move
+ }
+ playerPosition.x -= XAMOUNT;
+ if (!skid)
+ incrementHeroImage();
+ }
+ }
+ }
+
+ void rightPressed(boolean skid) {
+ if (!reapercrouching) {
+ if ((playerPosition.x + SPACE_FROM_X_TO_REAPER) >= (warpzone.x + 4)) {
+ // level complete!
+ ingame = false;
+ } else {
+ // if Hero was facing left, turn him right
+ if (reaperleft)
+ faceRight();
+ else {
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (isObstaclePosition(new Point(playerPosition.x + XAMOUNT, playerPosition.y), true))
+ return; // can't move
+ }
+ playerPosition.x += XAMOUNT;
+ // System.out.println("Reaper's x position is " + playerPosition.x);
+ if (!skid)
+ incrementHeroImage();
+ }
+ }
+ }
+ }
+
+ boolean anythingVisibleChanged() {
+ return (somethingChangedSinceRepaint);
+ }
+
+ @Override
+ public void run() {
+ boolean odd = true; // only change piranha image every other cycle
+ while (true) {
+ if (juststarted) {
+ try {
+ Thread.sleep(750);
+ } catch (Exception e) {
+ }
+ area.repaint();
+ juststarted = false;
+ }
+ try {
+ Thread.sleep(DELAY);
+ } catch (InterruptedException e) {
+ }
+ if (ingame) {
+ if (keysdown[LEFTDOWN] == 0 && keysdown[RIGHTDOWN] == 0 && keysdown[DOWNDOWN] == 0)
+ standStill();
+
+ if (keysdown[LEFTDOWN] > 0) {
+ leftPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ } else if (keysdown[RIGHTDOWN] > 0) {
+ rightPressed(false);
+ setSomethingChangedSinceRepaint(true);
+ }
+
+ if (!odd) {
+ // for each obstacle, cycle through the piranha pictures
+ for (int i = 0; i < obstacleNumber; i++) {
+ if (piranhaPopping[i]) {
+ incrementObstacleImage(i);
+ if (isVisibleObstacle(i))
+ setSomethingChangedSinceRepaint(true);
+ }
+ }
+ }
+ odd = !odd;
+
+ // for each prey, move the prey in the direction it was going
+ for (int i = 0; i < preyNumber; i++) {
+ // TODO if there is a fatal obstacle at that position, fall into it and
+ // decrement count of prey
+ // and set that prey's position to -1, -1
+ /*
+ * if (isObstaclePosition(preyPositions[i])) {
+ * System.out.println("A prey fell into a obstacle");
+ *
+ * preyPositions[i] = new Point(-1, -1); preyRemaining--;
+ * System.out.println(preyNumber-preyRemaining + " down, " + preyRemaining +
+ * " to go..."); }
+ */
+ // if there is a non-fatal obstacle
+ if (isObstaclePosition(preyPositions[i], false)) {
+ // change direction
+ changeDirection(i);
+ if (isVisibleEnemy(i))
+ setSomethingChangedSinceRepaint(true);
+ }
+ if (!preyDead[i]) {
+ preyPositions[i] = move(i, preyPositions[i], preyDirection[i], odd);
+ if (isVisibleEnemy(i))
+ setSomethingChangedSinceRepaint(true);
+ }
+
+ // if player is caught by a prey, end the game
+ int preyno = isEnemyPosition(playerPosition);
+ if (preyno > -1) {
+ int NEEDTOBEABOVE = preyPositions[preyno].y + preyTopSpace[preyno] - REAPERHEIGHT;
+ if (easymode)
+ NEEDTOBEABOVE = preyPositions[preyno].y - preyHeight[preyType[preyno]];
+ if ((!onTheWayUp && (playerPosition.y <= NEEDTOBEABOVE))) {
+ // player may have squished an prey
+ preyDead[preyno] = true;
+ preyDie(preyno);
+ // player bounces
+ bouncing = true;
+ startPosY = playerPosition.y;
+ setSomethingChangedSinceRepaint(true);
+ } else {
+ int offset = reapercrouching ? REAPERCROUCHOFFSET : REAPEROFFSET;
+ if (playerPosition.y > NEEDTOBEABOVE && (playerPosition.y
+ + offset <= preyPositions[preyno].y + preySize[preyType[preyno]])) {
+ die();
+ setSomethingChangedSinceRepaint(true);
+ }
+ }
+ }
+ }
+ if (!dead) {
+ if (onTheWayUp) {
+ if (playerPosition.y > startPosY - JUMPAMOUNT) {
+ playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
+ setSomethingChangedSinceRepaint(true);
+ } else {
+ onTheWayUp = false;
+ }
+ } else if (bouncing) {
+ if (playerPosition.y > startPosY - BOUNCEAMOUNT) {
+ playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
+ setSomethingChangedSinceRepaint(true);
+ } else {
+ bouncing = false;
+ wasbouncing = true;
+ }
+ } else {
+ int obstacleno = isObstacleX(playerPosition, true);
+ if (obstacleno == -1) { // no obstacle at this position
+ if (!onTheWayUp && !bouncing) {
+ if (playerPosition.y < startPosY) {
+ playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
+ wasbouncing = false;
+ setSomethingChangedSinceRepaint(true);
+ } else
+ jumping = false;
+ }
+ } else {
+ Point obstaclepos = obstaclePositions[obstacleno];
+ // if reaper's y position <= obstacle's height
+ int thisObstacleHeight = isTall[obstacleno] ? OBSTACLEHEIGHT + TALLOBSTACLEDIFF
+ : OBSTACLEHEIGHT;
+ if (playerPosition.y <= (obstaclepos.y - thisObstacleHeight) && // can't land on the
+ // obstacle if just < (??!)
+ (playerPosition.y + FALLAMOUNT >= (obstaclepos.y - thisObstacleHeight))) {
+ // allow reaper to land on the obstacle
+ jumping = false;
+ if (playerPosition.y != obstaclepos.y - thisObstacleHeight)
+ setSomethingChangedSinceRepaint(true);
+ playerPosition = new Point(playerPosition.x, obstaclepos.y - thisObstacleHeight);
+ // if the piranha was up, Hero dies
+ if (obstacleImages[obstacleImageNo[obstacleno]] != area.obstacle) {
+ die();
+ } else {
+ // otherwise stop this Piranha
+ piranhaPopping[obstacleno] = false;
+ }
+ } else {
+ if (!onTheWayUp && !bouncing) {
+ if (playerPosition.y < startPosY) {
+ setSomethingChangedSinceRepaint(true);
+ playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
+ wasbouncing = false;
+ } else
+ jumping = false;
+ }
+ }
+ }
+ }
+ if (!dead) {
+ checkIfBlockingObstacle(playerPosition);
+ if (playerPosition.y > GROUNDLEVEL)
+ playerPosition.y = GROUNDLEVEL;
+ }
+ if (anythingVisibleChanged()) {
+ area.repaint();
+ }
+ } else {
+ if (!area.showingMessage)
+ area.repaint();
+ }
+ }
+ }
+ }
+
+ boolean isVisibleObstacle(int i) {
+ // TODO - this probably needs fixing when obstacle is near page boundary
+ return ((obstaclePositions[i].x >= page * PAGEWIDTH) && (obstaclePositions[i].x < (page + 1) * PAGEWIDTH));
+ }
+
+ boolean isVisibleEnemy(int i) {
+ // TODO - this probably needs fixing when prey is near page boundary
+ return ((preyPositions[i].x >= page * PAGEWIDTH) && (preyPositions[i].x < (page + 1) * PAGEWIDTH)
+ && !preyDead[i]);
+ }
+
+ void changeDirection(int preyno) {
+ if (preyDirection[preyno] == LEFT) {
+ preyFaceRight(preyno);
+ } else {
+ preyFaceLeft(preyno);
+ }
+ }
+
+ synchronized void die() {
+ System.out.println("The Player is dead. Press the Enter key to restart the level");
+ ingame = false;
+ dead = true;
+ displayStatus();
+ }
+
+ synchronized void incrementObstacleImage(int i) {
+ obstacleImageNo[i]++;
+ if (obstacleImageNo[i] == OBSTACLEIMAGES)
+ obstacleImageNo[i] = 0;
+ }
+
+ synchronized void incrementHeroImage() {
+ reaperImageNo++;
+ if (reaperImageNo == HEROIMAGES)
+ reaperImageNo = 0;
+ }
+
+ synchronized void incrementEnemyImage(int i) {
+ preyImageNo[i]++;
+ if (preyImageNo[i] > (PREYIMAGES - 2))
+ preyImageNo[i] = 0;
+ }
+
+ Point move(int preyNo, Point start, int direction, boolean odd) {
+ if (odd)
+ incrementEnemyImage(preyNo);
+ if (direction == LEFT) {
+ return (new Point(start.x - preyMove[preyType[preyNo]], start.y));
+ } else {
+ return (new Point(start.x + preyMove[preyType[preyNo]], start.y));
+ }
+ }
+
+ @Override
+ public void keyReleased(KeyEvent e) {
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ reapercrouching = false;
+ decKeysDown(DOWNDOWN);
+ } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ decKeysDown(LEFTDOWN);
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ decKeysDown(RIGHTDOWN);
+ }
+ }
+
+ public void keyTyped(KeyEvent e) {
+ }
+
+ synchronized Image getHeroImage() {
+ return (reaperImages[reaperImageNo]);
+ }
+
+ synchronized Image getObstacleImage(int obstaclenum) {
+ return (obstacleImages[obstacleImageNo[obstaclenum]]);
+ }
+
+ synchronized Image getEnemyImage(int preyno) {
+ return (preyImage[preyno][preyImageNo[preyno]]);
+ }
+
+ void displayStatus() {
+ /*
+ * // when a certain F Key is pressed, display positions of Reaper, // all
+ * obstacles and all prey and the end flag (warp zone)
+ * System.out.println("--------"); System.out.println("Reaper is " + (dead?
+ * "dead" : "alive")); if (dead) { int preyno = isEnemyPosition(playerPosition);
+ * System.out.println("Reaper was killed by prey " + preyno); }
+ * System.out.println("In game is " + ingame); System.out.println("Reaper is " +
+ * (onTheWayUp? "on the way up" : "not on the way up"));
+ * System.out.println("Reaper's position is (" + playerPosition.x + ", " +
+ * playerPosition.y + ")");
+ * System.out.println("Reaper's visible left, bottom co-ordinates are " +
+ * (playerPosition.x + 55) + " and " + (playerPosition.y + REAPERHEIGHT));
+ * System.out.println("Reaper is on page " + page +
+ * " (which shows x positions from " + (page*PAGEWIDTH) + " to " +
+ * ((page+1)*PAGEWIDTH) + ")"); System.out.println("Screen bounds are (" +
+ * getBounds().width + ", " + getBounds().height + ")"); System.out.println("");
+ * for (int prey=0; prey < preyNumber; prey++) { System.out.println("Enemy " +
+ * prey + " is " + preyTypeString(preyType[prey]) + " and is " + (preyDead[prey]
+ * ? " " : "not ") + "dead"); System.out.println("Enemy " + prey +
+ * " is at position (" + preyPositions[prey].x + ", " +
+ * preyPositions[prey].y+") and has size " + preySize[preyType[prey]]); }
+ * //System.out.println(""); //for (int obstacle=0; obstacle < obstacleNumber;
+ * obstacle++) { // System.out.println("Obstacle " + obstacle +
+ * " is at position (" + obstaclePositions[obstacle].x + // ", " +
+ * obstaclePositions[obstacle].y+")"); //} System.out.println("");
+ * System.out.println("The warp zone is positioned at (" + warpzone.x + ", " +
+ * warpzone.y + ")"); System.out.println("========");
+ */
+ }
+
+ String preyTypeString(int fortype) {
+ switch (fortype) {
+ case RUNNER:
+ return ("RUNNER");
+ default:
+ return ("Unknown type (" + fortype + ")");
+ }
+ }
+
+ void changePageIfNecessary() {
+ if (playerPosition.x == LEFTEDGE)
+ return;
+ if ((playerPosition.x + SPACE_FROM_X_TO_REAPER) > (page * PAGEWIDTH + RIGHTEDGE - XAMOUNT)) {
+ // System.out.println("Change page up: (" + playerPosition.x+ "+" +
+ // SPACE_FROM_X_TO_REAPER+ ") > (" + page+ "*" + PAGEWIDTH + "+" + RIGHTEDGE +
+ // "-" + XAMOUNT + ")");
+ page++;
+ } else if ((playerPosition.x + SPACE_FROM_X_TO_REAPER) - (page * PAGEWIDTH) < (LEFTEDGE + XAMOUNT)) {
+ // System.out.println("Change page down: (" + playerPosition.x+ "+" +
+ // SPACE_FROM_X_TO_REAPER+ ")-(" + page+ "*" + PAGEWIDTH + ") < (" + LEFTEDGE+
+ // "+" + XAMOUNT+")");
+ page--;
+ }
+ }
+}
diff --git a/Reaper/src/ReaperArea.java b/Reaper/src/ReaperArea.java
@@ -13,7 +13,7 @@ public class ReaperArea extends JPanel {
static int FLOORLEVEL = 589;
static final int FLOORWIDTH = 150;
static int FLOORDIFF = 605 - FLOORLEVEL;
- ReaperGame myApplet = null;
+ Reaper myApplet = null;
Image reaperwarp;
Image reaper1;
Image reaper1left;
@@ -36,7 +36,7 @@ public class ReaperArea extends JPanel {
boolean showingMessage = false;
boolean starting = true;
- public ReaperArea(ReaperGame parent) {
+ public ReaperArea(Reaper parent) {
mt = new MediaTracker(parent);
myApplet = parent;
@@ -78,7 +78,7 @@ public class ReaperArea extends JPanel {
}
- Image load(ReaperGame parent, String picture) {
+ Image load(Reaper parent, String picture) {
try {
Image im = ImageIO.read(new File("../Assets/" + picture));
checkImage(im, picture);
@@ -115,67 +115,67 @@ public class ReaperArea extends JPanel {
g.setColor(Color.black);
// paint the floor
- if (ReaperGame.floors[ReaperGame.level - 1] != null) {
+ if (Reaper.floors[Reaper.level - 1] != null) {
for (int pos = 0; pos < w; pos += FLOORWIDTH) {
- g.drawImage(ReaperGame.floors[ReaperGame.level - 1], pos, FLOORLEVEL, Color.black, null);
+ g.drawImage(Reaper.floors[Reaper.level - 1], pos, FLOORLEVEL, Color.black, null);
}
}
- if (!ReaperGame.juststarted) {
- if (ReaperGame.obstaclePositions != null) {
+ if (!Reaper.juststarted) {
+ if (Reaper.obstaclePositions != null) {
myApplet.changePageIfNecessary();
// show the obstacles from right to left (because obstacles have white space to
// their left but not their right)
- for (int i = ReaperGame.obstacleNumber - 1; i >= 0; i--) {
+ for (int i = Reaper.obstacleNumber - 1; i >= 0; i--) {
obstacleimage = myApplet.getObstacleImage(i);
- if (ReaperGame.isTall[i])
+ if (Reaper.isTall[i])
obstacleimage = tallobstacle; // only one image for this for now
g.drawImage(obstacleimage,
- ReaperGame.obstaclePositions[i].x - (ReaperGame.page * ReaperGame.PAGEWIDTH),
- ReaperGame.obstaclePositions[i].y, Color.white, null);
+ Reaper.obstaclePositions[i].x - (Reaper.page * Reaper.PAGEWIDTH),
+ Reaper.obstaclePositions[i].y, Color.white, null);
}
}
// show the prey
- if (ReaperGame.preyPositions != null) {
- for (int i = 0; i < ReaperGame.preyNumber; i++) {
+ if (Reaper.preyPositions != null) {
+ for (int i = 0; i < Reaper.preyNumber; i++) {
// if (!myApplet.preyDead[i]) {
preyimage = myApplet.getEnemyImage(i);
- g.drawImage(preyimage, ReaperGame.preyPositions[i].x - (ReaperGame.page * ReaperGame.PAGEWIDTH),
- ReaperGame.preyPositions[i].y, null);
+ g.drawImage(preyimage, Reaper.preyPositions[i].x - (Reaper.page * Reaper.PAGEWIDTH),
+ Reaper.preyPositions[i].y, null);
// }
}
}
// draw Hero (on top of preceding images)
- if (ReaperGame.playerPosition != null) {
+ if (Reaper.playerPosition != null) {
// show the player
Image reapersimage = myApplet.getHeroImage();
- if (ReaperGame.reapercrouching) {
- if (ReaperGame.reaperleft)
+ if (Reaper.reapercrouching) {
+ if (Reaper.reaperleft)
reapersimage = reapercrouchleft;
else
reapersimage = reapercrouch;
}
- if (ReaperGame.jumping) {
- if (ReaperGame.reaperleft)
+ if (Reaper.jumping) {
+ if (Reaper.reaperleft)
reapersimage = reaperjumpleft;
else
reapersimage = reaperjump;
}
- g.drawImage(reapersimage, ReaperGame.playerPosition.x - (ReaperGame.page * ReaperGame.PAGEWIDTH),
- ReaperGame.playerPosition.y, /* Color.white, */ null);
+ g.drawImage(reapersimage, Reaper.playerPosition.x - (Reaper.page * Reaper.PAGEWIDTH),
+ Reaper.playerPosition.y, /* Color.white, */ null);
}
}
// draw warp image (on top of Hero)
- if (ReaperGame.warpzone != null) {
+ if (Reaper.warpzone != null) {
// show the warp zone at the end of the level
- g.drawImage(reaperwarp, ReaperGame.warpzone.x - (ReaperGame.page * ReaperGame.PAGEWIDTH),
- ReaperGame.warpzone.y, Color.white, null);
+ g.drawImage(reaperwarp, Reaper.warpzone.x - (Reaper.page * Reaper.PAGEWIDTH),
+ Reaper.warpzone.y, Color.white, null);
}
- if (ReaperGame.ingame == false && !ReaperGame.juststarted) {
- if (ReaperGame.dead) {
+ if (Reaper.ingame == false && !Reaper.juststarted) {
+ if (Reaper.dead) {
// Reaper is dead (?!)
g.drawImage(reaperdead, myApplet.getBounds().width / 2, getBounds().height / 2, Color.white, null);
} else {
diff --git a/Reaper/src/ReaperGame.java b/Reaper/src/ReaperGame.java
@@ -1,818 +0,0 @@
-import java.awt.Color;
-import java.awt.Image;
-import java.awt.Point;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-
-import javax.swing.JFrame;
-
-//* Copyright (c) Mary Percival 2003 */
-/* Reaper game Created May 2003 */
-
-public class ReaperGame extends JFrame implements KeyListener, Runnable {
- private static final long serialVersionUID = -3998951090286400255L;
- boolean easymode = true;
- static int MAXLEVEL = 1;
- static int level = 1;
-
- // the levels so far are:
- // 1 beginner level: 4 fire hydrants & 1 runner
-
- static int LEFT = 1;
- static int RIGHT = 0;
- // the next 2 constants are overridden in init once we know the screen size
- static int RIGHTEDGE = 789;
- static int BOTTOMEDGE = 900;
- static int PAGEWIDTH = 741;
-
- static Point IMAGESIZE = new Point(152, 107);
- static final int LEFTEDGE = 0;
- static final int TOPEDGE = -10;
- static int GROUNDLEVEL = 503;
- static int startPosY;
- static int JUMPAMOUNT = 70;
- static int BOUNCEAMOUNT = 48;
- static final int FALLAMOUNT = 16; // amount he falls each time interval
- static final int RISEAMOUNT = 16; // amount he rises each time interval
- static final int XAMOUNT = 12;
-
- static final int X = 1;
- static final int Y = 2;
- static final int NOT = 3;
- static final int DELAY = 50;
-
- static final int OBSTACLEIMAGES = 1; // static obstacles - unlike reaper obstacles
- static final int HEROIMAGES = 4;
- static final int PREYIMAGES = 3;
-
- // ----------------------------------------------------------------------------------------------
- // PREY TYPES
- // ----------------------------------------------------------------------------------------------
- static final int PREYTYPES = 1; // runner
- static final int RUNNER = 0;
-
- // prey positions (height)
- static final int RUNNERHEIGHT = GROUNDLEVEL - 20;
- static int preyHeight[] = new int[PREYTYPES];
-
- static final int preySize[] = { 27 };
- static final int preyTopSpace[] = { 4 };
-
- static final int SPACE_FROM_X_TO_REAPER = 55;
- static final int REAPERHEIGHT = 86;
- static final int REAPEROFFSET = 21;
- static final int REAPERCROUCHOFFSET = 39;
- static final int REAPERSTANDINGSIZE = 65;
- static final int REAPERCROUCHINGSIZE = 45;
-
- static final int JUMPDURATION = 5;
- static final int SUPERJUMPDURATION = 8;
- static final int REAPERLEFTOFOBSTACLE = 45; // fudge factor because Reaper image is diff size to obstacle image
- static final int REAPERRIGHTOFOBSTACLE = 10; // fudge factor because Reaper image is diff size to obstacle image
- static final int PREYLEFTOFOBSTACLE = 33; // fudge factor for prey images
- static final int PREYRIGHTOFOBSTACLE = 7; // >49 causes panic!
- static final int REAPERLEFTOFPREY = 73;
- static final int REAPERRIGHTOFPREY = -23;
-
- static final int LEFTDOWN = 0;
- static final int RIGHTDOWN = 1;
- static final int DOWNDOWN = 2;
- static final int SPACEDOWN = 3;
-
- static final int OBSTACLEHEIGHT = 42;
- static final int TALLOBSTACLEDIFF = 28;
- static final int OBSTACLEWIDTH = 40;
- int GROUNDDIFF = 605 - GROUNDLEVEL;
-
- // all member variables 'static' because shared with the prey action thread
- static ReaperArea area;
- static Thread timer;
- static boolean finished = false;
- static boolean ingame = false;
- static boolean juststarted = true;
- static Point warpzone;
- static int[] keysdown = new int[4];
- static Point[] preyPositions;
- static Point playerPosition;
- static Point[] obstaclePositions;
- static boolean[] piranhaPopping; // one for each obstacle
- static boolean[] hasPiranha; // one for each obstacle
- static boolean[] isTall; // one for each obstacle
- static int preyDirection[];
- static int preyNumber = 1, preyRemaining = 1, obstacleNumber = 1;
- static boolean reapercrouching = false;
- static boolean onTheWayUp = false;
- static boolean bouncing = false;
- static boolean wasbouncing = false;
- static boolean dead = false;
- static int page = 0;
- static int reaperImageNo = 0;
- static int preyImageNo[];
- static int levellength = 1482;
- static Image[] reaperImages = new Image[HEROIMAGES];
- static Image[] obstacleImages = new Image[OBSTACLEIMAGES]; // obstacle, piranhapeep, piranha peepy etc
- static Image[] squished = new Image[PREYTYPES]; // squished images for each prey type
- static Image[][][] preyImages = new Image[PREYTYPES][2][PREYIMAGES]; // left right left right or whatever
- static int obstacleImageNo[]; // what is the current image for obstacle n
- static Image[][] preyImage = new Image[PREYTYPES][PREYIMAGES];// what is the current image for prey n?
- static Image floors[] = new Image[MAXLEVEL];
- static int preyType[]; // what is the type of prey n?
- static boolean preyDead[]; // is prey n dead?
- static boolean reaperleft = false;
- static boolean jumping = false;
- static int preyMove[] = new int[PREYTYPES];
- boolean somethingChangedSinceRepaint = false;
-
- // *************************************************************
- public static void main(String[] args) {
- ReaperGame reaperGame = new ReaperGame();
-
- reaperGame.setLayout(null);
- reaperGame.setBackground(Color.white);
- reaperGame.setSize(RIGHTEDGE, BOTTOMEDGE);
-
- area = new ReaperArea(reaperGame);
- reaperGame.add(area);
- //RIGHTEDGE = (reaperGame.getBounds().width / XAMOUNT) * XAMOUNT + LEFTEDGE;
- //BOTTOMEDGE = reaperGame.getBounds().height - 1;
- reaperGame.setVisible(true);
- area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
- //GROUNDLEVEL = reaperGame.getBounds().height - reaperGame.GROUNDDIFF;
- startPosY = GROUNDLEVEL;
- //ReaperArea.FLOORLEVEL = reaperGame.getBounds().height - ReaperArea.FLOORDIFF;
- area.setVisible(true);
-
- reaperGame.addKeyListener(reaperGame);
- area.addKeyListener(reaperGame);
- area.requestFocus();
-
- for (int i = 0; i < OBSTACLEIMAGES; i++) {
- obstacleImages[i] = area.obstacle;
- }
-
- preyImages[RUNNER][RIGHT][0] = area.runner;
- preyImages[RUNNER][RIGHT][1] = area.runner2;
- preyImages[RUNNER][LEFT][0] = area.runnerleft;
- preyImages[RUNNER][LEFT][1] = area.runner2left;
-
- preyMove[RUNNER] = 5;
- preyHeight[RUNNER] = 40;
- squished[RUNNER] = area.squishedrunner;
-
- // for (int i=0; i < MAXLEVEL; i++) {
- // floors[i] = area.floor4;
- // }
-
- timer = new Thread(reaperGame);
- timer.start();
-
- }
-
- synchronized void faceRight() {
- reaperImages[0] = area.reaperstand;
- reaperImages[1] = area.reaper1;
- reaperImages[2] = area.reaperstand;
- reaperImages[3] = area.reaper2;
- reaperImageNo = 0;
- reaperleft = false;
- }
-
- synchronized void faceLeft() {
- reaperImages[0] = area.reaperstandleft;
- reaperImages[1] = area.reaper1left;
- reaperImages[2] = area.reaperstandleft;
- reaperImages[3] = area.reaper2left;
- reaperImageNo = 0;
- reaperleft = true;
- }
-
- synchronized void preyFaceRight(int preyno) {
- preyImage[preyno][0] = preyImages[preyType[preyno]][RIGHT][0];
- preyImage[preyno][1] = preyImages[preyType[preyno]][RIGHT][1];
- preyDirection[preyno] = RIGHT;
- }
-
- synchronized void preyFaceLeft(int preyno) {
- preyImage[preyno][0] = preyImages[preyType[preyno]][LEFT][0];
- preyImage[preyno][1] = preyImages[preyType[preyno]][LEFT][1];
- preyDirection[preyno] = LEFT;
- }
-
- synchronized void preyDie(int preyno) {
- // displayStatus();
- preyImage[preyno][0] = squished[preyType[preyno]];
- preyImage[preyno][1] = squished[preyType[preyno]];
- }
-
- synchronized void standStill() {
- reaperImageNo = 0;
- }
-
- public void doLevel(int level) {
- // this runs one 'level'
- juststarted = true;
- dead = false;
-
- // position reaper at the bottom left
- playerPosition = new Point(LEFTEDGE, GROUNDLEVEL);
- faceRight();
-
- // *********** THIS STUFF DEPENDS WHAT LEVEL YOU ARE ON ************
- switch (level) {
- case 1:
- obstacleNumber = 4; // 4 obstacles for level 1
- preyNumber = 1;
- levellength = 1482; // 2 pages
- break;
- default:
- System.out.println("Level " + level + " has not yet been implemented");
- }
- preyImage = new Image[preyNumber][PREYIMAGES];// what is the current image for prey n?
- // initialise piranha states
- obstacleImageNo = new int[obstacleNumber];
- hasPiranha = new boolean[obstacleNumber];
- piranhaPopping = new boolean[obstacleNumber];
- isTall = new boolean[obstacleNumber];
-
- // initialise the arrays of prey, etc
- preyPositions = new Point[preyNumber];
- preyType = new int[preyNumber];
- preyDead = new boolean[preyNumber];
- obstaclePositions = new Point[obstacleNumber];
- preyDirection = new int[preyNumber];
- preyImageNo = new int[preyNumber];
-
- for (int i = 0; i < preyNumber; i++) {
- preyImageNo[i] = 0;
- }
-
- switch (level) {
- // -----------------------------------------------
- // LEVEL 1
- // -----------------------------------------------
- case 1:
- for (int i = 0; i < obstacleNumber; i++) {
- isTall[i] = false;
- piranhaPopping[i] = false;
- hasPiranha[i] = false;
- }
- obstaclePositions[0] = new Point(400, GROUNDLEVEL);
- obstaclePositions[1] = new Point(950, GROUNDLEVEL);
- obstaclePositions[2] = new Point(1245, GROUNDLEVEL); // 1255 for adjacent
- obstaclePositions[3] = new Point(1320, GROUNDLEVEL);
-
- preyPositions[0] = new Point(1000, RUNNERHEIGHT);
- preyType = new int[] { RUNNER };
- break;
- // -----------------------------------------------
- // LEVEL 2
- // -----------------------------------------------
- default:
-
- }
-
- for (int j = 0; j < preyNumber; j++) {
- preyFaceRight(j); // in this game all the 'prey' are fleeing to the right
- preyDead[j] = false;
- }
-
- for (int i = 0; i < obstacleNumber; i++) {
- if (hasPiranha[i]) { // pick a random image number between 0 and 18 (inclusive)
- obstacleImageNo[i] = (int) (Math.random() * 18) / 1;
- } else
- obstacleImageNo[i] = 0;
- }
-
- // position the warp zone at the end of the level
- warpzone = new Point(levellength, GROUNDLEVEL);
- // *********** END OF STUFF THAT DEPENDS WHAT LEVEL YOU ARE ON ************
-
- ingame = true;
- System.out.println("Started level " + level);
- }
-
- boolean isPlayerPosition(Point p) {
- return (p.x == playerPosition.x && p.y == playerPosition.y);
- }
-
- int isEnemyPosition(Point p) {
- for (int i = 0; i < preyNumber; i++) {
- if (isEnemyX(p) != -1 && isEnemyY(p) != -1 && !preyDead[i])
- return (i);
- }
- return (-1);
- }
-
- boolean isObstaclePosition(Point p, boolean forReaper) {
- int obby;
- for (int i = 0; i < obstacleNumber; i++) {
- obby = isObstacleX(p, forReaper);
- if (obby != -1 && isObstacleY(p, obby, forReaper) != -1) {
- return (true);
- }
- }
- return (false);
- }
-
- boolean checkIfBlockingObstacle(Point p) {
- boolean result = false;
- int obby;
- obby = isObstacleX(p, true);
- if (obby != -1 && isBlockingObstacleY(p, obby)) {
- piranhaPopping[obby] = false;
- result = true;
- }
- for (int i = 0; i < obstacleNumber; i++) {
- if (i != obby || !result) {
- if (hasPiranha[i])
- piranhaPopping[i] = true;
- }
- }
- if (!result)
- startPosY = GROUNDLEVEL;
- return (result);
- }
-
- int isObstacleX(Point p, boolean forReaper) {
- int obstaclex;
- for (int i = 0; i < obstacleNumber; i++) {
- // if x is >= obstacleposition - (REAPERLEFTOFOBSTACLE) and x <=
- // obstacleposition + (REAPERRIGHTOFOBSTACLE)
- obstaclex = obstaclePositions[i].x;
- if (forReaper) {
- if (p.x >= (obstaclex - REAPERLEFTOFOBSTACLE) && p.x <= (obstaclex + REAPERRIGHTOFOBSTACLE))
- return (i); // return the number of the matching obstacle
- } else {
- if (p.x >= (obstaclex - PREYLEFTOFOBSTACLE) && p.x <= (obstaclex + PREYRIGHTOFOBSTACLE))
- return (i); // return the number of the matching obstacle
- }
- }
- return (-1);
- }
-
- boolean isBlockingObstacleY(Point p, int obstaclenumber) {
- // String s = "Is Reaper blocking obstacle " + obstaclenumber + " which is " +
- // (isTall[obstaclenumber] ? "" : "not ") + "tall";
- if (isTall[obstaclenumber]) {
- if (p.y <= obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
- // System.out.println(s+": Yes");
- return (true);
- }
- } else {
- if (p.y <= obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
- // System.out.println(s+": Yes");
- return (true);
- }
- }
- // System.out.println(s+": No");
- return (false);
- }
-
- int isObstacleY(Point p, int obstaclenumber, boolean forReaper) {
- if (isTall[obstaclenumber]) {
- if (p.y > obstaclePositions[obstaclenumber].y - (OBSTACLEHEIGHT + TALLOBSTACLEDIFF)) {
- return (obstaclenumber);
- }
- } else {
- if (p.y > obstaclePositions[obstaclenumber].y - OBSTACLEHEIGHT) {
- return (obstaclenumber);
- }
- }
- return (-1);
- }
-
- int isEnemyX(Point p) {
- int preyx;
- for (int i = 0; i < preyNumber; i++) {
- // if x is >= preyposition - (LEFTOFPREY) and x <= preyposition + (RIGHTOFPREY)
- preyx = preyPositions[i].x;
- // System.out.println("Player got by prey if " +
- // p.x + " >= " + (preyx - REAPERLEFTOFPREY) + " && " + p.x + " <= " + (preyx +
- // REAPERRIGHTOFPREY));
- if (p.x >= (preyx - REAPERLEFTOFPREY) && p.x <= (preyx + REAPERRIGHTOFPREY) && !preyDead[i])
- return (i); // return the number of the matching prey
- }
- return (-1);
- }
-
- int isEnemyY(Point p) {
- int offset = reapercrouching ? REAPERCROUCHOFFSET : REAPEROFFSET;
- for (int i = 0; i < preyNumber; i++) {
- if (!preyDead[i] && ((p.y + offset <= preyPositions[i].y + preySize[preyType[i]])
- && (p.y + REAPERHEIGHT) >= preyPositions[i].y))
- return (i);
- }
- return (-1);
- }
-
- int randomMove() {
- // return + or - value (randomly)
- if (Math.random() >= 0.5)
- return (24);
- else
- return (-24);
- }
-
- private synchronized void incKeysDown(int whichone) {
- keysdown[whichone] = 1;
- }
-
- private synchronized void decKeysDown(int whichone) {
- keysdown[whichone] = 0;
- }
-
- // this class will use just the key pressed event
- @Override
- public void keyPressed(KeyEvent e) {
- if (e.getKeyCode() == KeyEvent.VK_F1) {
- displayStatus();
- }
- if (ingame) {
- if (!(e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))) {
-
- // valid move: move the player and then move the prey
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- reapercrouching = true;
- incKeysDown(DOWNDOWN);
- setSomethingChangedSinceRepaint(true);
- } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- incKeysDown(LEFTDOWN);
- leftPressed(false);
- setSomethingChangedSinceRepaint(true);
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- incKeysDown(RIGHTDOWN);
- rightPressed(false);
- setSomethingChangedSinceRepaint(true);
- } else if (e.getKeyCode() == KeyEvent.VK_SPACE) {
- if (!jumping) {
- startPosY = playerPosition.y;
- jumping = true;
- onTheWayUp = true;
- setSomethingChangedSinceRepaint(true);
- }
- }
- if (somethingChangedSinceRepaint) {
- area.repaint();
- }
- } // if valid key press
- } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
- if (level == MAXLEVEL || dead)
- doLevel(level);
- else
- doLevel(++level);
- page = 0;
- area.repaint();
- }
- }
-
- /* synchronized */ void setSomethingChangedSinceRepaint(boolean val) {
- somethingChangedSinceRepaint = val;
- }
-
- void leftPressed(boolean skid) {
- if (!reapercrouching) {
- // if Hero was facing right, turn him left
- if (!reaperleft)
- faceLeft();
- else {
- // if the target position is not occupied by a obstacle...
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstaclePosition(new Point(playerPosition.x - XAMOUNT, playerPosition.y), true))
- return; // can't move
- }
- playerPosition.x -= XAMOUNT;
- if (!skid)
- incrementHeroImage();
- }
- }
- }
-
- void rightPressed(boolean skid) {
- if (!reapercrouching) {
- if ((playerPosition.x + SPACE_FROM_X_TO_REAPER) >= (warpzone.x + 4)) {
- // level complete!
- ingame = false;
- } else {
- // if Hero was facing left, turn him right
- if (reaperleft)
- faceRight();
- else {
- for (int i = 0; i < obstacleNumber; i++) {
- if (isObstaclePosition(new Point(playerPosition.x + XAMOUNT, playerPosition.y), true))
- return; // can't move
- }
- playerPosition.x += XAMOUNT;
- // System.out.println("Reaper's x position is " + playerPosition.x);
- if (!skid)
- incrementHeroImage();
- }
- }
- }
- }
-
- boolean anythingVisibleChanged() {
- return (somethingChangedSinceRepaint);
- }
-
- @Override
- public void run() {
- boolean odd = true; // only change piranha image every other cycle
- while (true) {
- if (juststarted) {
- try {
- Thread.sleep(750);
- } catch (Exception e) {
- }
- area.repaint();
- juststarted = false;
- }
- try {
- Thread.sleep(DELAY);
- } catch (InterruptedException e) {
- }
- if (ingame) {
- if (keysdown[LEFTDOWN] == 0 && keysdown[RIGHTDOWN] == 0 && keysdown[DOWNDOWN] == 0)
- standStill();
-
- if (keysdown[LEFTDOWN] > 0) {
- leftPressed(false);
- setSomethingChangedSinceRepaint(true);
- } else if (keysdown[RIGHTDOWN] > 0) {
- rightPressed(false);
- setSomethingChangedSinceRepaint(true);
- }
-
- if (!odd) {
- // for each obstacle, cycle through the piranha pictures
- for (int i = 0; i < obstacleNumber; i++) {
- if (piranhaPopping[i]) {
- incrementObstacleImage(i);
- if (isVisibleObstacle(i))
- setSomethingChangedSinceRepaint(true);
- }
- }
- }
- odd = !odd;
-
- // for each prey, move the prey in the direction it was going
- for (int i = 0; i < preyNumber; i++) {
- // TODO if there is a fatal obstacle at that position, fall into it and
- // decrement count of prey
- // and set that prey's position to -1, -1
- /*
- * if (isObstaclePosition(preyPositions[i])) {
- * System.out.println("A prey fell into a obstacle");
- *
- * preyPositions[i] = new Point(-1, -1); preyRemaining--;
- * System.out.println(preyNumber-preyRemaining + " down, " + preyRemaining +
- * " to go..."); }
- */
- // if there is a non-fatal obstacle
- if (isObstaclePosition(preyPositions[i], false)) {
- // change direction
- changeDirection(i);
- if (isVisibleEnemy(i))
- setSomethingChangedSinceRepaint(true);
- }
- if (!preyDead[i]) {
- preyPositions[i] = move(i, preyPositions[i], preyDirection[i], odd);
- if (isVisibleEnemy(i))
- setSomethingChangedSinceRepaint(true);
- }
-
- // if player is caught by a prey, end the game
- int preyno = isEnemyPosition(playerPosition);
- if (preyno > -1) {
- int NEEDTOBEABOVE = preyPositions[preyno].y + preyTopSpace[preyno] - REAPERHEIGHT;
- if (easymode)
- NEEDTOBEABOVE = preyPositions[preyno].y - preyHeight[preyType[preyno]];
- if ((!onTheWayUp && (playerPosition.y <= NEEDTOBEABOVE))) {
- // player may have squished an prey
- preyDead[preyno] = true;
- preyDie(preyno);
- // player bounces
- bouncing = true;
- startPosY = playerPosition.y;
- setSomethingChangedSinceRepaint(true);
- } else {
- int offset = reapercrouching ? REAPERCROUCHOFFSET : REAPEROFFSET;
- if (playerPosition.y > NEEDTOBEABOVE && (playerPosition.y
- + offset <= preyPositions[preyno].y + preySize[preyType[preyno]])) {
- die();
- setSomethingChangedSinceRepaint(true);
- }
- }
- }
- }
- if (!dead) {
- if (onTheWayUp) {
- if (playerPosition.y > startPosY - JUMPAMOUNT) {
- playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
- setSomethingChangedSinceRepaint(true);
- } else {
- onTheWayUp = false;
- }
- } else if (bouncing) {
- if (playerPosition.y > startPosY - BOUNCEAMOUNT) {
- playerPosition = new Point(playerPosition.x, playerPosition.y - RISEAMOUNT);
- setSomethingChangedSinceRepaint(true);
- } else {
- bouncing = false;
- wasbouncing = true;
- }
- } else {
- int obstacleno = isObstacleX(playerPosition, true);
- if (obstacleno == -1) { // no obstacle at this position
- if (!onTheWayUp && !bouncing) {
- if (playerPosition.y < startPosY) {
- playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
- wasbouncing = false;
- setSomethingChangedSinceRepaint(true);
- } else
- jumping = false;
- }
- } else {
- Point obstaclepos = obstaclePositions[obstacleno];
- // if reaper's y position <= obstacle's height
- int thisObstacleHeight = isTall[obstacleno] ? OBSTACLEHEIGHT + TALLOBSTACLEDIFF
- : OBSTACLEHEIGHT;
- if (playerPosition.y <= (obstaclepos.y - thisObstacleHeight) && // can't land on the
- // obstacle if just < (??!)
- (playerPosition.y + FALLAMOUNT >= (obstaclepos.y - thisObstacleHeight))) {
- // allow reaper to land on the obstacle
- jumping = false;
- if (playerPosition.y != obstaclepos.y - thisObstacleHeight)
- setSomethingChangedSinceRepaint(true);
- playerPosition = new Point(playerPosition.x, obstaclepos.y - thisObstacleHeight);
- // if the piranha was up, Hero dies
- if (obstacleImages[obstacleImageNo[obstacleno]] != area.obstacle) {
- die();
- } else {
- // otherwise stop this Piranha
- piranhaPopping[obstacleno] = false;
- }
- } else {
- if (!onTheWayUp && !bouncing) {
- if (playerPosition.y < startPosY) {
- setSomethingChangedSinceRepaint(true);
- playerPosition = new Point(playerPosition.x, playerPosition.y + FALLAMOUNT);
- wasbouncing = false;
- } else
- jumping = false;
- }
- }
- }
- }
- if (!dead) {
- checkIfBlockingObstacle(playerPosition);
- if (playerPosition.y > GROUNDLEVEL)
- playerPosition.y = GROUNDLEVEL;
- }
- if (anythingVisibleChanged()) {
- area.repaint();
- }
- } else {
- if (!area.showingMessage)
- area.repaint();
- }
- }
- }
- }
-
- boolean isVisibleObstacle(int i) {
- // TODO - this probably needs fixing when obstacle is near page boundary
- return ((obstaclePositions[i].x >= page * PAGEWIDTH) && (obstaclePositions[i].x < (page + 1) * PAGEWIDTH));
- }
-
- boolean isVisibleEnemy(int i) {
- // TODO - this probably needs fixing when prey is near page boundary
- return ((preyPositions[i].x >= page * PAGEWIDTH) && (preyPositions[i].x < (page + 1) * PAGEWIDTH)
- && !preyDead[i]);
- }
-
- void changeDirection(int preyno) {
- if (preyDirection[preyno] == LEFT) {
- preyFaceRight(preyno);
- } else {
- preyFaceLeft(preyno);
- }
- }
-
- synchronized void die() {
- System.out.println("The Player is dead. Press the Enter key to restart the level");
- ingame = false;
- dead = true;
- displayStatus();
- }
-
- synchronized void incrementObstacleImage(int i) {
- obstacleImageNo[i]++;
- if (obstacleImageNo[i] == OBSTACLEIMAGES)
- obstacleImageNo[i] = 0;
- }
-
- synchronized void incrementHeroImage() {
- reaperImageNo++;
- if (reaperImageNo == HEROIMAGES)
- reaperImageNo = 0;
- }
-
- synchronized void incrementEnemyImage(int i) {
- preyImageNo[i]++;
- if (preyImageNo[i] > (PREYIMAGES - 2))
- preyImageNo[i] = 0;
- }
-
- Point move(int preyNo, Point start, int direction, boolean odd) {
- if (odd)
- incrementEnemyImage(preyNo);
- if (direction == LEFT) {
- return (new Point(start.x - preyMove[preyType[preyNo]], start.y));
- } else {
- return (new Point(start.x + preyMove[preyType[preyNo]], start.y));
- }
- }
-
- @Override
- public void keyReleased(KeyEvent e) {
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- reapercrouching = false;
- decKeysDown(DOWNDOWN);
- } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- decKeysDown(LEFTDOWN);
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- decKeysDown(RIGHTDOWN);
- }
- }
-
- public void keyTyped(KeyEvent e) {
- }
-
- synchronized Image getHeroImage() {
- return (reaperImages[reaperImageNo]);
- }
-
- synchronized Image getObstacleImage(int obstaclenum) {
- return (obstacleImages[obstacleImageNo[obstaclenum]]);
- }
-
- synchronized Image getEnemyImage(int preyno) {
- return (preyImage[preyno][preyImageNo[preyno]]);
- }
-
- void displayStatus() {
- /*
- * // when a certain F Key is pressed, display positions of Reaper, // all
- * obstacles and all prey and the end flag (warp zone)
- * System.out.println("--------"); System.out.println("Reaper is " + (dead?
- * "dead" : "alive")); if (dead) { int preyno = isEnemyPosition(playerPosition);
- * System.out.println("Reaper was killed by prey " + preyno); }
- * System.out.println("In game is " + ingame); System.out.println("Reaper is " +
- * (onTheWayUp? "on the way up" : "not on the way up"));
- * System.out.println("Reaper's position is (" + playerPosition.x + ", " +
- * playerPosition.y + ")");
- * System.out.println("Reaper's visible left, bottom co-ordinates are " +
- * (playerPosition.x + 55) + " and " + (playerPosition.y + REAPERHEIGHT));
- * System.out.println("Reaper is on page " + page +
- * " (which shows x positions from " + (page*PAGEWIDTH) + " to " +
- * ((page+1)*PAGEWIDTH) + ")"); System.out.println("Screen bounds are (" +
- * getBounds().width + ", " + getBounds().height + ")"); System.out.println("");
- * for (int prey=0; prey < preyNumber; prey++) { System.out.println("Enemy " +
- * prey + " is " + preyTypeString(preyType[prey]) + " and is " + (preyDead[prey]
- * ? " " : "not ") + "dead"); System.out.println("Enemy " + prey +
- * " is at position (" + preyPositions[prey].x + ", " +
- * preyPositions[prey].y+") and has size " + preySize[preyType[prey]]); }
- * //System.out.println(""); //for (int obstacle=0; obstacle < obstacleNumber;
- * obstacle++) { // System.out.println("Obstacle " + obstacle +
- * " is at position (" + obstaclePositions[obstacle].x + // ", " +
- * obstaclePositions[obstacle].y+")"); //} System.out.println("");
- * System.out.println("The warp zone is positioned at (" + warpzone.x + ", " +
- * warpzone.y + ")"); System.out.println("========");
- */
- }
-
- String preyTypeString(int fortype) {
- switch (fortype) {
- case RUNNER:
- return ("RUNNER");
- default:
- return ("Unknown type (" + fortype + ")");
- }
- }
-
- void changePageIfNecessary() {
- if (playerPosition.x == LEFTEDGE)
- return;
- if ((playerPosition.x + SPACE_FROM_X_TO_REAPER) > (page * PAGEWIDTH + RIGHTEDGE - XAMOUNT)) {
- // System.out.println("Change page up: (" + playerPosition.x+ "+" +
- // SPACE_FROM_X_TO_REAPER+ ") > (" + page+ "*" + PAGEWIDTH + "+" + RIGHTEDGE +
- // "-" + XAMOUNT + ")");
- page++;
- } else if ((playerPosition.x + SPACE_FROM_X_TO_REAPER) - (page * PAGEWIDTH) < (LEFTEDGE + XAMOUNT)) {
- // System.out.println("Change page down: (" + playerPosition.x+ "+" +
- // SPACE_FROM_X_TO_REAPER+ ")-(" + page+ "*" + PAGEWIDTH + ") < (" + LEFTEDGE+
- // "+" + XAMOUNT+")");
- page--;
- }
- }
-}
diff --git a/Tank/src/Tank.java b/Tank/src/Tank.java
@@ -0,0 +1,439 @@
+import java.awt.Color;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.JFrame;
+
+/* Copyright (c) Mary Percival 2002 */
+/* Tank game Created October 2002 */
+
+public class Tank extends JFrame implements KeyListener, Runnable {
+ private static final long serialVersionUID = 2750159877444817519L;
+ // all member variables 'static' because shared with the enemy action thread
+ private static TankArea area;
+ private static boolean ingame = false;
+ private boolean juststarted = false;
+ private static int level = 1;
+ private static int enemiesRemaining;
+ protected static Point[] enemyPositions;
+ protected static Point playerPosition;
+ protected static Point[] pitPositions;
+ private static Thread enemies;
+
+ protected static int pitNumber = 15;
+ protected static int enemyNumber = 1;
+ protected static int RIGHTEDGE = 1200;
+ protected static final int LEFTEDGE = 0;
+ protected static final int TOPEDGE = 0;
+ protected static int BOTTOMEDGE = 1000;
+ protected static int XAMOUNT = 5;
+ protected static int YAMOUNT = 5;
+ private static final int X = 1;
+ private static final int Y = 2;
+ private static final int NOT = 3;
+ private static final int DELAY = 125;
+ protected int explosionx = -1, explosiony = -1;
+
+ // tank game stuff
+ boolean up = true, down = false, left = false, right = false, shooting = false;
+ static int NOTSHOOTING = 0;
+ static int SHOOTING = 1;
+ static int FIRSTUP = 0;
+ static int FIRSTDOWN = 2;
+ static int FIRSTLEFT = 4;
+ static int FIRSTRIGHT = 6;
+ int goodImageNo = FIRSTUP; // TODO - randomise
+ int[] enemyImageNo;
+ boolean[] enemyShooting;
+ Image[][] goodImages = new Image[8][2]; // up up2 down down2 left left2 right right2 x SHOOTING and NON_SHOOTING
+ Image[][] badImages = new Image[8][2]; // up up2 down down2 left left2 right right2 x SHOOTING and NON_SHOOTING
+
+ public static void main(String[] args) {
+ Tank Tank = new Tank();
+ Tank.setLayout(null);
+ Tank.setBackground(Color.gray);
+ Tank.setSize(RIGHTEDGE, BOTTOMEDGE);
+
+ area = new TankArea(Tank);
+ Tank.add(area);
+ //RIGHTEDGE = Tank.getBounds().width - 1;
+ //BOTTOMEDGE = Tank.getBounds().height - 1;
+ XAMOUNT = 12;
+ YAMOUNT = 12;
+ Tank.setVisible(true);
+ area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
+ area.setVisible(true);
+
+ Tank.addKeyListener(Tank);
+ area.addKeyListener(Tank);
+ area.requestFocus();
+
+ Tank.goodImages[FIRSTUP][NOTSHOOTING] = area.tankup;
+ Tank.goodImages[FIRSTUP + 1][NOTSHOOTING] = area.tankup2;
+ Tank.goodImages[FIRSTUP][SHOOTING] = area.tankupshoot;
+ Tank.goodImages[FIRSTUP + 1][SHOOTING] = area.tankupshoot2;
+
+ Tank.goodImages[FIRSTDOWN][NOTSHOOTING] = area.tankdown;
+ Tank.goodImages[FIRSTDOWN + 1][NOTSHOOTING] = area.tankdown2;
+ Tank.goodImages[FIRSTDOWN][SHOOTING] = area.tankdownshoot;
+ Tank.goodImages[FIRSTDOWN + 1][SHOOTING] = area.tankdownshoot2;
+
+ Tank.goodImages[FIRSTLEFT][NOTSHOOTING] = area.tankleft;
+ Tank.goodImages[FIRSTLEFT + 1][NOTSHOOTING] = area.tankleft2;
+ Tank.goodImages[FIRSTLEFT][SHOOTING] = area.tankleftshoot;
+ Tank.goodImages[FIRSTLEFT + 1][SHOOTING] = area.tankleftshoot2;
+
+ Tank.goodImages[FIRSTRIGHT][NOTSHOOTING] = area.tankright;
+ Tank.goodImages[FIRSTRIGHT + 1][NOTSHOOTING] = area.tankright2;
+ Tank.goodImages[FIRSTRIGHT][SHOOTING] = area.tankrightshoot;
+ Tank.goodImages[FIRSTRIGHT + 1][SHOOTING] = area.tankrightshoot2;
+
+ Tank.badImages[FIRSTUP][NOTSHOOTING] = area.badtankup;
+ Tank.badImages[FIRSTUP + 1][NOTSHOOTING] = area.badtankup2;
+ Tank.badImages[FIRSTUP][SHOOTING] = area.badtankupshoot;
+ Tank.badImages[FIRSTUP + 1][SHOOTING] = area.badtankupshoot2;
+
+ Tank.badImages[FIRSTDOWN][NOTSHOOTING] = area.badtankdown;
+ Tank.badImages[FIRSTDOWN + 1][NOTSHOOTING] = area.badtankdown2;
+ Tank.badImages[FIRSTDOWN][SHOOTING] = area.badtankdownshoot;
+ Tank.badImages[FIRSTDOWN + 1][SHOOTING] = area.badtankdownshoot2;
+
+ Tank.badImages[FIRSTLEFT][NOTSHOOTING] = area.badtankleft;
+ Tank.badImages[FIRSTLEFT + 1][NOTSHOOTING] = area.badtankleft2;
+ Tank.badImages[FIRSTLEFT][SHOOTING] = area.badtankleftshoot;
+ Tank.badImages[FIRSTLEFT + 1][SHOOTING] = area.badtankleftshoot2;
+
+ Tank.badImages[FIRSTRIGHT][NOTSHOOTING] = area.badtankright;
+ Tank.badImages[FIRSTRIGHT + 1][NOTSHOOTING] = area.badtankright2;
+ Tank.badImages[FIRSTRIGHT][SHOOTING] = area.badtankrightshoot;
+ Tank.badImages[FIRSTRIGHT + 1][SHOOTING] = area.badtankrightshoot2;
+
+ enemies = new Thread(Tank);
+ enemies.start();
+ }
+
+ public void doLevel(int level) {
+ // this runs one 'level'
+ // create arrays of pits and enemies here.
+ // Maybe each level will have different numbers?
+ juststarted = true;
+ Point temppoint;
+ pitPositions = new Point[pitNumber];
+ enemyPositions = new Point[enemyNumber];
+ for (int i = 0; i < enemyNumber; i++)
+ enemyPositions[i] = new Point(0, 0);
+ for (int i = 0; i < pitNumber; i++)
+ pitPositions[i] = new Point(0, 0);
+
+ enemyImageNo = new int[enemyNumber];
+ enemyShooting = new boolean[enemyNumber];
+ for (int i = 0; i < enemyNumber; i++) {
+ enemyShooting[i] = false;
+ enemyImageNo[i] = FIRSTUP; // TODO - randomise
+ }
+ System.out.println("Started level " + level + ": " + enemyNumber + " enemies and " + pitNumber + " pits");
+
+ // randomly position 1 player, x enemies and y pits
+ playerPosition = randomPosition();
+
+ for (int i = 0; i < enemyNumber; i++) {
+ temppoint = randomPosition();
+ while (isPlayerPosition(temppoint) || isTankPosition(temppoint)) {
+ // don't position any enemy on the player or on top of another enemy
+ temppoint = randomPosition();
+ }
+ enemyPositions[i] = temppoint;
+ }
+
+ for (int i = 0; i < pitNumber; i++) {
+ temppoint = randomPosition();
+ while (isPlayerPosition(temppoint) || isPitPosition(temppoint) || isTankPosition(temppoint)) {
+ // don't position any enemy at the player, an enemy or another pit
+ temppoint = randomPosition();
+ }
+ pitPositions[i] = temppoint;
+ }
+
+ enemiesRemaining = enemyNumber;
+ // paint the panel here
+ area.repaint();
+ ingame = true;
+ }
+
+ synchronized void incrementImageNo() {
+ goodImageNo++;
+ if ((goodImageNo % 2) == 0)
+ goodImageNo -= 2;
+ }
+
+ synchronized void incrementImageNo(int enemyNo) {
+ enemyImageNo[enemyNo]++;
+ if ((enemyImageNo[enemyNo] % 2) == 0)
+ enemyImageNo[enemyNo] -= 2;
+ }
+
+ void goLeft(int enemyno) {
+ if (enemyImageNo[enemyno] == FIRSTLEFT || enemyImageNo[enemyno] == FIRSTLEFT + 1) {
+ incrementImageNo(enemyno);
+ } else
+ enemyImageNo[enemyno] = FIRSTLEFT;
+ }
+
+ void goLeft() {
+ if (goodImageNo == FIRSTLEFT || goodImageNo == FIRSTLEFT + 1) {
+ incrementImageNo();
+ } else
+ goodImageNo = FIRSTLEFT;
+ }
+
+ void goRight(int enemyno) {
+ if (enemyImageNo[enemyno] == FIRSTRIGHT || enemyImageNo[enemyno] == FIRSTRIGHT + 1) {
+ incrementImageNo(enemyno);
+ } else
+ enemyImageNo[enemyno] = FIRSTRIGHT;
+ }
+
+ void goRight() {
+ if (goodImageNo == FIRSTRIGHT || goodImageNo == FIRSTRIGHT + 1) {
+ incrementImageNo();
+ } else
+ goodImageNo = FIRSTRIGHT;
+ }
+
+ void goUp(int enemyno) {
+ if (enemyImageNo[enemyno] == FIRSTUP || enemyImageNo[enemyno] == FIRSTUP + 1) {
+ incrementImageNo(enemyno);
+ } else
+ enemyImageNo[enemyno] = FIRSTUP;
+ }
+
+ void goUp() {
+ if (goodImageNo == FIRSTUP || goodImageNo == FIRSTUP + 1) {
+ incrementImageNo();
+ } else
+ goodImageNo = FIRSTUP;
+ }
+
+ void goDown(int enemyno) {
+ if (enemyImageNo[enemyno] == FIRSTDOWN || enemyImageNo[enemyno] == FIRSTDOWN + 1) {
+ incrementImageNo(enemyno);
+ } else
+ enemyImageNo[enemyno] = FIRSTDOWN;
+ }
+
+ void goDown() {
+ if (goodImageNo == FIRSTDOWN || goodImageNo == FIRSTDOWN + 1) {
+ incrementImageNo();
+ } else
+ goodImageNo = FIRSTDOWN;
+ }
+
+ private Point randomPosition() {
+ return new Point((int) (Math.random() * RIGHTEDGE) / XAMOUNT * XAMOUNT,
+ (int) (Math.random() * BOTTOMEDGE) / YAMOUNT * YAMOUNT);
+ }
+
+ private boolean isPlayerPosition(Point p) {
+ return (p.x == playerPosition.x && p.y == playerPosition.y);
+ }
+
+ private boolean isTankPosition(Point p) {
+ for (int i = 0; i < enemyNumber; i++) {
+ if (p.x == enemyPositions[i].x && p.y == enemyPositions[i].y)
+ return (true);
+ }
+ return (false);
+ }
+
+ private int isInline(Point p) {
+ // is the new position in the same row as the player?
+ if (Math.abs(p.x - playerPosition.x) < XAMOUNT) {
+ // see whether there is another enemy between this position and the player
+ if (playerPosition.y > p.y) {
+ for (int i = 0; i < enemyNumber; i++) {
+ if (p.x == enemyPositions[i].x && p.y < enemyPositions[i].y)
+ return (X);
+ }
+ } else { // playerPosition y < p.y
+ for (int i = 0; i < enemyNumber; i++) {
+ if (p.x == enemyPositions[i].x && p.y > enemyPositions[i].y)
+ return (X);
+ }
+ }
+ } else if (Math.abs(p.y - playerPosition.y) < YAMOUNT) {
+ // see whether there is another enemy between this position and the player
+ if (playerPosition.x > p.x) {
+ for (int i = 0; i < enemyNumber; i++) {
+ if (p.y == enemyPositions[i].y && p.x < enemyPositions[i].x)
+ return (Y);
+ }
+ } else { // playerPosition x < p.x
+ for (int i = 0; i < enemyNumber; i++) {
+ if (p.y == enemyPositions[i].y && p.x > enemyPositions[i].x)
+ return (Y);
+ }
+ }
+ }
+ return (NOT);
+ }
+
+ private boolean isPitPosition(Point p) {
+ for (int i = 0; i < pitNumber; i++) {
+ if (p.x == pitPositions[i].x && p.y == pitPositions[i].y)
+ return (true);
+ }
+ return (false);
+ }
+
+ private Point moveCloser(int enemyNo, Point original, Point target) {
+ Point result = new Point(original);
+ int inlineType = isInline(original);
+ // allowed to move EITHER X or Y but not both
+ if (Math.random() >= 0.5) {
+ // move in X direction
+ if (inlineType != X) {
+ if (original.x < target.x) {
+ result.x = original.x + (XAMOUNT / 2);
+ goRight(enemyNo);
+ } else if (original.x > target.x) {
+ result.x = original.x - (XAMOUNT / 2);
+ goLeft(enemyNo);
+ }
+ }
+ } else {
+ // move in Y direction
+ if (inlineType != Y) {
+ if (original.y < target.y) {
+ result.y = original.y + (YAMOUNT / 2);
+ goDown(enemyNo);
+ } else if (original.y > target.y) {
+ result.y = original.y - (YAMOUNT / 2);
+ goUp(enemyNo);
+ }
+ }
+ }
+ /*
+ * if (isTankPosition(result)) { if (isTankPosition(new Point(result.x,
+ * original.y))) { if (isTankPosition(new Point(original.x, result.y))) result =
+ * original; else result = new Point(original.x, result.y); } else result = new
+ * Point(result.x, original.y); }
+ */
+ inlineType = isInline(result);
+ if (inlineType == X) {
+ // fire along the X axis
+ } else if (inlineType == Y) {
+ // fire along the Y axis
+ }
+ return (result);
+ }
+
+ /*
+ * private int randomMove() { // return + or - value (randomly) if
+ * (Math.random() >= 0.5) return(24); else return(-24); }
+ */
+
+ // this class will use just the key pressed event
+ @Override
+ public void keyPressed(KeyEvent e) {
+ if (ingame) {
+ if (!((e.getKeyCode() == KeyEvent.VK_DOWN && playerPosition.y >= (BOTTOMEDGE - YAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_UP && playerPosition.y <= (TOPEDGE + YAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_RIGHT && playerPosition.x >= (RIGHTEDGE - XAMOUNT)))) {
+ // valid move: move the player and then move the enemies
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ playerPosition.y += YAMOUNT;
+ goDown();
+ } else if (e.getKeyCode() == KeyEvent.VK_UP) {
+ playerPosition.y -= YAMOUNT;
+ goUp();
+ } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ playerPosition.x -= XAMOUNT;
+ goLeft();
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ playerPosition.x += XAMOUNT;
+ goRight();
+ }
+ if (isTankPosition(playerPosition)) {
+ System.out.println("The Player ran into an enemy!! Press the Enter key to restart the level");
+ ingame = false;
+ }
+ if (isPitPosition(playerPosition)) {
+ System.out.println("The Player ran into a pit!! Press the Enter key to restart the level");
+ ingame = false;
+ }
+ area.repaint();
+ } // if valid key press
+ } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+ doLevel(level++);
+ }
+ }
+
+ @Override
+ public void run() {
+ while (true) {
+ if (juststarted) {
+ try {
+ Thread.sleep(750);
+ } catch (Exception e) {
+ }
+ juststarted = false;
+ }
+ try {
+ Thread.sleep(DELAY);
+ } catch (InterruptedException e) {
+ }
+ if (ingame) {
+ // for each enemy, move the enemy closer to the player
+ for (int i = 0; i < enemyPositions.length; i++) {
+ if (!deadTank(enemyPositions[i])) {
+ enemyPositions[i] = moveCloser(i, enemyPositions[i], playerPosition);
+ }
+ // if there is a pit at that position, fall into it and decrement count of
+ // enemies
+ // and set that enemy's position to -1, -1
+ if (isPitPosition(enemyPositions[i])) {
+ System.out.println("an enemy fell into a pit");
+ explosionx = enemyPositions[i].x;
+ explosiony = enemyPositions[i].y;
+
+ enemyPositions[i] = new Point(-1, -1);
+ enemiesRemaining--;
+ System.out.println(enemyNumber - enemiesRemaining + " down, " + enemiesRemaining + " to go...");
+ }
+ // if player is caught by an enemy or all enemies are gone, end the game
+ if (isPlayerPosition(enemyPositions[i])) {
+ System.out.println(
+ "\"Mmm! Brains...\". The Player is dead. Press the Enter key to restart the level");
+ level--; // because it will be incremented in a minute and we want to stay on the same
+ // 'level'
+ ingame = false;
+ }
+ }
+ if (enemiesRemaining == 0) {
+ System.out.println(
+ "All the enemies are gone -- you won!! Press the Enter key to start the next level");
+ enemyNumber++;
+ if (pitNumber > 2)
+ pitNumber--;
+ ingame = false;
+ } else
+ area.repaint();
+ }
+ }
+ }
+
+ private boolean deadTank(Point p) {
+ return (p.x == -1 && p.y == -1);
+ }
+
+ @Override
+ public void keyReleased(KeyEvent e) {
+ }
+
+ @Override
+ public void keyTyped(KeyEvent e) {
+ }
+}
diff --git a/Tank/src/TankArea.java b/Tank/src/TankArea.java
@@ -11,7 +11,7 @@ import javax.swing.JPanel;
public class TankArea extends JPanel {
private static final long serialVersionUID = -2906196036928924340L;
- TankGame myApplet = null;
+ Tank myApplet = null;
Image badtankdown2;
Image badtankdownshoot;
@@ -52,7 +52,7 @@ public class TankArea extends JPanel {
private Image explosion1, explosion2, explosion3;
MediaTracker mt = null;
- public TankArea(TankGame parent) {
+ public TankArea(Tank parent) {
myApplet = parent;
enemyImage = load(myApplet, "bad-tank-up.gif");
personImage = load(myApplet, "tank-up.gif");
@@ -94,7 +94,7 @@ public class TankArea extends JPanel {
tankup = load(myApplet, "tank-up.gif");
}
- Image load(TankGame parent, String picture) {
+ Image load(Tank parent, String picture) {
try {
Image im = ImageIO.read(new File("../Assets/" + picture));
checkImage(im, picture);
@@ -131,24 +131,24 @@ public class TankArea extends JPanel {
g.fillRect(0, 0, w, h);
g.setColor(Color.black);
- if (TankGame.playerPosition != null) {
+ if (Tank.playerPosition != null) {
// show the player
// g.drawString("#", myApplet.playerPosition.x, myApplet.playerPosition.y);
- int elem = myApplet.shooting ? myApplet.SHOOTING : myApplet.NOTSHOOTING;
- g.drawImage(myApplet.goodImages[myApplet.goodImageNo][elem], TankGame.playerPosition.x,
- TankGame.playerPosition.y, Color.gray, null);
+ int elem = myApplet.shooting ? Tank.SHOOTING : Tank.NOTSHOOTING;
+ g.drawImage(myApplet.goodImages[myApplet.goodImageNo][elem], Tank.playerPosition.x,
+ Tank.playerPosition.y, Color.gray, null);
// show the pits
- for (int i = 0; i < TankGame.pitPositions.length; i++) {
- g.drawImage(pitImage, TankGame.pitPositions[i].x, TankGame.pitPositions[i].y, Color.gray, null);
+ for (int i = 0; i < Tank.pitPositions.length; i++) {
+ g.drawImage(pitImage, Tank.pitPositions[i].x, Tank.pitPositions[i].y, Color.gray, null);
}
// show the enemies
- for (int i = 0; i < TankGame.enemyPositions.length; i++) {
- if (TankGame.enemyPositions[i].x > -1) {
- int eelem = myApplet.enemyShooting[i] ? myApplet.SHOOTING : myApplet.NOTSHOOTING;
- g.drawImage(myApplet.badImages[myApplet.enemyImageNo[i]][eelem], TankGame.enemyPositions[i].x,
- TankGame.enemyPositions[i].y, null);
+ for (int i = 0; i < Tank.enemyPositions.length; i++) {
+ if (Tank.enemyPositions[i].x > -1) {
+ int eelem = myApplet.enemyShooting[i] ? Tank.SHOOTING : Tank.NOTSHOOTING;
+ g.drawImage(myApplet.badImages[myApplet.enemyImageNo[i]][eelem], Tank.enemyPositions[i].x,
+ Tank.enemyPositions[i].y, null);
}
}
if (myApplet.explosionx != -1) {
diff --git a/Tank/src/TankGame.java b/Tank/src/TankGame.java
@@ -1,439 +0,0 @@
-import java.awt.Color;
-import java.awt.Image;
-import java.awt.Point;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-
-import javax.swing.JFrame;
-
-/* Copyright (c) Mary Percival 2002 */
-/* Tank game Created October 2002 */
-
-public class TankGame extends JFrame implements KeyListener, Runnable {
- private static final long serialVersionUID = 2750159877444817519L;
- // all member variables 'static' because shared with the enemy action thread
- private static TankArea area;
- private static boolean ingame = false;
- private boolean juststarted = false;
- private static int level = 1;
- private static int enemiesRemaining;
- protected static Point[] enemyPositions;
- protected static Point playerPosition;
- protected static Point[] pitPositions;
- private static Thread enemies;
-
- protected static int pitNumber = 15;
- protected static int enemyNumber = 1;
- protected static int RIGHTEDGE = 1200;
- protected static final int LEFTEDGE = 0;
- protected static final int TOPEDGE = 0;
- protected static int BOTTOMEDGE = 1000;
- protected static int XAMOUNT = 5;
- protected static int YAMOUNT = 5;
- private static final int X = 1;
- private static final int Y = 2;
- private static final int NOT = 3;
- private static final int DELAY = 125;
- protected int explosionx = -1, explosiony = -1;
-
- // tank game stuff
- boolean up = true, down = false, left = false, right = false, shooting = false;
- static int NOTSHOOTING = 0;
- static int SHOOTING = 1;
- static int FIRSTUP = 0;
- static int FIRSTDOWN = 2;
- static int FIRSTLEFT = 4;
- static int FIRSTRIGHT = 6;
- int goodImageNo = FIRSTUP; // TODO - randomise
- int[] enemyImageNo;
- boolean[] enemyShooting;
- Image[][] goodImages = new Image[8][2]; // up up2 down down2 left left2 right right2 x SHOOTING and NON_SHOOTING
- Image[][] badImages = new Image[8][2]; // up up2 down down2 left left2 right right2 x SHOOTING and NON_SHOOTING
-
- public static void main(String[] args) {
- TankGame tankGame = new TankGame();
- tankGame.setLayout(null);
- tankGame.setBackground(Color.gray);
- tankGame.setSize(RIGHTEDGE, BOTTOMEDGE);
-
- area = new TankArea(tankGame);
- tankGame.add(area);
- //RIGHTEDGE = tankGame.getBounds().width - 1;
- //BOTTOMEDGE = tankGame.getBounds().height - 1;
- XAMOUNT = 12;
- YAMOUNT = 12;
- tankGame.setVisible(true);
- area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
- area.setVisible(true);
-
- tankGame.addKeyListener(tankGame);
- area.addKeyListener(tankGame);
- area.requestFocus();
-
- tankGame.goodImages[FIRSTUP][NOTSHOOTING] = area.tankup;
- tankGame.goodImages[FIRSTUP + 1][NOTSHOOTING] = area.tankup2;
- tankGame.goodImages[FIRSTUP][SHOOTING] = area.tankupshoot;
- tankGame.goodImages[FIRSTUP + 1][SHOOTING] = area.tankupshoot2;
-
- tankGame.goodImages[FIRSTDOWN][NOTSHOOTING] = area.tankdown;
- tankGame.goodImages[FIRSTDOWN + 1][NOTSHOOTING] = area.tankdown2;
- tankGame.goodImages[FIRSTDOWN][SHOOTING] = area.tankdownshoot;
- tankGame.goodImages[FIRSTDOWN + 1][SHOOTING] = area.tankdownshoot2;
-
- tankGame.goodImages[FIRSTLEFT][NOTSHOOTING] = area.tankleft;
- tankGame.goodImages[FIRSTLEFT + 1][NOTSHOOTING] = area.tankleft2;
- tankGame.goodImages[FIRSTLEFT][SHOOTING] = area.tankleftshoot;
- tankGame.goodImages[FIRSTLEFT + 1][SHOOTING] = area.tankleftshoot2;
-
- tankGame.goodImages[FIRSTRIGHT][NOTSHOOTING] = area.tankright;
- tankGame.goodImages[FIRSTRIGHT + 1][NOTSHOOTING] = area.tankright2;
- tankGame.goodImages[FIRSTRIGHT][SHOOTING] = area.tankrightshoot;
- tankGame.goodImages[FIRSTRIGHT + 1][SHOOTING] = area.tankrightshoot2;
-
- tankGame.badImages[FIRSTUP][NOTSHOOTING] = area.badtankup;
- tankGame.badImages[FIRSTUP + 1][NOTSHOOTING] = area.badtankup2;
- tankGame.badImages[FIRSTUP][SHOOTING] = area.badtankupshoot;
- tankGame.badImages[FIRSTUP + 1][SHOOTING] = area.badtankupshoot2;
-
- tankGame.badImages[FIRSTDOWN][NOTSHOOTING] = area.badtankdown;
- tankGame.badImages[FIRSTDOWN + 1][NOTSHOOTING] = area.badtankdown2;
- tankGame.badImages[FIRSTDOWN][SHOOTING] = area.badtankdownshoot;
- tankGame.badImages[FIRSTDOWN + 1][SHOOTING] = area.badtankdownshoot2;
-
- tankGame.badImages[FIRSTLEFT][NOTSHOOTING] = area.badtankleft;
- tankGame.badImages[FIRSTLEFT + 1][NOTSHOOTING] = area.badtankleft2;
- tankGame.badImages[FIRSTLEFT][SHOOTING] = area.badtankleftshoot;
- tankGame.badImages[FIRSTLEFT + 1][SHOOTING] = area.badtankleftshoot2;
-
- tankGame.badImages[FIRSTRIGHT][NOTSHOOTING] = area.badtankright;
- tankGame.badImages[FIRSTRIGHT + 1][NOTSHOOTING] = area.badtankright2;
- tankGame.badImages[FIRSTRIGHT][SHOOTING] = area.badtankrightshoot;
- tankGame.badImages[FIRSTRIGHT + 1][SHOOTING] = area.badtankrightshoot2;
-
- enemies = new Thread(tankGame);
- enemies.start();
- }
-
- public void doLevel(int level) {
- // this runs one 'level'
- // create arrays of pits and enemies here.
- // Maybe each level will have different numbers?
- juststarted = true;
- Point temppoint;
- pitPositions = new Point[pitNumber];
- enemyPositions = new Point[enemyNumber];
- for (int i = 0; i < enemyNumber; i++)
- enemyPositions[i] = new Point(0, 0);
- for (int i = 0; i < pitNumber; i++)
- pitPositions[i] = new Point(0, 0);
-
- enemyImageNo = new int[enemyNumber];
- enemyShooting = new boolean[enemyNumber];
- for (int i = 0; i < enemyNumber; i++) {
- enemyShooting[i] = false;
- enemyImageNo[i] = FIRSTUP; // TODO - randomise
- }
- System.out.println("Started level " + level + ": " + enemyNumber + " enemies and " + pitNumber + " pits");
-
- // randomly position 1 player, x enemies and y pits
- playerPosition = randomPosition();
-
- for (int i = 0; i < enemyNumber; i++) {
- temppoint = randomPosition();
- while (isPlayerPosition(temppoint) || isTankPosition(temppoint)) {
- // don't position any enemy on the player or on top of another enemy
- temppoint = randomPosition();
- }
- enemyPositions[i] = temppoint;
- }
-
- for (int i = 0; i < pitNumber; i++) {
- temppoint = randomPosition();
- while (isPlayerPosition(temppoint) || isPitPosition(temppoint) || isTankPosition(temppoint)) {
- // don't position any enemy at the player, an enemy or another pit
- temppoint = randomPosition();
- }
- pitPositions[i] = temppoint;
- }
-
- enemiesRemaining = enemyNumber;
- // paint the panel here
- area.repaint();
- ingame = true;
- }
-
- synchronized void incrementImageNo() {
- goodImageNo++;
- if ((goodImageNo % 2) == 0)
- goodImageNo -= 2;
- }
-
- synchronized void incrementImageNo(int enemyNo) {
- enemyImageNo[enemyNo]++;
- if ((enemyImageNo[enemyNo] % 2) == 0)
- enemyImageNo[enemyNo] -= 2;
- }
-
- void goLeft(int enemyno) {
- if (enemyImageNo[enemyno] == FIRSTLEFT || enemyImageNo[enemyno] == FIRSTLEFT + 1) {
- incrementImageNo(enemyno);
- } else
- enemyImageNo[enemyno] = FIRSTLEFT;
- }
-
- void goLeft() {
- if (goodImageNo == FIRSTLEFT || goodImageNo == FIRSTLEFT + 1) {
- incrementImageNo();
- } else
- goodImageNo = FIRSTLEFT;
- }
-
- void goRight(int enemyno) {
- if (enemyImageNo[enemyno] == FIRSTRIGHT || enemyImageNo[enemyno] == FIRSTRIGHT + 1) {
- incrementImageNo(enemyno);
- } else
- enemyImageNo[enemyno] = FIRSTRIGHT;
- }
-
- void goRight() {
- if (goodImageNo == FIRSTRIGHT || goodImageNo == FIRSTRIGHT + 1) {
- incrementImageNo();
- } else
- goodImageNo = FIRSTRIGHT;
- }
-
- void goUp(int enemyno) {
- if (enemyImageNo[enemyno] == FIRSTUP || enemyImageNo[enemyno] == FIRSTUP + 1) {
- incrementImageNo(enemyno);
- } else
- enemyImageNo[enemyno] = FIRSTUP;
- }
-
- void goUp() {
- if (goodImageNo == FIRSTUP || goodImageNo == FIRSTUP + 1) {
- incrementImageNo();
- } else
- goodImageNo = FIRSTUP;
- }
-
- void goDown(int enemyno) {
- if (enemyImageNo[enemyno] == FIRSTDOWN || enemyImageNo[enemyno] == FIRSTDOWN + 1) {
- incrementImageNo(enemyno);
- } else
- enemyImageNo[enemyno] = FIRSTDOWN;
- }
-
- void goDown() {
- if (goodImageNo == FIRSTDOWN || goodImageNo == FIRSTDOWN + 1) {
- incrementImageNo();
- } else
- goodImageNo = FIRSTDOWN;
- }
-
- private Point randomPosition() {
- return new Point((int) (Math.random() * RIGHTEDGE) / XAMOUNT * XAMOUNT,
- (int) (Math.random() * BOTTOMEDGE) / YAMOUNT * YAMOUNT);
- }
-
- private boolean isPlayerPosition(Point p) {
- return (p.x == playerPosition.x && p.y == playerPosition.y);
- }
-
- private boolean isTankPosition(Point p) {
- for (int i = 0; i < enemyNumber; i++) {
- if (p.x == enemyPositions[i].x && p.y == enemyPositions[i].y)
- return (true);
- }
- return (false);
- }
-
- private int isInline(Point p) {
- // is the new position in the same row as the player?
- if (Math.abs(p.x - playerPosition.x) < XAMOUNT) {
- // see whether there is another enemy between this position and the player
- if (playerPosition.y > p.y) {
- for (int i = 0; i < enemyNumber; i++) {
- if (p.x == enemyPositions[i].x && p.y < enemyPositions[i].y)
- return (X);
- }
- } else { // playerPosition y < p.y
- for (int i = 0; i < enemyNumber; i++) {
- if (p.x == enemyPositions[i].x && p.y > enemyPositions[i].y)
- return (X);
- }
- }
- } else if (Math.abs(p.y - playerPosition.y) < YAMOUNT) {
- // see whether there is another enemy between this position and the player
- if (playerPosition.x > p.x) {
- for (int i = 0; i < enemyNumber; i++) {
- if (p.y == enemyPositions[i].y && p.x < enemyPositions[i].x)
- return (Y);
- }
- } else { // playerPosition x < p.x
- for (int i = 0; i < enemyNumber; i++) {
- if (p.y == enemyPositions[i].y && p.x > enemyPositions[i].x)
- return (Y);
- }
- }
- }
- return (NOT);
- }
-
- private boolean isPitPosition(Point p) {
- for (int i = 0; i < pitNumber; i++) {
- if (p.x == pitPositions[i].x && p.y == pitPositions[i].y)
- return (true);
- }
- return (false);
- }
-
- private Point moveCloser(int enemyNo, Point original, Point target) {
- Point result = new Point(original);
- int inlineType = isInline(original);
- // allowed to move EITHER X or Y but not both
- if (Math.random() >= 0.5) {
- // move in X direction
- if (inlineType != X) {
- if (original.x < target.x) {
- result.x = original.x + (XAMOUNT / 2);
- goRight(enemyNo);
- } else if (original.x > target.x) {
- result.x = original.x - (XAMOUNT / 2);
- goLeft(enemyNo);
- }
- }
- } else {
- // move in Y direction
- if (inlineType != Y) {
- if (original.y < target.y) {
- result.y = original.y + (YAMOUNT / 2);
- goDown(enemyNo);
- } else if (original.y > target.y) {
- result.y = original.y - (YAMOUNT / 2);
- goUp(enemyNo);
- }
- }
- }
- /*
- * if (isTankPosition(result)) { if (isTankPosition(new Point(result.x,
- * original.y))) { if (isTankPosition(new Point(original.x, result.y))) result =
- * original; else result = new Point(original.x, result.y); } else result = new
- * Point(result.x, original.y); }
- */
- inlineType = isInline(result);
- if (inlineType == X) {
- // fire along the X axis
- } else if (inlineType == Y) {
- // fire along the Y axis
- }
- return (result);
- }
-
- /*
- * private int randomMove() { // return + or - value (randomly) if
- * (Math.random() >= 0.5) return(24); else return(-24); }
- */
-
- // this class will use just the key pressed event
- @Override
- public void keyPressed(KeyEvent e) {
- if (ingame) {
- if (!((e.getKeyCode() == KeyEvent.VK_DOWN && playerPosition.y >= (BOTTOMEDGE - YAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_UP && playerPosition.y <= (TOPEDGE + YAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_RIGHT && playerPosition.x >= (RIGHTEDGE - XAMOUNT)))) {
- // valid move: move the player and then move the enemies
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- playerPosition.y += YAMOUNT;
- goDown();
- } else if (e.getKeyCode() == KeyEvent.VK_UP) {
- playerPosition.y -= YAMOUNT;
- goUp();
- } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- playerPosition.x -= XAMOUNT;
- goLeft();
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- playerPosition.x += XAMOUNT;
- goRight();
- }
- if (isTankPosition(playerPosition)) {
- System.out.println("The Player ran into an enemy!! Press the Enter key to restart the level");
- ingame = false;
- }
- if (isPitPosition(playerPosition)) {
- System.out.println("The Player ran into a pit!! Press the Enter key to restart the level");
- ingame = false;
- }
- area.repaint();
- } // if valid key press
- } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
- doLevel(level++);
- }
- }
-
- @Override
- public void run() {
- while (true) {
- if (juststarted) {
- try {
- Thread.sleep(750);
- } catch (Exception e) {
- }
- juststarted = false;
- }
- try {
- Thread.sleep(DELAY);
- } catch (InterruptedException e) {
- }
- if (ingame) {
- // for each enemy, move the enemy closer to the player
- for (int i = 0; i < enemyPositions.length; i++) {
- if (!deadTank(enemyPositions[i])) {
- enemyPositions[i] = moveCloser(i, enemyPositions[i], playerPosition);
- }
- // if there is a pit at that position, fall into it and decrement count of
- // enemies
- // and set that enemy's position to -1, -1
- if (isPitPosition(enemyPositions[i])) {
- System.out.println("an enemy fell into a pit");
- explosionx = enemyPositions[i].x;
- explosiony = enemyPositions[i].y;
-
- enemyPositions[i] = new Point(-1, -1);
- enemiesRemaining--;
- System.out.println(enemyNumber - enemiesRemaining + " down, " + enemiesRemaining + " to go...");
- }
- // if player is caught by an enemy or all enemies are gone, end the game
- if (isPlayerPosition(enemyPositions[i])) {
- System.out.println(
- "\"Mmm! Brains...\". The Player is dead. Press the Enter key to restart the level");
- level--; // because it will be incremented in a minute and we want to stay on the same
- // 'level'
- ingame = false;
- }
- }
- if (enemiesRemaining == 0) {
- System.out.println(
- "All the enemies are gone -- you won!! Press the Enter key to start the next level");
- enemyNumber++;
- if (pitNumber > 2)
- pitNumber--;
- ingame = false;
- } else
- area.repaint();
- }
- }
- }
-
- private boolean deadTank(Point p) {
- return (p.x == -1 && p.y == -1);
- }
-
- @Override
- public void keyReleased(KeyEvent e) {
- }
-
- @Override
- public void keyTyped(KeyEvent e) {
- }
-}
diff --git a/Zombie/src/Zombie.java b/Zombie/src/Zombie.java
@@ -0,0 +1,304 @@
+
+/* Copyright (c) M Percival 2002 */
+/* Zombie game Created October 2002 */
+
+import java.awt.Color;
+import java.awt.Point;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+
+import javax.swing.JFrame;
+
+public class Zombie extends JFrame implements KeyListener, Runnable {
+ private static final long serialVersionUID = 8654912377879331966L;
+ // all member variables 'static' because shared with the zombie action thread
+ private static ZombieArea area;
+ private static boolean ingame = false;
+ private boolean juststarted = false;
+ private static int level = 1;
+ private static int zombiesRemaining;
+ protected static Point[] zombiePositions;
+ protected static Point playerPosition;
+ protected static Point[] pitPositions;
+ private static Thread zombies;
+
+ protected static int pitNumber = 15;
+ protected static int zombieNumber = 10;
+ protected static int RIGHTEDGE = 1200;
+ protected static final int LEFTEDGE = 0;
+ protected static final int TOPEDGE = 0;
+ protected static int BOTTOMEDGE = 1000;
+ protected static int XAMOUNT = 5;
+ protected static int YAMOUNT = 5;
+ private static final int X = 1;
+ private static final int Y = 2;
+ private static final int NOT = 3;
+ private static final int DELAY = 125;
+ protected int explosionx = -1, explosiony = -1;
+
+ public static void main(String[] args) {
+ Zombie Zombie = new Zombie();
+ Zombie.setLayout(null);
+ Zombie.setBackground(Color.gray);
+ Zombie.setSize(RIGHTEDGE, BOTTOMEDGE);
+
+ area = new ZombieArea(Zombie);
+ Zombie.add(area);
+ // RIGHTEDGE = getBounds().width - 1;
+ // BOTTOMEDGE = getBounds().height - 1;
+ XAMOUNT = 12;
+ YAMOUNT = 12;
+ Zombie.setVisible(true);
+ area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
+ area.setVisible(true);
+
+ Zombie.addKeyListener(Zombie);
+ area.addKeyListener(Zombie);
+ area.requestFocus();
+
+ zombies = new Thread(Zombie);
+ zombies.start();
+ }
+
+ public void doLevel(int level) {
+ // this runs one 'level'
+ // create arrays of pits and zombies here.
+ // Maybe each level will have different numbers?
+ juststarted = true;
+ Point temppoint;
+ pitPositions = new Point[pitNumber];
+ zombiePositions = new Point[zombieNumber];
+ for (int i = 0; i < zombieNumber; i++)
+ zombiePositions[i] = new Point(0, 0);
+ for (int i = 0; i < pitNumber; i++)
+ pitPositions[i] = new Point(0, 0);
+
+ System.out.println("Started level " + level + ": " + zombieNumber + " zombies and " + pitNumber + " pits");
+
+ // randomly position 1 player, x zombies and y pits
+ playerPosition = randomPosition();
+
+ for (int i = 0; i < zombieNumber; i++) {
+ temppoint = randomPosition();
+ while (isPlayerPosition(temppoint) || isZombiePosition(temppoint)) {
+ // don't position any zombie on the player or on top of another zombie
+ temppoint = randomPosition();
+ }
+ zombiePositions[i] = temppoint;
+ }
+
+ for (int i = 0; i < pitNumber; i++) {
+ temppoint = randomPosition();
+ while (isPlayerPosition(temppoint) || isPitPosition(temppoint) || isZombiePosition(temppoint)) {
+ // don't position any zombie at the player, a zombie or another pit
+ temppoint = randomPosition();
+ }
+
+ pitPositions[i] = temppoint;
+ }
+
+ zombiesRemaining = zombieNumber;
+ // paint the panel here
+ area.repaint();
+ ingame = true;
+ }
+
+ private Point randomPosition() {
+ return new Point((int) (Math.random() * RIGHTEDGE) / XAMOUNT * XAMOUNT,
+ (int) (Math.random() * BOTTOMEDGE) / YAMOUNT * YAMOUNT);
+ }
+
+ private boolean isPlayerPosition(Point p) {
+ return (p.x == playerPosition.x && p.y == playerPosition.y);
+ }
+
+ private boolean isZombiePosition(Point p) {
+ for (int i = 0; i < zombieNumber; i++) {
+ if (p.x == zombiePositions[i].x && p.y == zombiePositions[i].y)
+ return (true);
+ }
+ return (false);
+ }
+
+ private int isInline(Point p) {
+ // is the new position in the same row as the player?
+ if (Math.abs(p.x - playerPosition.x) < XAMOUNT) {
+ // see whether there is another zombie between this position and the player
+ if (playerPosition.y > p.y) {
+ for (int i = 0; i < zombieNumber; i++) {
+ if (p.x == zombiePositions[i].x && p.y < zombiePositions[i].y)
+ return (X);
+ }
+ } else { // playerPosition y < p.y
+ for (int i = 0; i < zombieNumber; i++) {
+ if (p.x == zombiePositions[i].x && p.y > zombiePositions[i].y)
+ return (X);
+ }
+ }
+ } else if (Math.abs(p.y - playerPosition.y) < YAMOUNT) {
+ // see whether there is another zombie between this position and the player
+ if (playerPosition.x > p.x) {
+ for (int i = 0; i < zombieNumber; i++) {
+ if (p.y == zombiePositions[i].y && p.x < zombiePositions[i].x)
+ return (Y);
+ }
+ } else { // playerPosition x < p.x
+ for (int i = 0; i < zombieNumber; i++) {
+ if (p.y == zombiePositions[i].y && p.x > zombiePositions[i].x)
+ return (Y);
+ }
+ }
+ }
+ return (NOT);
+ }
+
+ private boolean isPitPosition(Point p) {
+ for (int i = 0; i < pitNumber; i++) {
+ if (p.x == pitPositions[i].x && p.y == pitPositions[i].y)
+ return (true);
+ }
+
+ return (false);
+ }
+
+ private Point moveCloser(Point original, Point target) {
+ Point result = new Point(original);
+ int inlineType = isInline(original);
+ if (inlineType != X) {
+ if (original.x < target.x)
+ result.x = original.x + (XAMOUNT / 2);
+ else if (original.x > target.x)
+ result.x = original.x - (XAMOUNT / 2);
+ } else {
+ // move out of the Y alignment - randomly left or right
+ result.x += randomMove();
+ }
+ if (inlineType != Y) {
+ if (original.y < target.y)
+ result.y = original.y + (YAMOUNT / 2);
+ else if (original.y > target.y)
+ result.y = original.y - (YAMOUNT / 2);
+ } else {
+ // move out of the Y alignment - randomly up or down
+ result.y += randomMove();
+ }
+ if (isZombiePosition(result)) {
+ if (isZombiePosition(new Point(result.x, original.y))) {
+ if (isZombiePosition(new Point(original.x, result.y)))
+ result = original;
+ else
+ result = new Point(original.x, result.y);
+ } else
+ result = new Point(result.x, original.y);
+ }
+ return (result);
+ }
+
+ private int randomMove() {
+ // return + or - value (randomly)
+ if (Math.random() >= 0.5)
+ return (24);
+ else
+ return (-24);
+ }
+
+ // this class will use just the key pressed event
+ @Override
+ public void keyPressed(KeyEvent e) {
+ if (ingame) {
+ if (!((e.getKeyCode() == KeyEvent.VK_DOWN && playerPosition.y >= (BOTTOMEDGE - YAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_UP && playerPosition.y <= (TOPEDGE + YAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))
+ || (e.getKeyCode() == KeyEvent.VK_RIGHT && playerPosition.x >= (RIGHTEDGE - XAMOUNT)))) {
+ // valid move: move the player and then move the zombies
+ if (e.getKeyCode() == KeyEvent.VK_DOWN) {
+ playerPosition.y += YAMOUNT;
+ } else if (e.getKeyCode() == KeyEvent.VK_UP) {
+ playerPosition.y -= YAMOUNT;
+ } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
+ playerPosition.x -= XAMOUNT;
+ } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
+ playerPosition.x += XAMOUNT;
+ }
+ if (isZombiePosition(playerPosition)) {
+ System.out.println("The Player ran into a zombie!! Press the Enter key to restart the level");
+ ingame = false;
+ }
+ if (isPitPosition(playerPosition)) {
+ System.out.println("The Player ran into a pit!! Press the Enter key to restart the level");
+ ingame = false;
+ }
+ area.repaint();
+ } // if valid key press
+ } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+ doLevel(level++);
+ }
+ }
+
+ @Override
+ public void run() {
+ while (true) {
+ if (juststarted) {
+ try {
+ Thread.sleep(750);
+ } catch (Exception e) {
+ }
+ juststarted = false;
+ }
+ try {
+ Thread.sleep(DELAY);
+ } catch (InterruptedException e) {
+ }
+ if (ingame) {
+ // for each zombie, move the zombie closer to the player
+ for (int i = 0; i < zombiePositions.length; i++) {
+ if (!deadZombie(zombiePositions[i])) {
+ zombiePositions[i] = moveCloser(zombiePositions[i], playerPosition);
+ }
+ // if there is a pit at that position, fall into it and decrement count of
+ // zombies
+ // and set that zombie's position to -1, -1
+ if (isPitPosition(zombiePositions[i])) {
+ System.out.println("A zombie fell into a pit");
+ explosionx = zombiePositions[i].x;
+ explosiony = zombiePositions[i].y;
+
+ zombiePositions[i] = new Point(-1, -1);
+ zombiesRemaining--;
+ System.out
+ .println(zombieNumber - zombiesRemaining + " down, " + zombiesRemaining + " to go...");
+ }
+ // if player is caught by a zombie or all zombies are gone, end the game
+ if (isPlayerPosition(zombiePositions[i])) {
+ System.out.println(
+ "\"Mmm! Brains...\". The Player is dead. Press the Enter key to restart the level");
+ level--; // because it will be incremented in a minute and we want to stay on the same
+ // 'level'
+ ingame = false;
+ }
+ }
+ if (zombiesRemaining == 0) {
+ System.out.println(
+ "All the zombies are gone -- you won!! Press the Enter key to start the next level");
+ zombieNumber++;
+ if (pitNumber > 2)
+ pitNumber--;
+ ingame = false;
+ } else
+ area.repaint();
+ }
+ }
+ }
+
+ private boolean deadZombie(Point p) {
+ return (p.x == -1 && p.y == -1);
+ }
+
+ @Override
+ public void keyReleased(KeyEvent e) {
+ }
+
+ @Override
+ public void keyTyped(KeyEvent e) {
+ }
+}
diff --git a/Zombie/src/ZombieArea.java b/Zombie/src/ZombieArea.java
@@ -11,13 +11,13 @@ import javax.swing.JPanel;
public class ZombieArea extends JPanel implements ActionListener {
private static final long serialVersionUID = 8492549939914174796L;
- ZombieGame myApplet = null;
+ Zombie myApplet = null;
Image zombieImage;
Image personImage;
Image pitImage;
private Image explosion1, explosion2, explosion3;
- public ZombieArea(ZombieGame parent) {
+ public ZombieArea(Zombie parent) {
myApplet = parent;
try {
@@ -43,20 +43,20 @@ public class ZombieArea extends JPanel implements ActionListener {
g.fillRect(0, 0, w, h);
g.setColor(Color.black);
- if (ZombieGame.playerPosition != null) {
+ if (Zombie.playerPosition != null) {
// show the player
//g.drawString("#", myApplet.playerPosition.x, myApplet.playerPosition.y);
- g.drawImage(personImage, ZombieGame.playerPosition.x, ZombieGame.playerPosition.y,Color.gray, null);
+ g.drawImage(personImage, Zombie.playerPosition.x, Zombie.playerPosition.y,Color.gray, null);
// show the pits
- for (int i=0; i < ZombieGame.pitPositions.length; i++) {
- g.drawImage(pitImage, ZombieGame.pitPositions[i].x, ZombieGame.pitPositions[i].y,Color.gray, null);
+ for (int i=0; i < Zombie.pitPositions.length; i++) {
+ g.drawImage(pitImage, Zombie.pitPositions[i].x, Zombie.pitPositions[i].y,Color.gray, null);
}
// show the zombies
- for (int i=0; i < ZombieGame.zombiePositions.length; i++) {
- if (ZombieGame.zombiePositions[i].x > -1)
- g.drawImage(zombieImage, ZombieGame.zombiePositions[i].x, ZombieGame.zombiePositions[i].y,null);
+ for (int i=0; i < Zombie.zombiePositions.length; i++) {
+ if (Zombie.zombiePositions[i].x > -1)
+ g.drawImage(zombieImage, Zombie.zombiePositions[i].x, Zombie.zombiePositions[i].y,null);
}
if (myApplet.explosionx != -1) {
diff --git a/Zombie/src/ZombieGame.java b/Zombie/src/ZombieGame.java
@@ -1,304 +0,0 @@
-
-/* Copyright (c) M Percival 2002 */
-/* Zombie game Created October 2002 */
-
-import java.awt.Color;
-import java.awt.Point;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-
-import javax.swing.JFrame;
-
-public class ZombieGame extends JFrame implements KeyListener, Runnable {
- private static final long serialVersionUID = 8654912377879331966L;
- // all member variables 'static' because shared with the zombie action thread
- private static ZombieArea area;
- private static boolean ingame = false;
- private boolean juststarted = false;
- private static int level = 1;
- private static int zombiesRemaining;
- protected static Point[] zombiePositions;
- protected static Point playerPosition;
- protected static Point[] pitPositions;
- private static Thread zombies;
-
- protected static int pitNumber = 15;
- protected static int zombieNumber = 10;
- protected static int RIGHTEDGE = 1200;
- protected static final int LEFTEDGE = 0;
- protected static final int TOPEDGE = 0;
- protected static int BOTTOMEDGE = 1000;
- protected static int XAMOUNT = 5;
- protected static int YAMOUNT = 5;
- private static final int X = 1;
- private static final int Y = 2;
- private static final int NOT = 3;
- private static final int DELAY = 125;
- protected int explosionx = -1, explosiony = -1;
-
- public static void main(String[] args) {
- ZombieGame zombieGame = new ZombieGame();
- zombieGame.setLayout(null);
- zombieGame.setBackground(Color.gray);
- zombieGame.setSize(RIGHTEDGE, BOTTOMEDGE);
-
- area = new ZombieArea(zombieGame);
- zombieGame.add(area);
- // RIGHTEDGE = getBounds().width - 1;
- // BOTTOMEDGE = getBounds().height - 1;
- XAMOUNT = 12;
- YAMOUNT = 12;
- zombieGame.setVisible(true);
- area.setBounds(0, 0, RIGHTEDGE, BOTTOMEDGE);
- area.setVisible(true);
-
- zombieGame.addKeyListener(zombieGame);
- area.addKeyListener(zombieGame);
- area.requestFocus();
-
- zombies = new Thread(zombieGame);
- zombies.start();
- }
-
- public void doLevel(int level) {
- // this runs one 'level'
- // create arrays of pits and zombies here.
- // Maybe each level will have different numbers?
- juststarted = true;
- Point temppoint;
- pitPositions = new Point[pitNumber];
- zombiePositions = new Point[zombieNumber];
- for (int i = 0; i < zombieNumber; i++)
- zombiePositions[i] = new Point(0, 0);
- for (int i = 0; i < pitNumber; i++)
- pitPositions[i] = new Point(0, 0);
-
- System.out.println("Started level " + level + ": " + zombieNumber + " zombies and " + pitNumber + " pits");
-
- // randomly position 1 player, x zombies and y pits
- playerPosition = randomPosition();
-
- for (int i = 0; i < zombieNumber; i++) {
- temppoint = randomPosition();
- while (isPlayerPosition(temppoint) || isZombiePosition(temppoint)) {
- // don't position any zombie on the player or on top of another zombie
- temppoint = randomPosition();
- }
- zombiePositions[i] = temppoint;
- }
-
- for (int i = 0; i < pitNumber; i++) {
- temppoint = randomPosition();
- while (isPlayerPosition(temppoint) || isPitPosition(temppoint) || isZombiePosition(temppoint)) {
- // don't position any zombie at the player, a zombie or another pit
- temppoint = randomPosition();
- }
-
- pitPositions[i] = temppoint;
- }
-
- zombiesRemaining = zombieNumber;
- // paint the panel here
- area.repaint();
- ingame = true;
- }
-
- private Point randomPosition() {
- return new Point((int) (Math.random() * RIGHTEDGE) / XAMOUNT * XAMOUNT,
- (int) (Math.random() * BOTTOMEDGE) / YAMOUNT * YAMOUNT);
- }
-
- private boolean isPlayerPosition(Point p) {
- return (p.x == playerPosition.x && p.y == playerPosition.y);
- }
-
- private boolean isZombiePosition(Point p) {
- for (int i = 0; i < zombieNumber; i++) {
- if (p.x == zombiePositions[i].x && p.y == zombiePositions[i].y)
- return (true);
- }
- return (false);
- }
-
- private int isInline(Point p) {
- // is the new position in the same row as the player?
- if (Math.abs(p.x - playerPosition.x) < XAMOUNT) {
- // see whether there is another zombie between this position and the player
- if (playerPosition.y > p.y) {
- for (int i = 0; i < zombieNumber; i++) {
- if (p.x == zombiePositions[i].x && p.y < zombiePositions[i].y)
- return (X);
- }
- } else { // playerPosition y < p.y
- for (int i = 0; i < zombieNumber; i++) {
- if (p.x == zombiePositions[i].x && p.y > zombiePositions[i].y)
- return (X);
- }
- }
- } else if (Math.abs(p.y - playerPosition.y) < YAMOUNT) {
- // see whether there is another zombie between this position and the player
- if (playerPosition.x > p.x) {
- for (int i = 0; i < zombieNumber; i++) {
- if (p.y == zombiePositions[i].y && p.x < zombiePositions[i].x)
- return (Y);
- }
- } else { // playerPosition x < p.x
- for (int i = 0; i < zombieNumber; i++) {
- if (p.y == zombiePositions[i].y && p.x > zombiePositions[i].x)
- return (Y);
- }
- }
- }
- return (NOT);
- }
-
- private boolean isPitPosition(Point p) {
- for (int i = 0; i < pitNumber; i++) {
- if (p.x == pitPositions[i].x && p.y == pitPositions[i].y)
- return (true);
- }
-
- return (false);
- }
-
- private Point moveCloser(Point original, Point target) {
- Point result = new Point(original);
- int inlineType = isInline(original);
- if (inlineType != X) {
- if (original.x < target.x)
- result.x = original.x + (XAMOUNT / 2);
- else if (original.x > target.x)
- result.x = original.x - (XAMOUNT / 2);
- } else {
- // move out of the Y alignment - randomly left or right
- result.x += randomMove();
- }
- if (inlineType != Y) {
- if (original.y < target.y)
- result.y = original.y + (YAMOUNT / 2);
- else if (original.y > target.y)
- result.y = original.y - (YAMOUNT / 2);
- } else {
- // move out of the Y alignment - randomly up or down
- result.y += randomMove();
- }
- if (isZombiePosition(result)) {
- if (isZombiePosition(new Point(result.x, original.y))) {
- if (isZombiePosition(new Point(original.x, result.y)))
- result = original;
- else
- result = new Point(original.x, result.y);
- } else
- result = new Point(result.x, original.y);
- }
- return (result);
- }
-
- private int randomMove() {
- // return + or - value (randomly)
- if (Math.random() >= 0.5)
- return (24);
- else
- return (-24);
- }
-
- // this class will use just the key pressed event
- @Override
- public void keyPressed(KeyEvent e) {
- if (ingame) {
- if (!((e.getKeyCode() == KeyEvent.VK_DOWN && playerPosition.y >= (BOTTOMEDGE - YAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_UP && playerPosition.y <= (TOPEDGE + YAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_LEFT && playerPosition.x <= (LEFTEDGE + XAMOUNT))
- || (e.getKeyCode() == KeyEvent.VK_RIGHT && playerPosition.x >= (RIGHTEDGE - XAMOUNT)))) {
- // valid move: move the player and then move the zombies
- if (e.getKeyCode() == KeyEvent.VK_DOWN) {
- playerPosition.y += YAMOUNT;
- } else if (e.getKeyCode() == KeyEvent.VK_UP) {
- playerPosition.y -= YAMOUNT;
- } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
- playerPosition.x -= XAMOUNT;
- } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
- playerPosition.x += XAMOUNT;
- }
- if (isZombiePosition(playerPosition)) {
- System.out.println("The Player ran into a zombie!! Press the Enter key to restart the level");
- ingame = false;
- }
- if (isPitPosition(playerPosition)) {
- System.out.println("The Player ran into a pit!! Press the Enter key to restart the level");
- ingame = false;
- }
- area.repaint();
- } // if valid key press
- } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
- doLevel(level++);
- }
- }
-
- @Override
- public void run() {
- while (true) {
- if (juststarted) {
- try {
- Thread.sleep(750);
- } catch (Exception e) {
- }
- juststarted = false;
- }
- try {
- Thread.sleep(DELAY);
- } catch (InterruptedException e) {
- }
- if (ingame) {
- // for each zombie, move the zombie closer to the player
- for (int i = 0; i < zombiePositions.length; i++) {
- if (!deadZombie(zombiePositions[i])) {
- zombiePositions[i] = moveCloser(zombiePositions[i], playerPosition);
- }
- // if there is a pit at that position, fall into it and decrement count of
- // zombies
- // and set that zombie's position to -1, -1
- if (isPitPosition(zombiePositions[i])) {
- System.out.println("A zombie fell into a pit");
- explosionx = zombiePositions[i].x;
- explosiony = zombiePositions[i].y;
-
- zombiePositions[i] = new Point(-1, -1);
- zombiesRemaining--;
- System.out
- .println(zombieNumber - zombiesRemaining + " down, " + zombiesRemaining + " to go...");
- }
- // if player is caught by a zombie or all zombies are gone, end the game
- if (isPlayerPosition(zombiePositions[i])) {
- System.out.println(
- "\"Mmm! Brains...\". The Player is dead. Press the Enter key to restart the level");
- level--; // because it will be incremented in a minute and we want to stay on the same
- // 'level'
- ingame = false;
- }
- }
- if (zombiesRemaining == 0) {
- System.out.println(
- "All the zombies are gone -- you won!! Press the Enter key to start the next level");
- zombieNumber++;
- if (pitNumber > 2)
- pitNumber--;
- ingame = false;
- } else
- area.repaint();
- }
- }
- }
-
- private boolean deadZombie(Point p) {
- return (p.x == -1 && p.y == -1);
- }
-
- @Override
- public void keyReleased(KeyEvent e) {
- }
-
- @Override
- public void keyTyped(KeyEvent e) {
- }
-}
