Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Sa Jul 12, 2025 23:12

Foren-Übersicht » Programmierung » Einsteiger-Fragen 		Unbeantwortete Themen | Aktive Themen


Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 14 Beiträge ] 
  Vorheriges Thema | Nächstes Thema 
Autor Nachricht
Pluto
BeitragVerfasst: So Dez 21, 2003 14:46 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
Hallo,
jedes Objekt ist 16X16 Pixel groß.
ich habe eine karte die ist (in meinen fall) 64X21 Pixel groß
Das sichtfenster ist 39X21 Pixel groß

die mini karte soll in ein fehld von:
145X128 Pixel rein

nun meine frage:
wie kann ich den Obitmalen größe für die mini karte herrausfinden, also:
wie groß muss jedes objekt auf der mini karte sein ?

ich verwende für die karte ein 2D Array

und ich benutze die GLXTreem komponenten, was aber egal sein dürfte !
wer hat eine idee für das problem ???
habe allesversucht !

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Lossy eX
 Betreff des Beitrags:
BeitragVerfasst: So Dez 21, 2003 15:18 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Ich verstehe gerade überhaupt nicht von welchen Karten du gerade redest. Bei so etwas sind Bilder nicht unbedingt schlecht. ;-)

Aber ich schätze mal, dass du von einer Übersichtskarte irgendwo in einer Ecke des Bildschirmes redest. Wenn dem so ist. Musst du dabei einfach mal schauen was am besten Aussieht und in welcher Einstellung du noch genügend auf der Karte erkennst. Das kann man nicht verpauschalisieren. Das ist auch davon abhängig was du alles in der Karte anzeigen möchtest und ob du deine gesammte Welt oder nur einen gewissen Bereich darstellen möchtest.
Nach oben
 Profil  
Mit Zitat antworten  
Pluto
 Betreff des Beitrags:
BeitragVerfasst: So Dez 21, 2003 15:54 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
ich habe eine große karte(wo man sollen kann/muss)
und möche das man diese große karte sofort sehen kann und zwar alles, also auf einer mini karte dastellen.
du meinst man kann es nicht vorrausberechnen ?
das ist aber schade !!!
nagut, dann muss ich wohl selbst testen, was die obtimalen werten sind !

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Lossy eX
 Betreff des Beitrags:
BeitragVerfasst: So Dez 21, 2003 16:23 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Klar kann man es vorher ausrechnen. Aber ich kann dir nicht sagen wie groß du das Teil machen musst (solltest), da niemand außer dir die genauen Anforderungen an die Übersicht kennt. Das ist das einzige Problem.

Aber bei solchen Dingen schaue ich meistens auch wie es wirkt und ob ich genügend erkennen kann. Wenn nicht dann ändere ich es so lange bis es mir gut gefällt. Da ist mitunter auch ein Grafikprogramm hilfreich in dem man das vorher schon mal als Bild zusammenbasteln kann. Dann musst du nicht immer so viel Programmieren und kannst es dann einmal machen wenn das Design etc. stimmt.
Nach oben
 Profil  
Mit Zitat antworten  
Pluto
 Betreff des Beitrags:
BeitragVerfasst: So Dez 21, 2003 21:06 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
ich bastel geradne an einer kleinen 2D engine, und da habe ich mir das ziel gesetzt : das der user(der progamiere) sich um sehr wenig kümmern muss !
die größer der karte kannst du veärndern wie du möchtes, entwer 200X200(wobei das die raster index sind, jedes objekt ist ja 16X16 groß)
und die kleine soll sich anpassen, wie machen das denn die andren spiele die das auch können ???

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Lossy eX
 Betreff des Beitrags:
BeitragVerfasst: So Dez 21, 2003 21:29 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Typischerweise machs du damit den normalen Dreisatz. Also Prozentual.

Aber da die Karten bei dir bliebig groß sein kann würde ich fast sagen, dass du die Karte einen faktor (10%) nicht unterschreiten darf. Also so, dass die Karte immer ein und die selbe Größe hat und der Inhalt davon variabel ist. Aber nie kleiner als ein bestimmter faktor sein darf ansonsten wird abgeschnitten. Denn wenn es zu klein wird erkennt man darauf nichts mehr. Und die 10% sind jetzt nur erst einmal erdacht. Das müsstest du dann durch rumprobieren herrausfinden.

