path: root/jeu-test/Lemmini/0.84/src/Game/GameController.java

package Game;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;

import javax.swing.JFrame;
import javax.swing.JOptionPane;

import GameUtil.Fader;
import GameUtil.KeyRepeat;
import GameUtil.Sound;
import GameUtil.Sprite;
import Tools.MicrosecondTimer;
import Tools.ToolBox;


/**
 * Game controller. Contains all the game logic.
 * @author Volker Oth
 */
public class GameController {
	/** game state */
	public static enum State {
		/** init state */
		INIT,
		/** display intro screen */
		INTRO,
		/** display level briefing screen */
		BRIEFING,
		/** display level */
		LEVEL,
		/** display debriefing screen */
		DEBRIEFING,
		/** fade out after level was finished */
		LEVEL_END
	}

	/** Transition states */
	public static enum TransitionState {
		/** no fading */
		NONE,
		/** restart level: fade out, fade in briefing */
		RESTART_LEVEL,
		/** replay level: fade out, fade in briefing */
		REPLAY_LEVEL,
		/** load level: fade out, fade in briefing */
		LOAD_LEVEL,
		/** load replay: fade out, fade in briefing */
		LOAD_REPLAY,
		/** level finished: fade out */
		END_LEVEL,
		/** go to intro: fade in intro */
		TO_INTRO,
		/** go to briefing: fade in briefing */
		TO_BRIEFING,
		/** go to debriefing: fade in debriefing */
		TO_DEBRIEFING,
		/** go to level: fade in level */
		TO_LEVEL
	}

	/** key repeat bitmask for icons */
	public final static int KEYREPEAT_ICON = 1;
	/** key repeat bitmask for keys */
	public final static int KEYREPEAT_KEY = 2;

	/** bang sound */
	public final static int SND_BANG = 0;
	/** brick wheel trap sound */
	public final static int SND_CHAIN = 1;
	/** setting new skill sound */
	public final static int SND_CHANGE_OP = 2;
	/** only some builder steps left sound */
	public final static int SND_CHINK = 3;
	/** dieing sound */
	public final static int SND_DIE = 4;
	/** trap door opening sound */
	public final static int SND_DOOR = 5;
	/** electric sound */
	public final static int SND_ELECTRIC = 6;
	/** explode sound */
	public final static int SND_EXPLODE = 7;
	/** fire sound */
	public final static int SND_FIRE = 8;
	/** drowning sound */
	public final static int SND_GLUG = 9;
	/** start of level sound */
	public final static int SND_LETSGO = 10;
	/** bear/twiner trap sound */
	public final static int SND_MANTRAP = 11;
	/** mouse clicked sound */
	public final static int SND_MOUSEPRE = 12;
	/** nuke command sound */
	public final static int SND_OHNO = 13;
	/** leaving exit sound */
	public final static int SND_OING = 14;
	/** scrape sound */
	public final static int SND_SCRAPE = 15;
	/** slicer sound */
	public final static int SND_SLICER = 16;
	/** splash sound */
	public final static int SND_SPLASH = 17;
	/** faller splat sound */
	public final static int SND_SPLAT = 18;
	/** ten tons sound, also pipe sucking lemmings in */
	public final static int SND_TEN_TONS = 19;
	/** icycle, brick stamper sound */
	public final static int SND_THUD = 20;
	/** thunk sound */
	public final static int SND_THUNK = 21;
	/** ting sound */
	public final static int SND_TING = 22;
	/** yipee sound */
	public final static int SND_YIPEE = 23;

	/** updates 5 frames instead of 1 in fast forward mode */
	public final static int FAST_FWD_MULTI = 5;
	/** updates 3 frames instead of 1 in Superlemming mode */
	public final static int SUPERLEMM_MULTI = 3;
	/** time per frame in microseconds - this is the timing everything else is based on */
	public final static int MICROSEC_PER_FRAME = 30*1000;
	/** resync if time difference greater than that (in microseconds)*/
	public final static int MICROSEC_RESYNC = 5*30*1000;

	/** redraw animated level obejcts every 3rd frame (about 100ms) */
	private final static int MAX_ANIM_CTR = 100*1000/MICROSEC_PER_FRAME;
	/** open Entry after about 1.5 seconds */
	private final static int MAX_ENTRY_OPEN_CTR = 1500*1000/MICROSEC_PER_FRAME;
	/** one second is 33.33 ticks (integer would cause error) */
	private final static double MAX_SECOND_CTR = 1000.0*1000/MICROSEC_PER_FRAME;
	/** maximum release rate */
	private final static int MAX_RELEASE_RATE = 99;

	/** nuke icon: maximum time between two mouse clicks for double click detection (in microseconds) */
	private final static long MICROSEC_NUKE_DOUBLE_CLICK = 240*1000;
	/** +/- icons: maximum time between two mouse clicks for double click detection (in microseconds) */
	private final static long MICROSEC_RELEASE_DOUBLE_CLICK = 200*1000;
	/** +/- icons: time for key repeat to kick in */
	private final static long MICROSEC_KEYREPEAT_START = 250*1000;
	/** +/- icons: time for key repeat rate */
	private final static long MICROSEC_KEYREPEAT_REPEAT = 67*1000;

