Esempio n. 1
0
void display(void)
{
		
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	
	if(full_screen)glutFullScreen();
	else{
		if(f_s_off){
			glutReshapeWindow(900,600);
			glutPositionWindow(100,100);
			f_s_off=FALSE;
		}
	}

	if(menu_id==0)DrawMenu(0,0,menuArray[0],true);
	else if(menu_id==1)DrawMenu(0,0,menuArray[1],true);
	else if(menu_id==2)DrawMenu(0,0,menuArray[2],true);
	else if(menu_id==3)DrawMenu(0,0,menuArray[3],true);
	else if(menu_id==4)DrawMenu(0,0,menuArray[4],true);
	else {
		Render_Gioco();
	}

	glutSwapBuffers();
    
}
Esempio n. 2
0
void OperMenu(T_E_Sel *Mnu){
int Y;
	if ((MX>=Mnu->X)&&(MX<Mnu->X+20)){
		Y=MY/20;
		if ((!MBlock)&&(MB)&&(Y==0)&&(Mnu->Top)) {Mnu->Top--;DrawMenu(*Mnu);MBlock=1;}
		if ((!MBlock)&&(MB)&&(Y==19)&&(Mnu->Top<Mnu->L-1)) {Mnu->Top++;DrawMenu(*Mnu);MBlock=1;}
		if ((Y>0)&&(Y<19)&&(Mnu->Top+Y-1<Mnu->L)){
			if ((!MBlock)&&(MB)){Mnu->Akt=Mnu->Top+Y-1;DrawMenu(*Mnu);MBlock=1;}
			else DrawMsg(Mnu->E[Mnu->Top+Y-1].Desc);
		}
	}
}
Esempio n. 3
0
void StageLose(void)
{
    clear();
    DrawMenu();
    ClearWindows();
    attron(COLOR_PAIR(11));
    mvprintw(21,28,"                                                   __ ");
    mvprintw(22,28,"                                                  |  |");
    mvprintw(23,28," _____ _                  _____     _ _       _   |  |");
    mvprintw(24,28,"|   __| |_ ___ ___ ___   |   __|___|_| |___ _| |  |__|");
    mvprintw(25,28,"|__   |  _| .'| . | -_|  |   __| .'| | | -_| . |   __ ");
    mvprintw(26,28,"|_____|_| |__,|_  |___|  |__|  |__,|_|_|___|___|  |__|");
    mvprintw(27,28,"              |___|                                   ");
    attroff(COLOR_PAIR(11));
    refresh();

    LoadStage('l');
    
    attron(A_BOLD);
    mvprintw(32,54,"Done!");
    attroff(A_BOLD);
    refresh();
    usleep(500000);

    ClearMap();
    curs_set(1);
}
Esempio n. 4
0
static void MenuModeHandler(unsigned char Option)
{
  PageType = PAGE_TYPE_MENU;

  if (Option) CurrentPage[PageType] = (eIdleModePage)Option;  
  DrawMenu(CurrentPage[PageType]);
}
Esempio n. 5
0
u32
GetButtonMap(u16 ctrlr_type, char* btn_name)
{
	u32 pressed, previous;
	char temp[50] = "";
	uint k;
	pressed = 0; previous = 1;

	switch (ctrlr_type) {
		case CTRLR_NUNCHUK:
			strncpy (cfg_text[3], (char*)"NUNCHUK", 7);
			break;
		case CTRLR_CLASSIC:
			strncpy (cfg_text[3], (char*)"CLASSIC", 7);
			break;
		case CTRLR_GCPAD:
			strncpy (cfg_text[3], (char*)"GC PAD", 7);
			break;
		case CTRLR_WIIMOTE:
			strncpy (cfg_text[3], (char*)"WIIMOTE", 7);
			break;
	};

	/*** note which button we are remapping ***/
	sprintf (temp, (char*)"Remapping ");
	for (k=0; k<9-strlen(btn_name); k++) strcat(temp, " "); // add whitespace padding to align text
	strncat (temp, btn_name, 9);		// snes button we are remapping
	strncpy (cfg_text[0], temp, 19);	// copy this all back to the text we wish to display

	DrawMenu(&cfg_text[0], NULL, cfg_text_count, 1);	// display text

	pressed = GetInput(ctrlr_type);
	return pressed;
}	// end getButtonMap()
Esempio n. 6
0
static int DrawMenu(int menu, int x, int *y)
{
   int i;
   int ret = 1;

   for(i=0; i < Menus[menu].NumItems; i++) {
      char *s = Menus[menu].Items[i].name;
      int a = 0;
      if(MouseY >= *y && MouseY < *y + MENU_FONT_HEIGHT &&
	 MouseX >= x && MouseX < x + Menus[menu].width) {
	 a = 1;
	 SelectedMenu = menu;
	 ret = 0;
	 Menus[menu].selected = i;
	 glColor3f(1,0,0);
      } else
	 glColor3f(1,1,1);

      *y += MENU_FONT_HEIGHT;
      glRasterPos2i(x, *y);
      for(; *s; s++)
	 glutBitmapCharacter(MENU_FONT, *s);

      if(Menus[menu].selected == i)
	 if(Menus[menu].Items[i].submenu) 
	    if(DrawMenu(Menus[menu].Items[i].submenu, x 
			+ SUBMENU_OFFSET, y)) {
	       if(!a)
		  Menus[menu].selected = -1;
	    } else
	       ret = 0;
   }
   return ret;
}
Esempio n. 7
0
u32
GetButtonMap(u16 ctrlr_type, char* btn_name)
{
	u32 pressed, previous;
	char title[20];
	pressed = 0; previous = 1;
	
	switch (ctrlr_type) {
		case CTRLR_NUNCHUK:
			strncpy (cfg_text[3], (char*)"NUNCHUK", 7);
			break;
		case CTRLR_CLASSIC:
			strncpy (cfg_text[3], (char*)"CLASSIC", 7);
			break;
		case CTRLR_GCPAD:
			strncpy (cfg_text[3], (char*)"GC PAD", 7);
			break;
		case CTRLR_WIIMOTE:
			strncpy (cfg_text[3], (char*)"WIIMOTE", 7);
			break;
	}; 
	
	sprintf (cfg_text[0], "Remapping %s", btn_name);	// note which button we are remapping
	
	DrawMenu(&cfg_text[0], title, cfg_text_count, 1);	// display text
	
//	while (previous != pressed && pressed == 0);	// get two consecutive button presses (which are the same)
//	{
//		previous = pressed;
//		VIDEO_WaitVSync();	// slow things down a bit so we don't overread the pads
		pressed = GetInput(ctrlr_type);
//	}
	return pressed;
}	// end getButtonMap()
Esempio n. 8
0
void StageWin(void)
{
    clear();
    DrawMenu();
    ClearWindows();

    attron(COLOR_PAIR(8));
    mvprintw(17,25, "                                                         __ ");
    mvprintw(18,25, "                                                        |  |");
    mvprintw(19,25, " _____ _                  _____ _                   _   |  |");
    mvprintw(20,25, "|   __| |_ ___ ___ ___   |     | |___ ___ ___ ___ _| |  |__|");
    mvprintw(21,25, "|__   |  _| .'| . | -_|  |   --| | -_| .'|  _| -_| . |   __ ");
    mvprintw(22,25, "|_____|_| |__,|_  |___|  |_____|_|___|__,|_| |___|___|  |__|");
    mvprintw(23,25, "              |___|                                         ");
    attroff(COLOR_PAIR(8));
    
    refresh();

    LoadStage('w');
    
    attron(A_BOLD);
    mvprintw(32,54,"Done!");
    attroff(A_BOLD);
    refresh();
    usleep(750000);
    
    // ClearMap();
    curs_set(1);
}
Esempio n. 9
0
int main (void)
{

    StartCurses();
    DrawMenu();

    Level lvl;
    TowerList tList;            // Tower List
    UnitList uList;             // Unit List
    UnitList sQueue;            // Spawn queue
    PathList pList;             // Path list
    UnitList PDUL;

    // Initializing variables
    TowerInitialize(&tList);
    UnitInitialize(&uList);
    UnitInitialize(&sQueue);
    UnitInitialize(&PDUL);
    PathInitialize(&pList);
    ReadStandardUnits(&PDUL);

    ReadFile(1, &tList, &pList, &lvl);

    DrawAvailableUnits(&lvl,&PDUL);
    refresh();
    DrawMap(&tList,&pList);
    PrintArrows(&pList);
    PrintUnitSelection();
    ClearMap();
    LeaderBoard();
    getchar();

    EndCurses();
}
Esempio n. 10
0
//メニュー画面を表示
void MainMenu(){
	//4つの項目をどれも開いていなかったら
	if(MapMenu[1].Flag != 1 && MapMenu[2].Flag != 1 && MapMenu[3].Flag != 1 && MapMenu[4].Flag != 1){
		// メニュー項目を描画
		DrawGraph( MapMenu[0].x, MapMenu[0].y, MapMenu[0].Graph, TRUE );
		MapMenu[ DrawMenu( 4, 1, KEY_INPUT_Z, MenuElement2 ) + 1 ].Flag=1;
	}
}
Esempio n. 11
0
bool GDisplayMenu::DrawTestResultMenu()
{
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_L1] = "";
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_L2] = "";
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_L3] = "";
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_L4] = std::string(" Previous\n Menu");

	char arycBuffer[64];
	GDisplayServiceStatistics & oStats = GDisplayService::GetService()->GetStatistics();

	UINT8  u8PassCont1, u8PassCont2, u8PassCont3, u8PassCont4, u8PassCont5 = 0;
	UINT8  u8FailCont1, u8FailCont2, u8FailCont3, u8FailCont4, u8FailCont5 = 0;
	UINT16 u16TotalTest = GDisplayService::GetService()->GetStatistics().GetTotalTests();

	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_1] = "The result of display test was:";

	u8PassCont1= oStats.GetStatistics(GDisplayServiceStatistics::ePass, GDisplayServiceStatistics::eTest1_White_Color);
	u8FailCont1= oStats.GetStatistics(GDisplayServiceStatistics::eFail, GDisplayServiceStatistics::eTest1_White_Color);
	snprintf(arycBuffer, sizeof(arycBuffer), "White color: PASS [%d] FAIL [%d].", u8PassCont1, u8FailCont1 );
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_2] = arycBuffer;

	u8PassCont2= oStats.GetStatistics(GDisplayServiceStatistics::ePass, GDisplayServiceStatistics::eTest2_Black_Color);
	u8FailCont2= oStats.GetStatistics(GDisplayServiceStatistics::eFail, GDisplayServiceStatistics::eTest2_Black_Color);
	snprintf(arycBuffer, sizeof(arycBuffer), "Black color: PASS [%d] FAIL [%d].", u8PassCont2, u8FailCont2 );
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_3] = arycBuffer;

	u8PassCont3= oStats.GetStatistics(GDisplayServiceStatistics::ePass, GDisplayServiceStatistics::eTest3_Red_Color);
	u8FailCont3= oStats.GetStatistics(GDisplayServiceStatistics::eFail, GDisplayServiceStatistics::eTest3_Red_Color);
	snprintf(arycBuffer, sizeof(arycBuffer), "Red color: PASS [%d] FAIL [%d].", u8PassCont3, u8FailCont3 );
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_4] = arycBuffer;

	u8PassCont4= oStats.GetStatistics(GDisplayServiceStatistics::ePass, GDisplayServiceStatistics::eTest4_Green_Color);
	u8FailCont4= oStats.GetStatistics(GDisplayServiceStatistics::eFail, GDisplayServiceStatistics::eTest4_Green_Color);
	snprintf(arycBuffer, sizeof(arycBuffer), "Green color: PASS [%d] FAIL [%d].", u8PassCont4, u8FailCont4 );
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_5] = arycBuffer;

	u8PassCont5= oStats.GetStatistics(GDisplayServiceStatistics::ePass, GDisplayServiceStatistics::eTest5_Blue_Color);
	u8FailCont5= oStats.GetStatistics(GDisplayServiceStatistics::eFail, GDisplayServiceStatistics::eTest5_Blue_Color);
	snprintf(arycBuffer, sizeof(arycBuffer), "Blue color: PASS [%d] FAIL [%d].", u8PassCont5, u8FailCont5 );
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_6] = arycBuffer;

	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_7] = "Summary:";

	snprintf(arycBuffer, sizeof(arycBuffer), "PASS [%d] - FAIL [%d] - TOTAL [%d]",
											 (u8PassCont1+u8PassCont2+u8PassCont3+u8PassCont4+u8PassCont5),
											 (u8FailCont1+u8FailCont2+u8FailCont3+u8FailCont4+u8FailCont5),
											 u16TotalTest );
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_8] = arycBuffer;

	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSEGMENT_9] = "";

	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_R1] = "";
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_R2] = "";
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_R3] = "";
	m_MenuLabelsMap[GSoftKeysWindowTemplate::eSOFT_R4] = "";

	return DrawMenu();
}
Esempio n. 12
0
void
MenuView::DrawMenu()
{
	menu_item = 0;

	if (menu) {
		int  mx = right_start.x - 2;
		int  my = right_start.y - 2;

		DrawMenu(mx, my, menu);
	}
}
Esempio n. 13
0
void C4Viewport::DrawOverlay(C4TargetFacet &cgo, const ZoomData &GameZoom)
{
	if (!Game.C4S.Head.Film || !Game.C4S.Head.Replay)
	{
		// Player info
		C4ST_STARTNEW(PInfoStat, "C4Viewport::DrawOverlay: Player Info")
		DrawPlayerInfo(cgo);
		C4ST_STOP(PInfoStat)
		C4ST_STARTNEW(MenuStat, "C4Viewport::DrawOverlay: Menu")
		DrawMenu(cgo);
		C4ST_STOP(MenuStat)
	}
Esempio n. 14
0
/****************************************************************************
 * domenu
 *
 * Returns index into menu array when A is pressed, -1 for B
 ****************************************************************************/
int DoMenu (char items[][20], int maxitems)
{
  int redraw = 1;
  int quit = 0;
  short p;
  int ret = 0;

  while (quit == 0)
  {
    if (redraw)
    {
      DrawMenu (&items[0], maxitems, menu);
      redraw = 0;
    }

    p = getMenuButtons ();

    if (p & PAD_BUTTON_UP)
    {
      redraw = 1;
      menu--;
      if (menu < 0) menu = maxitems - 1;
    }

    if (p & PAD_BUTTON_DOWN)
    {
      redraw = 1;
      menu++;
      if (menu == maxitems) menu = 0;
    }

    if ((p & PAD_BUTTON_A) || (p & PAD_BUTTON_RIGHT))
    {
      quit = 1;
      ret = menu;
    }

    if (p & PAD_BUTTON_LEFT)
    {
      quit = 1;
      ret = 0 - 2 - menu;
    }

    if (p & PAD_BUTTON_B)
    {
      quit = 1;
      ret = -1;
    }
  }

  return ret;
}
Esempio n. 15
0
int StartMenu(){
	//DrawGraph(240,40,MenuBackGround,TRUE);
	DrawFormatString( 320, 240, GetColor( 255, 255, 255 ), "ver4.00");
	if(syori==1)syori=help();
		else {
			for(int i=0;i<5; i++)DrawBox( MenuElement[i].x, MenuElement[i].y, MenuElement[i].x+18, MenuElement[i].y+18, GetColor( 255, 0, 0 ), FALSE) ;
			switch( DrawMenu( 5, 1, KEY_INPUT_Z, MenuElement ) ){
		case 0:return 2;	// ゲームスタート
		case 2:syori=help();break;
		case 4:return 5; // ゲーム終了
		}
	}
	return 1;
}
Esempio n. 16
0
void MenuState::Enter(Ndk::StateMachine& /*fsm*/)
{
	m_text.SetVisible(true);
	DrawMenu();

	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [this] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
	{
		if (key.code >= Nz::Keyboard::Key::A && key.code < (Nz::Keyboard::Key::A + static_cast<int>(EventStatus::Max) - 1))
		{
			m_selectedNextState = key.code - static_cast<int>(Nz::Keyboard::Key::A);
		}
	});
}
Esempio n. 17
0
int Battle( Character_t *Character, int EnemyType){	
	DrawGraph(0,0,BackGround,TRUE);
	MessageFrame();
	DrawFormatString( 60, 140, GetColor(255, 255, 255), " LV:%d ",Character->LEVEL) ;

	DrawGauge( 15, 16, Character->MaxHP, Character->HP, GetColor( 0, 255, 0 ), GetColor(0, 255/2, 0),TRUE);
	DrawGauge( 15, 31, Character->MaxMP, Character->MP, GetColor( 255, 255, 0 ),GetColor( 255/2, 255/2, 0 ),TRUE );

	DrawGraph(Enemy[EnemyType].X, Enemy[EnemyType].Y, Enemy[EnemyType].Graph, TRUE);
	// 現れたとこ
	if(move==0){if(DrawBattleMessage( 0, 2, BattleMenuString, 0, EnemyType, TRUE) == 1 )move=1;}


	// 選択
	if(move==1)switch( DrawMenu( 2, 2, KEY_INPUT_Z, BattleMenu) ){
	// 速度判定
	case 0:backmenu=0;if( Character->Speed >= Enemy[EnemyType].Speed ){
		Damage=DamageCalc2( *Character, &Enemy[EnemyType]);move=3;
		   }else {
			   Damage=DamageCalc2( Enemy[EnemyType], Character);move=5;
		   }break;
	case 1:break;
	case 2:move=2;break;
	case 3:break;
	}

	//逃げ出す勇者の処理
	if(move==2)if( DrawBattleMessage( 2, 3, BattleMenuString, 0, EnemyType,FALSE) == 1 ){move=0;Enemy[EnemyType].HP = Enemy[EnemyType].MaxHP ;return 2;}



	// 的にダメージを与える処理 中かっこの中には勝った時の処理
	if(move==3)if(DamageCalc3( Character, &Enemy[EnemyType], 3, 5, 5, EnemyType, FALSE)==1){ 
			Character->Ex += Enemy[EnemyType].Ex ; 
			Enemy->HP = Enemy[EnemyType].MaxHP ; 
			move=0 ; 
			return 2 ;
		}

	// 敵のダメージを与える分を表示 中かっこの中には負けた時の処理
	if(move==5)if(DamageCalc3( &Enemy[EnemyType], Character, 5, 7, 3, EnemyType, TRUE)==1){
			move=0 ;
			return 0 ;
		}
	

	return 4 ;
}/*
Esempio n. 18
0
void BatchScreenshot(MenuInfo* info, bool full_batch)
{
    for (u32 idx_m = 0; info[idx_m].name != NULL; idx_m++) {
        for (u32 idx_s = 0; idx_s < ((full_batch) ? info[idx_m].n_entries : 1); idx_s++) {
            char filename[16];
            snprintf(filename, 16, "menu%04lu.bmp", (idx_m * 100) + idx_s);
            #ifndef USE_THEME
            DrawMenu(info + idx_m, idx_s, true, true);
            #else
            LoadThemeGfxLogo();
            LoadThemeGfxMenu((idx_m * 100) + idx_s);
            #endif
            Screenshot(filename);
        }
    }
}
Esempio n. 19
0
void KeyState::Enter(Ndk::StateMachine& fsm)
{
	m_text.SetVisible(true);
	DrawMenu();

	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
	{
		ManageInput(KeyStatus::Pressed, key, fsm);
	});

	m_keyReleasedSlot.Connect(eventHandler.OnKeyReleased, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
	{
		ManageInput(KeyStatus::Released, key, fsm);
	});
}
Esempio n. 20
0
/*
 * Start Allegro and draw the game Menu
 */
