3. Wieder mal Zufallszahlen :/

Wieder mal Zufallszahlen :/

  • M

    Ja ich wills auch mal wissen 🙂
    Und zwar will ich ein simples rate spiel mit einer klasse machen.

    Der user soll eine zahl zwischen 1 und 10 wählen.
    Aber ich hab noch nie so etwas sinnloses versucht aber für mich wird es auch mal zeit 😉

    Hier mal mein kleines testspielchen:

    CPP:

    #include <iostream>
using namespace std;

#include "Header.h"

void AI::rate()
{
	cout<<"Erraten Sie die Zahl!\n";
}

int main()
{
	cout<<"Diese Programm soll eine simple KI zeigen!\n"
		<<"Sie muessen gleich eine zahl erraten!\n"
		<<"Diese liegt zwischen 1 und 10\n\n";
	bot.rate();
	system("PAUSE");
}

    Header:

    class AI
{
public:
	void rate();
	int zahl;
};

AI bot;

    Ich weiss die klasse heisst AI aber soll nur aus fun sein 😉

    0

  • zufall mit srand initilisieren und dann mit rand die zahl berechnen.
    beispiel hier
    http://www.cplusplus.com/ref/cstdlib/srand.html
    und warum hast du ein globales objekt? weg damit.

    die implementierung in eine eigene datei.

    so long :xmas2:

    0
  • M

    Warum ist global eigentlich immer so schlecht?

    Aber okay 🙂

    0
  • C

    weil somit alle funktionen, die in dateien definiert sind, die diese headerdatei einbinden vollen zugriff auf das objekt besitzen. Der Vorteil von OOP soll unter anderem das "Geheimnisprinzip" sein. Also so wenig Sichtbarkeit, wie möglich gewähren. Aber gerade so viel wie nötig.

    0
  • M

    aso k dann hab ich aber wie der mal das problem das ich dann diesen code auf lokal um schreiben muss:

    main.cpp:

    #include <iostream>
#include <fstream>
using namespace std;

#include "Pistole.h"
#include "Player.h"
#include "Enemy.h"
#include "All.h"

////////////////////////////////
//Methoden von Klasse Pistole://
////////////////////////////////

//Final!!!
void Pistole::info()
{
	cout<<"Waffen Infos:\n"
		<<"*****************************************************\n\n"
		<<"Pistolenname:Walther PPK\n"
		<<"Magazingroesse:"<<this->magazin<<endl
		<<"Gesamt Munition:"<<this->ammo<<endl
		<<"Schaden:"<<this->damage<<endl;

}

//vllt unnütz!
//Erstellt!!!
void Pistole::idle()
{
	cout<<"\n\nNichts passiert\n";
}

///////////////////////////////
//Methoden der Klasse Player://
///////////////////////////////

//Erstellt!!!
void Player::get_info()
{
	cout<<"Sie sind Spieler NR.1\n";
	if(this->health>0)
	{
		cout<<"Status:\n"<<this->health<<" Leben\n";
	}

	if(this->armor>0)
	{
	cout<<this->armor<<" Armor\n\n";
	}
}

//Medikit?!?(ungenutzt)!!!
void Player::get_health()
{
	this->health+=10;
}

//WIP!!!!!!
void Player::hit()
{
	switch(ene.shooting)
	{
	case 1:
	if(this->armor>0)
	{
		this->armor-=pist.damage;
		if(this->health>0)
		{
			this->health-=pist.damage;
		}
	}
	break;
	case 3:
	if(this->armor>0)
	{
		this->armor-=(pist.damage*3);
		if(this->health>0)
		{
			this->health-=(pist.damage*3);
		}
	}
	break;
	case 5:
	if(this->armor>0)
	{
		this->armor-=(pist.damage*5);
		if(this->health>0)
		{
			this->health-=(pist.damage*5);
		}
	}
	break;
	}

			if(this->armor<=0&&this->health<=0)
			{
				cout<<"Ihr Gegner ist tot!\n"
					<<"Sie haben gewonnen!\n";
			}
			else(play.health<=0&&ene.health<=0);
			{
				cout<<"Sie und Ihr Gegner sind tot!\n";
			}
}

//Schiesst eine bestimmte anzahl kugeln ab und ruft bei leerem magazin 
//die nachladefunktion auf.
void Player::shoot()
{
	cout<<"\n\nWie oft wollen sie schiessen?\n"
		<<"Geben sie die anzahl der schuesse ein\n"
		<<"(1, 3 oder 5 Schuss)!\n";
	cin>>pist.shoot;

switch(pist.shoot)
{
case 1:
	pist.magazin-=1;
	break;
case 3:
	pist.magazin-=3;
	break;
case 5:
	pist.magazin-=5;
	break;
default:
	cout<<"Falsche Eingabe!\n";
}
	if(pist.magazin<=0)
	{
		this->reload();
	}
	else(pist.magazin>0);
	{
		cout<<"Magazingroesse:"<<pist.magazin<<" Schuss\n";
	}
}

