2D map mit iso ansicht

TheBenji · **Registriert:** 08.01.2011, 19:18 **Beiträge:** 23

Hallo,

arbeite erst recht kurz mit irrlicht und man fängt natürlich klein an also auch in 2D.
Habe mir also jetzt meinen kleinen Bildschirmbereich gemacht in dem man drin rumlaufen kann, das funktioniert auch super

Ich würde nur mal gerne euch als Profis hier fragen wie ich den Code optimieren kann bzw. was man daran grundlegend anders machen sollte.
Habe mir halt so die tutorials durchgelesen & so aber wie hier oftmals zu lesen ist sind die wohl oftmals recht suboptimal

Also einfach mal kundtun was man daran in hinblick auf größere "welten" und mehr leben in diesen verändern sollte.
...evt. hilfts ja dem einen oder anderen auch direkt als denkanstoß für seine eigenen sachen.

Was noch zu sagen ist, die grafiken habe ich hier her:
http://reinerstileset.4players.de/environmentD.html
Diese sind so modifiziert das die einzelbilder alle in einem bild nebeneinander sind (macht das eig. einen unterschied so performancemäßig?)

Der eventReceiver ist das ding aus dem tut..unverändert^^

Also zum Code:

Code:

#include <irrlicht.h>
#include "driverChoice.h"
#include "MastEventReceiver.cpp"


using namespace irr;
using namespace std;


#ifdef _MSC_VER
#pragma comment(lib, "Irrlicht.lib")
#endif

int main()
 {



   MastEventReceiver eventReceiver;

     IrrlichtDevice *device = createDevice(video::EDT_SOFTWARE,
      core::dimension2d<u32>(800, 500), 16, false, false, false, &eventReceiver);
//Prüfen obs nen fehler gab...
      if(device == 0)
       return 1;

//kreativer (hier) unnötiger fenstertitel und logger der hier noch nicht genutzt wird
        device->setWindowCaption(L"2D RPG - Beta");
        ILogger *logger = device->getLogger();


        video::IVideoDriver *driver = device->getVideoDriver();
//Die ganzen Texturen definieren
        video::ITexture* running_left = driver->getTexture("media/harry_the_orc/running_left.bmp");
        video::ITexture* running_right = driver->getTexture("media/harry_the_orc/running_right.bmp");
        video::ITexture* running_top = driver->getTexture("media/harry_the_orc/running_top.bmp");
        video::ITexture* running_down = driver->getTexture("media/harry_the_orc/running_down.bmp");
        video::ITexture* stay_left = driver->getTexture("media/harry_the_orc/stay_left.bmp");

        //Terrain
        video::ITexture* TroughEarth = driver->getTexture("media/Trough_earth/rough ripple earth dark to grass tileset.bmp");

        video::ITexture* images;
//Für den imaginären Text xD
        gui::IGUIFont* font = device->getGUIEnvironment()->getBuiltInFont();



//eig. eher en fall für irgende config, startPosition, laufgeschwindigkeit
//jede bewegung der figur besteht aus 8 bildern, in frame wird das "aktuelle" gespeichert
int pos1 = 100;
int pos2 = 100;
int frame = 0;
int speed = 2.5;

   while(device->run() && driver)
   {
      if (device->isWindowActive())
      {
//Damit man nicht von der Karte runterlaufen kann
if(pos1 < 1)
 pos1 = 1;
if(pos2 < 1)
 pos2 = 1;
if(pos2 > 399)
 pos2 = 399;
if(pos1 > 699)
 pos1 = 699;

//frame um eins erhöhen, sind wir fertig wird es wieder auf null gesetzt
frame ++;
if(frame > 7)
 frame = 0;
//Prüfen ob eine Taste gedrückt ist, wenn ja grafik wechseln und position verändern
if(eventReceiver.IsKeyDown(irr::KEY_KEY_W))
 {
     pos2 -= 2 * speed;
     images = running_top;

 }
else if(eventReceiver.IsKeyDown(irr::KEY_KEY_D))
 {
     pos1 += 2 * speed;
     images = running_left;
 }
else if(eventReceiver.IsKeyDown(irr::KEY_KEY_S))
 {
     pos2 += 2 * speed;
     images = running_down;
 }
else if(eventReceiver.IsKeyDown(irr::KEY_KEY_A))
 {
     pos1 -= 2 * speed;
     images = running_right;
 }
else
 {
     images = stay_left;
 }

//alphamode für die gragiken ;)
driver->makeColorKeyTexture(images, core::position2d<s32>(0,0));
driver->makeColorKeyTexture(TroughEarth, core::position2d<s32>(0,0));
//Der timer der hier noch nicht genutzt wird
         u32 time = device->getTimer()->getTime();

         driver->beginScene(true, true, video::SColor(255,120,102,136));

         //Zeichne (überaus abwechslungsreiche) Terrain
         for(int i=0; i < 6; i++)
          {
              for(int j = 0; j<6; j++)
               {
         driver->draw2DImage(TroughEarth, core::position2d<s32>(i*200,j*140),core::rect<s32>(530,510,740,650), 0, video::SColor(255,255,255,255),true);
               }
          }
          //Zeichne figur
         driver->draw2DImage(images, core::position2d<s32>(pos1,pos2),core::rect<s32>(96*frame,0,96*frame+96,96), 0, video::SColor(255,255,255,255),true);


//Ändere den fenstertitel (gebe die fps aus)
core::stringw str = L"2RPG - Beta | FPS: ";
str += driver->getFPS();
device->setWindowCaption(str.c_str());



driver->endScene();


      }
   }

   device->drop();

   return 1;
 }

