fullcanvas.java

一个j2me的滑雪游戏

        keyPressCount[getKeyIndex(keyCode, true)]++;
        keyPressCount[getKeyIndex(keyCode, false)]++;
        
        if (keyCode == KEY_SOFTKEY1) {
            keyCode = KEY_SOFT1;
        } else if (keyCode == KEY_SOFTKEY2) {
            keyCode = KEY_SOFT2;
        }
        
        processKey(keyCode, true, true);
        processKey(keyCode, true, false);
    }

    public final void keyReleased(final int keyCode) {
        callProcessEvent = true;
        
        int gameIndex = getKeyIndex(keyCode, true);
        int keyIndex = getKeyIndex(keyCode, false);
        keyPressCount[gameIndex]--;
        keyPressCount[keyIndex]--;
        
        if (keyPressCount[gameIndex] <= 0 || emulator) {
            processKey(keyCode, false, true);
            keyPressCount[gameIndex] = 0;
        }
        
        if (keyPressCount[keyIndex] <= 0 || emulator) {
            processKey(keyCode, false, false);
            keyPressCount[keyIndex] = 0;
        }
        
        if (keyCode == KEY_SOFTKEY1) {
            processKey(KEY_SOFT1, false, false);
        } else if (keyCode == KEY_SOFTKEY2) {
            processKey(KEY_SOFT2, false, false);
        }
        
    }

    private void processKey(int keyCode, boolean press, boolean game) {
        if (game) {
          try {
            int gameAction = getGameAction(keyCode);
            switch (gameAction) {
                case UP :
                    if (press) {
                        keypadState |= (1 << KEY_UP);
                        processEvent(KEY_PRESSED_EVENT, KEY_UP);
                    } else {
                        keypadState &= ~(1 << KEY_UP);
                        processEvent(KEY_RELEASED_EVENT, KEY_UP);
                    }
                    callProcessEvent = false;
                    return;
                case DOWN :
                    if (press) {
                        keypadState |= (1 << KEY_DOWN);
                        processEvent(KEY_PRESSED_EVENT, KEY_DOWN);
                    } else {
                        keypadState &= ~(1 << KEY_DOWN);
                        processEvent(KEY_RELEASED_EVENT, KEY_DOWN);
                    }
                    callProcessEvent = false;
                    return;
                case LEFT :
                    if (press) {
                        keypadState |= (1 << KEY_LEFT);
                        processEvent(KEY_PRESSED_EVENT, KEY_LEFT);
                    } else {
                        keypadState &= ~(1 << KEY_LEFT);
                        processEvent(KEY_RELEASED_EVENT, KEY_LEFT);
                    }
                    callProcessEvent = false;
                    return;
                case RIGHT :
                    if (press) {
                        keypadState |= (1 << KEY_RIGHT);
                        processEvent(KEY_PRESSED_EVENT, KEY_RIGHT);
                    } else {
                        keypadState &= ~(1 << KEY_RIGHT);
                        processEvent(KEY_RELEASED_EVENT, KEY_RIGHT);
                    }
                    callProcessEvent = false;
                    return;
                case FIRE :
                    if (press) {
                        keypadState |= (1 << KEY_SELECT);
                        processEvent(KEY_PRESSED_EVENT, KEY_SELECT);
                    } else {
                        keypadState &= ~(1 << KEY_SELECT);
                        processEvent(KEY_RELEASED_EVENT, KEY_SELECT);
                    }
                    callProcessEvent = false;
                    return;
            }
          } catch(Exception e){}
        } else {
            switch (keyCode) {
                case KEY_NUM0 :
                    if (press) {
                        keypadState |= (1 << KEY_0);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_0);
                    } else {
                        keypadState &= ~(1 << KEY_0);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_0);
                    }
                    return;
                case KEY_NUM1 :
                    if (press) {
                        keypadState |= (1 << KEY_1);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_1);
                    } else {
                        keypadState &= ~(1 << KEY_1);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_1);
                    }
                    return;
                case KEY_NUM2 :
                    if (press) {
                        keypadState |= (1 << KEY_2);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_2);
                    } else {
                        keypadState &= ~(1 << KEY_2);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_2);
                    }
                    return;
                case KEY_NUM3 :
                    if (press) {
                        keypadState |= (1 << KEY_3);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_3);
                    } else {
                        keypadState &= ~(1 << KEY_3);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_3);
                    }
                    return;
                case KEY_NUM4 :
                    if (press) {
                        keypadState |= (1 << KEY_4);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_4);
                    } else {
                        keypadState &= ~(1 << KEY_4);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_4);
                    }
                    return;
                case KEY_NUM5 :
                    if (press) {
                        keypadState |= (1 << KEY_5);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_5);
                    } else {
                        keypadState &= ~(1 << KEY_5);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_5);
                    }
                    return;
                case KEY_NUM6 :
                    if (press) {
                        keypadState |= (1 << KEY_6);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_6);
                    } else {
                        keypadState &= ~(1 << KEY_6);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_6);
                    }
                    return;
                case KEY_NUM7 :
                    if (press) {
                        keypadState |= (1 << KEY_7);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_7);
                    } else {
                        keypadState &= ~(1 << KEY_7);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_7);
                    }
                    return;
                case KEY_NUM8 :
                    if (press) {
                        keypadState |= (1 << KEY_8);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_8);
                    } else {
                        keypadState &= ~(1 << KEY_8);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_8);
                    }
                    return;
                case KEY_NUM9 :
                    if (press) {
                        keypadState |= (1 << KEY_9);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_9);
                    } else {
                        keypadState &= ~(1 << KEY_9);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_9);
                    }
                    return;
                case KEY_STAR :
                    if (press) {
                        keypadState |= (1 << KEY_ASTERISK);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_ASTERISK);
                    } else {
                        keypadState &= ~(1 << KEY_ASTERISK);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_ASTERISK);
                    }
                    return;
                case Canvas.KEY_POUND :
                    if (press) {
                        keypadState |= (1 << KEY_POUND);
                        if (callProcessEvent) processEvent(KEY_PRESSED_EVENT, KEY_POUND);
                    } else {
                        keypadState &= ~(1 << KEY_POUND);
                        if (callProcessEvent) processEvent(KEY_RELEASED_EVENT, KEY_POUND);
                    }
                    return;
                case KEY_SOFT1 :
                    if (press) {
                        keypadState |= (1 << KEY_SOFT1);
                        processEvent(KEY_PRESSED_EVENT, KEY_SOFT1);
                        if (listener != null) listener.commandAction(cmdLeft, this);
                    } else {
                        keypadState &= ~(1 << KEY_SOFT1);
                        processEvent(KEY_RELEASED_EVENT, KEY_SOFT1);
                    }
                    return;
                case KEY_SOFT2 :
                    if (press) {
                        keypadState |= (1 << KEY_SOFT2);
                        processEvent(KEY_PRESSED_EVENT, KEY_SOFT2);
                        if (listener != null) listener.commandAction(cmdRight, this);
                    } else {
                        keypadState &= ~(1 << KEY_SOFT2);
                        processEvent(KEY_RELEASED_EVENT, KEY_SOFT2);
                    }
                    return;
            }
        }
    }

    public void processEvent(int type, int param) {}

    public void setCommandListener(CommandListener listener) {
        this.listener = listener;
    }
    
    public void addCommand(Command c) {
        if (c != null) {
            int type = c.getCommandType();
            switch (type) {
                case Command.OK:
                case Command.SCREEN:
                case Command.ITEM:
                case Command.HELP:
                    cmdRight = c;
                    break;
                case Command.BACK:
                case Command.CANCEL:
                case Command.EXIT:
                    cmdLeft = c;
                    break;
            }
        }
    }

    public void removeCommand(Command c) {
        if (c != null) {
            if (cmdRight != null && c.equals(cmdRight)) cmdRight = null;
            if (cmdLeft != null && c.equals(cmdLeft)) cmdLeft = null;
        }
    }
    
    private int getKeyIndex(int keyCode, boolean game) {
        if (game) {
          try {
            int gameAction = getGameAction(keyCode);    
            switch (gameAction) {
                case UP: return 1;
                case DOWN: return 2;
                case LEFT: return 3;
                case RIGHT: return 4;
                case FIRE: return 5;
            }
          } catch(Exception e){}
        } else {
            switch (keyCode) {
                case KEY_NUM0: return 6;
                case KEY_NUM1: return 7;
                case KEY_NUM2: return 8;
                case KEY_NUM3: return 9;
                case KEY_NUM4: return 10;
                case KEY_NUM5: return 11;
                case KEY_NUM6: return 12;
                case KEY_NUM7: return 13;
                case KEY_NUM8: return 14;
                case KEY_NUM9: return 15;
                case KEY_STAR: return 16;
                case KEY_POUND: return 17;
                case KEY_SOFT1: return 18;
                case KEY_SOFT2: return 19;
            } 
        }
        return 0;
    }
    
    public static int getColorOfRGB(int r, int g, int b) {
        return (((r & 0xff) << 16) + ((g & 0xff) << 8) + (b & 0xff));
    }
}