C++ Variablen "verknüpfen" aus zwei Klassen.

[100Lifes]

Guten Tag Zusammen
Ich bin ein Neuling der erst vor einer Woche mit C++, was meine erste OOP ist, angefangen.
Nun habe ich angefangen ein kleines sehr banales Spielchen zu erstellen und habe zwei Klassen.

Waffen

class Weapon {
public:
	string s_Name;
	int n_MinDmg;
	int n_MaxDmg;
	int n_CritDmg;
	Weapon(string a, int x, int y, int z) {
		s_Name = a;
		n_MinDmg = x;
		n_MaxDmg = y;
		n_CritDmg = z;
	}
};

Spieler

class Player {
public:
	string s_Name;
	int n_Health;
	int n_Xp;
	int n_Resistence; // 1-20
	int n_Level;
	string s_Weapon;
	Player(string n, int h, int x, int r, int l, string w) {
		s_Name = n;
		n_Health = h;
		n_Xp = x;
		n_Resistence = r;
		n_Level = l;
		s_Weapon = w;
	}
};

Ich difiniere die Variablen für die jeweiligen Waffen welche ausgerüstet werden in Weapon und hinterlege den Namen des Objekts im Player. Die Erstellung der beiden Objekten sieht wie folgt aus:

	// Initialize Player character
	// PlayerName, Health, XP, Resistence, Level, Equiped Weapon
	Player Player1("xxx", 100, 0, 1, 1, "stick");

	// Initialize all Weapon Types
	// Name, minDmg, maxDmg, critDmg
	Weapon stick("Basic Stick", 1, 2, 2);

Jetzt möchte ich z.B. wenn man das Inventar öffnet und Details zur Waffen angezeigt haben möchte, dass die Values im Weapon Objekt abgerufen werden, da es natürlich mehrere verschiedene Waffen geben sollte.
Unter anderem habe ich es schon mit einem gebastelten Pointer probiert:

// in der main function
string* PlayerWeapon = &Player1.s_Weapon;
cout << PlayerWeapon->n_MinDmg << endl;

Oder auch ganz "billig" mit einer Art verkettung:

cout << Player1.s_Weapon.n_MinDmg << endl;

Und auch schon mit einer tulpn Funktion um am Ende mehrere Values auf einmal zurück zu geben. Leider blieb bislang alles ohne Erfolg.

Wäre da um Input sehr dankbar und wie angekündigt, steh ich leider noch sehr am Anfang.

[Swordfish]

Was sollen diese s_ und n_? Lass das! Die einbuchstabigen Bezeichner für die Parameter sind auch nicht der burner.

[Th69]

Du solltest nicht den Namen der Waffe in der Player-Klasse benutzen, sondern ein Weapon-Objekt selbst (Variablen können nicht als Strings ausgelesen werden - C++ unterstützt keine sog. Reflection):

class Player
{
public:
    // ...
    Weapon weapon;
};

So kannst du es dann direkt verwenden:

cout << Player1.weapon.n_MinDmg << endl;

Du mußt aber jetzt noch den Player-Konstruktor ändern.

PS: Üblicherweise sollten Member in Klassen nicht public sein, sondern private und dann passende Getter-Funktionen benutzt werden (aber das wirst du sicherlich noch nach und nach lernen).

[100Lifes]

@Swordfish sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

Was sollen diese s_ und n_? Lass das! Die einbuchstabigen Bezeichner für die Parameter sind auch nicht der burner.

Das hab ich so im Buch "C++ für Spieleprogrammierer" von Heiko Kalista gelernt, dass das eigentlich ein gewisser Standard ist. Hab ich da Mist gelernt?

@Th69 - Das wusste ich nicht, dass man ganze Objekte in anderen Objekten verbauen kann ohne etwas zu vererben oder sowas.
Dann kann ich wirklich einfach in der klasse string s_Weapon mit Weapon stick jetzt in dem Beispiel ersetzen und dann kann ich darauf zugreiffen?
Das wäre ja lässig... Und ich suche seit 3 Tagen nach einer Lösung für das Problem...
Aber du hast recht mit Private und Public. Bin aktuell Schritt für Schritt am machen und das mit den Getter und Settern hab ich auch schon angeschaut. Nur hat mir die Frage jetzt keine Ruhe gelassen.

[Swordfish]

@100Lifes sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

Dann kann ich wirklich einfach in der klasse string s_Weapon mit Weapon stick jetzt in dem Beispiel ersetzen und dann kann ich darauf zugreiffen?