Freue mich auf Rückmeldung

Ps.: Sry das die formatierung so an..naja..kaputt ist *hust*

TheBenji · **Registriert:** 08.01.2011, 19:18 **Beiträge:** 23

Ach, und wenn ich schon dabei bin

Der gibt auf der Konsole immer aus:
Performance warning, slow unlock of non power of 2 texture.

Was genau will der damit sagen bzw. was kann ich dagegen tun?^^

Letalis Sonus · **Registriert:** 11.02.2009, 23:27 **Beiträge:** 23

Texturen können nur dann optimal verarbeitet werden, wenn die Kantenlänge 2^x ist, also zB 128x128, 64x32 usw. Irrlicht streckt diese dann auch mal ganz gern damit das hinkommt, was zu unscharfen Texturen führt.

TheBenji · **Registriert:** 08.01.2011, 19:18 **Beiträge:** 23

Hmm...okay.
Ist damit die Größe der Grafik gemeint die ich lade und die die ich anzeigen lasse?

Sprich muss ich bei der funktion getTexture() schon die textur entsprechend laden oder reicht es wenn ich die dann beim zeichnen mit draw2DImage() zurecht schneide...?

Edit: Eine Textur von z.b. 2000x125px sollte doch dann aber auch in Ordnung sein, oder...?

Letalis Sonus · **Registriert:** 11.02.2009, 23:27 **Beiträge:** 23

TheBenji hat geschrieben:

Eine Textur von z.b. 2000x125px sollte doch dann aber auch in Ordnung sein, oder...?

Es geht um die Potenz: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, ...
Wie viel von der Textur am Ende gezeichnet wird ist dabei unerheblich, aber die Textur an sich sollte eben möglichst diesen Vorgaben entsprechen, sollte also möglichst bereits als Datei in einer konformen Größe vorliegen.

das heck · **Verfasst:** 09.01.2011, 18:57

Was mir auffällt:

* Struktur ist fürn Arsch =D Nein ernsthaft Klassen benutzen für Karte, Figur, Steuerung etc
* Bitmap Grafiken für sowas? Nimm doch pngs da kann Irrlicht ganz automatisch den Alphachannel nutzen und du musst nicht mit makeColorKey die texture intern bearbeiten. Daher auch die Warnings, dass sowas sehr langsam ist.
* du hast serh viel Code beim rendern (zwischen beginScene(...) und endScene(...)). Vor allem auch Code, der asynchron bearbeitet wird (UserInput und Kollision). Lager das in eine Klasse aus und vor allem lass das on demand berechnen (also nur dann wenns gebraucht wird, Stichwort: Callback)
* im dateinamen möglichst keine leerzeichen, kann zu Problemen führen auf manchen Betriebssystemen
* gui::IGUIFont* font = device->getGUIEnvironment()->getBuiltInFont(); lol^^ Das macht Irrlicht automatisch afaik
* core::stringw str = L"2RPG - Beta | FPS: "; wird jedesmal wieder angelegt, weißt du was es kostet eine Variable anzulegen? Und das bei jedem renderdurchlauf? =D

Alles in allem coole Sache, aber du kannst Irrlicht viel besser und effizienter nutzen. Wenn du dich geschickt anstellst kannst du z.b. ein Karteninterface bauen, welches dann entweder von ortho, iso oder hexa implementiert wird. Sprich du hast mid dem gleichen Aufwand normale Karten, isometrische oder hexagonale Karten, aber das würde jez zu weit führen^^

