[Release] Turnier System

[yannick2008]

Hier Release ich mal mein Turnier System. Es ist noch nicht fertig und erfordert evtl. noch einige Stunden arbeit damit es wirklich fertig ist.

Was muss noch gemacht werden bzw. beachtet werden?

Ich benutzt als "Kampfwelt" die normale Arena, sprich - WI_WORLD_ARENA.
Dies müsst ihr eventuell in einigen Code Snippets ändern.

In der Structur für die Angemeldeten User wird der Name des Spielers gespeichert. Dies kann man löschen und an den Spielernamen via GetPlayerInfo() rankommen.

Die Turnier Tabelle klappt noch nicht richtig. Hab hierzu mal im Zug auf der Fahrt nachhause codeschnippsel aufn Blatt papier geschrieben. Werde das eventuell morgen hier reineditieren.

Ihr müsst bei einem NPC die Menüs adden:
AddMenu( MMI_TOURNAMENT_MENU );
AddMenu( MMI_TOURNAMENT_TABLE );



Sourcecode:

 Spoiler

Im Worldserver Projekt adden wir diese zwei neuen Dateien.

Tournament.cpp

 Spoiler

#include "stdafx.h"
#include "Tournament.h"

#include "User.h"
#include "worldmng.h"
#include "DPCoreClient.h"

extern CWorldMng	g_WorldMng;
extern CUserMng		g_UserMng;
extern CDPCoreClient	g_DPCoreClient;

#ifdef __TOURNAMENT

CTournamentMng::CTournamentMng()
{
	m_dwTick = g_tmCurrent;
	m_nRound = 1;
	m_bState = STATE_REGISTER;
}

CTournamentMng::~CTournamentMng()
{
}

CTournamentMng* CTournamentMng::GetInstance( void )
{
	static CTournamentMng sTournamentMng;
	return &sTournamentMng;
}

void CTournamentMng::AddMember( CUser* pUser )
{
	if( !IsValidObj( pUser ) )
		return;

	if( m_bState != STATE_REGISTER )
		return;


	if( MAX_TOURNAMENT_ENTRYS <= (int)m_vecMember.size() )
	{
		pUser->AddText( "Es sind bereits zuviele Spieler angemeldet." );
		return;
	}


	if( ((CMover*)pUser)->GetLevel() < MIN_TOURNAMENT_LEVEL )
	{
		pUser->AddText( "Dein Level ist zu niedrig." );
		return;
	}

	
	for( int i = 0; i < (int)m_vecMember.size(); i++ )
	{
		if( pUser->m_idPlayer == m_vecMember.at(i).idPlayer )
		{
			pUser->AddText( "Du bist bereits angemeldet." );
			return;
		}
	}

	
	__TOURNAMENT_MEMBER srTournamentMember;
	srTournamentMember.idPlayer = pUser->m_idPlayer;

	memcpy( srTournamentMember.szName, ((CMover*)pUser)->GetName(), MAX_PLAYER );
	srTournamentMember.nJob = pUser->m_nJob;
	m_vecMember.push_back( srTournamentMember );
	pUser->AddText( "Du hast dich erfolgreich für das Turnier registriert." );
}

void CTournamentMng::Process()
{
	switch( m_bState )
	{
		case STATE_END:
			return;
		case STATE_REGISTER:
		{
			if( GetStartTime() < g_tmCurrent )
			{
				if( StartTournament() )
				{
					m_dwTick = g_tmCurrent;
					m_bState = STATE_WAIT;
					for( int i = 0; i < (int)m_vecMember.size(); i++ )
					{
						SendTime( m_vecMember.at(i).idPlayer, GetMatchStartTime() - g_tmCurrent, 1 );
					}
				}
			}
			break;
		}
		case STATE_WAIT:
		{
			if( GetMatchStartTime() < g_tmCurrent )
			{
				InitializeMatch();
				m_bState = STATE_MATCH;
			}
			break;
		}
		case STATE_MATCH:
		{
			if( m_mapMatch.size() <= NULL )
			{
				int nMemberNow = 0;
				for( int i = 0; i < (int)m_vecMember.size();i++ )
				{
					m_vecMember.at(i).nMatchNum = 0;
					if( m_vecMember.at(i).bAvaible == TRUE )
					{
						nMemberNow++;
						TeleportBack( m_vecMember.at(i).idPlayer );
					}
				}
				
				if( nMemberNow > 1 )
				{
					m_nRound++;
					m_dwTick = g_tmCurrent;
					m_bState = STATE_WAIT;
					for( int i = 0; i < (int)m_vecMember.size(); i++ )
					{
						if( m_vecMember.at(i).bAvaible )
							SendTime( m_vecMember.at(i).idPlayer, GetMatchStartTime() - g_tmCurrent, 1 );
					}
				}
				else
				{
					m_bState = STATE_END;
					g_DPCoreClient.SendSystem("Das Turnier ist zuende!!!!!!");
					//EndTournament();
				}
				return;
			}
			vector<u_long> xVector;
			for( TOURNAMENTMATCH::iterator it = m_mapMatch.begin(); it != m_mapMatch.end(); it++ )
			{
				if( !(it->second) ) return;

				if( it->second->m_bState == MATCH_RUN )
				{
					it->second->Process();			
				}
				else if( it->second->m_bState == MATCH_END )
				{
					xVector.push_back( it->first );
				}
			}
			for( int i = 0; i < (int)xVector.size(); i++ )
			{
				TOURNAMENTMATCH::iterator xIt = m_mapMatch.find( (u_long)xVector.at(i) );
				m_mapMatch.erase( xIt );
			}
		}
		break;
	}
}

BOOLEAN CTournamentMng::StartTournament()
{
	for( int i = 0; i < (int)m_vecMember.size(); i++ )
	{
		CMover* pMover = prj.GetUserByID( m_vecMember.at(i).idPlayer );
		if( !IsValidObj( pMover ) )
			m_vecMember.erase( m_vecMember.begin()+i );
	}


	if( m_vecMember.size() < MIN_TOURNAMENT_ENTRYS )
	{
		m_dwTick = g_tmCurrent;
		return FALSE;
	}

	if( ( m_vecMember.size() % 2 ) != 0 )
	{
		__TOURNAMENT_MEMBER srTournamentMember;
		srTournamentMember.idPlayer = 0;
		memcpy( srTournamentMember.szName, "Dummy", MAX_PLAYER );
		srTournamentMember.nJob = 0;
		m_vecMember.push_back( srTournamentMember );
	}


	random_shuffle( m_vecMember.begin(), m_vecMember.end() );

	for( int i = 0; i < (int)m_vecMember.size(); i++ )
	{
		m_vecMember.at(i).bAvaible = TRUE;
		m_vecMember.at(i).nStartPos = i + 1;
	}


	g_DPCoreClient.SendSystem("Das Tournament hat begonnen!");
	return TRUE;
}

void CTournamentMng::InitializeMatch()
{
	vector<u_long> vecMember;
	CalculateMember(vecMember);

	for( int i = 0; i < (int)vecMember.size(); i+=2 )
	{
		Error( "m_vecMember.size() %i, vecMember.size() %i, i %i", (int)m_vecMember.size(), vecMember.size(), i );

		CTournamentMatch* pMatch = new CTournamentMatch;
		int nCalcMatchId;
		CUser* pUser1 = (CUser*)prj.GetUserByID( vecMember.at(i) );
		CUser* pUser2 = (CUser*)prj.GetUserByID( vecMember.at(i+1) );

		do
		{
			nCalcMatchId = GenerateMatchId( i / 2 + 1 );
		}
		while( (m_mapMatch.find( nCalcMatchId ) != m_mapMatch.end() ) );
		pMatch->m_nMatchId = nCalcMatchId;
		//MatchID Generieren und zuweisen.

		pMatch->CreateRoomLayer();
		//Erstelle Raum für den Match

		pMatch->m_idPlayer1 = (u_long)vecMember.at(i);
		pMatch->m_idPlayer2 = (u_long)vecMember.at(i+1);
		//Fülle Match mit UserID

		for( int j = 0; j < (int)m_vecMember.size(); j++ )
		{
			if( m_vecMember.at(i).idPlayer == (u_long)vecMember.at(i) )
				m_vecMember.at(i).nMatchNum = pMatch->m_nMatchId;

			if( m_vecMember.at(i).idPlayer == (u_long)vecMember.at(i+1) )
				m_vecMember.at(i).nMatchNum = pMatch->m_nMatchId;

		}//Weise User MatchID zu

		if( IsValidObj( pUser1 ) )
		{
			TeleportToMatch( pUser1->m_idPlayer, nCalcMatchId );
			SendTime( (u_long)vecMember.at(i), pMatch->GetEndTime() - g_tmCurrent, 2 );
		}
		if( IsValidObj( pUser2 ) )
		{
			TeleportToMatch( pUser2->m_idPlayer, nCalcMatchId );
			SendTime( (u_long)vecMember.at(i+1), pMatch->GetEndTime() - g_tmCurrent, 2 );
		}
		//Teleportiere User || Sende Timer

		m_mapMatch.insert( make_pair( pMatch->m_nMatchId, pMatch ));
		//Fertig
	}
}

void CTournamentMng::RemoveMember( u_long idPlayer )
{
	int nTmpRank = 0;
	for( int i = 0; i < (int)m_vecMember.size(); i++ )
		if( m_vecMember.at(i).idPlayer == idPlayer )
		{
			m_vecMember.at(i).bAvaible = FALSE;
			TeleportBack( idPlayer );
		}
}

void CTournamentMng::CalculateMember(vector<u_long>& vecRoundMember)
{
	int nLoops = (int)m_vecMember.size();

	for( int i = 1; i < m_nRound; i++ )
	{
		if( ( nLoops % 2 ) == 0 )
			nLoops /= 2;
		else
			nLoops = ( nLoops + 1 ) / 2;
	}

	for( int i = 0; i < nLoops; i++ )
	{
		BOOLEAN bFound = FALSE;
		for( int j = 0; j < (int)m_vecMember.size(); j++ )
		{
			if( !m_vecMember.at(j).bAvaible )
				continue;

			int nPos = m_vecMember.at(j).nStartPos;
			for( int k = 1; k < m_nRound; k++ )
			{
				if( ( nPos % 2 ) == 0 )
					nPos /= 2;
				else
					nPos = ( nPos + 1 ) / 2;
			}
			nPos--;
			if( i == nPos )
			{
				vecRoundMember.push_back( m_vecMember.at(j).idPlayer );
				bFound = TRUE;
				continue;
			}
		}
		if( !bFound )
		{
			vecRoundMember.push_back( 0 );
		}
	}
	if( vecRoundMember.size() % 2 != 0 )
		vecRoundMember.push_back( 0 );
}

void CTournamentMng::TeleportToMatch( u_long idPlayer, int nMatchId )
{
	CUser* pUser = (CUser*)prj.GetUserByID( idPlayer );
	if( IsValidObj( pUser ) )
	{
		CWorld* pWorld = g_WorldMng.GetWorld( MATCH_WORLD );
		if( pWorld )
			if( pWorld->m_linkMap.GetLinkMap( static_cast<int>( nMatchId ) ) )
				pUser->REPLACE( g_uIdofMulti, MATCH_WORLD, D3DXVECTOR3( 549.000000f, 135.364243f, 505.000000f ), REPLACE_NORMAL, static_cast<int>( nMatchId ) );
	}
}

void CTournamentMng::TeleportBack( u_long idPlayer )
{
	CUser* pUser = (CUser*)prj.GetUserByID( idPlayer );
	if( IsValidObj( pUser ) )
	{
		CWorld* pWorld = g_WorldMng.GetWorld( WI_WORLD_MADRIGAL );
		if( pWorld )
			if( pWorld->m_linkMap.GetLinkMap( static_cast<int>( nDefaultLayer ) ) )
				pUser->Replace( g_uIdofMulti, WI_WORLD_MADRIGAL, D3DXVECTOR3( 6971.984f, 99.8f, 3336.884f ), REPLACE_NORMAL, static_cast<int>( nDefaultLayer ) );
		pUser->SendTournamentRoundOver();
	}
}

BOOLEAN CTournamentMng::IsSuddenDeath( CMover* pMover )
{
	for( TOURNAMENTMATCH::iterator it = m_mapMatch.begin(); it != m_mapMatch.end(); it++ )
	{
		if( ( it->second->m_bMatchState == MATCH_RUN_HP || it->second->m_bMatchState == MATCH_RUN_MOVER ) && ( it->second->m_idPlayer1 == pMover->m_idPlayer || it->second->m_idPlayer2 == pMover->m_idPlayer ))
			return TRUE;
	}
	return FALSE;
}

