package.net.frog_parrot.jump;
import javax.microedition.lcdui.*;
import javax.microedition.lcdui.game.*;
/**
* this handles the graphics objects.
*
* @author carol hamer
*/
public class jumpmanager extends
javax.microedition.lcdui.game.layermanager {
//---------------------------------------------------------
// dimension fields
// (constant after initialization)
/**
* the x coordinate of the place on the game canvas where
* the layermanager window should appear, in terms of the
* coordinates of the game canvas.
*/
static int canvas_x;
/**
* the y coordinate of the place on the game canvas where
* the layermanager window should appear, in terms of the
* coordinates of the game canvas.
*/
static int canvas_y;
/**
* the width of the display window.
*/
static int disp_width;
/**
* the height of this object's graphical region. this is
* the same as the height of the visible part because
* in this game the layer manager's visible part scrolls
* only left and right but not up and down.
*/
static int disp_height;
//---------------------------------------------------------
// game object fields
/**
* the player's object.
*/
private cowboy mycowboy;
/**
* the tumbleweeds that enter from the left.
*/
private tumbleweed[] mylefttumbleweeds;
/**
* the tumbleweeds that enter from the right.
*/
private tumbleweed[] myrighttumbleweeds;
/**
* the object representing the grass in the background.
*/
private grass mygrass;
/**
* whether the player is currently going left.
*/
private boolean myleft;
/**
* the leftmost x coordinate that should be visible on the
* screen in terms of this objects internal coordinates.
*/
private int mycurrentleftx;
//-----------------------------------------------------
// gets/sets
/**
* this tells the player to turn left or right.
* @param left whether the turn is toward the left.
*/
void setleft(boolean left) {
myleft = left;
}
//-----------------------------------------------------
// initialization and game state changes
/**
* constructor sets the data and constructs the graphical objects.
* @param x the x coordinate of the place on the game canvas where
* the layermanager window should appear, in terms of the
* coordinates of the game canvas.
* @param y the y coordinate of the place on the game canvas where
* the layermanager window should appear, in terms of the
* coordinates of the game canvas.
* @param width the width of the region that is to be
* occupied by the layoutmanager.
* @param height the height of the region that is to be
* occupied by the layoutmanager.
*/
public jumpmanager(int x, int y, int width, int height)
throws exception {
canvas_x = x;
canvas_y = y;
disp_width = width;
disp_height = height;
mycurrentleftx = grass.cycle*grass.tile_width;
setviewwindow(0, 0, disp_width, disp_height);
// create the player:
if(mycowboy == null) {
mycowboy = new cowboy(mycurrentleftx + disp_width/2,
disp_height - cowboy.height - 2);
append(mycowboy);
}
// create the tumbleweeds to jump over:
if(mylefttumbleweeds == null) {
mylefttumbleweeds = new tumbleweed[2];
for(int i = 0; i < mylefttumbleweeds.length; i++) {
mylefttumbleweeds[i] = new tumbleweed(true);
append(mylefttumbleweeds[i]);
}
}
if(myrighttumbleweeds == null) {
myrighttumbleweeds = new tumbleweed[2];
for(int i = 0; i < myrighttumbleweeds.length; i++) {
myrighttumbleweeds[i] = new tumbleweed(false);
append(myrighttumbleweeds[i]);
}
// create the background object:
if(mygrass == null) {
mygrass = new grass();
append(mygrass);
}
}
/**
* sets all variables back to their initial positions.
*/
void reset() {
if(mygrass != null) {
mygrass.reset();
}
if(mycowboy != null) {
mycowboy.reset();
}
if(mylefttumbleweeds != null) {
for(int i = 0; i < mylefttumbleweeds.length; i++) {
mylefttumbleweeds[i].reset();
}
}
if(myrighttumbleweeds != null) {
for(int i = 0; i < myrighttumbleweeds.length; i++) {
myrighttumbleweeds[i].reset();
}
}
myleft = false;
mycurrentleftx = grass.cycle*grass.tile_width;
}
//-------------------------------------------------------
// graphics methods
/**
* paint the game graphic on the screen.
*/
public void paint(graphics g) {
etviewwindow(mycurrentleftx, 0, disp_width, disp_height);
paint(g, canvas_x, canvas_y);
}
/**
* if the cowboy gets to the end of the graphical region,
* move all of the pieces so that the screen appears to wrap.
*/
private void wrap() {
if(mycurrentleftx % (grass.tile_width*grass.cycle) == 0) {
if(myleft) {
mycowboy.move(grass.tile_width*grass.cycle, 0);
mycurrentleftx += (grass.tile_width*grass.cycle);
for(int i = 0; i < mylefttumbleweeds.length; i++) {
mylefttumbleweeds[i].move(grass.tile_width*grass.cycle, 0);
}
for(int i = 0; i < myrighttumbleweeds.length; i++) {
myrighttumbleweeds[i].move(grass.tile_width*grass.cycle, 0);
} else {
mycowboy.move(-(grass.tile_width*grass.cycle), 0);
mycurrentleftx -= (grass.tile_width*grass.cycle);
for(int i = 0; i < mylefttumbleweeds.length; i++) {
mylefttumbleweeds[i].move(-grass.tile_width*grass.cycle, 0);
}
for(int i = 0; i < myrighttumbleweeds.length; i++) {
myrighttumbleweeds[i].move(-grass.tile_width*grass.cycle, 0);
}
}
}
}
//-------------------------------------------------------
// game movements
/**
* tell all of the moving components to advance.
* @param gameticks the remaining number of times that
* the main loop of the game will be executed
* before the game ends.
* @return the change in the score after the pieces
* have advanced.
*/
int advance(int gameticks) {
int retval = 0;
// first you move the view window
// (so you are showing a slightly different view of
// the manager's graphical area).
if(myleft) {
mycurrentleftx--;
} else {
mycurrentleftx++;
}
// now you tell the game objects to move accordingly.
mygrass.advance(gameticks);
mycowboy.advance(gameticks, myleft);
for(int i = 0; i < mylefttumbleweeds.length; i++) {
retval += mylefttumbleweeds[i].advance(mycowboy,
gameticks, myleft, mycurrentleftx, mycurrentleftx + disp_width);
retval -= mycowboy.checkcollision(mylefttumbleweeds[i]);
}
for(int i = 0; i < mylefttumbleweeds.length; i++) {
retval += myrighttumbleweeds[i].advance(mycowboy,
gameticks, myleft, mycurrentleftx, mycurrentleftx + disp_width);
retval -= mycowboy.checkcollision(myrighttumbleweeds[i]);
}
// now you check if you have reached an edge of the viewable
// area, and if so, you move the view area and all of the
// game objects so that the game appears to wrap.
wrap();
return(retval);
}
/**
* tell the cowboy to jump.
*/
void jump() {
mycowboy.jump();
}
}
