# hilfe bei 2DSpiel.



## rrizi (28. Jun 2010)

Kannst du bitte mir helfen?
Ich bin rrizi aus Nederland. Sorry als mein deutsch nicht so gut ist. Aber hilfe mir bitte
Ich habe für meine Schule einen 2D Spiel programiert.  Das Spiel enthält ein Spielfeld, ein Mensch object , Monster object,  schwarze bloken und blaue bloken. 
Also mit der Friltastetn kan man die Mensch object bewegen.  Die Blaue bloken  können durch die Mensch verschiben werden aber die schwartze sind nicht bewegbar.  Die Monster object bewegt sich autamaticch richtung Mensch und wil ihn vressen.  Ich habe das spiel bis hier programiert und das werkt gut aber ich muss nog nun einen neuen blok in das spiel zufügen. Diese muss das funktion haben dass die Mensch object kan auf diese blok darauf gehen und punkte scoren. 
Zo komm ich hier gegen viele probleme. Ich weiss überhaupt nicht in welsche klase muss ich dass ales machen. Die ganze spiel ist eigentlich sehr schlecht und ohne plan programiert. Deswegen nun diese problem. Bitte wer kan hier bij mir helfen. Ich muss das spiel villeicht per email schiken um mehr übersicht zu haben. Besten dank
rrizi987@yahoo.de 

