[ATMEGA128] 레포트


#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/signal.h>

volatile unsigned int TIC_TIME;

void init_port(void){
        DDRF=0xFF;
        PORTF=0x00;
}
void init_timer1(void){
        TCNT1H=0;
        TCNT1L=0;
        TCCR1A=0x00;
        TCCR1B=0x0C;
        TCCR1C=0x00;

        OCR1AH=0xF4;
        OCR1AL=0x24;
        TIMSK=TIMSK|(1<<OCIE1A);
}

void init_timer(void){
        TIFR=0x00;
        init_timer1();
}
void init(void){
        init_port();
        init_timer();
}

SIGNAL(SIG_OUTPUT_COMPARE1A){
        TIC_TIME++;
}
int main(void){
        init();
        sei();
        while(1){
                if(TIC_TIME>99){
                        TIC_TIME=0;
                        PORTF=0x00;
                }
                else
                        PORTF=(TIC_TIME/10)<<4||TIC_TIME%10;
        }

        return 0;
}


Posted by rCan

2008/12/09 17:25 2008/12/09 17:25
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/585

[ATMEGA128] 시험관련


/*
시계 FND 0부터 59초
60초가 되면 LED1개 켜지기
OVERFLOW0 사용
08.12.10 수정
*/
#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/signal.h>


volatile unsigned int TIC_TIME;
volatile unsigned int TIME;
volatile unsigned int min;
volatile unsigned int sec;

void init_port(void){
        DDRC=0xFF;
        DDRD=0xFF;

        PORTC=0xFF;
        PORTD=0x00;
}
void init_timer0(void){
        TCCR0=0x04;
        TCNT0=6;
        TIMSK=TIMSK|(1<<TOIE0);
}
void init_timer(void){
        TIFR=0x00;
        init_timer0();
}
void init(void){
        init_port();
        init_timer();
}

SIGNAL(SIG_OVERFLOW0){
        TCNT0=6;
        TIC_TIME++;
}

int main(void){

        init();
        sei();
        while(1){
                if(TIC_TIME>1000){
                        TIC_TIME=0;
                        TIME++;
                        if(TIME==540){
                                PORTC=0xFF;
                                TIME=0;
                        }
                }
                min=TIME/60;
                sec=TIME%60;


                PORTC=0xFF<<min;
                PORTD=(sec/10)<<4||(sec%10);
        }

        return 0;
}

Posted by rCan

2008/12/09 16:39 2008/12/09 16:39
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/584

[게임제작] 기말고사

1. chapter 24
- WIPI IO 패키지에 포함된 파일클래스의 종류
- 파일 클래스의 3가지 접근 권한
- 파일클래스의 4가지 모드
- 스트림 클래스

2. chapter 22
- 적캐릭터와의 충돌체크 부분 소스 분석

3.모바일 게임에서의 "컨버팅(Converting)"의 의미?

4. Edit Plus의 환경설정 방법 (jar 파일 만드는 방법)

5. 통신 3사의 게임 상용화 절차를 간략하게 요약정리

Posted by rCan

2008/12/09 15:21 2008/12/09 15:21
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/583

[ATMEGA128] 키스캔 + fun

/*
0번핀 500ms 토글
1번 200ms 토글
2번핀입력일경우 나머지 6개 LED 로테이트 200ms
3번 모두 오프
4번 모두 온
5번 3개 온 3개 오프
6번 2개씩 led  프래쉬
7번 징검다리 온오프 온오프
*/
#include<stdio.h>
#include<avr/interrupt.h>
#include<avr/signal.h>

#define CPU_CLOCK 16000000
#define TICKS_PER_SEC 1000
#define Prescaler 64
#define OVERFLOW 256

volatile unsigned int cnt;
volatile unsigned int tic_time;
volatile unsigned int tic_time2;
volatile unsigned int oc1cnt;
volatile unsigned int oc3cnt;
volatile unsigned int FUN_MODE;

volatile unsigned char KEY_STATE;
volatile unsigned char CURRENT_KEY_STATE;
volatile unsigned char LAST_KEY_STATE;

void init_port(void);
void init_timer(void);
void init_timer0(void);
void init_timer1(void);
void init_timer3(void);
void fun_run(void);

