コード例 #1
0
ファイル: tetris.c プロジェクト: KungFuJesus/ntetris
STATE* Init(int argc, char* argv[])
{
    STATE* state;

    state = (STATE*)malloc(sizeof(STATE));
    if (!state)
        return NULL;

    memset(state, 0, sizeof(STATE));
    srand(time(0));

    state->Bx = 10;
    state->By = 20;
    state->queue = g_queue_new();
    state->fieldwin = NULL;
    state->queue_size = 5;
    state->init_speed = INIT_SPEED;
    state->delta = DELTA_SPEED;

    state->init_level = 1;
    state->line_clear_timeout = 0;

    state->do_clear = CLEAR_FLASH;
    state->do_rotate_timeout_reset = 0;
    state->do_dissolve = 1;
    state->do_pause_blocks = 0;

    // setup the default keymap
    state->keymap[TETRIS_KEY_QUIT]              = KeyParse("q");
    state->keymap[TETRIS_KEY_DROP]              = KeyParse("d");
    state->keymap[TETRIS_KEY_LOWER]             = KeyParse("s");
    state->keymap[TETRIS_KEY_ROTATE_CW]         = KeyParse("k");
    state->keymap[TETRIS_KEY_ROTATE_CCW]        = KeyParse("e");
    state->keymap[TETRIS_KEY_MOVE_LEFT]         = KeyParse("j");
    state->keymap[TETRIS_KEY_MOVE_RIGHT]        = KeyParse("l");
    state->keymap[TETRIS_KEY_PAUSE]             = KeyParse("p");
    state->keymap[TETRIS_KEY_RESET]             = KeyParse("r");

    if (! ParseOptions(state, argc, argv)) {
        Cleanup(state);
        return NULL;
    }

    // allocate the field data
    state->field = (char*)malloc(state->Bx * state->By);
    // game instance specific initiailzation
    Reset(state);
    // initialize the curses session
    InitTerminal(state);
    // orient the windows
    DimensionWindows(state);

    // TODO: we need to catch SIGWINCH,
    //       to be able to resize accordingly.
    // signal(SIGWINCH, SignalHandler);

    return state;
}
コード例 #2
0
ファイル: main.c プロジェクト: glocklueng/stm8-oscilloscope
void main(void)
{
    u16 trigpos;
    u8 keycode;
    
    SystemState = AutoRunMode;
    // 现在还是使用软件触发
	  ADCState = Triggered;       // ADCState = WaitTrigger;

    CLK_Init();                 // 主时钟初始化
    TIM4_Init();                // TIM4 用于产生系统运行需要的定时信号
    KEY_Init();                 // 按键驱动初始化
    KeyParse_Init();            // 按键处理模块初始化
    LCD_Init();                 // LCD驱动初始化
    WDraw_Init();               // 波形显示模块初始化
    TriggerInterruptInit();     // 外部触发中断初始化
    ADC_Init();                 // ADC采样程控模块初始化
    DProc_Init();               // 数据处理模块初始化
  

    enableInterrupts();

    /* Infinite loop */
    while (1)
    {
    
				if(flag_10ms_ok)
        {
            flag_10ms_ok = 0;
            keycode = KEY_Scan();
						switch(GET_KTYPE(keycode))
            {
                case KTYPE_NORMAL:
                    KeyParse(GET_KCODE(keycode));
                default:
                    break;
            }
        }
        switch(SystemState)
        {
            // to do
            case AutoRunMode:
            case ManualMode:
                //  处理数据
                if( ADCState == ADC_Buffer_Full )
                {
                    trigpos = GetTriggerPostion(0, 64);
                    WDraw_DisplayUpdate(&ADC_Buffer[trigpos]);
                    ADCState = Triggered;
                    ADC_Index = 0;
                }
                break;
            default:
                break;
        }
		
		}
  
}
コード例 #3
0
ファイル: tetris.c プロジェクト: KungFuJesus/ntetris
int ParseOptions(STATE *state, int argc, char *argv[])
{
    int go_ret, width, height, delay, level;
    const char *err_str;
    char *next_key = NULL;
    char *next_key_val = NULL;

    static struct option longopts[] = {
         { "clear",      required_argument,  NULL, 'c' },
         { "level",      required_argument,  NULL, 'L' },
         { "width",      required_argument,  NULL, 'x' },
         { "height",     required_argument,  NULL, 'y' },
         { "delay",      required_argument,  NULL, 'd' },
         { "pause-show", no_argument,        NULL, 'p' },
         { "keys",       required_argument,  NULL, 'k' },
         { NULL,         0,                  NULL, 0 }
    };


    while ((go_ret = getopt_long(argc, argv, "c:L:x:y:d:k:p", longopts, NULL)) != -1) {
        switch (go_ret) {
            case 'c':
                if (! strcmp(optarg, "none")) {
                    state->do_clear = CLEAR_NONE;
                } else if (! strcmp(optarg, "flash")) {
                    state->do_clear = CLEAR_FLASH;
                } else if (! strcmp(optarg, "blank")) {
                    state->do_clear = CLEAR_BLANK;
                } else {
                    fprintf(stderr, "<ntetris>\tInvalid line clear mode: \"%s\"\n",
                            optarg);
                    return 0;
                }
                break;
            case 'L':
                fprintf(stderr,"%s\n", optarg);
                level = strtonum(optarg, 1, 1000, &err_str);
                if (err_str) {
                    fprintf(stderr, "error parsing level field: %s\n", err_str);
                    return 0;
                }

                state->init_level = level;
                break;
            case 'x':
                /* Let's use the bsd safe strtonum functions for this */
                width = strtonum(optarg, 10, 1000, &err_str);
                if (err_str) {
                    fprintf(stderr, "error parsing width field: %s\n", err_str);
                    return 0;
                }

                state->Bx = width;
                break;
            case 'y':
                height = strtonum(optarg, 10, 1000, &err_str);
                if (err_str) {
                    fprintf(stderr, "error parsing height field: %s\n", err_str);
                    return 0;
                }

                state->By = height;
                break;
            case 'd':
                delay = strtonum(optarg, 0, 10, &err_str);
                if (err_str) {
                    fprintf(stderr, "error parsing delay field: %s\n", err_str);
                    return 0;
                }

                state->line_clear_timeout = delay;
                break;
            case 'p':
                state->do_pause_blocks = !state->do_pause_blocks;
                break;
            case 'k':
                    while ((next_key = strsep(&optarg, " ")) != NULL) {

                        size_t A;
                        next_key_val = strsep(&optarg, " ");

                        for (A = 0; A < TETRIS_KEYS; A++) {
                            if (! strcmp(keymap_desc[A], next_key)) {
                                state->keymap[A] = KeyParse(next_key_val);
                                break;
                            }
                        }

                        if (A >= TETRIS_KEYS) {
                            fprintf(stderr, "<ntetris>\tAction not supported: \"%s\".\n",
                                    next_key);
                            return 0;
                        }
                }
                break;
            default:
                return 0;
                break;
        }

    }

    return 1;

}