21

Montag, 23. April 2012, 10:32

Das klingt gar nicht so schlecht, wenn ich es richtig verstanden habe... Ich würde aber in deiner Map-Klasse eine Methode implementieren, in der du deine for-Schleife baust, und nur diese aus Rpg aufrufen.
.Leo

22

Montag, 23. April 2012, 11:05

Poste bitte mal wie du es gelöst hast, wäre nett wenn du es mit Erklärung machst wie du es gelöst hast.

23

Montag, 23. April 2012, 11:18

Meine Klassen sehen atm. so aus. Sie werden in deinem Projekt nicht funktionieren da ich andere eigene Klassen und draw-Methoden etc. verwende, aber als grobes Beispiel können sie dienen.

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class Tilemap {
	public LVector mapSize; // Mapgrösse in Feldern, LVector enthält lediglich ein x- und ein y-Feld (floats), in die ich die Werte speichere
	public Tileset tileset; // Das Tileset der Map, die Klasse habe ich unten ebenfalls angehängt
	public int[][] tiles; // Array, das die Nummern der Tiles speichert
 
        // Konstruktor, erstellt ein Array mit der gewünschten Grösse und füllt alles mit 0, also dem ersten Tile des Tilesets
	public Tilemap(Tileset pTileSet, LVector pMapSize){
		tileset = pTileSet;
		mapSize = pMapSize;
		tiles = new int[(int) mapSize.x][(int) mapSize.y];
		for(int x = 0; x < mapSize.x; x++){
			for(int y = 0; y < mapSize.y; y++){
				tiles[x][y] = 0;
			}
		}
	}
 
        // Geht durch jedes Element des Arrays und ruft die Draw-Methode meines Tilesets auf, um das richtige Tile an der richtigen Stelle zu zeichnen
	public void draw(SpriteBatch spriteBatch){
		for(int x = 0; x < mapSize.x; x++){
			for(int y = 0; y < mapSize.y; y++){
				tileset.drawTile(spriteBatch, tiles[x][y], new LVector(x*tileset.tileSize, y*tileset.tileSize));
			}
		}
	}
}


Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Tileset {
	public Texture sprite;
	public int tileSize;
 
	public LTileset(String pImage, int pTileSize){
		sprite = new Texture((Gdx.files.internal(pImage))); // Laden des Bildes
		tileSize = pTileSize;
	}
 
	public void drawTile(SpriteBatch spriteBatch, int i, LVector position) {
		int x = (int)(i * tileSize) % sprite.getWidth(); // Berechne die x-Position des Tiles auf dem Tileset
		int y = (int)(i * tileSize) / sprite.getWidth()*tileSize; // Berechne die y-Position des Tiles auf dem Tileset
		spriteBatch.draw(sprite, position.x, position.y, x, y, tileSize, tileSize); // Zeichnen des richtigen Ausschnitts aus dem Tileset, musst du dann mit der gleichen Methode wie in deiner Sprite-Klasse implementieren
	}
}


Vielleicht hilft das Bild hier noch etwas, das sind die Tilenummern:
Bild

Wie du siehst, habe ich keine Kollision implementiert. Man müsste jetzt der Tileset-Klasse einfach noch z.B. ein boolean Array geben, das für jedes Tile speichert, ob es passierbar ist oder nicht.

Btw, auch ich nehme Verbesserungsvorschläge gerne an, ich mach das auch zum ersten Mal...^^
.Leo

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von ».Leo« (23. April 2012, 12:41)


24

Montag, 23. April 2012, 12:39

Ich kann das jetzt schwer nachvollziehen was du da gemacht hast.
Was befindet sich denn genau in dieser LVector Methode? Nur die Map-Größe? Oder befindet sich der da eigentliche Array drin?

25

Montag, 23. April 2012, 12:45

Mein LVector enthält nur die Mapgrösse in Tiles, also z.B:
mapSize.x = 20;
mapSize.y = 15;

Anstelle des Vectors erstellt du einfach zwei Variabeln.
Das eigentliche Array ist "tiles".