void CTournamentMng::SendMenu( CUser* pUser )
{
	if( IsValidObj( pUser ) )
	{
		if( m_bState != STATE_REGISTER )
		{
			pUser->AddText( "Das Turnier hat bereits begonnen" );
			return;
		}

		DWORD dwTimeLeft = GetStartTime() - g_tmCurrent;

		pUser->SendTournamentMenuView( dwTimeLeft, m_vecMember );
	}
}

void CTournamentMng::SendTime( u_long idPlayer, DWORD dwTimeLeft, int nType )
{
	CUser* pUser = (CUser*)prj.GetUserByID( idPlayer );
	if( IsValidObj( pUser ) )
		pUser->SendTournamentTime( dwTimeLeft, nType, m_nRound );
}

void CTournamentMng::SendTable( CUser* pUser )
{
	if( IsValidObj( pUser ) )
	{
		if( m_bState == STATE_REGISTER )
		{
			pUser->AddText( "Das Turnier hat noch nicht begonnen" );
			return;
		}
		vector<__TABLE_VIEW> vecMemberList;
		for( int i = 0; i < (int)m_vecMemberRanking.size(); i++ )
		{
				if( m_vecMemberRanking.at(i).nPlace > 7 )
					continue;

				__TABLE_VIEW srTableView;
				memcpy( srTableView.szName, m_vecMemberRanking.at(i).szName, MAX_PLAYER );
				srTableView.nJob = m_vecMemberRanking.at(i).nJob;
				srTableView.nPlace = m_vecMemberRanking.at(i).nPlace;
				vecMemberList.push_back( srTableView );
		}
		pUser->SendTournamentTableView( vecMemberList );
	}
}
BOOLEAN CTournamentMng::IsMatch( CUser* pUser )
{
	if( IsValidObj(pUser) && ( m_bState == STATE_MATCH ) )
	{
		for( int i = 0; i < (int)m_vecMember.size(); i++ )
			if( pUser->m_idPlayer == m_vecMember.at(i).idPlayer && m_vecMember.at(i).bAvaible && pUser->GetWorld()->m_dwWorldID == MATCH_WORLD )
				return TRUE;
	}
	return FALSE;
}

void CTournamentMng::UpdateRanking( u_long idPlayer )
{
	if( idPlayer == 0 )
		return;

	for( int i = 0; i < (int)m_vecMember.size(); i++ )
	{
		if( m_vecMember.at(i).idPlayer == idPlayer )
		{
			__TABLE_VIEW srTblView;
			memcpy(srTblView.szName, m_vecMember.at(i).szName, MAX_PLAYER);
			srTblView.nJob = m_vecMember.at(i).nJob;

			int nTmpRank = m_vecMember.at(i).nStartPos;

			int nTmpMember = m_vecMember.size();
			int nCntMember = 0;
			if( m_nRound != 1 )
				nCntMember += m_vecMember.size();

			for( int i = 2; i < m_nRound; i++ )
			{
				if( nTmpMember % 2 == 0 )
					nTmpMember /= 2;
				else
					nTmpMember = (nTmpMember + 1) / 2;
				nCntMember += nTmpMember;
			}

			for( int i = 1; i < m_nRound; i++ )
				if( nTmpRank % 2 == 0 )
					nTmpRank /= 2;
				else
					nTmpRank = (nTmpRank + 1) / 2;
			nTmpRank += nCntMember;

			srTblView.nPlace = nTmpRank;

			m_vecMemberRanking.push_back( srTblView );
		}
	}
}
CTournamentMatch::CTournamentMatch()
{
	m_bMatchState = MATCH_RUN_BEGIN;
	m_dwTick = g_tmCurrent;
	m_dwMatchTick = g_tmCurrent;
	m_bState = MATCH_RUN;
}

CTournamentMatch::~CTournamentMatch()
{
}

void CTournamentMatch::Process()
{
	if( m_bState == MATCH_END )
		return;

	CUser* pUser1 = (CUser*)prj.GetUserByID( m_idPlayer1 );
	CUser* pUser2 = (CUser*)prj.GetUserByID( m_idPlayer2 );
	CTournamentMng* pMng = CTournamentMng::GetInstance();

	BOOLEAN bAvaiblePlayer1 = TRUE;
	BOOLEAN bAvaiblePlayer2 = TRUE;
	if( !IsValidObj( pUser1 ) )
	{
		pMng->RemoveMember( m_idPlayer1 );
		m_bState = MATCH_END;
		if( IsValidObj( pUser2 ) )
			pMng->TeleportBack( m_idPlayer2 );
		bAvaiblePlayer1 = FALSE;
	}


	if( !IsValidObj( pUser2 ) )
	{
		pMng->RemoveMember( m_idPlayer2 );
		m_bState = MATCH_END;
		if( IsValidObj( pUser1 ) )
			pMng->TeleportBack( m_idPlayer1 );
		bAvaiblePlayer2 = FALSE;
	}

	CMover* pMover1 = (CMover*)pUser1;
	CMover* pMover2 = (CMover*)pUser2;

	if( m_bState != MATCH_END )
	{
		if( pMover1->IsDie() || pMover1->GetWorld()->m_dwWorldID != MATCH_WORLD )
		{
			pMng->RemoveMember( m_idPlayer1 );
			m_bState = MATCH_END;
			pMng->TeleportBack( m_idPlayer2 );
			bAvaiblePlayer1 = FALSE;
		}
	
		if( pMover2->IsDie() || pMover2->GetWorld()->m_dwWorldID != MATCH_WORLD )
		{
			pMng->RemoveMember( m_idPlayer2 );
			m_bState = MATCH_END;
			pMng->TeleportBack( m_idPlayer1 );
			bAvaiblePlayer2 = FALSE;
		}
		if( GetEndTime() < g_tmCurrent )
		{
			if( pMover1->GetHitPointPercent() > pMover2->m_nHitPoint )
			{
				pMng->RemoveMember( m_idPlayer2 );
				pMng->TeleportBack( m_idPlayer1 );
				bAvaiblePlayer2 = FALSE;
			}
			else if( pMover2->GetHitPointPercent() > pMover1->m_nHitPoint )
			{
				pMng->RemoveMember( m_idPlayer1 );
				pMng->TeleportBack( m_idPlayer2 );
				bAvaiblePlayer1 = FALSE;
			}
			m_bState = MATCH_END;
		}
		if( GetHPTime() < g_tmCurrent && m_bMatchState == MATCH_RUN_BEGIN )
		{
			m_bMatchState = MATCH_RUN_HP;
			m_dwMatchTick = g_tmCurrent;
		}
		else if( GetMoverTime() < g_tmCurrent && m_bMatchState == MATCH_RUN_HP )
		{
			m_bMatchState = MATCH_RUN_MOVER;
			m_dwMatchTick = g_tmCurrent;
			for( int i = 0; i < 10; i++ )
			{
				CreateMover();
			}
		}
	}
	else
	{
		if( m_bMatchState == MATCH_RUN_MOVER )
			DestroyMover();
	}
	if( m_bState == MATCH_END )
	{
		pMng->UpdateRanking( m_idPlayer1 );
		pMng->UpdateRanking( m_idPlayer2 );
	}

}

void CTournamentMatch::CreateRoomLayer()
{
	CWorld* pWorld = g_WorldMng.GetWorld( MATCH_WORLD );
	if( pWorld && !pWorld->m_linkMap.GetLinkMap( static_cast<int>( m_nMatchId ) ) )
		pWorld->CreateLayer( static_cast<int>( m_nMatchId ) );
}

void CTournamentMatch::CreateMover()
{
	MoverProp* pMoverProp = prj.GetMoverPropEx( 22 );
	CWorld* pWorld = g_WorldMng.GetWorld( MATCH_WORLD );
	if( pWorld && pMoverProp && pMoverProp->dwID != 0 )
	{
		D3DXVECTOR3 vPos( 549.000000f, 135.364243f, 505.000000f );
		CObj* pObj	= CreateObj( D3DDEVICE, OT_MOVER, pMoverProp->dwID );
		pObj->SetPos( vPos );
		pObj->InitMotion( MTI_STAND );
		pObj->UpdateLocalMatrix();
		((CMover*)pObj)->m_bActiveAttack = TRUE;
		((CMover*)pObj)->AddItToGlobalId();
		((CMover*)pObj)->m_nStr = 4000000;
		((CMover*)pObj)->m_nDex = 4000000;
		((CMover*)pObj)->m_nInt = 4000000;
		((CMover*)pObj)->m_nSta = 4000000;
		pWorld->ADDOBJ( pObj, FALSE, m_nMatchId );
		m_vecMover.push_back( ((CMover*)pObj)->GetId() );
	}
}

void CTournamentMatch::DestroyMover()
{
	for( int i = 0; i < (int)m_vecMover.size(); i++ )
	{
		CMover* pMover = prj.GetMover( m_vecMover.at(i) );
		if( IsValidObj( pMover ) )
			pMover->Delete();
	}
}
#endif __TOURNAMENT

Tournament.h

 Spoiler

#ifndef TOURNAMENT_H
#define TOURNAMENT_H

#ifdef __TOURNAMENT

#define MAX_TOURNAMENT_ENTRYS		32
#define	MIN_TOURNAMENT_ENTRYS		2
#define	MIN_TOURNAMENT_LEVEL		1
#define MATCH_WORLD					WI_WORLD_ARENA

#ifdef __WORLDSERVER

enum{ STATE_REGISTER, STATE_WAIT, STATE_MATCH, STATE_END, MATCH_RUN, MATCH_END, MATCH_RUN_BEGIN, MATCH_RUN_HP, MATCH_RUN_MOVER };


struct __TOURNAMENT_MEMBER
{
	u_long		idPlayer;
	char		szName[MAX_PLAYER];
	int			nJob;
	int			nMatchNum;
	int			nStartPos;
	BOOLEAN		bAvaible;
};

typedef struct __MEMBER_LIST
{
	LPTSTR	szName;
	int		nLevel;
}
*MEMBER_LIST;

struct __TABLE_VIEW
{
	char	szName[MAX_PLAYER];
	int		nJob;
	int		nPlace;
};

class CTournamentMatch
{
public:
			CTournamentMatch();
	virtual ~CTournamentMatch();
	void	 Process();
	DWORD	GetEndTime( void )	{	return( m_dwTick + ( 60 * 1000 ) );	}
	DWORD	GetHPTime( void )	{	return( m_dwMatchTick + ( 10 * 1000 ) );	}
	DWORD	GetMoverTime( void )	{	return( m_dwMatchTick + ( 10 * 1000 ) );	}
	void	CreateRoomLayer();
	void	CreateMover();
	void	DestroyMover();

	u_long		m_idPlayer1;
	u_long		m_idPlayer2;
	int			m_nMatchId;
	BYTE		m_bState;
	DWORD		m_dwTick;
	DWORD		m_dwMatchTick;
	BYTE		m_bMatchState;
	vector<DWORD>	m_vecMover;
};

typedef map<u_long, CTournamentMatch*> TOURNAMENTMATCH;

class CTournamentMng
{
public:
			CTournamentMng();
	virtual ~CTournamentMng();
	static	CTournamentMng* GetInstance( void );
	void	Process();
	void	AddMember( CUser* pUser);
	BOOLEAN	StartTournament();
	DWORD	GetStartTime( void )	{	return( m_dwTick + ( 60 * 1000 ) );	}
	DWORD	GetMatchStartTime( void )	{	return( m_dwTick + ( 15 * 1000 )  );	}
	int		GenerateMatchId( int nValue = 1 ) { return xRandom( 0, 4000000000 ) * nValue; }
	void	RemoveMember( u_long idPlayer );
	void	InitializeMatch();
	void	CalculateMember(vector<u_long>& vecMemberRound);
	void	TeleportToMatch( u_long idPlayer, int nMatchId );
	BOOLEAN	IsSuddenDeath( CMover* pMover );
	BOOLEAN IsMatch( CUser* pUser );
	void	TeleportBack( u_long idPlayer );
	void	SendMenu( CUser* pUser );
	void	SendTime( u_long idPlayer, DWORD dwTimeLeft, int nType );
	void	SendTable( CUser* pUser );
	void	UpdateRanking( u_long idPlayer );
	vector<__TOURNAMENT_MEMBER> m_vecMember;
	vector<__TABLE_VIEW>		m_vecMemberRanking;
	BYTE			m_bState;
	DWORD			m_dwTick;
	TOURNAMENTMATCH m_mapMatch;
	int				m_nRound;
};

#endif //__WORLDSERVER
#endif //__TOURNAMENT
#endif //TOURNAMENT_H

Im Neuz Projekt adden wir diese zwei Dateien:

