Ich hab eine vereinfachte Version des Klassensystems erstellt aber mir fehlt noch ein Zeiger auf CBasePlayer zum verteilen der Waffen/Munition.

Kann mir da jemand helfen?

Beim kurzen Überfliegen des Codes seh ich da nur GetLocalPlayer().

Danke Koraktor wie immer eine große hilfe

Aber ich such noch 2 weitere sachen:
Einmal die Codes für item_suitrecharger und dann noch einen um die Maximale Rüstung zusetzen
Wenn ich die hab wäre ich wieder ein ganzes Stück weiter

Ich hab ein kleines Problem!
In der player.h ist keine Methode GetLocalPlayer(); aber eine ist in der c_baseplayer.h aber das ist für die Klasse C_BasePlayer aber ich brauch das für CBasePlayer da ich die Methoden GiveWeapons und GetNamedItem für Waffen und Munitions verteilung

Wenn ich mich bloß richtig im HL2-Code auskennen würde.
Also einen Pointer auf CBasePlayer kriegt man scheinbar nur beim Erstellen (CreatePlayer()). Da müsste man mal genau nachschauen, wo der Spieler erstellt wird und wie er gespeichert wird, das wird nämlich mit Sicherheit irgendwo gemacht.

Stimmt Der Spieler wird nur erstellt aber nicht gespeichert

Hab nämlich ein kleines Problem
Ich hab ein Klassensystem für meine Mod gecodet!

Hier mal der Code für die erste version:

//ClassSystem.h

---

#ifndef _CClasses_H
#define _CClasses_H

/*
=================================================
==Army Mod Klassensystem!
==Diese Klassensystem ist für die Army Mod!
==Muss noch implementiert werden!
=================================================
*/


//Valve Includes:
#include <convar.h>

//Hier muss ich den Server ansprechen:
#ifdef Client_Dll
#include "player.h"
#endif

//#include "c_baseplayer.h"


//Eigene Includes:
//#include "Slotsystem.h"

//Maximalen Speed setzen in CBasePlayer(Deklaration!)
//void SetMaxSpeed( float flMaxSpeed )



//Konsolenfunktionen für Klassenwechsel setzen!
//ConVar ClassFunction


//Das ist für die einteilung der Klassen!
enum //CLASS_
{
Invalid=-1,
Unassigned,
SpecOps,
Sniper,
Assaulter,
Supporter,
Medic,
Rocketteer,
Spy
};



/*
//Dies ist für die Scoreboard Ausgaben!
//Das Array und das enum werden in der Klasse CClassSystem verwendet!
char* ClassNames[] =
{
//"Invalid",
"Unassigned",
"Spec-Ops",
"Sniper",
"Assault",
"Support",
"Medic",
"Rocketteer",
"Spy"
};
*/

/*
//Defines für Leben/Armor jeder Klasse:
#define Spec_Ops_Health
#define Spec_Ops_Armor

#define Spec_Ops_MaxHealth
#define Spec_Ops_MaxArmor
*/




