level.java.svn-base

一个JAVA程序员的游戏

/*
 * Level.java
 *
 * Created on 5. Dezember 2006, 21:45
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package kanjitori;


import com.jme.bounding.BoundingBox;
import com.jme.scene.shape.Box;
import com.jme.scene.shape.Quad;
import com.jme.scene.state.RenderState;
import java.util.HashMap;
import kanjitori.graphics.GeometryBatch;
import com.jme.input.InputHandler;
import com.jme.math.Vector3f;
import com.jme.scene.Node;
import com.jme.scene.SharedNode;
import java.awt.Point;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import kanjitori.action.MoveAction;
import com.jme.scene.Controller;
import kanjitori.event.EntrySolvedEventManager;
import kanjitori.graphics.bot.Bot;
import kanjitori.graphics.bot.BotController;
import kanjitori.event.BotKilledEventManager;
import kanjitori.event.ItemDroppedEventManager;
import kanjitori.event.Listener;
import kanjitori.graphics.hud.AbstractHud;
import kanjitori.graphics.hud.DefaultHud;
import kanjitori.graphics.item.ChangeItem;
import kanjitori.graphics.item.HealthItem;
import kanjitori.graphics.item.Item;
import kanjitori.graphics.item.ItemController;
import kanjitori.graphics.item.TeleportItem;
import kanjitori.graphics.tile.MeshTile;
import kanjitori.graphics.tile.Tile;
import kanjitori.lesson.Entry;
import kanjitori.lesson.Lesson;
import kanjitori.map.Layer;
import kanjitori.map.Map;
import kanjitori.util.Randomizer;

/**
 *
 * @author Pirx
 */
public class Level {
    public final static Random RANDOM = new Random();
    
    private static Level INSTANCE;
    private Map map;
    private List<Entry> entries;
    private List<Entry> activeEntries = new ArrayList<Entry>();
    private InputHandler input;
    private Node rootNode;
    private BotDropController botDropper;
    private ItemDropController itemDropper;
    private Constructor<? extends Bot> constructor;
    private int botCount = 0;
    
    /** Creates a new instance of Level */
    public Level(Map map, Lesson lesson, Node rootNode) {
        INSTANCE = this;
        this.rootNode = rootNode;
        this.entries = lesson.getEntries();
        this.map = map;
        MoveAction.setLevelMap(map);
        
        try {
            Class botClass = Class.forName(lesson.getBotClass());
            constructor = botClass.getConstructor(String.class);
        } catch (SecurityException ex) {
            ex.printStackTrace();
        } catch (NoSuchMethodException ex) {
            ex.printStackTrace();
        } catch (ClassNotFoundException ex) {
            ex.printStackTrace();
        }
        
        java.util.Map<MeshTile, GeometryBatch[]> gbMap = new HashMap<MeshTile, GeometryBatch[]>();
        
        for (int l = 0; l < map.getLayerCount(); l++) {
            Layer layer = map.getLayer(l);
            for (int x = 0; x < map.getSize().width; x++) {
                for (int y = 0; y < map.getSize().height; y++) {
                    Tile tile = layer.getTile(x, y);
                    if (tile != null) {
                        Vector3f translation = new Vector3f(2 * x, layer.getHeight(), 2 * y);
                        if (tile instanceof MeshTile) {
                            MeshTile meshTile = (MeshTile) tile;
                            GeometryBatch[] gbs = gbMap.get(meshTile);
                            if (gbs == null) {
                                gbs = new GeometryBatch[meshTile.getSize()];
                                for (int i = 0; i < meshTile.getSize(); i++) {
                                    gbs[i] = new GeometryBatch("gb");
                                    for (RenderState rs : meshTile.getRenderStates(i)) {
                                        gbs[i].setRenderState(rs);
                                    }
                                }
                                gbMap.put(meshTile, gbs);
                            }
                            for (int i = 0; i < meshTile.getSize(); i++) {
                                gbs[i].addGeometry(meshTile.getMesh(i), translation );
                            }
                        } else {
                            SharedNode node = new SharedNode("node", tile.getNode());
                            node.setLocalTranslation(translation);
                            node.lock();
                            rootNode.attachChild(node);
                        }
                    }
                }
            }
        }
        
        for (GeometryBatch[] gbs: gbMap.values()) {
            for (GeometryBatch gb : gbs) {
                gb.updateRenderState();
                gb.setModelBound(new BoundingBox());
                gb.updateModelBound();
                gb.lock();
                rootNode.attachChild(gb);
            }
        }
        
        Randomizer<Class<? extends Item>> itemRand = new Randomizer<Class<? extends Item>>();
        itemRand.add(HealthItem.class, 4);
        itemRand.add(TeleportItem.class, 2);
        itemRand.add(ChangeItem.class, 1);
        rootNode.addController(itemDropper = new ItemDropController(30,120, itemRand));
        
        rootNode.addController(botDropper = new BotDropController(40));
        
        for (int i = 0; i < map.getBotCount(); i++) {
            dropNewBot();
        }
        
        new Player(rootNode, map);
        Player.getPlayer().setEntry(getNextEntry());
        
        EntrySolvedEventManager.getManager().register(new Listener<Entry>(){
            public void notify(Entry entry) {
                entrySolved(entry);
            }
        });
        BotKilledEventManager.getManager().register(new Listener<Bot>(){
            public void notify(Bot bot) {
                botKilled(bot.getValue());
            }
        });
    }
    