Vielleicht muss ich ein Tutorial dafür machen, oder aber du schaust dir die Tutorials durch, die DarkPrisma gepostet hat.
Edit Das Tut muss etwas warten, momentan fehlt mir komplett die Lust dazu...
.Leo

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von ».Leo« (23. April 2012, 17:14)


26

Montag, 23. April 2012, 12:52

Okay danke durch die Bilder ist es jetzt verständlicher, dann ist es ja ähnlich aufgebaut wie in der Hero-Klasse das mit den Tiles.

Edit 1:
Über ein Tutorial würde ich mich sehr freuen, weil vom Verständnis her würde mir das mehr bringen, natürlich nur wenn du dazu bereit wärst.

Edit 2:
Habe nun versucht eine Zufallsfunktion zum anzeigen der Felder zu machen. Aber momentan zeigt er noch gar nichts an, siehst du noch irgendwo einen Fehler?

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
import java.awt.*;
import java.awt.event.*;
 
public class renderMap extends Frame
{
  private Map map;
 
  public int sx1=0;
  public int sy1=0;
  public int sx2=32;
  public int sy2=32;
 
  public void sprite()
  {
	map = new Map("map.jpg");
	switch(map.tiles[map.mapSize_x][map.mapSize_y])
	{
    	case 0: // Gras
    	sx1=0;
    	sy1=0;
    	sx2=32;
    	sy2=32;
    	break;
 
    	case 1: // Zaun
    	sx1=0;
    	sy1=32;
    	sx2=32;
    	sy2=64;
    	break;
 
    	case 2: // Pfähle
    	sx1=0;
    	sy1=64;
    	sx2=32;
    	sy2=96;
    	break;
 
    	case 3: // Nadelbaum
    	sx1=0;
    	sy1=64;
    	sx2=32;
    	sy2=96;
    	break;
 
    	case 4: // Fruchtbaum
    	sx1=32;
    	sy1=0;
    	sx2=64;
    	sy2=32;
    	break;
 
    	case 5: // Innere Ecke rechts Höhle
    	sx1=32;
    	sy1=32;
    	sx2=64;
    	sy2=64;
    	break;
 
    	case 6: // Innere Ecke links Höhle
    	sx1=32;
    	sy1=64;
    	sx2=64;
    	sy2=96;
    	break;
 
    	default:
    	sx1=0;
    	sy1=0;
    	sx2=32;
    	sy2=32;
    	break;
	}
  }
}

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
import java.awt.*;
import java.awt.event.*;
 
public class Map extends Frame
{
  Image map;
  Image sprite;
 
  private renderMap render;
 
  public int mapSize_x=20;
  public int mapSize_y=20;
  private int x=1;
  private int y=1;
  public int[][] tiles; // Array, das die Nummern der Tiles speichert
 
  public Map(String Pmap)
  {
	render = new renderMap();
	map = getToolkit().getImage("map.jpg");
	sprite = getToolkit().getImage("Tileset.png");
	tiles = new int[mapSize_x][mapSize_y];
	tiles[mapSize_x][mapSize_y]=(int)(Math.random()*6);
  }
 
  public void draw(Graphics g)
  {
	g.drawImage(map, 0, 0, this);
	for(int i=0; i<639; i=i+32)
	{
  	for(int j=0; j<639; j=j+32)
  	{
    	g.drawImage(sprite, i, j, i+32, j+32, render.sx1, render.sy1, render.sx2, render.sy2, this);
  	}
	}
  }
}

Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von »Laiminator1992« (24. April 2012, 09:19)


27

Mittwoch, 25. April 2012, 22:02

Grundsätzlich verstehe ich nicht, warum du diesen Aufbau gewählt hast... Etwas verwirrend das ganze (Klassen sollten btw. gross geschrieben werden und Methoden ein Verb im Namen haben, auf die Naming Conventions hab ich ja schonmal verwiesen).