	/** sound object */
	public static Sound sound;
	// pour le mode W
	public static boolean modeW = false;
	/** the background stencil */
	public static Stencil stencil;
	/** the background image */
	public static BufferedImage bgImage;
	/** flag: play music */
	private static boolean musicOn;
	/** flag: play sounds */
	private static boolean soundOn;
	/** flag: use advanced mouse selection methods */
	private static boolean advancedSelect;
	/** graphics object for the background image */
	private static Graphics2D bgGfx;
	/** color used to erase the background (black) */
	private static Color blankColor = new Color(0xff,0,0,0);
	/** flag: fast forward mode is active */
	private static boolean fastForward;
	/** flag: Superlemming mode is active */
	private static boolean superLemming;
	/** game state */
	private static State gameState;
	/** transition (fading) state */
	private static TransitionState transitionState;
	/** skill to assign to lemming (skill icon) */
	private static Lemming.Type lemmSkill;
	/** flag: entry is openend */
	private static boolean entryOpened;
	/** flag: nuke was acticated */
	private static boolean nuke;
	/** flag: game is paused */
	private static boolean paused;
	/** flag: cheat/debug mode is activated */
	public static boolean cheat = false;
	/** flag: cheat mode was activated during play */
	private static boolean wasCheated = false;
	/** frame counter for handling opening of entries */
	private static int entryOpenCtr;
	/** frame counter for handling time */
	private static double secondCtr;
	/** frame counter used to handle release of new Lemmings */
	private static int releaseCtr;
	/** threshold to release a new Lemming */
	private static int releaseBase;
	/** frame counter used to update animated sprite objects */
	private static int animCtr;
	/** level object */
	public static Level level;
	/** index of current difficulty level */
	private static int curDiffLevel;
	/** index of current level pack */
	private static int curLevelPack;
	/** index of current level */
	private static int curLevelNumber;
	/** index of next difficulty level */
	private static int nextDiffLevel;
	/** index of next level pack */
	private static int nextLevelPack;
	/** index of next level */
	private static int nextLevelNumber;
	/** list of all active Lemmings in the Level */
	private static LinkedList<Lemming> lemmings;
	/** list of all active explosions */
	private static LinkedList<Explosion> explosions;
	/** list of all Lemmings under the mouse cursor */
	private static ArrayList<Lemming> lemmsUnderCursor;
	/** array of available level packs */
	private static LevelPack levelPack[];
	/** small preview version of level used in briefing screen */
	private static BufferedImage mapPreview;
	/** timer used for nuking */
	private static MicrosecondTimer timerNuke;
	/** key repeat object for plus key/icon */
	private static KeyRepeat plus;
	/** key repeat object for minus key/icon */
	private static KeyRepeat minus;
	/** Lemming for which skill change is requested */
	private static Lemming lemmSkillRequest;
	/** horizontal scrolling offset for level */
	private static int xPos;
	/** replay stream used for handling replays */
	private static ReplayStream replay;
	/** frame counter used for handling replays */
	private static int replayFrame;
	/** old value of release rate */
	private static int releaseRateOld;
	/** old value of nuke flag */
	private static boolean nukeOld;
	/** old value of horizontal scrolling position */
	private static int xPosOld;
	/** old value of selected skill */
	private static Lemming.Type lemmSkillOld;
	/** flag: replay mode is active */
	private static boolean replayMode;
	/** flag: replay mode should be stopped */
	private static boolean stopReplayMode;
	/** listener to inform GUI of player's progress */
	private static UpdateListener levelMenuUpdateListener;
	/** number of Lemmings which left the level */
	private static int numLeft;
	/** release rate 0..99 */
	private static int releaseRate;
	/** number of Lemmings available */
	private static int numLemmingsMax;
	/** number of Lemmings who entered the level */
	private static int numLemmingsOut;
	/** number of Lemmings which have to be rescued to finish the level */
	private static int numToRecue;
	/** time left in seconds */
	private static int time;
	/** number of climber skills left to be assigned */
	private static int numClimbers;
	/** number of floater skills left to be assigned */
	private static int numFloaters;
	/** number of bomber skills left to be assigned */
	private static int numBombers;
	/** number of blocker skills left to be assigned */
	private static int numBlockers;
	/** number of builder skills left to be assigned */
	private static int numBuilders;
	/** number of basher skills left to be assigned */
	private static int numBashers;
	/** number of miner skills left to be assigned */
	private static int numMiners;
	/** number of digger skills left to be assigned */
	private static int numDiggers;
	/** free running update counter */
	private static int updateCtr;
	/** gain for sound 0..1.0 */
	private static double soundGain = 1.0;
	/** gain for music 0..1.0 */
	private static double musicGain = 1.0;

	/**
	 * Initialization.
	 * @throws ResourceException
	 */
	public static void init() throws ResourceException {
		bgImage = ToolBox.createImage(Level.WIDTH, Level.HEIGHT, Transparency.BITMASK);
		bgGfx = bgImage.createGraphics();

		gameState = State.INIT;
		sound = new Sound(24,SND_MOUSEPRE);
		sound.setGain(soundGain);
		Icons.init(Core.getCmp());
		Explosion.init();
		Lemming.loadLemmings(Core.getCmp());
		lemmings = new LinkedList<Lemming>();
		explosions = new LinkedList<Explosion>();
		lemmsUnderCursor = new ArrayList<Lemming>(10);
		lemmSkillRequest = null;

		LemmFont.init();
		NumFont.init();
		LemmCursor.init();
		Music.init();
		Music.setGain(musicGain);
		MiscGfx.init();

		plus  = new KeyRepeat(MICROSEC_KEYREPEAT_START, MICROSEC_KEYREPEAT_REPEAT, MICROSEC_RELEASE_DOUBLE_CLICK);
		minus = new KeyRepeat(MICROSEC_KEYREPEAT_START, MICROSEC_KEYREPEAT_REPEAT, MICROSEC_RELEASE_DOUBLE_CLICK);
		timerNuke = new MicrosecondTimer();

		level = new Level();
		// read level packs

		File dir = new File(Core.resourcePath+"levels");
		File files[] = dir.listFiles();
		// now get the names of the directories
		ArrayList<String> dirs = new ArrayList<String>();
		for (int i=0; i<files.length; i++)
			if (files[i].isDirectory())
				dirs.add(files[i].getName());
		Collections.sort(dirs);

		levelPack = new LevelPack[dirs.size()+1];
		levelPack[0] = new LevelPack(); // dummy
		for (int i=0; i<dirs.size(); i++) {  // read levels
			String lvlName = dirs.get(i);
			levelPack[i+1] = new LevelPack(Core.findResource("levels/"+ToolBox.addSeparator(lvlName)+"levelpack.ini"));
		}
		curDiffLevel = 0;
		curLevelPack = 1; // since 0 is dummy
		curLevelNumber = 0;

		replayFrame = 0;
		replay = new ReplayStream();
		replayMode = false;
		stopReplayMode = false;

		if (isCheat())
			wasCheated = true;
		else
			wasCheated = false;
	}

