Die Game Map

[Wilhelm von Preußen]

Einige Fakten und Gedanken zur game map.
- Insgesamt werden wir an Grafikmaterial vorraussichtlich 150 mb NUR für die Map gebrauchen, welche auf RAM, AGP und grafikkartenmemory verteilt werden.

- Zum Auslesen sämtlicher Map relevanter Bezeichnungen(Ländernamen, Provinznamen, Flüsse) wird ein offscreenSurface in der Grösse der Spielwelt im SYSTEMMEM angelegt und mit einem RGB Wert pro Staat, Provinz etc durch ein bitmap file ausgestattet. Diese RGB Farben der Länder könnten wir ebenfalls als Grenzfarben benutzen oder generell als Länderfarben

- Um verschiedene Kartenansichten zu realisieren, wird es eine "nackte" Weltkarte geben. Auf dieser können, je nach Kartenansicht, verschiedene "Objektsets" dargestellt werden. Jedes Objekt erhält EINE X,Y KOORDINATE DER SPIELWELT, geblittet wird nur, wenn seine X,Y Welt-KOordinate im Sichtfenster des Spielers ist, wobei x_offset der Abstand vom Sichtfenster x der position 0 zur Weltkoordinate x der postion 0, und y_offset der Abstand vom Sichtfenster y der position 0 zur Weltkoordinate y der position 0 ist.
-> if( (x < SCREEN_WIDTH+x_offset || x > x0 + x_offset) && (y < SCREEN_HEIGHT+y_offset || y > y0 + y_offset) )
draw();
Das ist Objektkollisionserkennung im sichtbaren Fenster. Da in nAtioanlism so einige Objekte zu erkennen wären und die Leistung stark darunter leiden würde alle Mapobjekte des Spiels nach deren xy pos zu scannen, werden wir die Spielfläche in Sektoren einteilen und Objekte den Sektoren zuweisen. So müsste immer nur ein kleiner teil an objekten geprüft werden, ob das sichtfenster gerade in ihrer Nähe ist. Beispiel Pseudocode: Wenn Sichfenster X > SEKTORKOORD_EUROPA X und Sichtfenster X < SEKTORKOORD_EUROPA(X + 6000) dann prüfe alle Objekte in Sektor Europa.... oder: switch(sektoren) { case Europa: ........
müsste natürlich noch y geprüft werden und man könnte alles noch genauer programmieren, aber das erstmal als Ansatz. Mit dieser Sektorisierung dürfte das scrollen sehr flüssig werden und die Grafikkarte wird minimalst beansprucht.

- Zu den grossen Oberflächentexturen der map: Von jedem Land wird eien Textur erstellt mir einer globalen x,y Koordinate. Diese wird dann wie in der oben beschriebenen technik auf den bildschirm geblittet.

eine edle nacht

[Bismarck]

hört sich wahrlich beeindruckend an. Da man jedoch immer nur die Objekte des eigenen Landes sieht (sprich fabriken etc.) sollte man eine vorabprüfung auf das Land einbauen.
Sprich Sektoren = Land:
var xtestobject,ytestobject:real; //X und Y-Koordinate des Objektes
var countryx1,countryx2,countryy1,countryy2:real; //linke, obere, untere und rechte Begrenzung des Landes
if (xtestobject < countryx1) OR (xtestobject > countryx2) //teste ob Objekt außerhalb der Landesgrenzen
then skip //falls true dann überspringe Zeichen-anweisung
if (ytestobject < countryy1) OR (ytestobject > countryy2) //teste ob Objekt außerhalb der Landesgrenzen
then skip //falls true dann überspringe Zeichen-anweisung
// ist einfacher Delphicode, aber das macht mein Anliegen vielleicht klarer

[Wilhelm von Preußen]

Gut, mit ein wenig Veränderung wäre euer Ansatz der erste Schritt Richtung Fog OF war . "Zeige nur das, was innerhealb meines landes oder in Sichtweite meines Landes ist". Übrigens, man braucht immer nur 2 Koordinaten eines Objektes und berechnet den Rest mit den Offsets.

Herr, wann kommt der Programmierer? Würde ihn dann freischalten....

[Bismarck]

Bin leider krank und daher zu Hause und kann ihn nicht kontaktieren, sobald ich wieder gesundet bin und er Zeit hat
Definiert mir mal bitte den Offset

PS: kommt ihr mal bitte in den ICQ? Habe gerade die Bilder der Soldaten wiedergefunden

[Bismarck]

Außerdem vielleicht erst noch folgende Abfrage einbauen:
var screenwidth,screenheight:integer; //Auflösung als Variablen
var objectx,objecty:real; //Objektkoordinaten
var screencorx,screencory:real; //Pixel der oben links in der Ecke liegt
if (objectx < screencorx) OR (objectx > (screencorx+screenwidth) )
then skip
if (objecty < screencory) OR (objecty > (screencor + screenheight ) )
then skip
//erste testen ob überhaupt auf sichtbaren Bildschirmauschnitt

[Wilhelm von Preußen]

Bin leider krank und daher zu Hause und kann ihn nicht kontaktieren, sobald ich wieder gesundet bin und er Zeit hat
Definiert mir mal bitte den Offset

PS: kommt ihr mal bitte in den ICQ? Habe gerade die Bilder der Soldaten wiedergefunden

hab mal ein bild gemalt zum thema offset



ich bin im ICQ herr[img]

[Wilhelm von Preußen]

zum noch besseren Verständnis habe ich ein mini konsolenprogramm geschrieben dass zufällig 100 Pixelpostionen ermittelt ..... weitere beschreibung steht im code. Beenden müsst ihr selbst, es ist ein endlosprogramm, download am ende des codes...

Code: Alles auswählen

	struct Pixel
	{
		int x, y; //globale x,y des Pixels
	};


int main()
{
	srand(time(0));

	Pixel p[100]; //100 pixel werden erstellt
	
	//Spielwelt Breite besteht aus 10000 Pixeln
	int spielweltX = 10000;
	//Spielwelt Höhe besteht aus 5000 Pixeln
	int spielweltY = 5000;

    //counter
	int i = 0;

	//zufällige Positionen für die 100 Pixelobjekte erzeugen
	for(i=0;i<100;i++)
	{
		p[i].x = rand()%spielweltX;
		p[i].y = rand()%spielweltY;
	}

    //Sichtbares Spielfenster, Hauptfenster des Spielers
	const int visible_window_width = 800; // virtuelle FensterBreite
	const int visible_window_height = 600; //virtuelle FensterHöhe

	//Scrollgeschwindigkeit festlegen
	int scrollX, scrollY;


/*                     10000->
          *************************************    + = Pixel an random Position x,y
	      *     *                             *
virtuell->*     * 600          +              *
Fenster	  *     *                             *
		  *     *                             *
		  *******                             * 5000
		  * 800             +         +       *
		  *                                   *
		  *         +                         *
		  *                       +           *
		  *                                   *
		  ************************************* 
*/
	int offsetX = 0; //Abstand vom virtuellen fenster x0 zur Welt x0
	int offsetY = 0; //Abstand vom virtuellen fenster y0 zur Welt y0

	while( true )
	{
		cout << "\noffsetX: " << offsetX << " offsetY: " << offsetY << "\n\n";


        //Prüfen ob eine der 100 Pixel im virtuellen Fenster sichtbar sind
		for(i = 0;i<100;i++)
		{
			if( (p[i].x < visible_window_width + offsetX  &&  p[i].x > offsetX)
			&& (p[i].y < visible_window_height + offsetY && p[i].y > offsetY) )
			{
				cout << "Pixel[" << i << "] ist sichtbar! Globale x,y Position: "
					 << p[i].x << ", " << p[i].y << endl;
				
				cout << "Pixel[" << i << "] wurde gezeichnet an x: " << p[i].x-offsetX
					 << " y: " << p[i].y-offsetY << "\n\n";
			}
		}

        cout << "Um wieviele Schritte soll nach X gescroll werden: ";
		cin >> scrollX;
		cout << "Um wieviele Schritte soll anch Y gescrollt werden: ";
		cin >> scrollY;

		offsetX += scrollX;
		offsetY += scrollY;


	}
}

Genauso gehts im spiel, wobei dort keine Pixel ermittelt würden und jedes Objekt über eigene Breite und Höhe verfügt, was zusätzlich noch berechnet werden müsste. Geblittet wird immer nur , sobald ein objekt das virtuelle Fenster ankratzt, wird die Welt Position x,y des Objekts in "Reale" koordinaten des spielfensters umgewandelt und dann wird geblittet.

download:

http://www.nationalism.de/downloads/train.exe

[TheEvilForce]

Geht das nicht einfacher ?
Nehmen wir an, wir haben eine Provinz. Wir geben dann ein Viereck an, in dem die gesamte Provinz drin ist. Beim Blitten überprüfen wir dann einfach nur, ob die Provinz zu sehen ist. So weiss man, ob die Gebäude der Provinz zu blitten sind.

Hierfür könnte man eine Klasse Provinz nehmen :

struct Viereck
{
int Left, Right, Top, Bottom;
};

class Nat_Provinz
{
Viereck Prov_Area;
...
int Sichtbar(int World_Left, int World_Right, int World_Top, intWorld_Bottom); // Liefert 0 = FALSE oder 1 = TRUE zurück
}

Nat_Provinz::Sichtbar(int World_Left, int World_Right, int World_Top, intWorld_Bottom);
{
if (Viereck.Right > World_Left) || (Viereck.Left < World_Right) || (Viereck.Top < World_Bottom) || (Viereck.Bottom > World_Bottom)
return 1;
else
return 0;
}

Beim Blitten prüft man bei den Provinzen einer Region (zum Beispiel Westeuropa), welche Provinzen zu sehen sind und blittet dann nur diese.