Ich versuche mein Graphikprogramm mit einem Chat clientprogramm zu kreuzen , habe aber keine ahnung wie das geht. Ich hoffe mir kann jemand helfen

Code des Graphikprogramms:

#pragma comment (lib, "wsock32.lib")

#include "Client.h"
#include "stdio.h"
#include <conio.h>

#include <iostream>
#include <winsock.h>
#include <windows.h>
#include <string>

#include "resource.h" 
#include <windows.h>
#include <math.h>
#include <d3d9.h>
#include <d3dx9.h> // DirectX Extensions Utility library

#define DIRECTINPUT_VERSION 0x0800
#include <dinput.h> // DirectX/Direct Input

#define PI 3.141592654f

typedef struct
{

   float x, y, z;
} point_t;

typedef struct
{
	float neigen;
   float Rotation;   
   point_t Location; 
} camera_t;

LPDIRECT3D9          g_pDirect3D = NULL;
LPDIRECT3DDEVICE9    g_pDirect3D_Device = NULL;
LPDIRECTINPUT8       g_pDI = NULL; // The DirectInput object
LPDIRECTINPUTDEVICE8 g_pKeyboard = NULL; // The keyboard device 
BYTE                 dx_keyboard_state[256]; // DirectInput keyboard state buffer 
camera_t             g_Camera;

LRESULT WINAPI WndProc(HWND hwnd,  UINT msg, WPARAM wParam, LPARAM lParam);
void CalcMatrices(void);
void RenderFrame(void);

HRESULT CreateKeyboardDirectInputDevice(HWND hWnd);
void HandleKeys(void);
HRESULT ReadImmediateData(HWND hWnd);
VOID FreeDirectInput(void);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInst, LPSTR lpCmd, int nShow)
{
   MSG msg;
   WNDCLASSEX wc = {sizeof(WNDCLASSEX), CS_VREDRAW|CS_HREDRAW|CS_OWNDC, WndProc, 0, 0, hInstance, 
                    NULL, NULL, NULL, NULL, "DX9_TUTORIAL3_CLASS", NULL};
   RegisterClassEx(&wc);
   HWND hMainWnd = CreateWindow("DX9_TUTORIAL3_CLASS", "DirectX 9 Tutorial 3 - Simple 3D Room", WS_OVERLAPPEDWINDOW,
                                0, 0, 1024, 768, NULL, NULL, hInstance, NULL);

   g_pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
   D3DPRESENT_PARAMETERS PresentParams;
   memset(&PresentParams, 0, sizeof(D3DPRESENT_PARAMETERS));
   PresentParams.Windowed = TRUE;
   PresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
   PresentParams.EnableAutoDepthStencil = TRUE; // turn on z-buffering
   PresentParams.AutoDepthStencilFormat = D3DFMT_D16;

   g_pDirect3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hMainWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &PresentParams, &g_pDirect3D_Device);
      D3DXMATRIXA16 ProjectionMatrix;
   D3DXMatrixPerspectiveFovLH(&ProjectionMatrix, PI/4, 1.0f, 1.0f, 5000.0f);
   g_pDirect3D_Device->SetTransform(D3DTS_PROJECTION, &ProjectionMatrix);
    D3DXMATRIXA16 WorldTransformMatrix;
   D3DXMatrixIdentity(&WorldTransformMatrix);
   g_pDirect3D_Device->SetTransform(D3DTS_WORLD, &WorldTransformMatrix);
     g_pDirect3D_Device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);    g_pDirect3D_Device->SetRenderState(D3DRS_LIGHTING, FALSE);
   ShowWindow(hMainWnd, nShow);
   UpdateWindow(hMainWnd);
   while(PeekMessage(&msg, NULL, 0, 0, TRUE))
   {
      DispatchMessage(&msg);
      ReadImmediateData(hMainWnd); // get keyboard state
      HandleKeys();
      RenderFrame();
      InvalidateRect(hMainWnd, NULL, FALSE);
   }
   g_pDirect3D_Device->Release();
   g_pDirect3D->Release();
   FreeDirectInput();

   return(0);
}
LRESULT WINAPI WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
   HRESULT hr = S_OK;

   switch(msg)
   {
      case WM_CREATE:
         hr = CreateKeyboardDirectInputDevice(hwnd);

         if(FAILED(hr))
         {
            ::MessageBox(hwnd, "Could not create DirectInput device for keyboard.", "Error", MB_OK);
            PostQuitMessage(0);
            break;
         }
         g_Camera.Location.x = -64;
         g_Camera.Location.y = 40;
         g_Camera.Location.z = -550;
         g_Camera.Rotation = PI/2.0f;

         return(0);
      case WM_DESTROY:
         PostQuitMessage(0);
         return(0);
      case WM_ACTIVATE:
         if(WA_INACTIVE != wParam && g_pKeyboard)
         {
            hr = g_pKeyboard->Acquire();

            #ifdef _DEBUG
            if(!SUCCEEDED(hr))
               MessageBox(hwnd, "Acquire() for DirectInput keyboard failed.", "Error", MB_OK);
            #endif
         }
         return(0);
      case WM_PAINT:
         RenderFrame();
         ValidateRect(hwnd, NULL);

         return(0);
   }
   return(DefWindowProc(hwnd, msg, wParam, lParam));
}
void RenderFrame(void)
{
	float höhe_mauer = 190;
	float x_wall_front1 = -325;
	float z_wall_right1 = -400;
   // give DirectX the vertex information of the scene
   #pragma region Setup Vertices
   #define NUM_VERTICES 220

   #define FRONT_WALL_COLOR 0xa9a9a9;

    struct D3DVERTEX {float x, y, z; DWORD color;} vertices[NUM_VERTICES];

   vertices[0].x = x_wall_front1;
   vertices[0].y = 0; 
   vertices[0].z = 0; 
   vertices[0].color = FRONT_WALL_COLOR;

   vertices[1].x = 0;
   vertices[1].y = 0;
   vertices[1].z = 0; 
   vertices[1].color = FRONT_WALL_COLOR;

   vertices[2].x = 0;
   vertices[2].y = höhe_mauer;
   vertices[2].z = 0; 
   vertices[2].color = FRONT_WALL_COLOR;

   vertices[3].x = x_wall_front1;
   vertices[3].y = 0;
   vertices[3].z = 0; 
   vertices[3].color = FRONT_WALL_COLOR;

   vertices[4].x = 0;
   vertices[4].y = höhe_mauer;
   vertices[4].z = 0; 
   vertices[4].color = FRONT_WALL_COLOR;

   vertices[5].x = x_wall_front1;
   vertices[5].y = höhe_mauer;
   vertices[5].z = 0; 
   vertices[5].color = FRONT_WALL_COLOR;
   LPDIRECT3DVERTEXBUFFER9 pVertexObject = NULL;
   void *pVertexBuffer = NULL;

   if(FAILED(g_pDirect3D_Device->CreateVertexBuffer(NUM_VERTICES*sizeof(D3DVERTEX), 0, 
             D3DFVF_XYZ|D3DFVF_DIFFUSE, D3DPOOL_DEFAULT, &pVertexObject, NULL)))
      return;

   if(FAILED(pVertexObject->Lock(0, NUM_VERTICES*sizeof(D3DVERTEX), &pVertexBuffer, 0)))
      return;
   memcpy(pVertexBuffer, vertices, NUM_VERTICES*sizeof(D3DVERTEX));
   pVertexObject->Unlock();
   #pragma endregion 

     #pragma region Render Scene
   g_pDirect3D_Device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); // clear frame
   if(SUCCEEDED(g_pDirect3D_Device->BeginScene()))
   {
      CalcMatrices();
      g_pDirect3D_Device->SetStreamSource(0, pVertexObject, 0, sizeof(D3DVERTEX));
      g_pDirect3D_Device->SetFVF(D3DFVF_XYZ|D3DFVF_DIFFUSE);
      g_pDirect3D_Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, NUM_VERTICES/3);
      g_pDirect3D_Device->EndScene();
   }

   g_pDirect3D_Device->Present(NULL, NULL, NULL, NULL);
   pVertexObject->Release();
   #pragma endregion
}