	/**
	 * Calculate absolute level number from diff level and relative level number
	 * @param lvlPack   level pack
	 * @param diffLevel difficulty level
	 * @param level     relative level number
	 * @return absolute level number (0..127)
	 */
	static int absLevelNum(final int lvlPack, final int diffLevel, final int level) {
		LevelPack lpack = levelPack[lvlPack];
		// calculate absolute level number
		int absLvl = level;
		for (int i=0; i<diffLevel; i++)
			absLvl += lpack.getLevels(i).length;
		return absLvl;
	}

	/**
	 * Calculate diffLevel and relative level number from absolute level number
	 * @param lvlPack level pack
	 * @param lvlAbs  absolute level number
	 * @return { difficulty level, relative level number }
	 */
	public static int[] relLevelNum(final int lvlPack, final int lvlAbs) {
		int retval[] = new int[2];
		LevelPack lpack = levelPack[lvlPack];
		int diffLevels = lpack.getDiffLevels().length;
		int lvl=0;
		int diffLvl=0;
		int maxLevels=30;
		for (int i=0, ls = 0; i<diffLevels; i++) {
			int ls_old = ls;
			// add number of levels existing in this diff level
			maxLevels = lpack.getLevels(i).length;
			ls += maxLevels;
			if (lvlAbs < ls) {
				diffLvl = i;
				lvl = lvlAbs - ls_old; // relative level mumber
				break;
			}
		}
		retval[0] = diffLvl;
		retval[1] = lvl;
		return retval;
	}

	/**
	 * Proceed to next level.
	 * @return true: ok, false: no more level in this difficulty level
	 */
	public static synchronized boolean nextLevel() {
		int num = curLevelNumber + 1;

		if ( num < levelPack[curLevelPack].getLevels(curDiffLevel).length ) {
			curLevelNumber = num;
			return true;
		} else
			return false; // congrats - difficulty level done
	}

	/**
	 * Fade out at end of level.
	 */
	public static synchronized void endLevel() {
		transitionState = TransitionState.END_LEVEL;
		gameState = State.LEVEL_END;
		Fader.setState(Fader.State.OUT);
	}

	/**
	 * Level successfully finished, enter debriefing and tell GUI to enable next level.
	 */
	static synchronized void finishLevel() {
		Music.stop();
		setFastForward(false);
		setSuperLemming(false);
		replayMode = false;

		if (!wasLost()) {
			if (curLevelPack!=0)
				levelMenuUpdateListener.update();
			//			String pack = levelPack[curLevelPack].getName();
			//			String diff = levelPack[curLevelPack].getDiffLevels()[curDiffLevel];
			//			// get next level
			//			int num = curLevelNumber + 1;
			//			if ( num >= levelPack[curLevelPack].getLevels(curDiffLevel).length )
			//				num = curLevelNumber;
			//			// set next level as available
			//			GroupBitfield bf = Core.player.setAvailable(pack, diff, num);
			//			// update the menu
			//			if (curLevelPack!=0) // 0 is the dummy pack
			//				((Lemmini)Core.getCmp()).updateLevelMenu(pack, diff, bf);
		}
		gameState = State.DEBRIEFING;
	}

	/**
	 * Hook for GUI to get informed when a level was successfully finished.
	 * @param l UpdateListener
	 */
	public static void setLevelMenuUpdateListener(final UpdateListener l) {
		levelMenuUpdateListener = l;
	}

	/**
	 * Restart level.
	 * @param doReplay true: replay, false: play
	 */
	private static synchronized void restartLevel(final boolean doReplay) {
		initLevel();
		if (doReplay) {
			replayMode = true;
			replay.save(Core.resourcePath+"/replay.rpl");
			replay.rewind();
		} else {
			replayMode = false;
			replay.clear();
		}
	}

	/**
	 * Initialize a level after it was loaded.
	 */
	private static void initLevel() {
		Music.stop();

		setFastForward(false);
		setPaused(false);
		nuke = false;

		lemmSkillRequest = null;

		TextScreen.setMode(TextScreen.Mode.INIT);

		bgGfx.setBackground(blankColor);
		bgGfx.clearRect(0, 0, bgImage.getWidth(), bgImage.getHeight());

		stencil = getLevel().paintLevel(bgImage, Core.getCmp(), stencil);

		lemmings.clear();
		explosions.clear();
		Icons.reset();

		TrapDoor.reset(getLevel().getEntryNum());
		entryOpened = false;
		entryOpenCtr = 0;
		secondCtr = 0;
		releaseCtr = 0;
		lemmSkill = Lemming.Type.UNDEFINED;

		plus.init();
		minus.init();

		numLeft = 0;
		releaseRate = getLevel().getReleaseRate();
		numLemmingsMax = getLevel().getNumLemmings();
		numLemmingsOut = 0;
		numToRecue  = getLevel().getNumToRescue();
		time        = getLevel().getTimeLimitSeconds();
		numClimbers = getLevel().getNumClimbers();
		numFloaters = getLevel().getNumFloaters();
		numBombers = getLevel().getNumBombers();
		numBlockers = getLevel().getNumBlockers();
		numBuilders = getLevel().getNumBuilders();
		numBashers = getLevel().getNumBashers();
		numMiners = getLevel().getNumMiners();
		numDiggers = getLevel().getMumDiggers();
		setxPos(getLevel().getXpos());

		calcReleaseBase();

		mapPreview = getLevel().createMiniMap(mapPreview, bgImage, 4, 4, false);

		setSuperLemming(getLevel().isSuperLemming());

		replayFrame = 0;
		stopReplayMode = false;
		releaseRateOld = releaseRate;
		lemmSkillOld = lemmSkill;
		nukeOld = false;
		xPosOld = getLevel().getXpos();

		gameState = State.BRIEFING;
	}

	/**
	 * Request the restart of this level.
	 * @param doReplay
	 */
	public static synchronized void requestRestartLevel(final boolean doReplay) {
		if (doReplay)
			transitionState = TransitionState.REPLAY_LEVEL;
		else
			transitionState = TransitionState.RESTART_LEVEL;
		Fader.setState(Fader.State.OUT);
	}

	/**
	 * Request a new level.
	 * @param lPack index of level pack
	 * @param dLevel index of difficulty level
	 * @param lNum level number
	 * @param doReplay true: replay, false: play
	 */
	public static synchronized void requestChangeLevel(final int lPack, final int dLevel, final int lNum, final boolean doReplay) {
		nextLevelPack = lPack;
		nextDiffLevel = dLevel;
		nextLevelNumber = lNum;

		if (doReplay)
			transitionState = TransitionState.LOAD_REPLAY;
		else
			transitionState = TransitionState.LOAD_LEVEL;
		Fader.setState(Fader.State.OUT);
	}

