PageRenderTime 43ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/engine_java/000_Engine_Core/j2se/com/cell/j2se/GameCanvas.java

http://cellengine.googlecode.com/
Java | 359 lines | 286 code | 57 blank | 16 comment | 17 complexity | 5d0a8edab5cbaacfc5e9fad732baf19f MD5 | raw file
Possible License(s): GPL-2.0, AGPL-1.0, BSD-3-Clause, AGPL-3.0, LGPL-2.1, Apache-2.0, MPL-2.0-no-copyleft-exception, CPL-1.0
  1. package com.cell.j2se;
  2. import java.awt.Component;
  3. import java.awt.Graphics2D;
  4. import java.awt.GraphicsConfiguration;
  5. import java.awt.Image;
  6. import java.awt.Transparency;
  7. import java.awt.event.KeyEvent;
  8. import java.awt.event.KeyListener;
  9. import java.awt.event.MouseEvent;
  10. import java.awt.event.MouseListener;
  11. import java.awt.event.MouseMotionListener;
  12. import java.awt.event.MouseWheelEvent;
  13. import java.awt.event.MouseWheelListener;
  14. import com.cell.CObject;
  15. import com.cell.IAppBridge;
  16. import com.cell.gfx.AScreen;
  17. import com.cell.gfx.IImage;
  18. public class GameCanvas implements KeyListener, MouseListener, MouseMotionListener, MouseWheelListener, Runnable
  19. {
  20. static private GameCanvas s_m_GameCanvas;
  21. final static public GameCanvas createInstance(IGame game){
  22. AScreen.clearCurScreen();
  23. s_m_GameCanvas = new GameCanvas(game);
  24. return s_m_GameCanvas;
  25. }
  26. final static public GameCanvas getInstance(){
  27. return s_m_GameCanvas;
  28. }
  29. //------------------------------------------------------------------
  30. private volatile Component Canvas;
  31. private volatile Thread GameThread;
  32. private volatile boolean ThreadChanged = false;
  33. public IGame Game;
  34. Image Buffer;
  35. CGraphics CG;
  36. int offset_x;
  37. int offset_y;
  38. float rate_x;
  39. float rate_y;
  40. float scale_x;
  41. float scale_y;
  42. private GameCanvas(IGame game)
  43. {
  44. Game = game;
  45. // CObject.initSystem(new CStorage(), bridge);
  46. // bridge.setSavePath(game.getSavePath());
  47. // CStorage.setAppPath(bridge.getAppSavePath());
  48. // Game.init();
  49. AScreen.SCREEN_WIDTH = game.getWidth();
  50. AScreen.SCREEN_HEIGHT = game.getHeight();
  51. AScreen.SCREEN_HCENTER = game.getWidth()/2;
  52. AScreen.SCREEN_VCENTER = game.getHeight()/2;
  53. IImage img = Game.getLoadingImage();
  54. if(img!=null){
  55. AScreen.ChangeSubScreen(Game.getRootScreenName(), img);
  56. }else{
  57. AScreen.ChangeSubScreen(Game.getRootScreenName(), "Loading...");
  58. }
  59. }
  60. synchronized public void startGame(Component canvas, Thread thread)
  61. {
  62. if (GameThread!=null)
  63. {
  64. if (GameThread.isAlive()){
  65. ThreadChanged = true;
  66. try {
  67. GameThread.join(1000);
  68. } catch (InterruptedException e) {
  69. e.printStackTrace();
  70. }
  71. }
  72. GameThread = null;
  73. }
  74. if (Canvas!=null)
  75. {
  76. Canvas.removeKeyListener(this);
  77. Canvas.removeMouseListener(this);
  78. Canvas.removeMouseMotionListener(this);
  79. Canvas.removeMouseWheelListener(this);
  80. }
  81. Canvas = canvas;
  82. Canvas.setFocusable(true);
  83. Canvas.setEnabled(true);
  84. Canvas.enableInputMethods(true);
  85. Canvas.addKeyListener(this);
  86. Canvas.addMouseListener(this);
  87. Canvas.addMouseMotionListener(this);
  88. Canvas.addMouseWheelListener(this);
  89. GameThread = thread;
  90. ThreadChanged = false;
  91. GameThread.start();
  92. }
  93. synchronized public void exitGame(long timeOut){
  94. AScreen.ExitGame = true;
  95. ThreadChanged = true;
  96. if (GameThread!=null){
  97. try {
  98. GameThread.join(timeOut);
  99. } catch (InterruptedException e) {
  100. e.printStackTrace();
  101. }
  102. }
  103. }
  104. public void paint(Graphics2D g, int x, int y, int w, int h)
  105. {
  106. offset_x = x;
  107. offset_y = y;
  108. rate_x = AScreen.SCREEN_WIDTH / (float)w;
  109. rate_y = AScreen.SCREEN_HEIGHT / (float)h;
  110. scale_x = (float)w / AScreen.SCREEN_WIDTH;
  111. scale_y = (float)h / AScreen.SCREEN_HEIGHT;
  112. if(Buffer==null)
  113. {
  114. GraphicsConfiguration gc = g.getDeviceConfiguration();
  115. Buffer = gc.createCompatibleImage(
  116. AScreen.SCREEN_WIDTH,
  117. AScreen.SCREEN_HEIGHT,
  118. Transparency.OPAQUE);
  119. CG = new CGraphics((Graphics2D)Buffer.getGraphics());
  120. AScreen.CurGraphics = CG;
  121. }
  122. else{
  123. try {
  124. AScreen.gobal_paint(CG);
  125. g.drawImage(Buffer, offset_x, offset_y, w, h, Canvas);
  126. } catch (Exception err) {
  127. err.printStackTrace();
  128. }
  129. /*AffineTransform t = new AffineTransform();
  130. t.translate(offset_x, offset_y);
  131. t.scale(scale_x, scale_y);
  132. g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  133. g.drawImage(Buffer, t, Canvas);*/
  134. }
  135. }
  136. public void run()
  137. {
  138. AScreen.ExitGame = false;
  139. AScreen.FrameDelay = 1000 / Game.getFPS();
  140. while (!AScreen.ExitGame && !ThreadChanged)
  141. {
  142. long time = System.currentTimeMillis();
  143. try {
  144. AScreen.gobal_update();
  145. } catch (Exception err) {
  146. Game.exceptionCaught(err);
  147. //AScreen.clearCurScreen();
  148. //s_m_GameCanvas = null; // destory singlton instance
  149. err.printStackTrace();
  150. }
  151. Canvas.repaint();
  152. try{
  153. long elapsedTime = System.currentTimeMillis() - time;
  154. if (elapsedTime < AScreen.FrameDelay) {
  155. Thread.sleep(AScreen.FrameDelay - elapsedTime);
  156. }
  157. }catch(InterruptedException ir){
  158. ThreadChanged = true;
  159. ir.printStackTrace();
  160. break;
  161. }
  162. }
  163. if (AScreen.ExitGame){
  164. AScreen.clearCurScreen();
  165. Game.exited();
  166. s_m_GameCanvas = null; // destory singlton instance
  167. // for (IAppBridge.IAppStateListener listener : CObject.AppBridge.getAppListeners()){
  168. // listener.appExited();
  169. // }
  170. }
  171. GameThread = null;
  172. }
  173. public int getWidth(){
  174. return AScreen.SCREEN_WIDTH;
  175. }
  176. public int getHeight(){
  177. return AScreen.SCREEN_HEIGHT;
  178. }
  179. private int OldFrameDelay = 40;
  180. public boolean isActive(){
  181. return AScreen.RenderEnable;
  182. }
  183. public void activated() {
  184. AScreen.RenderEnable = true;
  185. AScreen.FrameDelay = OldFrameDelay;
  186. if(AScreen.getCurScreen()!=null){
  187. AScreen.getCurScreen().notifyResume();
  188. AScreen.clearKey();
  189. }
  190. }
  191. public void deactivated() {
  192. OldFrameDelay = AScreen.FrameDelay;
  193. AScreen.RenderEnable = false;
  194. AScreen.FrameDelay = 100;
  195. if(AScreen.getCurScreen()!=null){
  196. AScreen.getCurScreen().notifyPause();
  197. AScreen.clearKey();
  198. }
  199. }
  200. final private int getKeyValue(int keyCode) {
  201. switch (keyCode) {
  202. case KeyEvent.VK_0 :
  203. return AScreen.KEY_0;
  204. case KeyEvent.VK_1 :
  205. return AScreen.KEY_1;
  206. case KeyEvent.VK_2 :
  207. return AScreen.KEY_2;
  208. case KeyEvent.VK_3 :
  209. return AScreen.KEY_3;
  210. case KeyEvent.VK_4 :
  211. return AScreen.KEY_4;
  212. case KeyEvent.VK_5 :
  213. return AScreen.KEY_5;
  214. case KeyEvent.VK_6 :
  215. return AScreen.KEY_6;
  216. case KeyEvent.VK_7 :
  217. return AScreen.KEY_7;
  218. case KeyEvent.VK_8 :
  219. return AScreen.KEY_8;
  220. case KeyEvent.VK_9 :
  221. return AScreen.KEY_9;
  222. case KeyEvent.VK_ALT :
  223. return AScreen.KEY_SHARP;
  224. case KeyEvent.VK_CONTROL:
  225. return AScreen.KEY_STAR;
  226. case KeyEvent.VK_UP :
  227. return AScreen.KEY_UP;
  228. case KeyEvent.VK_DOWN :
  229. return AScreen.KEY_DOWN;
  230. case KeyEvent.VK_LEFT :
  231. return AScreen.KEY_LEFT;
  232. case KeyEvent.VK_RIGHT :
  233. return AScreen.KEY_RIGHT;
  234. case KeyEvent.VK_F1 :
  235. return AScreen.KEY_A;
  236. case KeyEvent.VK_F2 :
  237. case KeyEvent.VK_ESCAPE :
  238. return AScreen.KEY_B;
  239. case KeyEvent.VK_ENTER :
  240. return AScreen.KEY_C;
  241. case KeyEvent.VK_TAB:// tab
  242. return AScreen.KEY_TAB;
  243. case -11:
  244. default :
  245. return 0;
  246. }
  247. }
  248. public void keyPressed(KeyEvent e) {
  249. AScreen.keyPressed(getKeyValue(e.getKeyCode()));
  250. }
  251. public void keyReleased(KeyEvent e) {
  252. AScreen.keyReleased(getKeyValue(e.getKeyCode()));
  253. }
  254. public void keyTyped(KeyEvent e) {
  255. AScreen.keyTyped(e.getKeyChar());
  256. }
  257. // mouse
  258. public void mouseClicked(MouseEvent e) {}
  259. public void mouseEntered(MouseEvent e) {}
  260. public void mouseExited(MouseEvent e) {}
  261. public void mousePressed(MouseEvent e) {
  262. if(e.getButton()==MouseEvent.BUTTON1){
  263. AScreen.pointerPressed(
  264. -offset_x + (int)(e.getX() * rate_x),
  265. -offset_y + (int)(e.getY() * rate_y)
  266. );
  267. }else{
  268. AScreen.keyPressed(AScreen.KEY_B);
  269. }
  270. }
  271. public void mouseReleased(MouseEvent e) {
  272. if(e.getButton()==MouseEvent.BUTTON1){
  273. AScreen.pointerReleased(
  274. -offset_x + (int)(e.getX() * rate_x),
  275. -offset_y + (int)(e.getY() * rate_y)
  276. );
  277. }else{
  278. AScreen.keyReleased(AScreen.KEY_B);
  279. }
  280. }
  281. public void mouseDragged(MouseEvent e) {
  282. AScreen.pointerMoved(
  283. -offset_x + (int)(e.getX() * rate_x),
  284. -offset_y + (int)(e.getY() * rate_y)
  285. );
  286. }
  287. public void mouseMoved(MouseEvent e) {
  288. AScreen.pointerMoved(
  289. -offset_x + (int)(e.getX() * rate_x),
  290. -offset_y + (int)(e.getY() * rate_y)
  291. );
  292. }
  293. public void mouseWheelMoved(MouseWheelEvent e) {
  294. if(e.getWheelRotation()>0){
  295. AScreen.keyPressed(AScreen.KEY_DOWN);
  296. AScreen.keyReleased(AScreen.KEY_DOWN);
  297. }else if(e.getWheelRotation()<0){
  298. AScreen.keyPressed(AScreen.KEY_UP);
  299. AScreen.keyReleased(AScreen.KEY_UP);
  300. }
  301. }
  302. }