void CalcMatrices(void)
{
   D3DXMATRIXA16 ViewMatrix;
   D3DXVECTOR3 EyePoint(g_Camera.Location.x, g_Camera.Location.y, g_Camera.Location.z);
   D3DXVECTOR3 LookAt(g_Camera.Location.x+cos(g_Camera.Rotation), g_Camera.Location.y+tan(g_Camera.neigen), g_Camera.Location.z+sin(g_Camera.Rotation));
   D3DXVECTOR3 UpVector(0.0f, 1.0f, 0.0f);
   D3DXMatrixLookAtLH(&ViewMatrix, &EyePoint, &LookAt, &UpVector);
   g_pDirect3D_Device->SetTransform(D3DTS_VIEW, &ViewMatrix); 
}
HRESULT CreateKeyboardDirectInputDevice(HWND hWnd)
{
    HRESULT hr;
    BOOL    bExclusive;
    BOOL    bForeground;
    BOOL    bImmediate;
    BOOL    bDisableWindowsKey;
    DWORD   dwCoopFlags;

    FreeDirectInput();

    bExclusive         = FALSE;
    bForeground        = TRUE;
    bImmediate         = TRUE;
    bDisableWindowsKey = FALSE;

    if( bExclusive )
        dwCoopFlags = DISCL_EXCLUSIVE;
    else
        dwCoopFlags = DISCL_NONEXCLUSIVE;

    if( bForeground )
        dwCoopFlags |= DISCL_FOREGROUND;
    else
        dwCoopFlags |= DISCL_BACKGROUND;

    if( bDisableWindowsKey && !bExclusive && bForeground )
        dwCoopFlags |= DISCL_NOWINKEY;

    if( FAILED( hr = DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION, 
                                         IID_IDirectInput8, (VOID**)&g_pDI, NULL ) ) )
        return hr;

    if( FAILED( hr = g_pDI->CreateDevice( GUID_SysKeyboard, &g_pKeyboard, NULL ) ) )
        return hr;

    if( FAILED( hr = g_pKeyboard->SetDataFormat( &c_dfDIKeyboard ) ) )
        return hr;

      hr = g_pKeyboard->SetCooperativeLevel( hWnd, dwCoopFlags );
    if( hr == DIERR_UNSUPPORTED && !bForeground && bExclusive )
    {
        FreeDirectInput();
        MessageBox( hWnd, "SetCooperativeLevel() returned DIERR_UNSUPPORTED.\n"
                          "For security reasons, background exclusive keyboard\n"
                          "access is not allowed.", "Keyboard", MB_OK );
        return S_OK;
    }

    if( FAILED(hr) )
        return hr;

        hr = g_pKeyboard->Acquire(); 

    return S_OK;
}