WndTournament.cpp

 Spoiler

#include "stdafx.h"
#include "WndColosseum.h"
#ifdef	__TOURNAMENT

#include "resData.h"
#include "defineText.h"
#include "DPClient.h"

extern	CDPClient			g_DPlay;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CWndTournamentMenu::CWndTournamentMenu()
{ 
}

CWndTournamentMenu::~CWndTournamentMenu() 
{ 
} 

void CWndTournamentMenu::OnInitialUpdate() 
{ 
	CWndNeuz::OnInitialUpdate(); 

	MoveParentCenter();
} 

BOOL CWndTournamentMenu::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ ) 
{
	pWndList = (CWndListBox*)GetDlgItem( WIDC_LISTBOX1 );
	return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_TOURNAMENT_MENU, 0, CPoint( 0, 0 ), pWndParent );
} 

BOOL CWndTournamentMenu::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ) 
{ 
	return CWndNeuz::OnCommand( nID, dwMessage, pWndBase ); 
} 

void CWndTournamentMenu::OnSize( UINT nType, int cx, int cy )
{ 
	CWndNeuz::OnSize( nType, cx, cy ); 
} 



BOOL CWndTournamentMenu::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult ) 
{ 
	if( nID == WIDC_CLOSE )
	{
		Destroy();
	}
	else
	if( nID == WIDC_BUTTON1 )
	{
		Destroy();
		g_DPlay.SendTournamentRegister();
	}
	else
	if( nID == WIDC_BUTTON2 )
	{
		g_DPlay.SendTournamentMenuView();
	}
	
	return CWndNeuz::OnChildNotify( message, nID, pLResult ); 
} 

void CWndTournamentMenu::OnDraw( C2DRender* p2DRender ) 
{ 
	CWndStatic* pStatic	= (CWndStatic *)GetDlgItem( WIDC_STATIC2 );
	if( m_tCurrentTime > 0 )
	{
		CString str1;
		CString str2;
		CString str3;
		CString str;
			
		str1.Format(prj.GetText(TID_PK_LIMIT_HOUR), m_ct.GetHours() );
		str2.Format(prj.GetText(TID_PK_LIMIT_MINUTE), m_ct.GetMinutes() );
		str3.Format(prj.GetText(TID_PK_LIMIT_SECOND), m_ct.GetSeconds() );

		str.Format( "%s %s %s", str1, str2, str3 );
		pStatic->SetTitle(str);
	}
	else
	{
		pStatic->SetTitle("          -");
	}

	if( ( m_ct.GetHours() + m_ct.GetMinutes() <= 0 ) && m_ct.GetSeconds() <= 10 )
		pStatic->m_dwColor = D3DCOLOR_ARGB( 255, 229, 0, 0 );

	pStatic = (CWndStatic*)GetDlgItem( WIDC_STATIC5 );
	CString str;
	str.Format( "%i", m_nMemberCount );
	pStatic->SetTitle(str);
} 

BOOL CWndTournamentMenu::Process() 
{
	m_tCurrentTime = ( m_tEndTime - g_tmCurrent );
	
	if( m_tEndTime && m_tCurrentTime > 0 )
	{
		m_ct = m_tCurrentTime / 1000.0f;
	}
	
	return TRUE;
}

void CWndTournamentMenu::InitializeData( DWORD dwMemberCount, DWORD dwTimeLeft )
{
	pWndList = new CWndListBox;
	pWndList = (CWndListBox*)GetDlgItem( WIDC_LISTBOX1 );
	for( int i = 0; i < pWndList->GetCount(); i++ )
		pWndList->DeleteString( i );

	m_nMemberCount = (int)dwMemberCount;

	m_tCurrentTime = 0;
	m_tEndTime = g_tmCurrent + dwTimeLeft;
}

void CWndTournamentMenu::InsertMember( const char szName[],int nNum )
{
	CWndListBox* pWndList = (CWndListBox*)GetDlgItem( WIDC_LISTBOX1 );
	
	CString str;
	str.Format( "No.%.2d		%s", nNum, szName );
	pWndList->AddString(str);
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CWndTournamentTimer::CWndTournamentTimer()
{
}

CWndTournamentTimer::~CWndTournamentTimer()
{
}

void CWndTournamentTimer::OnInitialUpdate() 
{ 
	CWndNeuz::OnInitialUpdate(); 

	CRect rectRoot = m_pWndRoot->GetLayoutRect();
	CRect rectWindow = GetWindowRect();
	CPoint point( ( rectRoot.right - rectWindow.Width() ) / 2, 15 );
	Move( point );

	DWORD dwStyle = GetWndStyle();
	dwStyle &= (~WBS_MOVE);
	SetWndStyle( dwStyle );
} 

BOOL CWndTournamentTimer::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ ) 
{
	return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_NEWCOLOSTARTREADY1, 0, CPoint( 0, 0 ), pWndParent );
} 

BOOL CWndTournamentTimer::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ) 
{ 
	return CWndNeuz::OnCommand( nID, dwMessage, pWndBase ); 
} 

void CWndTournamentTimer::OnDraw( C2DRender* p2DRender ) 
{ 
	CWndStatic* pStatic	= (CWndStatic *)GetDlgItem( WIDC_STATIC2 );

	CString str;
	if( m_tCurrentTime > 0 )
	{
		CString str1;
		CString str2;
			
		str1.Format(prj.GetText(TID_PK_LIMIT_MINUTE), m_ct.GetMinutes() );
		str2.Format(prj.GetText(TID_PK_LIMIT_SECOND), m_ct.GetSeconds() );

		str.Format( "%s %s", str1, str2 );
	}

	if( m_ct.GetMinutes() <= 0 && m_ct.GetSeconds() <= 10 )
		pStatic->m_dwColor = D3DCOLOR_ARGB( 255, 229, 0, 0 );

	if( m_nType == 1 )
		str.Format( "Warte Zeit - %s", str );
	else if( m_nType == 2 )
		str.Format( "Match Zeit - %s", str );
	else
		str.Format( " %s ", str );
	pStatic->SetTitle(str);

	if( m_nType == 2 )
	{
		CWndStatic* pStatic1 = (CWndStatic *)GetDlgItem( WIDC_STATIC1 );

		CString szRound;
		szRound.Format( "Runde %i", m_nRound );
		pStatic1->SetTitle("Runde");
	}
}

BOOL CWndTournamentTimer::Process()
{
	m_tCurrentTime = ( m_tEndTime - g_tmCurrent );
	
	if( m_tEndTime && m_tCurrentTime > 0 )
	{
		m_ct = m_tCurrentTime / 1000.0f;
	}
	
	return TRUE;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CWndTournamentTable::CWndTournamentTable()
{
	for( int i = 0; i < MAX_PLACES; i++ )
		m_pTexture[i] = NULL;
}

CWndTournamentTable::~CWndTournamentTable()
{
}

void CWndTournamentTable::OnInitialUpdate() 
{ 
	CWndNeuz::OnInitialUpdate(); 
} 

BOOL CWndTournamentTable::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ ) 
{
	WndCtrl[0] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC1 );
	WndCtrl[1] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC2 );
	WndCtrl[2] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC3 );
	WndCtrl[3] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC4 );
	WndCtrl[4] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC5 );
	WndCtrl[5] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC6 );
	WndCtrl[6] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC7 );

	pStaticText[0] = (CWndStatic*)GetDlgItem( WIDC_STATIC8 );
	pStaticText[1] = (CWndStatic*)GetDlgItem( WIDC_STATIC9 );
	pStaticText[2] = (CWndStatic*)GetDlgItem( WIDC_STATIC10 );
	pStaticText[3] = (CWndStatic*)GetDlgItem( WIDC_STATIC11 );
	pStaticText[4] = (CWndStatic*)GetDlgItem( WIDC_STATIC12 );
	pStaticText[5] = (CWndStatic*)GetDlgItem( WIDC_STATIC13 );
	pStaticText[6] = (CWndStatic*)GetDlgItem( WIDC_STATIC14 );

	return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_TOURNAMENT_TABLE, 0, CPoint( 0, 0 ), pWndParent );
} 

BOOL CWndTournamentTable::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ) 
{ 
	return CWndNeuz::OnCommand( nID, dwMessage, pWndBase ); 
} 

void CWndTournamentTable::OnDraw( C2DRender* p2DRender ) 
{ 

	WndCtrl[0] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC1 );
	WndCtrl[1] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC2 );
	WndCtrl[2] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC3 );
	WndCtrl[3] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC4 );
	WndCtrl[4] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC5 );
	WndCtrl[5] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC6 );
	WndCtrl[6] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC7 );

	for( int i = 0; i < MAX_PLACES; i++ )
	{
		if( m_pTexture[i] != NULL )
			m_pTexture[i]->Render( p2DRender, CPoint( WndCtrl[0]->rect.left, WndCtrl[i]->rect.top ) );
	}
}

void CWndTournamentTable::SetMember( const char szName[], int nJob, int nPlace )
{
	if( nPlace > MAX_PLACES )
		return;

	nPlace--;
	switch( nJob )
	{
		case JOB_VAGRANT:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_MERCENARY:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ACROBAT:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ASSIST:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_MAGICIAN:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_KNIGHT:
		case JOB_KNIGHT_MASTER:
		case JOB_KNIGHT_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_BLADE:
		case JOB_BLADE_MASTER:
		case JOB_BLADE_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_BILLPOSTER:
		case JOB_BILLPOSTER_MASTER:
		case JOB_BILLPOSTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_RINGMASTER:
		case JOB_RINGMASTER_MASTER:
		case JOB_RINGMASTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ELEMENTOR:
		case JOB_ELEMENTOR_MASTER:
		case JOB_ELEMENTOR_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_PSYCHIKEEPER:
		case JOB_PSYCHIKEEPER_MASTER:
		case JOB_PSYCHIKEEPER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_JESTER:
		case JOB_JESTER_MASTER:
		case JOB_JESTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_RANGER:
		case JOB_RANGER_MASTER:
		case JOB_RANGER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_LORDTEMPLER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_STORMBLADE_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_WINDLURKER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_CRACKSHOOTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_FLORIST_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_FORCEMASTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_MENTALIST_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ELEMENTORLORD_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		default:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
	}
	CString szTitle;
	szTitle.Format( "Name %s", szName );
		if( nPlace == 0 )
		{
			pStaticText[0] = (CWndStatic*)GetDlgItem( WIDC_STATIC8 );
			pStaticText[0]->SetTitle( szTitle );
		}
		else if( nPlace == 1 )
		{
			pStaticText[1] = (CWndStatic*)GetDlgItem( WIDC_STATIC9 );
			pStaticText[1]->SetTitle( szTitle );
		}
		else if( nPlace == 2 )
		{
			pStaticText[2] = (CWndStatic*)GetDlgItem( WIDC_STATIC10 );
			pStaticText[2]->SetTitle( szTitle );
		}
		else if( nPlace == 3 )
		{
			pStaticText[3] = (CWndStatic*)GetDlgItem( WIDC_STATIC11 );
			pStaticText[3]->SetTitle( szTitle );
		}
		else if( nPlace == 4 )
		{
			pStaticText[4] = (CWndStatic*)GetDlgItem( WIDC_STATIC12 );
			pStaticText[4]->SetTitle( szTitle );
		}
		else if( nPlace == 5 )
		{
			pStaticText[5] = (CWndStatic*)GetDlgItem( WIDC_STATIC13 );
			pStaticText[5]->SetTitle( szTitle );
		}
		else if( nPlace == 6 )
		{
			pStaticText[6] = (CWndStatic*)GetDlgItem( WIDC_STATIC14 );
			pStaticText[6]->SetTitle( szTitle );
		}
}
#endif //__TOURNAMENT

WndTournament.h

 Spoiler

#ifndef __TOURNAMENT__H_XHUGASHJK
#define __TOURNAMENT__H_XHUGASHJK

#ifdef __CLIENT
#ifdef	__TOURNAMENT

#define MAX_PLACES	7

struct __MEMBER_LIST
{
	LPTSTR	szName;
	int		nLevel;
};

class CWndTournamentMenu : public CWndNeuz 
{ 
private: 
	CTimeSpan		m_ct;
	time_t			m_tEndTime;
	time_t			m_tCurrentTime;

public:
	CWndTournamentMenu();
	virtual ~CWndTournamentMenu(); 

