// ######################################################################
// #                                                                    #
// #         ##   ####   ##   ##   ####   ##  ##   ####   ##  #####     #
// #         ##  ##  ##  ##   ##  ##  ##  ### ##  ##  ##  ##  ##  ##    #
// #         ##  ##  ##   ## ##   ##  ##  ######  ##  ##  ##  ##  ##    #
// #     ##  ##  ######   ## ##   ######  ## ###  ##  ##  ##  ##  ##    #
// #      ####   ##  ##    ###    ##  ##  ##  ##   ####   ##  #####     #
// #                                                                    #
// #    [][][][] - A BLOCK BREAKER APPLET BY REMI FAITOUT - [][][][]    #
// #    [][]  []                                            [][]  []    #
// #        o             VERSION 1.53 15/03/1998               o       #
// #      o==o                                                o==o      #
// #                                                                    #
// ######################################################################

// ## IMPORTS ###########################################################
import java.lang.*;
import java.applet.*;
import java.io.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.event.*;
import java.net.*;

// ## JAVANOID : THE MAIN CLASS #########################################
// The user interface that contains the game itself...

public class javanoid extends Applet implements ActionListener, ItemListener {
	
	// References
	jngame game;
	
	// User interface
	Panel control;
	Checkbox soundCheck;
	Choice speedChoice;
	Button startButton, demoButton;
	Button pauseButton, resumeButton;
	Button unlockButton, nextButton;
	
  // javanoid initialization
	public void init() {

		// Game init
		showStatus("Creating game objects...");
		game = new jngame(this);
		
		// User interface construction
		showStatus("Building user interface...");
		setLayout(new FlowLayout()); 
		setBackground(Color.lightGray);
		control = new Panel();
		control.setLayout(new GridLayout(0,1));
		control.add(startButton = new Button("START"));
		startButton.addActionListener(this);
		control.add(demoButton = new Button("DEMO"));
		demoButton.addActionListener(this);
		control.add(pauseButton = new Button("PAUSE"));
		pauseButton.addActionListener(this);
		control.add(resumeButton = new Button("RESUME"));
		resumeButton.addActionListener(this);
		control.add(unlockButton = new Button("UNLOCK"));
		unlockButton.addActionListener(this);
		control.add(new Label("SPEED", Label.CENTER));
		control.add(speedChoice = new Choice());
		speedChoice.addItemListener(this);
		speedChoice.addItem("MAXIMUM");
		speedChoice.addItem("FAST");
		speedChoice.addItem("AVERAGE");
		speedChoice.addItem("SLOW");
		speedChoice.addItem("MINIMUM");
		speedChoice.select(2);
		control.add(soundCheck = new Checkbox("SOUND"));
		soundCheck.addItemListener(this);
		control.doLayout();
		add(game);
		add(control);
		doLayout();
		
		// Start in demo mode
		showStatus("");
		game.startGame(true); 
		}

	// Event handler (panel)
	public void actionPerformed(ActionEvent evt) {
		Object src = evt.getSource();
		if (game!=null) {
			if (src==startButton) { game.stopGame(); game.startGame(false); } 
			else if (src==demoButton) { game.stopGame(); game.startGame(true); } 
			else if (src==pauseButton) game.stop();
			else if (src==resumeButton) game.start();
			else if (src==unlockButton) game.unlockBalls();
			}
		}
	public void itemStateChanged(ItemEvent evt) {
		Object src = evt.getSource();
		if (game!=null) {
			if (src==speedChoice) game.setAnimationDelay (2 + 5 * speedChoice.getSelectedIndex()); 
			else if (src==soundCheck) game.toggleSound();
			}
		}

	// Applet information methods
	public String getAppletInfo() { return "Applet Javanoid v1.53 by Rémi FAITOUT"; }	
	}
	

// ## JAVANOID GAME CLASS ###############################################
// Main class for javanoid : It manages all the game objects, their lives, 
// collisions, both the user and game events (moves, bullets, pills and
// balls throws, next level, ...).  

final class jngame extends jnbuffer implements Runnable, MouseListener, MouseMotionListener {

	// Game default size
	final static int defaultWidth = 312;
	final static int defaultHeight = 300;
	
	// File names
	final static String imageFile = "javanoid.gif";
	final static String soundFiles[] = {"start.au", "wall.au", "shoot.au"};
	final static String levelFile = "javanoid.dat";
	
	// Number of images per object
	final static int nbBallImg = 2;	
	final static int nbPaddleImg = 4;
	final static int nbBlockImg = 16;					
	final static int nbPillImg = 6;
	final static int nbPillImgAnim = 4;
	final static int nbBulletImg = 1;

	// Number of sound files
	final static int nbSounds = 3;

	// Size & coordinates of the images
	final static int blockCoords[][] = { 
		{0 , 0, 24, 16}, {0 , 16, 24, 16}, {0 , 32, 24, 16}, {0 , 48, 24, 16}, 
		{24, 0, 24, 16}, {24, 16, 24, 16}, {24, 32, 24, 16}, {24, 48, 24, 16},
		{48, 0, 24, 16}, {48, 16, 24, 16}, {48, 32, 24, 16}, {48, 48, 24, 16},
		{72, 0, 24, 16}, {72, 16, 24, 16}, {72, 32, 24, 16}, {72, 48, 24, 16}};
	final static int ballCoords[][] = { 
		{0, 64, 12, 12}, {12, 64, 12, 12}};
	final static int paddleCoords[][] = { 
		{24, 64, 40, 12}, {64, 64, 32, 12}, {0, 76, 48, 12}, {48, 76, 40, 12} };
	final static int bulletCoords[][] = {
		{88, 82, 4, 6}};
	final static int pillCoords[][][] = {
		{{0,  88, 16, 8}, {0,  96, 16, 8}, {0, 104, 16, 8}, {0, 112, 16, 8}},
		{{16,  88, 16, 8}, {16,  96, 16, 8}, {16, 104, 16, 8}, {16, 112, 16, 8}}, 
		{{32,  88, 16, 8}, {32,  96, 16, 8}, {32, 104, 16, 8}, {32, 112, 16, 8}}, 
		{{48,  88, 16, 8}, {48,  96, 16, 8}, {48, 104, 16, 8}, {48, 112, 16, 8}}, 
		{{64,  88, 16, 8}, {64,  96, 16, 8}, {64, 104, 16, 8}, {64, 112, 16, 8}}, 
		{{80,  88, 16, 8}, {80,  96, 16, 8}, {80, 104, 16, 8}, {80, 112, 16, 8}}};