Ich hoffe auf Anwort von dir, kann man gut diskutieren sowas

TheBenji · **Registriert:** 08.01.2011, 19:18 **Beiträge:** 23

Natürlich antworte ich

Hoffe ja auf die Hilfe von erfahrenen Leuten hier da ich sowas in der form bisher nicht gemacht habe.

Das mit den Klassen war mir soweit bewusst..war halt bisher nur ein testdurchlauf.

Bin auch dran das sinnvoll zu erweitern da es natürlich auf lange sicht ein kleines rpg werden soll

Das mit den Texturen habe ich jetzt soweit hinbekommen, sprich die performance warnung bekomme ich nicht mehr.

Bin im moment nur am rumprobieren also nichts wesentliches zu zeigen/sagen oder so...

Aber ein Punkt evt. noch:
Das man die sachen möglichst selten zeichnen sollte ist mir bewusst auch wenn ich es bisher nicht beherzigt habe

würde da mir aber einfach in der klasse "Instanz" (das spiegelt die map bzw den teil der map wieder in der man sich befindet) einen flag setzen ob sich die karte verändert hat, sprich ob der ausschnitt gescrollt werden müsste ?wenn ja neu zeichnen, wenn nein bleibts so.
Figuren werden sowieso in einer eigenen Klasse gerendet haben damit also erstmal weniger zu tun.

Wie gesagt habe ich den flag noch nicht gesetzt aber eine if anweisung darum würde jetzt auch nicht so die welt sein aber es geht hier um die anderen Punkte.

Ich denke hier kann man noch viel rausholen, die Funktion in der Klasse die für das zeichnen zuständig ist sieht aktuell so aus:

Code:

 void drawMap(int x, int y, IrrlichtDevice *device)
       {

        video::IVideoDriver *driver = device->getVideoDriver();

        //Terrain
        video::ITexture* TroughEarth = driver->getTexture("media/Trough_earth/rough ripple earth dark to grass tileset.bmp");
        driver->makeColorKeyTexture(TroughEarth, core::position2d<s32>(0,0));

        //MapElements:
         video::ITexture* Trees = driver->getTexture("media/TTrees/trees_tileset.bmp");
         driver->makeColorKeyTexture(Trees, core::position2d<s32>(0,0));
         video::ITexture* wall = driver->getTexture("media/TStonewall/brownStonewall.bmp");
         driver->makeColorKeyTexture(wall, core::position2d<s32>(0,0));
         video::ITexture* hills = driver->getTexture("media/TStonebrown/tileset.bmp");
         driver->makeColorKeyTexture(hills, core::position2d<s32>(0,0));


        //Hintergrund zeichnen
            for(int i=0; i < 6; i++)
          {
              for(int j = 0; j<6; j++)
               {
                driver->draw2DImage(TroughEarth, core::position2d<s32>(i*200,j*140),core::rect<s32>(530,510,740,650), 0, video::SColor(255,255,255,255),true);
               }
          }
          //Alle Elemente durchgehen und prüfen ob diese in dem sichtbaren bereich sind
         for (int i=0; i<max_elements; i++)
          {
           if(allElements[i].element == 1) //Baum einzelnd
            driver->draw2DImage(Trees, core::position2d<s32>(allElements[i].start_x - akt_x,allElements[i].start_y - akt_y),core::rect<s32>(15,0,125,125), 0, video::SColor(255,255,255,255),true);
              if(allElements[i].element == 2) //Wall top
            driver->draw2DImage(wall, core::position2d<s32>(allElements[i].start_x - akt_x,allElements[i].start_y - akt_y),core::rect<s32>(0,0,760,130), 0, video::SColor(255,255,255,255),true);
               if(allElements[i].element == 3) //Wall right
            driver->draw2DImage(wall, core::position2d<s32>(allElements[i].start_x - akt_x,allElements[i].start_y - akt_y),core::rect<s32>(0,250,130,1010), 0, video::SColor(255,255,255,255),true);
            if(allElements[i].element == 4) //square hills vertical
             {
                driver->draw2DImage(hills, core::position2d<s32>(allElements[i].start_x - akt_x,allElements[i].start_y - akt_y),core::rect<s32>(960,450,1024,590), 0, video::SColor(255,255,255,255),true);
                driver->draw2DImage(hills, core::position2d<s32>(allElements[i].start_x - akt_x,allElements[i].start_y - akt_y + 135),core::rect<s32>(960,450,1024,590), 0, video::SColor(255,255,255,255),true);
                driver->draw2DImage(hills, core::position2d<s32>(allElements[i].start_x - akt_x,allElements[i].start_y - akt_y + 275),core::rect<s32>(960,450,1024,590), 0, video::SColor(255,255,255,255),true);
             }




          }
       } //end drawMap