	virtual BOOL Initialize( CWndBase* pWndParent = NULL, DWORD nType = MB_OK ); 
	virtual BOOL OnChildNotify( UINT message, UINT nID, LRESULT* pLResult ); 
	virtual void OnDraw( C2DRender* p2DRender ); 
	virtual	void OnInitialUpdate(); 
	virtual BOOL OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ); 
	virtual void OnSize( UINT nType, int cx, int cy ); 
	virtual BOOL Process ();
	void	InitializeData( DWORD dwMemberCount, DWORD dwTimeLeft );
	void	InsertMember( const char szName[], int nNum );

	int		m_nMemberCount;
	DWORD	m_dwTimeLeft;
	CWndListBox* pWndList;
};

class CWndTournamentTimer : public CWndNeuz 
{ 
private: 
	CTimeSpan		m_ct;
	time_t			m_tEndTime;
	time_t			m_tCurrentTime;

public:
	CWndTournamentTimer();
	virtual ~CWndTournamentTimer(); 

	virtual BOOL Initialize( CWndBase* pWndParent = NULL, DWORD nType = MB_OK ); 
	virtual void OnDraw( C2DRender* p2DRender ); 
	virtual	void OnInitialUpdate(); 
	virtual BOOL OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ); 
	virtual BOOL Process ();
	void	SetTime( DWORD dwTimeLeft ) { m_tCurrentTime = 0; m_tEndTime = g_tmCurrent + dwTimeLeft; };

	int		m_nType;
	DWORD	m_dwTimeLeft;
	int		m_nRound;
};

class CWndTournamentTable : public CWndNeuz
{
private:
	LPWNDCTRL		WndCtrl[MAX_PLACES];
	CWndStatic*		pStaticText[MAX_PLACES];
	CTexture*		m_pTexture[MAX_PLACES];

public:
	CWndTournamentTable();
	virtual ~CWndTournamentTable(); 

	virtual BOOL Initialize( CWndBase* pWndParent = NULL, DWORD nType = MB_OK ); 
	virtual void OnDraw( C2DRender* p2DRender ); 
	virtual	void OnInitialUpdate(); 
	virtual BOOL OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ); 
	void	SetMember(const char szName[], int nJob, int nPlace);
};
#endif //__TOURNAMENT
#endif //__TOURNAMENT
#endif //__TOURNAMENT__H_XHUGASHJK

Neuz\DPClient.cpp

 Spoiler

void CDPClient::OnSnapshot( CAr & ar )
In dieser Funktion added ihr:

#ifdef __TOURNAMENT
			case SNAPSHOTTYPE_TOURNAMENT: OnTournament( ar ); break;
#endif //__TOURNAMENT

Am ende dann noch:

#ifdef __TOURNAMENT
void CDPClient::OnTournament( CAr & ar )
{
	BYTE nType;
	ar >> nType;
	switch( nType )
	{
		case 1:	//Menü Ansicht
		{
			int nCount, nTimeLeft;

			ar >> nTimeLeft >> nCount;

			if( g_WndMng.m_pTournamentMenu )
			{
				g_WndMng.m_pTournamentMenu->InitializeData( nCount, nTimeLeft );
				for( int i = 0; i < nCount; i++ )
				{
					char szName[ MAX_PLAYER ] = {0, };
					ar.ReadString( szName, sizeof(szName) );
					g_WndMng.m_pTournamentMenu->InsertMember( szName, i+1 );
				}
			}
			else
			{

				SAFE_DELETE( g_WndMng.m_pTournamentMenu );

				g_WndMng.m_pTournamentMenu = new CWndTournamentMenu();
				if( g_WndMng.m_pTournamentMenu )
				{
					g_WndMng.m_pTournamentMenu->Initialize();
					g_WndMng.m_pTournamentMenu->InitializeData( nCount, nTimeLeft );
					for( int i = 0; i < nCount; i++ )
					{
						char szName[ MAX_PLAYER ] = {0, };
						ar.ReadString( szName, sizeof(szName) );
						g_WndMng.m_pTournamentMenu->InsertMember( szName, i+1 );
					}
				}
			}

		break;
		}
		case 2: // Table Ansicht
		{
			SAFE_DELETE( g_WndMng.m_pTournamentMenu );
			SAFE_DELETE( g_WndMng.m_pTournamentTimer );
			SAFE_DELETE( g_WndMng.m_pTournamentTable );

			g_WndMng.m_pTournamentTable = new CWndTournamentTable();
			if( g_WndMng.m_pTournamentTable )
			{
				int nCount;
				ar >> nCount;
				g_WndMng.m_pTournamentTable->Initialize();
				for( int i = 0; i < nCount; i++ )
				{
					char szName[MAX_PLAYER] = {0,};
					int nJob, nPlace;
					ar.ReadString( szName, MAX_PLAYER );
					ar >> nJob >> nPlace;
					g_WndMng.m_pTournamentTable->SetMember( szName, nJob, nPlace );
				}
			}
		break;
		}
		case 3: //Timer Ansicht
		{
			int nType, nTimeLeft, nRound;
			ar >> nType >> nTimeLeft >> nRound;

			SAFE_DELETE( g_WndMng.m_pTournamentMenu );
			SAFE_DELETE( g_WndMng.m_pTournamentTimer );
			SAFE_DELETE( g_WndMng.m_pTournamentTable );

			g_WndMng.m_pTournamentTimer = new CWndTournamentTimer;
			if( g_WndMng.m_pTournamentTimer )
			{
				g_WndMng.m_pTournamentTimer->Initialize();
				g_WndMng.m_pTournamentTimer->m_nType = nType;
				g_WndMng.m_pTournamentTimer->m_nRound = nRound;
				g_WndMng.m_pTournamentTimer->SetTime( nTimeLeft );

			}
		break;
		}
		case 4://Remove Timer
		{
			SAFE_DELETE( g_WndMng.m_pTournamentMenu );
			SAFE_DELETE( g_WndMng.m_pTournamentTimer );
			SAFE_DELETE( g_WndMng.m_pTournamentTable );
		}
		break;
	}
}

void CDPClient::SendTournamentMenuView()
{
	BEFORESENDSOLE( ar, PACKETTYPE_TOURNAMENT, DPID_UNKNOWN );
	ar << (BYTE)1;
	SEND( ar, this, DPID_SERVERPLAYER );
}

void CDPClient::SendTournamentRegister()
{
	BEFORESENDSOLE( ar, PACKETTYPE_TOURNAMENT, DPID_UNKNOWN );
	ar << 2;
	SEND( ar, this, DPID_SERVERPLAYER );
}

void CDPClient::SendTournamentTableView()
{
	BEFORESENDSOLE( ar, PACKETTYPE_TOURNAMENT, DPID_UNKNOWN );
	ar << (BYTE)3;
	SEND( ar, this, DPID_SERVERPLAYER );
}
#endif //__TOURNAMENT

Neuz\DPClient.h

 Spoiler

class CDPClient : public CDPMng
In dieser Klasse added ihr:

#ifdef __TOURNAMENT
	void	OnTournament( CAr & ar );
	void	SendTournamentMenuView();
	void	SendTournamentRegister();
	void	SendTournamentTableView();
#endif //__TOURNAMENT

WORLDSERVER\DPSrvr.cpp

 Spoiler

Im Kopf der Datei includieren wir unser System.
#ifdef __TOURNAMENT
#include "Tournament.h"
#endif //__TOURNAMENT

CDPSrvr::CDPSrvr()
In dieser Funktion adden wir:

#ifdef __TOURNAMENT
	ON_MSG( PACKETTYPE_TOURNAMENT, OnTournament );
#endif //__TOURNAMENT

Am ende Adden wir noch:

#ifdef __TOURNAMENT
void CDPSrvr::OnTournament( CAr & ar, DPID dpidCache, DPID dpidUser, LPBYTE lpBuf, u_long uBufSize )
{
	CUser* pUser	= g_UserMng.GetUser( dpidCache, dpidUser );
	if( IsValidObj( pUser ) )
	{
		BYTE nState;
		ar >> nState;
		switch( nState )
		{
			case 1: //Menu ansicht
			{
				CTournamentMng::GetInstance()->SendMenu( pUser );
			}
			break;
			case 2: //Teilnehmen
			{
				CTournamentMng::GetInstance()->AddMember( pUser );
			}
			break;
			case 3: //Table Ansicht
			{
				CTournamentMng::GetInstance()->SendTable( pUser );
			}
			break;
		}
	}
}
#endif //__TOURNAMENT

Im Neuz Projekt adden wir diese zwei Dateien:

WndTournament.cpp

 Spoiler

#include "stdafx.h"
#include "WndColosseum.h"
#ifdef	__TOURNAMENT

#include "resData.h"
#include "defineText.h"
#include "DPClient.h"

extern	CDPClient			g_DPlay;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CWndTournamentMenu::CWndTournamentMenu()
{ 
}

CWndTournamentMenu::~CWndTournamentMenu() 
{ 
} 

void CWndTournamentMenu::OnInitialUpdate() 
{ 
	CWndNeuz::OnInitialUpdate(); 

	MoveParentCenter();
} 

BOOL CWndTournamentMenu::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ ) 
{
	pWndList = (CWndListBox*)GetDlgItem( WIDC_LISTBOX1 );
	return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_TOURNAMENT_MENU, 0, CPoint( 0, 0 ), pWndParent );
} 

BOOL CWndTournamentMenu::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ) 
{ 
	return CWndNeuz::OnCommand( nID, dwMessage, pWndBase ); 
} 

void CWndTournamentMenu::OnSize( UINT nType, int cx, int cy )
{ 
	CWndNeuz::OnSize( nType, cx, cy ); 
} 



BOOL CWndTournamentMenu::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult ) 
{ 
	if( nID == WIDC_CLOSE )
	{
		Destroy();
	}
	else
	if( nID == WIDC_BUTTON1 )
	{
		Destroy();
		g_DPlay.SendTournamentRegister();
	}
	else
	if( nID == WIDC_BUTTON2 )
	{
		g_DPlay.SendTournamentMenuView();
	}
	
	return CWndNeuz::OnChildNotify( message, nID, pLResult ); 
} 

void CWndTournamentMenu::OnDraw( C2DRender* p2DRender ) 
{ 
	CWndStatic* pStatic	= (CWndStatic *)GetDlgItem( WIDC_STATIC2 );
	if( m_tCurrentTime > 0 )
	{
		CString str1;
		CString str2;
		CString str3;
		CString str;
			
		str1.Format(prj.GetText(TID_PK_LIMIT_HOUR), m_ct.GetHours() );
		str2.Format(prj.GetText(TID_PK_LIMIT_MINUTE), m_ct.GetMinutes() );
		str3.Format(prj.GetText(TID_PK_LIMIT_SECOND), m_ct.GetSeconds() );

		str.Format( "%s %s %s", str1, str2, str3 );
		pStatic->SetTitle(str);
	}
	else
	{
		pStatic->SetTitle("          -");
	}

	if( ( m_ct.GetHours() + m_ct.GetMinutes() <= 0 ) && m_ct.GetSeconds() <= 10 )
		pStatic->m_dwColor = D3DCOLOR_ARGB( 255, 229, 0, 0 );

	pStatic = (CWndStatic*)GetDlgItem( WIDC_STATIC5 );
	CString str;
	str.Format( "%i", m_nMemberCount );
	pStatic->SetTitle(str);
} 

BOOL CWndTournamentMenu::Process() 
{
	m_tCurrentTime = ( m_tEndTime - g_tmCurrent );
	
	if( m_tEndTime && m_tCurrentTime > 0 )
	{
		m_ct = m_tCurrentTime / 1000.0f;
	}
	
	return TRUE;
}

void CWndTournamentMenu::InitializeData( DWORD dwMemberCount, DWORD dwTimeLeft )
{
	pWndList = new CWndListBox;
	pWndList = (CWndListBox*)GetDlgItem( WIDC_LISTBOX1 );
	for( int i = 0; i < pWndList->GetCount(); i++ )
		pWndList->DeleteString( i );

	m_nMemberCount = (int)dwMemberCount;

	m_tCurrentTime = 0;
	m_tEndTime = g_tmCurrent + dwTimeLeft;
}

void CWndTournamentMenu::InsertMember( const char szName[],int nNum )
{
	CWndListBox* pWndList = (CWndListBox*)GetDlgItem( WIDC_LISTBOX1 );
	
	CString str;
	str.Format( "No.%.2d		%s", nNum, szName );
	pWndList->AddString(str);
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CWndTournamentTimer::CWndTournamentTimer()
{
}

CWndTournamentTimer::~CWndTournamentTimer()
{
}

void CWndTournamentTimer::OnInitialUpdate() 
{ 
	CWndNeuz::OnInitialUpdate(); 

	CRect rectRoot = m_pWndRoot->GetLayoutRect();
	CRect rectWindow = GetWindowRect();
	CPoint point( ( rectRoot.right - rectWindow.Width() ) / 2, 15 );
	Move( point );

	DWORD dwStyle = GetWndStyle();
	dwStyle &= (~WBS_MOVE);
	SetWndStyle( dwStyle );
} 

BOOL CWndTournamentTimer::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ ) 
{
	return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_NEWCOLOSTARTREADY1, 0, CPoint( 0, 0 ), pWndParent );
} 