HRESULT ReadImmediateData(HWND hWnd)
{
    HRESULT hr;

    if( NULL == g_pKeyboard ) 
        return S_OK;

    ZeroMemory( dx_keyboard_state, sizeof(dx_keyboard_state) );
    hr = g_pKeyboard->GetDeviceState( sizeof(dx_keyboard_state), dx_keyboard_state );
    if( FAILED(hr) ) 
    {
        hr = g_pKeyboard->Acquire();
        while( hr == DIERR_INPUTLOST ) 
            hr = g_pKeyboard->Acquire();
        return S_OK; 
    }

    return S_OK;
}
void HandleKeys(void)
{
...

}

#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }

VOID FreeDirectInput(void)
{
      if( g_pKeyboard ) 
        g_pKeyboard->Unacquire();

    // Release any DirectInput objects.
    SAFE_RELEASE( g_pKeyboard );
    SAFE_RELEASE( g_pDI );
}

Code des Chat-Clients:

#include "Client.h"

#include <conio.h>

Client Client::m_Instance;
bool Client::StartUp()
{
	WSADATA wsa;
	int rc = WSAStartup(MAKEWORD(2, 0), &wsa);
	if(rc == SOCKET_ERROR)
	{
		std::cout << "Fehler beim Starten des Servers..." << std::endl;
		return false;
	}
	return true;
}
bool Client::CreateConnectSocket(char* argv[2])
{
	int rc;

	s = socket(AF_INET, SOCK_STREAM, 0);
	if(s == INVALID_SOCKET)
	{
		std::cout << "Socket konnte nicht erstellt werden.\n";
		return false;
	}

	addr.sin_addr.s_addr = inet_addr("192.168.2.107");
	addr.sin_port        = htons(111);
	addr.sin_family      = AF_INET;

	rc = connect(s, (SOCKADDR*)&addr, sizeof(SOCKADDR));
	if(rc == SOCKET_ERROR)
	{
		std::cout << "Verbindung fehlgeschlagen.\n";
		return false;
	}

	return true;
}
int Client::ClientMain(char* argv[2])
{
	if(!StartUp())
		return 1;

	if(!CreateConnectSocket(argv))
		return 2;

	int         rc = 0;
	fd_set      fdSetRead;
	char        buffer[1024];
	char        buffera[1024];
	char        c;
	int         bufpos = 0;
	TIMEVAL     timeout;
	bool        mainloop = true;

	std::cout << "Alles erfolgreich gestartet und verbunden.\n";

	while(rc != SOCKET_ERROR && mainloop)
	{
		while(kbhit())
		{
			c = getch(); 
			if(c==13)
			{ 
				if(strcmp(buffer, "exit") == 0)
				{
					mainloop = false;
					break;
				}
				rc = send(s,buffer,bufpos, 0); 
			    bufpos = 0; 
			}
			else
				buffer[bufpos++]=c; 
		} 
		buffer[bufpos] = '\0'; 

		FD_ZERO(&fdSetRead);
		FD_SET(s, &fdSetRead);

		timeout.tv_sec  = 0;
		timeout.tv_usec = 0;

		while((rc = select(0, &fdSetRead, 0, 0, &timeout)) > 0)
		{
			rc = recv(s, buffera, 1023, 0);

			if(rc == 0)
			{
				std::cout << "Der Server hat die Verbindung unterbrochen.\n";
				break;
			}
			else if(rc == SOCKET_ERROR)
			{
				std::cout << "Empfangen der Nachricht fehlgeschlagen: " << WSAGetLastError() << '\n';
				break;
			}

			buffera[rc] = '\0';
			std::cout << buffera << '\n';
		}	

		Sleep(1);
	}

	std::cout << "Client wird beendet.\n";

	closesocket(s);
	WSACleanup();

	return 0;
}

Ich hoffe es kann mir jemand helfen

Viel Spass weiterhin.

• Zu viel Code
• Keine Eigeninitiative

Lies dir bitte durch, wie man Fragen richtig stellt. Fast alle dieser Punkte hast du nämlich missachtet.