class CClassSystem /*: public CSlotSystem;*/
{
public:

//Konstruktor/Destruktor!
CClassSystem();
virtual ~CClassSystem();


/*
=======================================================================================
==Klassensystem:
==Hier werden die Klassen verteilt!
==Es wird auch auf die richtigen Klassen geprüft!
=======================================================================================
*/


//Initalisierung des Klassensystems!
void InitClassSystem();

//Zeiger auf CBasePlayer initalisieren!
void InitPointer(CBasePlayer* pPlayer2);

//Holt uns wichtige Sachen!
void GetClassSystemStuff();

//Holt den Integer für die Klassen:
void SetiClass();
void SetiClassConVar();
int GetiClassConVar()const;

void SetiDefaultClassConVar();
int GetiDefaultClassConVar()const;


//Holt die Namen der Klassen
void SetszClass();
void SetszClassConVar();
const char* GetszClassConVar()const;

void SetszDefaultClassConVar();
const char* GetszDefaultClassConVar()const;

/*
//Testet ob der Spieler seine Waffe/n erhalten hat!
//Prüfung ob es die jeweilige Klasse ist!
void HasCorrectClass();
bool GetCorrectClass()const;


//Bis auf die Standart waffen alle anderen Löschen,
//Spieler Killen und respawnen!
void OnChangeClass();


//Gibt unserer Klasse ein bestimmtes Model!
void SetPlayerClassModel();


//Legt unsere Klasse im Scoreboard fest:
void SetSBClass();
const char* GetSBClass()const;


//Legt die maximale Anzahl an Klassen fest:
void SetMaxClass();
int GetMaxClass()const;


//Leben/Armor/Sprint/Ausdauer holen:

//Legt das Leben für unsere klasse fest:
int GetClassHealth()const;

//Diese Methoden setzen für jede Klasse das Leben und die Armor
int GetClassMaxHealth()const;

//Legt die Armor für die Klasse Fest:
int GetClassArmor()const;

//Diese Methode holt die Maximale armor für die Klassen!
int GetClassMaxArmor()const;

//Setzt die geschwindigkeit für die Klassen!
int GetClassSpeed()const;

//Setzt die Sprint Geschwindigkeit beim Sprinten!
int GetClassCondition()const;


*/



/*
=======================================================================================
==Slotsystem:
==Hier werden Waffen und Items in Slots untergebracht.
==Dazu muss ich noch drag&Drop in VGUI einbauen!
=======================================================================================
*/

/*
//Setzt die Anzahl der Slots für Waffen usw.
virtual void SetMaxSlots();


//Holt unsere verbrauchten Slots:
virtual void SetUsedSlots();


//Holen wir uns die freien Slots:
virtual void SetFreeSlots();

//Holt unsere verbrauchten Slots:
virtual int GetUsedSlots()const;


//Holen wir uns die freien Slots:
virtual int GetFreeSlots()const;


//Fragt ab ob wir noch freie Slots haben!
virtual bool HasFreeSlots();


//Fragt ab ob wir noch genügend Slots haben(Wenn wir items aufnehmen wollen!
virtual bool HasEnoughSlots();
*/




private:


/*
=======================================================================================
==Klassensytem Variablen/Methoden:
=======================================================================================
*/

//Zeiger für die Methoden zum Waffen/Ammo verteilen:
CBasePlayer* pPlayer;

//Welche Klasse haben wir(enum/ConVar):
int m_iClass;

//Hier setzen wir die Standartklasse!
int m_iDefaultClass;

//Welche Klasse haben wir(enum/ConVar):
const char* m_szClass;

//Hier setzen wir die Standartklasse!
const char* m_szDefaultClass;

//Setzt die Maximalen Klassen fest!
int m_iMaxSpec_Ops;
int m_iMaxSniper;
int m_iMaxAssault;
int m_iMaxSupport;
int m_iMaxMedic;
int m_iMaxRocketteer;
int m_iMaxSpy;


//Waffen, Leben und Armor der Klassen verteilen:
void SetiDefaultClass();
void SetszDefaultClass();
void SetClassSpec_Ops();
void SetClassSniper();
void SetClassAssault();
void SetClassSupport();
void SetClassMedic();
void SetClassRocketteer();
void SetClassSpy();


//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
//Speichert den Wert vom Ammo Timer!
int m_iTimerAmmo;


//Eigenschaften von Support!
void CheckTimerAmmo();
void GetAmmo()const;
void GiveAmmo();



//Speichert den Timer für den Lebenstimer!
int m_iTimerHealth;


//Eigenschaften von Medic!
void CheckTimerHealth();
void GetHealth()const;
void GiveHealth();



//Speichert den Timer für den Tarnungswechsel
int m_iTimerCamouflage;


//Spions Stuff:
void SetCamouflage();
void GiveCamouflage();


//Haben wir die richtige Klasse?
bool m_bCorrectClass;
*/


/*
=======================================================================================
==Spielereigenschaften:
==Hier werden Eigenschaften wie Speed, Condition
==und maximale Klassen festgelegt!
=======================================================================================
*/

//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
//Leben/Armor für Jede Klasse:
int m_iHealth;
int m_iArmor;

//Maximal Leben/Armor für Jede Klasse:
int m_iMaxHealth;
int m_iMaxArmor;


//Gewicht der Klasse:
//int m_iWeight;


//Geschwindigkeit der Klasse:
int m_iSpeed;


//Kondition der Klasse:
int m_iCondition;
*/


/*
======================================================================================
==Unnötige Sachen?
==Alle Methoden werden durch Member ersetzt:
======================================================================================
*/


//Speichert/Lädt die Klassen!
//UNDONE:Wird in den ConVars gespeichert!
/*
void SaveClass();
void RestoreClass();

void SaveDefaultClass();
void RestoreDefaultClass();
*/

/*
********************************************
**Slotsystem Variablen:
********************************************
*/

//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
//Anzahl unserer Slots für das Menu:
virtual int m_iMaxSlots;


//Anzahl der genutzten Plätze:
virtual int m_iUsedSlots;


//Anzahl der freien Slots:
virtual int m_iFreeSlots;
*/



/*
********************************************
**Waffensytem Variablen:
********************************************
*/

//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
//Welche Waffe haben wir:
int m_iWeapon;

//Diese Variable verteilt unsere Magazine:
int m_iMagazin;
*/


protected:

/*
======================================================================================
==Erstmal nix hier rein!
======================================================================================
*/
};


