Du bist nicht angemeldet.

Werbeanzeige

Anonymous

unregistriert

1

21.08.2004, 13:10

Strategiespiel mit TriBase

Hi!
Ich würde gerne ein Strategiespiel programmieren, und zwar Rundenbasiert.
Hab das ganze auch schon ziemlich gut durchdacht(versch. Einheiten mit versch. Attributen, 2-4 Spieler auf einem Spielfeld, jeder hat eine Startbasis...).
Mein problem ist jetzt 1.: Wie mach ich die Grafik? 2D? 3D? oder sowas wie 2.5D? Hätte halt gerne ne Zufallsgenerierte map, so 'tile' mäsig hab ich mit gedacht, aber geht das in 3D überhaupt? ???
Und 2.: Der Grundaufau von meinem Spiel, also wie es in versch. Klassen unterteilt wird und was da so reinkommt.
Bis jetzt hab ich ne unit-Klasse, mit den Werten, Grafik und so, und ne main-Klasse, wo halt die game-states und so was reinkommen.

könnt ihr mir weiterhelfen?
mfg

2

21.08.2004, 14:01

Also ein komplettes Design können wir dir hier nicht präsentieren.


Aber um auf ein paar Punkte einzugehen:
2D, 3D:
Es ist zwar immer ganz nett wenn man in Ego-Manier um die einheiten schlendern kann. Jedoch ist es absolut unübersichtlich. Die Iso-Perspektive ist einfach das Übersichtlichste. Daher reicht 2D allemal.
Da du 2D durch die 3D Technik darstellst ist es auch kein Problem ein Stufenloses Zoomen einzubauen.


Map:
Da 2D ist es auch einfacher eine Map zufällig generieren zu lassen. Naja eine 3D Map zufällig generieren zu lassen ist auch nich so schwer. Jedoch sollte man eines bedenken. Je komplexer die Map's werden sollen um so schwerer wird es die Map zufällig generieren zu lassen.

Klasse:
Na was in deine Klassen so reinkommt und wie du sie aufbauen mußt können wir dir nun beim besten willen nicht sagen. Da ich C++ Programmierer bin, kann ich dir nur ein Interface Design empfehlen. Z.B. baust du dir ein Ammo-Interface und ein Weapon-Interface. Damit läst sich dann sehr viel einfacher Arbeiten und es ist einfacher z.B. neue Munition und Waffen ins Spiel einzubauen. Das selbe gilt natürlich auch für all die anderen Dinge.
Wichtig! Ich übernehme keinerlei Verantwortung für eventl. Datenverlust oder Schäden am Rechner ;D

Anonymous

unregistriert

3

21.08.2004, 14:43

dankeschön! :)
das hilft mir auf jeden fall schon mal weiter!
Aber wie ist das dann mit den Figuren, wenn ich 2D mach? Sind das dann nur Bitmaps, oder 3D Modelle?

4

21.08.2004, 15:16

Oft wird ein Mix produziert. Die Map ist 2D und die Einheiten sind 3D. Es ist für die Animation sicherlich besser wenn die Einheiten 3D sind. Da hat man mehr Spielraum. Und da du die Einheiten mit großer wahrscheinlichkeit nach sowie so in einem 3D Modeller (z.B. Milkshap) erstellen wirst, liegt es nahe die Modell einfach 3D zu lassen.
Wichtig! Ich übernehme keinerlei Verantwortung für eventl. Datenverlust oder Schäden am Rechner ;D

LEVIATHAN

Frischling

Beiträge: 13

Wohnort: Wuppertal

  • Private Nachricht senden

5

22.08.2004, 21:37

Kann denn nun einer vielleicht noch mal ein Buch empfehlen, das ein wenig genauer auf das Thema ISO Ansicht (2d maps und 3d units) bzw. Strategiespiele allgemein eingeht?
Soweit ich weiß geht der David nur am Rande darauf ein aber es gibt doch noch Entwickler, die immer noch ein Spiel in 2d (zumindest die Ansicht) proggen wollen.
Kann denn da einer von euch weiter helfen?

6

22.08.2004, 21:44