//Final!!!
void Player::reload()
{

	if(pist.magazin==20)
	{
		cout<<"\n\nDas Magazin ist nochvoll!\n"
			<<"Kein nachladen moeglich!\n\n";
	}

	if(pist.magazin>0&&pist.magazin<20||pist.magazin<=0)
	{

		for(;pist.magazin<20;pist.magazin++)
		{
			pist.ammo--;
		}
		cout<<"\nDie Waffe wurde nachgeladen!\n\n"
			<<"Sie haben "<<pist.magazin<<" schuss im Magazin!\n";
	}

	if(pist.ammo<=0)
	{
		cout<<"Ammo ist leer!\n\n";
	}
	//Spieler wir jetzt nachdem Nachladen getroffen!
	play.hit();

}

//////////////////////////////
//Methoden der Klasse Enemy://
//////////////////////////////

//Erstellt!!!(Final)!!!
void Enemy::get_info()
{
	cout<<"Ihr gegner ist der PC!\n";
	if(this->health>0)
	{
		cout<<"Status:\n"<<this->health<<" Leben\n";
	}

	if(this->armor>0)
	{
	cout<<this->armor<<" Armor\n\n";
	}
}

//Medikit des gegners?!?(ungenutzt)!!!
void Enemy::get_health()
{
	ene.health+=10;
}

//wip!!!
void Enemy::hit()
{
	switch(pist.shoot)
	{
	case 1:
	if(this->armor>0)
	{
		this->armor-=pist.damage;
		if(this->health>0)
		{
			this->health-=pist.damage;
		}
	}
	break;
	case 3:
	if(this->armor>0)
	{
		this->armor-=(pist.damage*3);
		if(this->health>0)
		{
			this->health-=(pist.damage*3);
		}
	}
	break;
	case 5:
	if(this->armor>0)
	{
		this->armor-=(pist.damage*5);
		if(this->health>0)
		{
			this->health-=(pist.damage*5);
		}
	}
	break;
	}

			if(this->armor<=0&&this->health<=0)
			{
				cout<<"Ihr Gegner ist tot!\n"
					<<"Sie haben gewonnen!\n";
			}
			else(play.health<=0&&ene.health<=0);
			{
				cout<<"Sie und Ihr Gegner sind tot!\n";
			}
}

/////////////////////////////
//Alle Anderen Funktionen////
/////////////////////////////

//Wip!!!
void choice()
{
		//Hier muss noch irgend wie ein übersprung zum ende wenn play.health||ene.health<=0!!!
	for(;play.health>0||ene.health>0;i++)
	{
		info();
	if(play.health<=0||ene.health<=0)
		{
			cout<<"\n\n\n";
			break;
		}

		cout<<"Runde "<<i<<endl;
		play.get_info();
		ene.get_info();
	pist.info();
	cout<<"\n"
		<<"*****************************************************"
		<<"\nWaehlen sie nun was sie tun wohlen!\n\n"
		<<"*[F]ire\n"
		<<"*[R]ealod\n"
		<<"*[I]dle\n";

	cin>>op;
	switch(op)
	{
	case 'f':
	case 'F':
		play.shoot();
		play.hit();
		ene.hit();
		break;
	case 'r':
	case 'R':
		play.reload();
		play.hit();
		break;
	case 'i':
	case 'I':
		pist.idle();
		play.hit();
		break;
	default:
		pist.idle();
		play.hit();
		break;
	}
	}
}

//Erstellt!
void info()
{	
	//Waffe!!!
	fout<<"//Start Runde "<<i<<"!\n{\n"
		<<"\n//Waffen Informationen!\n\n"
		<<"Pistolenname:Walther PPK\n"
		<<"Magazingroesse:"<<pist.magazin<<endl
		<<"Gesamt Munition:"<<pist.ammo<<endl
		<<"Schaden:"<<pist.damage<<"\n\n";

	//Spieler!!!
	fout<<"//Spieler Informationen!\n\n"
		<<"Sie sind Spieler NR.1\n";
	if(play.armor<=0&&play.health<=0)
			{
				fout<<"Sie sind tot!\n"
					<<"Sie haben verloren!\n";
			}
	if(play.health>0)
	{
		fout<<"Status:\n"<<play.health<<" Leben\n";
	}

	if(play.armor>0)
	{
	fout<<play.armor<<" Armor\n\n";
	}

	//Gegner!!!!
	fout<<"\n//Gegner Informationen!\n\n";	

	if(ene.armor<=0&&ene.health<=0)
			{
				fout<<"Sie sind tot!\n"
					<<"Sie haben verloren!\n";
			}

	fout<<"Ihr gegner ist der PC!\n";
	if(ene.health>0)
	{
		fout<<"Status:\n"<<ene.health<<" Leben\n";
	}

	if(ene.armor>0)
	{
	fout<<ene.armor<<" Armor\n\n";
	}
	fout<<"}//Ende Runde "<<i<<"!\n\n\n\n";
}