BOOL CWndTournamentTimer::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ) 
{ 
	return CWndNeuz::OnCommand( nID, dwMessage, pWndBase ); 
} 

void CWndTournamentTimer::OnDraw( C2DRender* p2DRender ) 
{ 
	CWndStatic* pStatic	= (CWndStatic *)GetDlgItem( WIDC_STATIC2 );

	CString str;
	if( m_tCurrentTime > 0 )
	{
		CString str1;
		CString str2;
			
		str1.Format(prj.GetText(TID_PK_LIMIT_MINUTE), m_ct.GetMinutes() );
		str2.Format(prj.GetText(TID_PK_LIMIT_SECOND), m_ct.GetSeconds() );

		str.Format( "%s %s", str1, str2 );
	}

	if( m_ct.GetMinutes() <= 0 && m_ct.GetSeconds() <= 10 )
		pStatic->m_dwColor = D3DCOLOR_ARGB( 255, 229, 0, 0 );

	if( m_nType == 1 )
		str.Format( "Warte Zeit - %s", str );
	else if( m_nType == 2 )
		str.Format( "Match Zeit - %s", str );
	else
		str.Format( " %s ", str );
	pStatic->SetTitle(str);

	if( m_nType == 2 )
	{
		CWndStatic* pStatic1 = (CWndStatic *)GetDlgItem( WIDC_STATIC1 );

		CString szRound;
		szRound.Format( "Runde %i", m_nRound );
		pStatic1->SetTitle("Runde");
	}
}

BOOL CWndTournamentTimer::Process()
{
	m_tCurrentTime = ( m_tEndTime - g_tmCurrent );
	
	if( m_tEndTime && m_tCurrentTime > 0 )
	{
		m_ct = m_tCurrentTime / 1000.0f;
	}
	
	return TRUE;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CWndTournamentTable::CWndTournamentTable()
{
	for( int i = 0; i < MAX_PLACES; i++ )
		m_pTexture[i] = NULL;
}

CWndTournamentTable::~CWndTournamentTable()
{
}

void CWndTournamentTable::OnInitialUpdate() 
{ 
	CWndNeuz::OnInitialUpdate(); 
} 

BOOL CWndTournamentTable::Initialize( CWndBase* pWndParent, DWORD /*dwWndId*/ ) 
{
	WndCtrl[0] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC1 );
	WndCtrl[1] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC2 );
	WndCtrl[2] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC3 );
	WndCtrl[3] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC4 );
	WndCtrl[4] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC5 );
	WndCtrl[5] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC6 );
	WndCtrl[6] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC7 );

	pStaticText[0] = (CWndStatic*)GetDlgItem( WIDC_STATIC8 );
	pStaticText[1] = (CWndStatic*)GetDlgItem( WIDC_STATIC9 );
	pStaticText[2] = (CWndStatic*)GetDlgItem( WIDC_STATIC10 );
	pStaticText[3] = (CWndStatic*)GetDlgItem( WIDC_STATIC11 );
	pStaticText[4] = (CWndStatic*)GetDlgItem( WIDC_STATIC12 );
	pStaticText[5] = (CWndStatic*)GetDlgItem( WIDC_STATIC13 );
	pStaticText[6] = (CWndStatic*)GetDlgItem( WIDC_STATIC14 );

	return CWndNeuz::InitDialog( g_Neuz.GetSafeHwnd(), APP_TOURNAMENT_TABLE, 0, CPoint( 0, 0 ), pWndParent );
} 

BOOL CWndTournamentTable::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ) 
{ 
	return CWndNeuz::OnCommand( nID, dwMessage, pWndBase ); 
} 

void CWndTournamentTable::OnDraw( C2DRender* p2DRender ) 
{ 

	WndCtrl[0] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC1 );
	WndCtrl[1] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC2 );
	WndCtrl[2] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC3 );
	WndCtrl[3] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC4 );
	WndCtrl[4] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC5 );
	WndCtrl[5] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC6 );
	WndCtrl[6] = (LPWNDCTRL)GetWndCtrl( WIDC_STATIC7 );

	for( int i = 0; i < MAX_PLACES; i++ )
	{
		if( m_pTexture[i] != NULL )
			m_pTexture[i]->Render( p2DRender, CPoint( WndCtrl[0]->rect.left, WndCtrl[i]->rect.top ) );
	}
}

void CWndTournamentTable::SetMember( const char szName[], int nJob, int nPlace )
{
	if( nPlace > MAX_PLACES )
		return;

	nPlace--;
	switch( nJob )
	{
		case JOB_VAGRANT:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_MERCENARY:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ACROBAT:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ASSIST:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_MAGICIAN:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_KNIGHT:
		case JOB_KNIGHT_MASTER:
		case JOB_KNIGHT_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_BLADE:
		case JOB_BLADE_MASTER:
		case JOB_BLADE_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_BILLPOSTER:
		case JOB_BILLPOSTER_MASTER:
		case JOB_BILLPOSTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_RINGMASTER:
		case JOB_RINGMASTER_MASTER:
		case JOB_RINGMASTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ELEMENTOR:
		case JOB_ELEMENTOR_MASTER:
		case JOB_ELEMENTOR_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_PSYCHIKEEPER:
		case JOB_PSYCHIKEEPER_MASTER:
		case JOB_PSYCHIKEEPER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_JESTER:
		case JOB_JESTER_MASTER:
		case JOB_JESTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_RANGER:
		case JOB_RANGER_MASTER:
		case JOB_RANGER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_LORDTEMPLER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_STORMBLADE_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_WINDLURKER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_CRACKSHOOTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_FLORIST_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_FORCEMASTER_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_MENTALIST_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		case JOB_ELEMENTORLORD_HERO:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
			break;

		default:
			m_pTexture[nPlace] = CWndBase::m_textureMng.AddTexture( g_Neuz.m_pd3dDevice, MakePath( DIR_THEME, "SlotVag.bmp" ), 0xffff00ff );
	}
	CString szTitle;
	szTitle.Format( "Name %s", szName );
		if( nPlace == 0 )
		{
			pStaticText[0] = (CWndStatic*)GetDlgItem( WIDC_STATIC8 );
			pStaticText[0]->SetTitle( szTitle );
		}
		else if( nPlace == 1 )
		{
			pStaticText[1] = (CWndStatic*)GetDlgItem( WIDC_STATIC9 );
			pStaticText[1]->SetTitle( szTitle );
		}
		else if( nPlace == 2 )
		{
			pStaticText[2] = (CWndStatic*)GetDlgItem( WIDC_STATIC10 );
			pStaticText[2]->SetTitle( szTitle );
		}
		else if( nPlace == 3 )
		{
			pStaticText[3] = (CWndStatic*)GetDlgItem( WIDC_STATIC11 );
			pStaticText[3]->SetTitle( szTitle );
		}
		else if( nPlace == 4 )
		{
			pStaticText[4] = (CWndStatic*)GetDlgItem( WIDC_STATIC12 );
			pStaticText[4]->SetTitle( szTitle );
		}
		else if( nPlace == 5 )
		{
			pStaticText[5] = (CWndStatic*)GetDlgItem( WIDC_STATIC13 );
			pStaticText[5]->SetTitle( szTitle );
		}
		else if( nPlace == 6 )
		{
			pStaticText[6] = (CWndStatic*)GetDlgItem( WIDC_STATIC14 );
			pStaticText[6]->SetTitle( szTitle );
		}
}
#endif //__TOURNAMENT

WndTournament.h

 Spoiler

#ifndef __TOURNAMENT__H_XHUGASHJK
#define __TOURNAMENT__H_XHUGASHJK

#ifdef __CLIENT
#ifdef	__TOURNAMENT

#define MAX_PLACES	7

struct __MEMBER_LIST
{
	LPTSTR	szName;
	int		nLevel;
};

class CWndTournamentMenu : public CWndNeuz 
{ 
private: 
	CTimeSpan		m_ct;
	time_t			m_tEndTime;
	time_t			m_tCurrentTime;

public:
	CWndTournamentMenu();
	virtual ~CWndTournamentMenu(); 

	virtual BOOL Initialize( CWndBase* pWndParent = NULL, DWORD nType = MB_OK ); 
	virtual BOOL OnChildNotify( UINT message, UINT nID, LRESULT* pLResult ); 
	virtual void OnDraw( C2DRender* p2DRender ); 
	virtual	void OnInitialUpdate(); 
	virtual BOOL OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ); 
	virtual void OnSize( UINT nType, int cx, int cy ); 
	virtual BOOL Process ();
	void	InitializeData( DWORD dwMemberCount, DWORD dwTimeLeft );
	void	InsertMember( const char szName[], int nNum );

	int		m_nMemberCount;
	DWORD	m_dwTimeLeft;
	CWndListBox* pWndList;
};

class CWndTournamentTimer : public CWndNeuz 
{ 
private: 
	CTimeSpan		m_ct;
	time_t			m_tEndTime;
	time_t			m_tCurrentTime;

public:
	CWndTournamentTimer();
	virtual ~CWndTournamentTimer(); 

	virtual BOOL Initialize( CWndBase* pWndParent = NULL, DWORD nType = MB_OK ); 
	virtual void OnDraw( C2DRender* p2DRender ); 
	virtual	void OnInitialUpdate(); 
	virtual BOOL OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ); 
	virtual BOOL Process ();
	void	SetTime( DWORD dwTimeLeft ) { m_tCurrentTime = 0; m_tEndTime = g_tmCurrent + dwTimeLeft; };

	int		m_nType;
	DWORD	m_dwTimeLeft;
	int		m_nRound;
};

class CWndTournamentTable : public CWndNeuz
{
private:
	LPWNDCTRL		WndCtrl[MAX_PLACES];
	CWndStatic*		pStaticText[MAX_PLACES];
	CTexture*		m_pTexture[MAX_PLACES];

public:
	CWndTournamentTable();
	virtual ~CWndTournamentTable(); 

	virtual BOOL Initialize( CWndBase* pWndParent = NULL, DWORD nType = MB_OK ); 
	virtual void OnDraw( C2DRender* p2DRender ); 
	virtual	void OnInitialUpdate(); 
	virtual BOOL OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase ); 
	void	SetMember(const char szName[], int nJob, int nPlace);
};
#endif //__TOURNAMENT
#endif //__TOURNAMENT
#endif //__TOURNAMENT__H_XHUGASHJK

WORLDSERVER\DPSrvr.h

 Spoiler

class CDPSrvr : public CDPMng
In dieser Klasse adden wir nun:

#ifdef __TOURNAMENT
	void	OnTournament( CAr & ar, DPID dpidCache, DPID dpidUser, LPBYTE, u_long );
#endif //__TOURNAMENT

WORLDSERVER\User.cpp

 Spoiler

Am ende der Datei einfach dies adden:

#ifdef __TOURNAMENT
void CUser::SendTournamentMenuView( DWORD dwTimeLeft, vector<__TOURNAMENT_MEMBER>& vecMember )
{
if( IsDelete() ) return;

m_Snapshot.cb++;
m_Snapshot.ar << GetId();
m_Snapshot.ar << SNAPSHOTTYPE_TOURNAMENT;
m_Snapshot.ar << (BYTE)1 << dwTimeLeft << (int)vecMember.size();
for( int i = 0; i < (int)vecMember.size(); i++ )
m_Snapshot.ar.WriteString( vecMember.at(i).szName );
}

void CUser::SendTournamentTableView( vector<__TABLE_VIEW>& vecMemberList )
{
if( IsDelete() ) return;
m_Snapshot.cb++;
m_Snapshot.ar << GetId();
m_Snapshot.ar << SNAPSHOTTYPE_TOURNAMENT;
m_Snapshot.ar << (BYTE)2 << vecMemberList.size();
for( int i = 0; i < (int)vecMemberList.size(); i++ )
{
m_Snapshot.ar.WriteString( vecMemberList.at(i).szName );
m_Snapshot.ar << vecMemberList.at(i).nJob << vecMemberList.at(i).nPlace;
}

}
void CUser::SendTournamentTime( DWORD dwTimeLeft, int nType, int nRound )
{
if( IsDelete() ) return;

m_Snapshot.cb++;
m_Snapshot.ar << GetId();
m_Snapshot.ar << SNAPSHOTTYPE_TOURNAMENT;
m_Snapshot.ar << (BYTE)3 << nType << dwTimeLeft << nRound;
}

