Beispiel #1
0
/**
**  Parse CREATEGAME
*/
static void ParseCreateGame(Session *session, char *buf)
{
	char *description;
	char *map;
	char *players;
	char *ip;
	char *port;
	char *password;
	int players_int;
	int port_int;


	if (Parse5or6Args(buf, &description, &map, &players, &ip, &port, &password)) {
		Send(session, "ERR_BADPARAMETER\n");
		return;
	}

	players_int = atoi(players);
	port_int = atoi(port);
	// FIXME: check ip
	if (strlen(description) > MAX_DESCRIPTION_LENGTH ||
			strlen(map) > MAX_MAP_LENGTH ||
			players_int < 1 || players_int > 16 ||
			port_int < 1 || port_int > 66535 ||
			(password && strlen(password) > MAX_GAME_PASSWORD_LENGTH)) {
		Send(session, "ERR_BADPARAMETER\n");
		return;
	}

	CreateGame(session, description, map, players, ip, port, password);

	DebugPrint("%s created a game\n" _C_ session->UserData.Name);
	Send(session, "CREATEGAME_OK\n");
}
Beispiel #2
0
//=============================================================================
// Starting point for a Windows application
//=============================================================================
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine, int nCmdShow)
{
    // Check for memory leak if debug build
    #if defined(DEBUG) | defined(_DEBUG)
        _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
    #endif

    MSG msg;

    // Create the game, sets up message handler
    game = CreateGame();

    // Create the window
    if (!CreateMainWindow(hwnd, hInstance, nCmdShow))
        return 1;

    try{
        game->initialize(hwnd);     // throws GameError

        // main message loop
        int done = 0;
        while (!done)
        {
            if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                // look for quit message
                if (msg.message == WM_QUIT)
                    done = 1;

                // decode and pass messages on to WinProc
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            } else
                game->run(hwnd);    // run the game loop
        }
        safeDelete(game);           // free memory before exit
        return msg.wParam;
    }
    catch(const GameError &err)
    {
        game->deleteAll();
        DestroyWindow(hwnd);
        MessageBox(NULL, err.getMessage(), "Error", MB_OK);
    }
    catch(...)
    {
        game->deleteAll();
        DestroyWindow(hwnd);
        MessageBox(NULL, "Unknown error occured in game.", "Error", MB_OK);
    }

    safeDelete(game);       // free memory before exit
    return 0;
}
Beispiel #3
0
void FindOpponent(int incomeSd, int userID)
{
    int found = 0;
    int i;
    for (i = 0; i < MAXUSERS; i++)
        if (i != userID && users_available[i])
        {
            if (users[userID].ownLevel == users[i].desiredLevel && users[userID].desiredLevel == users[i].ownLevel)
            {
                found = 1;
                int gameID = CreateGame(userID, i);
                userGame[userID] = userGame[i] = gameID;
                userOp[userID] = i;
                userOp[i] = userID;
                
                printf("\n\nUserIDs: %d, %d\n", userID, i);
                printf("Game info\n");
                printf("\tGameID: %d\n", gameID);
                printf("\tWhiteID: %d\n", games[gameID].white_user.userID);
                printf("\tBlackID: %d\n", games[gameID].black_user.userID);
                break;
            }
        }
    
    if (!found)
    {
        int result_val = 0;
        MessageType m = composeMessage(result, sizeof(int), &result_val);
        sendMessage(incomeSd, &m);
        
        while (userOp[userID] == userID)
            continue;
    }
    else
    {
        int result_val = 1;
        MessageType m = composeMessage(result, sizeof(int), &result_val);
        sendMessage(incomeSd, &m);
        
    }
    
    MessageType m = composeMessage(text, sizeof(users[userOp[userID]].name), &(users[userOp[userID]].name));
    sendMessage(incomeSd, &m);
    
    Color color;
    if (games[userGame[userID]].white_user.userID == userID)
        color = white;
    else
        color = black;
    m = composeMessage(color_t, sizeof(Color), &color);
    sendMessage(incomeSd, &m);
    
    clearMessage(&m);    
}
Beispiel #4
0
bool GameWorld::init()
{
    if ( !CCLayer::init() )
    {
        return false;
    }
    
	CreateWorld();
	CreateGame();
    return true;
}
Beispiel #5
0
void CGameServer::DestroyAllEntities(const tvector<tstring>& asSpare, bool bRemakeGame)
{
	if (!GameNetwork()->IsHost() && !IsLoading())
		return;

	if (m_pWorkListener)
		m_pWorkListener->SetAction("Locating dead nodes", GameServer()->GetMaxEntities());

	for (size_t i = 0; i < GameServer()->GetMaxEntities(); i++)
	{
		CBaseEntity* pEntity = CBaseEntity::GetEntity(i);
		if (!pEntity)
			continue;

		bool bSpare = false;
		for (size_t j = 0; j < asSpare.size(); j++)
		{
			if (asSpare[j] == pEntity->GetClassName())
			{
				bSpare = true;
				break;
			}
		}

		if (bSpare)
			continue;

		pEntity->Delete();

		if (m_pWorkListener)
			m_pWorkListener->WorkProgress(i);
	}

	if (m_pWorkListener)
		m_pWorkListener->SetAction("Clearing buffers", GameServer()->m_ahDeletedEntities.size());

	for (size_t i = 0; i < GameServer()->m_ahDeletedEntities.size(); i++)
	{
		delete GameServer()->m_ahDeletedEntities[i];

		if (m_pWorkListener)
			m_pWorkListener->WorkProgress(i);
	}

	GameServer()->m_ahDeletedEntities.clear();

	if (CBaseEntity::GetNumEntities() == 0)
		CBaseEntity::s_iNextEntityListIndex = 0;

	if (bRemakeGame && GameNetwork()->IsHost())
		m_hGame = CreateGame();
}
Beispiel #6
0
//Private
int Engine::Initialize(){
	m_EngineState = EngineState::Initializing;

	Game* game = CreateGame();

	if (!game)
		return false;

	//Add some systems


	return true;
}
Beispiel #7
0
void ShowHeroScene::CreateMenu()
{
	auto strings = FileUtils::getInstance()->getValueMapFromFile("fonts/menu.xml"); 
	std::string strBeginGame  = strings["BeginGame"].asString(); 
	std::string strCreateGame = strings["CreateGame"].asString(); 
	std::string strJoinGame = strings["JoinGame"].asString(); 
	std::string strExitGame = strings["ExitGame"].asString();  

	if (/*GameLogic::GetInstance()->IsSingleGame()*/GameLogic::GetInstance()->GetGameType() == SINGLE_GAME_TYPE)
	{
		MenuItemLabel* beginGameItem = MenuItemLabel::create(LabelTTF::create(strBeginGame, "Arial", 40), 
			[&](Ref* sender)
		{
			BeginGame();
		}
		);
		beginGameItem->setPosition(Point(500,100));
		auto menu = Menu::create(beginGameItem,NULL);
		menu->setPosition(Point(0, 0));
		addChild(menu);
	}
	else
	{
		if (/*GameLogic::GetInstance()->IsCreator()*/GameLogic::GetInstance()->GetGameType() == CREATE_GAME_TYPE)
		{
			MenuItemLabel* createGameItem = MenuItemLabel::create(LabelTTF::create(strCreateGame, "Arial", 40), 
				[&](Ref* sender)
			{
				CreateGame();
			}
			);
			createGameItem->setPosition(Point(500,100));
			auto menu = Menu::create(createGameItem,NULL);
			menu->setPosition(Point(0, 0));
			addChild(menu);
		}
		else
		{
			MenuItemLabel* joinGameItem = MenuItemLabel::create(LabelTTF::create(strJoinGame, "Arial", 40), 
				[&](Ref* sender)
			{
				JoinGame();
			}
			);
			joinGameItem->setPosition(Point(500,100));
			auto menu = Menu::create(joinGameItem,NULL);
			menu->setPosition(Point(0, 0));
			addChild(menu);
		}
	}
}
Beispiel #8
0
int main(int argc, char* args[])
{
    const int width=800, height=600, bpp=32;
    const char* caption = "FPS";

    if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
        return 1;

    if (SDL_SetVideoMode(width, height, bpp, SDL_OPENGL) == 0)
        return 2;

    // vsync
    SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1);

    SDL_WM_SetCaption(caption, 0);

    //
    Game* game = CreateGame(width, height);
    Gamepad* gamepad = CreateGamepad();

    Uint32 accum = 0;
    Uint32 lastTick = SDL_GetTicks();

    while (doLoop) {
        const Uint32 now = SDL_GetTicks();
        accum += now-lastTick;
        lastTick = now;

        while (accum > TICKS_PER_FRAME) {
            gamepad->update();
            game->update(*gamepad);
            accum -= TICKS_PER_FRAME;
        }
        game->render();

        // delay some amount of time to play nice with the OS
        // this value can be tweaked
        SDL_Delay(1);
    }

    delete game;
    delete gamepad;

    SDL_Quit();

    return 0;
}
Beispiel #9
0
void StartMap(const std::string &filename, bool clean)
{
	std::string nc, rc;

	gcn::Widget *oldTop = Gui->getTop();
	gcn::Container *container = new gcn::Container();
	Containers.push_back(container);
	container->setDimension(gcn::Rectangle(0, 0, Video.Width, Video.Height));
	container->setOpaque(false);
	Gui->setTop(container);

	NetConnectRunning = 0;
	InterfaceState = IfaceStateNormal;

	//  Create the game.
	DebugPrint("Creating game with map: %s\n" _C_ filename.c_str());
	if (clean) {
		CleanPlayers();
	}
	GetDefaultTextColors(nc, rc);

	CreateGame(filename.c_str(), &Map);

	UI.StatusLine.Set(NameLine);
	SetMessage("%s", _("Do it! Do it now!"));

	//  Play the game.
	GameMainLoop();

	//  Clear screen
	Video.ClearScreen();
	Invalidate();

	CleanGame();
	InterfaceState = IfaceStateMenu;
	SetDefaultTextColors(nc, rc);

	Gui->setTop(oldTop);
	Containers.erase(std::find(Containers.begin(), Containers.end(), container));
	delete container;
}
Beispiel #10
0
int main(int argc, char **argv)
{
	//_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	//creating engine
	Engine* engine = new Engine;

	GLUTInput* nativeInput = new GLUTInput;
	engine->nativeInput = nativeInput;

	WinAssetLoader* assetLoader = new WinAssetLoader;
	engine->assetLoader = assetLoader;

	GLUTDisplay* displayModule = new GLUTDisplay(engine, &argc, argv, GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH, 800, 600, "ENGINE");
	engine->display = displayModule;
	displayModule->create();

	CreateGame();

	glutMainLoop(); //TEMP

	return 0;
}
Beispiel #11
0
game NewGame() {
    game g = CreateGame();
    if( g == NULL ) return NULL;
    RandomMap(g->gameMap);
    g->pc = CreateCharacter(g);
    wrefresh(g->win);
    init_pc(g->pc);    
    box(g->arena, 0, 0);
    wrefresh(g->arena);
    int nzombies = NumZombies(g->arena);
    g->ZombieListHead = CreateCreature(g);
    init_npc(g->ZombieListHead->Character);
    wrefresh(g->arena);
    int n = 1;
    while( n < nzombies ) {
        wrefresh(g->arena);
        creature Z = CreateCreature(g);
        init_npc(Z->Character);
        InsertCreatureNode( g->ZombieListHead, Z );
        ++n;
    }
    return g;
}
Beispiel #12
0
//Private Methods
int Engine::Initialize()
{
	// Set the engine to Initializing
	m_EngineState = EngineState::Initializing;

	// Create the WorldSettings singleton
	Singleton<WorldSettings>::CreateInstance();

	// Create a new point to a new game
	Game* game = CreateGame();

	// Break if the new game failed
	if (!game) { return false; }

	// Add systems

	// Adding the Window system
#if defined(DEBUG) | defined(_DEBUG)
	if (!AddSystem(new Window(WindowData(Singleton<WorldSettings>::GetInstance()->getWindowWidth(),
										 Singleton<WorldSettings>::GetInstance()->getWindowHeight(),
										 Singleton<WorldSettings>::GetInstance()->getWindowTitle()))))
		return false;
#else
	AddSystem(new Window(WindowData(Singleton<WorldSettings>::GetInstance()->getWindowWidth(),
									Singleton<WorldSettings>::GetInstance()->getWindowHeight(),
									Singleton<WorldSettings>::GetInstance()->getWindowTitle())));
#endif
	// Adding the Graphics system
#if defined(DEBUG) | defined(_DEBUG)
	if (!AddSystem(new Graphics(GraphicsData(GetSystem<Window>(SystemType::Sys_Window)))))
		return false;
#else
	AddSystem(new Graphics(GraphicsData(GetSystem<Window>(SystemType::Sys_Window))));
#endif
	// Adding the Engine Timer system
#if defined(DEBUG) | defined(_DEBUG)
	if (!AddSystem(new EngineTimer(EngineTimerData())))
		return false;
#else
	AddSystem(new EngineTimer(EngineTimerData()));
#endif
	// Adding the Game Logic Data system
#if defined(DEBUG) | defined(_DEBUG)
	if (!AddSystem(new GameLogic(GameLogicData())))
		return false;
#else
	AddSystem(new GameLogic(GameLogicData()));
#endif

	// Initialize the system

	// Window Init Block
#if defined(DEBUG) | defined(_DEBUG)
	if (!m_mapSystems[SystemType::Sys_Window]->Initialize())
		return false;
#else
	m_mapSystems[SystemType::Sys_Window]->Initialize();
#endif

		// Graphics Init Block
#if defined(DEBUG) | defined(_DEBUG)
		if (!m_mapSystems[SystemType::Sys_Graphics]->Initialize())
			return false;
#else
	m_mapSystems[SystemType::Sys_Graphics]->Initialize();
#endif

		// Engine Timer Init Block
#if defined(DEBUG) | defined(_DEBUG)
		if (!m_mapSystems[SystemType::Sys_EngineTimer]->Initialize())
			return false;
#else
	m_mapSystems[SystemType::Sys_EngineTimer]->Initialize();
#endif

		// Game Logic Init Block
#if defined(DEBUG) | defined(_DEBUG)
		if (!m_mapSystems[SystemType::Sys_Logic]->Initialize())
			return false;
#else
	m_mapSystems[SystemType::Sys_Logic]->Initialize();
#endif

	// Create the singleton of the graphics device manager
	Singleton<GraphicsDeviceManager>::CreateInstance();
	// Set that to the system we created
	Singleton<GraphicsDeviceManager>::GetInstance()->SetGraphics(GetSystem<Graphics>(SystemType::Sys_Graphics));

	return true;
}
Beispiel #13
0
int CALLBACK
old(
    HINSTANCE Instance,
    HINSTANCE PrevInstance,
    LPSTR CommandLine,
    int ShowCode)
{
#if 1
    Win32EnableConsole();
#endif

    sf::ContextSettings settings;
    settings.depthBits = 32; //24
    settings.stencilBits = 0; //0
    settings.antialiasingLevel = 0; //0
    settings.majorVersion = 3;
    settings.minorVersion = 2;

    // Display the list of all the video modes available for fullscreen
    std::vector<sf::VideoMode> modes = sf::VideoMode::getFullscreenModes();
    for (std::size_t i = 0; i < modes.size(); ++i)
    {
        sf::VideoMode mode = modes[i];    
        std::cout << "Mode #" << i << ": "
        << mode.width << "x" << mode.height << " - "
        << mode.bitsPerPixel << " bpp" << std::endl;
    }
    
    uint8 defaultStyle = (sf::Style::Titlebar | sf::Style::Close);
    auto mode = modes[17];
    sf::RenderWindow renderWindow(sf::VideoMode(mode.width, mode.height, mode.bitsPerPixel), "OpenGL", defaultStyle , settings);
    
    renderWindow.setVerticalSyncEnabled(true);
    renderWindow.setFramerateLimit(60);
    renderWindow.resetGLStates();

    settings = renderWindow.getSettings();

    cout << "depth bits:" << settings.depthBits << endl;
    cout << "stencil bits:" << settings.stencilBits << endl;
    cout << "antialiasing level:" << settings.antialiasingLevel << endl;
    cout << "version:" << settings.majorVersion << "." << settings.minorVersion << endl;

    renderWindow.setActive(true);

    sfg::SFGUI sfgui;
    sfg::Desktop sfguiDesktop;

    CreateGui(sfguiDesktop);

    sf::Font retro_font;
    retro_font.loadFromFile( "../data/fonts/Retro Computer_DEMO.ttf" );
    auto fent = std::make_shared<sf::Font>();// = sf::Font>(retro_font);
    fent->loadFromFile( "../data/fonts/Retro Computer_DEMO.ttf" );
    
    //my_font.setGlobalBounds(text.getGlobalBounds.left, text.getGlobalBounds().top);
    sfguiDesktop.GetEngine().GetResourceManager().AddFont( "retro_font", fent );
    //desktop.SetProperty( "*", "FontName",  "custom_font" );

    sfguiDesktop.SetProperties(
        "* {"
        "   FontName: retro_font;"
        "   FontSize: 18;"
        "}"
        );

    sf::Text text;
    text.setFont(retro_font);
    text.setPosition(sf::Vector2f(2, 2));
    text.setCharacterSize(18);
    text.setColor(sf::Color::White);

    KeyboardManager keyboardManager;

    //Game game(renderWindow, retro_font, &keyboardManager);
    char *GameDLLFullPath = "J:/build/terrific.dll";
    char *TempDLLName = "J:/build/tmp.dll";
    char *LockFileName = "J:/build/lock.tmp";

    auto GameCodeDLL = Win32LoadGameCode(GameDLLFullPath, TempDLLName, LockFileName);
    Game *game = GameCodeDLL.CreateGame(renderWindow, retro_font, &keyboardManager);
    uint32 LoadCounter = 0;

    uint32 m_fps_counter = 0;
    float delta = 0;
    sf::Clock m_fps_clock;
    m_fps_clock.restart();

    sf::Clock clock;
    sf::Clock frame_time_clock;

    sf::Int64 frame_times[5000];
    std::size_t frame_times_index = 0;

    std::fill( std::begin( frame_times ), std::end( frame_times ), 0 );
    int X(0), Y(0);
    while (globalRunning)
    {
        sf::Event event;
        while (renderWindow.pollEvent(event))
        {
            if ((event.type == sf::Event::Closed))
            {
                globalRunning = false;
                break;
            }
            else if ((event.type == sf::Event::MouseMoved))
            {
                X = event.mouseMove.x;
                Y = event.mouseMove.y;
            } 
            else if ((event.type == sf::Event::KeyPressed) |
               (event.type == sf::Event::KeyReleased))
            {
                keyboardManager.ProcessEvent(event);
            }
            sfguiDesktop.HandleEvent(event);
        }

        FILETIME NewDLLWriteTime = Win32GetLastWriteTime(GameDLLFullPath);
        auto t = CompareFileTime(&NewDLLWriteTime, &GameCodeDLL.LastWriteTime);
        if(t != 0 && LoadCounter > 0)
        {
            //char buffer[256];
            //sprintf(buffer, "J:/build/tmp%d.dll", LoadCounter);
	  GameCodeDLL->DestroyGame(GameMemory);
            Win32UnloadGameCode(&GameCodeDLL);
            {
                sf::Clock clockT;
                while (clockT.getElapsedTime().asSeconds() < 0.5f)
                {
                    system("cls");
                    cout << "Unloading Game Code  . . . " << endl;
                }
                cout << "Game Code loaded!" << endl;
                clockT.restart();
            }
            GameCodeDLL = Win32LoadGameCode(GameDLLFullPath, TempDLLName, LockFileName);
            if(GameCodeDLL.IsValid) {
                game = GameCodeDLL.CreateGame(renderWindow, retro_font, &keyboardManager);
            }
            LoadCounter++;
        } 
        else 
        {
            LoadCounter++;
        }

        auto microseconds = clock.getElapsedTime().asMicroseconds();
        //delta = static_cast<float>( microseconds ) / 1000000.f;
        // Only update every 5ms
        delta = static_cast<float>(frame_time_clock.getElapsedTime().asSeconds());
        if( microseconds > 5000 ) {
            game->update(delta);
            sfguiDesktop.Update(delta);
            keyboardManager.Update();
            clock.restart();

            renderWindow.setActive( true );
        }
        renderWindow.clear();

        delta = static_cast<float>(frame_time_clock.getElapsedTime().asSeconds());
        game->draw(delta);
        sfgui.Display(renderWindow);
        renderWindow.draw(text);
        renderWindow.display();

        auto frame_time = frame_time_clock.getElapsedTime().asMicroseconds();
        frame_time_clock.restart();

        frame_times[ frame_times_index ] = frame_time;
        frame_times_index = ( frame_times_index + 1 ) % 5000;

        if( m_fps_clock.getElapsedTime().asMicroseconds() >= 1000000 ) {
            m_fps_clock.restart();

            sf::Int64 total_time = 0;

            for( std::size_t index = 0; index < 5000; ++index ) {
                total_time += frame_times[index];
            }

            std::stringstream sstr;
            sstr << "SFGUI test -- FPS: " << m_fps_counter << " -- Frame Time (microsecs): min: "
            << *std::min_element( frame_times, frame_times + 5000 ) << " max: "
            << *std::max_element( frame_times, frame_times + 5000 ) << " avg: "
            << static_cast<float>( total_time ) / 5000.f;

            renderWindow.setTitle( sstr.str() );
            

            m_fps_counter = 0;
        }

        ++m_fps_counter;
    }
    renderWindow.close();

    Win32UnloadGameCode(&GameCodeDLL);
    {
        sf::Clock clockT;
        while (clockT.getElapsedTime().asSeconds() < 0.5f)
        {
            cout << "Unloading Game Code  . . . " << endl;
        }
        clockT.restart();
    }
    DeleteFile(TempDLLName);

    return 0;
}
Beispiel #14
0
/*******************************************************************************
* ##########   关于Callback回调函数    ##########
*
* 回调函数 Callback functions 是系统程序开发中常用的一种机制。
*
* 在事件\消息驱动型的系统,我们会遇到以下情况:
* (1)系统并不知道应用程序要如何处理事件(如鼠标点击);
* (2)应用程序不知道何时会发生事件(如鼠标何时被点击)。
* 因此,应用程序定义好处理事件的函数,然后将这个函数的指针传递给操作系统,系统保存这个指针,
* 当事件发生时,系统通过指针调用这个函数。
*
* 因为很多情况下事件的发生都是硬件相关的,只有操作系统通过底层驱动才能获取硬件的IO情况。
* 现代操作系统的设计是不允许应用程序直接和硬件通讯的,必须全部由操作系统来进行管理。
*
* 回调函数并不神秘,基本原理就是函数指针。
* 在消息和事件处理、多线程、异步IO等情况下经常会使用到。
* 回调函数机制是“消息驱动型”程序的基本技术。
*
*******************************************************************************/
LONG CALLBACK MainWndProc(
	HWND hwnd, //
	UINT msg, // 消息
	WPARAM wParam, // 消息参数,不同的消息有不同的意义,详见MSDN中每个消息的文档
	LPARAM lParam) // 消息参数,不同的消息有不同的意义,详见MSDN中每个消息的文档
{
	// 注意,是switch-case, 每次这个函数被调用,只会落入到一个case中。
	switch (msg)
	{
		// 当窗口被创建时,收到的第一个消息就是WM_CREATE,
		// 一般收到这个消息处理过程中,可以用来进行一些初始化的工作
	case WM_CREATE:
		CreateGame(hwnd,
			INIT_TIMER_ELAPSE,
			ONE_LEVELS_SCORES,
			SPEEDUP_RATIO,
			MAX_X, MAX_Y,
			INIT_X, INIT_Y,
			INIT_SNAKE_LEN,
			INIT_DIR);
		ReSizeGameWnd(hwnd);
		break;

		// 当系统认为窗口上的GDI对象应该被重绘时,会向窗口发送一个WM_PAINT消息。
		// 当然应用程序也可以通过调用 UpateWindow来主动向窗口发送一个WM_PAINT消息。
		// 所有使用GDI在窗口上绘制图形的程序都 “必须” 写在这里。
		// 如果不是在WM_PAINT消息的处理过程中绘制GDI图形,那么在窗口刷新时就会被新被抹除和覆盖
	case WM_PAINT:

		GamePaint(hwnd);
		break;

	case WM_KEYDOWN:

		OnKeyDown(wParam);
		GamePaint(hwnd);
		break;

	case WM_LBUTTONDOWN:
		OnTimer(hwnd);
		GamePaint(hwnd);
		break;

	case WM_TIMER:

		OnTimer(hwnd);
		GamePaint(hwnd);
		break;

	case WM_DESTROY:
		ExitProcess(0);
		break;

	default:
		break;
	}
	return DefWindowProc(hwnd,
		msg,
		wParam,
		lParam);
}