ja.

[Swordfish]

Sonst wenn Du sowas wie ein Inventar willst und dynamisch dessen Inhalt tauschen können willst:

#include <string>
#include <iostream>

constexpr std::size_t max_weapons = 10;

class weapon {
    std::string name;

public:
    weapon(std::string const &name) : name{ name } {}
    std::string const& get_name() const { return name; }
};

class player {
    weapon const *weapons[max_weapons];
    std::size_t num_weapons = 0;

public:
    bool add_weapon(weapon const *weapon_to_add)
    {
        if (num_weapons == max_weapons)
            return false;

        weapons[num_weapons++] = weapon_to_add;
        return true;
    }

    void list_weapons() const
    {
        if (!num_weapons)
            return;
        
        std::cout << "Weapons:\n";
        for (std::size_t i = 0; i < num_weapons; ++i)
            std::cout << (i + 1) << ": " << weapons[i]->get_name() << '\n';
    }
};

int main()
{
    weapon glock{ "Glock" };
    weapon minigun{ "Minigun" };

    player hugo;
    hugo.add_weapon(&clock);
    hugo.add_weapon(&minigun);

    hugo.list_weapons();
}

[Swordfish]

@100Lifes sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

Hab ich da Mist gelernt?

Ja. https://www.c-plusplus.net/forum/topic/249378/suche-liste-mit-quot-c-standardbezeichnungen-quot/5

[zeropage]

@100Lifes sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

@Swordfish sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

Was sollen diese s_ und n_? Lass das! Die einbuchstabigen Bezeichner für die Parameter sind auch nicht der burner.

Das hab ich so im Buch "C++ für Spieleprogrammierer" von Heiko Kalista gelernt, dass das eigentlich ein gewisser Standard ist. Hab ich da Mist gelernt?

Es ist zumindest sehr alt. Irgendwann damals, war es üblich die Variable zusätzlich mit dem Anfangsbuchstaben des Typ zu bezeichnen.
Warum, weiß ich aber auch nicht...

[100Lifes]

@Swordfish - Danke für den Code bezüglich dem Inventar. Ich verstehe einiges und habe auch gerade gelernt, wie man die maximale Anzahl an Objekten festlegt. Merke aber auch, dass ich noch einen weiten Weg habe gerade mit Pointer usw. weil das, bzw. den genauen Einsatzzweck, versteh ich noch nicht so ganz.

@zeropage - Danke für den Beitrag bezüglich den Ungarischen Notationen. Dann lass ich das mal lieber und übe mich in aussagekräftigen Variabel/Class/Object Namen usw.

[Swordfish]

@100Lifes sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

Ich verstehe einiges

Zu Dingstis die Du nicht verstehst kannst Du ja nachfragen.

[100Lifes]

@Th69 sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

Du solltest nicht den Namen der Waffe in der Player-Klasse benutzen, sondern ein Weapon-Objekt selbst (Variablen können nicht als Strings ausgelesen werden - C++ unterstützt keine sog. Reflection):

class Player
{
public:
    // ...
    Weapon weapon;
};

Du mußt aber jetzt noch den Player-Konstruktor ändern.

Ich hätte da noch eine Frage... Ich habe den Player Konstruktor jetzt angepasst aber irgendwie scheint er das nicht ganz so cool zu finden.

class Player {
public:
	string PlayerName;
	int n_Health;
	int n_Xp;
	int n_Resistence; // 1-20
	int n_Level;
	Weapon WeaponName;
	Player(string n, int h, int x, int r, int l, string w) {
		PlayerName = n;
		n_Health = h;
		n_Xp = x;
		n_Resistence = r;
		n_Level = l;
		WeaponName = w;
	}
};

Habe Weapon::s_Name zu Weapon::WeaponName modifiziert deswegen nicht wundern.

Aktuell erhalte ich Kein geeigneter Standardkonstruktor verfügbar
WeaponName ist jedoch auch ein String und deswegen weiss ich gerade nicht so genau, wo das Problemchen liegt. Könntest du mir nochmals aushelfen?

[Swordfish]

Deine Weapon-Klasse hat einen Konstruktor der 4 Parameter nimmt. So kann WeaponName = w nicht funktionieren.
Schau' Dir auch an was Initialisierungslisten sind.

Mal was Allgemeiner: Woher nimmst Du denn die Parameter für alle im Spiel verfügbaren Waffen?

[100Lifes]