int main(void){
        CURRENT_KEY_STATE=0xFF;
        LAST_KEY_STATE=0xFF;

        init_port();
        init_timer();
        init_timer0();
        init_timer1();
        init_timer3();
        sei();

        while(1){
                if(FUN_MODE!=0)
                        if(tic_time2>=200){ tic_time2=0; fun_run(); }

                CURRENT_KEY_STATE=PINF; // SW에 값을 CURRENT_KEY_STATE에 넣어줌
                if(CURRENT_KEY_STATE!=0xFF){
                // CURRENT_KEY_STATE가 0xFF가 아닌 경우(어느 키라도 눌렸을경우)
                        if(CURRENT_KEY_STATE!=LAST_KEY_STATE){
                        // 지금 누른키와 눌린키가 아닐 경우 (키가 변경된 경우)
                                tic_time=0;
                                KEY_STATE=0;
                        }
                        if(tic_time>=50){
                                // 키를 누르고 50ms가 지났으면 (계속 눌려잇는 경우)
                                if(KEY_STATE==0){
                                        KEY_STATE=1;
                                        if(CURRENT_KEY_STATE==0xFE) sbi(DDRB,5); // oc1a를 출력으로 설정
                                        if(CURRENT_KEY_STATE==0xFD) sbi(DDRE,3); // oc3a를 출력으로 설정
                                        if(CURRENT_KEY_STATE==0xFB) FUN_MODE=1;
                                        if(CURRENT_KEY_STATE==0xF7) FUN_MODE=2;
                                        if(CURRENT_KEY_STATE==0xEF) FUN_MODE=3;
                                        if(CURRENT_KEY_STATE==0xDF) FUN_MODE=4;
                                        if(CURRENT_KEY_STATE==0xBF) FUN_MODE=5;
                                        if(CURRENT_KEY_STATE==0x7F) FUN_MODE=6;
                                }
                        }
                }
                else KEY_STATE=0; // PINA가 0xFF인경우는 KEY_STATE를 0으로 초기화 시켜준다.
                LAST_KEY_STATE=CURRENT_KEY_STATE; // 현재 눌린키를 눌려진 키로 넣어줌
                if(tic_time>=1000){

                // 키를 누르지 않을 경우에 생기는 문제점을 해결하기 위해서
                // tic_time은 int형 변수이기에 넘어가게 되면 오버 플로우가 발생될가능성도 있다.
                // 그것뿐만 아니라 예를 들어 키보드 방향키 위를 생각해보면
                // 위를 한번 꾸우우우욱 누른경우랑
                // 위를 한번  꾹 누른 경우랑 같게 된다는것이다.
                        tic_time=0;
                        LAST_KEY_STATE=0xFF;
                }

        }
        return 0;
}

void init_port(void){
        DDRF=0x00;
        DDRC=0xFF;
        PORTC=0xFF;
}
void init_timer(void){
        // 타이머에 관한 전반적인 공통사항을 기술
        TIFR=0x00;
}
void init_timer0(void){
        // 타이머0에 대한 설정
        TCCR0=0x04;
        TCNT0=OVERFLOW - (CPU_CLOCK / TICKS_PER_SEC / Prescaler);
        TIMSK=0x01;
}
void init_timer1(void){
        // 타이머1에 대한 설정
        TCNT1H=0x00;
        TCNT1L=0x00;

        TCCR1A=0x40;
        TCCR1B=0x0C;
        TCCR1C=0x00;

        OCR1AH=0x7A;
        OCR1AL=0x12;
        TIMSK=TIMSK|(1<OCIE1A);
}
void init_timer3(void){
        // 타이머3에 대한 설정
        TCNT3H=0x00;
        TCNT3L=0x00;

        TCCR3A=0x40;
        TCCR3B=0x0C;
        TCCR3C=0x00;

        OCR3AH=0x18;
        OCR3AL=0x6A;
        TIMSK=ETIMSK|(1<OCIE3A);
}
SIGNAL(SIG_OVERFLOW0){
        // 오버 플로우 인터럽트 발생시 (timer0에서 발생되는..)
        tic_time++;
        tic_time2++;
        TCNT0 = OVERFLOW - (CPU_CLOCK / TICKS_PER_SEC / Prescaler);
}
SIGNAL(SIG_OUTPUT_COMPARE1A){

}
SIGNAL(SIG_OUTPUT_COMPARE3A){

}

