RPGCanvas.java
上传用户:gyyuli
上传日期:2013-07-09
资源大小:3050k
文件大小:6k
源码类别:

J2ME

开发平台:

Java

  1. import javax.microedition.lcdui.Graphics;
  2. import javax.microedition.lcdui.game.*;
  3. public class RPGCanvas extends GameCanvas implements Runnable
  4. {
  5. private static final int X = 0;
  6. private static final int Y = 1;
  7. private static final int WIDTH = 2;
  8. private static final int HEIGHT = 3;
  9. private static final int STEP = 3;
  10. private Hero loader;
  11. private Sprite hero;
  12. private Thread thread;
  13. private TiledLayer layer;
  14. private Map map;
  15. private int lastState = -1;
  16. private int WORLD_WIDTH;
  17. private int WORLD_HEIGHT;
  18. private int[] view = new int[4];
  19. private boolean initialized = false;
  20. private boolean paused = false;
  21. private Object executionLock = new Object();
  22. public RPGCanvas()
  23. {
  24. super(true);
  25. setFullScreenMode(true);
  26. }
  27. public void showNotify()
  28. {
  29. if(initialized)
  30. {
  31. synchronized (executionLock)
  32. {
  33. if (paused)
  34. {
  35. paused = false;
  36. executionLock.notify();
  37. }
  38. }
  39. }
  40. }
  41. public void hideNotify()
  42. {
  43. synchronized (executionLock)
  44. {
  45. paused = true;
  46. }
  47. }
  48. public void initialize()
  49. {
  50. view[X] = 0;
  51. view[Y] = 0;
  52. view[WIDTH] = getWidth();
  53. view[HEIGHT] = getHeight();
  54. loader = new Hero();
  55. loader.load();
  56. hero = loader.getHero();
  57. hero.defineCollisionRectangle(
  58. 0,
  59. 0,
  60. hero.getWidth(),
  61. hero.getHeight());
  62. map = new Map();
  63. map.insert(hero, 0);
  64. map.setViewWindow(0, 0, getWidth(), getHeight());
  65. int[] size = getWorldSize();
  66. WORLD_WIDTH = size[0];
  67. WORLD_HEIGHT = size[1];
  68. initialized = true;
  69. }
  70. private int[] getWorldSize()
  71. {
  72. int width = 0;
  73. int height = 0;
  74. for (int i = 0; i < map.getSize(); i++)
  75. {
  76. Layer layer = map.getLayerAt(i);
  77. if(layer.getWidth() > width)
  78. width = layer.getWidth();
  79. if(layer.getHeight() > height)
  80. height = layer.getHeight();
  81. }
  82. return new int[]{width, height};
  83. }
  84. public void start()
  85. {
  86. thread = new Thread(this);
  87. thread.start();
  88. }
  89. public void stop()
  90. {
  91. initialized = false;
  92. thread = null;
  93. }
  94. public void run()
  95. {
  96. Graphics g = getGraphics();
  97. while (initialized)
  98. {
  99. synchronized (executionLock)
  100. {
  101. if (paused)
  102. {
  103. try
  104. {
  105. wait();
  106. }
  107. catch (Exception e)
  108. {
  109. }
  110. }
  111. }
  112. int keyState = getKeyStates();
  113. if ((keyState & LEFT_PRESSED) != 0)
  114. {
  115. if (lastState != LEFT_PRESSED)
  116. {
  117. lastState = LEFT_PRESSED;
  118. hero.setFrameSequence(new int[] { 9, 10, 11 });
  119. }
  120. else
  121. {
  122. hero.nextFrame();
  123. }
  124. if(hero.getX() - STEP >= 0)
  125. hero.move(-STEP, 0);
  126. else
  127. hero.setPosition(0, hero.getY());
  128. }
  129. else if ((keyState & RIGHT_PRESSED) != 0)
  130. {
  131. if (lastState != RIGHT_PRESSED)
  132. {
  133. lastState = RIGHT_PRESSED;
  134. hero.setFrameSequence(new int[] { 3, 4, 5 });
  135. }
  136. else
  137. {
  138. hero.nextFrame();
  139. }
  140. if(hero.getX() + hero.getWidth() < WORLD_WIDTH)
  141. hero.move(STEP, 0);
  142. else
  143. hero.setPosition(WORLD_WIDTH-hero.getWidth(), hero.getY());
  144. }
  145. else if ((keyState & UP_PRESSED) != 0)
  146. {
  147. if (lastState != UP_PRESSED)
  148. {
  149. lastState = UP_PRESSED;
  150. hero.setFrameSequence(new int[] { 0, 1, 2 });
  151. }
  152. else
  153. {
  154. hero.nextFrame();
  155. }
  156. if(hero.getY() - STEP >= 0)
  157. hero.move(0, -STEP);
  158. else
  159. hero.setPosition(hero.getX(), 0);
  160. }
  161. else if ((keyState & DOWN_PRESSED) != 0)
  162. {
  163. if (lastState != DOWN_PRESSED)
  164. {
  165. lastState = DOWN_PRESSED;
  166. hero.setFrameSequence(new int[] { 6, 7, 8 });
  167. }
  168. else
  169. {
  170. hero.nextFrame();
  171. }
  172. if(hero.getY() + hero.getHeight() < WORLD_HEIGHT)
  173. hero.move(0, STEP);
  174. else
  175. hero.setPosition(hero.getX(), WORLD_HEIGHT-hero.getHeight());
  176. }
  177. checkCollision(lastState);
  178. // Next scroll the view if needed
  179. if (hero.getX() < view[X] + hero.getWidth())
  180. {
  181. int dx = (view[X] - hero.getX() + hero.getWidth());
  182. if (view[X] - dx >= 0)
  183. {
  184. view[X] -= dx;
  185. }
  186. }
  187. else if (
  188. hero.getX() + hero.getWidth()
  189. > (view[X] + view[WIDTH]) - hero.getWidth())
  190. {
  191. int dx =
  192. (hero.getX() + hero.getWidth())
  193. - (view[X] + view[WIDTH] - hero.getWidth());
  194. if(view[X] + view[WIDTH] <= WORLD_WIDTH)
  195. {
  196. view[X] += dx;
  197. }
  198. }
  199. if (hero.getY() < view[Y] + hero.getHeight()) // scoll up
  200. int dy = (view[Y] - hero.getY() + hero.getHeight());
  201. if (view[Y] - dy >= 0)
  202. {
  203. view[Y] -= dy;
  204. }
  205. }
  206. else if ( 
  207. hero.getY() + hero.getHeight()
  208. > (view[Y] + view[HEIGHT]) - hero.getHeight()) // scroll down
  209. {
  210. int dy =
  211. (hero.getY() + hero.getHeight())
  212. - (view[Y] + view[HEIGHT] - hero.getHeight());
  213. if(view[Y] + view[HEIGHT] <= WORLD_HEIGHT)
  214. {
  215. view[Y] += dy;
  216. }
  217. }
  218. map.setViewWindow(
  219. view[X],
  220. view[Y],
  221. view[WIDTH],
  222. view[HEIGHT]);
  223. map.paint(g, 0, 0);
  224. flushGraphics();
  225. try
  226. {
  227. Thread.sleep(100);
  228. }
  229. catch (Exception e)
  230. {
  231. e.printStackTrace();
  232. }
  233. }
  234. }
  235. private void checkCollision(int key)
  236. {
  237. if (hero.collidesWith((TiledLayer) map.getLayerAt(1), true))
  238. {
  239. if (key == LEFT_PRESSED)
  240. hero.move(STEP, 0);
  241. else if (key == RIGHT_PRESSED)
  242. hero.move(-STEP, 0);
  243. else if (key == UP_PRESSED)
  244. hero.move(0, STEP);
  245. else
  246. hero.move(0, -STEP);
  247. }
  248. }
  249. public void paint(Graphics g)
  250. {
  251. if (!initialized)
  252. {
  253. initialize();
  254. if (thread == null)
  255. {
  256. start();
  257. }
  258. }
  259. super.paint(g);
  260. }
  261. }