    public List<Entry> getActiveEntries() {
        return activeEntries;
    }
    
    public static Level getLevel() {
        return INSTANCE;
    }
    
    public void dropNewBot() {
        if (entries.size() == 0) {
            return;
        }
        Entry entry = entries.remove(0);
        try {
            for (String value : entry.getValues()) {
                Bot bot = constructor.newInstance(value);
                bot.getNode().addController(new BotController(bot, map));
                rootNode.attachChild(bot.getNode());
                rootNode.updateRenderState();
                botDropper.resetTime();
                botCount ++;
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        activeEntries.add(entry);
        updateBotCount();
    }
    
    public void dropNewItem(Item item) {
        Point pos = map.findFreePos();
        item.getNode().setLocalTranslation(new Vector3f(pos.x * 2, 0, pos.y * 2));
        rootNode.attachChild(item.getNode());
        item.getNode().addController(new ItemController(item, map));
        rootNode.updateRenderState();
        ItemDroppedEventManager.getManager().fireEvent(item);
    }
    
    private void updateBotCount() {
        DefaultHud.getHud().showBotCount(botCount);
    }
    
    public void win() {
        Main.getMain().win();
    }
    
    public void botKilled(String value) {
        AbstractHud.getHud().addSolution(value);
        botCount--;
        updateBotCount();
        if (botCount < 5) {
            dropNewBot();
        }
    }
    
    public void entrySolved(Entry entry) {
        if (activeEntries.contains(entry)) {
            activeEntries.remove(entry);
            if (activeEntries.size() == 0) {
                win();
            }
        }
        Player.getPlayer().entrySolved();
    }
    
    public Entry getNextEntry() {
        return activeEntries.get(RANDOM.nextInt(activeEntries.size()));
    }
    
    private class BotDropController extends Controller {
        
        private float time = 0;
        private float dropRate;
        
        public BotDropController(float dropRate) {
            this.dropRate = dropRate;
        }
        
        public float getTime() {
            return time;
        }
        
        public void resetTime() {
            time = 0;
        }
        
        public void update(float f) {
            time += f;
            if (time > dropRate) {
                time = 0;
                dropNewBot();
            }
        }
    }
    
    private class ItemDropController extends Controller {
        
        private float time = 0;
        private int minDropRate;
        private int maxDropRate;
        private int currentDrop;
        private Randomizer<Class<? extends Item>> itemRand;
        
        public ItemDropController(int minDropRate, int maxDropRate,
                Randomizer<Class<? extends Item>> itemRand) {
            this.minDropRate = minDropRate;
            this.maxDropRate = maxDropRate;
            this.itemRand = itemRand;
            calcCurrentDrop();
        }
        
        private void calcCurrentDrop() {
            currentDrop = minDropRate + RANDOM.nextInt(maxDropRate - minDropRate);
        }
        
        public float getTime() {
            return time;
        }
        
        public void resetTime() {
            time = 0;
        }
        
        public void update(float f) {
            time += f;
            if (time > currentDrop) {
                time = 0;
                calcCurrentDrop();
                try {
                    dropNewItem(itemRand.get().newInstance());
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}