	// Arrays for images
	protected Image ballImg[] = new Image[nbBallImg];
	protected Image paddleImg[] = new Image[nbPaddleImg];
	protected Image blockImg[] = new Image[nbBlockImg];
	protected Image pillImg[][] = new Image[nbPillImg][nbPillImgAnim];	
	protected Image bulletImg[] = new Image[nbBulletImg];

	// Array for sounds
	protected AudioClip sounds[] = new AudioClip[nbSounds];

	// Level definitions
	final static int nbLevels = 12;
	final static int nbLevelRows = 12;
	final static int nbLevelCols = 13;
	final static int colWidth = 24;
	final static int rowHeight = 16;	
	protected String levelNames[] = new String[nbLevels];
  protected String levelDefinitions[][] = new String[nbLevels][nbLevelRows];

	// Current level definition
	protected int currentLevel = 0;
	protected int nbBlocksLeft = 0;	
	protected jnblock levelMap[][] = new jnblock[nbLevelCols][nbLevelRows];

	// Game default attributes
	final static int nbPills = 4;
	final static int nbBullets = 8;
	final static int nbBalls = 3;
	final static int displayAlt = 90;
	final static int paddleAlt = 40;
	final static int scoreAlt = 20;
	final static int nbPillValues = 6;
	
	// Idle time during the run loop
	protected int animationDelay = 12;

	// Current sound
	protected int currentSound = 0;
	
	// Flags for game state
	protected boolean goToNext = false;
	protected boolean demoMode = false;
	protected boolean fireMode = false;
	protected boolean soundOn = false;
	protected boolean gameover = false;
	
	// Javanoid objects
	protected jnstatus status;
	protected jnpill pills[] = new jnpill[nbPills];
	protected jnbullet bullets[] = new jnbullet[nbBullets];
	protected jnball balls[] = new jnball[nbBalls];
	protected jnpaddle paddle;
	
	// References
	Thread myThread;
	Applet applet;
	
	// Constructor
	public jngame (Applet a) {
		
		// Canvas init
		super(a, defaultWidth, defaultHeight);
		applet = a;

		// Loading images
		applet.showStatus("Loading images...");
		MediaTracker tracker = new MediaTracker(applet);
		URL url = applet.getCodeBase();		
		Image imageTmp = applet.getImage(url, imageFile);
		tracker.addImage(imageTmp, 0);
		ImageFilter filter;
		
		// Extracting images
		for (int i=0; i<nbBlockImg; i++) {
			filter = new CropImageFilter(blockCoords[i][0], blockCoords[i][1], blockCoords[i][2], blockCoords[i][3]);
			blockImg[i] = applet.createImage(new FilteredImageSource(imageTmp.getSource(), filter));
			tracker.addImage(blockImg[i], 0);
			}
		for (int i=0; i<nbBallImg; i++) {
			filter = new CropImageFilter(ballCoords[i][0], ballCoords[i][1], ballCoords[i][2], ballCoords[i][3]);
			ballImg[i] = applet.createImage(new FilteredImageSource(imageTmp.getSource(), filter));
			tracker.addImage(ballImg[i], 0);
			}
		for (int i=0; i<nbPaddleImg; i++) {
			filter = new CropImageFilter(paddleCoords[i][0], paddleCoords[i][1], paddleCoords[i][2], paddleCoords[i][3]);
			paddleImg[i] = applet.createImage(new FilteredImageSource(imageTmp.getSource(), filter));
			tracker.addImage(paddleImg[i], 0);
			}
		for (int i=0; i<nbPillImg; i++) {
			for (int j=0; j<nbPillImgAnim; j++) {
				filter = new CropImageFilter(pillCoords[i][j][0], pillCoords[i][j][1], pillCoords[i][j][2], pillCoords[i][j][3]);
				pillImg[i][j] = applet.createImage(new FilteredImageSource(imageTmp.getSource(), filter));
				tracker.addImage(pillImg[i][j], 0);
				}
			}
		for (int i=0; i<nbBulletImg; i++) {
			filter = new CropImageFilter(bulletCoords[i][0], bulletCoords[i][1], bulletCoords[i][2], bulletCoords[i][3]);
			bulletImg[i] = applet.createImage(new FilteredImageSource(imageTmp.getSource(), filter));
			tracker.addImage(bulletImg[i], 0);
			}

		// Waiting for completion
		try { tracker.waitForAll(); }
		catch (InterruptedException e) {}

		// Loading sounds
		applet.showStatus("Loading sounds...");
		for (int i=0;i<nbSounds;i++) {
			sounds[i] = applet.getAudioClip(url, soundFiles[i]);
			try { Thread.sleep(100); } 
			catch (InterruptedException e) { }
			}

		// Loading levels
		applet.showStatus("Loading levels...");
		try {
			String line;
			URL url2 = new URL(applet.getCodeBase(), levelFile);
			URLConnection cnx = url2.openConnection();
			BufferedReader br = new BufferedReader(new InputStreamReader(cnx.getInputStream())); 
			for (int l=0;l<nbLevels;l++) {
				levelNames[l]=br.readLine();
				for (int r=0;r<nbLevelRows;r++) { levelDefinitions[l][r] = br.readLine(); }
				}
			br.close();
      }
		catch (FileNotFoundException e) { System.out.println("File " + levelFile + "not found."); } 
		catch (IOException e) { System.out.println("File " + levelFile + " is corrupt : " + e); }
		
		// Status & level init
		applet.showStatus("Creating game objects...");
		status = new jnstatus(this, ballImg[0], scoreAlt, displayAlt);

		// Adding event handlers
		addMouseListener(this);
		addMouseMotionListener(this);
		}
		