Beispiel:
Deine Karte ist 1000x1000 (Einheiten) und dein Übersicht ist 100x100 (Pixel). Da bekommst du dann alles rein. Und von Karteneinheiten in Pixel umgerechnet wären das 10%.
Wenn deine Karte jetzt allerdings 2000x2000 groß wäre würdest du aber nur einen Ausschnitt von 1000x1000 in der Übersicht sehen. Der Rest wäre wegen der minimalen Begrenzung ausgeschlossen. Du würdest in der Übersicht aber durch scrollen auf der Karte auch die eigentliche Übersicht scrollen. Wie das in vielen Strategiespielen so der Fall ist.

Aber was du als Faktor dort nimmst musst du selber mal ausprobieren.
Nach oben
 Profil  
Mit Zitat antworten  
Mars
 Betreff des Beitrags:
BeitragVerfasst: So Dez 21, 2003 22:59 
Offline
DGL Member
Benutzeravatar

Registriert: Fr Dez 13, 2002 12:18
Beiträge: 1063
Wenn die Minimap eine konstante Größe ausfüllen soll, kannst du die Größe der einzelnen Elemente so berechnen

t = Ausdehnung eines Tiles
a = Ausdehnung der Map in Pixel
b = Ausdehnung der Minimap in Pixel
t' = t * b / a = Ausdehung eines Tiles auf der Minimap

Im Prinzip genau das, was Lossy bereits angeführt hat, soll heißen
t verhält sich zu a wie t' zu b.

Wenn deine Tiles aber konstant 16x16 Pixel breit sind, bietet es sich ohnehin an, diese in einer Übersicht durch ein einzelnes Pixel zu repräsentieren, was viele 2D-Strategiespiele ja ebenfalls so machen: ist die Karte klein, gibt es einen schwarzen Rand, ist sie groß, muss man teils sogar in der Minimap scrollen.

_________________
Viel Spaß beim Programmieren,
Mars
http://www.basegraph.com/
Nach oben
 Profil  
Mit Zitat antworten  
Pluto
 Betreff des Beitrags:
BeitragVerfasst: Mo Dez 22, 2003 17:37 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
danke, für die vielen antworten, das beste ist wohl, wenn man in der übersichtkarte auch scrollen kann.

