# 2D Side Scrool Platformer



## TheSorm (10. Jan 2014)

Ich habe eine Side Scrool Platformer geschrieben, mit Lvl Editor. Das einzige was mir nich fehlt/ ich nicht hinbekomme, ist die Kollisionsabfrage und Reaktion vom Player mit der map. Ich habe eine Array list in der alle Blöcke der Map (64*64 pc mit rectangle bounding box) als Objekte drin sind  und den Player der ebenfals eine Kollsionsbo hat und auch 64*64 px groß ist. Wenn mir jemand weiter helfen könnte were das sehr nett!


----------



## Tru (12. Jan 2014)

Die Kollisionsabfrage kannst du ganz einfach implementieren:
-fällt der Spieler nach unten, so checke Kollision mit den oberen Seiten von Objekten. 
-läuft der Spieler nach links, so checke Kollision mit den rechten seiten von Objekten. 
-läuft der Spieler nach rechts, so checke Kollision mit den linken seiten von Objekten. 
-springt der Spieler, so checke Kollision mit Kopf von Spieler und Boden von Objekten.


----------



## TheSorm (12. Jan 2014)

Das ist kla, aber wie kann ich 100%tig sagen ob ich oben Kollidiren oder unten oder rechts oder links?!


----------



## Tru (12. Jan 2014)

Je nach Richtung überprüfst du ob die jeweilige Seite eines Vierecks mit einer eines anderen Vierecks kollidiert.


```
//Kollision OBEN
if(Keys.isKeyDown(KeyEvent.VK_UP)){
		playerRect.y -= speed;
		if(playerRect.intersects(Block.getRect()) && playerRect.y <= Block.getRect().y+Block.getRect().height){
			playerRect.y += speed;
		}
	}
//Kollision UNTEN
if(Keys.isKeyDown(KeyEvent.VK_DOWN)){
		playerRect.y += speed;
		if(playerRect.intersects(Block.getRect()) && playerRect.y+playerRect.height >= Block.getRect().y){
			playerRect.y -= speed;
		}
	}
//Kollision LINKS
if(Keys.isKeyDown(KeyEvent.VK_LEFT)){
		playerRect.x -= speed;
		if(playerRect.intersects(Block.getRect()) && playerRect.x <= Block.getRect().x+Block.getRect().width){
			playerRect.x += speed;
		}
	}
//Kollision RECHTS
if(Keys.isKeyDown(KeyEvent.VK_RIGHT)){
		playerRect.x += speed;
		if(playerRect.intersects(Block.getRect()) && playerRect.x+playerRect.width >= Block.getRect().x){
			playerRect.x -= speed;
		}
	}
```


----------



## TheSorm (12. Jan 2014)

Dafür muss ich mein Programm ein wenig umstellen aber ich werde es mal so ausprobieren, Danke!


----------



## TheSorm (12. Jan 2014)

Naja da es ja ein Jump and run ist muss man ja ergendwie statt hoch und runter mit sporingen lösen wie soll das gehen, also das auch das boolean jumping und falling auf false zurüchgesetzt wirt?


----------



## Tru (12. Jan 2014)

Du deklarierst 2 Variablen.
Einmal eine die auf true gesetzt wird, wenn du springt bzw. Leertaste drückst und eine die nach dem Sprung beim fallen auf true gesetzt wird.
Dann fragst du folgendes ab:


```
//Wenn der Spieler fällt
if(isFalling){
        if(playerRect.intersects(Block.getRect()) && playerRect.y+playerRect.height > Block.getRect().y{ //Wenn der Boden bzw. die Oberseite eines Block berührt wird
            isFalling = false; //Fallvariable auf false setzen, um das Fallen zu stoppen
        }
    }
}

//Wenn der Spieler springt
if(hasJumped){
        if(playerRect.intersects(Block.getRect()) && playerRect.y+playerRect.height > Block.getRect().y){ //Wenn die Unterseite eines Block berührt wird
            isFalling = true; //Fallen auf true setzen, damit der Spieler fällt
        }
    }
}
```


Wie du das ganze bewerkstelligst ist dir überlassen. :bae:


----------



## TheSorm (13. Jan 2014)

Ich krichs einfach nich hin -.- kann mir jemand nochmal an meiner player calsse selber helfen ... unter die for schleife muss die Kollisionsabfrage aber ich packs einfach nicht ...