void fun_run(void){
        switch(FUN_MODE){
                case 1:
                break; // 6개 로테이트
                case 2: PORTC=0x3F; break; // 6개 OFF 해결
                case 3: PORTC=0x00; break; // 6개 on 해결
                case 4: PORTC=0x38; break; // 6개 3on 3off 해결
                case 5: PORTC=0xFF<<cnt);
                break; // 2개씩 반복
                case 6: PORTC=0xAA; break; // onoffonoff 해결
        }
}

Posted by rCan

2008/10/15 16:55 2008/10/15 16:55
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/580

[ATMEGA128] 시험

/*
INT0
timer0 500ms
평상시
LED_OFF 0xFF - PORTF

INT0 입력이 들어오면 500ms후에 불이 켜지게
하나씩 증가시켜서 불이 켜지도록 8개까지 켜지고 종료
*/

#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/signal.h>

#define CPU_CLOCK 16000000
#define TICKS_PER_SEC 1000
#define Prescaler 64
#define OVERFLOW 256

volatile unsigned int tic_time;
volatile unsigned STATE_FLAG;

void init_port(void);
void init_timer0(void);

int main(void){

        init_port();
        init_timer0();

        sei();
        while(1){
                if(tic_time>=500&&STATE_FLAG==1){
                        tic_time=0;
                        PORTF=(PORTF<<1);
                }
        }
        return 0;
}

void init_port(void){
        DDRF=0xFF;
        PORTF=0xFF;
        cbi(DDRD,INT0);

        EIFR=0x00;
        EICRA=0x03;
        EIMSK=0x01;
}
void init_timer0(void){
        TIFR=0x00;
        TCNT0=0x00;
        TCCR0=0x0C;
        OCR0=CPU_CLOCK/TICKS_PER_SEC/Prescaler;
        TIMSK=0x02;
}
SIGNAL(SIG_INTERRUPT0){
        tic_time=0;
        STATE_FLAG=1;
}

SIGNAL(SIG_OUTPUT_COMPARE0){
        tic_time++;
}

Posted by rCan

2008/10/14 18:04 2008/10/14 18:04
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/579

[ATMEGA128] Key Scan Test중

#include<stdio.h>
#include<avr/interrupt.h>
#include<avr/signal.h>

#define CPU_CLOCK 16000000
#define TICKS_PER_SEC 1000
#define Prescaler 64
#define OVERFLOW 256

volatile int tic_time;
volatile unsigned char KEY_STATE;
volatile unsigned char CURRENT_KEY_STATE;
volatile unsigned char LAST_KEY_STATE;

void init_port(void);
void init_timer(void);
void init_timer0(void);
void init_timer1(void);
void init_timer3(void);

int main(void){
        CURRENT_KEY_STATE=0xFF;
        LAST_KEY_STATE=0xFF;

        init_port();
        init_timer();
        init_timer0();
        init_timer1();
        init_timer3();
        sei();

        while(1){
                CURRENT_KEY_STATE=PINA; // SW에 값을 CURRENT_KEY_STATE에 넣어줌
                if(CURRENT_KEY_STATE!=0xFF){
                // CURRENT_KEY_STATE가 0xFF가 아닌 경우(어느 키라도 눌렸을경우)
                        if(CURRENT_KEY_STATE!=LAST_KEY_STATE){
                        // 지금 누른키와 눌린키가 아닐 경우 (키가 변경된 경우)
                                tic_time=0;
                                KEY_STATE=0;
                        }
                        if(tic_time>=50){
                                // 키를 누르고 50ms가 지났으면 (계속 눌려잇는 경우)
                                if(KEY_STATE==0){
                                        KEY_STATE=1;
                                        if(CURRENT_KEY_STATE==0xFE) sbi(DDRB,5); // oc1a를 출력으로 설정
                                        if(CURRENT_KEY_STATE==0xFD) sbi(DDRE,3); // oc3a를 출력으로 설정
                                }
                        }
                }
                else KEY_STATE=0; // PINA가 0xFF인경우는 KEY_STATE를 0으로 초기화 시켜준다.
                LAST_KEY_STATE=CURRENT_KEY_STATE; // 현재 눌린키를 눌려진 키로 넣어줌
                if(tic_time>=1000){

                // 키를 누르지 않을 경우에 생기는 문제점을 해결하기 위해서
                // tic_time은 int형 변수이기에 넘어가게 되면 오버 플로우가 발생될가능성도 있다.
                // 그것뿐만 아니라 예를 들어 키보드 방향키 위를 생각해보면
                // 위를 한번 꾸우우우욱 누른경우랑
                // 위를 한번  꾹 누른 경우랑 같게 된다는것이다.
                        tic_time=0;
                        LAST_KEY_STATE=0xFF;
                }
               
        }
        return 0;
}