Zerbst Band 1 beschreibt reines 2D und die Iso-Ansicht. Es wird sogar ein kleines Strategie-Spiel entwickelt. Aber ohne 3D-Units.

Sonst kenn ich kein Buch das deine Kriterien gerecht wird. Aber schau doch einfach mal auf www.games-net.de nach. Dort gibbet ne ganze Sammlung von Büchern.
Wichtig! Ich übernehme keinerlei Verantwortung für eventl. Datenverlust oder Schäden am Rechner ;D

7

22.08.2004, 23:15

Ich kenn ein gutes Buch:

"Strategy Game Programming with DirectX 9.0"
Verlag: Wordware

Also das Buch ist ziemlich gut, wie eigentlich alle Bücher von Wordware.
Da wird auch extra auf das erzeugen von 2D/Iso und 3D Tile Maps eingegangen.

Also wir hat es sehr weitergeholfen!

[edited by DragonMaster: Last posting of blueEye]
Oh, ich les grad Zerbst Band I.

Also wir fällt es schwer Dragon Master zu widersprechen, aber das Zerbst Band kann ich nicht empfehlen.
Erstens ist es mit DX7 und daher mit DirectDraw entwickelt.
Zweitens ist der Quellcode einfach nur miserabel.

Also sorry Dragon Master, du bist hier im Forum mein persönlicher Programmier Master, aber ich finde mal sollte auch erwähnen in welcher Qualität dort programmiert wird und da gibt es wirklich besseres!
[/edited]

8

23.08.2004, 00:37

Zuerst möchte ich die auch die Editirfunktion hinweisen. Also wenn dir das nächste mal 5min. Später noch was einfallen sollte und noch keiner gepostet hat. Benutz sie auch.


Aber nun zurück zum Thema:
Sicherlicht. Der Code von Zerbst ist einfach nur schlecht. Aber die Erklärungen sind eine gute Ausgangsbasis. Da die Grundprinzipien der Iso-Ansicht erklärt werden. Die kann man sich mal eben schnell im Bücherladen reinziehen ;D Man muss es ja nicht gleich kaufen.
Wichtig! Ich übernehme keinerlei Verantwortung für eventl. Datenverlust oder Schäden am Rechner ;D

9

23.08.2004, 00:48

Ok, nächstes Mal wird editiert :angel:

Du hast Recht, denn die Zerbst Bücher, ich habe eigentlich nur Band I komplett gelesen, haben eine gute Theorie Basis. Durch seinen lockeren Schreibstil macht einem das Lesen mehr Spass, wie bei den meisten anderen Fachbüchern.

Wie gesagt, ich empfehle das Buch von Wordware, d.h. nicht das ich es haben will (Anmerkung an die PM, die ich vorhin bekommen habe).

Anonymous

unregistriert

10

24.08.2004, 16:38

Hab ein Problem, ich hoff ihr könnt mir helfen.
Ich hab jetzt anhand des Tutorials www.gamedev.net/reference/articles/article1972.asp
versucht Tiles zu rendern....klappt aber nicht. Der Code spuckt zwar keine Fehler aus aber auf dem Bildschirm wird nichts angezeigt. Ich hab auf jeden Fall das Gefühl dass irgendwas noch fehlt, ich hab das ganze eben ein bisschen verändert und ein paar sachen weggelassen, bei denen ich gedacht hab dass ich sie nicht brauch...tja.

Hier der Codemeiner Tiles-Klasse :

C-/C++-Quelltext

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
#include "Main.h" 
 
 
// Vertex def. 

 
const DWORD D3DFVF_TLVERTEX = D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1; 
 
struct STVERTEX 
{ 
    tbVector3   vPosition; 
    float       rhw; 
    D3DCOLOR    Color; 
    tbVector2   vTex0; 
}; 
 
PDIRECT3DVERTEXBUFFER9  vertexBuffer; 
 
LPDIRECT3DBASETEXTURE9  m_pTile1; 
LPDIRECT3DBASETEXTURE9  m_pTile2; 
LPDIRECT3DBASETEXTURE9  m_pTile3; 
 
//------------------------------------------------------------------- 

