?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
adjust to match the expanded name.
[AROS-Contrib.git] / Games / Moria3D / Source / Level.c
blobe9239f92062258355f5fa5c5c80b798ddbe0bc03
1 /****************************************************************************
2 * *
3 * Level.C 970319 *
4 * *
5 * Level loaders *
6 * *
7 ****************************************************************************/
8
9 #include <stdio.h>
10 #include <string.h>
11 #include <stdlib.h>
12
13 #include "Clean.h"
14 #include "MyMath.h"
15 #include "Level.h"
16
17 /* Variables */
18
19 Missions MyMissions;
20 LevelData MyLevelData;
21 int16 MyPoints[8];
22
23 Color MyColor;
24 Fade MyFade;
25 pBot FirstUnusedBot=0;
26
27 /* Replace strtod1000() cause of bug */
28
29 fix strtod1000(char * MyStr, char ** EndStr)
30 {
31 return ((fix)strtol(MyStr,EndStr,10))/1000.0;
32 }
33
34 /* Parse a string from File */
35 /* No error checking yet */
36
37 int16 ParseFile(FILE *MyFile,char *Buffer)
38 {
39 int16 Error=0;
40 char *Pos;
41 char *Pos2;
42 char *Pos3;
43
44 fscanf(MyFile,"%s",Buffer);
45
46 Pos=Buffer;
47
48 if (feof(MyFile))
49 return 1;
50 else
51 {
52 if (*Pos==(char)34) /* Check for " and parse until " */
53 { /* Eliminate first " */
54 Pos2=Pos;
55 while (*(Pos2)!=(char)0)
56 {
57 *Pos2=*(Pos2+1);
58 Pos2++;
59 }
60 while (*Pos!=(char)34) /* Parse until " */
61 {
62 if (*Pos==(char)0)
63 {
64 *Pos=(char)32;
65 Pos++;
66 fscanf(MyFile,"%s",Pos);
67 }
68 else
69 Pos++;
70 }
71 while (*(Pos)!=(char)0) /* Eliminate second " */
72 {
73 *Pos=*(Pos+1);
74 Pos++;
75 }
76 }
77 else
78 {
79 while (*Pos!=(char)0) /* Check for `/''*` */
80 {
81 if ((*Pos=='/') && (*(Pos+1)=='*'))
82 {
83 Pos2=Pos; /* Remember start of comment */
84 Pos+=2;
85 while ((*Pos!='*') || (*(Pos+1)!='/'))
86 { /* parse until '*''/' */
87 if (*Pos==(char)0)
88 {
89 Pos=Pos2;
90 fscanf(MyFile,"%s",Pos);
91 }
92 else
93 Pos++;
94 }
95 Pos3=Pos+2; /* Eliminate Comment */
96 Pos=Pos2;
97 while (*Pos2!=(char)0)
98 {
99 *Pos2=*Pos3;
100 Pos2++;
101 Pos3++;
102 }
103 }
104 else
105 Pos++;
106 }
107 }
108
109 if ((*Buffer==(char)0)&&(Error==0))
110 return ParseFile(MyFile,Buffer);
111 else
112 return Error;
113 }
114 }
115
116 /* Parse Missionfile and build Mission Menu */
117
118 int16 LoadMissions(char *Name)
119 {
120 int16 Error=0;
121 char PadStr[512];
122 FILE *MissionFile = NULL;
123 pMission PosMission = NULL;
124 pLevel PosLevel = NULL;
125
126 MissionFile=fopen(Name,"r");
127
128 while (!feof(MissionFile))
129 {
130 if (!ParseFile(MissionFile,PadStr))
131 {
132 if (!strcmp(PadStr,"OnFile")) /* Parse loader helpers */
133 while (strcmp(PadStr,"OnFileEnd"))
134 {
135 ParseFile(MissionFile,PadStr);
136 }
137 else if (!strcmp(PadStr,"Missions")) /* Parse Missions */
138 while (strcmp(PadStr,"MissionsEnd"))
139 {
140 ParseFile(MissionFile,PadStr);
141 if (!strcmp(PadStr,"NumMissions:"))
142 {
143 ParseFile(MissionFile,PadStr);
144 MyMissions.Num=strtol(PadStr,0,0);
145 MyMissions.Missions=(pMission)MemAlloc((int32)(MyMissions.Num*sizeof(Mission)));
146 if (MyMissions.Missions==0)
147 {
148 printf("Not enough mem to alloc Missions\n");
149 /* To be considered */
150 }
151 PosMission=MyMissions.Missions;
152 }
153 else if (!strcmp(PadStr,"MissionsName:"))
154 {
155 ParseFile(MissionFile,PadStr);
156 strcpy(MyMissions.Name,PadStr);
157 }
158 else if (!strcmp(PadStr,"MissionsStorry:"))
159 {
160 ParseFile(MissionFile,PadStr);
161 if (*PadStr!='@')
162 {
163 MyMissions.Storry="MissionsStorry";
164 /* To be considered */
165 }
166 else
167 {
168 MyMissions.Storry="MissionsStorry";
169 /* To be considered */
170 }
171 }
172 }
173 else if (!strcmp(PadStr,"Mission")) /* parse Mission */
174 {
175 while (strcmp(PadStr,"MissionEnd"))
176 {
177 ParseFile(MissionFile,PadStr);
178 if (!strcmp(PadStr,"MissionName:"))
179 {
180 ParseFile(MissionFile,PadStr);
181 strcpy(PosMission->Name,PadStr);
182 }
183 else if (!strcmp(PadStr,"MissionStorry:"))
184 {
185 ParseFile(MissionFile,PadStr);
186 if (*PadStr!='@')
187 {
188 PosMission->Storry="MissionStorry";
189 /* To be considered */
190 }
191 else
192 {
193 PosMission->Storry="MissionStorry";
194 /* To be considered */
195 }
196 }
197 else if (!strcmp(PadStr,"NumLevels:"))
198 {
199 ParseFile(MissionFile,PadStr);
200 PosMission->Num=strtol(PadStr,0,0);
201 PosMission->Levels=(pLevel)MemAlloc((int32)(PosMission->Num*sizeof(Level)));
202 if (PosMission==0)
203 {
204 printf("Could not allocate mem for LevelNames\n");
205 /* To be considered */
206 }
207 PosLevel=PosMission->Levels;
208 }
209 else if (!strcmp(PadStr,"Level:"))
210 {
211 ParseFile(MissionFile,PadStr);
212 if (*PadStr!='@')
213 {
214 printf("Levelnames should have a leeding @\n");
215 /* To be considered */
216 }
217 else
218 {
219 strcpy((char *)PosLevel,PadStr+1);
220 PosLevel++;
221 }
222 }
223
224 }
225 PosMission++;
226 }
227 }
228 }
229
230 fclose(MissionFile);
231
232 return Error;
233 }
234
235 void ReadTextureFile(char * Name,pTexture Texture)
236 {
237 FILE * TextFile;
238
239 printf("Loading Texture :%s\n",Name);
240
241 TextFile=fopen(Name,"r");
242
243 if (TextFile != NULL)
244 {
245 Texture->TextureWidth = 256;
246 Texture->TextureHeight = 256;
247 fread(&Texture->ColMap,256,256,TextFile);
248
249 fclose(TextFile);
250 }
251 else
252 {
253 printf("Could not open Texture: %s\n",Name);
254 exit(10);
255 }
256 }
257
258 void LoadColors(char * Name,pColor MyColor)
259 {
260 FILE * ColFile;
261 int t;
262 uint32 *col;
263 uint8 bytes[4];
264
265 printf("Loading Colors...\n");
266
267 ColFile = fopen(Name,"r");
268
269 if (ColFile != NULL)
270 {
271 col = &MyColor->RGB[0][0];
272
273 for (t=0; t<256*3; t++)
274 {
275 fread(bytes,1,4,ColFile);
276
277 col[t] = (bytes[0] << 24) | (bytes[1] << 16) |
278 (bytes[2] << 8) | bytes[3];
279 }
280
281 fclose(ColFile);
282 }
283 else
284 {
285 printf("Could not open Colors:%s\n",Name);
286 exit(10);
287 }
288 }
289
290 void LoadFading(char * Name,pFade MyFade)
291 {
292 FILE * FadeFile;
293
294 printf("Loading Fading...\n");
295
296 FadeFile = fopen(Name,"r");
297
298 if (FadeFile != NULL)
299 {
300 fread(&MyFade->Col,256,256,FadeFile);
301
302 fclose(FadeFile);
303 }
304 else
305 {
306 printf("Could not open Fadeings:%s\n",Name);
307 exit(10);
308 }
309 }
310 int16 LoadLevel(char * Name)
311 {
312 int16 Error=0;
313 char PadStr[512];
314 FILE * LevelFile;
315 pPnt PosPoint = NULL;
316 pTexture PosTexture = NULL;
317 pSide PosSide = NULL;
318 pCube PosCube = NULL;
319 pPolygon PosPolygon = NULL;
320 pMesh PosMesh = NULL;
321 pBot PosBot = NULL;
322 int16 u,v;
323
324 LevelFile=fopen(Name,"r");
325
326 if (LevelFile != 0)
327 {
328 while (!feof(LevelFile))
329 {
330 ParseFile(LevelFile,PadStr);
331 if (!strcmp(PadStr,"Header"))
332 {
333 while(strcmp(PadStr,"HeaderEnd"))
334 {
335 ParseFile(LevelFile,PadStr);
336 /* To be considered */
337 if (!strcmp(PadStr,"Colors:"))
338 {
339 ParseFile(LevelFile,PadStr);
340 if (PadStr[0] != '@')
341 {
342 printf("Colors must be in a file!\n");
343 fclose(LevelFile);
344 exit(10);
345 }
346 else
347 {
348 LoadColors(&PadStr[1],&MyColor);
349 }
350 }
351 if (!strcmp(PadStr,"Fadeing:"))
352 {
353 ParseFile(LevelFile,PadStr);
354 if (PadStr[0] != '@')
355 {
356 printf("Fading must be in a file!\n");
357 fclose(LevelFile);
358 exit(10);
359 }
360 else
361 {
362 LoadFading(&PadStr[1],&MyFade);
363 }
364 }
365 if (!strcmp(PadStr,"Rings:"))
366 {
367 ParseFile(LevelFile,PadStr);
368 MyLevelData.NumRings = strtol(PadStr,0,0);
369 }
370 }
371 }
372 else if (!strcmp(PadStr,"Points"))
373 {
374 while(strcmp(PadStr,"PointsEnd"))
375 {
376 ParseFile(LevelFile,PadStr);
377 if (!strcmp(PadStr,"NumPoints:"))
378 {
379 ParseFile(LevelFile,PadStr);
380 MyLevelData.NumPoints=strtol(PadStr,0,0);
381 MyLevelData.Points=(pPnt)MemAlloc((int32)(MyLevelData.NumPoints*sizeof(Pnt)));
382 PosPoint=MyLevelData.Points;
383 }
384 else if (!strcmp(PadStr,"Point:"))
385 {
386 ParseFile(LevelFile,PadStr);
387 PosPoint->x=(fix)strtod1000(PadStr,0);
388 ParseFile(LevelFile,PadStr);
389 PosPoint->y=(fix)strtod1000(PadStr,0);
390 ParseFile(LevelFile,PadStr);
391 PosPoint->z=(fix)strtod1000(PadStr,0);
392 PosPoint++;
393 }
394
395 }
396 }
397 else if (!strcmp(PadStr,"Textures"))
398 {
399 while(strcmp(PadStr,"TexturesEnd"))
400 {
401 ParseFile(LevelFile,PadStr);
402 if (!strcmp(PadStr,"NumTextures:"))
403 {
404 ParseFile(LevelFile,PadStr);
405 MyLevelData.NumTextures=strtol(PadStr,0,0);
406 MyLevelData.Textures=(pTexture)MemAlloc((int32)(MyLevelData.NumTextures*sizeof(Texture)));
407 PosTexture=MyLevelData.Textures;
408 }
409 else if (!strcmp(PadStr,"Texture:"))
410 {
411 ParseFile(LevelFile,PadStr);
412 if (PadStr[0] != '@')
413 {
414 printf("Textures should be in a file\n");
415 exit(10);
416 }
417 else
418 {
419 ReadTextureFile(&PadStr[1],PosTexture);
420 }
421 PosTexture++;
422 }
423
424 }
425 }
426 else if (!strcmp(PadStr,"Sides"))
427 {
428 while(strcmp(PadStr,"SidesEnd"))
429 {
430 ParseFile(LevelFile,PadStr);
431 if (!strcmp(PadStr,"NumSides:"))
432 {
433 ParseFile(LevelFile,PadStr);
434 MyLevelData.NumSides=strtol(PadStr,0,0);
435 MyLevelData.Sides=(pSide)MemAlloc((int32)(MyLevelData.NumSides*sizeof(Side)));
436 PosSide=MyLevelData.Sides;
437 }
438 else if (!strcmp(PadStr,"Side:"))
439 {
440 ParseFile(LevelFile,PadStr);
441 if (strtol(PadStr,0,0) != 0)
442 {
443 PosSide->Back=&MyLevelData.Textures[strtol(PadStr,0,0)];
444 for (v=0;v<4;v++)
445 {
446 ParseFile(LevelFile,PadStr);
447 PosSide->BackPnts[v].x=strtod1000(PadStr,0);
448 ParseFile(LevelFile,PadStr);
449 PosSide->BackPnts[v].y=strtod1000(PadStr,0);
450 ParseFile(LevelFile,PadStr);
451 PosSide->BackPnts[v].z=strtod1000(PadStr,0);
452 }
453 }
454 else
455 {
456 PosSide->Back=0;
457 }
458 ParseFile(LevelFile,PadStr);
459 if (strtol(PadStr,0,0) != 0)
460 {
461 PosSide->Front=&MyLevelData.Textures[strtol(PadStr,0,0)];
462 for (v=0;v<4;v++)
463 {
464 ParseFile(LevelFile,PadStr);
465 PosSide->FrontPnts[v].x=strtod1000(PadStr,0);
466 ParseFile(LevelFile,PadStr);
467 PosSide->FrontPnts[v].y=strtod1000(PadStr,0);
468 ParseFile(LevelFile,PadStr);
469 PosSide->FrontPnts[v].z=strtod1000(PadStr,0);
470 }
471 }
472 else
473 {
474 PosSide->Front=0;
475 }
476 PosSide++;
477 }
478
479 }
480 }
481 else if (!strcmp(PadStr,"Cubes"))
482 {
483 while(strcmp(PadStr,"CubesEnd"))
484 {
485 ParseFile(LevelFile,PadStr);
486 if (!strcmp(PadStr,"NumCubes:"))
487 {
488 ParseFile(LevelFile,PadStr);
489 MyLevelData.NumCubes=strtol(PadStr,0,0);
490 MyLevelData.Cubes=(pCube)MemAlloc((int32)(MyLevelData.NumCubes*sizeof(Cube)));
491 PosCube=MyLevelData.Cubes;
492 }
493 else if (!strcmp(PadStr,"Cube:"))
494 {
495 PosCube->FirstBot=0;
496
497 for (v=0;v<8;v++) /* Read 8 Points */
498 {
499 ParseFile(LevelFile,PadStr);
500 MyPoints[v]=strtol(PadStr,0,0);
501 }
502 ParseFile(LevelFile,PadStr); /* Read Light */
503 PosCube->Light=strtod1000(PadStr,0);
504
505 for (v=0;v<6;v++) /* Read 6 Sides */
506 {
507 ParseFile(LevelFile,PadStr);
508 if (strtol(PadStr,0,0) != 0)
509 {
510 PosCube->Sides[v].Back=MyLevelData.Sides[strtol(PadStr,0,0)-1].Back;
511 PosCube->Sides[v].BackPnts[0]=MyLevelData.Sides[strtol(PadStr,0,0)-1].BackPnts[0];
512 PosCube->Sides[v].BackPnts[1]=MyLevelData.Sides[strtol(PadStr,0,0)-1].BackPnts[1];
513 PosCube->Sides[v].BackPnts[2]=MyLevelData.Sides[strtol(PadStr,0,0)-1].BackPnts[2];
514 PosCube->Sides[v].BackPnts[3]=MyLevelData.Sides[strtol(PadStr,0,0)-1].BackPnts[3];
515 PosCube->Sides[v].Front=MyLevelData.Sides[strtol(PadStr,0,0)-1].Front;
516 PosCube->Sides[v].FrontPnts[0]=MyLevelData.Sides[strtol(PadStr,0,0)-1].FrontPnts[0];
517 PosCube->Sides[v].FrontPnts[1]=MyLevelData.Sides[strtol(PadStr,0,0)-1].FrontPnts[1];
518 PosCube->Sides[v].FrontPnts[2]=MyLevelData.Sides[strtol(PadStr,0,0)-1].FrontPnts[2];
519 PosCube->Sides[v].FrontPnts[3]=MyLevelData.Sides[strtol(PadStr,0,0)-1].FrontPnts[3];
520 ParseFile(LevelFile,PadStr);
521 PosCube->Sides[v].Light=strtod1000(PadStr,0);
522 }
523 else
524 {
525 PosCube->Sides[v].Light=0.0;
526 PosCube->Sides[v].Back=0;
527 PosCube->Sides[v].Front=0;
528 }
529 switch (v) /* Insert Points depending on the side */
530 {
531 case 0:
532 {
533 PosCube->Sides[0].Pnts[0]=&MyLevelData.Points[MyPoints[SideFront0]-1];
534 PosCube->Sides[0].Pnts[1]=&MyLevelData.Points[MyPoints[SideFront1]-1];
535 PosCube->Sides[0].Pnts[2]=&MyLevelData.Points[MyPoints[SideFront2]-1];
536 PosCube->Sides[0].Pnts[3]=&MyLevelData.Points[MyPoints[SideFront3]-1];
537 }
538 case 1:
539 {
540 PosCube->Sides[1].Pnts[0]=&MyLevelData.Points[MyPoints[SideBack0]-1];
541 PosCube->Sides[1].Pnts[1]=&MyLevelData.Points[MyPoints[SideBack1]-1];
542 PosCube->Sides[1].Pnts[2]=&MyLevelData.Points[MyPoints[SideBack2]-1];
543 PosCube->Sides[1].Pnts[3]=&MyLevelData.Points[MyPoints[SideBack3]-1];
544 }
545 case 2:
546 {
547 PosCube->Sides[2].Pnts[0]=&MyLevelData.Points[MyPoints[SideLeft0]-1];
548 PosCube->Sides[2].Pnts[1]=&MyLevelData.Points[MyPoints[SideLeft1]-1];
549 PosCube->Sides[2].Pnts[2]=&MyLevelData.Points[MyPoints[SideLeft2]-1];
550 PosCube->Sides[2].Pnts[3]=&MyLevelData.Points[MyPoints[SideLeft3]-1];
551 }
552 case 3:
553 {
554 PosCube->Sides[3].Pnts[0]=&MyLevelData.Points[MyPoints[SideRight0]-1];
555 PosCube->Sides[3].Pnts[1]=&MyLevelData.Points[MyPoints[SideRight1]-1];
556 PosCube->Sides[3].Pnts[2]=&MyLevelData.Points[MyPoints[SideRight2]-1];
557 PosCube->Sides[3].Pnts[3]=&MyLevelData.Points[MyPoints[SideRight3]-1];
558 }
559 case 4:
560 {
561 PosCube->Sides[4].Pnts[0]=&MyLevelData.Points[MyPoints[SideTop0]-1];
562 PosCube->Sides[4].Pnts[1]=&MyLevelData.Points[MyPoints[SideTop1]-1];
563 PosCube->Sides[4].Pnts[2]=&MyLevelData.Points[MyPoints[SideTop2]-1];
564 PosCube->Sides[4].Pnts[3]=&MyLevelData.Points[MyPoints[SideTop3]-1];
565 }
566 case 5:
567 {
568 PosCube->Sides[5].Pnts[0]=&MyLevelData.Points[MyPoints[SideBottom0]-1];
569 PosCube->Sides[5].Pnts[1]=&MyLevelData.Points[MyPoints[SideBottom1]-1];
570 PosCube->Sides[5].Pnts[2]=&MyLevelData.Points[MyPoints[SideBottom2]-1];
571 PosCube->Sides[5].Pnts[3]=&MyLevelData.Points[MyPoints[SideBottom3]-1];
572 }
573 }
574 ParseFile(LevelFile,PadStr);
575 if (strtol(PadStr,0,0) != 0)
576 {
577 PosCube->Cubes[v]=&MyLevelData.Cubes[strtol(PadStr,0,0)-1];
578 }
579 else
580 {
581 PosCube->Cubes[v]=0;
582 }
583 CalcNormalToSide(&PosCube->Sides[v]);
584 }
585 PosCube++;
586 }
587
588 }
589 }
590 else if (!strcmp(PadStr,"Polygons"))
591 {
592 while(strcmp(PadStr,"PolygonsEnd"))
593 {
594 ParseFile(LevelFile,PadStr);
595 if (!strcmp(PadStr,"NumPolygons:"))
596 {
597 ParseFile(LevelFile,PadStr);
598 MyLevelData.NumPolygons=strtol(PadStr,0,0);
599 MyLevelData.Polygons=(pPolygon)MemAlloc((int32)(MyLevelData.NumPolygons*sizeof(Polygon)));
600 PosPolygon=MyLevelData.Polygons;
601 }
602 else if (!strcmp(PadStr,"Polygon:"))
603 {
604 /* Read NumPoints */
605
606 ParseFile(LevelFile,PadStr);
607 PosPolygon->NumPoints=strtol(PadStr,0,0);
608
609 /* Read Points */
610
611 for (u=0;u<PosPolygon->NumPoints;u++)
612 {
613 ParseFile(LevelFile,PadStr);
614 PosPolygon->Pnts[u].x=strtod1000(PadStr,0);
615 ParseFile(LevelFile,PadStr);
616 PosPolygon->Pnts[u].y=strtod1000(PadStr,0);
617 ParseFile(LevelFile,PadStr);
618 PosPolygon->Pnts[u].z=strtod1000(PadStr,0);
619 }
620
621 /* Read Normal */
622
623 ParseFile(LevelFile,PadStr);
624 PosPolygon->Normal.x=strtod1000(PadStr,0);
625 ParseFile(LevelFile,PadStr);
626 PosPolygon->Normal.y=strtod1000(PadStr,0);
627 ParseFile(LevelFile,PadStr);
628 PosPolygon->Normal.z=strtod1000(PadStr,0);
629
630 /* Read Textures */
631
632 ParseFile(LevelFile,PadStr);
633
634 if (strtol(PadStr,0,0) == 0)
635 {
636 PosPolygon->Back = 0;
637 }
638 else
639 {
640 PosPolygon->Back = &MyLevelData.Textures[strtol(PadStr,0,0)];
641
642 /* Read uvls´s */
643
644 for (u=0;u<4;u++)
645 {
646 ParseFile(LevelFile,PadStr);
647 PosPolygon->BackPnts[u].x=strtod1000(PadStr,0);
648 ParseFile(LevelFile,PadStr);
649 PosPolygon->BackPnts[u].y=strtod1000(PadStr,0);
650 ParseFile(LevelFile,PadStr);
651 PosPolygon->BackPnts[u].z=strtod1000(PadStr,0);
652 }
653 }
654
655 ParseFile(LevelFile,PadStr);
656
657 if (strtol(PadStr,0,0) == 0)
658 {
659 PosPolygon->Front = 0;
660 }
661 else
662 {
663 PosPolygon->Front = &MyLevelData.Textures[strtol(PadStr,0,0)];
664
665 /* Read uvls´s */
666
667 for (u=0;u<4;u++)
668 {
669 ParseFile(LevelFile,PadStr);
670 PosPolygon->FrontPnts[u].x=strtod1000(PadStr,0);
671 ParseFile(LevelFile,PadStr);
672 PosPolygon->FrontPnts[u].y=strtod1000(PadStr,0);
673 ParseFile(LevelFile,PadStr);
674 PosPolygon->FrontPnts[u].z=strtod1000(PadStr,0);
675 }
676 }
677
678 PosPolygon++;
679 }
680 }
681 }
682 else if (!strcmp(PadStr,"Meshes"))
683 {
684 while(strcmp(PadStr,"MeshesEnd"))
685 {
686 ParseFile(LevelFile,PadStr);
687 if (!strcmp(PadStr,"NumMeshes:"))
688 {
689 ParseFile(LevelFile,PadStr);
690 MyLevelData.NumMeshes=strtol(PadStr,0,0);
691 MyLevelData.Meshes=(pMesh)MemAlloc((int32)(MyLevelData.NumMeshes*sizeof(Mesh)));
692 PosMesh=MyLevelData.Meshes;
693 }
694 else if (!strcmp(PadStr,"Mesh:"))
695 {
696 /* Read NumPolygons */
697
698 ParseFile(LevelFile,PadStr);
699 PosMesh->NumPolygons=strtol(PadStr,0,0);
700
701 /* Read Polygons */
702
703 for (u=0;u<PosMesh->NumPolygons;u++)
704 {
705 /* Read Polygon */
706
707 ParseFile(LevelFile,PadStr);
708 PosMesh->Polygons[u] = &MyLevelData.Polygons[strtol(PadStr,0,0)-1];
709
710 ParseFile(LevelFile,PadStr);
711 PosMesh->Base[u].x=strtod1000(PadStr,0);
712 ParseFile(LevelFile,PadStr);
713 PosMesh->Base[u].y=strtod1000(PadStr,0);
714 ParseFile(LevelFile,PadStr);
715 PosMesh->Base[u].z=strtod1000(PadStr,0);
716 }
717
718 /* Read Light */
719
720 ParseFile(LevelFile,PadStr);
721 PosMesh->Light=strtod1000(PadStr,0);
722
723 PosMesh++;
724 }
725 }
726 }
727 else if (!strcmp(PadStr,"Bots"))
728 {
729 while(strcmp(PadStr,"BotsEnd"))
730 {
731 ParseFile(LevelFile,PadStr);
732 if (!strcmp(PadStr,"NumBots:"))
733 {
734 ParseFile(LevelFile,PadStr);
735 MyLevelData.NumBots=strtol(PadStr,0,0);
736 MyLevelData.Bots=(pBot)MemAlloc((int32)(MyLevelData.NumBots*sizeof(Bot)));
737 PosBot=MyLevelData.Bots;
738
739 MyLevelData.Bots[0].AbsPrev=0;
740
741 if (MyLevelData.NumBots >1)
742 {
743 MyLevelData.Bots[0].AbsNext=&MyLevelData.Bots[1];
744 for (u=1;u<MyLevelData.NumBots-1;u++)
745 {
746 MyLevelData.Bots[u].AbsNext = &MyLevelData.Bots[u+1];
747 MyLevelData.Bots[u].AbsPrev = &MyLevelData.Bots[u-1];
748 }
749
750 MyLevelData.Bots[MyLevelData.NumBots-1].AbsNext = 0;
751 MyLevelData.Bots[MyLevelData.NumBots-1].AbsPrev = &MyLevelData.Bots[MyLevelData.NumBots-2];
752 }
753 else
754 {
755 MyLevelData.Bots[0].AbsNext = 0;
756 }
757 }
758 else if (!strcmp(PadStr,"Bot:"))
759 {
760 PosBot->Next=0;
761 PosBot->Prev=0;
762
763 /* Read Position */
764
765 ParseFile(LevelFile,PadStr);
766 PosBot->Pos.x=strtod1000(PadStr,0);
767 ParseFile(LevelFile,PadStr);
768 PosBot->Pos.y=strtod1000(PadStr,0);
769 ParseFile(LevelFile,PadStr);
770 PosBot->Pos.z=strtod1000(PadStr,0);
771
772 /* Read Direction */
773
774 ParseFile(LevelFile,PadStr);
775 PosBot->Direction.a.x=strtod1000(PadStr,0);
776 ParseFile(LevelFile,PadStr);
777 PosBot->Direction.a.y=strtod1000(PadStr,0);
778 ParseFile(LevelFile,PadStr);
779 PosBot->Direction.a.z=strtod1000(PadStr,0);
780
781 ParseFile(LevelFile,PadStr);
782 PosBot->Direction.b.x=strtod1000(PadStr,0);
783 ParseFile(LevelFile,PadStr);
784 PosBot->Direction.b.y=strtod1000(PadStr,0);
785 ParseFile(LevelFile,PadStr);
786 PosBot->Direction.b.z=strtod1000(PadStr,0);
787
788 ParseFile(LevelFile,PadStr);
789 PosBot->Direction.c.x=strtod1000(PadStr,0);
790 ParseFile(LevelFile,PadStr);
791 PosBot->Direction.c.y=strtod1000(PadStr,0);
792 ParseFile(LevelFile,PadStr);
793 PosBot->Direction.c.z=strtod1000(PadStr,0);
794
795 /* Read Speed */
796
797 ParseFile(LevelFile,PadStr);
798 PosBot->Speed.x=strtod1000(PadStr,0);
799 ParseFile(LevelFile,PadStr);
800 PosBot->Speed.y=strtod1000(PadStr,0);
801 ParseFile(LevelFile,PadStr);
802 PosBot->Speed.z=strtod1000(PadStr,0);
803
804 /* Read Size */
805
806 ParseFile(LevelFile,PadStr);
807 PosBot->Size=strtod1000(PadStr,0);
808
809 /* Read Cube */
810
811 ParseFile(LevelFile,PadStr);
812 PosBot->Cube=&MyLevelData.Cubes[strtol(PadStr,0,0)-1];
813
814 if (PosBot->Cube->FirstBot != 0)
815 {
816 PosBot->Next = PosBot->Cube->FirstBot;
817 PosBot->Cube->FirstBot->Prev = PosBot;
818 }
819
820 PosBot->Cube->FirstBot = PosBot;
821
822 /* Read Type */
823
824 ParseFile(LevelFile,PadStr);
825 PosBot->Type=strtol(PadStr,0,0);
826
827 /* Read Light */
828
829 ParseFile(LevelFile,PadStr);
830 PosBot->Light=strtod1000(PadStr,0);
831
832 /* Read Mesh */
833
834 ParseFile(LevelFile,PadStr);
835
836 if (strtol(PadStr,0,0) == 0)
837 {
838 PosBot->Mesh=0;
839 }
840 else
841 {
842 PosBot->Mesh = &MyLevelData.Meshes[strtol(PadStr,0,0)-1];
843 }
844
845 PosBot->NumRings=0;
846
847 PosBot++;
848 }
849 }
850 }
851 }
852
853 fclose(LevelFile);
854 }
855 else
856 {
857 printf ("Failed to open LevelFile\n");
858 exit(10);
859 Error = (0==0);
860 };
861
862 return Error;
863 }
864
Mirror of AROS' Contrib svn.