kann mir dazu jemmand ein beispiel geben ?
hier ist mein code zum zeichnen:
Code:
  1.  
  2. procedure T2D_Engine.DrawMap;
  3. var
  4.   x,y,i,m,wx,wy,mx,my:Integer;
  5. begin
  6.   GLXDraw.Clear;
  7.   GLXImageList.Items[3].Draw(0,352,0);
  8.  
  9.   wx:=(Player.Players[Player.index].x div Player.DX);
  10.   wx:=Player.DX*wx;
  11.  
  12.   wy:=(Player.Players[Player.index].y div Player.DY);
  13.   wy:=Player.DY*wy;
  14.  
  15.   if wx+Player.dx <= MapX then
  16.     mx:=wx+Player.dx
  17.   else
  18.     mx:=MapX;
  19.  
  20.   if wy+Player.dy <= MapY then
  21.     my:=wy+Player.dy
  22.   else
  23.     my:=MapY;
  24.  
  25.   for x:=wx to mx do begin
  26.     for y:=wy to my do begin
  27.  
  28.       if Karte[x,y].typ > -1 then begin
  29.         for i:=0 to High(Karte[x,y].Tex) do begin
  30.           if (x-wx >= 0) or (x-wy >= 0 ) then
  31.             GLXImageList.Items[Karte[x,y].typ].Draw( (x-wx) * MapS,(y-wy) * MapS,Karte[x,y].Tex[i] )
  32.           else
  33.             GLXImageList.Items[Karte[x,y].typ].Draw( X*MapS,Y*MapS,Karte[x,y].Tex[i] )
  34.         end
  35.       end;
  36.     end;
  37.   end;
  38.  
  39.   m:=Player.index;
  40.  
  41.   wx:=Player.Players[m].x div Player.DX;
  42.   wx:=wx*Player.DX;
  43.  
  44.   wy:=Player.Players[m].y div Player.DY;
  45.   wy:=wy*Player.DY;
  46.  
  47.   GLXImageList.Items[2].Draw( ( Player.Players[m].x-wx )*MapS ,(Player.players[m].Y-wy)*MapS,Player.players[m].tex );
  48.  
  49.   for i:=0 to High(Player.Players) do begin
  50.     if i <> Player.index then begin
  51.       m:=i;
  52.  
  53.       wx:=Player.Players[i].x div Player.dx;
  54.       wy:=Player.Players[i].Y div Player.dy;
  55.       if ((Player.Players[Player.index].x - Player.Players[i].x)+1 < Player.dx) and ((Player.Players[Player.index].y - Player.Players[i].y)+1 < Player.dy) then
  56.         GLXImageList.Items[2].Draw(( Player.Players[m].x-wx )*MapS ,(Player.players[m].Y-wy)*MapS,Player.players[m].tex )
  57.     end;
  58.   end;
  59.  
  60.   for x:=0 to MapX do begin
  61.     for y:=0 to MapY do begin
  62.       glximagelist.items[4].draw( x*4 ,352+y, 0);
  63.     end;
  64.   end;
  65.  
  66. //  GLXImageList.Items[4].Draw(Player.Players[Player.index].x  ,354 + Player.Players[Player.index].y ,1);
  67.  
  68.   GLXDraw.Flip;
  69. end;
  70.  

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Lossy eX
 Betreff des Beitrags:
BeitragVerfasst: Mo Dez 22, 2003 18:02 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 05, 2002 10:35
Beiträge: 4234
Wohnort: Dortmund
Ich glaube mal die anderen können sich darunter genau so viel vorstellen wie ich auch. Also nicht viel. Kannst du mal ein oder zwei Bilder posten? Da kann man sich dann viel besser etwas vorstellen.
Nach oben
 Profil  
Mit Zitat antworten  
Pluto
 Betreff des Beitrags:
BeitragVerfasst: Mo Dez 22, 2003 18:08 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
das sind einfach nur bmp von einer größe von 16X16
füge ich mal hinzu als "Attachment"

edit:
bekomme ich leider nicht hin!
aber es sind kächsten 16X16 pixel gro0

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Pluto
 Betreff des Beitrags:
BeitragVerfasst: Di Dez 23, 2003 19:55 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
habe das problem gelöst(ich habe einfach nur die falschen zaheln genommen :oops: ), nun habe ich aber ein neues problem:
beim testen ist mir aufgefallen, das die mini karte zu klein ist.
wie kann ich die beste mögliche karten größe für die mini karte berechnen ???

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Sascha Willems
 Betreff des Beitrags:
BeitragVerfasst: Di Dez 23, 2003 19:57 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++
Rendere die Minikarte doch ganz einfach in eine Textur. So kannst du dann nach Belieben und ohne die Werte verändern zu müssen testen welche Größe passend ist. Du kannst dann ganz einfach hingehen und das Quad auf dem die Textur deiner Minikarte liegt solange vergrößern/verkleinern bis es dir passt.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)
Nach oben
 Profil  
Mit Zitat antworten  
Pluto
 Betreff des Beitrags:
BeitragVerfasst: Mi Dez 24, 2003 15:05 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
der rechner soll mir die optimal größe sagen, ich weiß leider nicht wie man bei GLXTreem sowas macht......

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Pluto
 Betreff des Beitrags:
BeitragVerfasst: Mi Dez 24, 2003 16:02 
Offline
DGL Member
Benutzeravatar

