slugsengine.java

这是我编写的第一个J2ME程序

            player.setDirection(Player.EAST);

            break;

        case UP:
            player.setDirection(Player.NORTH);

            break;

        case DOWN:
            player.setDirection(Player.SOUTH);

            break;

        case JUMP:
            if (!player.isDigging() && player.getJetpackCount() > 0) {
                player.setStatusBit(Player.FLY);
                player.clearStatusBit(Player.RUN);
                player.setJetpackCount(player.getJetpackCount() - 1);
                events.add(new Item(player.getJetpackCount(), player_id, 
                                    Item.JETPACK_COUNT));
            } 

            break;

        case DIG:
            if (!player.isDigging() && player.getShovelCount() > 0) {
                player.setStatusBit(Player.BURROW);
                player.clearStatusBit(Player.RUN);
                player.setShovelCount(player.getShovelCount() - 1);
                events.add(new Item(player.getShovelCount(), player_id, 
                                    Item.SHOVEL_COUNT));
            } 

            break;

        default:
            handleError("should not reach here: " + action);
        }
    } 

    /**
     * Return the maximum number of players for this game
     */
    public int getMaxPlayerCount() {
        return 2;
    } 

    private void restoreBackground(Player player) {
        int x, y;

        x = player.getX();
        y = player.getY();

        if (player.isOnGround()) {
            int type = (player == player_list[0] ? Item.PATH1 : Item.PATH2);

            playing_field[y * level_width + x] = new Item(x, y, type);
        } else {
            player.getCovered().setDirty(true);

            playing_field[y * level_width + x] = player.getCovered();
        } 
    } 

    private void move(int player_id) {
        Player player;
        Item item;
        int xx, yy;

        player = player_list[player_id];

        player.tick();

        xx = player.getX();
        yy = player.getY();

        switch (player.getDirection()) {

        case Player.NORTH:
            yy--;

            break;

        case Player.SOUTH:
            yy++;

            break;

        case Player.WEST:
            xx--;

            break;

        case Player.EAST:
            xx++;

            break;

        case Player.STILL:
            return;

        default:
            handleError("illegal direction: " + player.getDirection());
        }

        if (xx < 0 || xx >= level_width || yy < 0 || yy >= level_height) {
            if (players_die) {
                player.setStatusBit(Player.DEAD);
                player.setLives(player.getLives() - 1);
                events.add(new Item(player.getLives(), player_id, 
                                    Item.LIFE_COUNT));

                restart = true;
            } 

            return;
        } 

        item = playing_field[yy * level_width + xx];

        if (item instanceof Player) {
            Player other = (Player) item;

            restoreBackground(player);
            player.setX(xx);
            player.setY(yy);

            playing_field[yy * level_width + xx] = player;

            if ((player.isOnGround() && other.isOnGround() || player.isFlying() && other.isFlying() || player.isDigging() && other.isDigging()) 
                    && players_die) {
                // players have crashed into each other
                player.setStatusBit(Player.DEAD);
                player.setLives(player.getLives() - 1);
                events.add(new Item(player.getLives(), player_id, 
                                    Item.LIFE_COUNT));
                other.setStatusBit(Player.DEAD);
                other.setLives(other.getLives() - 1);
                events.add(new Item(other.getLives(), 1 - player_id, 
                                    Item.LIFE_COUNT));

                restart = true;
            } 
        } else {
            switch (item.getStatus()) {

            case Item.WALL:      // fall through

            case Item.POISON:    // fall through

            case Item.PATH1:     // fall through

            case Item.PATH2:
                if (player.isOnGround() && players_die) {
                    player.setStatusBit(Player.DEAD);
                    player.setLives(player.getLives() - 1);
                    events.add(new Item(player.getLives(), player_id, 
                                        Item.LIFE_COUNT));

                    restart = true;
                } 

                break;

            case Item.JET_PACK:
                player.setJetpackCount(player.getJetpackCount() + 1);
                events.add(new Item(player.getJetpackCount(), player_id, 
                                    Item.JETPACK_COUNT));
                item.setStatus(Item.DELETE);

                break;

            case Item.SHOVEL:
                player.setShovelCount(player.getShovelCount() + 1);
                events.add(new Item(player.getShovelCount(), player_id, 
                                    Item.SHOVEL_COUNT));
                item.setStatus(Item.DELETE);

                break;

            case Item.EXTRA_LIFE:
                player.setLives(player.getLives() + 1);
                events.add(new Item(player.getLives(), player_id, 
                                    Item.LIFE_COUNT));
                item.setStatus(Item.DELETE);

                break;

            case Item.BOOSTER:
                player.setStatusBit(Player.RUN_FAST);
                item.setStatus(Item.DELETE);

                break;

            case Item.HOUSE:
                player.setStatusBit(Player.WIN);
                item.setStatus(Item.DELETE);

                level_complete = true;

                break;

            case Item.GRASS:
                break;           // do nothing

            default:
                handleError("should not reach here: " + item.getStatus());
            }

            restoreBackground(player);
            player.setX(xx);
            player.setY(yy);
            player.setCovered(item);

            playing_field[yy * level_width + xx] = player;
        } 
    } 

    private Frame makeSnapshot(boolean newLevel) {
        Player player;
        Item from, to;
        int i, n, player_count;

        n = 0;

        for (i = 0; i < getMaxPlayerCount(); i++) {
            player = player_list[i];

            if (newLevel || player.isDirty()) {
                to = item_list[n++];

                to.copyFrom(player);
            } 

            if (newLevel) {
                events.add(new Item(player.getLives(), i, Item.LIFE_COUNT));
                events.add(new Item(player.getJetpackCount(), i, 
                                    Item.JETPACK_COUNT));
                events.add(new Item(player.getShovelCount(), i, 
                                    Item.SHOVEL_COUNT));
            } 
        } 

        player_count = n;

        if (newLevel) {
            to = item_list[n++];

            to.setX(level_width);
            to.setY(level_height);
            to.setStatus(Item.NEW_LEVEL);
        } 

        for (i = 0; i < playing_field.length; i++) {
            from = playing_field[i];

            if (newLevel || from.isDirty()) {
                to = item_list[n++];

                to.copyFrom(from);
            } 
        } 

        for (i = 0; i < events.size(); i++) {
            from = (Item) events.get(i);
            to = item_list[n++];

            to.copyFrom(from);
        } 

        events.clear();

        return new Frame(item_list, n, player_count);
    } 

    /**
     * main loop
     */
    public void run() {
        Frame snapshot;
        Player player;
        Item item;
        int i, j;

        for (; ; ) {
            if (player_count == getMaxPlayerCount()) {
                if (game_started) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {}

                    game_started = false;
                } 

                synchronized (this) {
                    for (i = 0; i < getMaxPlayerCount(); i++) {
                        player = player_list[i];

                        for (j = 0; j < player.getSpeed(); j++) {
                            move(i);
                        }
                    } 
                } 

                del.distributeUpdate(makeSnapshot(level_started), 
                                     frame_count++);

                level_started = false;

                for (i = 0; i < playing_field.length; i++) {
                    item = playing_field[i];

                    item.setDirty(false);

                    if (item.getStatus() == Item.DELETE) {
                        item.setStatus(Item.GRASS);
                    } 
                } 

                if (restart || level_complete) {
                    try {
                        Thread.sleep(5000 /* 3000 */);
                    } catch (InterruptedException e) {}

                    if (level_complete) {
                        level_no++;
                    } 

                    initLevel();
                } 
            } 

            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {}
        } 
    } 

}