Пример #1
0
void Init(HWND hWnd)
{
    // Set our global window handle to our main window
    g_hWnd = hWnd;

    // Create our double buffering our window
    g_Buffer.CreateDoubleBuffering(hWnd);

    // This is where we create the image of our character
    HBITMAP hPlayerImage = g_Buffer.LoadABitmap((LPSTR)kPlayerImage);

    // Initialize our player with it's image and position
    g_Player.Init(hPlayerImage, kPlayerStartX, kPlayerStartY);

    // Init, load and draw the first map file
    g_Map.Load(kStartMap);
    g_Map.SetDrawFlag(true);

    // Here we load then play the starting background music
    if(!g_Music.Init("techno.mod"))
        exit(0);

    g_Music.PlaySong();

    // we need to seed our random number generator (rand()) for moving npcs.
    srand(GetTickCount());

    // Set the backbuffer to black first (This clears the backbuffer)
    g_Buffer.ClearScreen(BLACK_BRUSH);
}
Пример #2
0
void LoadOrSaveAMap(bool bLoad)
{
    string strMapName = "";		// Create a STL string to read in the input from the user
    char szName[255] = {0};		// Create a traditional string of characters for the file name

    // In this function we setup a prompt for the user to type in the file name to
    // either save or load.  If you want to load a file, you pass in "true", otherwise
    // we use "false" to indicate that we want to save a file.  This cuts down on code
    // since a lot of the code is the same for each action.  This function doesn't
    // actually do the saving and loading code, but handles the input from the user.
    // The save and load code is in our CMap::Load() and CMap::Save() functions that
    // we call from here.

    // Get an output handle for the console window and set the cursor position for a prompt
    HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hOutput, g_promptPos);

    // To clear the prompt, we just print out a bunch of tabs and then reset the cursor position
    cout << "\t\t\t\t\t\t\t\t\t\t";
    SetConsoleCursorPosition(hOutput, g_promptPos);

    // Get an input handle and set the console window to allow input from the user
    // and echo it to the screen.  This is important.  If you don't set this mode,
    // the user won't see what they are typing.
    HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
    SetConsoleMode(hInput, ENABLE_PROCESSED_INPUT | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT);

    // Below we check if we want to load or save a file, then display the appropriate message
    if(bLoad)
        cout << "Enter a map to Load: ";
    else
        cout << "Enter a map to Save: ";

    // Here we get the map name that we want to save or load
    cin >> strMapName;

    // Then we extract the string from the string class and put it in a normal array or characters
    strcpy(szName, strMapName.c_str());

    // Next we either load or save the map entered by the user, depending on bLoad
    if(bLoad)
        g_Map.Load(szName);
    else
        g_Map.Save(szName);

    // Next, we restore the console mode for getting mouse and keyboard input and redraw the screen
    SetConsoleMode(hInput, ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT);
    g_Map.Draw();
}
Пример #3
0
void Init()
{
	// This is where we create the image of our character, a brown @ symbol
	CHAR_INFO playerImage = {'@', FOREGROUND_RED | FOREGROUND_GREEN};
	
	// Initialize our player with it's image and position
	g_Player.Init(playerImage, kPlayerStartX, kPlayerStartY);

	// Init the map and load the first map.  Then set the flag that tells
	// the map's Draw() function to draw that frame.  We don't want to draw
	// every frame, but only when something happens.
	g_Map.SetDefault();
    g_Map.Load(kStartMap);
	g_Map.SetDrawFlag(true);
}
Пример #4
0
void HandleExitTiles()
{
	// This function handles our exit setting on the destination map.  If the
	// exit map (destination map) isn't open, then we want to get the name of
	// the map to open from the user.  We check to see if it's valid, and if
	// it's not, we need to delete all the exits on the main map since they
	// are invalid.  If it is valid, then we want to load the destination map
	// so that they user can choose the spot where the player will end up on
	// the other map.  If the exit map is already open and this function is
	// called, we want to go through all the exits we set and fill in their
	// destination information.  This function is thus called twice, when we
	// want to load the destination map, and after we are finished placing exits.

	// If we don't have the exit map open
	if(!g_bExitMapOpen)
	{
		char szExitFile[255] = {0}; 
		
		// Bring up the open dialog box and get a map to exit to
		if(GetExitFileName(szExitFile))
		{
			g_ExitMap.Load(szExitFile);					// Open the map to exit to
			g_bExitMapOpen = true;						// State that we now have the exit map open
			g_pCurrentMap = &g_ExitMap;					// Set the current map to our exit map
			g_pCurrentMap->SetCurrentType(EXIT_TYPE);	// Set the current type to the exit type
		}
		else											// If the file is invalid, delete the exits
			g_pCurrentMap->DeleteBlankExits();
	}
	else												// If we already have the exit map open
	{
		// Get the size of the current exit list and get the last exit tile in the list.
		// In other words, get the last tile we just placed on the exit map.
		int size = g_ExitMap.GetCurrentListSize();
		CExit *pExit = (CExit*)g_ExitMap.GetCurrentListTile(size - 1);

		// Set the exits we just placed on the main map with the 
		// new destination info (name, position, etc...)
		g_Map.SetExits(g_ExitMap.GetMapName(), pExit);

		// Restore the current map to our normal map we were working with
		g_pCurrentMap = &g_Map;
		g_bExitMapOpen = false;
	}
}
Пример #5
0
void LoadOrSaveAMap(bool bLoad)
{
	string strMapName = "";		// Create a STL string to read in the input from the user
	char szName[255] = {0};		// Create a traditional string of characters for the file name

	// Get an output handle for the console window and set the cursor position for a prompt
	HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
	SetConsoleCursorPosition(hOutput, g_promptPos);

	// To clear the prompt, we just print out a bunch of tabs and then reset the cursor position
	cout << "\t\t\t\t\t\t\t\t\t\t";
	SetConsoleCursorPosition(hOutput, g_promptPos);

	// Get an input handle and set the console window to allow input from the user 
	HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);			
	SetConsoleMode(hInput, ENABLE_PROCESSED_INPUT | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT);

	// Below we check if we want to load or save a file, then display the appropriate message
	if(bLoad)
		cout << "Enter a map to Load: ";
	else
		cout << "Enter a map to Save: ";

	// Here we get the map name that we want to save or load
	cin >> strMapName;

	// Then we extract the string from the string class and put it in a normal array or characters
	strcpy(szName, strMapName.c_str());

	// Next we either load or save the map entered by the user, depending on bLoad
	if(bLoad)
		g_Map.Load(szName);
	else
		g_Map.Save(szName);

	// Next, we restore the console mode for getting mouse and keyboard input and redraw the screen
	SetConsoleMode(hInput, ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT);
	g_Map.Draw();	
}
Пример #6
0
void HandleMenu(int menuID)
{		
	if(menuID == ID_FILE_QUIT)					// If the user chose File->Quit
	{
		PostQuitMessage(0);						// Quit the program
	}


//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////

	else if(menuID == ID_FILE_OPENUP)			// If the user chose File->Open
	{	
		// Have windows bring up the Open File dialog box and Load the file chosen
		if(GetOpenFileName(&g_OpenInfo))
			g_Map.Load(g_OpenInfo.lpstrFile);	
	}
	else if(menuID == ID_FILE_SAVEIT)			// If the user chose File->Save
	{
		// If we have a n valid name for our map already, do a normal save
		if(strlen(g_Map.GetMapName()) > 3)
			g_Map.Save(g_Map.GetMapName());
		else
		{
			// If haven't given our map a name yet, do a "SaveAs" and bring up the save dlg box
			if(GetSaveFileName(&g_OpenInfo))
				g_Map.Save(g_OpenInfo.lpstrFile);
		}
	}
	else if(menuID == ID_FILE_SAVEAS)			// If the user chose File->SaveAs
	{
		// Bring up the save dlg box and allow the user to type in a new map name and save it
		if(GetSaveFileName(&g_OpenInfo))
			g_Map.Save(g_OpenInfo.lpstrFile);
	}

//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////


	else if(menuID == ID_FILE_RESET)			// If the user chose File->Reset
		g_Map.SetDefault();						// Destroy all the tiles on the map and start over
	else if(menuID == ID_TILES_TILES)			// If the user chose Tiles->Tiles
		g_Map.SetCurrentType(TILE_TYPE);		// Set the tool bar tile type to tiles
	else if(menuID == ID_TILES_ITEMS)			// If the user chose Tiles->Items
		g_Map.SetCurrentType(ITEM_TYPE);		// Set the tool bar tile type to items
	else if(menuID == ID_TILES_MONSTERS)		// If the user chose Tiles->Monsters
		g_Map.SetCurrentType(MONSTER_TYPE);		// Set the tool bar tile type to monsters
	else if(menuID == ID_TILES_CITIZENS)		// If the user chose Tiles->Citizens
		g_Map.SetCurrentType(NPC_TYPE);			// Set the tool bar tile type to citizens
	else if(menuID == ID_TILES_EXITS)			// If the user chose Tiles->Exits
		g_Map.SetCurrentType(EXIT_TYPE);		// Set the tool bar tile type to exits (no tiles of course)
	else if(menuID == ID_HELP_ABOUT)			// If the user chose Help->About
		// Instead of creating a help dialog box, we can just use a simple system MessageBox() call
		MessageBox(g_hWnd, "www.GameTutorials.com Map Editor\n\n"
						   "\t- Choose the desired tile type from the Tiles menu,\n"
						   "\t  then click on a tile in the tile window. You can\n"
						   "\t  then draw the tiles on the map with the left mouse button.\n\n"
						   "\t- Right click to remove the current cursor tile.\n\n"
						   "\t- To delete a item:monster:citizen:exit, make sure you choose\n"
						   "\t  that type from the menu, then right click on the tile.\n\n"
						   "\t- When setting an exit you can hold down shift to place more exits.\n"
						   "\t  Once you place an exit without holding the shift key you will be\n"
						   "\t  prompted to choose the destination map.  Then place one tile for\n"
						   "\t  the position where the character will end up.\n\n"
						   "\t- Hit Esc to quit the program.", "About", MB_OK | MB_ICONINFORMATION);

	// Over assuming that a tile type was changed, reset the scroll bar size.
	// The -1 is because the tool bar window's title size offsets it a bit (being smaller).
	g_ScrollInfo.nMax = g_Map.GetCurrentTypeSize() - MAP_HEIGHT - 1;
	
	// If there isn't enough (or any) tiles to fill up the tool bar window, disable the scroll bar
	if(g_ScrollInfo.nMax < 0)
	{
		g_ScrollInfo.nMax = 0;
		EnableScrollBar(g_hWndTool, SB_VERT, ESB_DISABLE_BOTH);
	}
	else
		EnableScrollBar(g_hWndTool, SB_VERT, ESB_ENABLE_BOTH);	// Enable the scroll bar if it's needed

	// Reset the scroll bar info
	g_scrollBarPosY = 0;
	g_ScrollInfo.nPage = 0;

	// Update the current scroll bar information with no need to redraw (FALSE)
	SetScrollInfo(g_hWndTool, SB_VERT, &g_ScrollInfo, FALSE);
	ShowScrollBar(g_hWndTool, SB_VERT, TRUE);

	// If we chose a tile type, put a check box next to it
	switch(menuID)
	{
		case ID_TILES_TILES: 
		case ID_TILES_ITEMS:
		case ID_TILES_MONSTERS:
		case ID_TILES_CITIZENS:
		case ID_TILES_EXITS:
			g_pCursorTile = NULL;
			CheckTileType(menuID);
			break;
	}
}
Пример #7
0
	//pêtla g³ówna gry
	void CGame::mainLoop()
	{
		CMap mapa;
		mapa.Load("data/xml_data/maps/level_001.xml");
		mapa.RespawnMapObjects(true);

		
		//rêczna, bezpieczna inicjacja niektórych singleton
		initSingletons();

		//jakaœ funkcja ³aduj¹ca na pocz¹tku zasoby dla poprawy wydajnoœci...

		//bardzo Ÿle napisane...mo¿na poni¿sze opakowaæ do jakiejœ klasy/metody?
		CFont font = *gResourceManager.GetFont("data/fonts/tahoma.ttf");
		fps_text.setString("Zaczynamy");
		fps_text.setFont(font);
		fps_text.setCharacterSize(20);
		fps_text.setColor(sf::Color::Blue);
		fps_text.setPosition(10,10);

	/*
		//³adowanie danych z poziomu CResourceManager'a
		if(gResourceManager.LoadPhysicalTemplate("data/xml_data/units_enemy/destroyer.xml") == false)
			printf("Data not loaded...\n");
		if(gResourceManager.LoadPhysicalTemplate("data/xml_data/units_monster/monster.xml") == false)
			printf("Data not loaded...\n");

		
		//tworzê fabrykê i inicjujê j¹ danymi pobramymi z CResourceManager'a uprzednio za³adowanymi
		CEnemyTemplate *p_enemy_template = (CEnemyTemplate*)gResourceManager.GetPhysicalTemplate("data/xml_data/units_enemy/destroyer.xml");
		//ten kod jest testowy, bo tworzenie (respawn) obiektów bêdzie z poziomu ³adowania mapy (level'a)
		CEnemy *p_enemy = p_enemy_template->Create(L"ID_enemy");
		
		
		if(p_enemy)
		{
			p_enemy->SetUseDisplayableBody(false);
			p_enemy->setSmoothing(false);
			p_enemy->SetPosition(400, 200);
			p_enemy->SetScale(2.5f);
			p_enemy->SetScaleHead(1.0f,1.0f);
			p_enemy->SetColorHead(sf::Color::Transparent);
			p_enemy->SetColorShadow(sf::Color::Transparent);
			p_enemy->SetAnimationHead("backpack_anim");
			p_enemy->SetAnimationBody("backpack_anim");
			

			//p_enemy->SetRotationBody(32.f);
			//p_enemy->SetRotationHead(310);

			//testy...sprawdziæ...jak to dzia³a...
			//p_enemy->SetColorHead(sf::Color::Blue);	//kolorujemy obiekt body na niebiesko
			//p_enemy->SetColorBody(sf::Color::Red);	//kolorujemy obiekt head na czerwono

			//p_enemy->RestoreColor();				//odzyskujemy oryginalny kolor body and head
			//p_enemy->RestoreColorBody();			//odzyskujemy oryginalny kolor body
			//p_enemy->RestoreColorHead();			//odzyskujemy oryginalny kolor head
		}
		

		//tworzê fabrykê i inicjujê j¹ danymi pobramymi z CResourceManager'a uprzednio za³adowanymi
		CMonsterTemplate *p_monster_template = (CMonsterTemplate*)gResourceManager.GetPhysicalTemplate("data/xml_data/units_monster/monster.xml");
		//ten kod jest testowy, bo tworzenie (respawn) obiektów bêdzie z poziomu ³adowania mapy (level'a)
		CMonster *p_monster = p_monster_template->Create(L"ID_monster");

		if(p_monster)
		{
			//p_enemy->SetUseDisplayableBody(false);
			p_monster->setSmoothing(false);
			p_monster->SetPosition(550, 200);
			//p_enemy->SetScale(2.5f);
			//p_enemy->SetScaleHead(1.0f,1.0f);
			//p_enemy->SetColorHead(sf::Color::Transparent);
			//p_enemy->SetColorShadow(sf::Color::Transparent);
			//p_enemy->SetAnimationHead("backpack_anim");
			//p_enemy->SetAnimationBody("backpack_anim");
		}
		*/
		printf("CGame::Run()\n");

		while (m_render_window->isOpen())
		{
			//zegar
			float elapsedTime = m_clock.GetElapsedTime();
			m_clock.Reset();

			//mo¿na te¿ skorzystaæ z poni¿szego zegara...
			//float elapsedTime = gClock.GetElapsedTime();
			//gClock.Update();

			while (m_render_window->pollEvent(m_event))
			{
				switch (m_event.type)
				{
				case sf::Event::Closed:
					m_render_window->close();
					return;

				case sf::Event::KeyPressed:
					for (std::set<IKeyListener*>::iterator i = m_keyListeners.begin() ; i != m_keyListeners.end(); i++ )
						(*i)->KeyPressed(m_event.key);
					break;
				
				default:
					break;

				}
			}

			m_render_window->clear(sf::Color(120,128,23));
			//m_render_window->clear(sf::Color::White);
			Update(elapsedTime);				//aktualizacja gry
			m_render_window->draw(fps_text);	//statystyki...

			
			m_render_window->display();			//wyœwietlenie sceny w oknie
		}
	}