	/**
	 * Start a new level.
	 * @param lPack index of level pack
	 * @param dLevel index of difficulty level
	 * @param lNum level number
	 * @param doReplay true: replay, false: play
	 */
	static private synchronized Level changeLevel(final int lPack, final int dLevel, final int lNum, final boolean doReplay) throws ResourceException, LemmException {
		//gameState = GAME_ST_INIT;
		curLevelPack = lPack;
		curDiffLevel = dLevel;
		curLevelNumber = lNum;

		String lvlPath = levelPack[curLevelPack].getInfo(curDiffLevel, curLevelNumber).getFileName();
		// lemmings need to be reloaded to contain pink color
		Lemming.loadLemmings(Core.getCmp());
		// loading the level will patch pink lemmings pixels to correct color
		getLevel().loadLevel(lvlPath);

		// if with and height would be stored inside the level, the bgImage etc. would have to
		// be recreated here
		// bgImage = gc.createCompatibleImage(Level.width, Level.height, Transparency.BITMASK);
		// bgGfx = bgImage.createGraphics();

		initLevel();

		if (doReplay) {
			replayMode = true;
			replay.rewind();
		} else {
			replayMode = false;
			replay.clear();
		}

		return getLevel();
	}

	/**
	 * Get level lost state.
	 * @return true if level was lost, false otherwise
	 */
	static synchronized boolean wasLost() {
		if (gameState != State.LEVEL && numLeft >= numToRecue)
			return false;
		return true;
	}

	/**
	 * Get current replay image.
	 * @return current replay image
	 */
	public synchronized static BufferedImage getReplayImage() {
		if (!replayMode)
			return null;
		if ( (replayFrame & 0x3f) > 0x20)
			return MiscGfx.getImage(MiscGfx.Index.REPLAY_1);
		else
			return MiscGfx.getImage(MiscGfx.Index.REPLAY_2);
	}

	/**
	 * Get a Lemming under the selection cursor.
	 * @param type cursor type
	 * @return fitting Lemming or null if none found
	 */
	public static synchronized Lemming lemmUnderCursor(final LemmCursor.Type type) {
		// search for level without the skill
		for (int i=0; i<getLemmsUnderCursor().size(); i++) {
			Lemming l = getLemmsUnderCursor().get(i);
			// Walker only cursor: ignore non-walkers
			if (type == LemmCursor.Type.WALKER && l.getSkill()!=Lemming.Type.WALKER)
				continue;
			if (type == LemmCursor.Type.LEFT && l.getDirection() != Lemming.Direction.LEFT)
				continue;
			if (type == LemmCursor.Type.RIGHT && l.getDirection() != Lemming.Direction.RIGHT)
				continue;
			switch (lemmSkill) {
				case CLIMBER:
					if (!l.canClimb())
						return l;
					break;
				case FLOATER:
					if (!l.canFloat())
						return l;
					break;
				default:
					if (l.canChangeSkill() && l.getSkill() != lemmSkill && l.getName().length() > 0) {
						//System.out.println(l.getName());
						return l;
					}
			}
			break;
		}
		if (type == LemmCursor.Type.NORMAL && getLemmsUnderCursor().size() > 0) {
			Lemming l = getLemmsUnderCursor().get(0);
			if (l.getName().length() == 0)
				return null;
			//System.out.println(((Lemming)lemmsUnderCursor.get(0)).getName());
			return l;
		}
		return null;
	}

	/**
	 * Lemming has left the Level.
	 */
	static synchronized void increaseLeft() {
		numLeft += 1;
	}

	/**
	 * Stop replay.
	 */
	private static void stopReplayMode() {
		if (replayMode)
			stopReplayMode = true;
	}

	/**
	 * Return time as String "minutes-seconds"
	 * @return time as String "minutes-seconds"
	 */
	public synchronized static String getTimeString() {
		String t1 = Integer.toString(time/60);
		String t2 = Integer.toString(time%60);
		if (t2.length() < 2)
			t2 = "0"+t2;
		return t1 + "-" + t2;
	}

