# Jump'n Run Background wiederholen



## F4ckHanoi (22. Jan 2016)

Hallöchen zusammen,

ich habe Anhand eines Tutorials ein Spiel programmiert. Jedoch habe ich ein Problem. Im Tutorial wurde das mit dem Hintergrund zeichnen gelöst, jedoch war die Framebreite 600 Pixel. Ich möchte es nun aber 1200 Pixel breit haben. Meiner Meinung nach habe ich mit absoluten Werten gearbeitet. Es sind komische Lücken dazwischen.



Screenshots:
http://img5.fotos-hochladen.net/uploads/screen1tpwmy7zqn1.png
http://img5.fotos-hochladen.net/uploads/screen2sm0jn9qe7k.png

Auf dem ersten Bild ist schon mein Problem dargestellt. Ich möchte, dass sich das Hintergrund schon vorher zeichnet, bevor man es sieht. Auf dem zweiten Bild wird es erst dann gezeichnet, nachdem ich paar Schritte gelaufen bin.


Naja, hier ist mein Code:

```
package HNGProduction;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;


public class Spiel extends JPanel implements ActionListener {
 
    //Timer
    Timer time;
 
    //Hintergrund
    Image background;
    int backgroundZeichnenX,backgroundZeichnenX_zwei;
    int background_aktuelle_posX;
    static int background_posX;
    int anzahl = 0;
    int anzahl_zwei= 0;
 
    //Taste
    int gedrueckteTaste;
 
 
    //Charakter 
    Image figur;
    int figur_posX = 75;
    int figur_posY = 235;

    //Blöcke
    Random random = new Random();
    Block block[] = new Block[5];
    int blockAnzahl = 1000;
    int blockPosX = 350;
    int randomPosX = 1 + (int) Math.floor(Math.random()*5);
    Block blockArray[] = new Block[blockAnzahl];
    int coin_score = 0;

 
 
 
    /********************* KONSTRUKTOR *********************/
    public Spiel(){

     
        /*
         * Inizialisieren
         */
        backgroundZeichnenX = 0;
        backgroundZeichnenX_zwei = 690;
        gedrueckteTaste = 0;
        background_posX = 0;
        setFocusable(true);
     
     
     
     
        /*
         * Bilder von Charakter und Hintergrund
         */
        ImageIcon u = new ImageIcon((getClass().getResource("background.jpg")));
        background = u.getImage();
     
        ImageIcon s = new ImageIcon((getClass().getResource("char.png")));
        figur = s.getImage();
     
 
     
     
     
        /*
         * KeyListener
         */
        addKeyListener(new AL());
     
     
     
     
        /*
         * Blöcke
         */
        //149 y hoch Springen - Höhe
        block[0] = new Block(250,110,50,50, Color.YELLOW);
        block[1] = new Block(310,110,50,50, Color.YELLOW);
        block[2] = new Block(370,110,50,50, Color.YELLOW);
     
        for(int i = 1; i < blockArray.length; i++){
            randomPosX = 1 + (int) Math.floor(Math.random()*5);
            blockArray[i] = new Block(((blockPosX*i)*randomPosX),110,50,50, Color.WHITE);
        }
         
     
     
     
        /*
         * Springen
         */
        Springen sprung = new Springen();
 
     
     
     
        /*
         * Alternative zu "update - Methode" die sich alle 5 Millisekunden wiederholt
         */
        time = new Timer(5,this);
        time.start();
     
    }
    /***********************************************/
 
 

 
 
 
 
    /********************* Wiederholende Methodenaufruf *********************/
    public void actionPerformed(ActionEvent e){
        //(Wird immer wieder neu gezeichnet)
        bewegen();
        repaint();
        figur_posY = Springen.sprungposition;
    }
    /***********************************************/
 
 
 
 
 
 
 
    /********************* PAINT METHODE *********************/
    public void paint(Graphics g){
     
        super.paint(g);
        Graphics2D f2 =(Graphics2D)g;
     
     
        /*
         * Hintergrund wiederholt sich
         */
     
        //510
        if (getXBild() == 510 + (anzahl * 2350)){
            System.out.println("\n*****************************************\nErste Abrage\n\nAktuelle Position des Backgrounds: " + getXBild() + "\n" + "Berechnung: " + "(510 + " + anzahl + " * 2350)) = " + (510 + (anzahl * 2350)) + "\n" + anzahl + "*2350 = " + (anzahl*2350));
            anzahl += 1;
            System.out.println("\nAnzahl Variable: " + anzahl + "\n*****************************************");
            backgroundZeichnenX = 0;
        }
     
        //1690
        if (getXBild() == 1690 + (anzahl_zwei*2350)){
            System.out.println("\n*****************************************\nZweite Abrage\n\nAktuelle Position des Backgrounds: " + getXBild() + "\n" + "Berechnung: " + "(1690 + " + anzahl + " * 2350)) = " + (1690 + (anzahl_zwei * 2350)) + "\n" + anzahl + "*2350 = " + (anzahl*2350));
            anzahl_zwei += 1;
            System.out.println("\nAnzahl_Zwei Variable: " + anzahl + "\n*****************************************");
            backgroundZeichnenX_zwei = 0;
        }
     
        if (getXBild() >= 510){
            //685
            f2.drawImage(background,685-backgroundZeichnenX,0,null);
            //System.out.println("X-Position des Backgrounds die gezeichnet wird: " + (685-backgroundZeichnenX));
        }
        //System.out.println(getXBild());
     
     
        //Hintergrund
        f2.drawImage(background,685-backgroundZeichnenX_zwei,0,null);
        //System.out.println("X-Position ZWEI des Backgrounds die gezeichnet wird: " + (685-backgroundZeichnenX_zwei));
     
     
        //Charakter
        f2.drawImage(figur,figur_posX,figur_posY,null);
     
     
        //Blöcke
        f2.setColor(block[0].getFarbe());
        f2.fillRect(block[0].getX_Block()-getXBild(), block[0].getY_Block(), block[0].getWidth(), block[0].getHeight());
        f2.fillRect(block[1].getX_Block()-getXBild(), block[1].getY_Block(), block[1].getWidth(), block[1].getHeight());
        f2.fillRect(block[2].getX_Block()-getXBild(), block[2].getY_Block(), block[2].getWidth(), block[2].getHeight());
     
     
        /*
         * Kollisionsabfrage
         */
            //74 -12 (Größe des Charakters also die X Position minus den Abstand zu den Rand)
        block[0].kollisionsabfrage(block[0].getX_Block()-getXBild(), block[0].getY_Block() + block[0].getHeight(),figur_posX + (74-12), figur_posY);
        block[1].kollisionsabfrage(block[1].getX_Block()-getXBild(), block[1].getY_Block() + block[1].getHeight(),figur_posX + (74-12), figur_posY);
        block[2].kollisionsabfrage(block[2].getX_Block()-getXBild(), block[2].getY_Block() + block[2].getHeight(),figur_posX + (74-12), figur_posY);
     
         
     
     
            //Wenn Block berührt wird, erhält man Punkte
            if(block[0].Coin() == true || block[1].Coin() == true || block[2].Coin() == true ){
                coin_score = 1;
            }
         
            //Kollision, Punkte und Zeichnen für Random Blöcke
            for(int i = 1; i < blockArray.length; i++){
                f2.setColor(blockArray[i].getFarbe());
                f2.fillRect(blockArray[i].getX_Block()-getXBild(), blockArray[i].getY_Block(), blockArray[i].getWidth(), blockArray[i].getHeight());
                blockArray[i].kollisionsabfrage(blockArray[i].getX_Block()-getXBild(), blockArray[i].getY_Block() + blockArray[i].getHeight(), figur_posX + (74-12), figur_posY);
             
                if(blockArray[i].Coin() == true){
                    coin_score += 1;
                }
             
                /*if(){
                    //Wenn Blöcke übereinander liegen
                }*/
             
            }
         
         
        //Punktestand
        f2.setColor(Color.WHITE);
        f2.drawString("Score :" + coin_score, 10, 15);
     
    }
    /***********************************************/
 
 
 
 
 

 
    /***************** akutelle X Position des Hintergrunds zurückliefern ***********************/
    private int getXBild() {
        return background_aktuelle_posX;
    }
    /***********************************************/
 
 
 
 
 
 

    /********************BEWEGEN METHODE**************************/
    public void bewegen(){
     
        if (background_posX != -2) {
            if (figur_posX + background_posX <= 75) {
                figur_posX += background_posX;
            } else {
                background_aktuelle_posX += background_posX;
                backgroundZeichnenX += background_posX;
                backgroundZeichnenX_zwei += background_posX;
            }
        }else {
            if (figur_posX + background_posX > 0) {
                figur_posX += background_posX;
            }
        }

    }
    /**************************************************************/
 
 
 
 
 
 
 
    /**************************** KEYEVENT KLASSE *********************************/
    private class AL extends KeyAdapter{
        public AL(){}
     
        public void keyPressed(KeyEvent e){
            gedrueckteTaste = e.getKeyCode();
         
            if(gedrueckteTaste == KeyEvent.VK_LEFT){
                background_posX = -2;
                //figur_posX -= 2;
            }
         
            if(gedrueckteTaste == KeyEvent.VK_RIGHT){
                background_posX = 2;
                //figur_posX += 2;
            }
     
            if(gedrueckteTaste == KeyEvent.VK_ESCAPE){
                //Pause Menü öffnen
            }

            if(gedrueckteTaste == KeyEvent.VK_SPACE){
                if(Springen.springenAnimationFertig == true)
                Sprung();
            }

        }

        public void keyReleased(KeyEvent e){
            gedrueckteTaste = e.getKeyCode();
            if(gedrueckteTaste == KeyEvent.VK_LEFT || gedrueckteTaste == KeyEvent.VK_RIGHT){
                background_posX = 0;
            }
        }
        /*************************************************************/
 
     
     
     
     
        /**************************** SPRINGEN METHODE *********************************/
        public void Sprung(){
            Springen SprungAnimation = new Springen();
            SprungAnimation.start();
        }
        /*************************************************************/

     
    } }
```