Als erstes wird einfach auf dem ganzen sichtbaren Hintergrund etwas wiese gemalt (in form einer grastextur).

Alle Elemente die mehr oder weniger dynamisch gezeichnet werden werden in einem array gespeichert mit einer ID (aktuell gibt es nur 4 verschiedene elemente).
Wie viele maximal in einer Instanz existieren dürfen lege ich beim initialiseren der klasse fest.

Diese werden einfach alle durchgelaufen und gezeichnet.
(ist das element "0" wird halt dann einfach gar nichts gemacht).
Bin mir nicht sicher ob diese Lösung so gut ist...
...was hier noch fehlt ist die Abfrage ob das element überhaupt in dem sichtbaren kartenausschnitt liegen.
müsste aber nur die abfrage erweitert werden, ist auch nicht so das Problem.

Sprich abgesehen von den zwei Punkten:
*karte nur zeichnen beim scrollen
*nur elemente zeichnen die auf dem kartenabschnitt sind
Was ist noch alles scheiße hier?

Kann man die Benutzereingaben sinnvoll auslagern lassen?
Ich mein die müssen ja eh eig. durchgehend überprüft werden oder habe ich da einen denkfehler?

edit: dateinamen werde ich bearbeiten, wenn du sagst png's sind besser dafür auch die bmp's mal in png's umwandeln

edit2: Okay die erste Idee von mir war nicht durchdacht xD
Wenn ich die nicht neu zeichnen lasse werden die alten ja deswegen noch lange nicht beibehalten...xD
Also muss ich die doch in der Theorie in jedem schleifendruchgang neu zeichnen lassen, oder? oO

das heck · **Verfasst:** 09.01.2011, 20:52

Richtig

Das wollte ich grade sagen, aber gut, dass dus erkannt hast. Wäre auch doof gewesen, da deine Idee keine animierten Tiles zulässt :<

Objekte zu cullen ist schon sehr sinnvoll, da es eben die performance ziemlich steigern kann. So wenig draw-Befehle wie geht. Ich hoffe, dass ist in der endgültigen Fassung dann raus., aber ich sags nochmal: Im rendering-Schritt Variablen anlegen solltest du vermeiden. So wenig wie möglich Schritte da reinbasteln.

>Kann man die Benutzereingaben sinnvoll auslagern lassen?
Sicher dat, das macht doch Irrlicht. Da läuft iwo ein EventListener, der alles abfängt und ein entsprechendes Event schmeißt, was du dann abfangen kannst.

TheBenji · **Registriert:** 08.01.2011, 19:18 **Beiträge:** 23

Hmm, wie macht man das mit dem cullen am hier besten?
Weiß da grad ehrlich gesagt nicht wo ich ansetzen soll...

Wie gesagt, die Bilder werde ich noch in's png umwandeln...

Ich habe auch mal das ganze soweit wie es ist hochgeladen...einmal in compilierter form für linux und die source-datein.

Wenn du zeit und lust hast kannste dir das ja mal anschauen, würde mich freuen.
Mich intressiert natürlich alles was performance-steigernd ist^^
Habe aktuell auf meinem High-end rechner (muhahah) durchschnittlich 26fps *hust*
(Wie schaut das so bei euch aus..?)

Wenn du magst kannst du mir dann ja mal ein Beispiel zum cullen daran zeigen und am besten auch was du noch alles aus der main rausschmeißen würdest...
...werde wohl mal noch die events ..irgendwohin verpacken...da werden ja noch ein paar dazu kommen...

Und mal noch so ein spontaner Einwurf:
Mir kam die Idee das sich die Wiese "abnutzen" können soll, sprich ich möchte die Textur ändern können...wenn z.b. 100 mal jemand über ein feld gelaufen ist soll die textur sich ändern.
Problem dabei ist, es gibt in diesem Sinne ja keine felder, es wird ja alles über die pixelzahl gemacht...also ist ja sozusagen stufenlos (muhahah).

Man müsste also irgendwie felder definieren und diese in nem array speichern oder so...nur das verballter ja dann sicher unendlich viele ressourcen, oder?
Kann man das auch iwie anders lösen oder so das es nicht total unperformant ist?

Belassen wir es an dieser Stelle mal damit xD

------------------------
-.-
muss der die datei erst hochladen um mir dann zu sagen das die zu groß ist?...hmpf