	// Start in demo or game mode
	void startGame(boolean d) {

		// Game, status & level reset
		demoMode = d; 
		goToNext = false; 
		fireMode = false;
		gameover = false;
		currentLevel = 0;		
	  clearBackground();
		computeLevel();
		status.reset();
		
		// Objects creation
		paddle = new jnpaddle(this, paddleImg, paddleAlt, true);
		balls[0] = new jnball(this, paddle, ballImg);
		
		// Automatic start or level name display
		if (demoMode) { 
			status.showHiScore(); 
			balls[0].launch(); 
			}
		else status.showName(levelNames[currentLevel]);

		// Starts the thread
		start();
		}

	// End level & resets the game
	void stopGame() {

		// Reset game objects
		for (int i=0;i<nbBalls;i++) balls[i] = null;
		for (int i=0;i<nbPills;i++) pills[i] = null;
		for (int i=0;i<nbBullets;i++) bullets[i] = null;
		paddle = null;

		// Force garbage collection
		System.gc();
		
		// Stop the thread
		stop();
		}
	
	// Start & stop methods
	public void stop() {
		if (myThread!=null) myThread.stop();
		myThread=null;
		}	
	public void start() { 
		if (myThread == null) {
			myThread = new Thread(this); 
			myThread.setPriority(Thread.MIN_PRIORITY);
			myThread.start(); 
			}
		}

	// Run method
	public synchronized void run() {
	
		while (Thread.currentThread()==myThread) {

			// Sleep for animation delay
			try { Thread.sleep(animationDelay); } 
			catch (InterruptedException e) { }

			// Level life
			if ((nbBlocksLeft==0) || goToNext) jumpToNextLevel();

			// Paddle move
			if (paddle != null) {
				if (demoMode) { paddle.followBall(balls[0].getX() + balls[0].getWidth() / 2); }	
				paddle.live();	
				}

			// Ball move
			for (int i=0;i<nbBalls;i++) { 	
				if (balls[i] != null) {
					if (balls[i].isAlive()) balls[i].live();
					else ballLost(i);
					}
				}

 			// Pills move
			for (int i=0;i<nbPills;i++) {
				if (pills[i] != null) {
					if (pills[i].isAlive()) pills[i].live();
					else pills[i]=null;
					}
				}

			// Bullets move
			for (int i=0;i<nbBullets;i++) {
				if (bullets[i] != null) {
					if (bullets[i].isAlive()) bullets[i].live();
					else bullets[i]=null;
					}
				}

			// Repaint & notify the applet thread
			repaint(); 

			// Wait for notify
			try { wait(); } 
			catch (InterruptedException e) { }
			
			// Stops if gameover is set
			if (gameover) stopGame();
			}
		}

	// Ball launch
	public void launchBall() { 
		if (!demoMode) {
			if (fireMode) throwBullet(paddle.getX() + paddle.getWidth() / 2, paddle.getY());
			else { 
				status.hideName(); 
				for (int i=0;i<nbBalls;i++) { 
					if ((balls[i]!=null) && (!balls[i].isLaunched())) balls[i].launch(); 
					}
				}
			}
		}

	// Paddle move
	public void movePaddle (int x) { if ((!demoMode) && (paddle!=null)) paddle.followMouse(x); }

	// Pill events
	public void pillEvent (int v) {

		// Reseting objects	
		paddle.setNormal(); fireMode = false;
		for (int i=0;i<nbBalls;i++) { 
			if (balls[i]!=null) {
				balls[i].setKiller(false);
				balls[i].setGlue(false);
				if (!balls[i].isLaunched()) { balls[i].launch(); }
				}
			}
		switch(v) {

			// Set multi-ball mode		
			case 0: 
				throwMultiBall(); 
				break;

			// Set fire mode
			case 1: 
				paddle.setFire(); 
				fireMode = true; 
				break;

			// Set glue mode
			case 2: 
				for (int i=0;i<nbBalls;i++) { 
					if (balls[i]!=null) balls[i].setGlue(!demoMode); 
					} 
				break;

			// Set big paddle				
			case 3: 
				paddle.setBig(); 
				break;

			// Set small paddle
			case 4: 
				paddle.setSmall(); 
				break;

			// Add bonus life, bonus score or gives super ball !
			case 5: 
				switch((int)(6 * Math.random())) {
					case 0: 
						status.addLife(); 	
						break;
					case 1: 
						for (int i=0;i<nbBalls;i++) { 
							if (balls[i]!=null) balls[i].setKiller(true); 
							} 
						break;
					default: 
						status.addBonus(); 
						break;
					}
				break;											
			}
		}

	// Next level
	void jumpToNextLevel() {

		// Reset current level
		for (int i=0;i<nbPills;i++) pills[i] = null;
		for (int i=0;i<nbBullets;i++) bullets[i] = null;
		for (int i=0;i<nbBalls;i++) balls[i] = null;
		goToNext = false;
		
		// Force garbage collection
		System.gc();
		
		// Compute the same level in demo mode
		if (demoMode) {
			clearBackground();
			computeLevel();
			status.sameLevel();
			}
		// Compute next level
		else {
			currentLevel++;
			if (currentLevel>=nbLevels) currentLevel = 0;
		  clearBackground();
			computeLevel();
			status.addLevel(); 
			}
			
		// New ball & paddle reset
		balls[0] = new jnball(this, paddle, ballImg); 
		paddle.setNormal(); 
		fireMode = false; 

		// Automatic start or level name display whether demo or not
		if (demoMode) balls[0].launch();
		else status.showName(levelNames[currentLevel]);
		}

