game.java :  » Java-2D » polhemthegame » main » Java Open Source

package main;

import elements.boss;
import elements.player;
import game_states.basic_state;
import game_states.boss_state;
import game_states.creeps_state;
import game_states.game_state;
import game_states.starting_boss_state;
import game_states.states;
import game_states.transition_state;

import java.io.FileNotFoundException;
import java.io.IOException;

import levels.campaign;
import levels.level;

import org.newdawn.slick.Graphics;
import org.newdawn.slick.SlickException;

import ui.hud;

public class game
{
  private game_state       gs;
  private transition_state ts;
  // OSD
  private final int        text_time = 3500;
  // Level
  private final campaign   campaign;
  private level            level;
  private boss             boss;
  // Player related
  private final boolean    two_player;
  public player            player1, player2;
  public hud               player1_hud, player2_hud;
  // Running the game
  private boolean          paused, exit, completed;
  private long             time_start, last_frame;

  public game( final boolean two_player ) throws SlickException, FileNotFoundException, IOException
  {
    loader.weapons.load_weapons();

    campaign = new campaign( "polhem" );

    completed = false;
    exit = false;
    completed = false;
    paused = false;
    time_start = 0;
    last_frame = 0;

    this.two_player = two_player;

    player1 = new player( "blue", 0, two_player );
    player1_hud = new hud( 0, player1 );
    if ( two_player ) {
      player2 = new player( "red", 1, true );
      player2_hud = new hud( launcher.config.get_height() - hud.height, player2 );
    }
  }

  public void load_level() throws SlickException, FileNotFoundException, IOException, Exception
  {
    level = campaign.next_level();

    if ( level != null ) {
      basic_state bs;

      player1.reset();
      player1.position( level.constraints, two_player );
      bs = new basic_state( player1 );
      if ( two_player ) {
        player2.reset();
        player2.position( level.constraints, two_player );
        bs = new basic_state( player1, player2 );
      }
      gs = new creeps_state( level, bs );
      ts = new transition_state( time(), text_time, level.text_start, states.CREEPS );
    }
    else {
      throw new Exception( "Failed to load level." );
    }
  }

  private void load_boss() throws Exception
  {
    if ( level.has_boss() ) {
      boss = level.boss;
      ts = new starting_boss_state( time(), text_time, level.text_boss, states.BOSS, boss );

      player1.reset();
      if ( two_player ) {
        player2.reset();
      }
    }
    else {
      throw new Exception( "Level '" + level.name + "' has no boss." );
    }
  }

  private void start_level()
  {
    time_start = System.currentTimeMillis();
    last_frame = time_start;
  }

  public void pause()
  {
    if ( !paused ) {
      paused = true;
      last_frame = time();
    }
  }

  public void resume()
  {
    if ( paused ) {
      paused = false;
      pause_compensation();
    }
  }

  private void pause_compensation()
  {
    final long t = time();
    last_frame = t;
    time_start += t - last_frame;
  }

  public void update( final float m ) throws SlickException, FileNotFoundException, IOException, Exception
  {
    if ( !paused ) {
      final long t = time();

      if ( t - last_frame > 1000 ) {
        // Mainly for debugging support, might have hit a breakpoint
        pause_compensation();
      }

      if ( ts == null ) {
        gs.update( m, t, level.constraints );
        player1_hud.update( player1 );
        if ( two_player ) {
          player2_hud.update( player2 );
        }
      }
      else {
        ts.update( m, t, level.constraints );
      }

      // Transition between states
      if ( ts != null ) {
        if ( ts.new_state() != null ) {
          if ( ts.new_state() == states.CREEPS ) {
            ts = null;
            gs = new creeps_state( level, (basic_state) gs );
            start_level();
          }
          else if ( ts.new_state() == states.BOSS ) {
            ts = null;
            gs = new boss_state( boss, (basic_state) gs, level.constraints );
          }
          else if ( ts.new_state() == states.NEXT_LEVEL ) {
            ts = null;
            load_level();
          }
          else if ( ts.new_state() == states.CREDITS ) {
            ts = null;
            completed = true;
            exit = true;
          }
        }
      }
      else if ( gs.new_state() != null ) {
        if ( gs.new_state() == states.CREEPS_FINISHED ) {
          if ( level.has_boss() ) {
            load_boss();
          }
          else if ( campaign.has_more_levels() ) {
            load_level();
          }
          else {
            ts = new transition_state( t, text_time, level.text_finished, states.CREDITS );
          }
        }
        else if ( gs.new_state() == states.FINISHED_LEVEL ) {
          if ( campaign.has_more_levels() ) {
            ts = new transition_state( t, text_time, level.text_finished, states.NEXT_LEVEL );
          }
          else {
            ts = new transition_state( t, text_time, level.text_finished, states.CREDITS );
          }
        }
        else if ( gs.new_state() == states.GAME_OVER ) {
          ts = new transition_state( t, text_time, level.text_game_over, states.CREDITS );
        }
      }

      last_frame = t;
    }
  }

  /*
   * Rendering
   */
  public void render( final Graphics g )
  {
    campaign.current_level().draw();

    if ( gs != null ) {
      gs.render( g );
    }
    if ( ts != null ) {
      ts.render( g );
    }

    if ( two_player ) {
      player2_hud.draw();
    }
    player1_hud.draw();
  }

  /*
   * Game element handlers
   */
  public void fire_player( final player player )
  {
    if ( gs instanceof basic_state ) {
      ( (basic_state) gs ).add_projectile( player.fire( time() ) );
    }
  }

  /*
   * Getters, Setters, Adders
   */
  public long time()
  {
    return System.currentTimeMillis() - time_start;
  }

  public boolean exit()
  {
    return exit;
  }

  public boolean is_paused()
  {
    return paused;
  }

  public boolean is_completed()
  {
    return completed;
  }

  public boolean is_two_player()
  {
    return two_player;
  }

  public boolean input_enabled()
  {
    return ts == null;
  }
}