Ach so, dann muss ich damit die vollständige Klasse initialisieren.
Somit macht es eigentlich wenig Sinn die Waffen Objekte in der int main() zu deklarieren sondern in einer inkludierten .cpp Datei?

Also aktuell sieht die Struktur ungefähr wie folgt aus (sind jetzt eben "dumme" Variablen):
c_Player.hpp

#pragma once
#include <iostream>

using namespace std;

class Player {
public:
	string PlayerName;
	int n_Health;
	int n_Xp;
	int n_Resistence; // 1-20
	int n_Level;
	Weapon WeaponName;
	Player(string n, int h, int x, int r, int l, string w) {
		PlayerName = n;
		n_Health = h;
		n_Xp = x;
		n_Resistence = r;
		n_Level = l;
		WeaponName = w;
	}
};

c_Weapon.hpp

#pragma once
#include <iostream>

using namespace std;

class Weapon {
public:
	string WeaponName;
	int n_MinDmg;
	int n_MaxDmg;
	int n_CritDmg;
	Weapon(string a, int x, int y, int z) {
		WeaponName = a;
		n_MinDmg = x;
		n_MaxDmg = y;
		n_CritDmg = z;
	}
};

FunctionCollector.hpp

#pragma once

#include <iostream>

using namespace std;

// Text handling
void PrintDots(int);  // Slow printout of '.'
void WriteText(string);  // char by char printout for effect

Functions.cpp

#include "FunctionCollector.hpp"
#include "c_Weapon.hpp"
#include "c_Player.hpp"

#include <chrono>
#include <thread>

using namespace std;
using namespace std::this_thread;

void PrintDots(int dots) {
	int n_latency = 0;
	for (int i = 0; i < dots; ++i) {
		cout << ".";
		sleep_for(std::chrono::milliseconds(n_latency));
	}
}

void WriteText(string s_Text) {
	int n_latency = 0;
	for (int i = 0; i < s_Text.size(); i++) {
		cout << s_Text[i];
		sleep_for(std::chrono::milliseconds(n_latency));
	}
}

MainGame.cpp

// Public Librarys
#include <iostream>
#include <chrono>
#include <thread>
// Personal Headerfiles
#include "FunctionCollector.hpp"
#include "c_Weapon.hpp"
#include "c_Player.hpp"

using namespace std;