```
package model;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

/**
 *
 * @author Shayan
 */
public class BzBlok extends SpelObject {
    /** variable om beweegbaarheid van de blokken bij te houden*/
    private boolean movable;

    /**
     * Constructor
     * @param v Het veld waar het bzblok geplaatst wordt
     * @param m Of het bzblok beweegbaar is
     */
    public BzBlok(Veld v, boolean m){
        //constructor van SpelObject
        super(v);
        movable = m;
        //als het bzblok beweegbaar is
        if(movable){
            //haal het plaatje van een beweegbaar object op
            try {
                setImg(ImageIO.read(new File(getIPATH()+"Blauweblok.gif")));
            } catch (IOException e) {
                System.out.println("Fout bij het laden!: " + e);
                System.exit(0);
            }
        //als het bzblok niet beweegbaar is
        }else{
            //haal het plaatje van een beweegbaar object op
            try {
                setImg(ImageIO.read(new File(getIPATH()+"Zwarteblok.gif")));
            } catch (IOException e) {
                System.out.println("Fout bij het laden!: " + e);

                System.exit(0);
            }
        }
    }

    
    public boolean isMovable(){
        return movable;
    }

    
    public void changeMovable(){
        movable = !movable;
    }

    /**
     * Beweeg het bzblok
     * @param r De richting om in te bewegen
     * @return Bewegen mogelijk ja of nee
     */
    public boolean move(Richting r){
        //als het object beweegbaar is
        if(movable){
            //haal het buurveld op
            Veld buur = this.getVeld().getBuur(r);
            //als het buurveld bestaat en er staat geen object op
            if(buur != null && buur.getSpelObject() == null){
               
                this.getVeld().setSpelObject(null);
                //Zet het bzblok op het buurveld
                buur.setSpelObject(this);
                
                this.setVeld(buur);

                return true;
            
            }else if(buur != null && buur.getSpelObject() instanceof BzBlok){
              
                BzBlok o = (BzBlok)buur.getSpelObject();
                
                if(o.isMovable()){
                    //beweeg het buurbzblok in dezelfde richting
                    //als het lukt
                    if(o.move(r)){
                        //haal het bzblok van het huidige veld af
                        this.getVeld().setSpelObject(null);
                        //zet het bzblok op het buurveld
                        buur.setSpelObject(this);
                        //stel het buurveld in bij dit bzblok
                        this.setVeld(buur);

                        return true;
                    }
                }
            }
        }
        //als het bewegen niet lukt returnm false
        return false;
    }
}
]
[/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package model;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

/**
 *
 * @author Shayan
 */
public class Mens extends SpelObject {
    /**
     * De constructor
     * @param v Het veld waar de mens op staat
     */
    public Mens(Veld v){
        //roep de constructor van Spel Object aan
        super(v);
        //haal het plaatje van de mens op
        try {
            setImg(ImageIO.read(new File(getIPATH()+"mens.gif")));
        }catch (IOException e) {
             System.out.println("Fout bij het laden van de recources: " + e);
             System.exit(0);
        }
    }

    /**
     * Haal de positie van de mens op
     * @return De positie van de mens
     */
    public Positie getPositie(){
        return this.getVeld().getPositie();
    }

    /**
     * Beweeg de mens
     * @param r De richting om in te bewegen
     */
    public void move(Richting r){
        //DE bur ophalen waar de mens heen wilt
        Veld buur = this.getVeld().getBuur(r);
        //als de buur bestaat & de buur is leeg
        if(buur != null && buur.getSpelObject() == null){
            //Verwijder de Mens van het huidige veld
            this.getVeld().setSpelObject(null);
            //Zet de Mens op het buurveld
            buur.setSpelObject(this);
            //Voeg de buur toe aan de Mens
            this.setVeld(buur);
            this.paint();
         //als de buur bestaat & er staat een Mens op
         }else if(buur != null && buur.getSpelObject() instanceof BzBlok){
                //haal het bzblok op
                BzBlok o = (BzBlok)buur.getSpelObject();
                //als het beweeegbaar is
                if(o.isMovable()){
                    //Als het bzblok bewogen is
                    if(o.move(r)){
                        //Verwijder de mens van het huidige veld
                        this.getVeld().setSpelObject(null);
                        //Zet de mens op het buurveld
                        buur.setSpelObject(this);
                        //Voeg de buur toe aan de mens
                        this.setVeld(buur);
                        this.paint();
                    }
                }
         //als het veld bestaat en er staat een monster op
         }else if(buur != null && buur.getSpelObject() instanceof Monster){
             //monster wint
         }
    }
    
    public void paint(){
        SpelMap.teken();
    }
}
][/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package model;

import java.util.ArrayList;
import java.util.Collections;

/**
 *
 * @author Reza
 */
public class RouteFinder{
        /** De lijst van knooppunten die al volledig onderzocht zijn */
	private ArrayList closed = new ArrayList();
	/** De lijst van knooppunten die nog niet volledig onderzocht zijn */
	private SortedList open = new SortedList();

	/** De map waarop gezocht wordt */
	private SpelMap map;
	/** Het aantal zoekpogingen voordat er wordt opgegeven */
	private int maxSearchDistance;

	/** Alle knooppunten van de map */
	private Node[][] nodes;

        private boolean allowDiagMovement;

	/** De heuristic die wordt gebruikt om te bepalen welk knooppunt het
            eerst onderzocht wordt*/
	private Heuristic heuristic;

        /** bezochte knooppunten */
        private boolean[][] visited;


        /**
	 * Constructor
	 *
	 * @param map De spel map waarop gezocht wordt
	 * @param maxSearchDistance Het aantal stappen dat gezocht mag worden
         * voordat er opgegeven wordt
	 * @param allowDiagMovement Of er diagonaal bewogen mag worden
	 */
	public RouteFinder(SpelMap map, int maxSearchDistance, boolean allowDiagMovement) {
		this.heuristic = new Heuristic();
		this.map = map;
		this.maxSearchDistance = maxSearchDistance;

                //het aantal nodes is gelijk aan het aantal velden
                //ook staan ze in dezelfde volgorde
		nodes = new Node[map.getVelden().length][map.getVelden()[0].length];
		for (int x=0;x<nodes.length;x++) {
			for (int y=0;y<nodes[0].length;y++) {
				nodes[x][y] = new Node(x,y);
			}
		}

                //het aantal visited is gelijk aan nodes
                //ook staan ze in dezelfde volgorde
                
                visited = new boolean[nodes.length][nodes[0].length];
        }


	public Route findRoute(int sx, int sy, int tx, int ty) {
		
		nodes[sx][sy].cost = 0;
		nodes[sx][sy].depth = 0;
		closed.clear();
		open.clear();
		open.add(nodes[sx][sy]);
                clearVisited();
		nodes[tx][ty].parent = null;

		
		int maxDepth = 0;
		while ((maxDepth < maxSearchDistance) && (open.size() != 0)) {
			// Haal het eerste knooppunt uit de open lijst, van dit
                        // knooppunt is het het meest waarschijnlijk dat het
                        // de goede richting is.
			Node current = getFirstInOpen();

                        // Als het doel bereikt is
                        if (current == nodes[tx][ty]) {
                            break;
			}

			removeFromOpen(current);
			addToClosed(current);

			// Zoek alle buren van het knooppunt af en onderzoek
			// of ze een mogelijke volgende stap kunnen zijn
			for (int x=-1;x<2;x++) {
				for (int y=-1;y<2;y++) {
					// Als het het huidige knooppunt is
					if ((x == 0) && (y == 0)) {
						continue;
					}


                                        if (!allowDiagMovement) {
						if ((x != 0) && (y != 0)) {
							continue;
						}
					}

					
					// bepaal de locatie van de buur
					int xp = x + current.x;
					int yp = y + current.y;

                                        // als het een geldige locatie is
					if (isValidLocation(sx,sy,xp,yp)) {
						
						float nextStepCost = current.cost + getMovementCost(current.x, current.y, xp, yp);
						Node neighbour = nodes[xp][yp];
                                                setVisited(xp, yp);

						
						if (nextStepCost < neighbour.cost) {
							if (inOpenList(neighbour)) {
								removeFromOpen(neighbour);
							}
							if (inClosedList(neighbour)) {
								removeFromClosed(neighbour);
							}
						}

						
						if (!inOpenList(neighbour) && !(inClosedList(neighbour))) {
							neighbour.cost = nextStepCost;
							neighbour.heuristic = getHeuristicCost(xp, yp, tx, ty);
							maxDepth = Math.max(maxDepth, neighbour.setParent(current));
							addToOpen(neighbour);
						}
					}
				}
			}
		}

		
		if (nodes[tx][ty].parent == null) {
			return null;
		}

		// Maak een nieuw route aan
                Route route = new Route();

                // Maak een node aan voor het doel
		Node target = nodes[tx][ty];

                // zolang het doel niet gelijk is aan de huidige locatie
		while (target != nodes[sx][sy]) {
                        //voeg de locatie van het doel toe aan de stappen
                        //let op: wordt aan de voorkant van de lijst ingevoerd
			route.prependStep(target.x, target.y);
                        //maak van de parent van het doel het nieuwe doel
			target = target.parent;
		}
                //voeg de huidige locatie als stap toe
		route.prependStep(sx,sy);

		// return het route
		return route;
	}

	
	private Node getFirstInOpen() {
		return (Node) open.first();
	}

	/**
	 * Voeg een knooppunt toe aan de open lijst
	 *
	 * @param node Het knooppunt dat moet worden toegevoegd
	 */

	private void addToOpen(Node node) {
		open.add(node);
	}

	
	private boolean inOpenList(Node node) {
		return open.contains(node);
	}

	
	private void removeFromOpen(Node node) {
		open.remove(node);
	}

	
	private void addToClosed(Node node) {
		closed.add(node);
	}

	
	private boolean inClosedList(Node node) {
		return closed.contains(node);
	}

	
	private void removeFromClosed(Node node) {
		closed.remove(node);
	}

	protected boolean isValidLocation(int sx, int sy, int x, int y) {
		boolean invalid = (x < 0) || (y < 0) || (x >= nodes.length) || (y >= nodes[0].length);

		if ((!invalid) && ((sx != x) || (sy != y))) {
                    Veld curVeld = map.getVeld(x,y);
                    invalid = (curVeld.getSpelObject() != null && !(curVeld.getSpelObject() instanceof Mens));
		}
		return !invalid;
	}

	
	public float getMovementCost(int sx, int sy, int tx, int ty) {
		return 1;
	}

	
	public float getHeuristicCost(int x, int y, int tx, int ty) {
		return heuristic.getCost(x, y, tx, ty);
	}

        
	public void clearVisited() {
		for (int x=0;x<nodes.length;x++) {
			for (int y=0;y<nodes[0].length;y++) {
				visited[x][y] = false;
			}
		}
	}

	
	public boolean visited(int x, int y) {
		return visited[x][y];
	}

        
	public void setVisited(int x, int y) {
		visited[x][y] = true;
	}


	private class Node implements Comparable {
		
		private int x;
		
		private int y;
		
		private float cost;
		
		private Node parent;
		
		private float heuristic;
		
		private int depth;

		
		public Node(int x, int y) {
			this.x = x;
			this.y = y;
                }

		
		public int setParent(Node parent) {
			depth = parent.depth + 1;
			this.parent = parent;

			return depth;
		}

		
		public int compareTo(Object other) {
			Node o = (Node) other;

			float f = heuristic + cost;
			float of = o.heuristic + o.cost;

			if (f < of) {
				return -1;
			} else if (f > of) {
				return 1;
			} else {
				return 0;
			}
		}
	}

        
	private class SortedList {
		/** The list of elements */
		private ArrayList list = new ArrayList();

		public Object first() {
			return list.get(0);
		}

		
		public void clear() {
			list.clear();
		}

		
		public void add(Object o) {
			list.add(o);
			Collections.sort(list);
		}

		
		public void remove(Object o) {
			list.remove(o);
		}

		
		public int size() {
			return list.size();
		}

	
		public boolean contains(Object o) {
			return list.contains(o);
		}
	}

    }
]
[/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package model;
import java.awt.Image;

/**
 *
 * @author Shayan
 */
public abstract class SpelObject {
    /** Het veld waar het object op staat */
    private Veld veld;
    /** Het plaatje dat bij het object hoort */
    private Image img;
    /** De locatie van de plaatjes */
    private final String IPATH = System.getProperty("user.dir") + "\\res\\";

    /**
     * De constructor
     * @param v Het veld waar het object op staat
     */
    public SpelObject(Veld v){
        setVeld(v);
    }

    /**
     * Verander het veld waar het object op staat
     * @param v Het nieuwe veld
     */
    public void setVeld(Veld v){
        veld = v;
    }

    /**
     * Verander het plaatje van het object
     * @param i Het nieuwe plaatje
     */
    public void setImg(Image i){
        img = i;
    }

    /**
     * Haal het veld op
     * @return Het veld waarop het object staat
     */
    public Veld getVeld(){
        return veld;
    }

    /**
     * Haal het plaatje op
     * @return Het plaatje van het object
     */
    public Image getImg(){
        return img;
    }

    /**
     * Haal de locatie van de plaatjes op
     * @return De locatie van de plaatjes
     */
    public String getIPATH(){
        return IPATH;
    }
}
```


