editingpanel.java

一个j2me手机游戏程序

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.geom.*;
import java.awt.dnd.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.border.*;
import java.net.*;
import java.io.*;
import java.util.*;

class EditingPanel extends JPanel implements Runnable, MouseListener, MouseMotionListener,KeyListener
{
	public static final int EDITING_IMAGE_WIDTH  = 700;
	public static final int EDITING_IMAGE_HEIGHT = 800;
	
	public static final int CELL_LENGTH = 5;
	public static final int MAPBUFFER_OFF_Y = 50;
	
	static double[] matrix = new double[6];;
	static byte flag;
	
	static int keyCode;
	
	static int tickCounter;
	
	static int zoomFactor = 1;
	
	static int selectedID = -1;
	
	static int buttonPressed = -1;
	
	static int mouseX;
	static int mouseY;
	
	static int oringalMapX;
	static int oringalMapY;
	
	static int imageWidth;
	static int imageHeight;
	
	static int srcImageWidth;
	static int srcImageHeight;
	
	static int nb_tile_in_tile_image_H;
	static int nb_tile_in_tile_image_V;
	
	static int nb_tile_in_map_H;
	static int nb_tile_in_map_V;
	
	static int tileWidth = 16;
	static int tileHeight = 16;
	static int mapWidth = 480;
	static int mapHeight = 288;
	static int screenWidth;
	static int screenHeight;
	
	static int mapX;
	static int mapY;
	
	static int[][] tileData;
	static byte[][] tileFlag;
	
	static boolean repaintMap = true;
	static boolean moveMap;
	static boolean preview;
	
	Image screenBuffer;
	Image tile;
	Image mapBuffer;
	
	Thread m_t = new Thread(this);
	
	EditingPanel()
	{
		initImage("maptileset.png");
		initMatrix(matrix);
		
		addMouseListener(this);
		addMouseMotionListener(this);
		addKeyListener(this);
		
		m_t.start();
	}
	
	void initMatrix(double[] matrix)
	{
		matrix[0] = 1;
		matrix[1] = 0;
		matrix[2] = 0;
		matrix[3] = 1;
		matrix[4] = imageWidth + 50;
		matrix[5] = 0;
	}
	
	void drawCell(Graphics g, int x, int y, int w, int h)
	{
		g.setClip(x,y,w + 1,h + 1);
		g.setColor(Color.gray);
		
		int xspace = tileWidth * zoomFactor;
		int yspace = tileHeight * zoomFactor;
		
		for(int i = 0;i <= w/xspace;i++)
		{
			g.drawLine(x + i * xspace, y, x + i * xspace, y + h);
		}
		
		for(int i = 0;i <= h/yspace;i++)
		{
			g.drawLine(x, y + i * yspace, x + w, y + i * yspace);
		}
	}
	
	void drawMap(Graphics g, int x, int y, int w, int h)
	{
		g.setClip(x - 4 * EDITING_IMAGE_WIDTH, y - 4 * EDITING_IMAGE_WIDTH, 8 *EDITING_IMAGE_WIDTH, EDITING_IMAGE_HEIGHT * 8);
		g.setColor(Color.white);
		g.fillRect(x - 4 * EDITING_IMAGE_WIDTH, y - 4 * EDITING_IMAGE_WIDTH, 8 *EDITING_IMAGE_WIDTH, EDITING_IMAGE_HEIGHT * 8);
		drawCell(g, x, y, w, h);
		
		for(int i = 0;i < tileData.length;i++)
		{
			for(int j = 0;j < tileData[0].length;j++)
			{
				int xInTile = (tileData[i][j] % nb_tile_in_tile_image_H) * tileWidth * zoomFactor;
				int yInTile = (tileData[i][j] / nb_tile_in_tile_image_H) * tileHeight * zoomFactor;
				int clipX = x + i * tileWidth * zoomFactor;
				int clipY = y + j * tileHeight * zoomFactor;
				
				g.setClip(clipX, clipY, tileWidth * zoomFactor,tileHeight * zoomFactor);
				if(tileFlag[i][j] == 0)
				{
					g.drawImage(tile, clipX - xInTile, clipY - yInTile, this);
				}
				else
				{
					int aX = clipX - xInTile;
					int aY = clipY - yInTile;
					
					int tflagx = tileFlag[i][j] & 0x01;
					int tflagy = tileFlag[i][j] & 0x02;
					
					if(tflagx != 0)
					{
						aX = clipX + imageWidth - (imageWidth - tileWidth * zoomFactor - xInTile);
					}
					
					if(tflagy != 0)
					{
						aY = clipY + imageHeight - (imageHeight - tileHeight * zoomFactor - yInTile);
					}
					
					Graphics2D g2 = (Graphics2D)g;
					System.out.println("x="+i + " y="+j+"  "+tileFlag[i][j] + "aX"+aX + " aY"+aY);
					AffineTransform a = new AffineTransform(tflagx == 0 ? 1:-1,0,0,tflagy == 0?1:-1,aX,aY);
					g2.drawImage(tile, a, this);
				}
			}
		}
	}
	