	void computeLevel() {
		char blockRow[];
		nbBlocksLeft = 0;
		for (int y=0;y<nbLevelRows;y++) { 
			for (int x=0;x<nbLevelCols;x++) { 
				levelMap[x][y] = null; 
				} 
			}
		for (int r=0;r<nbLevelRows;r++) {
			blockRow = levelDefinitions[currentLevel][r].toCharArray();
			for (int c=0;c<nbLevelCols;c++) {
				switch(blockRow[c]) {
				  case 'F':	
						levelMap[c][r] = new jnblock(this, blockImg[15], c, r, -1); 
						break; 
					case 'E': 
						levelMap[c][r] = new jnblock(this, blockImg[14], c, r, 2); 
						nbBlocksLeft++; 
						break;
				  case 'D':	
						levelMap[c][r] = new jnblock(this, blockImg[13], c, r, 0); 
						nbBlocksLeft++; 
						break; 
					case 'C': 
						levelMap[c][r] = new jnblock(this, blockImg[12], c, r, 0); 
						nbBlocksLeft++; 
						break;
				  case 'B':	
						levelMap[c][r] = new jnblock(this, blockImg[11], c, r, 0); 
						nbBlocksLeft++;
						break; 
					case 'A': 
						levelMap[c][r] = new jnblock(this, blockImg[10], c, r, 0); 
						nbBlocksLeft++; 
						break;
					case '9' : case '8' : case '7' : case '6' : case '5' : 
					case '4' : case '3' : case '2' : case '1' : case '0' : 
						levelMap[c][r] = new jnblock(this, blockImg[blockRow[c] - '0'], c, r, 0); 
						nbBlocksLeft++; break;
					default : levelMap[c][r] = null; 
						break;
					}
				}		
			}
		}

	// Ball lost
	void ballLost(int j) {
		balls[j]=null;
		if (j==0) {
			boolean found = false;
			for (int i=1;i<nbBalls;i++) {
				if ((balls[i]!=null) && (!found)) { 
					balls[0]=balls[i]; 
					balls[i]=null; 
					found = true; 
					}
				}
			if (!found) {
				for (int i=0;i<nbPills;i++) pills[i] = null;
				for (int i=0;i<nbBullets;i++) bullets[i] = null;
				status.removeLife();
				
				// Game Over ...
				if (status.getLives() < 0) { 				
					status.showGameOver();
					gameover = true;
					}

				// Next ball
				else {
					balls[0] = new jnball(this, paddle, ballImg);
					paddle.setNormal(); 
					fireMode = false;
					}
				}
			}
		}

	// Pill throwing
	void throwPill(int x, int y) {
		int i = 0; int v = (int)(nbPillValues * Math.random());
		while ((i<nbPills) && (pills[i]!=null)) i++; 
		if (i<nbPills) pills[i] = new jnpill(this, paddle, pillImg[v], v, x, y);
		}
	// Bullet throwing
	void throwBullet(int x, int y) {
		int i = 0; 
		while ((i<nbBullets) && (bullets[i]!=null)) i++; 
		if (i<nbBullets) bullets[i] = new jnbullet(this, bulletImg[0], x, y);
		}
	// MultiBallThrowing
	void throwMultiBall() {
		for (int i=1;i<nbBalls;i++) {
			if (balls[i]==null) {
				balls[i] = new jnball(this, paddle, ballImg, balls[0], i);
				}
			}
		}

	// Collision detection & effects for blocks
	public jnblock block(int x, int y) {
		int c = x / colWidth; int r = y / rowHeight; 
		if ((c<nbLevelCols) && (r<nbLevelRows)) return levelMap[c][r];
		else return null;
		}
	public boolean hitBlock(int x, int y, boolean kill) { 
		int c = x / colWidth; int r = y / rowHeight;
		boolean found = ((c<nbLevelCols) && (r<nbLevelRows) && (levelMap[c][r]!=null));
		if (found) {
			if (kill) {
				if (levelMap[c][r].kill()) {
					nbBlocksLeft--; 
					status.addScore(); 
					if (Math.random()<0.2) throwPill(x, y);
					}
				levelMap[c][r] = null;
				}
			else if (levelMap[c][r].hit()) { 
				nbBlocksLeft--; 
				levelMap[c][r] = null;
				status.addScore(); 
				if (Math.random()<0.2) throwPill(x, y);
				}
			}
		return ((found) && (!kill));
		}		

	// Forced jump to next level
	public void forceNextLevel () { goToNext = true; }

	// Unlock balls when no solutions
	public void unlockBalls() {
		for (int i=0;i<nbBalls;i++) { if (balls[i]!=null) balls[i].setRandomDX(); }
		}

	// Animation delay setting
	public void setAnimationDelay(int d) { animationDelay = d; }
	
	// Sound play
	public void playStart() { playSound(0, false); }
	public void playTouch() { playSound(1, false); }
	public void playHit() { playSound(2, false); }
	public void playSound (int i, boolean l) {
		if ((soundOn) && (i<nbSounds)) {
			sounds[currentSound].stop();
			currentSound = i;
			if (l) sounds[currentSound].loop();
			else sounds[currentSound].play();
			}
		}
	public void toggleSound() { 
		if (soundOn) sounds[currentSound].stop();
		soundOn = (!soundOn);
		}

	// Event handlers
	public void mouseClicked(MouseEvent evt) { }
	public void mouseEntered(MouseEvent evt) { }
	public void mouseExited(MouseEvent evt) { }
	public void mousePressed(MouseEvent evt) {
		if (demoMode || gameover) { 
			stopGame(); 
			startGame(false); 
			}
		else launchBall();
		}
	public void mouseReleased(MouseEvent evt) { }
	public void mouseDragged(MouseEvent evt) { 
		movePaddle(evt.getX()); 
		}
	public void mouseMoved(MouseEvent evt) { 
		movePaddle(evt.getX()); 
		} 
	}

// ## JAVANOID STATUS CLASS #############################################
// This class maintains and displays the state of the game (score, lives 
// & level). 

final class jnstatus {