//Diese Klasse soll das Klassen Limit setzen!
//UNDONE: Wird im Klassensystem selbst geregelt!
/*
class ClassLimit
{
public:
//Konstruktor/Destruktor:
ClassLimit();
~ClassLimit();


//Setzt das Limit der Maximalen Klassen:
SetClassLimit();


//Holt das Limit der Maximalen Klassen:
GetClassLimit();
private:
protected:
};
*/

#endif //_CClasses_H

---

//ClassSystem.cpp

---

/*
=================================================
==Army Mod Klassensystem!
==Diese Klassensystem ist für die Army Mod!
==Muss noch implementiert werden!
=================================================
*/

//Valve's Header:
#include <cbase.h>
#include "baseplayer_shared.h"



//Eigene Header:

//Waffensystem:
//#include "WeaponSystem.h"

//Magazin Definitionen:
#include "Magazin.h"

//Slotsystem:
//#include "Slotsystem.h"

//Definitionen der Slotanzahlen:
//#include "Slots.h"

//Das wichtigste(Das Klassensystem):
#include "ClassSystem.h"



//Mein ConVars für das Klassensystem:

//ConVars für das Klassensystem:
//Timer Stuff:
ConVar Timer_Ammo("Timer_Ammo","3",FCVAR_ARCHIVE,"Variable für Zeit(in Sek.) für neue Ammo(Supporter)");
ConVar Timer_Health("Timer_Health","3",FCVAR_ARCHIVE,"Variable für Zeit(in Sek.) für neuees Leben(Medic)");


//Klassensystem Integer ConVars:
ConVar iClass("Class", "3", FCVAR_ARCHIVE, "Klassen Variable für Konsole!");
ConVar iDefault_Class("Default_Class", "3", FCVAR_ARCHIVE, "Variable für Standartklasse!");

//Klassensystem String ConVars:
//ConVar szClass("Class", "Assaulter", FCVAR_ARCHIVE, "Klassen Variable für Konsole!");
//ConVar szDefault_Class("Default_Class", "Assaulter", FCVAR_ARCHIVE, "Variable für Standartklasse!");