NinmanMenu::NinmanMenu() {
    NinmanConfig::loadConfig();
    install_keyboard();
    install_mouse();
    install_timer();
    if (install_sound(DIGI_AUTODETECT, MIDI_NONE, NULL) < 0)
        install_sound(DIGI_OSS, MIDI_NONE, NULL);
    set_color_depth(32);
    if (NinmanConfig::getFullScreenOption())
        set_gfx_mode(GFX_AUTODETECT, 800, 600, 0, 0);
    else
        set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0);
    set_volume(NinmanConfig::getVolume(), 0);
    DrawMenu(220);
    MainMenu();
}
Esempio n. 21
0
	/**
	*	Draw a frame
	*	@param delta Delta time between the last frame and now
	*/
	void Renderer::DrawFrame(float pDelta, bool pDisplayMenu)
	{
		UpdateDynamicElements();

		glMemoryBarrier(GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT);

		glViewport(0, 0, _width, _height);

		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		DrawUi(pDelta);

		if (pDisplayMenu && _menuPtr != nullptr)
			DrawMenu(pDelta);

		CheckGLError();
	}
Esempio n. 22
0
int NinmanMenu::MainMenu() {
    int y = 220;
    while (true) {
        readkey();
        if (key[KEY_ESC])
            return 0;
        if (key[KEY_DOWN]) {
            y = y + 55;
            if (y > 440)
                y = 220;
        }
        if (key[KEY_UP]) {
            y = y - 55;
            if (y < 220)
                y = 440;
        }
        if (key[KEY_ENTER]) {
            if (y == 220) {
                std::string player;
                while (player == "")
                    player = TextBox();
                if (player != "-1")
                    NinmanGame(player.c_str());
            }
            if (y == 275) {
                Score();
                y = 220;
            }
            if (y == 330) {
                OptionMenu();
                y = 220;
            }
            if (y == 385) {
                About();
                y = 220;
            }

            if (y == 440)
                break;
            clear_keybuf();
        }
        DrawMenu(y);
    }
    return 0;
}
Esempio n. 23
0
void main()
{
    bool StillPlaying=true;					// Define our boolean flag to true.  In this case, let's make a boolean and set it to true, meaning we
    int choice=0;							// are "StillPlaying" the game.  When Quit is chosen, we will set it to false, ending the game loop.

    // Let's create a while loop to continue until they Press '6' for quit.
    while(StillPlaying)						// This says, do everything below until StillPlaying == false.  Remember, a statement doesn't happen if 0 is the result from the expression.
    {
        DrawMenu();							// All we need to do is call our function, like so.
        // Since there are no parameters to pass in, we just close the parenthesis (); with a semicolon.
        // Now comes the part where we need to be able to choose from the menu.

        printf("Choose from the menu: ");	// Prompt the user

        scanf("%d", &choice);				// Get the users choice, (remember the & makes it so we can change "choice".  Think of it as a security thing.  It's permission to mess with choice.)

        // This is our "switch" statement.  Just a quick review:
        // What it does is take "choice" (or whatever is passed in), and does a bunch of if/else statements on it.
        // it's pretty much the same things as if/else, but looks cleaner.
        switch(choice)						// "case 1:"  is the same thing as saying, "if(choice == 1)"  You see?  A lot cleaner.
        {
        case 1:
            printf("You chose a New Game!\n");		// if (choice == 1)
            break;					// break - breaks out of the switch statement.
        case 2:
            printf("You chose to Load a Game!\n");	// if (choice == 2)
            break;									// Print the choice and break;
        case 3:
            printf("You chose to Save a Game!\n");	// if (choice == 3)
            break;									// Print the choice and break;
        case 4:
            printf("You chose your Inventory!\n");	// if (choice == 4)
            break;									// Print the choice and break;
        case 5:
            printf("You chose Options!\n");			// if (choice == 5)
            break;									// Print the choice and break;
        case 6:
            StillPlaying = false;					// if (choice == 6)
            printf("Game Over Already?\n");			// StillPlaying is set to false.  This means, when the code goes back up to the top, while(StillPlaying) will NOT be true and fail.
            break;									// A weird thing about switch statements, you don't need brackets {} for more than one line.
        }													// You just need a break;
    }	// while (StillPlaying)								// It's a good idea to label what the closing bracket is coming from.
    // When your code gets huge, it's kinda annoying to go back and match up all the brackets to find the statement.

}    	// void main()										// Once the user hits 6, the while loop quits and ends our program.
Esempio n. 24
0
void DrawMenus(void)
{
   int x, y;

   if(GameMode)
      return;

   x = Menus[ActiveMenu].x;
   y = Menus[ActiveMenu].y;

   /* save old settings */
   glPushAttrib(GL_COLOR_BUFFER_BIT | GL_CURRENT_BIT
		| GL_ENABLE_BIT | GL_VIEWPORT_BIT);

   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
   glLoadIdentity();

   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
   glLoadMatrixd(MenuProjection);
   glViewport(0, 0, VarInfo.xres, VarInfo.yres);

   glDisable(GL_DEPTH_TEST);
   glDisable(GL_ALPHA_TEST);
   glDisable(GL_LIGHTING);
   glDisable(GL_FOG);
   glDisable(GL_TEXTURE_2D);
   glEnable(GL_COLOR_LOGIC_OP);
   glLogicOp(GL_AND_REVERSE);

   if(DrawMenu(ActiveMenu, x, &y))
      Menus[ActiveMenu].selected = -1;
    
   /* restore settings */
   glPopMatrix();
   glMatrixMode(GL_MODELVIEW);
   glPopMatrix();

   glPopAttrib();
}
Esempio n. 25
0
int Game::Draw(){
	ClearScreen();
	glLoadIdentity();
	camera->Update();

	//描画処理
	switch(phase){
	case MENU:
		DrawMenu();
		break;
	case PLAY:
		DrawPlay();
		break;
	case RESULT:
		DrawResult();
		break;
	}

	SwapScreen();
	return 0;
}
//Output
void cGame::Render()
{
	glClear(GL_COLOR_BUFFER_BIT);
	
	glLoadIdentity();

	if (level == MENU)
	{
		RenderMenu(IMG_MENU);
	}else if (level == ABOUT)
	{
		RenderMenu(IMG_ABOUT);
	}else if (level == CONTROLS)
	{
		RenderMenu(IMG_CONTROLS);
	}else
	{
		Scene.Draw(Data.GetID(IMG_TILESET));

		for (int i = 0; i < allDogs.size(); ++i) allDogs[i].Draw(Data.GetID(IMG_DOG));
		for (int i = 0; i < allOctopus.size(); ++i) {
			allOctopus[i].Draw(Data.GetID(IMG_OCTOPUS));
			if (allOctopus[i].hasBall()) allOctopus[i].getBall()->Draw(Data.GetID(IMG_OCTOPUS));
		}

		for (int i=0; i < Isaac.getAllTears()->size(); ++i) {
			Isaac.getTear(i)->Draw(Data.GetID(IMG_OCTOPUS));
		}

		if (!Player.isDead()) Player.Draw(Data.GetID(IMG_PLAYER));

		for (int i = 0; i < allSwords.size(); ++i) allSwords[i].Draw(Data.GetID(IMG_SWORD));

		Isaac.Draw(Data.GetID(IMG_ISAAC));

		DrawMenu();
	}

	glutSwapBuffers();
}
Esempio n. 27
0
void TextEnterState::Enter(Ndk::StateMachine& fsm)
{
	m_text.SetVisible(true);
	DrawMenu();

	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
	{
		if (key.code == Nz::Keyboard::Key::M && key.shift)
		{
			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
		}
	});

	m_textEnteredSlot.Connect(eventHandler.OnTextEntered, [&] (const Nz::EventHandler*, const Nz::WindowEvent::TextEvent& event)
	{
		Nz::String content = "Character: " + Nz::String::Unicode(event.character);
		if (event.repeated)
			content += " repeated";
		m_text.SetContent(content + "\nM for Menu");
	});
}
Esempio n. 28
0
u32
GetButtonMap(u16 ctrlr_type, char* btn_name)
{
	u32 pressed, previous;
	char temp[50] = "";
	uint k;
	pressed = 0; previous = 1;

	switch (ctrlr_type) {
		case CTRLR_NUNCHUK:
			strncpy (cfg_text[3], (char*)"NUNCHUK", 7);
			break;
		case CTRLR_CLASSIC:
			strncpy (cfg_text[3], (char*)"CLASSIC", 7);
			break;
		case CTRLR_GCPAD:
			strncpy (cfg_text[3], (char*)"GC PAD", 7);
			break;
		case CTRLR_WIIMOTE:
			strncpy (cfg_text[3], (char*)"WIIMOTE", 7);
			break;
	};

	/*** note which button we are remapping ***/
	sprintf (temp, (char*)"Remapping ");
	for (k=0; k<9-strlen(btn_name); k++) strcat(temp, " "); // add whitespace padding to align text
	strncat (temp, btn_name, 9);		// snes button we are remapping
	strncpy (cfg_text[0], temp, 19);	// copy this all back to the text we wish to display

	DrawMenu(&cfg_text[0], NULL, cfg_text_count, 1);	// display text

//	while (previous != pressed && pressed == 0);	// get two consecutive button presses (which are the same)
//	{
//		previous = pressed;
//		VIDEO_WaitVSync();	// slow things down a bit so we don't overread the pads
		pressed = GetInput(ctrlr_type);
//	}
	return pressed;
}	// end getButtonMap()
void AGameplayDebuggingHUDComponent::PrintAllData()
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)

	// Allow child hud components to position the displayed info
	DefaultContext = FPrintContext(GEngine->GetSmallFont(), Canvas, DebugInfoStartX, DebugInfoStartY);
	DefaultContext.FontRenderInfo.bEnableShadow = true;

	if (DefaultContext.Canvas != NULL)
	{
		float XL, YL;
		const FString ToolName = FString::Printf(TEXT("Gameplay Debug Tool [Timestamp: %05.03f]"), GetWorld()->TimeSeconds);
		CalulateStringSize(DefaultContext, DefaultContext.Font, ToolName, XL, YL);
		PrintString(DefaultContext, FColorList::White, ToolName, DefaultContext.Canvas->ClipX / 2.0f - XL / 2.0f, 0);
	}

	const float MenuX = DefaultContext.CursorX;
	const float MenuY = DefaultContext.CursorY;

	UGameplayDebuggingComponent* DebugComponent = NULL;
	if (GetDebuggingReplicator())
	{
		DebugComponent = GetDebuggingReplicator()->GetDebugComponent();
	}
				
	if (DebugComponent)
	{
		APlayerController* const MyPC = Cast<APlayerController>(PlayerOwner);
		DrawDebugComponentData(MyPC, DebugComponent);
	}

	if (DefaultContext.Canvas && DefaultContext.Canvas->SceneView && DefaultContext.Canvas->SceneView->Family && DefaultContext.Canvas->SceneView->Family->EngineShowFlags.Game)
	{
		DrawMenu(MenuX, MenuY, DebugComponent);
	}
#endif
}
Esempio n. 30
0
void WindowModificationState::Enter(Ndk::StateMachine& fsm)
{
	m_text.SetVisible(true);
	DrawMenu();

	Nz::EventHandler& eventHandler = m_context.window.GetEventHandler();
	m_keyPressedSlot.Connect(eventHandler.OnKeyPressed, [&] (const Nz::EventHandler*, const Nz::WindowEvent::KeyEvent& key)
	{
		if (key.code == Nz::Keyboard::Key::M && key.shift)
		{
			fsm.ChangeState(StateFactory::Get(EventStatus::Menu));
		}
	});

	m_movedSlot.Connect(eventHandler.OnMoved, [&] (const Nz::EventHandler*, const Nz::WindowEvent::PositionEvent& event)
	{
		m_text.SetContent("Position(" + Nz::String::Number(event.x) + ", " + Nz::String::Number(event.y) + ")\nM for Menu");
	});

	m_resizedSlot.Connect(eventHandler.OnResized, [&] (const Nz::EventHandler*, const Nz::WindowEvent::SizeEvent& event)
	{
		m_text.SetContent("Size(" + Nz::String::Number(event.width) + ", " + Nz::String::Number(event.height) + ")\nM for Menu");
	});
}