Java Games Programmeren

Java Games Programmeren

door L.L.

Source Code

Ik heb uiteindelijk besloten de source code van mijn snake applet volledig online te zetten. Als je ergens met een eigen applet vastzit kan je op deze manier misschien een oplossing vinden door in mijn source code te gaan zoeken. Aangezien ik zelf ook een beginnende programmeur ben zullen er waarschijnlijk nog enkele bugs in zitten en is niet alles perfect geprogrammeerd zoals het hoort. Deze code mag niet herbruikt worden tenzij je mijn expliciete toestemming daarvoor hebt.

  • Main
  • Level
  • Snake
  • GUI
  • Menu
/*
 *
 * Copyright (c) 2010, L.L., Inc.
 *
 * All rights reserved.
 *
 */

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

/**
 * Class Main
 * 
 * @LL
 * @version 22/8/2010
 */
public class Main extends JApplet implements KeyListener, Runnable {
  /**
   * Velden
   */
  // VersieID
  private static final long serialVersionUID = 1L;

  // om te debuggen
  private static final boolean DEBUG = false;

  // thread = hierdoor kan het spel in een loop blijven lopen
  private Thread t;

  // level = klasse waarin het String[][] board geregeld wordt.
  private Level level;
  private int levelNr;

  // snake = klasse waarin int[] snake, mey x,y coordinaten in array
  private Snake snake;

  // GUI = klasse met grafische user interface
  private GUI gui;

  // Menu = klasse met beginmenu
  private Menu menu;

  /**
   * Called by the browser or applet viewer to inform this JApplet that it has
   * been loaded into the system. It is always called before the first time
   * that the start method is called.
   */
  public void init() {
    // zorgt dat applet luistert naar indrukken keyboard
    addKeyListener(this);

    // level aanmaken
    level = new Level(0);
    levelNr = 1;
    // zorgt voor groter appletvenster
    setSize(Level.width, Level.height);
    // GUI aanmaken
    gui = new GUI();
    // snake aanmaken
    snake = new Snake();
    // Menu aanmaken
    menu = new Menu();

    t = new Thread(this);
    t.start();
  }

  // In deze lus zit het spel constant
  public void run() {
    while (menu.getQuit() == false) {
      // startMenu
      menu();

      // met escape kan je terug naar startmenu
      while (menu.getEscape() == false) {
        // checkt of er naar volgende level moet verdergegaan worden
        checkIfNextLevel();
        // scherm voor level (of eventueel na laatste level)
        preLevel(level.getGameOver());
        if (menu.getEscape() == false && level.getGameOver() == false) {
          // snake en level resetten
          reset();
          // het eigenlijke level spelen
          play();
        }
      }
    }
  }

  public void menu() {
    menu.setEscape(false);
    menu.setStart(false);
    level.setGameOver(false);
    menu.setContLevel(1);
    // lus om in start menu te blijven
    while (menu.getStart() != true) {
      menu.setListen(true);
      gui.menu(snake.getSpeed(), level.getBoard(), menu.getContinue(),
          menu.getCode(), snake.getDirection());
      repaint();
      levelNr = menu.getContLevel();
      sleep(100);
    }
  }

  public void checkIfNextLevel() {
    if (level.getNextLevel() == true) {
      level.setNextLevel(false);
      level.setEnd(false);
      levelNr++;
      if (levelNr > level.getNrOfLevels()) {
        level.setGameOver(true);
      }
    }
  }

  public void preLevel(boolean gameOver) {
    menu.setEnter(false);
    menu.setEscape(false);
    while (menu.getEnter() != true && menu.getEscape() != true) {
      menu.setListen(true);
      if (gameOver != true) {
        level.loadFile(0);
        gui.level(level.getBoard(), levelNr, level
            .getLevelCode(levelNr), snake.getDirection());
      }
      // na laatste level uitgespeeld te hebben
      else if (gameOver == true) {
        level.loadFile(0);
        gui.gameOver(level.getBoard(), snake.getDirection());
      }
      repaint();
      sleep(100);
    }
  }