//Maximale Klassen erlauben(Admins!)
ConVar Max_Spec_Ops("Max_Spec_Ops", "3", FCVAR_ARCHIVE, "Variable für Maximale Spec-Ops!");
ConVar Max_Sniper("Max_Sniper", "3", FCVAR_ARCHIVE, "Variable für Maximale Sniper!");
ConVar Max_Assault("Max_Assault", "3", FCVAR_ARCHIVE, "Variable für Maximale Assaulter!");
ConVar Max_Support("Max_Support", "3", FCVAR_ARCHIVE, "Variable für Maximale Supporter!");
ConVar Max_Medic("Max_Medic", "3", FCVAR_ARCHIVE, "Variable für Maximale Medics!");
ConVar Max_Rocketteer("Max_Rocketteer", "3", FCVAR_ARCHIVE, "Variable für Maximale Rocketteer!");
ConVar Max_Spy("Max_Spy", "3", FCVAR_ARCHIVE, "Variable für Maximale Spy's!");



//Konstruktor/Destruktor!
CClassSystem::CClassSystem()
{
//Code hier rein!
//Finale!

//TODO:Hier muss der Zeiger auf 0 und in InitPointer eine Adresse bekommen!
pPlayer=new CBasePlayer;
//pPlayer=Player;

//Startklasse festlegen:
m_iClass=iClass.GetInt();

//Die standart Klasse also Assault also 3 setzen!
m_iDefaultClass=iDefault_Class.GetInt();

//Startklasse festlegen:
//m_szClass=szClass.GetString();
m_szClass="None";

//Die standart Klasse also Assault also 3 setzen!
//m_szDefaultClass=szDefault_Class.GetString();
m_szDefaultClass="None";

m_iMaxSpec_Ops=Max_Spec_Ops.GetInt();
m_iMaxSniper=Max_Sniper.GetInt();
m_iMaxAssault=Max_Assault.GetInt();
m_iMaxSupport=Max_Support.GetInt();
m_iMaxMedic=Max_Medic.GetInt();
m_iMaxRocketteer=Max_Rocketteer.GetInt();
m_iMaxSpy=Max_Spy.GetInt();

//Start Timer festlegen!
//m_iTimerAmmo=Timer_Ammo.GetInt();
//m_iTimerHealth=Timer_Health.GetInt();
//m_iTimerCamouflage=Timer_Camouflage.GetInt();


//Standartwerte 100 für leben/armor:
//m_iHealth=100;
//m_iArmor=100;

//Maximal Leben/Armor für Jede Klasse:
//m_iMaxHealth=100;
//m_iMaxArmor=100;


//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
//Gewicht standartmäßig auf 0 setzen!
//m_iWeight=0;


//Geschwindigkeit standartmäßig auf 0 setzen!
m_iSpeed=0;


//Kondition standartmäßig auf 0 setzen!
m_iCondition=0;


//Welche Waffe haben wir:
m_iWeapon=Weapon_None;


//Kein Magazin also 0!
m_iMagazin=Magzin_None;


//Slots(insgesamt 42, pro Klasse festlegen:
m_iMaxSlots=0;


//Genutzte Slots festlegen:
m_iUsedSlots=0;


//Freie Slots festlegen:
m_iFreeSlots=m_iMaxSlots;
*/
}



void CClassSystem::InitPointer(CBasePlayer* pPlayer2)
{
pPlayer=pPlayer2;
}



void CClassSystem::SetiClassConVar()
{
DevMsg("Spieler bekommt Klassezugewissen!\n");
m_iClass=iClass.GetInt();
}



int CClassSystem::GetiClassConVar()const
{
return m_iClass;
}



void CClassSystem::SetiDefaultClassConVar()
{
m_iDefaultClass=iDefault_Class.GetInt();
}



int CClassSystem::GetiDefaultClassConVar()const
{
return m_iDefaultClass;
}



//Hier sind alle aufrufe die wir brauchen(Client):
/*
GetDefaultClass();
HasCorrectClass();
*/