1. müssen "renderMap" und wahrscheinlich auch "Map" nicht von Frame erben, bzw wüsste ich nicht warum
2. ein Switch-Case loopt nicht durch deine Tiles, somit wird nur ein Feld (das btw. auch gar nicht existiert, Index 20 gibts nicht in deinem Array, nur 0-19) geprüft
3. ist ein Switch gar nicht notwendig, Zeile 11+12 in meiner Tileset-Klasse lösen das mMn. eleganter
4. sehe ich nicht, wo du deine sprite-Methode aufrufst, was wohl auch nicht geschieht, weil sonst Exceptions fliegen würden xD Müsste dann wohl auch in jedem Schleifendurchlauf aufgerufen werden, wie gesagt, das lässt sich sicher besser lösen...
5. Map übergibst du einen Parameter, den du gar nicht verwendest
6. eine Map-Klasse würde bestimmt reichen

Abgesehen von einigen oben genannten Punkten könnte das ganze funktionieren, auch wenn der Code nicht sehr strukturiert und durchdacht wirkt.^^

Fürs Tutorial fehlt mir momentan die Lust, tut mir leid.
.Leo

28

Freitag, 27. April 2012, 17:18

So ich habe es jetzt eigentlich soweit bloß bekomme ich es noch nicht hin, dass mein Array einen Rückgabewert für meine Switch-Anweisung liefert.

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
import java.awt.*;
import java.awt.event.*;
 
public class Feld extends Frame
{
	Image sprite;
 
	public int[][] tile;
	private int mapTiles;
 
	private int x;
	private int y;
 
	public Feld()
	{
   	sprite = getToolkit().getImage("Tileset.png");
	}
 
	public int[][] neu(int mapTiles)
	{
    	this.mapTiles= mapTiles;
    	tile = new int[mapTiles][mapTiles];
    	for(int i=1; i<mapTiles; i++)
    	{
       	for(int j=1; j<mapTiles; j++)
       	{
          	tile[i][j] = (int)(Math.random()*24);
       	}
    	}
    	return tile;
	}
 
	public void get(int i, int j)
	{
  	switch(tile[i][j])
  	{
          	case 0:
          	y=0;
          	x=0;
          	break;
 
          	case 1:
          	y=0;
          	x=1;
          	break;
 
          	case 2:
          	y=0;
          	x=2;
          	break;
 
          	case 3:
          	y=0;
          	x=3;
          	break;
 
          	case 4:
          	y=1;
          	x=0;
          	break;
 
          	case 5:
          	y=1;
          	x=1;
          	break;
 
          	case 6:
          	y=1;
          	x=2;
          	break;
 
          	case 7:
          	y=1;
          	x=3;
          	break;
 
          	case 8:
          	y=2;
          	x=0;
          	break;
 
          	case 9:
          	y=2;
          	x=1;
          	break;
 
          	case 10:
          	y=2;
          	x=2;
          	break;
 
          	case 11:
          	y=2;
          	x=3;
          	break;
 
          	case 12:
          	y=3;
          	x=0;
          	break;
 
          	case 13:
          	y=3;
          	x=1;
          	break;
 
          	case 14:
          	y=3;
          	x=2;
          	break;
 
          	case 15:
          	y=3;
          	x=3;
          	break;
 
          	case 16:
          	y=4;
          	x=0;
          	break;
 
          	case 17:
          	y=4;
          	x=1;
          	break;
 
          	case 18:
          	y=4;
          	x=2;
          	break;
 
          	case 19:
          	y=4;
          	x=3;
          	break;
 
          	case 20:
          	y=5;
          	x=0;
          	break;
 
          	case 21:
          	y=5;
          	x=1;
          	break;
 
          	case 22:
          	y=5;
          	x=2;
          	break;
 
          	case 23:
          	y=5;
          	x=3;
          	break;
  	}
	}
 
}

Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.awt.*;
import java.awt.event.*;
import java.io.*;
public class Map extends Frame
{
  Image map;
 
  private Feld feld;
  private int i;
  private int j;
  private int x;
  private int y;
  private int mapTiles;
 
  public Map()
  {
 	feld= new Feld();
 	int tile[][]=feld.neu(mapTiles=20);
 	//System.out.println(tile[i][j]);
  }
 
  public void draw(Graphics g)
  {
 	feld.get(x, y);
 	x = x*32; // Berechne die x-Position des Tiles auf dem Tileset
 	y = y*32; // Berechne die y-Position des Tiles auf dem Tileset
 	for(i=0; i<639; i=i+32)
 	{
   	for(j=0; j<639; j=j+32)
   	{
       	g.drawImage(feld.sprite, i, j, i+32, j+32, x, y, x+32, y+32, this);
   	}
 	}
  }
}