Пример #8
0
bool Controller::Initialize(const char* server_name, const char* configure_file)
{
    _server_name = server_name;
    _configure_file = configure_file;

    // 加载配置
    if (!gConfigureMap.Load(configure_file))
    {
        printf("error: %s\n", gConfigureMap.GetErrMsg().c_str());
        return false;
    }
    gConfigureMap.Print();

    // 初始化日志
    std::string log_path = JoinPath(gConfigureMap["log"]["log_path"].str(), server_name);
    if (!Logger::Initialize(log_path.c_str(),
                           gConfigureMap["log"]["max_file_size"].as<uint32_t>(DefaultConf::kMaxLogFileSize),
                           gConfigureMap["log"]["max_file_num"].as<uint32_t>(DefaultConf::kMaxLogFileNum),
                           gConfigureMap["log"]["log_level"].c_str())) {
        printf("logger initialize failed, errmsg: %s\n", Logger::GetErrMsg().c_str());
    }

    LogInfo("Logger initialize succeed\n");

    int poller_max_event = gConfigureMap["poller_max_event"].as<int>(DefaultConf::kPollerMaxEventNum);
    assert(poller_max_event > 0);
    _poller = new Poller(poller_max_event);
    assert(_poller);

    LogInfo("Poller initialize succeed\n");

    // 初始化监听端口

    // TODO different port bind different protocol(unpack function)
    // 每个监听端口最好能独立的包完整性检查,每个访问外部server的端口,最好也能绑定独立协议
    const Value & val = gConfigureMap["listen"];
    _listen_size = val.size() + 128;
    _listen_sockets = new ListenFdInfo[_listen_size];
    for (uint32_t i=0; i<_listen_size; ++i)
    {
        unsigned int port = val[i]["port"].as<unsigned>(0);
        int fd = ListenTcpV4(port);
        if (fd < 0) {
            FillErrmsg("listen failed: ", errno);
            return false;
        }

        _listen_sockets[fd].port = port;
        _listen_sockets[fd].fd = fd;

        if (_poller->Add(fd, (uint64_t)fd, EPOLLIN)) {
            FillErrmsg("listen fd add to poller failed: ", errno);
            return false;
        }
    }

    _io_handler_num = gConfigureMap["server"]["io_handler_num"].as<uint32_t>(DefaultConf::kIoHandlerNum);
    _io_handers = new IoHandler[_io_handler_num];
    assert(_io_handers);
    for (uint32_t i=0; i<_io_handler_num; ++i) {
        if(!_io_handers[i].Initialize()) {
            _errmsg = "io handler initialize failed";
            return false;
        }
    }

    _worker_num = gConfigureMap["server"]["worker_num"].as<uint32_t>(DefaultConf::kWorkerNum);
    _workers = new Worker[_worker_num];
    assert(_workers);
    for (uint32_t i=0; i<_worker_num; ++i) {
        if(!_workers[i].Initialize()) {
            _errmsg = "initialize workers failed";
            return false;
        }
    }

    int pool_size = _io_handler_num + _worker_num;
    int queue_size = gConfigureMap["server"]["queue_size"].as<uint32_t>(DefaultConf::kQueueSize);
    _task_pool = new TaskPool();
    assert(_task_pool);
    if (!_task_pool->Initialize(pool_size, queue_size)) {
        LogErr("task poll initialize failed");
        return false;
    }

    return true;
}