void CClassSystem::InitClassSystem()
{
DevMsg("Klassensystem wird initalisiert!\n");
SetiClassConVar();
SetiDefaultClassConVar();
//SetszClassConVar();
//SetszDefaultClassConVar();

//SetSBClass();
SetiClass();
}


//Prüft ob wir die richtige Klasse haben!
//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
void CClassSystem::HasCorrectClass()
{

switch(m_iClass)
{
case CLASS_INVALID:
m_bCorrectClass=false;
break;

case CLASS_UNASSIGNED:
m_bCorrectClass=false;
break;

case CLASS_SPEC-OPS:
m_bCorrectClass=true;
break;

case CLASS_SNIPER:
m_bCorrectClass=true;
break;

case CLASS_ASSAULT:
m_bCorrectClass=true;
break;

case CLASS_SUPPORT:
m_bCorrectClass=true;
break;

case CLASS_MEDIC:
m_bCorrectClass=true;
break;

case CLASS_ROCKETTEER:
m_bCorrectClass=true;
break;

default:
m_bCorrectClass=false;
break;
}
}


bool CClassSystem::GetCorrectClass()const
{
return m_bCorrectClass;
}
*/

/*
********************************************
**Klassensystem:
**Hier werden die Klassen verteilt!
**Es wird auch auf die richtigen Klassen geprüft!
********************************************
*/


//Aufruf nur in CBasePlayer::!
//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
void CClassSystem::OnChangeClass()
{
//Spieler killen und punkte um 1 erhöhen(wegen Selbstmord)!
CommitSuicide();
IncrementFragCount(1);
}


//Hier stellen wir den Namen der Klasse für das Scoreboard ein!
void CClassSystem::SetSBClass()
{
switch(m_iClass)
{
case CLASS_INVALID:
{
//To Do: Hier sollte ich eine Bessere Lösung finden!
m_szClass="Invalid";
break;
}

case CLASS_UNASSIGNED:
{
m_szClass=ClassNames[CLASS_UNASSIGNED];
break;
}

case CLASS_SPEC-OPS:
{
m_szClass=ClassNames[CLASS_SPEC-OPS];
break;
}

case CLASS_SNIPER:
{
m_szClass=ClassNames[CLASS_SNIPER];
break;
}

case CLASS_ASSAULT:
{
m_szClass=ClassNames[CLASS_ASSAULT];
break;
}

case CLASS_SUPPORT:
{
m_szClass=ClassNames[CLASS_SUPPORT];
break;
}

case CLASS_MEDIC:
{
m_szClass=ClassNames[CLASS_MEDIC];
break;
}

case CLASS_ROCKETTEER:
{
m_szClass=ClassNames[CLASS_ROCKETTEER];
break;
}

default:
{
m_szClass=ClassNames[CLASS_UNASSIGNED];
break;
}
}
}

//Hier holen wir uns unsere Klasse für das Scoreboard:
const char* CClassSystem::GetSBClass()const
{
return m_szClass;
}
*/


/*
***************************************************
**Waffenverteilt:
***************************************************
*/


//Soll die Waffen verteilen:
//Wird wahrscheinlich gelöscht!
void CClassSystem::SetiClass()
{
switch(m_iClass)
{
case Invalid:
//Muss noch eingebaut werden!
//Hier bekommt man nur die standart Waffen!
SetiDefaultClass();
break;

case Unassigned:
//Hier setzen wir die Standart-Klasse!
SetiDefaultClass();
break;

case SpecOps:
SetClassSpec_Ops();
break;

case Sniper:
SetClassSniper();
break;

case Assaulter:
SetClassAssault();
break;

case Supporter:
SetClassSupport();
break;

case Medic:
SetClassMedic();
break;

case Rocketteer:
SetClassRocketteer();
break;

case Spy:
SetClassSpy();
break;

default:
SetiDefaultClass();
break;
}
}




//Default:
void CClassSystem::SetiDefaultClass()
{
DevMsg("Standart Klasse wird abgerufen!\n");
Msg("Default Klasse wird gewählt!\n");

m_iClass=m_iDefaultClass;
SetiClass();
}