// Initialisierung 

 
tbResult CTiles::Init()  
    { 
    tbDirect3D::SetFVF(D3DFVF_TLVERTEX); 
 
    tbDirect3D::GetDevice()->CreateVertexBuffer(4 * sizeof(STVERTEX), 
                                     0, 
                                     D3DFVF_TLVERTEX, 
                                     D3DPOOL_MANAGED, 
                                     &vertexBuffer, 
                                     NULL); 
    tbDirect3D::GetDevice()->SetStreamSource(0, vertexBuffer, 0, sizeof(STVERTEX)); 
 
 
    // Renderstates 

    tbDirect3D::SetRS(D3DRS_LIGHTING, FALSE); 
    tbDirect3D::SetRS(D3DRS_ALPHABLENDENABLE, TRUE); 
    tbDirect3D::SetRS(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA); 
    tbDirect3D::SetRS(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA); 
    tbDirect3D::SetTSS(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE); 
 
    LoadTextures(); 
 
    return TB_OK; 
}; 
 
//--------------------------------------------------------------------- 

// Exit... 

 
tbResult CTiles::Exit() 
    { 
    tbDirect3D::GetDevice()->SetStreamSource (0, NULL, 0, 0); 
 
    //Release vertex buffer 

    if (vertexBuffer) 
         vertexBuffer->Release (); 
 
    UnloadTextures(); 
 
    return TB_OK; 
}; 
 
 
//--------------------------------------------------------------------- 

// Textur laden 

 
tbResult CTiles::LoadTextures()  
    { 
 
 
    m_pTile1 = tbTextureManager::GetTexture("Tile1.jpg"); 
//  m_pTile2 = tbTextureManager::GetTexture("Tile2.jpg"); 

//  m_pTile3 = tbTextureManager::GetTexture("Tile3.jpg"); 

 
    return TB_OK; 
}; 
 
//--------------------------------------------------------------------- 

// Textur entladen 

 
tbResult CTiles::UnloadTextures() 
    { 
    g_pOeger->m_pTexManager->ReleaseTexture(m_pTile1); 
//  g_pOeger->m_pTexManager->ReleaseTexture(m_pTile2); 

//  g_pOeger->m_pTexManager->ReleaseTexture(m_pTile3); 

 
    return TB_OK; 
}; 
 
//--------------------------------------------------------------------- 

// Zeichnen 

 
tbResult CTiles::Draw(LPDIRECT3DBASETEXTURE9 texture, D3DCOLOR VColor, float x, float y) 
    { 
 
    STVERTEX vertices[4]; 
 
 
    vertices[0].Color = VColor; 
    vertices[0].vPosition.x = x - 0.5f; 
    vertices[0].vPosition.y = y - 0.5f; 
    vertices[0].vPosition.z = 0.0f; 
    vertices[0].rhw = 1.0f; 
    vertices[0].vTex0.u = 0.0f; 
    vertices[0].vTex0.v = 0.0f; 
 
    vertices[1].Color = VColor; 
    vertices[1].vPosition.x = x - 0.5f; 
    vertices[1].vPosition.y = y - 0.5f; 
    vertices[1].vPosition.z = 0.0f; 
    vertices[1].rhw = 1.0f; 
    vertices[1].vTex0.u = 1.0f; 
    vertices[1].vTex0.v = 0.0f; 
 
    vertices[2].Color = VColor; 
    vertices[2].vPosition.x = x - 0.5f; 
    vertices[2].vPosition.y = y - 0.5f; 
    vertices[2].vPosition.z = 0.0f; 
    vertices[2].rhw = 1.0f; 
    vertices[2].vTex0.u = 1.0f; 
    vertices[2].vTex0.v = 1.0f; 
 
    vertices[3].Color = VColor; 
    vertices[3].vPosition.x = x - 0.5f; 
    vertices[3].vPosition.y = y - 0.5f; 
    vertices[3].vPosition.z = 0.0f; 
    vertices[3].rhw = 1.0f; 
    vertices[3].vTex0.u = 0.0f; 
    vertices[3].vTex0.v = 1.0f; 
 
    tbDirect3D::SetTexture(0, texture); 
 
    tbDirect3D::GetDevice()->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2); 
 
    return TB_OK; 
}


schonmal danke für eure Zeit
SimonS

Werbeanzeige