  public void reset() {
    // booleans terug in beginstand zetten
    menu.setEnter(false);
    level.setDead(false);
    level.setGotDiamond(true);
    level.setDiamondsTaken(0);

    // board aanmaken
    level.loadFile(levelNr);
    // hoofd slang zoeken op map
    level.searchBoard(0, 0, snake, "h", level.getBoard());
    snake.reset();
    snake.moveSnake(snake.getSnake(), level.getEnd());
    snake.drawSnake(level.getBoard(), snake.getSnake(), level.getEnd());
    // board tekenen
    gui.drawBoard(level.getBoard(), snake.getDirection());
  }

  // hier wordt het eigenlijke snake spel gespeeld
  public void play() {
    while (level.getDead() == false && level.getNextLevel() == false) {
      snake.move(level.getEnd());
      snake.moveSnake(snake.getSnake(), level.getEnd());
      level.checkBoard(level.getBoard(), snake);
      snake.drawSnake(level.getBoard(), snake.getSnake(), level.getEnd());
      checkDiamond();
      gui.drawBoard(level.getBoard(), snake.getDirection());
      repaint();
      sleep(snake.getSpeed());

    }
  }

  public void checkDiamond() {
    if (level.getGotDiamond() == true) {
      if (level.getDiamondsTaken() == 10) {
        level.generate(level.getBoard(), "endGate");
      } else {
        level.generate(level.getBoard(), "diamond");
      }
      level.setGotDiamond(false);
    }
  }

  public void stop() {

  }

  public void destroy() {

  }

  public void sleep(int howLong) {
    try {
      Thread.sleep(howLong);
    } catch (InterruptedException e) {
      ;
    }
  }

  /**
   * Paint method for applet.
   * 
   * @param g
   *            the Graphics object for this applet
   */
  public void paint(Graphics g) {
    g.drawImage(gui.getOffscr(), 0, 0, this);
  }

  public void update(Graphics g) {
    paint(g);
  }

  /**
   * KeyListener methodes
   */
  @Override
  public void keyPressed(KeyEvent e) {
    snake.keyPressed(e);
    menu.keyPressed(e, snake, level);
    if (DEBUG) {
      System.out.println(e.getKeyCode());
      System.out.println(snake.getDirection());
    }
  }

  @Override
  public void keyReleased(KeyEvent e) {
    // TODO Auto-generated method stub

  }

  @Override
  public void keyTyped(KeyEvent e) {
    // TODO Auto-generated method stub

  }

}
/*
 *
 * Copyright (c) 2010, L.L., Inc.
 *
 * All rights reserved.
 *
 */

import java.awt.Toolkit;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;

public class Level {

  // variabelen die te maken hebben met grootte level
  public static final int size = 20;
  public static final int blocksHor = 32;
  public static final int blocksVer = 20;
  public static final int width = size * blocksHor;
  public static final int height = size * blocksVer;

  // dood
  private boolean dead;
  // wanneer een diamant opgepakt wordt door de snake
  private boolean gotDiamond;
  // aantal diamanten dat de snake al heeft opgegeten
  private int diamondsTaken;
  // level uitgespeeld
  private boolean end;
  // helemaal weg in poortje
  private boolean nextLevel;
  // game uitgespeeld
  private boolean gameOver;

  // board
  private String[][] board;
  // levelcodes
  private String[] levelCodes;
  // aantal levels
  private int nrOfLevels;

  /**
   * Constructor van Level
   * 
   * @param level
   */
  public Level(int level) {
    board = loadFile(level);
    gotDiamond = true;
    end = false;
    gameOver = false;
    nextLevel = false;
    diamondsTaken = 0;
    loadLevelCodes();
  }