	// strings for display
	final static String appletString1 = "JAVANOID V1.53";
	final static String appletString2 = "by Rémi Faitout";
	final static String scoreString = "SCORE : ";
	final static String levelString = "LEVEL : ";
	final static String livesString = "LIVES : ";
	final static String hiScoreString = "HIGH SCORE : ";
	final static String gameOverString = "GAME OVER";
	
	// default game settings
	final static int nbLives = 2;	
	final static int maxLives = 5;
	final static int lifeSize = 12;
	final static int hitScore = 10;
	final static int bonusScore = 100;
	final static int levelScore = 500;

	// status values
	protected int hiScore = 1000; 
	protected int score = 0;
	protected int lives = 0;
	protected int level = 0;

	// String positions	
	protected int scoreX, scoreXX, livesX, livesXX, levelX, namesX;
	protected int statusY, textY, namesY, livesY;
	protected int width, height;	
	protected int livesWidth, scoreWidth, levelWidth;

	// display the level name or not	
	protected boolean nameDisplay;
	
	jnbuffer buffer;
	Image lifeImage;
	
	// Constructor
	public jnstatus(jnbuffer b, Image i, int alt1, int alt2 ) {
		buffer = b;
		lifeImage = i;
		width = buffer.getWidth();
		height = buffer.getStringHeight();	
		livesX = 1 * width / 18; 
		levelX = 8 * width / 18; 
		scoreX = 12 * width / 18; 
		namesX = width / 2;
		livesXX = livesX + buffer.getStringWidth(livesString);
		scoreXX = scoreX + buffer.getStringWidth(scoreString);
		statusY = buffer.getHeight() - alt1;
		namesY = buffer.getHeight() - alt2;
		livesY = statusY - lifeSize + buffer.getStringHeight();
		nameDisplay = false;
		}
			
	// Actions on the status : add or remove
	public void addLife() { 
		if (lives<maxLives) buffer.drawPermanentImage(lifeImage, livesXX + lives * lifeSize, livesY); 
		lives++;  
		}
	public void removeLife() { lives--; set();}
	public void addLevel() { level++; score+=levelScore; set();}
	public void sameLevel() { score=0; set(); }
	public void addScore() { score+=hitScore; setScore();}
	public void addBonus() { score+=bonusScore; set(); }

	// hiding or showing the level name
	public void showName(String s) {
		nameDisplay = true;
		buffer.drawPermanentString(s, namesX - buffer.getStringWidth(s) / 2, namesY + height);
		}
	public void hideName() {
		if (nameDisplay) buffer.clearPermanentImage(0, namesY, width, height);
		}

	// showing high scores
	public void showHiScore() { 
		int h = (int)(height/2);
		String scoreString = hiScoreString + hiScore;
		buffer.drawPermanentString(appletString1, namesX - buffer.getStringWidth(appletString1) / 2, namesY - 2*h);
		buffer.drawPermanentString(appletString2, namesX - buffer.getStringWidth(appletString2) / 2, namesY + h);
		buffer.drawPermanentString(scoreString, namesX - buffer.getStringWidth(scoreString) / 2, namesY + 5*h);		
		}
	public void showGameOver() {
		int h = (int)(height/2);	
		buffer.drawString(gameOverString, namesX - buffer.getStringWidth(gameOverString) / 2, namesY + h);
		}
	
	// tell whether it's a high score
	public boolean isHighScore() { return (score > hiScore); } 
		
	// reset & set (partial or not) : Draw the status on the buffer
	public void reset() { 
		if (score > hiScore) hiScore = score;
		lives = nbLives; 
		level = 1; 
		score = 0; 
		set();
		}
	void set() {
		buffer.clearPermanentImage(0, statusY, width, height);
		buffer.drawPermanentString(livesString, livesX, statusY + height);
		for (int i=0;i<lives;i++) { 
			if (i<maxLives) buffer.drawPermanentImage(lifeImage, livesXX + i * lifeSize, livesY); 
			}
		buffer.drawPermanentString(levelString + level, levelX, statusY + height);
		buffer.drawPermanentString(scoreString + score, scoreX, statusY + height);
		}
	void setScore() {
		buffer.clearPermanentImage(scoreXX, statusY, width - scoreXX, height);
		buffer.drawPermanentString(String.valueOf(score), scoreXX, statusY + height);
		}

	public int getLives() { return lives; }
	public int getScore() { return score; }
	}
		
// ## JAVANOID BALL CLASS ###############################################
// This class represents the balls in the game : they are moving object 
// that have a really hard life (paddle & block collisions)

final class jnball extends jnmovingobject {

	// default attributes
	final static int defaultSpeed = 6;
	final static int defaultWidth = 12;
	final static int defaultHeight = 12;
	final static int defaultImage = 0;
	
	// ball speed (speed^2 = dx^2 + dy^2)
	protected int speed;
	
	// ball mode
	protected boolean launched = false;
	protected boolean glueMode = false;
	protected boolean killMode = false;

	// Default direction & position
	protected int defaultDX = 3;
	protected int posX = 0, posY = 0;
	
	Image images[];
	jngame game;
	jnpaddle paddle;
	
	// Constructor for a normal single ball
	public jnball(jngame g, jnpaddle p, Image i[]) {
		super(g, i[0], defaultWidth, defaultHeight, p.getX() + p.getWidth() / 2, p.getY() - defaultHeight, 0, 0);
		game = g;
		paddle = p;
		images = i;
		speed = defaultSpeed;
		posX = (paddle.getWidth() - width) / 2; 
		posY = - height;
		}
	// Constructor for the second or third ball of the game
	public jnball(jngame g, jnpaddle p, Image i[], jnball b, int n) {
		super(g, i[0], defaultWidth, defaultHeight, b.getX(), b.getY(), 0, 0);
		game = g;
		paddle = p;
		images = i;
		speed = defaultSpeed;
		posX = (paddle.getWidth() - width) / 2; 
		posY = - height;
		if (n==1) setBallDX(b.getDX() + 1, (b.getDY()<0));
		else setBallDX(b.getDX() - 1, (b.getDY()<0)); 
		launched = true;
		}

