# Hitpoints/Lifepoints programmieren, wie?



## InfoStudent93 (24. Mai 2014)

Wahrscheinlich ist meine Frage eines der einfachsten Sachen in der Spieleprogrammierung, doch irgendwie komme ich nicht auf die Lösung!

Ich bin Informatik Student und in diesem Semester wird von uns verlangt ein kleines Spiel zu programmieren.
Unser Spieler muss Lebenspunkte haben (100 LP) und diese natürlich auch durch Angriffe verlieren können. Und bei 0 Punkten stirbt der Spieler. 
Nun zu meiner Frage:
Wie erstelle ich einen Code, der meinem Spieler 100 LP gibt, die auch im Bild angezeigt werden(Muss keine Leiste sein. Mir reicht die Zahl 100, die auf 0 runterfallen kann)?

Ich hoffe ihr könnt mir behilflich sein  Danke!


----------



## JavaMeister (24. Mai 2014)

Hi,

wir machen keine Hausaufgaben.

Wie sieht dein Anfang aus?

Schöne Grüße

Martin


----------



## InfoStudent93 (24. Mai 2014)

Um meinen Anfang zu zeigen müsste ich meine ganzen Klassen hochstellen. 
Ich habe nun eine neue Klasse Schlange erstellt. 
Ich will meiner Schlange Eigenschaften geben die ich dann mit private int benenne.
In diesem Fall private int Leben;
Und danach hört bei mir das ganze denken auf, weil ich einfach nicht weiß wie ich weiter machen soll.

Eine player Klasse habe ich schon, wo die ganzen Positionen meines Spielers sind etc. Aber mein Tutor sagt ich soll für die Eigenschaften eine neue Klasse erstellen und darf die Spieler Klasse nicht nutzen. 
Von daher habe ich nur:

public class Schlange {