void init_port(void){
        DDRA=0x00;
}
void init_timer(void){
        // 타이머에 관한 전반적인 공통사항을 기술
        TIFR=0x00;
}
void init_timer0(void){
        // 타이머0에 대한 설정
        TCCR0=0x04;
        TCNT0=OVERFLOW - (CPU_CLOCK / TICKS_PER_SEC / Prescaler);
        TIMSK=0x01;
}
void init_timer1(void){
        // 타이머1에 대한 설정
        TCNT1H=0x00;
        TCNT1L=0x00;

        TCCR1A=0x40;
        TCCR1B=0x0C;
        TCCR1C=0x00;

        OCR1AH=0x7A;
        OCR1AL=0x12;
        TIMSK=TIMSK|(1<OCIE1A);
}
void init_timer3(void){
        // 타이머3에 대한 설정
        TCNT3H=0x00;
        TCNT3L=0x00;

        TCCR3A=0x40;
        TCCR3B=0x0C;
        TCCR3C=0x00;

        OCR3AH=0x18;
        OCR3AL=0x6A;
        TIMSK=ETIMSK|(1<OCIE3A);
}
SIGNAL(SIG_OVERFLOW0){
        // 오버 플로우 인터럽트 발생시 (timer0에서 발생되는..)
        tic_time++;
        TCNT0 = OVERFLOW - (CPU_CLOCK / TICKS_PER_SEC / Prescaler);
}
SIGNAL(SIG_OUTPUT_COMPARE1A){}
SIGNAL(SIG_OUTPUT_COMPARE3A){}

Posted by rCan

2008/10/08 16:51 2008/10/08 16:51
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/577

[ATMEGA128] 냐옹

// 256 분주 62500 데헷 'ㅅ';
//흐암 -_-;


#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/signal.h>

void init_port(void);
void init_timer1(void);

int main(void){

        init_port();
        init_timer1();
        sei();
        while(1){}
        return 0;
}
void init_port(void){
        DDRF=0xFF;
        PORTF=0xFF;
        sbi(DDRB,5);
}
void init_timer1(void){

        TIFR=0x00;
        TCNT1H=0x00;
        TCNT1L=0x00;

        TCCR1A=0x40;
        TCCR1B=0x0C;
        TCCR1C=0x00;

        OCR1AH=0xF4;
        OCR1AL=0x24;

        TIMSK=0x10;
}

SIGNAL(SIG_OUTPUT_COMPARE1A){
}

Posted by rCan

2008/10/07 17:40 2008/10/07 17:40
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/576

[WIPI] 게임 냐옹

import org.kwis.msp.lcdui.*;
import java.io.*;

public class MainCard extends Card implements Runnable{
 Thread mThread = new Thread(this);
 Display dis = Display.getDefaultDisplay();

 Graphics g;

 public final byte MAINSTATE_MENU = 0;
 public final byte MAINSTATE_GAME = 1;
 public final byte MENU_STARTGAME = 0;
 public final byte MENU_CONTINUEGAME = 1;
 public final byte MENU_EXPGAME = 2;
 public final byte MENU_OPTION = 3;
 public final byte MENU_EXIT = 4;
 public final byte MENU_NUM = 5;
 public final byte LEFT = 0;
 public final byte RIGHT = 1;
 private final byte GROUND_HEIGHT = 20;
 private final byte HERO_WIDTH = 21;
 private final byte HERO_HEIGHT = 26;
 private final byte HERO_SPEED=3;
 private final byte HERO_JUMP_FRAME=6;
 private final byte HERO_JUMP_PIXEL=5;
 
 
 int width, height;
 byte mainState;
 int menuCursor;

 private int heroX;
 private int heroY;
 private int heroDirection;
 private int heroSpeed;
 private int heroFrame;
 private boolean bHeroJump;

 Image imgHero[] = new Image[6];

 public final String MENU_TEXT[] = {"게임시작","이어하기","게임설명","환경설정","게임종료"};

 public MainCard(){  
  width = getWidth();
  height = getHeight();
 
  System.out.println("width->"+width+" height->"+height);
 
  setMainState(MAINSTATE_MENU);
 
  mThread.start();  
 }
 public void run(){
  while(true){
   repaint();
   try{Thread.sleep(100);}catch (InterruptedException ex){}
  }
 }
 public void paint(Graphics g){
  this.g = g;
  switch(mainState){
   case MAINSTATE_MENU:
    showMenu();    
    break;
   case MAINSTATE_GAME:
    showGame();
    break;
  }
 }