	// ball launch & live methods
	public void launch() { 
		if (!glueMode) { 
			game.playStart(); 
			setBallDX(defaultDX, true); 
			}
		launched = true; 
		}
		
	// ball life (paddle & block detection)
	public void live() {
		int oldX = X; 
		int oldY = Y;

		// Follow paddle when not launched
		if (!launched) { X = paddle.getX() + posX; Y = paddle.getY() + posY; }
		
		// Ball movement
		super.live();

		if (launched) {
			if (dY > 0) {
				// Paddle hit 
				if (paddle.isHit(X + width / 2, Y + height)) {
					if (glueMode) { 
						launched = false; 
						posX = X - paddle.getX(); 
						posY = Y - paddle.getY(); 
						}
					setBallDX(paddle.hit(X + width / 2, dX, speed), true); 
					}
				else if (game.hitBlock(X + width / 2, Y + height, killMode)) invertDY();
				}
			else if (game.hitBlock(X + width / 2, Y, killMode)) invertDY(); 
			if (dX < 0) { 
				if (game.hitBlock(X, Y + height / 2, killMode)) invertDX();	 
				}
			else if (game.hitBlock(X + width, Y + height / 2, killMode)) invertDX(); 
			}
		}
	
	// Ball settings
	public void setBallDX (int d, boolean b) { 
		dX = d; 
		dY = (int)(Math.max(Math.sqrt((double)(speed * speed - dX * dX)), 1));
		if (b) dY = - dY; 
		}
	public void setSpeed (int s) { speed = s; }
	public void setGlue (boolean g) { glueMode = g; }
	public void setKiller (boolean g) { 
		killMode = g; 
		if (killMode) change(images[1], defaultWidth, defaultHeight);
		else change(images[0], defaultWidth, defaultHeight);
		}
	public void setRandomDX() { 
		setBallDX((int)((speed - 1) * (2 * Math.random() - 1)), false);
		}

	// Ball requests
	public int getSpeed() { return speed; }
	public boolean isLaunched() { return launched; }
	}

// ## JAVANOID PILL CLASS ###############################################
// This class represents the pills in the game : They are moving objects 
// with a value that gives their effects on the game when they're catched 
// by the paddle

final class jnpill extends jnmovingobject {

	// Default attributes
	final static int defaultSpeed = 3;
	final static int defaultWidth = 16;
	final static int defaultHeight = 8;
	
	// Animation frame
	protected int pillNbFrames;
	protected double pillStep = 0.25;
	protected double pillFrame;
	
	// Values gives the effect
	protected int pillValue;

	Image images[];
	jngame game;
	jnpaddle paddle;

	// Constructor
	public jnpill(jngame g, jnpaddle p, Image i[], int v, int bx, int by) {
		super(g, i[0], defaultWidth, defaultHeight, bx, by, 0, defaultSpeed);
		game = g;
		paddle = p; 
		images = i;
		pillNbFrames = images.length;
		pillValue = v;
		pillFrame = 0;
		}

	// Pill life (paddle detection + dies when at the bottom of the screen)
	public void live() {
	
		// Pill animation
		pillFrame+=pillStep;
		if (pillFrame>=pillNbFrames) pillFrame = 0;
		change(images[(int)pillFrame], defaultWidth, defaultHeight);

		// Pill move
		super.live();

		// Pill death
		if (paddle.isHit(X + width / 2, Y + height)) {
			game.playHit(); 
			game.pillEvent(pillValue); 
			die(); 
			}
		}
	}
	
// ## JAVANOID BULLET CLASS #############################################
// This class represents the paddle bullets : They are very similar to 
// pills except they move from bottom to top and hit the blocks.

final class jnbullet extends jnmovingobject {

	final static int defaultSpeed = 6;
	final static int defaultWidth = 4;
	final static int defaultHeight = 6;

	jngame game;	
	
	// Constructor
	public jnbullet(jngame g, Image i, int px, int py) {
		super(g, i, defaultWidth, defaultHeight, px, py, 0, - defaultSpeed);
		game = g;
		}

	public void live() {
		super.live();
		if ((dY > 0) || (game.hitBlock(X + width / 2, Y, false))) { die(); }
		}
	}

// ## JAVANOID PADDLE CLASS #############################################
// This class represents the paddle in the game : It a 'static' object 
// that can be moved to a position (ex : mouse position). It also gives 
// the direction of the ball.

final class jnpaddle extends jnobject {

	// Default attributes
	final static int defaultWidth = 40;
	final static int defaultWidthBig = 48;
	final static int defaultWidthSmall = 32;
	final static int defaultHeight = 12;
	final static int defaultImage = 0;

	// Mouse position
	protected int minX, maxX;	
	protected int newX;
	protected boolean demo;
	
	jngame game;
	Image images[];
	
	// Constructor
	public jnpaddle (jngame g, Image[] i, int alt, boolean d) { 
		super(g, i[0], defaultWidth, defaultHeight, (g.getWidth() - defaultWidth) / 2, g.getHeight() - alt);
		game = g;
		images = i;
		demo = d;
		minX = 0; 
		maxX = game.getWidth() - defaultWidth;
		newX = X;
		}

	// Paddle life (move to the saved position)
	public void live() { 
		setX(newX); 
		super.live();	
		}
	
	// Paddle settings
	public int hit(int bx, int bdx, int s) {
		int ndx = 2 * s * (bx - X - width / 2) / width; 
		game.playTouch(); 
		return (ndx==0) ? bdx : ndx;
		}

	// Methods of controls
	public void followBall (int bx) { newX = bx - width / 2; }
	public void followMouse (int mx) { newX = mx - width / 2; }
	public void followArrows (int dx) { newX = newX + dx; }
	
	// Paddle settings
	public void setNormal() { change(images[0], defaultWidth, defaultHeight); }
	public void setSmall () { change(images[1], defaultWidthSmall, defaultHeight); }
	public void setBig () { change(images[2], defaultWidthBig, defaultHeight); }
	public void setFire () { change(images[3], defaultWidth, defaultHeight); }
	}
	