29

Samstag, 28. April 2012, 09:17

Hallo,

vielleicht hilft dir das hier auch weiter. Weil wir haben eine Tutorial, wie man einen Karteneditor mit passender Engine baut. Ich habe die Tutorial relativ einfach gehalten.

Java/Tutorials – Scientia

Aber vielleicht hilft sie dir.

30

Samstag, 28. April 2012, 19:16

Hallöle,
beobachte das hier schon seit dem Thread-Start und gebe jetzt au mal meinen Senf zu Laiminators Code dazu.
Bezüglich des Frame-Extends: Du kannst einfach ein BufferedImage-Objekt über ImageIO.read(filename) laden, wodurch du die Extension nicht mehr brauchst. Du könntest aber auch Toolkit.getDefaultToolkit().getImage(filename) verwenden, ImageIO ist aber meines Wissens sowieso Konvention. An sich unterscheiden sich Buffered- und das normale Image eigentlich nicht, zumindest bei deiner momentanen Verwendung.
Deine get-Methode in der Feld-Klasse ergibt für mich gerade auch keinen Sinn da sie sich von der Definition schon selbst "widerspricht", sie hat keinen Rückgabewert, man holt sich aber etwas damit. Noch dazu setzt sie x- und y-Werte die aber nirgendwo verwendet werden. Die Feld-Klasse soll denke ich mal dazu dienen, ein bestimmtes Tile aus dem Tileset zu holen um dieses für die Map auf den Bildschirm zu zeichnen. Du könntest eine Tile-Klasse erstellen, welche definiert, welche Position das Tile auf dem Tileset hat und welche Begehbarkeit (Eine eigene Klasse um das ganze einfach zu erweitern).
Also sollte die Map ein Array haben, in dem du für x- und y-Positionen auf der Map Tile-Objekte anlegst. Du kannst jetzt ein Tileset-Klasse haben für die du sagst: Nummeriere deine Tiles durch und erstelle für jedes nach Vorgaben (Eine Datei oder ähnliches, welche sagt "Tile 1 ist begehbar und liegt auf Position 1, 32") ein Tile-Objekt. Um jetzt die Tiles auf die Map zu bekommen brauchst du wieder eine Datei oder sowas, in der du sagst, Position x,y hat Tile 1. Diese liest du in das Teil Array der Map ein. Beim zeichnen der Map benutzt du jetzt eine Methode ala map.getTileAt(x,y) um an die einzelnen Tiles ranzukommen. Dementsprechend musst du natürlich ein SubImage erstellen etc.

Aber wenn du willst kann ich dir das ganze noch ausführlicher per Skype oder so erklären, etwaige Messenger-Namen von mir findest du hier in meinem Studio-Profil auf der rechten Seite.

MfG
Darth Cleanueis
  • Minecraft Bild

    Ich betreibe seit neustem einen Minecraft-Server, welcher noch fleißige Mitarbeiter für die erste Bauphase sucht (Sprich noch gewhitelistet!). Für mehr Infos, guckt hier vorbei ;) .
  • Handschriftdeutung :quill:

    Darth Cleanueis ist eher bescheiden und zurückhaltend.
    Es reicht ihm, wenn er nicht im Mittelpunkt steht.

    Er ist sinnlich, warmherzig, gemütlich und phantasievoll.
    Im Großen und Ganzen wirkt er gelassen bis uninteressiert,
    wenn er aber von einer Sache überzeugt ist, überrascht er
    seine Umwelt durch sein überschwängliches und begeisterungsfähiges Auftreten.

    Er ist lebhaft und kontaktfreudig.
    Mit viel Verständnis für die Belange anderer.

    Darth Cleanueis legt Wert auf eine Grunddistanz zu seinen Mitmenschen.
    Auch gute Kollegen müssen nicht alles wissen.

    Er ist bestrebt, anderen Menschen so weit wie möglich zu helfen.

Ähnliche Themen

Social Bookmarks