	/**
	 * Update the whole game state by one frame.
	 */
	public static synchronized void update() {
		if (gameState != State.LEVEL)
			return;

		updateCtr++;

		if (!replayMode)
			assignSkill(false); // first try to assign skill

		// check +/- buttons also if paused
		KeyRepeat.Event fired = plus.fired();
		if (fired != KeyRepeat.Event.NONE) {
			if (releaseRate < MAX_RELEASE_RATE) {
				if (fired == KeyRepeat.Event.DOUBLE_CLICK)
					releaseRate = MAX_RELEASE_RATE;
				else
					releaseRate += 1;
				calcReleaseBase();
				sound.playPitched(releaseRate);
			} else sound.play(SND_TING);
		}

		fired = minus.fired();
		if (fired != KeyRepeat.Event.NONE) {
			if (releaseRate > getLevel().getReleaseRate()) {
				if (fired == KeyRepeat.Event.DOUBLE_CLICK)
					releaseRate = getLevel().getReleaseRate();
				else
					releaseRate -= 1;
				calcReleaseBase();
				sound.playPitched(releaseRate);
			} else sound.play(SND_TING);
		}


		if (isPaused())
			return;

		// test for end of replay mode
		if ( replayMode && stopReplayMode ) {
			replay.clearFrom(replayFrame);
			replayMode = false;
			stopReplayMode = false;
		}

		if (!replayMode) {
			if (!wasCheated) {
				// replay: release rate changed?
				if (releaseRate != releaseRateOld) {
					replay.addReleaseRateEvent(replayFrame, releaseRate);
					releaseRateOld = releaseRate;
				}
				// replay: nuked?
				if (nuke != nukeOld) {
					replay.addNukeEvent(replayFrame);
					nukeOld = nuke;
				}
				// replay: xPos changed?
				if (getxPos() != xPosOld) {
					replay.addXPosEvent(replayFrame, getxPos());
					xPosOld = getxPos();
				}
				// skill changed
				if (lemmSkill != lemmSkillOld) {
					replay.addSelectSkillEvent(replayFrame, lemmSkill);
					lemmSkillOld = lemmSkill;
				}
			} else replay.clear();
		} else {
			// replay mode
			ReplayEvent r;
			while ( (r=replay.getNext(replayFrame)) != null) {
				switch (r.type) {
					case ReplayStream.ASSIGN_SKILL: {
						ReplayAssignSkillEvent rs = (ReplayAssignSkillEvent)r;
						synchronized (lemmings) {
							Lemming l = lemmings.get(rs.lemming);
							l.setSkill(rs.skill);
							l.setSelected();
						}
						switch (rs.skill) {
							case FLOATER:
								numFloaters -= 1;
								break;
							case CLIMBER:
								numClimbers -= 1;
								break;
							case BOMBER:
								numBombers -= 1;
								break;
							case DIGGER:
								numDiggers -= 1;
								break;
							case BASHER:
								numBashers -= 1;
								break;
							case BUILDER:
								numBuilders -= 1;
								break;
							case MINER:
								numMiners -= 1;
								break;
							case STOPPER:
								numBlockers -= 1;
								break;
						}
						sound.play(SND_CHANGE_OP);
						break;
					}
					case ReplayStream.SET_RELEASE_RATE:
						ReplayReleaseRateEvent rr = (ReplayReleaseRateEvent)r;
						releaseRate = rr.releaseRate;
						calcReleaseBase();
						sound.playPitched(releaseRate);
						break;
					case ReplayStream.NUKE:
						nuke = true;
						break;
					case ReplayStream.MOVE_XPOS: {
						ReplayMoveXPosEvent rx = (ReplayMoveXPosEvent)r;
						setxPos(rx.xPos);
						break;
					}
					case ReplayStream.SELECT_SKILL: {
						ReplaySelectSkillEvent rs = (ReplaySelectSkillEvent)r;
						lemmSkill = rs.skill;
						switch (lemmSkill) {
							case FLOATER:
								Icons.press(Icons.Type.FLOAT);
								break;
							case CLIMBER:
								Icons.press(Icons.Type.CLIMB);
								break;
							case BOMBER:
								Icons.press(Icons.Type.BOMB);
								break;
							case DIGGER:
								Icons.press(Icons.Type.DIG);
								break;
							case BASHER:
								Icons.press(Icons.Type.BASH);
								break;
							case BUILDER:
								Icons.press(Icons.Type.BUILD);
								break;
							case MINER:
								Icons.press(Icons.Type.MINE);
								break;
							case STOPPER:
								Icons.press(Icons.Type.BLOCK);
								break;
						}
						break;
					}
				}
			}
		}

		// replay: xpos changed

		// store locally to avoid it's overwritten amidst function
		boolean nukeTemp = nuke;

		// time
		secondCtr+=1.0;
		if (secondCtr > MAX_SECOND_CTR) {
			// one second passed
			secondCtr -= MAX_SECOND_CTR;
			time--;
			if (!isCheat() && time == 0) {
				// level failed
				endLevel();
			}
		}
		// release
		if (entryOpened && !nukeTemp && !isPaused() && numLemmingsOut < getNumLemmingsMax() && ++releaseCtr >= releaseBase) {
			releaseCtr = 0;
			//LemmingResource ls = Lemming.getResource(Lemming.TYPE_FALLER);
			try {
				if (getLevel().getEntryNum() != 0) {
					Entry e = getLevel().getEntry(TrapDoor.getNext());
					Lemming l = new Lemming(e.xPos+2, e.yPos+20);
					synchronized (lemmings) {
						lemmings.add(l);
					}
					numLemmingsOut++;
				}
			} catch (ArrayIndexOutOfBoundsException ex) {}
		}
		// nuking
		if (nukeTemp && ((updateCtr&1)==1)) {
			synchronized (lemmings) {
				Iterator<Lemming> it = lemmings.iterator();
				while (it.hasNext()) {
					Lemming l = it.next();
					if (!l.nuke() && !l.hasDied() && !l.hasLeft()) {
						l.setSkill(Lemming.Type.NUKE);
						//System.out.println("nuked!");
						break;
					}
				}
			}
		}
		// open trap doors ?
		if (!entryOpened) {
			if (++entryOpenCtr == MAX_ENTRY_OPEN_CTR) {
				for (int i=0; i<getLevel().getEntryNum(); i++)
					getLevel().getSprObject(getLevel().getEntry(i).id).setAnimMode(Sprite.Animation.ONCE);
				sound.play(SND_DOOR);
			} else if (entryOpenCtr == MAX_ENTRY_OPEN_CTR+10*MAX_ANIM_CTR) {
				//System.out.println("opened");
				entryOpened = true;
				releaseCtr = releaseBase; // first lemming to enter at once
				if (musicOn)
					Music.play();
			}
		}
		// end of game conditions
		if ((nukeTemp || numLemmingsOut == getNumLemmingsMax()) && explosions.size()==0 && lemmings.size()==0) {
			endLevel();
		}

		synchronized (lemmings) {
			Iterator<Lemming> it = lemmings.iterator();
			while (it.hasNext()) {
				Lemming l = it.next();
				if (l.hasDied() || l.hasLeft()) {
					it.remove();
					continue;
				}
				l.animate();
			}
		}

		synchronized (explosions) {
			Iterator<Explosion> it = explosions.iterator();
			while (it.hasNext()) {
				Explosion e = it.next();
				if (e.isFinished())
					it.remove();
				else
					e.update();
			}
		}

		// animate level objects
		if (++animCtr > MAX_ANIM_CTR) {
			animCtr -= MAX_ANIM_CTR;
			for (int n=0; n<getLevel().getSprObjectNum(); n++) {
				SpriteObject spr = getLevel().getSprObject(n);
				spr.getImageAnim(); // just to animate
			}
		}

		if (!replayMode)
			assignSkill(true); // 2nd try to assign skill

		replayFrame ++;
	}

	/**
	 * Request a skill change for a Lemming (currently selected skill).
	 * @param lemm Lemming
	 */
	public synchronized static void requestSkill(final Lemming lemm) {
		if (lemmSkill != Lemming.Type.UNDEFINED)
			lemmSkillRequest = lemm;
		stopReplayMode();
	}