  /**
   * Bestand inladen = level, en omzetten naar String[][] moet nog bewerken
   * dat ik int level --> neem juiste level
   */
  public String[][] loadFile(int level) {
    // Dit is DE manier om bestanden in te laden en te laten werken online
    BufferedReader bf = new BufferedReader(new InputStreamReader(getClass()
        .getResourceAsStream("data/levels.txt")));
    StreamTokenizer tokenizer = new StreamTokenizer(bf);
    tokenizer.wordChars('a', 'z');

    // lus om int[][] op te vullen met karakters uit test.txt bestand
    int token = 0;

    // zet token op nummer 1 = level 1 uit txt file
    token = nextToken(tokenizer);

    // verder lopen in txt bestand tot aan juiste level
    while (tokenizer.nval != level) {
      token = nextToken(tokenizer);
      while (token != StreamTokenizer.TT_NUMBER) {
        token = nextToken(tokenizer);
      }
    }
    // gaat naar 1e vakje van level
    token = nextToken(tokenizer);

    board = new String[blocksVer][blocksHor];
    int i, j;
    // laad het level in tot het volgende level bereikt wordt in txt file of
    // endoffile
    while (token != StreamTokenizer.TT_NUMBER
        && token != StreamTokenizer.TT_EOF) {
      for (i = 0; i < blocksVer; i++) {
        for (j = 0; j < blocksHor; j++) {
          board[i][j] = tokenizer.sval;
          token = nextToken(tokenizer);
        }
      }

    }

    return board;

  }

  // submethode die alleen in loadfile wordt gebruikt
  public int nextToken(StreamTokenizer tokenizer) {
    int token = 0;
    try {
      token = tokenizer.nextToken();
    } catch (final IOException e) {
      System.out.println("IOException");
    }
    return token;
  }

  public String[][] getBoard() {
    return board;
  }

  /**
   * checkt het vakje waar hoofd van de snake op terecht komt
   * 
   * @param board
   * @param snake
   */
  public void checkBoard(String[][] board, Snake snake) {
    int i = snake.getY() / size;
    int j = snake.getX() / size;
    if (board[i][j].equals("w")) {
      dead = true;
      Toolkit.getDefaultToolkit().beep();
    } else if (board[i][j].equals("s")) {
      if (i == snake.getYTail() / size && j == snake.getXTail() / size) {
      } else {
        dead = true;
        Toolkit.getDefaultToolkit().beep();
      }
    } else if (board[i][j].equals("d")) {
      gotDiamond = true;
      diamondsTaken++;
      Toolkit.getDefaultToolkit().beep();
      snake.setGrown(false);
      // printSnake();
    } else if (board[i][j].equals("e")) {
      end = true;
      // snake verdwijnt in gat totdat de tail ook op dat vakje komt
      if (board[snake.getYTail() / size][snake.getXTail() / size]
          .equals("e")) {
        nextLevel = true;
      }
    } else if (board[i][j].startsWith("g")) {
      // zoekt op g1, g2, g3 of gelijk hoeveel poorten je wilt
      searchBoard(i, j, snake, "g" + board[i][j].substring(1), board);
    }
    // stukje code om snake meerdere vakjes te laten groeien
    if (snake.getGrown() == false
        && snake.getGrowLength() < Snake.getGrow()) {
      snake.addSnakeLength();
    }

  }

  public void searchBoard(int i, int j, Snake snake, String letter,
      String[][] bord) {
    for (int k = 0; k < blocksVer; k++) {
      for (int l = 0; l < blocksHor; l++) {
        if (bord[k][l].equals(letter)) {
          // voorwaarde dat hij niet zelfde poort terug pakt
          if (k != i || l != j) {
            // snake verplaatsen naar andere poort
            snake.setY(k * size);
            snake.setX(l * size);
          }
        }

      }
    }
  }

  /**
   * genereert een diamant die de slang kan opeten
   * 
   * @param board
   */
  // LET OP MET INDICES! eerst y, dan x in de board array
  public void generate(String[][] board, String what) {
    int i = 0;
    int j = 0;
    boolean generated = false;

    while (generated == false) {
      i = size + ((int) (Math.random() * (blocksHor - 2))) * size;
      j = size + ((int) (Math.random() * (blocksVer - 2))) * size;

      if (board[j / size][i / size].equals("b")) {
        if (what.equals("diamond")) {
          board[j / size][i / size] = "d";
        } else if (what.equals("endGate")) {
          board[j / size][i / size] = "e";
        }
        generated = true;
      }
    }

  }