 public void showMenu(){
  String text;

  g.setColor(255, 255, 255);
  g.fillRect(0, 0, width, height);
  g.setColor(0, 0, 0);
  for(int i=0; i<MENU_NUM; i++){
   if(i==menuCursor) text = "-> "+MENU_TEXT[i];
   else text = MENU_TEXT[i];
   g.drawString(text, width/2, 20+14*i, Graphics.HCENTER|Graphics.TOP);
  }
 }

 public void showGame(){
  g.setColor(0, 0, 0);
  g.fillRect(0, 0, width, height);
  g.setColor(255, 255, 255);
  g.fillRect(0, height-GROUND_HEIGHT, width, GROUND_HEIGHT);

  drawHero();
  gameUpdate();
 }

 private void gameUpdate() {
  // TODO Auto-generated method stub
  heroUpdate();
 }
 private void heroUpdate() {
  // TODO Auto-generated method stub
  heroX+=heroSpeed;
  if(bHeroJump){
   if(heroFrame!=0 && heroY==height-GROUND_HEIGHT-HERO_HEIGHT/2)
    bHeroJump=false;
   else if(heroFrame<HERO_JUMP_FRAME) heroY-=HERO_JUMP_PIXEL;
   else if(heroFrame>HERO_JUMP_FRAME) heroY+=HERO_JUMP_PIXEL;
  }
  if(heroSpeed!=0||bHeroJump) heroFrame++;
 }
 public void drawHero(){  
//  g.drawImage(imgHero, heroX-HERO_WIDTH/2, heroY-HERO_HEIGHT/2, 0);
  if(bHeroJump)
   g.drawImage(imgHero[3*heroDirection+2], heroX-HERO_WIDTH/2, heroY-HERO_HEIGHT/2, 0);
  else g.drawImage(imgHero[3*heroDirection+(heroFrame/3)&2], heroX-HERO_WIDTH/2, heroY-HERO_HEIGHT/2, 0);
 }

 public boolean keyNotify(int type, int key){
  if(type == EventQueue.KEY_PRESSED){
   switch(mainState){
    case MAINSTATE_MENU:
     keyMenu(key);    
     break;
    case MAINSTATE_GAME:
     keyGame(key);
     break;
   }
  }
  repaint();
  return true;
 }

 public int getGameAction(int key){
  if((key >= EventQueue.KEY_NUM0 && key < EventQueue.KEY_NUM9) || key == EventQueue.KEY_POUND || key == EventQueue.KEY_STAR)
   return key;
  else
   return Display.getGameAction(key);
//   return dis.getGameAction(key);
 }

 public void keyMenu(int key){
  switch(getGameAction(key)){
   case EventQueue.UP:
   case EventQueue.LEFT:
    menuCursor--;
    if(menuCursor < 0)
     menuCursor = MENU_NUM-1;
    break;

   case EventQueue.DOWN:
   case EventQueue.RIGHT:
    menuCursor++;
    if(menuCursor == MENU_NUM)
     menuCursor = 0;
    break;

   case EventQueue.FIRE:
    switch(menuCursor){
     case MENU_STARTGAME:
      setMainState(MAINSTATE_GAME);
      loadGame();
      break;
     case MENU_CONTINUEGAME:
      break;
     case MENU_EXPGAME:
      break;
     case MENU_OPTION:
      break;
     case MENU_EXIT:
      break;
    }
    break;
  }
 }

 public void keyGame(int key){
  switch(getGameAction(key)){
   case EventQueue.UP:
   case EventQueue.FIRE:
    if(bHeroJump) break;
    bHeroJump=true;
    heroFrame=0;
    break;
   case EventQueue.DOWN:
    break;
   case EventQueue.LEFT:
    if(bHeroJump) break;
    if(heroDirection!=LEFT) heroSpeed=0;
    else if(heroSpeed>HERO_SPEED*(-2)) heroSpeed-=HERO_SPEED;
    heroDirection=LEFT;
    break;
   case EventQueue.RIGHT:
    if(bHeroJump) break;
    if(heroDirection!=RIGHT) heroSpeed=0;
    else if(heroSpeed < HERO_SPEED*(2)) heroSpeed+=HERO_SPEED;
    heroDirection=RIGHT;
    break;
  }
 }