	/**
	 * Assign the selected skill to the selected Lemming.
	 * @param delete flag: reset the current skill request
	 */
	private synchronized static void assignSkill(final boolean delete) {
		if (lemmSkillRequest == null || lemmSkill == Lemming.Type.UNDEFINED)
			return;

		Lemming lemm = lemmSkillRequest;
		if (delete)
			lemmSkillRequest = null;

		boolean canSet = false;
		stopReplayMode();

		if (isCheat()) {
			canSet = lemm.setSkill(lemmSkill);
		} else {
			switch (lemmSkill) {
				case BASHER:
					if (numBashers > 0 && lemm.setSkill(lemmSkill)) {
						numBashers -= 1;
						canSet = true;
					}
					break;
				case BOMBER:
					if (numBombers > 0 && lemm.setSkill(lemmSkill)) {
						numBombers -= 1;
						canSet = true;
					}
					break;
				case BUILDER:
					if (numBuilders > 0 && lemm.setSkill(lemmSkill)) {
						numBuilders -= 1;
						canSet = true;
					}
					break;
				case CLIMBER:
					if (numClimbers > 0 && lemm.setSkill(lemmSkill)) {
						numClimbers -= 1;
						canSet = true;
					}
					break;
				case DIGGER:
					if (numDiggers > 0 && lemm.setSkill(lemmSkill)) {
						numDiggers -= 1;
						canSet = true;
					}
					break;
				case FLOATER:
					if (numFloaters > 0 && lemm.setSkill(lemmSkill)) {
						numFloaters -= 1;
						canSet = true;
					}
					break;
				case MINER:
					if (numMiners > 0 && lemm.setSkill(lemmSkill)) {
						numMiners -= 1;
						canSet = true;
					}
					break;
				case STOPPER:
					if (numBlockers > 0 && lemm.setSkill(lemmSkill)) {
						numBlockers -= 1;
						canSet = true;
					}
					break;
			}
		}
		if (canSet) {
			lemmSkillRequest = null; // erase request
			sound.play(SND_MOUSEPRE);
			if (isPaused()) {
				setPaused(false);
				Icons.press(Icons.Type.PAUSE);
			}
			// add to replay stream
			if (!wasCheated)
				synchronized (lemmings) {
					for (int i=0; i<lemmings.size(); i++)
						if (lemmings.get(i) == lemm) // if 2nd try (delete==true) assign to next frame
							replay.addAssignSkillEvent(replayFrame+((delete) ? 1:0), lemmSkill, i);
				}
		} else if (delete)
			sound.play(SND_TING);
	}

	/**
	 * Calculate the counter threshold for releasing a new Lemmings.
	 */
	static private void calcReleaseBase() {
		// the original formula is: release lemming every 4+(99-speed)/2 time steps
		// where one step is 60ms (3s/50) or 66ms (4s/60).
		// Lemmini runs at 30ms/33ms, so the term has to be multiplied by 2
		// 8+(99-releaseRate) should be correct
		releaseBase = 8 + (99 - releaseRate);
	}

	/**
	 * Handle pressing of an icon button.
	 * @param type icon type
	 */
	public static synchronized void handleIconButton(final Icons.Type type) {
		Lemming.Type lemmSkillOld = lemmSkill;
		boolean ok = false;
		switch (type) {
			case FLOAT:
				if (isCheat() || numFloaters>0)
					lemmSkill = Lemming.Type.FLOATER;
				stopReplayMode();
				break;
			case CLIMB:
				if (isCheat() || numClimbers>0)
					lemmSkill = Lemming.Type.CLIMBER;
				stopReplayMode();
				break;
			case BOMB:
				if (isCheat() || numBombers>0)
					lemmSkill = Lemming.Type.BOMBER;
				stopReplayMode();
				break;
			case DIG:
				if (isCheat() || numDiggers>0)
					lemmSkill = Lemming.Type.DIGGER;
				stopReplayMode();
				break;
			case BASH:
				if (isCheat() || numBashers>0)
					lemmSkill = Lemming.Type.BASHER;
				stopReplayMode();
				break;
			case BUILD:
				if (isCheat() || numBuilders>0)
					lemmSkill = Lemming.Type.BUILDER;
				stopReplayMode();
				break;
			case MINE:
				if (isCheat() || numMiners>0)
					lemmSkill = Lemming.Type.MINER;
				stopReplayMode();
				break;
			case BLOCK:
				if (isCheat() || numBlockers>0)
					lemmSkill = Lemming.Type.STOPPER;
				stopReplayMode();
				break;
			case NUKE: {
				ok = true;
				stopReplayMode();
				if (timerNuke.delta() < MICROSEC_NUKE_DOUBLE_CLICK) {
					if (!nuke) {
						nuke = true;
						sound.play(SND_OHNO);
					}
				} else timerNuke.deltaUpdate();
				break;}
			case PAUSE:
				setPaused(!isPaused());
				ok = true;
				break;
			case FFWD:
				setFastForward(!isFastForward());
				ok = true;
				break;
			case PLUS:
				ok = true; // supress sound
				plus.pressed(KEYREPEAT_ICON);
				stopReplayMode();
				break;
			case MINUS:
				ok = true; // supress sound
				minus.pressed(KEYREPEAT_ICON);
				stopReplayMode();
				break;
		}
		if (ok || lemmSkill != lemmSkillOld) {
			switch (type) {
				case PLUS:
				case MINUS:
					break; // supress sound
				default:
					sound.play(SND_CHANGE_OP);
			}
			Icons.press(type);
		} else
			sound.play(SND_TING);
	}