void CUser::SendTournamentRoundOver()
{
if( IsDelete() ) return;
m_Snapshot.cb++;
m_Snapshot.ar << GetId();
m_Snapshot.ar << SNAPSHOTTYPE_TOURNAMENT;
m_Snapshot.ar << (BYTE)4;
}
#endif //__TOURNAMENT

WORLDSERVER\User.h

 Spoiler

Im Kopf der Datei adden wir:

#ifdef __TOURNAMENT
#include "Tournament.h"
#endif //__TOURNAMENT

class CUser : public CMover
In der Klasse adden wir:

#ifdef __TOURNAMENT
	void	SendTournamentMenuView( DWORD dwTimeLeft, vector<__TOURNAMENT_MEMBER>& vecMember );
	void	SendTournamentTime( DWORD dwTimeLeft, int nType, int nRound );
	void	SendTournamentRoundOver();
	void	SendTournamentTableView( vector<__TABLE_VIEW>& vecMemberList );
#endif //__TOURNAMENT

_Common\CommonCtrl.cpp

 Spoiler

Wir suchen nach:

	FOR_LINKMAP( GetWorld(), vPos, pObj, nRange, CObj::linkPlayer, GetLayer() )
	{
		if( pObj->GetType() == OT_MOVER )				// ´ë»óÀÌ ¹«¹öÀ϶§¸¸.
		{
			CMover *pTarget = (CMover *)pObj;
			if( pTarget->IsLive() && pAttacker != pTarget )
			{
				if( pObj->IsRangeObj( vPos, 1.0f ) )
				{
#if __VER >= 9	// __SKILL_0706
					int n = 0;
					if( bPVP && pAttacker->IsPVPTarget( pTarget ) )
						n	= pTarget->m_pActMover->SendDamage( AF_FORCE, pAttacker->GetId(), nDamagePVP, FALSE );	
					else if( bPVP && (m_bControl || pAttacker->IsGuildCombatTarget( pTarget )
								/*¾Æ·¹³ª Ãß°¡*/	|| pAttacker->IsArenaTarget( pTarget ) 
						) )
						n	= pTarget->m_pActMover->SendDamage( AF_FORCE, pAttacker->GetId(), nDamage, FALSE );	
#else	// __SKILL_0706
					int n	= pTarget->m_pActMover->SendDamage( AF_FORCE, pAttacker->GetId(), nDamage, FALSE );	
#endif	// __SKILL_0706

Und fügen darunter dies ein:

#ifdef __TOURNAMENT
					if( bPVP && pAttacker->IsTournamentTarget( pTarget ) )
						n = pTarget->m_pActMover->SendDamage( AF_FORCE, pAttacker->GetId(), nDamagePVP, FALSE );
#endif //__TOURNAMENT

_Common\Ctrl.cpp

 Spoiler

Wir suchen nach:

void	CCtrl::ApplySkill( CCtrl *pSrc, ItemProp *pSkillProp, AddSkillProp *pAddSkillProp, bool bIgnoreProb, int nParam, BOOL bOnlyDmg, BOOL bTarget )
{
#ifdef __PK_PVP_SKILL_REGION
	if( pSrc->GetType() == OT_MOVER && GetType() == OT_MOVER )
	{
		if( ((CMover *)pSrc)->IsPlayer() && ((CMover *)this)->IsPlayer() && pSkillProp->dwSkillType != NULL_ID )
		{
			DWORD dwPKRegionAttr = ((CMover *)this)->GetPKPVPRegionAttr();
			int nAttackerPK = ((CMover *)pSrc)->IsPKPVPInspectionBase( dwPKRegionAttr, FALSE );
			int nDefenDerPK = ((CMover *)this)->IsPKPVPInspectionBase( dwPKRegionAttr, FALSE );
			if( nAttackerPK == 1 || nDefenDerPK == 1 )
			{
				if( pSkillProp->nEvildoing < 0 )
				{
					CMover* pAttacker = (CMover*)pSrc;
					CMover* pDefender = (CMover*)this;
					if( !(pAttacker->IsPVPTarget( pDefender ) || 
						pAttacker->IsWarTarget( pDefender ) ||
						pAttacker->IsGuildCombatTarget( pDefender )
#ifdef __JEFF_11_4
						|| pAttacker->IsArenaTarget( pDefender )
#endif	// __JEFF_11_4

Darunter fügen wir dies ein:

#ifdef __TOURNAMENT
						|| pAttacker->IsTournamentTarget( pDefender )
#endif //__TOURNAMENT

-----------------

Wir suchen nach:

#if defined(__WORLDSERVER)
	if( this != pSrc && pSrc->GetType() == OT_MOVER && GetType() == OT_MOVER )		// ±¤¿ª µð¹öÇÁ Áß Å¸°ÙÀ̾ƴϸé skip
	{
		if( ((CMover *)this)->IsDie() == FALSE )
		{
#if __VER >= 8 // __S8_PK
			if( pSkillProp->nEvildoing < 0 )													// ³ª»Û¸¶¹ýÀº
				if( ((CMover *)pSrc)->GetHitType2(((CMover *)this), bTarget, FALSE ) == HITTYPE_FAIL )  	// ÆòÈ*ÀûÀλó´ë¿¡°Ô
					return;																			// Àû¿ë¾ÈµÊ
#ifdef __JEFF_11_4
			CWorld* pWorld	= pSrc->GetWorld();
			if(  pWorld && pWorld->IsArena() == FALSE )		// ¾Æ·¹³ª°¡ ¾Æ´Ï¸é,
#endif	// __JEFF_11_4
			{

Und fügen darunter ein:

#ifdef __TOURNAMENT
				if( ((CMover*)pSrc)->IsTournament() )
#endif //__TOURNAMENT

_Common\Mover.cpp

 Spoiler

Wir suchen nach:

	if( pAttacker && pAttacker != this && pAttacker->IsPlayer() )		// ÀÚ»ìÇÑ°Ô ¾Æ´Ï°í, Ç÷¹À̾°Ô Á×¾ú³Ä ¾Æ´Ï³Ä.
	{
		PVP_MODE mode = GetPVPCase( pAttacker ); 

		if( mode == PVP_MODE_PK )	// PK°æ¿ì
		{
#ifdef __JEFF_11_4
#endif	// __JEFF_11_4
			if( g_eLocal.GetState( EVE_PKCOST )
#ifdef __JEFF_11_4
				&& GetWorld()->IsArena() == FALSE

Und fügen darunter ein:

#ifdef __TOURNAMENT
				&& IsTournament()
#endif //__TOURNAMENT

--------------------------------

Wir suchen nach

int	CMover::SubPK( CMover *pAttacker, int nReflect )
{
	if( !g_eLocal.GetState( EVE_PK )
#ifdef __JEFF_11_4
		|| GetWorld()->IsArena()
#endif	// __JEFF_11_4

Und fügen darunter ein:

#ifdef __TOURNAMENT
		|| IsTournament()
#endif //__TOURNAMENT

-------------------------------

Wir suchen nach:

#if __VER >= 11 // __GUILD_COMBAT_1TO1
	if( g_GuildCombat1to1Mng.IsPossibleUser( (CUser*)this ) && g_GuildCombat1to1Mng.IsPossibleUser( (CUser*)pAttacker ) )
		return 1;
#endif // __GUILD_COMBAT_1TO1

	if( g_eLocal.GetState( EVE_PKCOST ) 
#ifdef __JEFF_11_4
		&& GetWorld()->IsArena() == FALSE
#endif	// __JEFF_11_4

Und fügen darunter ein:

#ifdef __TOURNAMENT
		&& IsTournament()
#endif //__TOURNAMENT

----------------------------------------

Wir suchen nach:

	CWorld* pWorld = GetWorld();
	if( pWorld )
	{
		//"%s´ÔÀÌ Çö»ó¹ü %s¸¦ Àâ¾Æ Çö»ó±Ý %sÆä³Ä¸¦ ¾ò¾ú½À´Ï´Ù."
		char szFormat[256];
		strcpy( szFormat, pAttacker->GetName() );
		strcat( szFormat, prj.GetText( TID_PK_REWARDNOTICE ) );
		g_DPCoreClient.SendWCWantedReward( m_idPlayer, pAttacker->m_idPlayer, szFormat, pWorld->GetID(), GetPos() );
	}

	if( g_eLocal.GetState( EVE_PKCOST ) 
#ifdef __JEFF_11_4
		&& ( pWorld && pWorld->IsArena() == FALSE )
#endif	// __JEFF_11_4

Und fügen darunter ein:

#ifdef __TOURNAMENT
		&& IsTournament()
#endif //__TOURNAMENT

---------------------------------------

Wir suchen nach

		if( pObj->GetType() == OT_MOVER )
		{
		#ifdef __CLIENT
			CMover *pMover = (CMover *)pObj;

				if( pMover->IsPlayer() )
				{
					if( g_eLocal.GetState( EVE_18 ) )
					{
						if( IsPVPTarget( pMover ) )			// pvp
						{
							if( m_nDuelState == 1 && !IsFly() && !pMover->IsFly() )
								bAble	= TRUE;
						}

Und fügen darunter ein:

#ifdef __TOURNAMENT
						else if( IsTournamentTarget( pMover ) )
						{
							bAble = TRUE;
						}
#endif //__TOURNAMENT

-------------------------------------

Wir suchen nach:

#endif	// __JEFF_11_4
						else								// pk
						{
							bAble	= IsPKAttackAble( pMover );
							if( bAble )
								( (CWndWorld *)g_WndMng.m_pWndWorld )->SetLastTarget( pMover->GetId() );
						}
					}

#if __VER >= 8 // 8Â÷ µà¾ó 061226 ma
					if( IsPVPTarget( pMover ) )			// pvp
					{
						if( m_nDuelState == 1 && !IsFly() && !pMover->IsFly() )
							bAble	= TRUE;
					}
#endif // __VER >= 8 // 8Â÷ µà¾ó 061226 ma

Und fügen darunter ein:

#ifdef __TOURNAMENT
					if( IsTournamentTarget( pMover ) )
						{
							bAble = TRUE;
						}
#endif //__TOURNAMENT

Die Funktion
BOOL CMover::IsPKAttackAble( CMover* pMover )

Ersetzen wir damit:

BOOL CMover::IsPKAttackAble( CMover* pMover )
{
#ifdef __JEFF_11_4
	if( IsArenaTarget( pMover ) )
		return TRUE;
#endif	// __JEFF_11_4
#ifdef __TOURNAMENT
	if( IsTournamentTarget( pMover ) )
		return TRUE;
#endif //__TOURNAMENT
	if( !g_eLocal.GetState( EVE_PK ) )
		return FALSE;
	return IsPKInspection( pMover );
}

_Common\Mover.h

 Spoiler

Die Enum

enum HITTYPE
{
	HITTYPE_FAIL	= 0,
	HITTYPE_GENERIC,			/// Player vs Monster
	HITTYPE_PVP,				/// Player vs Player
	HITTYPE_WAR,				/// ±æµåÀü 
	HITTYPE_SCHOOL,				/// Çб³ ´ëÇ× À̺¥Æ® ŸÀÔ 
	HITTYPE_PK,					/// Player Killing
	HITTYPE_GUILDCOMBAT,		/// ±æµå´ëÀü 
#ifdef __JEFF_11_4
	HITTYPE_ARENA,		// ¾Æ·¡³ª
#endif	// __JEFF_11_4
};

Ersetzen wir damit:

enum HITTYPE
{
	HITTYPE_FAIL	= 0,
	HITTYPE_GENERIC,			/// Player vs Monster
	HITTYPE_PVP,				/// Player vs Player
	HITTYPE_WAR,				/// ±æµåÀü 
	HITTYPE_SCHOOL,				/// Çб³ ´ëÇ× À̺¥Æ® ŸÀÔ 
	HITTYPE_PK,					/// Player Killing
	HITTYPE_GUILDCOMBAT,		/// ±æµå´ëÀü 
#ifdef __JEFF_11_4
	HITTYPE_ARENA,		// ¾Æ·¡³ª
#endif	// __JEFF_11_4
#ifdef __TOURNAMENT
	HITTYPE_TOURNAMENT,
#endif //__TOURNAMENT
};

In der Klasse:
class CMover : public CCtrl
Adden wir:

#ifdef __TOURNAMENT
	BOOL			IsTournamentTarget( CMover* pMover );
	BOOL			IsTournament();
#endif //__TOURNAMENT

_Common\MoverAttack.cpp

 Spoiler

Unter diesem code

void CMover::OnAttacked( CMover* pAttacker, int nDamage, BOOL bTarget, int nReflect )
{
	CMover* pDefender = this;
	if( pDefender == pAttacker )
	{
//		ASSERT( FALSE );	// ÀÏ´Ü Çö ±âȹ¿¡¼* ÀÚ½ÅÀ» °ø°ÝÇÏ´Â °æ¿ì´Â ¾ø´Ù. 
		return;
	}

	BOOL bAddEnemy = TRUE;
	DWORD dwLast = 0;

	HITTYPE type = pAttacker->GetHitType( pDefender, bTarget, nReflect );
	if( type == HITTYPE_PVP || type == HITTYPE_WAR || type == HITTYPE_SCHOOL
#ifdef __JEFF_11_4
		|| type == HITTYPE_ARENA
#endif	// __JEFF_11_4

Adden wir

#ifdef __TOURNAMENT
		|| type == HITTYPE_TOURNAMENT
#endif //__TOURNAMENT

-------------------------------------

Unter diesem Code

	case HITTYPE_PK:
		{
#if __VER >= 8 // __S8_PK
			if( nReflect )
				break;
			
			if( pAttacker->IsChaotic() || pDefender->IsChaotic() )
				break;

#ifdef __JEFF_11_4
			CWorld* pWorld	= pDefender->GetWorld();
			if( pWorld && pWorld->IsArena() )
				break;
#endif	// __JEFF_11_4

Adden wir

#ifdef __TOURNAMENT
			if( IsTournament() )
				break;
#endif //__TOURNAMENT

---------------------------------------

Unter diesem Code

		if( m_pActMover->IsFly() || pMover->m_pActMover->IsFly() )	// °øÁß¿¡ ÀÖÀ¸¸é ºÒ°¡ 
			return HITTYPE_FAIL;
		if( IsPVPTarget( pMover ) )
			return HITTYPE_PVP;
		if( IsWarTarget( pMover ) )
			return HITTYPE_WAR;
		if( IsSchoolTarget( pMover ) )
			return HITTYPE_SCHOOL;
		if( IsGuildCombatTarget( pMover ) )
			return HITTYPE_GUILDCOMBAT;
#ifdef __JEFF_11_4
		if( IsArenaTarget( pMover ) )
			return HITTYPE_ARENA;
#endif	// __JEFF_11_4

Adden wir

#ifdef __TOURNAMENT
		if( IsTournamentTarget( pMover ) )
		{
			return HITTYPE_TOURNAMENT;
			Error(" GetHitType2 tournament ");
		}
#endif //__TOURNAMENT

-------------------------------------

Unter diesem Code

		if( m_pActMover->IsFly() || pMover->m_pActMover->IsFly() )	// °øÁß¿¡ ÀÖÀ¸¸é ºÒ°¡ 
			return HITTYPE_FAIL;
		if( IsPVPTarget( pMover ) )
			return HITTYPE_PVP;
		if( IsWarTarget( pMover ) )
			return HITTYPE_WAR;
		if( IsSchoolTarget( pMover ) )
			return HITTYPE_SCHOOL;

#ifdef __JEFF_11_4
		if( IsArenaTarget( pMover ) )
			return HITTYPE_ARENA;
#endif	// __JEFF_11_4

Adden wir

#ifdef __TOURNAMENT
		if( IsTournamentTarget( pMover ) )
		{
			return HITTYPE_TOURNAMENT;
			Error("GetHitType tournament");
		}
#endif //__TOURNAMENT

----------------------------

Unter der Funktion
BOOL CMover::IsPVPTarget( CMover* pMover )

Adden wir:

#ifdef __TOURNAMENT
BOOL CMover::IsTournamentTarget( CMover* pMover )
{
	BOOL bResult = FALSE;
	if( m_idDuelOther != NULL_ID && m_idDuelOther == pMover->GetId() )
		bResult = TRUE;

	if( bResult && ( pMover->GetWorld()->m_dwWorldID == WI_WORLD_ARENA && GetWorld()->m_dwWorldID == WI_WORLD_ARENA ) )
		bResult = TRUE;

	return bResult;
}

BOOL CMover::IsTournament()
{
	BOOL bResult = FALSE;
	if( GetWorld()->m_dwWorldID == WI_WORLD_ARENA )
		bResult = TRUE;

	return bResult;
}

#endif //__TOURNAMENT

_Common\MoverParam.cpp

 Spoiler

Im kopf der Datei adden wir

#ifdef __TOURNAMENT
#include "Tournament.h"
#endif //__TOURNAMENT

Die funktion
int CMover::GetMaxHitPoint()

Ersetzen wir damit:

int CMover::GetMaxHitPoint()
{
	if( IsInvalidObj(this) )	
		return 0;

	float factor = 1.0f;
	int nResult = GetParam( DST_HP_MAX, GetMaxOriginHitPoint( FALSE ) );
	int nFactor = GetParam( DST_HP_MAX_RATE, 0 );

	factor += (float)nFactor/(float)100;
	nResult	= (int)( nResult * factor );

#ifdef __JEFF_11
	if( nResult < 1 )
		nResult		= 1;
#endif	// __JEFF_11
#ifdef __WORLDSERVER
#ifdef __TOURNAMENT
	if( CTournamentMng::GetInstance()->IsSuddenDeath( this ) )
		return 1;
#endif //__TOURNAMENT
#endif //__WORLDSERVER
	return nResult; 
}

_Common\MoverSkill.cpp

 Spoiler

Wir suchen nach:

#ifdef __PK_PVP_SKILL_REGION
	if( pSkillProp->nEvildoing < 0 )	//PK ±ÝÁö±¸¿ª¿¡¼* ¾ÇÇà Á¾·ùÀÇ ½ºÅ³Àº PVP »ó´ë¿¡°Ô¸¸ »ç¿ëÇϵµ·Ï..
	{
		int nAttackerPK, nDefenderPK;
		nAttackerPK = nDefenderPK = 0;
		if( IsPlayer() && pTarget->IsPlayer() && (this != pTarget) ) //(this!=pTarget) - Ÿ°ÙÀ» ¾ÈÂï´Â ½ºÅ³Àº Ÿ°ÙÀÌ ½ÃÀüÀÚÀÌ´Ù.
		{
			DWORD dwRegionAttr	= GetPKPVPRegionAttr();
			nAttackerPK = IsPKPVPInspectionBase( dwRegionAttr, FALSE );
			nDefenderPK = pTarget->IsPKPVPInspectionBase( dwRegionAttr, FALSE );
			if( (nAttackerPK == 1 || nDefenderPK == 1) &&
				!( 
						IsPVPTarget( pTarget )
					|| IsWarTarget( pTarget )
					|| IsGuildCombatTarget( pTarget ) 
#ifdef __JEFF_11_4
					|| IsArenaTarget( pTarget )
#endif	// __JEFF_11_4

Und fügen darunter dies ein:

#ifdef __TOURNAMENT
					|| IsTournamentTarget( pTarget )
#endif //__TOURNAMENT

Wir suchen nach

	#ifdef __WORLDSERVER
		if( pSkillProp->dwUseChance == WUI_NOW )	// ˬ - ¸®¼Ò½º ÇØÅ·
			return FALSE;
		if( pSkillProp->dwExeTarget == EXT_SELFCHGPARAMET )
			return FALSE;

		if( pTarget->IsNPC() && pTarget->IsPeaceful() )	
			return FALSE;	// NPCÁö¸¸ Ä£ÇÑ?NPC¿¡°Õ ½ºÅ³ »ç¿ë ±ÝÁö
		
		if( !g_eLocal.GetState( EVE_STEAL ) )
		{
			if( pSkillProp->nEvildoing < 0 )	// ³ª»Û¸¶¹ýÀ» ¾²·ÁÇÒ¶§
				if( IsSteal( pTarget ) )	// pTarget¸¦ ½ºÆ¿ ÇÏ·ÁÇϸé 
					return FALSE;
		}
#ifdef __JEFF_11_4
		if(  pWorld && pWorld->IsArena() == FALSE )		// ¾Æ·¹³ª°¡ ¾Æ´Ï¸é,
#endif	// __JEFF_11_4
		{

Und fügen darunter ein:

#ifdef __TOURNAMENT
			if( IsTournament() )
#endif //__TOURNAMENT

_Interface\WndField.cpp

 Spoiler

Die funktion
void CWndRevival::OnDraw( C2DRender* p2DRender )

Ersetzen wir damit:

void CWndRevival::OnDraw( C2DRender* p2DRender ) 
{ 
#ifdef __JEFF_11_4
	BOOL	bArena	= g_pPlayer->GetWorld() && g_pPlayer->GetWorld()->IsArena(); 
#endif	// __JEFF_11_4
	if( NULL == g_pPlayer->m_Inventory.GetAtItemId( II_SYS_SYS_SCR_RESURRECTION )
#ifdef __JEFF_11_4
		|| bArena
#endif	// __JEFF_11_4
#ifdef __TOURNAMENT
		|| g_pPlayer->IsTournament()
#endif //__TOURNAMENT
		)
		m_pRevival->EnableWindow( FALSE );
	else
		m_pRevival->EnableWindow( TRUE );
}

Wir suchen nach

	m_pLodeLight->m_strToolTip = _T( prj.GetText(TID_GAME_TOOLTIP_LODELIGHT) );//"·Îµå¶óÀÌÆ®´Â ¿©ÇàÀÚ°¡ Á÷Á¢ ÁöÁ¤ÇÑ ºÎÈ° À§Ä¡ÀÔ´Ï´Ù." );
	m_pLodeStar->m_strToolTip = _T( prj.GetText(TID_GAME_TOOLTIP_LODESTAR) );//"·Îµå½ºÅ¸´Â Àα٠¸¶À»ÀÇ ºÎÈ° À§Ä¡ÀÔ´Ï´Ù." );
	m_pRevival->m_strToolTip = _T( prj.GetText(TID_GAME_TOOLTIP_OGNPOINT) );
#if __VER >= 9 // __S_9_ADD
	m_pShop->m_strToolTip = _T( prj.GetText(TID_GAME_TOOLTIP_SHOP) );
#endif // __S_9_ADD

#ifdef __JEFF_11_4
	BOOL	bArena	= g_pPlayer->GetWorld() && g_pPlayer->GetWorld()->IsArena(); 
#endif	// __JEFF_11_4
	if( NULL == g_pPlayer->m_Inventory.GetAtItemId( II_SYS_SYS_SCR_RESURRECTION )
#ifdef __JEFF_11_4
		|| bArena
#endif	// __JEFF_11_4

Und adden darunter

#ifdef __TOURNAMENT
		|| g_pPlayer->IsTournament()
#endif //__TOURNAMENT

WndManager.cpp

 Spoiler

In der Funktion CWndMgr::CWndMngr

Adden wir:

#ifdef __TOURNAMENT
	m_pTournamentMenu = NULL;
	m_pTournamentTimer = NULL;
	m_pTournamentTable = NULL;
#endif //TOURNAMENT

Unter diesem Code:

#ifdef __GUILD_HOUSE_MIDDLE
	else if( m_pWndGHBid == pWndChild )
	{
		SAFE_DELETE( m_pWndGHBid );
		pWndChild = NULL;
	}
#endif //__GUILD_HOUSE_MIDDLE

Adden wir:

#ifdef __TOURNAMENT
	else if( m_pTournamentMenu == pWndChild)
	{
		SAFE_DELETE( m_pTournamentMenu );
		pWndChild = NULL;
	}
	else if( m_pTournamentTimer == pWndChild )
	{
		SAFE_DELETE( m_pTournamentTimer );
		pWndChild = NULL;
	}
	else if( m_pTournamentTable == pWndChild )
	{
		SAFE_DELETE( m_pTournamentTable );
		pWndChild = NULL;
	}
#endif //__TOURNAMENT

_Interface\WndManager.h

 Spoiler

Im kopf der Datei adden wir:

#ifdef __TOURNAMENT
#include "WndTournament.h"
#endif //__TOURNAMENT

Unter diesem Code

	// ¸ÞÁö½Ã À©µµ
	CWndMessageBox*		m_pWndMessageBox;
	CWndMessageBoxUpper*		m_pWndMessageBoxUpper;

	//	Äù½ºÆ® ¾ÆÀÌÅÛ Á¤º¸
	CWndQuestItemInfo*	m_pQuestItemInfo;

Adden wir

#ifdef __TOURNAMENT
	CWndTournamentMenu*		m_pTournamentMenu;
	CWndTournamentTimer*	m_pTournamentTimer;
	CWndTournamentTable*	m_pTournamentTable;
#endif //__TOURNAMENT

_Interface\WndWorld.cpp

 Spoiler

Unter diesen Coden:

BOOL CWndWorld::OnCommand( UINT nID, DWORD dwMessage, CWndBase* pWndBase )
{
	CCtrl* pFocusObj = (CCtrl*)g_WorldMng()->GetObjFocus();
	CMover* pFocusMover = (CMover*)pFocusObj;
	if( pWndBase == &m_wndMenuMover && pFocusObj )
	{
		Error("error nID %i", (int)nID);
		switch( nID )
		{

Adden wir:

#ifdef __TOURNAMENT
		case MMI_TOURNAMENT_MENU:
			{
				g_DPlay.SendTournamentMenuView();
			}
			break;
		case MMI_TOURNAMENT_TABLE:
			{
				g_DPlay.SendTournamentTableView();
			}
			break;
#endif //__TOURNAMENT

_Network\MsgHdr.h

 Spoiler

Hier definieren wir noch die Packete:

#ifdef __TOURNAMENT
#define	PACKETTYPE_TOURNAMENT			(DWORD)0x88E00000
#endif //__TOURNAMENT

#ifdef __TOURNAMENT
#define	SNAPSHOTTYPE_TOURNAMENT						(WORD)0xF000
#endif //__TOURNAMENT

Resource:

 Spoiler

Resdata.inc
Diese zwei Applets adden:

 Spoiler

APP_TOURNAMENT_TABLE "WndTile00.tga" 1 608 512 0x2410000 26
{
// Title String
IDS_RESDATA_INC_006338
}
{
// Help Key
IDS_RESDATA_INC_006339
}
{
WTYPE_STATIC WIDC_STATIC1 "Slottest.bmp" 0 268 52 332 116 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC2 "Slottest.bmp" 0 140 176 204 240 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC3 "Slottest.bmp" 0 396 176 460 240 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC4 "Slottest.bmp" 0 74 300 138 364 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC5 "Slottest.bmp" 0 204 300 268 364 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC6 "Slottest.bmp" 0 332 300 396 364 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC7 "Slottest.bmp" 0 460 300 524 364 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC8 "" 0 248 22 352 42 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC9 "" 0 120 146 224 166 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC10 "" 0 376 146 480 166 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC11 "" 0 54 270 158 290 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC12 "" 0 184 270 288 290 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC13 "" 0 312 270 416 290 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
WTYPE_STATIC WIDC_STATIC14 "" 0 440 270 544 290 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_007457
}
{
// ToolTip
IDS_RESDATA_INC_007457
}
}
APP_TOURNAMENT_MENU "WndTile00.tga" 1 304 448 0x2410000 26
{
// Title String
IDS_RESDATA_INC_100000
}
{
// Help Key
IDS_RESDATA_INC_100001
}
{
WTYPE_STATIC WIDC_STATIC1 "WndEditTile200.tga" 1 20 20 116 36 0x2220001 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100002
}
{
// ToolTip
IDS_RESDATA_INC_100003
}
WTYPE_STATIC WIDC_STATIC2 "" 0 134 20 270 36 0x2220000 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100004
}
{
// ToolTip
IDS_RESDATA_INC_100005
}
WTYPE_STATIC WIDC_STATIC3 "WndEditTile200.tga" 1 20 342 116 358 0x2220001 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100006
}
{
// ToolTip
IDS_RESDATA_INC_100007
}
WTYPE_STATIC WIDC_STATIC5 "" 0 134 342 230 358 0x2220000 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100008
}
{
// ToolTip
IDS_RESDATA_INC_100009
}
WTYPE_BUTTON WIDC_BUTTON1 "ButtApply.tga" 0 18 374 90 394 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100010
}
{
// ToolTip
IDS_RESDATA_INC_100011
}
WTYPE_BUTTON WIDC_BUTTON2 "ButtGWRefresh.tga" 0 108 374 180 394 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100012
}
{
// ToolTip
IDS_RESDATA_INC_100013
}
WTYPE_BUTTON WIDC_CLOSE "ButtClose.tga" 0 198 374 270 394 0x220010 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100014
}
{
// ToolTip
IDS_RESDATA_INC_100015
}
WTYPE_LISTBOX WIDC_LISTBOX1 "WndEditTile00.tga" 1 22 58 278 320 0x20020000 0 0 0 0
{
// Title String
IDS_RESDATA_INC_100016
}
{
// ToolTip
IDS_RESDATA_INC_100017
}

}

ResData.txt.txt
Diese neuen Texte adden:

 Spoiler

IDS_RESDATA_INC_100000 Turnier Anmeldestatus
IDS_RESDATA_INC_100001
IDS_RESDATA_INC_100002 Übrige Zeit
IDS_RESDATA_INC_100003
IDS_RESDATA_INC_100004 4 Tag/e 12:10:31
IDS_RESDATA_INC_100005 Dies ist die verbleibende Zeit bis das Tournament beginnt.
IDS_RESDATA_INC_100006 Teilnehmer
IDS_RESDATA_INC_100007
IDS_RESDATA_INC_100008 0 Teilnehmer
IDS_RESDATA_INC_100009
IDS_RESDATA_INC_100010
IDS_RESDATA_INC_100011
IDS_RESDATA_INC_100012
IDS_RESDATA_INC_100013
IDS_RESDATA_INC_100014
IDS_RESDATA_INC_100015
IDS_RESDATA_INC_100016
IDS_RESDATA_INC_100017

defineNeuz.h
Die defines adden:

 Spoiler

#define MMI_TOURNAMENT_MENU 241
#define MMI_TOURNAMENT_TABLE 242

defineText.h

 Spoiler

#define TID_MMI_TOURNAMENT_MENU 7241
#define TID_MMI_TOURNAMENT_TABLE 7242

textClient.inc

 Spoiler

TID_MMI_TOURNAMENT_MENU 0xffffffff
{
IDS_TEXTCLIENT_INC_020000
}

TID_MMI_TOURNAMENT_TABLE 0xffffffff
{
IDS_TEXTCLIENT_INC_020001
}

textClient.txt.txt

 Spoiler

IDS_TEXTCLIENT_INC_020000 Turnier Anmeldung
IDS_TEXTCLIENT_INC_020001 Turnier Tabelle

[- DK]

Danke Ich machs mir nachher fertig
Es ist das was ich mir darunter vorstelle mit dem Tunier ? Also Pvp ..

[yannick2008]

Originally Posted by Armageddon ™

Danke Ich machs mir nachher fertig
Es ist das was ich mir darunter vorstelle mit dem Tunier ? Also Pvp ..

Sind 1vs1 Matches. Ist aber 1:1 wie ein richtiges Turnier aufgebaut.
Das schwerste daran war eher die berechnung wer gegen wen kämpft etc ^^

[- DK]

Originally Posted by yannick2008

Sind 1vs1 Matches. Ist aber 1:1 wie ein richtiges Turnier aufgebaut.
Das schwerste daran war eher die berechnung wer gegen wen kämpft etc ^^

Wäre nicht einfach mit DB Abfragen ? Also simple gesehen nh Abfrage wer mehr punte hat die gegeneinader antreten .. ;o ? Also Am anfang Zufalls Systen .. Mit Grundwert 1 .Danach je nach verloren und gewonnen 2 Punkte oder 0 (Die 0er fliegen raus) Dann wieder Zufalls System Immer so weiter bis am ende die gewisse anzahl bei raus kommt .. und die finalisten dann halt am ende aufeinander tretten ,wäre zwar pure abfragen ,aber es würde doch im grund prinzip genauso funktionieren oder nicht ?

[yannick2008]

Originally Posted by Armageddon ™

Wäre nicht einfach mit DB Abfragen ? Also simple gesehen nh Abfrage wer mehr punte hat die gegeneinader antreten .. ;o ? Also Am anfang Zufalls Systen .. Mit Grundwert 1 .Danach je nach verloren und gewonnen 2 Punkte oder 0 (Die 0er fliegen raus) Dann wieder Zufalls System Immer so weiter bis am ende die gewisse anzahl bei raus kommt .. und die finalisten dann halt am ende aufeinander tretten ,wäre zwar pure abfragen ,aber es würde doch im grund prinzip genauso funktionieren oder nicht ?

Nene dann würde das Turnier System nicht greifen.

[Rhyder`]

please post any ScreenShot

[Delightx3.]

Screens ?

[- DK]

Originally Posted by Delightx3.

Screens ?

Wenns noch nicht fertig ist ;O ? Vorstellung reicht doch eigentlich oder ?

[Srsly']

Ich hoffe Mentus kommt nachher um deinen Code zu kritisieren. Dann siehst du mal das du nur labern kannst. Etioom steckt dir alles ins Popöchen

@Topic: Finde das System an sich nicht schlecht, nur man releast keine unvollständigen sachen.

[xTwiLightx]

Resourcen sind kinderkram, die schaut man sich an und hat den Dreh nach spätestens ner Woche raus.

Serverbesitzer sollten sich um die Verwaltung des Servers und nicht um den Code kümmern. Dafür gibt es "Developer".

yannick hat hier einen Ansatz eines Turniersystems gepostet, das er evtl noch erweitern wird. Leute, die ungeduldig sind, können diesen Release also als Basis nehmen und ihn erweitern. Oder man wartet eben, bis er vervollständigt wird.

Wenn einer über seinen Post nachdenken sollte, dann die Person, die auf Beef wartet und sich über den virtuellen Zwiespalt zweier Personen freut.
yannick kann neben dem Labern aber auch zumindest irgendwas an Coding, von dir habe ich hier nichts Produktives gesehen.

[IaMWatchingYouu]

Originally Posted by Srsly'

Es gibt viele Serverbesitzer die sich wirklich sehr gut in den Resourcen auskennen. Jedoch können sie keine eigenen Systeme schreiben (von daher auch nicht fertig schreiben).

Also bevor du was postest, denke darüber nach!

Das ist der Punkt worauf Twillight hinaus wollte LOL , sollen sie halt sich die Funtkionen Googlen , oder sich nen Buch kaufen und die Sprache selber lernen , und ein bischen eigen initiative ergreifen.

YOU KNOW?
Yannick wusste das dus releast..^^
@Antispam , nice work naja... , funtz ja bischen ingame

[TrøublêMakêr]

@ SeriouS'
IamWatchingYouu und Yannick sind dicke.


Nicht schlecht, wenn Turnier System komplett funktionieren würde.

[SourceShop]

work with 100%?

[yannick2008]

Originally Posted by Delightx3.

Screens ?

Werde ich heute oder morgen Abend posten.

Originally Posted by Srsly'

Ich hoffe Mentus kommt nachher um deinen Code zu kritisieren. Dann siehst du mal das du nur labern kannst. Etioom steckt dir alles ins Popöchen

Ohgott ich schlottere schon vor angst xDDDDDDDDDDDDD

Solll er halt kommen und was kritisieren. So ein noob findet doch nichtmal fehler wenn sie vor seiner Nase breakdance tanzen.

Seltsam. Ich hatte kein Internet als ich das System geschrieben habe. Wie konnte mir da Etioom etwas ins Popöchen stecken bzw. macht er in Sachen Flyff garnichtsmehr (außer er lacht noch herzlich mit mir über noobs wie euch).

Originally Posted by SourceShop

work with 100%?

Es funktioniert eigentlich 100%.

Man muss eigentlich nur noch die Visuelle turnier tabelle etwas aufpeppen und ein Belohnungssystem am ende einbauen.

Sowas wie Datenbank speicherung kann man bei belieben auch noch hinzufügen.

[Мentus]

Originally Posted by Srsly'

Ich hoffe Mentus kommt nachher um deinen Code zu kritisieren. Dann siehst du mal das du nur labern kannst. Etioom steckt dir alles ins Popöchen

@Topic: Finde das System an sich nicht schlecht, nur man releast keine unvollständigen sachen.

Auch wenn es so sein mag - ich halte mich daraus, ich bin um einiges reifer im Kopf als manch einer glaubt.

Originally Posted by SourceShop

work with 100%?

und schon kommen diese internationalen Leecher aus ihren Löcher'n gekrochen, das ist nicht mehr schön.

@Yannick
Ich werde deine Code NICHT kritisieren, er schaut ok aus, klar hab ich bei oder andern Sachen meine Bedenken, aber du hast zu entscheiden wie du dein Zeug's programmierst.


Aber.. :
Jedoch gebe ich dir einen Tipp: Schau dir mal die Definition & Deklaration von CUser an. ( Das Casten von CUser nach CMover ist überflüssig. )
Genau so wie bei der "For" Schleife, caste nicht zu int, sondern definiere i mit dem Typen unsigned int, schon hast du keine Warnings mehr. ( m_vecMembers.size() returnt soweit ich weiß ein unsigned [ size_t( size_type ) ?] )

Das sind echt keine "Niedermachungen", das ist nur ein Tipp!