  // codes om uit hoofdmenu direct naar level te gaan
  public void loadLevelCodes() {
    // Dit is DE manier om bestanden in te laden en te laten werken online
    BufferedReader bf = new BufferedReader(new InputStreamReader(getClass()
        .getResourceAsStream("data/codes.txt")));
    StreamTokenizer tokenizer = new StreamTokenizer(bf);
    tokenizer.wordChars('a', 'z');
    tokenizer.commentChar('/');

    // zet token op 1e getal in txt file = aantal levels
    int token = nextToken(tokenizer);
    nrOfLevels = (int) tokenizer.nval;

    // ik gebruik 0 niet in de array
    levelCodes = new String[nrOfLevels + 1];
    // ga naar code 1e level
    token = nextToken(tokenizer);

    int i = 1;
    while (token != StreamTokenizer.TT_EOF) {
      int code = (int) tokenizer.nval;
      levelCodes[i] = Integer.toString(code);
      token = nextToken(tokenizer);
      i++;
    }

  }

  public int tryCode(String code) {
    boolean correct = false;
    int i = 1;
    while (i <= nrOfLevels && correct != true) {
      if (code.equals(levelCodes[i])) {
        correct = true;
        // HappyMusic
        Toolkit.getDefaultToolkit().beep();
      }
      i++;
    }
    if (correct != true) {
      i = 1 + 1;
    }
    return i - 1;

  }

  /**
   * Getters en setters
   */
  public boolean getGotDiamond() {
    return gotDiamond;
  }

  public void setGotDiamond(boolean taken) {
    gotDiamond = taken;
  }

  public boolean getDead() {
    return dead;
  }

  public void setDead(boolean b) {
    dead = b;
  }

  public boolean getEnd() {
    return end;
  }

  public void setEnd(boolean b) {
    end = b;
  }

  public boolean getNextLevel() {
    return nextLevel;
  }

  public void setNextLevel(boolean b) {
    nextLevel = b;
  }

  public String getLevelCode(int levelNr) {
    return levelCodes[levelNr];
  }

  public int getNrOfLevels() {
    return nrOfLevels;
  }

  public boolean getGameOver() {
    return gameOver;
  }

  public void setGameOver(boolean gameOver) {
    this.gameOver = gameOver;
  }

  public int getDiamondsTaken() {
    return diamondsTaken;
  }

  public void setDiamondsTaken(int diamondsTaken) {
    this.diamondsTaken = diamondsTaken;
  }

  /**
   * Testklassen
   */
  public void printBoard() {
    // print array in rectangular form
    for (int r = 0; r < board.length; r++) {
      for (int c = 0; c < board[r].length; c++) {
        System.out.print(" " + board[r][c]);
      }
      System.out.println("");
    }
  }