 public void setMainState(byte state){
  mainState = state;
  switch(mainState){
   case MAINSTATE_MENU:    
    initMenu();    
    break;
   case MAINSTATE_GAME:
    initGame();
    break;
  }
 }

 public void loadGame(){
  try {
   for(int i=0;i<6;i++) imgHero[i] = Image.createImage("img/hero"+(i+1)+".png");  
  }catch(IOException e){}
 }
 public void unloadGame(){
  for(int i=0;i<6;i++) imgHero[i] = null;
  System.gc();
 }

 public void initMenu(){
  menuCursor = 0;  
 }

 public void initGame(){
  heroX = width/2;
  heroY = height - GROUND_HEIGHT - HERO_HEIGHT/2;
  heroDirection = RIGHT;
  heroSpeed = 0;
  heroFrame = 0;
  bHeroJump=false;
 }
}

Posted by rCan

2008/10/07 17:40 2008/10/07 17:40
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/575

[ATMEGA128] 흐음

/*
타이머2에서 클럭이 들어와서 인터럽트 발생시에.
타이머0에서 300ms마다 불이
*/

#include<avr/io.h>
#include<avr/interrupt.h>
#include<avr/signal.h>

void init_port(void);
void init_timer0(void);
void init_timer2(void);

volatile unsigned int tic_time;
volatile unsigned int STATE_FLAG;
volatile unsigned int cnt;

SIGNAL(SIG_OVERFLOW2){
        STATE_FLAG=1;
}
SIGNAL(SIG_OUTPUT_COMPARE0){
        tic_time++;
}


int main(void){

        init_port();
        init_timer0();
        init_timer2();

        sei();
        for(;;){
                if(STATE_FLAG==1){
                        if(tic_time>=300){
                                tic_time=0;
                                if(cnt>8) cnt=0;
                                PORTF=~(0xFF&(1<<cnt));
                                cnt++;
                        }
                }
        }
        return 0;
}

void init_port(){
        DDRF=0xFF;
        PORTF=0xFF;
        cbi(DDRD,7);
}
void init_timer0(){
        TIFR=0x00;
        TCCR0=0x0C;  // 00001100
        TCNT0=0;
        OCR0=249;
}
void init_timer2(){
        TIFR=0x00;
        TCCR2=0x06;
        TCNT2=253;
        TIMSK=0x42;
}

Posted by rCan

2008/10/01 17:13 2008/10/01 17:13
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/573

[WIPI]0929 - 소스






Project1.java

import org.kwis.msp.handset.BackLight;
import org.kwis.msp.lcdui.*;

public class Project1 extends Jlet {
 
 MainCard mc = new MainCard(); // MainCard 의 객채생성 >> mc
 

 protected void destroyApp(boolean arg0) throws JletStateChangeException {
  // TODO Auto-generated method stub

 }

 protected void startApp(String[] arg0) {
  // TODO Auto-generated method stub
  BackLight.alwaysOn(); // BackLight 항상 켬
  Display dis=Display.getDefaultDisplay(); // Display객체로부터 기본 display가저와서 dis 만듬
  dis.pushCard(mc); // mc를 디스플레이 시킴
  }

}




MainCard.java

import org.kwis.msp.lcdui.*;
import java.io.*;

public class MainCard extends Card implements Runnable
{
 Thread mThread = new Thread(this);
 Display dis = Display.getDefaultDisplay();

 Graphics g;

 public final byte MAINSTATE_MENU = 0;
 public final byte MAINSTATE_GAME = 1;
 public final byte MENU_STARTGAME = 0;
 public final byte MENU_CONTINUEGAME = 1;
 public final byte MENU_EXPGAME = 2;
 public final byte MENU_OPTION = 3;
 public final byte MENU_EXIT = 4;
 public final byte MENU_NUM = 5;
 public final byte LEFT = 0;
 public final byte RIGHT = 1;
 private final byte GROUND_HEIGHT = 20;
 private final byte HERO_WIDTH = 21;
 private final byte HERO_HEIGHT = 26;

 int width, height;
 byte mainState;
 int menuCursor;

 private int heroX;
 private int heroY;
 private int heroDirection;
 private int heroSpeed;
 private int heroFrame;

 Image imgHero;

 public final String MENU_TEXT[] = {
  "게임시작",
  "이어하기",
  "게임설명",
  "환경설정",
  "게임종료"
 };