int main() {
	// Initialize all Weapon Types
	// Name, minDmg, maxDmg, critDmg
	Weapon stick("Basic Stick", 1, 2, 2);

	// Initialize Player character
	// PlayerName, Health, XP, Resistence, Level, Equiped Weapon
	Player Player1("xxx", 100, 0, 1, 1, "stick");

Das ist der aktuelle Stand von den "angefangenen Bausteinen".
Aber dann muss ich die Initialisierung im Idealfall von Weapon stick[...] aus der MainGame.cpp Datei entfernen da es dann vermutlich von der Struktur keinen Sinn mehr macht und pack dass dann in die c_Player.hpp Datei?

Ich hab zwar das Buch fast durch und man sieht evtl., dass ich die Basics ungefähr verstanden habe aber ich bin nicht gelernter Programmierer sondern auf der Systemseite zuhause, was man dem Code sicher ansieht.

Deswegen noch Danke an alle, die hier die Geduld mit mir aufbringen.

[Th69]

Ich meine, daß du statt dem Waffennamen direkt das Waffenobjekt übergibst:

Player(string n, int h, int x, int r, int l, Weapon w)
{
  weapon = w;
}

Nun mußt du nur noch den Aufruf in der main-Funktion anpassen (dies überlasse ich dir als Aufgabe, damit du verstehst, wie man Objekte übergibt) - ist eigentlich nur eine kleine Änderung.

Edit: Wie von @Swordfish schon angemerkt, beschäftige dich auch mit der Initialisierungsliste - dann kannst du sogar gleiche Namen für die Konstruktorparameter und die Membervariablen wählen.

Wenn du verschiedene Waffenobjekte definieren möchtest, dann kannst du diese in einem statischen Array (oder einem std:.vector<>) halten, z.B.

const Weapon weapons[] =
{
  { "Basic Stick", 1, 2, 2 },
  { "Better Stick", 2, 3, 4 },
  // ...
};

Als weitere Lernaufgabe, könntest du diese Daten auch aus einer Textdatei lesen.

PS: using namespace std; sollte man niemals in Headerdateien verwenden, denn dadurch ergeben sich Probleme bei größeren Projekten mit unterschiedlichen Namensbereichen (und daher gewöhne dich nicht erst daran).
Entweder explizit std::string ausschreiben oder einzelne Namen per using std::string; etc. auflisten.
Noch besser, für Fortgeschrittene, wenn man einen eigenen Namensbereich wählt (anstatt alles im globalen Bereich zu haben).

[100Lifes]

Ich habe das Gefühl ich verursache mehr Chaos in meinem Projekt als Ordnung

Ich habe das ganze etwas umgebaut, damit es etwas mehr dem "modernen" Standard entspricht was ich so gelesen habe.
Jetzt sieht es wie folgt aus, funktioniert aber praktisch nichts mehr....
MainGame.cpp

// Public Librarys
#include <iostream>
// Personal Headerfiles
#include "c_Weapon.hpp"
#include "c_Player.hpp"

using namespace std;

int main() {
	// Initialize all Weapon Types
	Weapon stick("Basic Stick");

	// Initialize Player character
	Player Player1;

	// Set Variables
	string UserInput;
	
	cout << "Setze Spielername: ";
	cin >> UserInput;
	Player1.setPlayerName(UserInput);
	cout << "Der Spielername ist: " << Player1.getPlayerName();

	cout << "\n\n\n[ENTER]" << endl;
	cin.get();
}

c_Player.hpp

#pragma once
#include <iostream>

class Player {
private:
	std::string PlayerName;
	Weapon EquipedWeapon;

public:
	Player(std::string Name);

	void setPlayerName(std::string PlayerName);
	void setPlayerWeapon(const Weapon& WeaponName);

	void getPlayerName();
	void getEquipedWeapon();
};

c_Player.cpp

#include <iostream>
#include "c_Player.hpp"
#include "c_Weapon.hpp"

using namespace std;

// Methode
void Player::setPlayerWeapon(const Weapon& WeaponName) {
	this->EquipedWeapon = WeaponName;
}

void Player::setPlayerName(string Name) {
	this->PlayerName = Name;
}

void Player::getPlayerName() {
	cout << this->PlayerName;
}

void Player::getEquipedWeapon() {
	cout << this->EquipedWeapon.WeaponName;
}

// Konstruktor
Player::Player(string Name) {
	this->PlayerName = Name;
}

c_Weapon.hpp

#pragma once
#include <iostream>

class Weapon {
public:
	string WeaponName;
	
	Weapon(std::string Name);
};

c_Weapon.cpp

#include <iostream>
#include "c_Weapon.hpp"

using namespace std;

// Methoden

// Konstruktor
Weapon::Weapon(string Name) {
	this->WeaponName = Name;
}

Ich weiss, dass bei Weapon der string immer noch als Publici st, wollte aber zuerst c_Player mit Getter und Setter einbauen.
Nach Anleitung wie man mit Objekten in Objekten arbeitet müsste das rein theoretisch so ungefähr funktionieren nur funktioniert bei mir leider so gar nichts und woher es kommt versteh ich auch gerade nicht...

[Schlangenmensch]

@100Lifes sagte in C++ Variablen "verknüpfen" aus zwei Klassen.:

nur funktioniert bei mir leider so gar nichts und woher es kommt versteh ich auch gerade nicht

Was heißt das? Kompilerfehler? Dann wäre es super, wenn du den hier mit angeben könntest. Macht das Programm was anderes, als erwartet? Dann sag doch, was es macht und was du stattdessen erwarten würdest.

[100Lifes]

Hier der Auszug von Visual Studio:

Erstellen gestartet...
1>------ Erstellen gestartet: Projekt: Console-Minigame-1, Konfiguration: Debug x64 ------
1>c_Player.cpp
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.hpp(7,9): error C3646: "EquipedWeapon": Unbekannter Überschreibungsspezifizierer
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.hpp(7,22): error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.hpp(13,35): error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.hpp(13,35): error C2143: Syntaxfehler: Es fehlt "," vor "&"
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(6,9): error C3646: "WeaponName": Unbekannter Überschreibungsspezifizierer
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(6,19): error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.cpp(8,56): error C2511: "void Player::setPlayerWeapon(const Weapon &)": Überladene Memberfunktion nicht in "Player" gefunden
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.hpp(4): message : Siehe Deklaration von "Player"
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.cpp(9,2): error C2671: "Player::setPlayerWeapon": Statische Memberfunktionen haben keinen this-Zeiger
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.cpp(21,16): error C2039: "EquipedWeapon" ist kein Member von "Player".
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.hpp(4): message : Siehe Deklaration von "Player"
1>c_Weapon.cpp
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(6,9): error C3646: "WeaponName": Unbekannter Überschreibungsspezifizierer
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(6,19): error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.cpp(10,8): error C2039: "WeaponName" ist kein Member von "Weapon".
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(4): message : Siehe Deklaration von "Weapon"
1>Functions.cpp
1>MainGame.cpp
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(6,9): error C3646: "WeaponName": Unbekannter Überschreibungsspezifizierer
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(6,19): error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>C:\x\Console-Minigame-1\Console-Minigame-1\MainGame.cpp(31,9): error C2512: "Player": Kein geeigneter Standardkonstruktor verfügbar
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.hpp(4,7): message : Siehe Deklaration von "Player"
1>C:\x\Console-Minigame-1\Console-Minigame-1\MainGame.cpp(39,60): error C2679: Binärer Operator "<<": Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operanden vom Typ "void" akzeptiert (oder keine geeignete Konvertierung möglich)
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(465,39): message : kann "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(std::basic_streambuf<char,std::char_traits<char>> *)" sein
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(440,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(const void *)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(422,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(long double)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(404,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(double)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(386,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(float)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(368,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(unsigned __int64)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(350,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(__int64)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(332,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(unsigned long)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(314,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(long)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(295,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(unsigned int)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(269,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(int)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(250,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(unsigned short)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(216,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(short)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(198,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(bool)"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(193,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(std::ios_base &(__cdecl *)(std::ios_base &))"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(188,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(std::basic_ios<char,std::char_traits<char>> &(__cdecl *)(std::basic_ios<char,std::char_traits<char>> &))"
1>C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.28.29910\include\ostream(183,39): message : oder "std::basic_ostream<char,std::char_traits<char>> &std::basic_ostream<char,std::char_traits<char>>::operator <<(std::basic_ostream<char,std::char_traits<char>> &(__cdecl *)(std::basic_ostream<char,std::char_traits<char>> &))"
1>C:\x\Console-Minigame-1\Console-Minigame-1\MainGame.cpp(39,60): message : bei Anpassung der Argumentliste "(std::basic_ostream<char,std::char_traits<char>>, void)"
1>Code wird generiert...
1>Die Erstellung des Projekts "Console-Minigame-1.vcxproj" ist abgeschlossen -- FEHLER.
========== Erstellen: 0 erfolgreich, 1 fehlerhaft, 0 aktuell, 0 übersprungen ==========

[Th69]

Du hast vergessen, c_Weapon.hpp in c_Player.hpp einzubinden:

#include "c_Weapon.hpp"

(sonst kennt der Compiler den Typ Weapon nicht).

PS: Du solltest bei void setPlayerWeapon(const Weapon& WeaponName) den Parameter nur weapon nennen, da es ja kein Name ist, sondern ein Weapon-Objekt).
Und noch ein wenig Englischnachhilfe: es heißt EquippedWeapon.

[100Lifes]

Manchmal fühl ich mich echt etwas beschränkt und bin sehr dankbar für eure Geduld mit mir.
Englisch "Patzer" ausgebessert.
Jetzt ist auch klar, wieso ich c_Weapon.hpp in die CPP Datei einbinden musste da ich es bei der c_Player.hpp verpeilt habe. Ist jetzt auch korrigiert.

Jetzt erhalte ich aktuell noch folgende Meldung:

1>c_Player.cpp
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Player.cpp(24,29): error C2512: "Weapon": Kein geeigneter Standardkonstruktor verfügbar
1>C:\x\Console-Minigame-1\Console-Minigame-1\c_Weapon.hpp(4,7): message : Siehe Deklaration von "Weapon"

Diese Meldung ist im Tutorial wo ich gefolgt bin leider nie aufgetreten und ich habe es (abgesehen von Variablenamen) extra nachgebaut.
Ich kann es auch nicht 100% nachvollziehen da ich extra die Classes auf das Minimum, 1 Variable, reduziert habe.

[Th69]

Es existiert kein parameterloser Konstruktor für Weapon, so daß EquippedWeapon in der Klasse Player nicht standardmäßig erzeugt werden kann.
Du müßtest entweder über die Initialisierungsliste eine Standard-Waffe setzen oder aber den parameterlosen Konstruktor Weapon() zu der Klasse hinzufügen (überlege dir mal logisch, was es bedeutet, wenn keine Waffe zugewiesen wurde).

Außerdem benutzt du in main bei

Player Player1;

ebenso den parameterlosen Konstruktor, aber du hast diesen nicht definiert, sondern nur den mit einem Namen als Parameter.