okay, downloadlink: http://www.fileuploadx.de/451523

das heck · **Verfasst:** 10.01.2011, 10:55

Also 26 fps o.O" Da geht mehr, ich hab nen 4 Jahre alten Rechner (AMD Smeperon 300+ 1.8GHz) und hab durchschnittlich 40+ fps

Werds mir mal anschauen.

Ansonsten wegen deiner Abnutzung

1. Gute Idee

2.

Code:

class Tile
{
public:
ITexture* image;
position2d<int> coords;
unsigned int numOfEntries; //Wie oft wurd es betreten...

...
};

class Map
{
public:
Tile* karte[10][10];
//erstellen und rendern istn klacks verzichte mal drauf

void update(void) //wird periodisch aufgerufen
{
for(unsigned int x = 0; x < 10; x ++)
for(unsigned int y = 0; y < 10; y ++)
{
if(karte[x][y]->numOfEntries >= 100)
{
tile[x][y]->image = driver->getTexture("dirt.png");
}//if
}//for
}//update
};

Das ist keine OOP, natürlich sind alle Methoden private und alles was dazu gehört, aber es sollte ja zur Wegrichtung dienen und auf keinen Fall c&p zum Opfer fallen.

Ansonsten Cullen: Wenn du deine Karte hast musst du für jedes Tile überprüfen, ob es sichtbar ist, mit anderen Worten: sobald eine Ecke sichtbar ist musst du zeichnen! Zumindest gilt der Ansatz für OrthoMaps, bei Isomaps und Hexa geht das auch, nur musst du vorher die Bildkoordinaten transformieren.

(Gute Anleitung + Erklärung: http://www.tonypa.pri.ee/tbw/tut18.html)

Code:

rect<int> screen = rect<int>(0,0,screenwidth,screenheight);
for(unsigned int x = 0; x < 10; x ++)
for(unsigned int y = 0; y < 10; y ++)
{
if(screen.isPointInside(tile[x][y].position) || screen.isPointInside(tile[x][y].position + position2d<int>(tileWidth, tileHeight))
{
tile[x][y]->render();
}
}

Wieder mal nur n Fingerzeig, bitte kein c&p da kann man noch einiges optimieren und verbessern.

Grüße heck

p.s.: Comments zu deinem Code folgen noch

TheBenji · **Registriert:** 08.01.2011, 19:18 **Beiträge:** 23

Okay, dann werde ich also über die Karte aufjedenfall noch ein raster drüber legen um darin dann informationen zu den feldern zu speichern wie z.b. Abnutzung.

Hm, okay, also meint cullen nur das ich Grafiken zeichnen lasse die im Bildausschnitt liegen? Hm, das wurde da noch nicht so ganz beherzigt *hust*
Ist aber nicht so das Problem da noch mit einzubringen.

Ansonten freue ich mich schon mal auf deine kommentare zu dem Code und hoffe auf verbesserungsvorschläge

..kannst ja mal wenn du denn so unverändert startest schauen wie viele fps du hast...
werde wenn ich daheim bin mir auch mal dein bombermann anschauen (kann man sich da die fps einblenden lassen?) und mal gucken ob ich da noch ein paar Ideen klauen kann

:D

das heck · **Verfasst:** 10.01.2011, 12:43

Hab noch nicht geschaut wie viel fps ich da bekomme, aber ich werds dann hier nochmal editieren keine Sorge

Comments findest du hier: http://rapidshare.com/files/441783490/source.zip

Kannst einfach mal Volltext suche machen und nach sowas suchen COMMENT da findest du meine Kommentare, musst also net rumirren. Hab auch mal ein interface mitgeliefert, wie ich mir das so vorstelle, bzw. wie ich es selber verwende und ich bin höchst zufrieden damit

Ist mehr als dynamisch und vor allem kann man dazu einen Leveleditor bauen (was ich auch bereits getan habe *hust*)

@RPGBomber: Fps werden angezeigt als WindowCaption. Da krieg ich im Menu knappe 360 und im Spiel imemrhin noch 260+ hin von daher geht da bei dir auf jeden Fall noch was

Ansonsten Ideen klauen würde ichs nicht unbedingt nennen, ist ja GPL von daher sowieso alles frei kannst also nachschauen ohne dich wie ein Dieb zu fühlen

fps: 36

Dann hab ich mal n bissl rumoptimiert, d.h. alle Variablen die im Renderschritt angelegt werden durch lokale Klassenmamber ersetzt usw...

fps: 82

2D map mit iso ansicht

Wer ist online?