gt: 		for (Monster nextSprite : spritesOnScreen) {
context: package org.erikaredmark.monkeyshines;
  
  import java.awt.Color;
  import java.awt.Graphics2D;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  import java.util.ListIterator;
  
  import org.erikaredmark.monkeyshines.World.GoodieLocationPair;
  import org.erikaredmark.monkeyshines.background.Background;
  import org.erikaredmark.monkeyshines.background.FullBackground;
  import org.erikaredmark.monkeyshines.background.SingleColorBackground;
  import org.erikaredmark.monkeyshines.resource.AwtRenderer;
  import org.erikaredmark.monkeyshines.resource.AwtWorldGraphics;
  import org.erikaredmark.monkeyshines.resource.WorldResource;
  import org.erikaredmark.monkeyshines.sprite.Monster;
  import org.erikaredmark.monkeyshines.sprite.Sprite;
  
  /**
   * Improving the screen-by-screen architecture is NOT something I will be doing.
   * This provides the classic Monkey Shines feel: Each screen is one part of a level. Going off to the side of a screen
   * sends you to the next screen
   * <p/>
   * The initial screen is screen 1000. The Bonus screen can be determined by a constant (To allow more flexibility; the 
   * original used 10000.)
   * <p/>
   * This contains a lot of elements similar to World, but World is what contains the objects. These are only pointers.
   * The large number of pointers allow the LevelScreen to draw itself and handle it's own collisions.
   * <p/>
   * Changes to a level screen are not persisted to a level. The level editor must use {@link LevelScreenEditor} objects
   * that wrap level screens and store a list of changes to them to write out level data. This object, by itself, only
   * represents the level as it is in one-instance of the game.
   * 
   */
  public final class LevelScreen {
  	
  	// Initialisation datas for a level screen
  	// Id IS repeated in the Map holding the screens. Kept here for ease of use with other algorithms
  	// that work only with screens and need an id.
  	private final int screenId;
  	private       Background background;
  	
  	private final TileMap map;
  	// Whilst this is generally final in gameplay, it is left non-final here so it may be modified by the level editor.
  	private       ImmutablePoint2D bonzoStart;
  	private final List<Monster> spritesOnScreen;
  	
  	// state information for the screen. Bonzo can respawn where he came from at the velocity that
  	// he came into the screen
  	private       BonzoSaveState bonzoCameFrom;
  	private       ImmutablePoint2D bonzoLastOnGround;
  
  	
  	// defaults to true on constructions; intended to allow level editor to stop sprite animations for easier
  	// selection and editing.
  	private boolean animateSprites;
  	
  	// Graphics
  	// These are all pointers to what is stored in world.
  	private WorldResource rsrc;
  
  	
  
  	/**
  	 * 
  	 * Creates an empty level screen initialised to no tiles or sprites with a default background. The default
  	 * background is either the first full background in the resource, the first pattern in the resource, or
  	 * failing that, a solid colour of black.
  	 * 
  	 * @param screenId
  	 * 		the id of the screen, which must match with the id of the key that maps to this screen value in the world
  	 * 		hash map. Id may be negative is so choosing
  	 * 
  	 * @param rsrc
  	 * 		a graphics resource to skin this level
  	 * 
  	 * @param world
  	 * 		a reference to the world that contains this level screen. Required for some world-level properties
  	 * 		that affect all screens
  	 * 
  	 * @return
  	 * 		a new level screen
  	 * 
  	 */
  	public static final LevelScreen newScreen(int screenId, WorldResource rsrc) {
  		
  		Background defaultBackground =   rsrc.getBackgroundCount() > 0
  									   ? new FullBackground(0, false)
  									   :    rsrc.getPatternCount() > 0
  									   	  ? new FullBackground(0, true)
  									   	  : new SingleColorBackground(Color.BLACK);
  		
  		return new LevelScreen(screenId,
  							   defaultBackground,
  							   new TileMap(GameConstants.LEVEL_ROWS, GameConstants.LEVEL_COLS),
  							   ImmutablePoint2D.of(0, 0),
  							   new ArrayList<Monster>(),
  							   rsrc);
  	}
  	
  
  	/**
  	 * 
  	 * Intended for internal static factories and decoding system only
  	 * BonzoStart is a resolved-to-tile-cordinate location, not pixel location
  	 * 
  	 */
  	public LevelScreen(final int screenId, 
  			 		   final Background background,
  					   final TileMap map, 
  					   final ImmutablePoint2D bonzoStart, 
  					   final List<Monster> spritesOnScreen,
  					   final WorldResource rsrc) {
  		
  		this.screenId = screenId;
  		this.background = background;
  		this.map = map;
  		this.bonzoStart = bonzoStart;
  		this.spritesOnScreen = spritesOnScreen;
  		this.rsrc = rsrc;
  		this.animateSprites = true;
  	}
  	
  	/** Returns the screen id of this screen																			*/
  	public int getId() { return this.screenId; }
  	
  	/**
  	 * Returns the background for this screen
  	 * @return
  	 */
  	public Background getBackground() { 
  		return this.background; 
  	}
  	
  	/**
  	 * 
  	 * Only intended to be called from level editor: sets the background for the current screen.
  	 * 
  	 * @param newBackground
  	 * 		new background for this screen
  	 * 
  	 */
  	public void setBackground(Background newBackground) {
  		this.background = newBackground;
  	}
  
  	
  	/**
  	 * 
  	 * Gets the starting position of Bonzo in the level. The returned point is immutable: Use {@code Point2D#from(ImmutablePoint2D)}
  	 * to get a mutable version
  	 * <p/>
  	 * This location is in <strong>Tile Coordinates</strong>, not pixel coordinates!
  	 * 
  	 * @return
  	 * 		the location bonzo starts on this level. Never {@code null}
  	 */
  	public ImmutablePoint2D getBonzoStartingLocation() {
  		return this.bonzoStart;
  	}
  	
  	/**
  	 * 
  	 * Same as {@code getBonzoStartingLocation} but returns values as pixel co-ordinates.
  	 * 
  	 * @return
  	 */
  	public ImmutablePoint2D getBonzoStartingLocationPixels() {
  		return this.bonzoStart.multiply(GameConstants.TILE_SIZE_X, GameConstants.TILE_SIZE_Y);
  	}
  	
  	/**
  	 * 
  	 * Returns the location bonzo came from when entering this level, or the starting location if bonzo started
  	 * on this screen.
  	 * 
  	 * @return
  	 * 		a new instance of a point that represents the location bonzo entered this screen. This initially is set to his
  	 * 		starting location on the screen but is changed as he moves through the screens. Value never {@code null}
  	 * 
  	 */
  	public BonzoSaveState getBonzoCameFrom() {
  		return bonzoCameFrom;
  	}
  	
  	/**
  	 * Called when Bonzo enters the screen from another Screen. Sets the location he came from so if he dies on this screen, 
  	 * he can return to that position at the given velocity.
  	 * 
  	 * @param bonzoCameFrom 
  	 * 		the location Bonzo entered the screen from
  	 */
  	public void setBonzoCameFrom(final BonzoSaveState bonzoCameFrom) {
  		this.bonzoCameFrom = bonzoCameFrom;
  	}
  	
  	/**
  	 * If, for some reason, the location Bonzo Came from becomes invalid, this resets it.
  	 */
  	public void resetBonzoCameFrom() {
  		this.bonzoCameFrom = BonzoSaveState.fromPoint(bonzoStart);
  	}
  	
  
  	/**
  	 * 
  	 * Resets screen. Hazards are returned to their locations, and sprites are reset to initial positions.
  	 * 
  	 */
  	public void resetScreen() {
  		resetMonsters();
  		map.resetTiles();
  	}
  	
  	/**
  	 * Sprites move around the screen. This makes them return to where they spawn when the screen is first entered. 
  	 * Typically called alongside resetBonzo when Bonzo dies.
  	 */
  	private void resetMonsters() {
  