//Hier holen wir uns die Standart Klasse und Starten erneut die Klassenwahl:
void CClassSystem::SetszDefaultClass()
{
DevMsg("Standart Klasse wird abgerufen!\n");
Msg("Default Klasse wird gewählt!\n\n");

m_szClass=m_szDefaultClass;
//SetszClass();
}


//Spec-Ops:
void CClassSystem::SetClassSpec_Ops()
{
//Code hier rein!
//m_szClassName=ClassNames[CLASS_SPEC_OPS];

//Waffen verteilen:
Msg("Du hast die Klasse Spec-Ops!\n");
pPlayer->GiveNamedItem( "weapon_shotgun" );
pPlayer->GiveNamedItem( "weapon_slam" );
pPlayer->GiveNamedItem( "weapon_frag" );

pPlayer->GiveAmmo( Magazin_Shotgun, "Buckshot");
pPlayer->GiveAmmo( Magazin_Slam, "slam" );
pPlayer->GiveAmmo( Magazin_Frag, "grenade" );
}



//Sniper:
void CClassSystem::SetClassSniper()
{
//Code hier rein!
//m_szClassName=ClassNames[CLASS_SNIPER];

//Waffen verteilen:
Msg("Du hast die Klasse Sniper!\n");
pPlayer->GiveNamedItem( "weapon_crossbow" );
pPlayer->GiveNamedItem( "weapon_frag" );

pPlayer->GiveAmmo( Magazin_Crossbow , "XBowBolt" );
pPlayer->GiveAmmo( Magazin_Frag , "grenade" );
}


//Assault:
void CClassSystem::SetClassAssault()
{
//Code hier rein!
//m_szClassName=ClassNames[CLASS_ASSAULT];

//Waffen verteilen:
Msg("Du hast die Klasse Assault!\n");
pPlayer->GiveNamedItem( "weapon_smg1" );
pPlayer->GiveNamedItem( "weapon_frag" );

pPlayer->GiveAmmo( Magazin_SMG1 , "SMG1");
pPlayer->GiveAmmo( Magazin_SMG1_Granates, "smg1_grenade");
pPlayer->GiveAmmo( Magazin_Frag , "grenade" );
}


//Supporter
void CClassSystem::SetClassSupport()
{
//Code hier rein!
//m_szClassName=ClassNames[CLASS_SUPPORT];

//Waffen verteilen:
Msg("Du hast die Klasse Supporter!\n");
pPlayer->GiveNamedItem( "weapon_ar2" );
pPlayer->GiveNamedItem( "weapon_frag" );

pPlayer->GiveAmmo( Magazin_AR2, "AR2" );
pPlayer->GiveAmmo( Magazin_AR2AltFire, "AR2AltFire" );
pPlayer->GiveAmmo( Magazin_Frag, "grenade" );

//Eigenschaft des Supporter's aufrufen:
//GetAmmo();
}


//Medic:
void CClassSystem::SetClassMedic()
{
//Code hier rein!
//m_szClassName=ClassNames[CLASS_MEDIC];

//Waffen verteilen:
Msg("Du hast die Klasse Medic!\n");
pPlayer->GiveNamedItem( "weapon_357" );
pPlayer->GiveNamedItem( "weapon_smg1" );

pPlayer->GiveAmmo( Magazin_357, "357" );
pPlayer->GiveAmmo( Magazin_SMG1 , "SMG1");
pPlayer->GiveAmmo( Magazin_SMG1_Granates, "smg1_grenade");

//Eigenschaft des Medic's aufrufen:
//GetHealth();
}