	/**
	 * Fade in/out.
	 * @param g graphics object
	 */
	public static void fade(final Graphics g) {
		if (Fader.getState() == Fader.State.OFF && transitionState != TransitionState.NONE) {
			switch (transitionState) {
				case END_LEVEL:
					finishLevel();
					break;
				case TO_BRIEFING:
					gameState = State.BRIEFING;
					break;
				case TO_DEBRIEFING:
					gameState = State.DEBRIEFING;
					break;
				case TO_INTRO:
					gameState = State.INTRO;
					break;
				case TO_LEVEL:
					GameController.sound.play(SND_LETSGO);
					try {
						Music.load("music/"+GameController.levelPack[GameController.curLevelPack].getInfo(GameController.curDiffLevel,
								GameController.curLevelNumber).getMusic());
					} catch (ResourceException ex) {
						Core.resourceError(ex.getMessage());
					} catch (LemmException ex) {
						JOptionPane.showMessageDialog( null, ex.getMessage(), "Error", JOptionPane.ERROR_MESSAGE );
						System.exit(1);
					}
					gameState = State.LEVEL;
					break;
				case RESTART_LEVEL:
				case REPLAY_LEVEL:
					restartLevel(transitionState == TransitionState.REPLAY_LEVEL);
					break;
				case LOAD_LEVEL:
				case LOAD_REPLAY:
					try {
						changeLevel(nextLevelPack, nextDiffLevel, nextLevelNumber, transitionState == TransitionState.LOAD_REPLAY);
						((JFrame)Core.getCmp()).setTitle("Lemmini - "+getLevel().getLevelName());
					} catch (ResourceException ex) {
						Core.resourceError(ex.getMessage());
					} catch (LemmException ex) {
						JOptionPane.showMessageDialog( null, ex.getMessage(), "Error", JOptionPane.ERROR_MESSAGE );
						System.exit(1);
					}
					break;
			}
			Fader.setState(Fader.State.IN);
			transitionState = TransitionState.NONE;
		}
		Fader.fade(g);
	}

	/**
	 * Draw the explosions
	 * @param g graphics object
	 * @param width width of screen in pixels
	 * @param height height of screen in pixels
	 * @param xOfs horizontal level offset in pixels
	 */
	public static void drawExplosions(final Graphics2D g, final int width, final int height, final int xOfs) {
		synchronized (explosions) {
			Iterator<Explosion> it = explosions.iterator();
			while (it.hasNext()) {
				Explosion e = it.next();
				e.draw(g, width, height, xOfs);
			}
		}
	}

	/**
	 * Add a new explosion.
	 * @param x x coordinate in pixels.
	 * @param y y coordinate in pixels.
	 */
	public static void addExplosion(final int x, final int y) {
		// create particle explosion
		synchronized (GameController.explosions) {
			GameController.explosions.add(new Explosion(x, y));
		}
	}

	/**
	 * Draw icon bar.
	 * @param g graphics object
	 * @param x x coordinate in pixels
	 * @param y y coordinate in pixels
	 */
	public static void drawIcons(final Graphics2D g, final int x, final int y) {
		g.drawImage(Icons.getImg(),x,y,null);
	}

	/**
	 * Draw the skill/release rate values
	 * @param g graphics object
	 * @param y y offset in pixels
	 */
	public static void drawCounters(final Graphics2D g, final int y) {
		// draw counters
		int val = 0;
		for (int i=0; i<10;i++) {
			switch (i) {
				case 0:
					val = level.getReleaseRate();
					break;
				case 1:
					val = releaseRate;
					break;
				case 2:
					val = numClimbers;
					break;
				case 3:
					val = numFloaters;
					break;
				case 4:
					val = numBombers;
					break;
				case 5:
					val = numBlockers;
					break;
				case 6:
					val = numBuilders;
					break;
				case 7:
					val = numBashers;
					break;
				case 8:
					val = numMiners;
					break;
				case 9:
					val = numDiggers;
					break;
			}
			g.drawImage(NumFont.numImage(val),Icons.WIDTH*i+8,y,null);
		}

	}

	/**
	 * Get index of current level pack.
	 * @return index of current level pack
	 */
	public static int getCurLevelPackIdx() {
		return curLevelPack;
	}

	/**
	 * Get current level pack.
	 * @return current level pack
	 */
	public static LevelPack getCurLevelPack() {
		return levelPack[curLevelPack];
	}

	/**
	 * get number of level packs
	 * @return number of level packs
	 */
	public static int getLevelPackNum() {
		return levelPack.length;
	}

	/**
	 * Get level pack via index.
	 * @param i index of level pack
	 * @return LevelPack
	 */
	public static LevelPack getLevelPack(final int i) {
		return levelPack[i];
	}

	/**
	 * Get index of current difficulty level.
	 * @return index of current difficulty level
	 */
	public static int getCurDiffLevel() {
		return curDiffLevel;
	}

	/**
	 * Get number of current level.
	 * @return number of current leve
	 */
	public static int getCurLevelNumber() {
		return curLevelNumber;
	}


	/**
	 * Set horizontal scrolling offset.
	 * @param x horizontal scrolling offset in pixels
	 */
	public static void setxPos(final int x) {
		xPos = x;
	}

	/**
	 * Get horizontal scrolling offset.
	 * @return horizontal scrolling offset in pixels
	 */
	public static int getxPos() {
		return xPos;
	}

	/**
	 * Set game state.
	 * @param s new game state
	 */
	public static void setGameState(final State s) {
		gameState = s;
	}

	/**
	 * Get game state.
	 * @return game state
	 */
	public static State getGameState() {
		return gameState;
	}

	/**
	 * Enable/disable cheat mode.
	 * @param c true: enable, false: disable
	 */
	public static void setCheat(final boolean c) {
		cheat = c;
	}

	/**
	 * Get state of cheat mode.
	 * @return true if cheat mode enabled, false otherwise
	 */
	public static boolean isCheat() {
		return cheat;
	}

	/**
	 * Set transition state.
	 * @param ts TransitionState
	 */
	public static void setTransition(final TransitionState ts) {
		transitionState = ts;
	}


	/**
	 * Load a replay.
	 * @param fn file name
	 * @return replay level info object
	 */
	public static ReplayLevelInfo loadReplay(final String fn) {
		return replay.load(fn);
	}

	/**
	 * Save a replay.
	 * @param fn file name
	 * @return true if saved successfully, false otherwise
	 */
	public static boolean saveReplay(final String fn) {
		return replay.save(fn);
	}

	/**
	 * Activate/deactivate Superlemming mode.
	 * @param sl true: activate, false: deactivate
	 */
	public static void setSuperLemming(final boolean sl) {
		superLemming = sl;
	}

	/**
	 * Get Superlemming state.
	 * @return true is Superlemming mode is active, false otherwise
	 */
	public static boolean isSuperLemming() {
		return superLemming;
	}

	/**
	 * Set cheated detection.
	 * @param c true: cheat mode was activated, false otherwise
	 */
	public static void setWasCheated(final boolean c) {
		wasCheated = c;
	}