	public void paint(Graphics g)
	{
		g.setColor(Color.white);
		g.setClip(0,0, EDITING_IMAGE_WIDTH, EDITING_IMAGE_HEIGHT);
		g.fillRect(0,0, EDITING_IMAGE_WIDTH, EDITING_IMAGE_HEIGHT);
		
		if(preview)
		{
			
		}
		else
		{
			if(tile != null)
			{
				g.drawImage(tile, 0, 0, this);
				drawCell(g, 0, 0, imageWidth, imageHeight);
				g.setColor(Color.black);
				g.drawRect(0, 0, imageWidth,imageHeight);
			}
			
			if(repaintMap)
			{
				Graphics g_mapBuffer = mapBuffer.getGraphics();
				drawMap(g_mapBuffer, 0, 0, mapWidth * zoomFactor, mapHeight * zoomFactor);
				repaintMap =false;
			}
			
			if(mapBuffer != null)
			{
				g.setClip(0,0, EDITING_IMAGE_WIDTH, EDITING_IMAGE_HEIGHT);
				g.drawImage(mapBuffer, mapX, imageHeight + MAPBUFFER_OFF_Y + mapY, this);
			}
			
			if(selectedID != -1)
			{
				int x = (selectedID % nb_tile_in_tile_image_H) * tileWidth * zoomFactor;
				int y = (selectedID / nb_tile_in_tile_image_H) * tileHeight * zoomFactor;
				int cX = 0;
				int cY = 0;
				
				if(keyCode == KeyEvent.VK_X)
				{
					matrix[0] *= -1;
				}
				else if(keyCode == KeyEvent.VK_Y)
				{
					matrix[3] *= -1;
				}
				else if(keyCode == KeyEvent.VK_A)
				{
					for(int i = 0;i < tileData.length;i++)
					{
						for(int j = 0;j < tileData[0].length;j++)
						{
							tileData[i][j] = selectedID;
							tileFlag[i][j] = flag;
						}
					}
				}
				else if(keyCode == KeyEvent.VK_D)
				{
					for(int i = 0;i < tileData.length;i++)
					{
						for(int j = 0;j < tileData[0].length;j++)
						{
							tileData[i][j] = -1;
							tileFlag[i][j] = 0;
						}
					}
				}
				
				if(matrix[0] == -1)
				{
					matrix[4] = 2 * imageWidth + 50;
					cX = imageWidth + 50 + imageWidth - tileWidth * zoomFactor - x;
					flag |= 0x01;
				}
				else
				{
					matrix[4] = imageWidth + 50;
					cX = imageWidth + 50 + x;
					flag &= 0xfe;
				}
				
				if(matrix[3] == -1)
				{
					matrix[5] = imageHeight;
					cY = imageHeight - tileHeight * zoomFactor - y;
					flag |= 0x02;
				}
				else
				{
					matrix[5] = 0;
					cY = y;
					flag &= 0xfd;
				}
					
				g.setClip(cX,cY,tileWidth * zoomFactor, tileHeight * zoomFactor);
				AffineTransform a = new AffineTransform(matrix);
				Graphics2D g2 = (Graphics2D)g;
				g2.drawImage(tile, a, this);
				
				g.setClip(mouseX - tileWidth * zoomFactor / 2,mouseY - tileHeight * zoomFactor /2, tileWidth * zoomFactor, tileHeight * zoomFactor);
				if(flag == 0)
				{
					g.drawImage(tile, mouseX - tileWidth * zoomFactor / 2 - x,mouseY - tileHeight * zoomFactor /2 - y,this);
				}
				else
				{
					double[] tMatrix = new double[6];
					initMatrix(tMatrix);
					
					tMatrix[4] = mouseX - tileWidth * zoomFactor / 2 - x;
					tMatrix[5] = mouseY - tileHeight * zoomFactor / 2 - y;
					
					if(matrix[0] == -1)
					{
						tMatrix[0] = -1;
						tMatrix[4] = mouseX + imageWidth - tileWidth * zoomFactor / 2 - (imageWidth - tileWidth * zoomFactor - x);
					}
					if(matrix[3] == -1)
					{
						tMatrix[3] = -1;
						tMatrix[5] = mouseY + imageHeight - tileHeight * zoomFactor / 2 - (imageHeight - tileHeight * zoomFactor - y);
					}
					
					AffineTransform t = new AffineTransform(tMatrix);	
					g2.drawImage(tile, t , this);
				}
			}
		}
		
		keyCode = -1;
    }
	