     private int Leben;
     private int Amor;
     private int Dead;


----------



## JavaMeister (24. Mai 2014)

Wie sieht die klasse spieler aus?

Kann ein Spieler eine Schlange sein?


----------



## InfoStudent93 (24. Mai 2014)

```
public class Player {


    Rectangle bounding;

    public float player_x;
    public float player_y;

    private float f_dx;
    private float f_dy;
    private float f_gravity;

    private boolean p_air;

    private BufferedImage playerImage;


    public Player(){


        //Startpunkt
        player_x = 10;
        player_y = 512;

        f_dx = 5;
        f_dy = -10;
        f_gravity = 0.8f;

        p_air = false;

        //PlayerImage wird implementiert

        try {


        playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("schlangerechtsklein.png"));
    } catch (IOException e) {e.printStackTrace();}

        bounding = new Rectangle((int)player_x, (int)player_y,playerImage.getWidth(),playerImage.getHeight());




    }
    public void update(){
        //nach links
        if (keyCheck.keysCheck(KeyEvent.VK_A)) {
            player_x -= f_dx;

            try {


                playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("schlangelinksklein.png"));
            } catch (IOException e) {e.printStackTrace();}

        }
        //nach rechts
            if (keyCheck.keysCheck(KeyEvent.VK_D)) {
            player_x += f_dx;

                try {


                    playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("schlangerechtsklein.png"));
                } catch (IOException e) {e.printStackTrace();}
        }
        //nach unten
        if (keyCheck.keysCheck(KeyEvent.VK_S)) {
            player_y -= f_dy;

            try {


                playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("schlangerechtsklein.png"));
            } catch (IOException e) {e.printStackTrace();}
        }
        //nach oben
        if (keyCheck.keysCheck(KeyEvent.VK_W)) {
            player_y += f_dy;

            try {


                playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("schlangerechtsklein.png"));
            } catch (IOException e) {e.printStackTrace();}
        }
        //springen
        if(keyCheck.keysCheck(KeyEvent.VK_SPACE)){
            p_air = true;

            try {


                playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("schlangerechtsklein.png"));
            } catch (IOException e) {e.printStackTrace();}


        }

        if(p_air == true){
            if(player_y >= 508){
                f_dy = -10;
                p_air = false;
            }

            f_dy += f_gravity;
            player_y += f_dy;

        }

            bounding.x = (int)player_x;
            bounding.y = (int)player_y;
        }
        public Rectangle getBounding(){
        return bounding;
    }

        public BufferedImage getPlayerImage(){
            return playerImage;
        }

}
```


So sieht meine Player Klasse aus. 
Mein Player ist die Schlange. Die Schlange kämpft nämlich und hat Eigenschaften wie Leben, Rüstung und Tod. 
Und für diese Eigenschaften soll ich eine neue Klasse erstellen und dort der Schlange Leben geben. Aber bei diesem Punkt bin ich überfordert.


----------



## Phash (24. Mai 2014)

Na,  dann mach dir doch eine Variable vom typ int, die die hitpoints hält. 
Und initialisiere sie mit 100.
Am besten im Konstruktor deiner Klasse


----------



## triplec0re (5. Jun 2014)

Moin,

lege dir doch eine Klasse "Stats" an, in welcher Leben und Rüstung des Spielers als int-Werte gespeichert werden. Zusätzlich dann natürlich auch entsprechende getter-Methoden und Methoden die Leben und Rüstung verringern/erhöhen und ggf. prüfen, ob der Spieler tot ist. Deine Player-Klasse hat dann einfach ein Attribut vom Typ "Stats".


----------



## kaoZ (14. Jun 2014)

Warum gehst du das ganze nicht so an ? falls die klasse Player vorgegeben sein sollte kannst du die variablen auch direkt in den erbenden Klassen zuordnen :


```
public class Player {

	private int healthPoints;
	private int shield;
	
	public Player() {
	    // TODO Auto-generated constructor stub
    }
	
	void setHealthPoints(int hp){
		this.healthPoints = hp;
	}
	
	void setShield(int shield){
		this.shield = shield;
	}
	
	void damageTaken(int dmg){
		System.out.println("Damage taken from enemy : " + dmg);
		this.healthPoints = healthPoints - dmg;
		
		if (this.healthPoints <= 0) {
	        System.out.println("You died ! Try Again.");
        }
	}
	
	public int getHealthPoints() 			{return this.healthPoints;}
	public int getShield()					{return this.shield;}
}
```

Hier ein gegner :


```
public class Enemy {
	
	int dmg;
	
	public Enemy() {
	    // TODO Auto-generated constructor stub
    }
	
	public void attack(String attackName, Player target){
		
		switch(attackName){
		case "hit":
			setDmg(30);
			target.damageTaken(getDmg());
			break;
		case "kick":
			setDmg(32);
			target.damageTaken(getDmg());
			break;
		}
	}
	
	void setDmg(int dmg){
		this.dmg = dmg;
	}
	
	int getDmg(){
		return this.dmg;
	}

}
```

und dann in einer Spezialisierung z.B


```
public class Warlock extends Player {
	
	public Warlock() {
		setHealthPoints(100);
		setShield(0);
    }
	
	public static void main(String[] args) {
	    Player warlock = new Warlock();
	    
	    Enemy e = new Enemy();
	    
	    e.attack("hit", warlock);
	    
	    System.out.println(warlock.getHealthPoints());
	    
	    e.attack("kick", warlock);
	    
	    System.out.println(warlock.getHealthPoints());
	    
	    e.attack("hit", warlock);
	    
	    System.out.println(warlock.getHealthPoints());
	    
	    e.attack("hit", warlock);
	    
	    System.out.println(warlock.getHealthPoints());
	    
    }
}
```

Die Ausgabe wäre dann :


```
Damage taken from enemy : 30
70
Damage taken from enemy : 32
38
Damage taken from enemy : 30
8
Damage taken from enemy : 30
You died ! Try Again.
-22
```

Ok zugegeben das ist nur eine einfache Konsolenversion..... aber so in der art *könnte* man das Realisieren.


----------