// ## JAVANOID BLOCK CLASS ##############################################
// Blocks are basic 'static object', except they die after a certain 
// number of hits. As they don't move at all, they are drawn or erased on 
// the permanent buffer.

final class jnblock extends jnobject {

	final static int defaultWidth = 24;
	final static int defaultHeight = 16;
	final static int defaultImage = 0;

	// i.e. nb hits before it dies
	protected int resistance;	

	// position in the level	
	protected int column, row;
	
	jngame game;
	
	// Constructor
	public jnblock (jngame g, Image i, int col, int row, int r) {
		super(g, i, defaultWidth, defaultHeight, col * defaultWidth, row * defaultHeight);
		game = g;
		resistance = r;
		}

	// Life : no drawing there !!!
	public void live() {}	
	
	// Blocks are "permanent" images : Draw on the background & erase
	public void draw() { buffer.drawPermanentImage(image, X, Y); }
	public void clear() { buffer.clearPermanentImage(X, Y, width, height); }

	// Death depends on resistance
	public void die() { 
		if (resistance==0) { 
			clear(); 
			super.die(); 
			} 
		else resistance--; 
		}
	
	// Hit method (tells if it dies or not)
	public boolean hit() { 
		die(); 
		if (alive) game.playTouch(); 
		else game.playHit(); 
		return alive ? false : true;
		}
		
	// Kill method (dies & tells if it's a gold one)
	public boolean kill() { 
		clear(); 
		super.die(); 
		return (resistance >= 0); 
		}
	}
	
// ## JAVANOID BUFFER CLASS #############################################
// This class implements a sort of triple buffer : one for the background 
// image & the objects that you draw for a long time, one where the moving 
// objects are drawn, and one for display (see update method).

abstract class jnbuffer extends Panel {

	// Width & height of the game canvas
	protected int width;
	protected int height;
	protected int numBackground = 0;
	protected int nbBackgrounds = 6;
	protected int backgroundColors[][] = {
		{255, 191, 0  , 0  , 191, 0  , 0  , 0  , 255, 0  , 191, 255}, // yellow, green, blue & cyan
		{0  , 191, 255, 0  , 0  , 255, 255, 0  , 0  , 255, 0  , 255}, // cyan, blue, red & pink
		{255, 0  , 255, 255, 0  , 0  , 0  , 191, 0  , 255, 191, 0  }, // pink, red, green & yellow
		{255, 191, 0  , 255, 0  , 0  , 0  , 0  , 255, 255, 0  , 255}, // yellow, red, blue & pink
		{255, 0  , 255, 0  , 0  , 255, 0  , 191, 0  , 0  , 191, 255}, // pink, blue, green & cyan
		{0  , 191, 255, 0  , 191, 0  , 255, 0  , 0  , 255, 191, 0  }};// cyan, green, red & yellow
		 
	Applet applet;

	// On & off graphics for triple (!) buffering
	Graphics offGraphics, offBackGraphics;

	// Fontmetrics object
	FontMetrics fontMetrics;

	// Buffer & background images
	Image offImage, offBackImage, backImage;
	Dimension minSize;

	// Font style for text
	Font textFont = new Font("SansSerif", Font.BOLD, 12);

	// Color for texts & background
	Color textColor = new Color (255, 223, 0);
	Color backColor = new Color (0, 0, 0);
	
	// Constructor
	public jnbuffer (Applet a, int w, int h) { 
		applet = a; 
		width = w; 
		height = h;

		// Off backround graphics : "Permanent" background graphics
		offBackImage = applet.createImage(width, height);
		offBackGraphics = offBackImage.getGraphics();
		offBackGraphics.setColor(textColor);
		offBackGraphics.setFont(textFont);

		// Off graphics : Double buffer graphics
		offImage = applet.createImage(width, height);
		offGraphics = offImage.getGraphics();
		offGraphics.setColor(textColor);
		offGraphics.setFont(textFont);

		// Dimension
		fontMetrics = offGraphics.getFontMetrics();
		minSize = new Dimension(width, height);
		setSize(width, height);
		clearBackground();
		}

	// Compute background image
	void computeBackground() {
		int[] pix = new int[width * height];
		int index = 0;
		double alphai, alphaj, betai, betaj;
		int r1, r2, r, g1, g2, g, b1, b2, b;
		if (numBackground >= nbBackgrounds) numBackground = 0;

		// Make a fade between the four corner colors
		for (int j=0;j<height;j++) {
			alphaj = (double)j / (height - 1);
			betaj = 1.0 - alphaj;
			r1 = (int)(backgroundColors[numBackground][3]*alphaj + backgroundColors[numBackground][0]*betaj);
			r2 = (int)(backgroundColors[numBackground][9]*alphaj + backgroundColors[numBackground][6]*betaj);
			g1 = (int)(backgroundColors[numBackground][4]*alphaj + backgroundColors[numBackground][1]*betaj);
			g2 = (int)(backgroundColors[numBackground][10]*alphaj + backgroundColors[numBackground][7]*betaj);
			b1 = (int)(backgroundColors[numBackground][5]*alphaj + backgroundColors[numBackground][2]*betaj);
			b2 = (int)(backgroundColors[numBackground][11]*alphaj + backgroundColors[numBackground][8]*betaj);
			for (int i=0;i<width;i++) {
				alphai = (double)i / (width - 1);
				betai = 1.0 - alphai;
				r = (int)(r2*alphai + r1*betai);
				g = (int)(g2*alphai + g1*betai);
				b = (int)(b2*alphai + b1*betai);
				pix[index++] = (255 << 24) | (r << 16) | (g << 8) | b;
				}
			}
		backImage = applet.createImage(new MemoryImageSource(width, height, pix, 0, width));

		// Next background
		numBackground++;
		}