  // level gebruiken zonder er een te moeten inladen
  public void fillBoard() {
    board = new String[blocksVer][blocksHor];
    for (int i = 0; i < blocksVer; i++) {
      for (int j = 0; j < blocksHor; j++) {
        board[i][j] = "b";
      }
    }
  }
}
/*
 *
 * Copyright (c) 2010, L.L., Inc.
 *
 * All rights reserved.
 *
 */

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class Snake implements KeyListener {
  // om te debuggen
  private static final boolean DEBUG = false;
  // grootte van snakeblokje
  private static final int size = Level.size;
  // maximum lengte van de snake
  private static final int maxLength = 100;
  // hoeveel blokjes er bij komen als snake diamond pakt
  private static final int grow = 3;
  private int growLength;
  private boolean grown;

  // positie van hoofd snake en van staart snake
  private int x, y;
  private int xTail, yTail;

  // richting die snake opgaat
  private String direction;
  // snelheid = niveau van het spel
  private int speed;

  // snake, x,y coordinaten in array
  private int[] snake;
  // lengte van de snake op elk moment
  private int snakeLength;

  // queue waarin keyEvents worden opgeslagen en bij elke move 1 uitgehaald
  private int[] queue;
  // houdt bij waar in de queue de beweging moet ingestoken worden (=
  // achteraan queue)
  private int queueNumber;

  public Snake() {
    // normale snelheid = Medium
    speed = 100;
    // snake aanmaken (2*maxLength want in elke vakje array een y of x
    // coordinaat)
    snake = new int[2 * maxLength];
    // queue aanmaken met 100, men kan nooit zoveel toetsen vlug indrukken
    // (= alleszinds moeilijk)
    queue = new int[25];
    // zet basisinstellingen snake
    reset();
  }

  /**
   * Snake reageert op toetsen Je kan nooit de tegenovergestelde richting
   * opgaan van degene die je momenteel gaat
   */
  public void keyPressed(KeyEvent e) {

    int c = e.getKeyCode();
    queue[queueNumber] = c;
    queueNumber++;
    e.consume();
  }

  public void changeDirection(int c) {
    if ((c == KeyEvent.VK_RIGHT || c == KeyEvent.VK_NUMPAD6)
        && direction != "left") {
      direction = "right";
    } else if ((c == KeyEvent.VK_LEFT || c == KeyEvent.VK_NUMPAD4)
        && direction != "right") {
      direction = "left";
    } else if ((c == KeyEvent.VK_UP || c == KeyEvent.VK_NUMPAD8)
        && direction != "down") {
      direction = "up";
    } else if ((c == KeyEvent.VK_DOWN || c == KeyEvent.VK_NUMPAD5)
        && direction != "up") {
      direction = "down";
    }
    // met 7 en 3 alle bewegingen kunnen doen
    else if (c == KeyEvent.VK_NUMPAD7
        && (direction == "right" || direction == "left")) {
      direction = "up";
    } else if (c == KeyEvent.VK_NUMPAD7
        && (direction == "up" || direction == "down")) {
      direction = "left";
    } else if (c == KeyEvent.VK_NUMPAD3
        && (direction == "right" || direction == "left")) {
      direction = "down";
    } else if (c == KeyEvent.VK_NUMPAD3
        && (direction == "up" || direction == "down")) {
      direction = "right";
    }
    // met 9 en 1 alle bewegingen kunnen doen
    else if (c == KeyEvent.VK_NUMPAD9
        && (direction == "right" || direction == "left")) {
      direction = "up";
    } else if (c == KeyEvent.VK_NUMPAD9
        && (direction == "up" || direction == "down")) {
      direction = "right";
    } else if (c == KeyEvent.VK_NUMPAD1
        && (direction == "right" || direction == "left")) {
      direction = "down";
    } else if (c == KeyEvent.VK_NUMPAD1
        && (direction == "up" || direction == "down")) {
      direction = "left";
    }
  }

  public void keyReleased(KeyEvent e) {
  }

  public void keyTyped(KeyEvent e) {
  }

  /**
   * Beweegt de snake automatisch in de richting die hij opgaat verandert x,y
   */
  public void move(boolean end) {
    if (DEBUG) {
      System.out.println("voor ");
      printQueue();
    }

    // gebruik eerste element in queue om van richting te veranderen = FIFO
    // werking
    changeDirection(queue[0]);
    // Schuif elk element in queue 1 plaats naar voor
    for (int i = 0; i < 24; i++) {
      queue[i] = queue[i + 1];
    }
    if (queueNumber > 0) {
      queueNumber--;
    }

    if (DEBUG) {
      System.out.println("na ");
      printQueue();
    }

    if (end != true) {
      if (direction == "right") {
        x += size;
      } else if (direction == "left") {
        x -= size;
      } else if (direction == "up") {
        y -= size;
      } else if (direction == "down") {
        y += size;
      }
    }

  }

  /**
   * moveSnake Schuift array door + geeft x,y aan 1e plaatsen array en neemt
   * xtail,ytail van laatste
   */
  public void moveSnake(int[] snakeArray, boolean end) {
    // lus om snake altijd te hertekenen, array verschuiven vanachter naar
    // voor!!
    for (int j = ((2 * snakeLength) - 1); j >= 0; j--) {
      snakeArray[j + 2] = snakeArray[j];
    }

    if (end == false) {
      snakeArray[0] = y;
      snakeArray[1] = x;
    }
    // tail = vakje dat gewist moet worden
    setYTail(snakeArray[(snakeLength * 2)]);
    setXTail(snakeArray[(snakeLength * 2) + 1]);
  }

  /**
   * Tekent snake in board door s'en te zetten
   * 
   * @param board
   * @param snakeArray
   */
  public void drawSnake(String[][] board, int[] snakeArray, boolean end) {

    // for (int k = 2; k<2+(2*snakeLength); k++)
    for (int k = 0; k < (2 * snakeLength); k++) {
      // om poorten niet te wissen
      if (board[snakeArray[k] / size][snakeArray[k + 1] / size]
          .startsWith("g")) {
      }

      else {
        board[snakeArray[k] / size][snakeArray[k + 1] / size] = "s";
      }
      k++;
    }
    // om poorten niet te wissen
    if (board[yTail / size][xTail / size].startsWith("g")) {
    }

    else
      board[yTail / size][xTail / size] = "b";

    if (end == true) {
      board[y / size][x / size] = "e";
    } else {
      // om poorten niet te wissen
      if (board[y / size][x / size].startsWith("g")) {
      }
      // om hoofd te tekenen
      else {
        board[y / size][x / size] = "h";
      }
    }

  }

  public void reset() {
    xTail = x;
    yTail = y;

    direction = "right";

    snake[0] = y;
    snake[1] = x;
    snakeLength = 1;

    growLength = 0;
    grown = false;

    java.util.Arrays.fill(queue, 0);
    queueNumber = 0;
  }

  public void addSnakeLength() {
    snakeLength++;
    growLength++;
    if (growLength == grow) {
      grown = true;
      growLength = 0;
    }
  }

  /**
   * Getters en setters.
   * 
   */
  public int getX() {
    return x;
  }

  public int getY() {
    return y;
  }

  public int getXTail() {
    return xTail;
  }

  public int getYTail() {
    return yTail;
  }

  public int getSnakeLength() {
    return snakeLength;
  }

  public int getSpeed() {
    return speed;
  }

  public String getDirection() {
    return direction;
  }

  public int[] getSnake() {
    return snake;
  }

  public boolean getGrown() {
    return grown;
  }

  public void setGrown(boolean grown) {
    this.grown = grown;
  }

  public int getGrowLength() {
    return growLength;
  }

  public static int getGrow() {
    return grow;
  }

  public void setY(int ynew) {
    y = ynew;
  }

  public void setX(int xnew) {
    x = xnew;
  }

  public void setYTail(int y) {
    yTail = y;
  }

  public void setXTail(int x) {
    xTail = x;
  }

  public void increaseSpeed() {
    speed -= 50;
    if (speed == 0) {
      speed = 25;
    }
    if (speed == -25) {
      speed = 200;
    }
  }

  /**
   * Testklassen
   */
  // testklasse om snake uit te printen
  public void printSnake() {
    System.out.println("SnakeLength= " + snakeLength);
    for (int l = 0; l < (2 * snakeLength); l++) {
      System.out.println(snake[l] + " " + snake[l + 1]);
      l++;
    }
  }

  // om de queue met KeyEvents te printen
  public void printQueue() {
    System.out.println("start PrintQueue");
    for (int l = 0; l < 100; l++) {
      System.out.println("queue " + l + " : " + queue[l]);
    }
    System.out.println("end PrintQueue");
  }
}
/*
 *
 * Copyright (c) 2010, L.L., Inc.
 *
 * All rights reserved.
 *
 */

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;