/////////////////////////////////////////////////////
//funktion int main() Hier startet das programm ;)///
/////////////////////////////////////////////////////

//Final!
int main()
{
	choice();
	system("PAUSE");
}

    Player.h:

    //Klasse des Spielers
class Player
{
public:
	//Funktionen:
	void get_health();	//Erstellt
	void hit();			//Erstellt
	void shoot();		//Erstellt
	void get_info();	//Erstellt
	void reload();		//Erstellt

	//Variablen:
	int health;
	int armor;
	Player()
	{
		health=100;
		armor=100;
	}
	~Player()
	{
	}
};

    Enem<.h:

    //Klasse des Gegners
class Enemy
{
public:
	//Funktionen:
	void get_health();	//Erstellt
	void hit();			//WIP!!!
	void shoot();		//Fehlt!!!
	void get_info();	//Erstellt
	void reload();		//Fehlt!!!

	//Variablen:
	int shooting;
	int health;
	int armor;
	Enemy()
	{
		health=100;
		armor=100;
	}
	~Enemy()
	{
	}
};

    Pistole.h:

    //FINAL!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

//Klasse der pistole
class Pistole
{
public:
	//Funktionen:
	void info();	//Erstellt(FINAL)!!!
	void idle();	//Erstellt(eher unnütze)(FINAL)!!!

	//Variablen:
	int shoot;
	int magazin;
	int ammo;
	int damage;
	Pistole()
	{
		magazin=20;
		ammo=200;
		damage=10;
	}
	~Pistole()
	{
	}
};

    All.h:

    //Funktion der wahl zwischen den Aktionen
void choice();

//Objekte der klassen
Enemy ene;
Player play;
Pistole pist;

//Variablen
char op;
int i=1;

//Funktion zur ausgabe der Infos des spielverlaufs als txt datei!
void info();

fstream fout("Verlauf.txt", ios::out);

    Kommentar:
    Also das ganze ist nur ein test um OOP wirklich zuverstehen!
    Und ich will auch ein wenig mit fstream rumexperementieren.
    Dann hab ich die konstruktoren noch ohne Argumente gelassen da ich das thema jetzt erst gelsen und verstanden hab 😛 aber ich denke das ich das noch ändern werde.

    Dann möchte ich noch wissen ob ich eine methode über geben kann die keine argumente besitzt und zurück gibt aber trotzdem im speicher die werte verändert so wie bei globalen Objekten? oder muss ich doch mit zeigern und Rückgaben in form von int und co arbeiten?

    0
  • ?

    Eine Methode hat auf jeden Fall ein Argument - den impliziten Zeiger 'this'. Über den Zeiger kannst du Membervariablen der aufrufenden Objekts ändern.

    Z.B. würde 'play.shoot()' die Methode shoot() des Objketes 'play' aufrufen und diese dann dessen Munition etc ändern.

    0
  • M

    ja aber wenn ich mit der methode einer klasse die variavblen(elemente) der anderen klasse bearbeiten?

    muss ich dann nur ein objekt der klasse erstellen und dann einfach eintragen?

    bsp:

    void Enemy::hit()
{
        //Objekte deklarieren!
        Player play;
        Pistole pist;

	switch(pist.shoot)
	{
	case 1:
	if(this->armor>0)
	{
		this->armor-=pist.damage;
		if(this->health>0)
		{
			this->health-=pist.damage;
		}
	}
	break;
	case 3:
	if(this->armor>0)
	{
		this->armor-=(pist.damage*3);
		if(this->health>0)
		{
			this->health-=(pist.damage*3);
		}
	}
	break;
	case 5:
	if(this->armor>0)
	{
		this->armor-=(pist.damage*5);
		if(this->health>0)
		{
			this->health-=(pist.damage*5);
		}
	}
	break;
	}

			if(this->armor<=0&&this->health<=0)
			{
				cout<<"Ihr Gegner ist tot!\n"
					<<"Sie haben gewonnen!\n";
			}
			else(play.health<=0&&ene.health<=0);
			{
				cout<<"Sie und Ihr Gegner sind tot!\n";
			}
}
    0
Anmelden zum Antworten