	public void drawImage(Image i, int x, int y) { 
		offGraphics.drawImage(i, x, y, this); 
		}
	public void drawString(String s, int x, int y) { 
		offGraphics.drawString(s, x, y); 
		}
	public void drawPermanentString(String s, int x, int y) { 
		offBackGraphics.drawString(s, x, y); 
		}
	public void drawPermanentImage (Image i, int x, int y) { 
		offBackGraphics.drawImage(i, x, y, this); 
		}
	public void clearPermanentImage (int x, int y, int w, int h) {
		offBackGraphics.drawImage(backImage, x, y, x + w, y + h, x, y, x + w, y + h, this);
		}
	public void clearBackground() {
		computeBackground(); 
		if (offBackGraphics==null) {
			offBackGraphics = offBackImage.getGraphics();
			offBackGraphics.setColor(textColor);
			offBackGraphics.setFont(textFont);
			}
		offBackGraphics.drawImage(backImage, 0, 0, this);
		}		

	// Update & paint methods
	public void paint(Graphics g) { update(g); }
	public synchronized void update(Graphics g) {
		if (g==null) g = this.getGraphics();
		g.drawImage(offImage, 0, 0, this);
		if (offGraphics==null) {
			offGraphics = offImage.getGraphics(); 
			offGraphics.setColor(textColor);
			offGraphics.setFont(textFont);
			}
		offGraphics.drawImage(offBackImage, 0, 0, this);
		notifyAll(); 
		}

	// Dimension functions
	public int getStringWidth(String s) { return fontMetrics.stringWidth(s); }
	public int getStringHeight() { return fontMetrics.getHeight(); }
	public int getStringAscent() { return fontMetrics.getAscent(); }
	public int getWidth() { return width; }
	public int getHeight() { return height; }

	// Canvas resizing methods
	public Dimension getPreferredSize() { return getMinimumSize(); }
	public synchronized Dimension getMinimumSize() { return minSize; }
	}
	
// ## JAVANOID MOVING OBJECT ############################################
// A javanoid moving object is an object that moves by itself. It has dX 
// & dY values that give its movement in relative coordinates

abstract class jnmovingobject extends jnobject {

	// Initial & current movement of the object
	protected int dX0, dY0;
	protected int dX, dY;

	// Constructor
	public jnmovingobject(jnbuffer b, Image i, int w, int h, int x, int y, int dx, int dy) {
		super(b, i, w, h, x, y);
		dX0 = dx; 
		dY0 = dy;
		dX = dx; 
		dY = dy;
		}
	public void die() { 
		dX = 0; 
		dY = 0; 
		super.die(); 
		}

	// Object movement settings
	public void setX(int x) {
		if (x > maxX) { 
			X = maxX; 
			invertDX(); 
			} 
		else if (x < minX) {
			X = minX; 
			invertDX(); 
			}
		else X = x;
		}
	public void setY(int y) {
		if (y > maxY) die();  
		else if (y < minY) { 
			Y = minY; 
			invertDY(); 
			}
		else Y = y;
		}
	public void setDXDY(int dx, int dy) { dX = dx; dY = dy; }
	public void setDX(int dx) { dX = dx; }
	public void setDY(int dy) { dY = dy; }
	public void invertDXDY() { dX = - dX; dY = - dY; } 
	public void invertDX() { dX = - dX; }
	public void invertDY() { dY = - dY; }
	public void reset() { 
		dX = dX0; 
		dY = dY0; 
		super.reset(); 
		}

	// Object life : move + drawing (dies when at the bottom of the screen) 
	public void live() { 
		if (alive) {
			setX(X + dX); 
			setY(Y + dY); 
			draw();
			}
		}

	// Object requests
	public int getDX() { return dX; }
	public int getDY() { return dY; }
	}

// ## JAVANOID OBJECT ###################################################
// It's the basic object of javanoid. Though it doesn't move by itself, 
// it can be moved to absolute coordinates (ex: the paddle, which moves 
// to the position of the mouse pointer). A javanoid object lives (i.e. 
// is on the screen) & dies when it touches the bottom

abstract class jnobject extends Object {

	// Width & height of the object
	protected int width, height;

	// Initial & current position of the object
	protected int X0, Y0;	
	protected int X, Y;

	// X & Y limits for the canvas
	protected int minX, maxX;
	protected int minY, maxY;

	// Tells if the object is still alive
	protected boolean alive;

	// The buffer where the object is drawn
	jnbuffer buffer;

	// The bitmap image of the object	
	Image image;

	// Constructor
	public jnobject(jnbuffer c, Image i, int w, int h, int x, int y) {
		buffer = c;
		image = i; 
		width = w; 
		height = h;
		X0 = x; 
		Y0 = y;
		X = x; 
		Y = y;
		minX = 0; 
		maxX = buffer.getWidth() - width;
		minY = 0; 
		maxY = buffer.getHeight() - height;
		alive = true;
		draw();
		}

	// Object position settings
	public void setXY(int x, int y) { setX(x); setY(y); }
	public void setX(int x) {
		if (x > maxX) X = maxX;  
		else if (x < minX) X = minX;
		else X = x;
		}
	public void setY(int y) {
		if (y > maxY) Y = maxY;  
		else if (y < minY) Y = minY;
		else Y = y;
		}
	public void reset() { X = X0; Y = Y0; }

	// Object drawing & erasing
	public void draw() { buffer.drawImage(image, X, Y); }

	// Objet life (what he does until he's dead)
	public void live() { if (alive) draw(); }

	// Object death
	public void die() { alive = false; }

	// Collision detection
	public boolean isHit(int x, int y) { 
		return (alive) && (x > X) && (x < X + width) && (y > Y) && (y < Y + height); 
		}
	
	// Object graphic changes
	public void change(Image i, int w, int h) {
		image = i; width = w; height = h;
		minX = 0; maxX = buffer.getWidth() - width;
		minY = 0; maxY = buffer.getHeight() - height;
		}
	
	// Object requests
	public boolean isAlive() { return alive; }
	public int getWidth() { return width; }
	public int getHeight() { return height; }
	public int getX() { return X; }
	public int getY() { return Y; }
	}