	/**
	 * Enable pause mode.
	 * @param p true: pause is active, false otherwise
	 */
	public static void setPaused(final boolean p) {
		paused = p;
	}

	/**
	 * Get pause state.
	 * @return true if pause is active, false otherwise
	 */
	public static boolean isPaused() {
		return paused;
	}

	/**
	 * Enable fast forward mode.
	 * @param ff true: fast forward is active, false otherwise
	 */
	public static void setFastForward(final boolean ff) {
		fastForward = ff;
	}

	/**
	 * Get fast forward state.
	 * @return true if fast forward is active, false otherwise
	 */
	public static boolean isFastForward() {
		return fastForward;
	}

	/** get number of lemmings left in the game
	 * @return number of lemmings left in the game
	 */
	public static int getNumLeft() {
		return numLeft;
	}

	/**
	 * Set number of Lemmings left in the game.
	 * @param n number of Lemmings left in the game
	 */
	public static void setNumLeft(final int n) {
		numLeft = n;
	}

	/**
	 * Get level object.
	 * @return level object
	 */
	public static Level getLevel() {
		return level;
	}

	/**
	 * Get maximum number of Lemmings for this level.
	 * @return maximum number of Lemmings for this level
	 */
	public static int getNumLemmingsMax() {
		return numLemmingsMax;
	}

	/**
	 * Get icon type from x position.
	 * @param x x position in pixels
	 * @return icon type
	 */
	public static Icons.Type getIconType(final int x) {
		return Icons.getType(x);
	}

	/**
	 * Icon was pressed.
	 * @param t icon type
	 */
	public static void pressIcon(final Icons.Type t) {
		Icons.press(t);
	}

	/**
	 * Icon was released.
	 * @param t icon type
	 */
	public static void releaseIcon(final Icons.Type t) {
		Icons.release(t);
	}

	/**
	 * Plus was pressed.
	 * @param d bitmask: key or icon
	 */
	public static void pressPlus(final int d) {
		plus.pressed(d);
	}

	/**
	 * Plus was released.
	 * @param d bitmask: key or icon
	 */
	public static void releasePlus(final int d) {
		plus.released(d);
	}

	/**
	 * Minus was pressed.
	 * @param d bitmask: key or icon
	 */
	public static void pressMinus(final int d) {
		minus.pressed(d);
	}

	/**
	 * Minus was released.
	 * @param d bitmask: key or icon
	 */
	public static void releaseMinus(final int d) {
		minus.released(d);
	}

	/**
	 * Get list of all Lemmings under the mouse cursor.
	 * @return list of all Lemmings under the mouse cursor
	 */
	public static ArrayList<Lemming> getLemmsUnderCursor() {
		return lemmsUnderCursor;
	}

	/**
	 * Get list of all Lemmings in this level.
	 * @return list of all Lemmings in this level
	 */
	public static LinkedList<Lemming> getLemmings() {
		return lemmings;
	}

	/**
	 * Set sound gain.
	 * @param g gain (0..1.0)
	 */
	public static void setSoundGain(final double g) {
		soundGain = g;
		if (sound != null)
			sound.setGain(soundGain);
	}

	/**
	 * Set music gain.
	 * @param g gain (0..1.0)
	 */
	public static void setMusicGain(final double g) {
		musicGain = g;
		if (Music.getType() != null)
			Music.setGain(musicGain);
	}

	/**
	 * Set advanced mouse selection mode.
	 * @param sel true: advanced selection mode active, false otherwise
	 */
	public static void setAdvancedSelect(final boolean sel) {
		advancedSelect = sel;
	}

	/**
	 * Get state of advanced mouse selection mode.
	 * @return true if advanced selection mode activated, false otherwise
	 */
	public static boolean isAdvancedSelect() {
		return advancedSelect;
	}

	/**
	 * Get background image of level.
	 * @return background image of level
	 */
	public static BufferedImage getBgImage() {
		return bgImage;
	}

	/**
	 * Get background stencil of level.
	 * @return background stencil of level
	 */
	public static Stencil getStencil() {
		return stencil;
	}

	/**
	 * Enable music.
	 * @param on true: music on, false otherwise
	 */
	public static void setMusicOn(final boolean on) {
		musicOn = on;
	}

	/**
	 * Get music enable state.
	 * @return true: music is on, false otherwise
	 */
	public static boolean isMusicOn() {
		return musicOn;
	}

	/**
	 * Enable sound.
	 * @param on true: sound on, false otherwise
	 */
	public static void setSoundOn(final boolean on) {
		soundOn = on;
	}

	/**
	 * Get sound enable state.
	 * @return true: sound is on, false otherwise
	 */
	public static boolean isSoundOn() {
		return soundOn;
	}

	/**
	 * Get small preview image of level.
	 * @return small preview image of level
	 */
	public static BufferedImage getMapPreview() {
		return mapPreview;
	}

	/**
	 * Get number of Lemmings to rescue.
	 * @return number of Lemmings to rescue
	 */
	public static int  getNumToRecue() {
		return numToRecue;
	}

	/**
	 * Get time left in seconds.
	 * @return time left in seconds
	 */
	public static int getTime() {
		return time;
	}
}


/**
 * Trapdoor/Entry class
 * Trapdoor logic: for numbers >1, just take the next door for each lemming and wrap around to 1 when
 * the last one is reached.
 * Special rule for 3 trapdoors: the order is 1, 2, 3, 2 (loop), not 1, 2, 3 (loop)
 *
 * @author Volker Oth
 */
class TrapDoor {
	/** pattern for three entries */
	private final static int[] PATTERN3 = {0,1,2,1};

	/** number of entries */
	private static int entries;
	/** entry counter */
	private static int counter;

	/**
	 * Reset to new number of entries.
	 * @param e number of entries
	 */
	static void reset(final int e) {
		entries = e;
		counter = 0;
	}

	/**
	 * Get index of next entry.
	 * @return index of next entry
	 */
	static int getNext() {
		int retVal = counter;
		counter++;
		if (entries != 3) {
			if (counter >= entries)
				counter = 0;
			return retVal;
		}
		// special case: 3
		if (counter >= 4)
			counter = 0;
		return PATTERN3[retVal];
	}

}