----------



## Quaxli (28. Jun 2010)

Du hast das alles programmiert (sogar mit Wegfindung, wenn ich das beim Überfliegen richtig gesehen habe) und weißt jetzt nicht, wie Du ein Feld einfügst mit dem man Punkte erzielen kann? :lol::lol::lol:

Dir ist schon klar, daß das nicht glaubwürdig klingt?


----------



## Quurks (28. Jun 2010)

1) Nichts dagegen dass du rrizi bist aber warum steht oben @author Shayan?
2) Der gesamte Pfadfindungscode erinnert mich irgendwie an Tile Map Path Finding with A Star (A*) | Coke And Code - Java Games and Games Development
3) Warum sind die Variablen / Methodennamen manchmal englisch und manchmal niederländisch?

Zu deiner Frage: ich blick nicht wirklich durch einen niederländisch kommentierten Quellcode durch, ich hab bis jetzt nichtmal die Stelle gefunden wo du den ganzen spass anzeigst. Eventuell mal auf das notwendige beschränken?


----------



## rrizi (28. Jun 2010)

das ist ein project von unsere schule für 2 studente, ich ( reza rrizi) und shayan. das spiel ist in 13 kalssen gemacht. hier habe ich nur ein par von klassen gestellt. wer ahnung hat muss dan das gesamte spiel sehen. wie gesagt von anfang an war die programierung falsh gelaufen. alle code sind durch einander und ohne plan gemacht. deswegen komme ich mit der neue bloken nicht weiter. ich weiss nicht wo muss ich die neue kalssen aanmachen.


----------