import java.awt.image.BufferedImage;

public class GUI {

  // double buffer voor grafische interface
  private BufferedImage offscreenImage;
  private Graphics offscr;

  // afstanden om text op goeie plaats te krijgen
  int x, y, distance, fontSize;

  public GUI() {
    // double buffer
    offscreenImage = new BufferedImage(Level.width, Level.height,
        BufferedImage.TYPE_INT_ARGB);
    offscr = offscreenImage.getGraphics();

    x = Level.width / 5;
    y = Level.height / 3;
    distance = Level.height / 6;
    fontSize = Level.size * 2;
  }

  /**
   * laad het board in het begin van het spel en tijdens het spel de hele tijd
   * opnieuw en tekent het op de offscr
   */
  // Heel belangrijk om .equals() te gebruiken, anders werkt methode niet
  public void drawBoard(String[][] board, String direction) {
    int i, j;
    for (i = 0; i < Level.blocksVer; i++) {
      for (j = 0; j < Level.blocksHor; j++) {
        // Wall
        if (board[i][j].equals("w")) {
          offscr.setColor(Color.black);
        }
        // Background
        else if (board[i][j].equals("b")) {
          offscr.setColor(Color.blue);
        }
        // Snake
        else if (board[i][j].equals("s")) {
          offscr.setColor(Color.red);
        }
        // Head of snake
        else if (board[i][j].equals("h")) {
          offscr.setColor(Color.red);
        }
        // Diamond
        else if (board[i][j].equals("d")) {
          offscr.setColor(Color.cyan);
        }
        // Endgate
        else if (board[i][j].equals("e")) {
          offscr.setColor(Color.yellow);
        }
        // Gate
        else if (board[i][j].startsWith("g")) {
          offscr.setColor(Color.magenta);
        } else
          System.out.println("foutje" + board[i][j]);

        offscr.fillRect(j * Level.size, i * Level.size, Level.size,
            Level.size);

        if (board[i][j].equals("h")) {
          snakeHead(i, j, direction);
        }

      }
    }
  }