```
package main;

import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;

public class Player {
	
	private Rectangle bounding;
	
	private float ply_x;
	private float ply_y;
	
	private float f_dx;
	private float f_dy;
	private float f_gravity;

	
	private float f_counter;
	private float neededTime;
	
	private boolean b_air;
	private boolean b_airimg;
	private boolean letzterichtung;
	private boolean falling;
	private boolean jumping;
	private boolean b_kill;
	
	private int richtung;
	
	private BufferedImage playerImage;
	private BufferedImage[] laufr; 
	private BufferedImage[] laufl; 
	
	
	public Player() {
		
		laufr = new BufferedImage[3];
		laufl = new BufferedImage[3];
		
		ply_x = 0;
		ply_y = 640;
		
		f_counter = 0;
		neededTime = 10;
		
		f_dx = 5;
		f_dy = -9;
		f_gravity = 0.4f;
		
		b_air = false;
		b_airimg = false;
		letzterichtung = true;
		falling = false;
		jumping = false;
		b_kill = false;
		
		richtung = 0;
		
		try {
			playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(0, 0, 64, 64);
			laufr[0] = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(64, 0, 64, 64);
			laufr[1] = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(128, 0, 64, 64);
			laufr[2] = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(192, 0, 64, 64);
			laufl[0] = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(64, 64, 64, 64);
			laufl[1] = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(128, 64, 64, 64);
			laufl[2] = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(192, 64, 64, 64);
		} catch (IOException e) {e.printStackTrace();}
		
		bounding = new Rectangle((int) ply_x, (int) ply_y, playerImage.getWidth(), playerImage.getHeight());
		
	}

	public void update() {
		if (b_kill){
			return;
		}
		for(int i = 0; i < Frame.teilesArray.size();i++){ //teilesArray is a Array with all tiles from the map (every block has 64x64 px)
			if(Frame.teilesArray.get(i).getimgInt()== 0 || Frame.teilesArray.get(i).getimgInt()== 1){ // means that only the two special blocks will check of collision not all blocks only this blocks
				
				}
			}
				
		}
		
		if(getBounding().x >= 400){
			ply_x = 399;
		}
			
		if(getBounding().x <=0 ){
			ply_x = 0;
		}
		
		if(keyCheck.keysCheck(KeyEvent.VK_SHIFT)){
			f_dx = 7;
		}else {f_dx = 5; }
		
		if(keyCheck.keysCheck(KeyEvent.VK_A)){
			ply_x -= f_dx;
			if(b_air == false){
				if(f_counter >= neededTime*1.5f){
					f_counter = 0;
				}
				if(f_counter == 0) {
					playerImage = laufl[0];
					f_counter++;
				}else if(f_counter == 5){
					playerImage = laufl[1];
					f_counter++;
				}else if(f_counter == 10){
					playerImage = laufl[2];
					f_counter++;
				}else {
					f_counter++;
				}
			richtung = 2;
			letzterichtung = false;
			}
		}
		if(keyCheck.keysCheck(KeyEvent.VK_D)){
			ply_x += f_dx;
			if(b_air == false){
				if(f_counter >= neededTime*1.5f){
					f_counter = 0;
				}
				if(f_counter == 0) {
					playerImage = laufr[0];
					f_counter++;
				}else if(f_counter == 5){
					playerImage = laufr[1];
					f_counter++;
				}else if(f_counter == 10){
					playerImage = laufr[2];
					f_counter++;
				}else {
					f_counter++;
				}
			}
			richtung = 1;
			letzterichtung = true;
		}
		
		if(keyCheck.keysCheck(KeyEvent.VK_D)==false && keyCheck.keysCheck(KeyEvent.VK_A)==false){
			if(richtung == 1 || letzterichtung == true && b_air == false && b_airimg ==false){
				try {
					playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(0, 0, 64, 64);
				} catch (IOException e) {e.printStackTrace();}
			}
			else if(richtung == 2 || letzterichtung == false && b_air == false && b_airimg ==false){
				try {
					playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(0, 64, 64, 64);
				} catch (IOException e) {e.printStackTrace();}
			}
			richtung = 0;
		}
		
		if(keyCheck.keysCheck(KeyEvent.VK_SPACE)){
			b_air = true;
		}	
		
		if(b_air ==true){
			if(b_airimg == false){
				if (letzterichtung == true)
				{
					try {
						playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(256, 0, 64, 64);
					} catch (IOException e) {e.printStackTrace();}
				}else {
					try {
						playerImage = ImageIO.read(getClass().getClassLoader().getResourceAsStream("pic\\player1.png")).getSubimage(256, 64, 64, 64);
					} catch (IOException e) {e.printStackTrace();}
				}

				b_airimg = true;
			}

			
			if(f_dy < 0 && f_dy > -9){
				jumping = true;
				falling = false;
			}else jumping = false;
			if(f_dy >= 0){
				jumping = false;
				falling = true;
			}else falling = false;
			f_dy += f_gravity;
			ply_y += f_dy;	
			//System.out.println("falling= "+falling+", jumping= "+jumping+", f_dy= "+f_dy);
		}
		
		if (ply_y > 800){
			b_kill = true;
		}
		
		bounding.x = (int) ply_x;
		bounding.y = (int) ply_y;
		
		
	}
	
	public Rectangle getBounding() {
		return bounding;
	}
	
	public boolean getPlayerKill() {
		return b_kill;
	}
	
	public BufferedImage getPlayerimage() {
		return playerImage;
	}
	
	public void setPlayerLocation(int ply_x, int ply_y){
		this.ply_x = ply_x;
		this.ply_y = ply_y;
		bounding.x = (int) this.ply_x;
		bounding.y = (int) this.ply_y;
		System.out.println(""+this.ply_x+" "+this.ply_y);
	}
}
```


----------



## TheSorm (15. Jan 2014)

keine eine Anung?


----------