Registriert: So Mai 11, 2003 10:36
Beiträge: 285
Wohnort: Oldenburg
Programmiersprache: Object Pascal
geht doch noch nicht, beim testen ist mir aufgefallen heute, das die mini karte zu ungenau ist:
Code:
  1.  
  2. procedure T2D_Engine.DrawMap;
  3. var
  4.   x,y,i,m,wx,wy,mx,my:Integer;
  5. begin
  6.   GLXDraw.Clear;
  7.   GLXImageList.Items[3].Draw(0,352,0);
  8.  
  9.   wx:=(Player.Players[Player.index].x div Player.DX);
  10.   wx:=Player.DX*wx;
  11.  
  12.   wy:=(Player.Players[Player.index].y div Player.DY);
  13.   wy:=Player.DY*wy;
  14.  
  15.   if wx+Player.dx <= MapX then
  16.     mx:=wx+Player.dx
  17.   else
  18.     mx:=MapX;
  19.  
  20.   if wy+Player.dy <= MapY then
  21.     my:=wy+Player.dy
  22.   else
  23.     my:=MapY;
  24.  
  25.   for x:=wx to mx do begin
  26.     for y:=wy to my do begin
  27.  
  28.       if Karte[x,y].typ > -1 then begin
  29.         for i:=0 to High(Karte[x,y].Tex) do begin
  30.           if (x-wx >= 0) or (x-wy >= 0 ) then
  31.             GLXImageList.Items[Karte[x,y].typ].Draw( (x-wx) * MapS,(y-wy) * MapS,Karte[x,y].Tex[i] )
  32.           else
  33.             GLXImageList.Items[Karte[x,y].typ].Draw( X*MapS,Y*MapS,Karte[x,y].Tex[i] )
  34.         end
  35.       end;
  36.     end;
  37.   end;
  38.  
  39.   m:=Player.index;
  40.  
  41.   wx:=Player.Players[m].x div Player.DX;
  42.   wx:=wx*Player.DX;
  43.  
  44.   wy:=Player.Players[m].y div Player.DY;
  45.   wy:=wy*Player.DY;
  46.  
  47.   GLXImageList.Items[2].Draw( ( Player.Players[m].x-wx )*MapS ,(Player.players[m].Y-wy)*MapS,Player.players[m].tex );
  48.  
  49.   // Player auf minikarte zeichnen
  50.   GLXImageList.Items[4].Draw(Round((rx  / mapX)*Player.Players[Player.index].x),Round(352+(ry / mapy)*Player.Players[Player.index].y),1);
  51.  
  52.   for i:=0 to High(Player.Players) do begin
  53.     if i <> Player.index then begin
  54.       m:=i;
  55.  
  56.       wx:=Player.Players[i].x div Player.dx;
  57.       wy:=Player.Players[i].Y div Player.dy;
  58.  
  59.       if ((Player.Players[Player.index].x - Player.Players[i].x)+1 < Player.dx) and ((Player.Players[Player.index].y - Player.Players[i].y)+1 < Player.dy) then
  60.         GLXImageList.Items[2].Draw(( Player.Players[m].x-wx )*MapS ,(Player.players[m].Y-wy)*MapS,Player.players[m].tex );
  61.  
  62.       // Player auf minikarte zeichnen
  63.       GLXImageList.Items[4].Draw(Round((rx  / mapX)*Player.Players[i].x),Round(352+(ry / mapy)*Player.Players[i].y),2);
  64.     end;
  65.   end;
  66.  
  67.   // Zeichne mini karte
  68.   for x:=0 to MapX do begin
  69.     for y:=0 to MapY do begin
  70.       if Karte[x,y].typ > -1 then
  71.         glximagelist.items[4].draw( Trunc( (RX  / mapX)*x),Trunc(352+(RY / mapY)*y), 0)
  72.     end;
  73.   end;
  74.  
  75.  
  76.   GLXDraw.Flip;
  77. end;
  78.  

kann mir jemmand sagen an was das liegt ?
RX:= 145; RY:=128

_________________
MFG<br> Michael Springwald, <br>
Bitte nur Links in Deutsch, nutze überwiegend Lazarus
Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  Seite 1 von 1
  [ 14 Beiträge ] 
Foren-Übersicht » Programmierung » Einsteiger-Fragen


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.014s | 16 Queries | GZIP : On ]