  public void snakeHead(int i, int j, String direction) {
    offscr.setColor(Color.black);
    if (direction == "up") {
      offscr.fillRect(j * Level.size + Level.size / 5, i * Level.size
          + Level.size / 5, Level.size / 4, Level.size / 4);
      offscr.fillRect(j * Level.size + 3 * Level.size / 5, i * Level.size
          + Level.size / 5, Level.size / 4, Level.size / 4);
    } else if (direction == "down") {
      offscr.fillRect(j * Level.size + Level.size / 5, i * Level.size + 3
          * Level.size / 5, Level.size / 4, Level.size / 4);
      offscr.fillRect(j * Level.size + 3 * Level.size / 5, i * Level.size
          + 3 * Level.size / 5, Level.size / 4, Level.size / 4);
    } else if (direction == "right") {
      offscr.fillRect(j * Level.size + 3 * Level.size / 5, i * Level.size
          + Level.size / 5, Level.size / 4, Level.size / 4);
      offscr.fillRect(j * Level.size + 3 * Level.size / 5, i * Level.size
          + 3 * Level.size / 5, Level.size / 4, Level.size / 4);
    } else if (direction == "left") {
      offscr.fillRect(j * Level.size + Level.size / 5, i * Level.size
          + Level.size / 5, Level.size / 4, Level.size / 4);
      offscr.fillRect(j * Level.size + Level.size / 5, i * Level.size + 3
          * Level.size / 5, Level.size / 4, Level.size / 4);
    }
  }

  /**
   * Menu: startmenu om spel te beginnen
   */
  public void menu(int speed, String[][] board, boolean cont, String code,
      String direction) {
    drawBoard(board, direction);
    offscr.setColor(Color.black);
    Font font1 = new Font("Helvetica", Font.BOLD, fontSize);
    offscr.setFont(font1);
    offscr.drawString("[P]lay", x, y);
    offscr.drawString("[S]peed: " + convertSpeed(speed), x, y + distance);
    if (cont != true) {
      offscr.drawString("[C]ontinue", x, y + 2 * distance);
    } else if (cont == true) {
      offscr.drawString(code, x, y + 2 * distance);
    }

  }