	public void update(Graphics g)
	{
		if(screenBuffer == null)
		{
			screenBuffer=createImage(EDITING_IMAGE_WIDTH,EDITING_IMAGE_HEIGHT);
		}
		Graphics g2=screenBuffer.getGraphics();
		paint(g2);
		g.drawImage(screenBuffer,0,0,null);
	}
	
	public void run()
	{
		while(true)
		{
			try
			{
				tickCounter++;
				if(tickCounter % 3 == 0)
				{
					repaintMap = true;
				}
				repaint();
				m_t.sleep(100);
			}
			catch(Exception e)
			{
			}
		}
	}
	
	
	void initImage(String name)
	{
		tile = (new ImageIcon(name)).getImage();
		
		srcImageWidth = tile.getWidth(this);
		srcImageHeight = tile.getHeight(this);
		
		imageWidth = srcImageWidth;
		imageHeight = srcImageHeight;
		
		nb_tile_in_tile_image_H = imageWidth / tileWidth;
		nb_tile_in_tile_image_V = imageHeight / tileHeight;
		
	}
	
	void initMapBuffer()
	{
		mapBuffer = MapEditor.mapBuffer;
		
		tileData = new int[mapWidth/tileWidth][mapHeight/tileHeight];
		tileFlag = new byte[mapWidth/tileWidth][mapHeight/tileHeight];
		
		for(int i = 0;i < tileData.length;i++)
		{
			for(int j = 0;j < tileData[0].length;j++)
			{
				tileData[i][j] = -1;
			}
		}
		
		repaintMap = true;
	}
	
	void notifyImage()
	{
		if(tile == null)
		{
			return;
		}
		
		try
		{
			zoomFactor = MapEditor.zoomFactor;
			
			imageWidth = srcImageWidth * zoomFactor;
			imageHeight = srcImageHeight * zoomFactor;
			
			Image temp = tile.getScaledInstance(imageWidth,imageHeight,Image.SCALE_SMOOTH);
			
			tile = temp;
			
			repaintMap = true;
		}
		catch(Exception e)
		{
			Image temp = tile.getScaledInstance(imageWidth,imageHeight,Image.SCALE_SMOOTH);
			
			tile = temp;
		}
	}
	
	void setPreview()
	{
		preview = true;
	}
	
	void quitPreview()
	{
		preview = false;
	}
	
	
	public void mouseClicked(MouseEvent e)
	{
		requestFocus();
		
		if(selectedID == -1)
		{
			mouseX = e.getX();
			mouseY = e.getY();
			
			if(mouseX < imageWidth && mouseY < imageHeight)
			{
				selectedID = mouseY / zoomFactor / tileHeight * nb_tile_in_tile_image_H + mouseX / zoomFactor / tileWidth;
				
				System.out.println(selectedID);
			}
		}
		else
		{
			if(e.getButton() == MouseEvent.BUTTON3)
			{
				selectedID = -1;
				initMatrix(matrix);
				flag = 0;
			}
			
			if(mouseX - mapX < mapWidth *zoomFactor && mouseY - mapY > imageHeight + MAPBUFFER_OFF_Y && mouseY - mapY <  imageHeight + MAPBUFFER_OFF_Y + mapHeight * zoomFactor)
			{
				System.out.println("zoomFactor="+zoomFactor);
				int x = (mouseX - mapX) / tileWidth / zoomFactor;
				int y = (mouseY - imageHeight - MAPBUFFER_OFF_Y - mapY) / tileHeight / zoomFactor;
				tileData[x][y] = selectedID;
				tileFlag[x][y] = flag;
				repaintMap = true;
			}
		}
	}

	public void mouseExited(MouseEvent e)
	{
	}

	public void mouseEntered(MouseEvent e)
	{
	}

	public void mousePressed(MouseEvent e)
	{
		mouseX = e.getX();
		mouseY = e.getY();
		
		oringalMapX = mapX;
		oringalMapY = mapY;
		
		buttonPressed = e.getButton();
	}
	
	public void mouseReleased(MouseEvent e)
	{
		buttonPressed = -1;
	}
	
	public void mouseDragged(MouseEvent e) 
	{
		
		if(buttonPressed == MouseEvent.BUTTON3)
		{
			int delX = e.getX() - mouseX;
			int delY = e.getY() - mouseY;
			mapX = delX + oringalMapX;
			mapY = delY + oringalMapY;
		}
	}
	
    public void mouseMoved(MouseEvent e)  
    {
    	if(selectedID != -1)
    	{
    		mouseX = e.getX();
    		mouseY = e.getY();
    	}
    }
    
    public void keyPressed(KeyEvent e)
    {
    	keyCode = e.getKeyCode();
    }
    
    public void keyReleased(KeyEvent e)
    {
    }
    
    public void keyTyped(KeyEvent e)
    {
    }
}