//Rocketteer:
void CClassSystem::SetClassRocketteer()
{
//Code hier rein!

//Erst Variablen setzen:
//m_szClassName=ClassNames[CLASS_ROCKETTEER];

//Waffen verteilen:
Msg("Du hast die Klasse Rocketteer!\n");
pPlayer->GiveNamedItem( "weapon_357" );
pPlayer->GiveNamedItem( "weapon_rpg" );
pPlayer->GiveNamedItem( "weapon_frag" );

pPlayer->GiveAmmo( Magazin_357, "357" );
pPlayer->GiveAmmo( Magazin_RPG, "rpg_round");
pPlayer->GiveAmmo( Magazin_Frag, "grenade" );
}



//Spion:
void CClassSystem::SetClassSpy()
{
//Code hier rein!
//Erst Variablen setzen:
//m_szClassName=ClassNames[CLASS_SPY];

//Waffen verteilen:
Msg("Du hast die Klasse Spion!\n");
pPlayer->GiveAmmo( Magazin_Crossbow , "XBowBolt" );
pPlayer->GiveAmmo( Magazin_Slam, "SLAM" );

pPlayer->GiveNamedItem( "weapon_crossbow" );
pPlayer->GiveNamedItem( "weapon_slam" );
}





/*
********************************************
**Timer für Ammo:
**Dieser Timer ist eigentlich eine Think Methode
**(Umschreiben in ThinkTimerAmmo();!
********************************************
*/


//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
//Ist es wieder soweit für Ammo?
void CClassSystem::CheckTimerAmmo()
{
m_iTimerAmmo--;

if( m_iTimerAmmo<=0)
{
GetAmmo();
GiveAmmo();
m_iTimerAmmo=Next_Time_Ammo;
}

else
{
return;
}

return;
}



//Eigenschaften von Support/Medic!
void CClassSystem::GetAmmo()
{
//Hier mit bekommt der Support selbst ammo:
pPlayer->GiveAmmo( Magazin_Pistole , "Pistol");
pPlayer->GiveAmmo( Magazin_AR2 , "AR2" );
pPlayer->GiveAmmo( Magazin_AR2AltFire , "AR2AltFire" );
pPlayer->GiveAmmo( Magazin_SMG1 , "SMG1");
pPlayer->GiveAmmo( Magazin_SMG1_Granates , "smg1_grenade");
pPlayer->GiveAmmo( Magazin_Shotgun , "Buckshot");
pPlayer->GiveAmmo( Magazin_357 , "357" );
pPlayer->GiveAmmo( Magazin_RPG , "rpg_round");
pPlayer->GiveAmmo( Magazin_Frag , "grenade" );
pPlayer->GiveAmmo( Magazin_Slam , "slam" );
pPlayer->GiveAmmo( Magazin_Crossbow , "XBowBolts");

//Jetzt sind die anderen dran:
//To Do: Muss noch eingebaut werden!
}





//Hier Munition an die Spieler verteilen:
void CClassSystem::GiveAmmo();
{
}
*/



/*
********************************************
**Timer für Health:
**Dieser Timer ist eigentlich eine Think Methode
**(Umschreiben in ThinkTimerHealth();!
********************************************
*/

//UNDONE:Diese Sachen kommen erst in dernächsten Version dran!
/*
//Ist es wieder Soweit für Leben?
void CClassSystem::CheckTimerHealth()
{
m_iTimerHealth--;

if( m_iTimerHealth<=0)
{
GetHealth();
GiveHealth();
m_iTimerHealth=Next_Time_Health;
}

else
{
return;
}

return;
}




//Hier mit bekommt der Medic selbst Leben:
void CClassSystem::GetHealth()
{
//To Do: Muss noch eingebaut werden!

//Jetzt sind die anderen dran:
//To Do: Muss noch eingebaut werden!
}



//Hier Leben an die Spieler verteilen:
void CClassSystem::GiveHealth()
{
//To Do: Muss noch eingebaut werden!
}
*/




/*
*******************************************
**Slotsystem:
**Hier werden Waffen und Items in Slots untergebracht.
**Dazu muss ich noch drag&Drop in VGUI einbauen!
********************************************
*/