 public MainCard()
 {
  width = getWidth();
  height = getHeight();
  System.out.println("width->"+width+" height->"+height);

  setMainState(MAINSTATE_MENU);
 
  mThread.start();
 }
 public void run()
 {
  while(true)
  {
   repaint();
   try{
    Thread.sleep(100);
   }
   catch (InterruptedException ex){}
  }
 }
 public void paint(Graphics g){
  this.g = g;
  switch(mainState)
  {
   case MAINSTATE_MENU:
    showMenu();    
    break;
   case MAINSTATE_GAME:
    showGame();
    break;
  }
 }

 public void showMenu()
 {
  String text;

  g.setColor(255, 255, 255);
  g.fillRect(0, 0, width, height);
  g.setColor(0, 0, 0);
  for(int i=0; i<MENU_NUM; i++)
  {
   if(i==menuCursor)
    text = "-> "+MENU_TEXT[i];
   else
    text = MENU_TEXT[i];
   g.drawString(text, width/2, 20+14*i, Graphics.HCENTER|Graphics.TOP);
  }
 }

 public void showGame()
 {
  g.setColor(0, 0, 0);
  g.fillRect(0, 0, width, height);
  g.setColor(255, 255, 255);
  g.fillRect(0, height-GROUND_HEIGHT, width, GROUND_HEIGHT);

  drawHero();
 }

 public void drawHero()
 {
  g.drawImage(imgHero, heroX-HERO_WIDTH/2, heroY-HERO_HEIGHT/2, 0);
 }

 public boolean keyNotify(int type, int key){
  if(type == EventQueue.KEY_PRESSED){
   switch(mainState)
   {
    case MAINSTATE_MENU:
     keyMenu(key);    
     break;
    case MAINSTATE_GAME:
     keyGame(key);
     break;
   }
  }
  repaint();
  return true;
 }

 public int getGameAction(int key)
 {
  if((key >= EventQueue.KEY_NUM0 && key < EventQueue.KEY_NUM9) || key == EventQueue.KEY_POUND || key == EventQueue.KEY_STAR)
   return key;
  else
   return dis.getGameAction(key);
 }

 public void keyMenu(int key)
 {
  switch(getGameAction(key))
  {
   case EventQueue.UP:
   case EventQueue.LEFT:
    menuCursor--;
    if(menuCursor < 0)
     menuCursor = MENU_NUM-1;
    break;

   case EventQueue.DOWN:
   case EventQueue.RIGHT:
    menuCursor++;
    if(menuCursor == MENU_NUM)
     menuCursor = 0;
    break;

   case EventQueue.FIRE:
    switch(menuCursor)
    {
     case MENU_STARTGAME:
      setMainState(MAINSTATE_GAME);
      loadGame();
      break;
     case MENU_CONTINUEGAME:
      break;
     case MENU_EXPGAME:
      break;
     case MENU_OPTION:
      break;
     case MENU_EXIT:
      break;
    }
    break;
  }
 }

 public void keyGame(int key)
 {
  switch(getGameAction(key))
  {
   case EventQueue.UP:
   case EventQueue.FIRE:
    break;
   case EventQueue.DOWN:
    break;
   case EventQueue.LEFT:
    break;
   case EventQueue.RIGHT:
    break;
  }
 }

 public void setMainState(byte state)
 {
  mainState = state;
  switch(mainState)
  {
   case MAINSTATE_MENU:    
    initMenu();    
    break;
   case MAINSTATE_GAME:
    initGame();
    break;
  }
 }

 public void loadGame()
 {
  try
  {
   imgHero = Image.createImage("/img/hero1.png");
  }
  catch(IOException e)
  {}
 }
 public void unloadGame()
 {
  imgHero = null;
  System.gc();
 }

 public void initMenu()
 {
  menuCursor = 0;
 }

 public void initGame()
 {
  heroX = width/2;
  heroY = height - GROUND_HEIGHT - HERO_HEIGHT/2;
  heroDirection = RIGHT;
  heroSpeed = 0;
  heroFrame = 0;
 }
};

Posted by rCan

2008/09/29 11:40 2008/09/29 11:40
Response
No Trackback , No Comment
RSS :
http://rcan.net/rss/response/572


블로그 이미지

- rCan

Calendar

«   2012/02   »
      1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29      

Notices

  1. About Me

Site Stats

Total hits:
113574
Today:
5
Yesterday:
43