  public void level(String[][] board, int level, String code, String direction) {
    drawBoard(board, direction);
    offscr.setColor(Color.black);
    Font font1 = new Font("Helvetica", Font.BOLD, fontSize);
    offscr.setFont(font1);
    offscr.drawString("Level: " + level, x, y);
    offscr.drawString("Code: " + code, x, y + distance);
    offscr.drawString("Press Enter to play", x, y + 2 * distance);
  }

  public void gameOver(String[][] board, String direction) {
    drawBoard(board, direction);
    offscr.setColor(Color.black);
    Font font1 = new Font("Helvetica", Font.BOLD, fontSize);
    offscr.setFont(font1);
    offscr.drawString("Game Completed!", x, y + distance / 2);
    offscr.drawString("Congratulations!", x, y + 2 * distance);
  }

  public String convertSpeed(int speed) {
    String speediness = null;
    if (speed == 25) {
      speediness = "Damn Fast";
    } else if (speed == 50) {
      speediness = "Fast";
    } else if (speed == 100) {
      speediness = "Medium";
    } else if (speed == 150) {
      speediness = "Slow";
    } else if (speed == 200) {
      speediness = "Very Slow";
    }
    return speediness;
  }

  // getter voor offscreenimage
  public Image getOffscr() {
    return offscreenImage;
  }
}
/*
 *
 * Copyright (c) 2010, L.L., Inc.
 *
 * All rights reserved.
 *
 */

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class Menu implements KeyListener {
  // booleans die snake aanbelangen (listen = luister naar key events)
  private boolean start;
  private boolean listen;
  private boolean cont;
  private boolean enter;
  private boolean escape;
  private boolean quit;

  // Code om te continuen
  private String code = "";
  // level om te continuen
  private int contLevel;

  public Menu() {
    // booleans invullen
    cont = false;
    start = false;
    enter = false;
    escape = false;
    quit = false;

    contLevel = 1;
  }

  public void keyPressed(KeyEvent e, Snake snake, Level level) {
    int c = e.getKeyCode();

    if (listen == true) {
      if (c == KeyEvent.VK_P) {
        start = true;
      } else if (c == KeyEvent.VK_C) {
        cont = true;
      } else if (c == KeyEvent.VK_S) {
        snake.increaseSpeed();
      }
      // oplossing om codes in te geven, numpad of gewoon
      else if ((95 < c && c < 106) || (47 < c && c < 58)) {
        String str = KeyEvent.getKeyText(c);
        // manier om bij numpad alleen nummer te gebruiken en niet
        // numpad_2 ofzo
        code = code + str.charAt(str.length() - 1);
        // System.out.println(code);
      } else if (c == KeyEvent.VK_ENTER) {
        enter = true;
        if (cont == true) {
          contLevel = level.tryCode(code);
          cont = false;
          code = "";
        }
      } else if (c == KeyEvent.VK_ESCAPE) {
        escape = true;
      }
    }
    listen = false;
    e.consume();
  }

  @Override
  public void keyPressed(KeyEvent e) {
  }

  @Override
  public void keyReleased(KeyEvent e) {
  }

  @Override
  public void keyTyped(KeyEvent e) {
  }

  /**
   * Getters en setters
   */
  public String getCode() {
    return code;
  }

  public int getContLevel() {
    return contLevel;
  }

  public void setContLevel(int level) {
    contLevel = level;
  }

  public boolean getStart() {
    return start;
  }

  public boolean getContinue() {
    return cont;
  }

  public boolean getEnter() {
    return enter;
  }

  public boolean getEscape() {
    return escape;
  }

  public boolean getQuit() {
    return quit;
  }

  public void setEnter(boolean b) {
    enter = b;
  }

  public void setListen(boolean b) {
    listen = b;
  }

  public void setStart(boolean b) {
    start = b;
  }

  public void setEscape(boolean b) {
    escape = b;
  }

  public boolean getListen() {
    return listen;
  }
}

Top

© 2010 All rights reserved.
Commentaar, vragen, feedback? --> javagames@telenet.be