/*
void CClassSystem::SetMaxSlots()
{
//Setzt die Anzahl der Slots für Waffen usw.
//Hier die Slots für waffen bearbeiten:
m_iMaxSlots=42;
}



int CClassSystem::GetMaxSlots()const
{
return m_iMaxSlots;
}



//Legt die verbrauchten Slots fest!
void CClassSystem::SetUsedSlots()
{
//Setzt unsere belegten Slots:
m_iUsedSlots=m_iMaxSlots-m_iFreeSlots;
}


//Holt unsere belegten Slots:
int CClassSystem::GetUsedSlots()const
{
return m_iUsedSlots;
}



//Legt die freien Slots fest!
void CClassSystem::SetFreeSlots()
{
m_iFreeSlots=m_iMaxSlots-m_iUsedSlots;
}


//Hier holen wir uns dir freien Slots:
int CClassSystem::GetFreeSlots()const
{
return m_iFreeSlots;
}
*/

CClassSystem::~CClassSystem()
{
//Code hier rein!
//Final!

delete pPlayer;
}

---

So Ich brauch nämlich einen Pointer auf CBasePlayer, einen auch CHL2_Player und einen auf CHL2MP_Player aber kann ich das nicht so machen das ich CBasePlayer nicht einfach das Klassensystem erben lasse so das CBasePlayer, CHL2_Player und CHL2MP_Player nicht einfach die Funktionen mit CClassSystem::Methode aufrufen können?

Den ich Brauch CBasePlayer um die Waffen/Munition zuverteilen.
Dann brauch ich CHL2_Player umd die Maximale Armor festzulegen und CHL2MP_Player soll das Klassensystem mit InitClassSystem() aktivieren!

Damit ihr wisst warum ich den Code zeige->Dies ist eine Open Source Mod an der jeder mit machen darf aber ich verwalte Code und Client!

---

class CHL2_Player : public CBasePlayer

---

bzw.

---

class CHL2MP_Player : public CHL2_Player

---

Also reicht z.B. CClassSystem PlayerClass innerhalb der Klasse CBasePlayer.
Ich kenn ja die Mod nicht, aber warum überhaupt diese Aufteilung? In einer MP-Mod würde es doch auch reichen alles in CHL2MP_Player reinzupacken.

Bestimmt schon aber ich möchte im Code eine gute übersicht haben und wenn ich jetzt alles in CHL2MP_Player packe dann ist die Übersicht wohl eher für die Katz!

EDIT
Danke für den Tip hoffe es klappt

EDIT2
Irgend wie geht es nicht
Ich hab zwar das Objekt der Klasse CClassSystem deklariert aber es wird nicht weiter vererbt
Kann ich es als Virtual weiter vererben? bzw kann man Allgemein Member vererben lassen?

EDIT3
So hab alles aus dem Klassensystem in CHL2MP_Player gepackt und es funktioniert perfekt Danke Koraktor

Client un Source Code werd ich heute abend auf Filefront uppen

Okay jetzt bbrauch ich 2 weitere Sachen
Ich hab jetzt den gesamten Code in die CHL2MP_Player Klasse gepackt!
Dadurch funktioniert alles wie gewollt Aber ich muss noch die GetHealth(), GetMaxHealth(), GetArmor() und die GetMaxArmor() Methoden in CBasePlayer und in der baseplayer_shared.cpp einbauen.

Den in CBasePlayer::SharedSpawn wird das Maximale Leben und die Start Armor festgelegt die ich aber je nach Klasse varieiren lassen will

Dann muss ich auch noch die Maximalrüstung einstellen aber ich weiß noch nicht wo das gesetzt wird

Ich glaub das steht in einer Config-Datei...

Ja im Singelplayer hat Valve das über die ConVars geregelt aber nicht im MP und das will ich jetzt direkt im Code regeln!

Die Startarmor hab ich gesetzt!
Jetzt muss ich noch Leben, Maximal Leben und Maximalrüstung setzen!