kanjibot.java.svn-base

一个JAVA程序员的游戏

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

package kanjitori.graphics.bot;

import com.jme.animation.SpatialTransformer;
import com.jme.bounding.BoundingBox;
import com.jme.image.Texture;
import com.jme.math.Vector3f;
import com.jme.renderer.ColorRGBA;
import com.jme.scene.Controller;
import com.jme.scene.Node;
import com.jme.scene.shape.Box;
import com.jme.scene.state.TextureState;
import com.jme.util.TextureManager;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.geom.FlatteningPathIterator;
import java.awt.geom.PathIterator;
import java.awt.image.BufferedImage;
import javax.swing.ImageIcon;
import kanjitori.graphics.bot.Bot;
import kanjitori.lesson.Entry;
import kanjitori.graphics.shape.RoundedBox;

/**
 *
 * @author Pirx
 */
public class KanjiBot extends AbstractBoxBot implements Bot {
    
    
    private final static Image CORPUS_IMAGE = new ImageIcon("data/corpus.png").getImage();
    private final static Font FONT = new Font("Arial Unicode MS", Font.PLAIN, 200);
    private final static Color DARK_COLOR = new Color(0.2f, 0.2f, 0f);
    //private final static ColorRGBA MAT_COLOR = new ColorRGBA(1, 1, 1, 1);
    
    //private Texture tex;
    
    /** Creates a new instance of Bot */
    public KanjiBot(String value) {
        super(value);
        //node = new Node("bot");
        //initBot();
    }
    
    /*private void initBot() {
        Image img = getKanjiImage(value);
        
        TextureState ts = display().getRenderer().createTextureState();
        Texture t = TextureManager.loadTexture(img, Texture.MM_LINEAR, Texture.MM_LINEAR, ts.getMaxAnisotropic(), false);
         
        t.setWrap(Texture.WM_WRAP_S_WRAP_T);
        t.setScale(new Vector3f(1,-1,-1));
        ts.setTexture(t);
        
        
        TextureState ts = display().getRenderer().createTextureState();
        //Base texture, not environmental map.
        Texture t0 = TextureManager.loadTexture(img,
                Texture.MM_LINEAR_LINEAR,
                Texture.FM_LINEAR, ts.getMaxAnisotropic(), false);
        t0.setWrap(Texture.WM_WRAP_S_WRAP_T);
        t0.setScale(new Vector3f(1,-1,-1));
        tex = t0;
        
        //Environmental Map (reflection of clouds)
        Texture t = TextureManager.loadTexture(
                "data/envmap.png",
                Texture.MM_LINEAR_LINEAR,
                Texture.FM_LINEAR);
        t.setEnvironmentalMapMode( Texture.EM_SPHERE );
        ts.setTexture( t0, 0 );
        ts.setTexture( t, 1 );
        ts.setEnabled( true );
        
        
        RoundedBox box = new RoundedBox("bot",
                new Vector3f(0.5f, 0.5f, 0.5f),
                new Vector3f(0.05f, 0.05f, 0.05f),
                new Vector3f(0.02f, 0.02f, 0.02f));
        box.setRenderState(getMaterialState(MAT_COLOR));
        box.setRenderState(ts);
        box.updateRenderState();
        box.setModelBound(new BoundingBox());
        box.updateModelBound();
        node.attachChild(box);
        
    }*/
    
    Image getImage(String character) {
        int dx = 30;
        int dy = 200;
        
        BufferedImage bi = new BufferedImage(256, 256,BufferedImage.TYPE_INT_RGB);
        Graphics2D bg = (Graphics2D) bi.getGraphics();
        bg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        //draw the background texture
        bg.drawImage(CORPUS_IMAGE, 0, 0, null);
        //bg.setColor(Color.WHITE);
        //bg.fillRect(0,0,256,256);
        bg.setColor(Color.ORANGE);
        bg.setFont(FONT);
        //draw the Kanji background
        bg.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
        bg.drawString(character, dx, dy);
        //draw the Kanji outline
        bg.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1f));
        bg.setStroke(new BasicStroke(3,
                BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
        bg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        bg.setColor(DARK_COLOR);
        GlyphVector gv = FONT.createGlyphVector(new FontRenderContext(
                null, true, true), character);
        gv.performDefaultLayout();
        Shape s = gv.getOutline();
        float[] coords = new float[6];
        Point start = new Point();
        Point last = new Point();
        for(PathIterator pi = new FlatteningPathIterator(s.getPathIterator(null), 0.1); ! pi.isDone(); pi.next()) {
            int seg = pi.currentSegment(coords);
            int xk = (int) coords[0];
            int yk = (int) coords[1];
            switch(seg) {
                case PathIterator.SEG_MOVETO :
                    last = new Point(xk + dx, yk + dy);
                    start = last;
                    break;
                case PathIterator.SEG_LINETO :
                    bg.drawLine(last.x , last.y, xk + dx, yk + dy);
                    last = new Point(xk + dx, yk + dy);
                    break;
                case PathIterator.SEG_CLOSE :
                    bg.drawLine(last.x, last.y, start.x, start.y);
                    break;
                default : throw new IllegalArgumentException("unknown segment type " + seg);
            }
        }
        bg.dispose();
        return bi;
    }
    
   /* public void die() {
        Vector3f position = node.getLocalTranslation();
        Node rootNode = node.getParent();
        killSound();
        //rootNode.detachChild(this);
        
        final SpatialTransformer st = new SpatialTransformer(1);
        st.setObject(node, 0, -1);
        st.setRepeatType(Controller.RT_CLAMP);
        node.addController(st);
        st.setScale(0, 0, new Vector3f(1, 1, 1));
        st.setScale(0, 0.33f, new Vector3f(0.8f, 0.2f, 0.8f));
        st.setScale(0, 0.67f, new Vector3f(0.2f, 0.2f, 0.2f));
        st.setScale(0, 1, new Vector3f(0, 0, 0));
        st.setPosition(0, 0, node.getLocalTranslation());
        st.setPosition(0, 1, new Vector3f(node.getLocalTranslation().x, -1, node.getLocalTranslation().z));
        st.setNewAnimationTimes(0, 1);
        st.setCurTime(0);
        st.interpolateMissing();
        
        node.addController(new Controller() {
            private float time = 0;
            public void update(float f) {
                time += f;
                if (time > 2) {
                    TextureManager.releaseTexture(tex);
                    node.removeController(this);
                    remove();
                }
            }
        });
    }*/
    
}