Es sind die ersten drei IF Abfrage in der PAINT Methode. Dort wurde es so programmiert, dass sich das Background ständig wiederholt und es gezeichnet wird. Bei einer größeren Framebreite wird es auch gezeichnet, jedoch sind dort Lücken dazwischen, was auch hier mein Problem ist.

Habe schon einiges versucht aber irgendwie habe ich wiedermal nen Blackout.

Ich würde mich freuen, wenn Ihr mir helfen würdet.

Lg


----------



## Sogomn (22. Jan 2016)

Das ganze scheint mir nicht wirklich dynamisch. Das ist eben so, wenn man mit absoluten Werten arbeitet. Mach' Dir eine Hintergrund-Klasse, die das alles für dich übernimmt.
Falls Dir das hilft: https://github.com/Sogomn/Sogomn-en...ngine/src/de/sogomn/engine/fx/Background.java


----------



## F4ckHanoi (22. Jan 2016)

Vielen dank für deine Hilfe .

Ich werde mir das genauer anschauen, wenn ich Zuhause bin. Danach poste ich, ob es geklappt hat oder nicht.

Lg


----------



## F4ckHanoi (22. Jan 2016)

Ich habs ausgetestet. Die Klasse ist eigentlich wunderbar anwendbar aber bei mir weiß ich jetzt echt nicht. Vieles musste ich weglassen und das umzusetzen für mein Code ist für mich irgendwie nicht möglich. Da bin ich doch nur noch mehr durcheinander gekommen.

Ich würde mich sehr freuen, wenn Ihr mir weiterhelfen könnt. Meine Java Fähigkeiten will ich auf jeden Fall verbessern! .

Ich bedanke mich im Voraus

Lg


----------

