home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Amiga / jeux / demos / MFS_Demo.lha / mfs-beta_1.20.demo / kernel.c.bak < prev    next >
Text File  |  1995-06-15  |  19KB  |  874 lines
  1. /*****************************************************************
  2.    Flusi/Huba/Fedmain  (c)  Andre BorngrΣber & Marec Andree▀en 
  3.    Dice 2.06.40
  4.    PC-Version (c) Martin Borchard    Turbo C 2.0
  5. *****************************************************************/   
  6.  
  7. #define VERSION "1.11a"
  8.  
  9. char Version[] = "$VER: Amiga-MFS "VERSION" ("__DATE__") ⌐ 1995 Andre Borngraeber";
  10.  
  11.  
  12. /* Kanalbelegung:
  13. 1. li: D, S  r: H, Q
  14. 2. li: D, Q  r: H, S
  15. 3. li: H, Q  r: D, S
  16. 4. li  H, S  r: D, Q */
  17.  
  18.  
  19. #include "math.h"
  20. #include "stdio.h"
  21. #include "graphics/rastport.h"
  22. #include "intuition/screens.h"
  23. #include "intuition/intuition.h"
  24. #include "Areaextras.h"
  25. #include "hardware/custom.h"
  26. #include "graphics/gfxmacros.h"
  27. #include "planesound.h"
  28. #include "hardware/intbits.h"
  29. #include "exec/types.h"
  30. #include "exec/memory.h"
  31. #include "input.c"
  32. #include "readkey.c"
  33. #include <time.h>
  34.  
  35. #define ax 0
  36. #define ay 0
  37. #define az 1000
  38. #define ANZECKEN 15
  39. #define ANZPOLY 50 
  40.  
  41. #define HOEHESENS 750000.0
  42. #define QUERSENS  600000.0
  43. #define DROSSELSENS 100.0
  44. #define SEITENSENS  1000000.0
  45.  
  46. short *pot0dat=(short *)0xdff012;
  47. short *pot1dat=(short *)0xdff014;
  48.  
  49. short Joy0x=0,Joy0y=0,Joy1x=0,Joy1y=0;
  50.  
  51. char *cia=(char *)0xbfe001;
  52.  
  53. APTR PotgoBase = 0;               
  54. long gotpotgo = 0;                
  55.  
  56.  
  57. short laut,frequenz;
  58. int anzahl=0,st=1,punktnr;
  59. struct ViewPort *thisview;
  60.  
  61.  
  62. struct     intvec
  63.    {
  64.       short x;
  65.       short y;
  66.       short z;
  67.   };
  68.  
  69. struct     Vec
  70.    {
  71.       float x;
  72.       float y;
  73.       float z;
  74.   };
  75.  
  76. struct     Basis
  77.   {
  78.    struct  Vec a;
  79.    struct  Vec b;
  80.    struct  Vec c;
  81.   };
  82.  
  83. struct TransStore
  84.   {
  85.    short a;
  86.    short b;
  87.   };
  88.  
  89. struct Basis     e={1,0,0, 0,1,0, 0,0,1}, sky, plane;
  90. struct Vec     distToPlane={0,-200,500};
  91. struct RastPort    *rp      =0;
  92. struct Window    *window =0;
  93. struct Screen    *screen =0;
  94. struct Vec     Magic[ANZPOLY*ANZECKEN+9],Rotor[9][10];
  95. struct TransStore  MagicStore[ANZPOLY*ANZECKEN+9],RotorStore[20];
  96. struct BitMap    Map[2];
  97. struct Vec     beweg={0,0,0};
  98. struct View    *View;
  99. struct ViewPort    *VPort;
  100. struct UCopList    *CopList,*CopListMerk;
  101. struct Custom    *Custom=0xdff000;
  102. struct IntuiMessage *IntuiMessage;
  103.  
  104. short hoehe,quer,seite,PlaneNr=0,pix=160;
  105. int tscheibe,ipitch,ihrot,igewicht;
  106. float gesch=0.02,flugwinkel=0,reibung=0.0007,auftrieb=0.1,abtrieb=-25.0,pitch,gewicht;
  107. float rpm=1,gamma=0,Beweg,hrot,rauf,runter,xReibung,floatdummy,xFrei;
  108.  
  109. short *joy=(short *)0xdff00c;
  110. char *feuer=(char *) 0xbfe001;
  111. short j,h=0;
  112. BOOL bruch,fw,demo=FALSE;
  113.  
  114. struct Bild {
  115.           int ppunkte;
  116.           int pfarbe;
  117.           int pinvfarbe;
  118.           int ppx[ANZECKEN+1];
  119.           int ppy[ANZECKEN+1];
  120.           int ppz[ANZECKEN+1];
  121.          };       
  122.  
  123. struct Bild polygon[ANZPOLY+1];
  124.  
  125. int polygone;
  126.  
  127. struct RGBFarbe {
  128.            int rot;
  129.            int gruen;
  130.            int blau;
  131.           };
  132.  
  133. struct RGBFarbe RGB[8];
  134.  
  135. int FWart,xGewicht,xMotor,xPower,xWiderstand,abriss;
  136. int xBack,xQuer,xHoehe,xSeite,xDrossel,xSpeed,xSense;
  137. int xAchs=0,xLaut=0,xPrg=0,xKnall=0,xKanal=1;
  138. int xJoy=0,xKaefig=0;
  139. int Joy0x0,Joy0y0,Joy1x0,Joy1y0;
  140. int Knueppel[5], KanalHoehe=2, KanalQuer=1, KanalMotor=3, KanalSeite=4;
  141. float HoeheFak, QuerFak, PowerFak, SeitenFak, xJoySens=1.0;
  142. int xToggleLX=1,xToggleLY=1,xToggleRX=1,xToggleRY=1,xUhr=3;
  143.  
  144. long xScreenm=135168L;
  145. int  xScreenh=256, xScreenw=320, xScreend=3;
  146.  
  147. struct Task *mytask;
  148.  
  149. struct IntuiMessage *imsg;
  150. short code;
  151. ULONG class;
  152.  
  153. time_t t;
  154. long startzeit=-1,thiszeit=0;
  155. long starttime=-1,thistime=0,frames=0;
  156. float framesps=1.0;
  157.  
  158. char frametext[80]="still counting !";
  159.  
  160. /***********************************************************************/
  161.  
  162. ResetJoy()
  163. {
  164.       Joy0x0=(*pot0dat & 255);
  165.       Joy0y0=(short)((*pot0dat & 65280)/256)-10;
  166.       Joy1x0=(*pot1dat & 255);
  167.       Joy1y0=(short)((*pot1dat & 65280)/256);
  168.    WritePotgo(0x0001,0x0001); 
  169. }
  170.  
  171. /*********************************************************************/
  172.  
  173. OpenAJoystick()
  174. {
  175. long AllocPotBits();
  176. APTR OpenResource();
  177.  
  178.    PotgoBase = OpenResource((STRPTR)"potgo.resource");
  179.    gotpotgo = AllocPotBits(0xff01);
  180.    printf("gotpotgo: %i \n\n",gotpotgo);
  181.    WritePotgo(0x0001,0xff01);
  182. }                   
  183.  
  184. /*********************************************************************/
  185.  
  186. long CloseAJoystick()
  187. {
  188.    FreePotBits(gotpotgo);
  189.    return 1;
  190. }
  191.  
  192. /*********************************************************************/
  193.  
  194.  
  195. ReadAJoystick()
  196. {
  197.       Knueppel[4]=xToggleLX*(Joy0x0-(*pot0dat & 255));
  198.       Knueppel[3]=xToggleLY*(Joy0y0-(short)((*pot0dat & 65280)/256));
  199.       Knueppel[1]=xToggleRX*(Joy1x0-(*pot1dat & 255));              
  200.       Knueppel[2]=xToggleRY*(Joy1y0-(short)((*pot1dat & 65280)/256));
  201.       WritePotgo(0x0001,0x0001);                      
  202. }
  203.  
  204. /*********************************************************************/
  205.  
  206. GetThePower()
  207. {
  208.   mytask=FindTask(NULL);
  209.   SetTaskPri(mytask,19);
  210. }
  211.  
  212. /***********************************************************************/
  213.  
  214. MakeCopper()
  215. {
  216.  
  217.     View = ViewAddress();
  218.     VPort = &(screen->ViewPort); 
  219.  
  220.     CINIT(CopList,3);
  221.     CWAIT(CopList,170+h,0);
  222.     if ( h < 130 ) {CMOVE(CopList,Custom->color[0],0x8c8);}
  223.     else {CMOVE(CopList,Custom->color[0],0x000);}
  224.     CEND(CopList);
  225.     VPort->UCopIns = CopList; 
  226.     MakeVPort(View,VPort);
  227.     MrgCop(View);
  228.     LoadView(View);
  229. }
  230.  
  231. /***********************************************************************/
  232.  
  233. FrameCount()
  234. {
  235.   frames++;
  236.   if (frames<200)
  237.   {
  238.     if(starttime==-1)
  239.     {
  240.       starttime=clock();
  241.       frames=0;
  242.     }
  243.     thistime=clock();
  244.     if(thistime-starttime<0)
  245.     {
  246.       starttime=-1;
  247.     }
  248.     else
  249.     {
  250.     if(thistime-starttime!=0)
  251.       {
  252.         framesps=5.0*(float)frames/(float)(thistime-starttime);
  253.         sprintf(frametext,"%7.1f Bilder/s",framesps*10.0);
  254.         if (framesps==0.0) framesps=1.0;
  255.       }
  256.     }
  257.   }
  258. }
  259.  
  260. /***********************************************************************/
  261.  
  262. MakeBigCopper()
  263. {
  264.  
  265.     View = ViewAddress();
  266.     VPort = &(screen->ViewPort);
  267.  
  268.     CINIT(CopList,11);
  269.     CWAIT(CopList,141+h,0);
  270.     if ( h > 125 ) 
  271.     {
  272.       CMOVE(CopList,Custom->color[0],0x000);
  273.     }
  274.     else 
  275.     {
  276.       CMOVE(CopList,Custom->color[0],0x474);
  277.       CWAIT(CopList,143+h,0);
  278.       CMOVE(CopList,Custom->color[0],0x585);
  279.       CWAIT(CopList,147+h,0);
  280.       CMOVE(CopList,Custom->color[0],0x696);
  281.       CWAIT(CopList,153+h,0);
  282.       CMOVE(CopList,Custom->color[0],0x7a7);
  283.       CWAIT(CopList,160+h,0);
  284.       CMOVE(CopList,Custom->color[0],0x8b8);
  285.       CWAIT(CopList,170+h,0);
  286.       CMOVE(CopList,Custom->color[0],0x9c9); 
  287.     }
  288.     CEND(CopList);
  289.     VPort->UCopIns = CopList;
  290.     MakeVPort(View,VPort);
  291.     MrgCop(View);
  292.     LoadView(View);
  293. }
  294.  
  295. /*********************************************************************/
  296.  
  297. InitVars()
  298.  {
  299.   switch(xKanal)
  300.   {
  301.     case 2:  KanalHoehe=2; KanalQuer=4; KanalSeite=1; KanalMotor=3; break;
  302.     case 3:  KanalHoehe=3; KanalQuer=4; KanalSeite=1; KanalMotor=2; break;
  303.     case 4:  KanalHoehe=3; KanalQuer=1; KanalSeite=4; KanalMotor=2; break;
  304.   }
  305.   if(xAchs==1)  { KanalQuer=KanalSeite; QuerFak=SeitenFak; SeitenFak=0; } 
  306.   sky = e;
  307.   plane = e;
  308.   RotSkyX();
  309.   InitMagic();
  310.   RefreshMagic();
  311.  }
  312.  
  313. /***********************************************************************/
  314.  
  315. OpenAll()
  316.  {
  317.   struct  NewWindow NewWindow;
  318.   int i;
  319.  
  320.   screen=(struct screen *) DBufferScreen();
  321.   if (!screen) CloseAll();
  322.   CopList = AllocMem(sizeof(struct UCopList),MEMF_CHIP|MEMF_CLEAR|MEMF_PUBLIC);
  323.   MakeBigCopper(); 
  324.  
  325.   /*  NewWindow-Struktur initialisieren  */
  326.   NewWindow.LeftEdge   = 0;
  327.   NewWindow.TopEdge    = 0;
  328.   NewWindow.Width   = 320;
  329.   NewWindow.Height     = 256;
  330.   NewWindow.BlockPen   = 1;
  331.   NewWindow.DetailPen      = 0;
  332.   NewWindow.Title   = NULL;
  333.   NewWindow.Flags   = SIMPLE_REFRESH|ACTIVATE;
  334.   NewWindow.IDCMPFlags     = RAWKEY;
  335.   NewWindow.Type    = CUSTOMSCREEN;
  336.   NewWindow.FirstGadget   = NULL;
  337.   NewWindow.CheckMark      = NULL;
  338.   NewWindow.Screen     = screen;
  339.   NewWindow.BitMap     = NULL;
  340.   NewWindow.MinWidth   = 1;
  341.   NewWindow.MinHeight      = 1;
  342.   NewWindow.MaxWidth   = 320;
  343.   NewWindow.MaxHeight      = 256;
  344.  
  345.   /*  Das neue Fenster ÷ffnen.      */
  346.   window=(struct window *)OpenWindow(&NewWindow);
  347.   if (!window) CloseAll();
  348.   ActivateWindow(window);
  349.   SetRast(rp,0);
  350.   SwapDBufferScreen();
  351.   SetRast(rp,0);
  352.   rp=window->RPort;
  353.   thisview = &((*screen).ViewPort);
  354.   for(i=0; i<=7; i++)
  355.   {
  356.     SetRGB4(thisview,i,RGB[i].rot,RGB[i].gruen,RGB[i].blau);
  357.   }
  358.  }
  359.  
  360. /***********************************************************************/
  361.  
  362. CloseAll()
  363.  {
  364.   FreeVPortCopLists(VPort);
  365.   if (window) CloseWindow(window);
  366.   if (screen) CloseDBufferScreen();
  367.  }
  368.  
  369. /***********************************************************************/
  370.  
  371. SwapDBufferScreen()
  372. {
  373.   screen->ViewPort.RasInfo->BitMap=&Map[PlaneNr];
  374.   MakeScreen(screen);
  375.   RethinkDisplay();
  376.   PlaneNr=1-PlaneNr;
  377.   rp->BitMap=&Map[PlaneNr];
  378.   SetAPen(rp,1);
  379. }
  380.  
  381. /***********************************************************************/
  382.  
  383. DBufferScreen()
  384. {
  385. struct     NewScreen NewScreen;
  386. short i,j;
  387.  
  388.     for(i=0;i<=1;i++)
  389.        {
  390.     InitBitMap(&Map[i],3,320,256);
  391.     for (j=0;j<=2;j++)
  392.      {
  393.        Map[i].Planes[j]=(PLANEPTR) AllocRaster(320,256);
  394.      }
  395.        }
  396.  
  397.      PlaneNr=0;
  398.  
  399.   /*  NewScreen-Struktur initialisieren.  */
  400.   NewScreen.LeftEdge   = 0;
  401.   NewScreen.TopEdge    = 0;
  402.   NewScreen.Width   = 320;
  403.   NewScreen.Height     = 256;
  404.   NewScreen.Depth   = 3;
  405.   NewScreen.DetailPen      = 0;
  406.   NewScreen.BlockPen   = 1;
  407.   NewScreen.ViewModes      = 0;
  408.   NewScreen.Type    = CUSTOMSCREEN|CUSTOMBITMAP;
  409.   NewScreen.Font    = NULL;
  410.   NewScreen.DefaultTitle  = NULL;
  411.   NewScreen.Gadgets    = NULL;
  412.   NewScreen.CustomBitMap  = &Map[0];
  413.  
  414.   /*  Den neuen Screen ÷ffnen.      */
  415.   screen=(struct Screen *)OpenScreen(&NewScreen);
  416.  
  417.      rp=&screen->RastPort;
  418.      SetRast(rp,0);
  419.      SwapDBufferScreen();
  420.      SetRast(rp,0);
  421.      return(screen);
  422. }
  423.  
  424. /***********************************************************************/
  425.  
  426. CloseDBufferScreen()
  427. {
  428.  
  429. short  j,i;
  430.  
  431.   CloseScreen(screen);
  432.   for (j=0;j<=1;j++)
  433.     {
  434.       for(i=0;i<=2;i++)
  435.    {
  436.      if (Map[j].Planes[i])  FreeRaster(Map[j].Planes[i],screen->Width,screen->Height);
  437.    }
  438.     }
  439. }
  440.  
  441.  
  442.  
  443. /***********************************************************************/
  444.  
  445. BasisVecProduct(b,r,res)
  446.  struct Basis b;
  447.  struct Vec r,*res;
  448.  {
  449.    res->x = b.a.x*r.x+b.b.x*r.y+b.c.x*r.z;
  450.    res->y = b.a.y*r.x+b.b.y*r.y+b.c.y*r.z;
  451.    res->z = b.a.z*r.x+b.b.z*r.y+b.c.z*r.z;
  452.  }
  453.  
  454.  
  455. /***********************************************************************/
  456.  
  457. VecAdd(a,b,res)
  458.  struct Vec a,b,*res;
  459.  {
  460.    res->x=a.x+b.x;
  461.    res->y=a.y+b.y;
  462.    res->z=a.z+b.z;
  463.  }
  464.  
  465. /***********************************************************************/
  466.  
  467. RotX(r,alpha)
  468.  struct Vec *r;
  469.  float alpha;
  470.  {
  471.  float h;
  472.    h   =r->y*fcos(alpha) - r->z*fsin(alpha);
  473.    r->z=r->y*fsin(alpha) + r->z*fcos(alpha);
  474.    r->y=h;
  475.  }
  476.  
  477. /***********************************************************************/
  478.  
  479. RotZ(r,alpha)
  480.  struct Vec *r;
  481.  float alpha;
  482.  {
  483.  float h;
  484.    h   =r->x*fcos(alpha) - r->y*fsin(alpha);
  485.    r->y=r->x*fsin(alpha) + r->y*fcos(alpha);
  486.    r->x=h;
  487.  }
  488.  
  489. /***********************************************************************/
  490.  
  491. RotY(r,alpha)
  492.  struct Vec *r;
  493.  float alpha;
  494.  {
  495.  float h;
  496.    h   =r->x*fcos(alpha) - r->z*fsin(alpha);
  497.    r->z=r->x*fsin(alpha) + r->z*fcos(alpha);
  498.    r->x=h;
  499.  }
  500.  
  501. /***********************************************************************/
  502.  
  503. Transform(r,a,b)
  504. struct Vec r;
  505. short *a,*b;
  506.  {
  507. /*
  508.    *a=(short) 160 + r.x;
  509.    *b=(short) 128 - r.y;
  510. */
  511. *a=(short) 160 + ( (int) (500*r.x) / (int)(r.z));
  512. *b=(short) 128 - ( (int) (500*r.y)  / (int)(r.z));
  513.  
  514.  }
  515.  
  516. /***********************************************************************/
  517.  
  518. SkyToWindow(r,a,b)
  519. struct Vec r;
  520. short *a,*b;
  521.  {
  522.    BasisVecProduct(sky,r,&r);
  523.    Transform(r,a,b);
  524.  }
  525.  
  526.  
  527. /***********************************************************************/
  528.  
  529. PlaneToWindow(r,a,b)
  530. struct Vec r;
  531. short *a,*b;
  532.  {
  533.    BasisVecProduct(plane,r,&r);
  534.    VecAdd(distToPlane,r,&r);
  535.    Transform(r,a,b);
  536.  }
  537.  
  538. /***********************************************************************/
  539.  
  540. RotSkyX()
  541.  {
  542.   RotX(&sky.b,0.523);
  543.   RotX(&sky.c,0.523);
  544.  }
  545.  
  546. /***********************************************************************/
  547.  
  548. RotSkyY()
  549.  {
  550.   RotY(&sky.b,0.523);
  551.   RotY(&sky.c,0.523);
  552.  }
  553.  
  554. /***********************************************************************/
  555.  
  556. RotPlane()
  557.  {
  558.    RotY(&distToPlane,0.055);
  559.    RotY(&plane.a,0.055);
  560.    RotY(&plane.b,0.055);
  561.    RotY(&plane.c,0.055);
  562.  }
  563.  
  564. /***********************************************************************/
  565.  
  566. DrawPlane()
  567.  {
  568.  struct Vec dist,h;
  569.  short a0,b0,a,b;
  570.  
  571.    SkyToWindow(distToPlane,&a0,&b0);
  572.  
  573.    VecAdd(distToPlane,plane.a,&h);
  574.    Move(rp,a0,b0);
  575.    SkyToWindow(h,&a,&b);
  576.    Draw(rp,a,b);
  577.  
  578.    VecAdd(distToPlane,plane.b,&h);
  579.    Move(rp,a0,b0);
  580.    SkyToWindow(h,&a,&b);
  581.    Draw(rp,a,b);
  582.  
  583.    VecAdd(distToPlane,plane.c,&h);
  584.    Move(rp,a0,b0);
  585.    SkyToWindow(h,&a,&b);
  586.    Draw(rp,a,b);
  587.  }
  588.  
  589.  
  590. /***********************************************************************/
  591.  
  592. Loop(arg)
  593. float arg;
  594. {
  595.  struct Vec ey,ez;
  596.  ey=e.b;
  597.  ez=e.c;
  598.  RotX(&ey,arg);
  599.  RotX(&ez,arg);
  600.  BasisVecProduct(plane,ey,&ey);
  601.  BasisVecProduct(plane,ez,&ez);
  602.  plane.b=ey;
  603.  plane.c=ez;
  604. }
  605.  
  606. /***********************************************************************/
  607.  
  608. Roll(arg)
  609. float arg;
  610. {
  611.  struct Vec ex,ey;
  612.  ex=e.a;
  613.  ey=e.b;
  614.  RotZ(&ex,arg);
  615.  RotZ(&ey,arg);
  616.  BasisVecProduct(plane,ex,&ex);
  617.  BasisVecProduct(plane,ey,&ey);
  618.  plane.a=ex;
  619.  plane.b=ey;
  620. }
  621.  
  622. /***********************************************************************/
  623.  
  624. Turn(arg)
  625. float arg;
  626. {
  627.  struct Vec ex,ez;
  628.  ex=e.a;
  629.  ez=e.c;
  630.  RotY(&ex,arg);
  631.  RotY(&ez,arg);
  632.  BasisVecProduct(plane,ex,&ex);
  633.  BasisVecProduct(plane,ez,&ez);
  634.  plane.a=ex;
  635.  plane.c=ez;
  636. }
  637.  
  638.  
  639. /***********************************************************************/
  640.  
  641. lesen()
  642. {
  643.      FILE *weser;   /* Deskriptor-Zeiger */
  644.      char text[80];
  645.      int i,j,tester;
  646.  
  647.      weser=fopen("ram:flug.dat", "r");
  648.      if(!weser)
  649.      {
  650.         printf("***** MFS-Fehler: Keine gⁿltige Flugzeugdefinition ! *****\n");
  651.         exit(50);
  652.      }
  653.  
  654.                                              /*  Ersma den Kram aus MFS.cfg ! */ 
  655.      fgets(text, 80, weser);
  656.      sscanf(text,"%d",&xScreenm);
  657.  
  658.      fgets(text, 80, weser);
  659.      sscanf(text,"%d",&xScreenh);
  660.  
  661.      fgets(text, 80, weser);
  662.      sscanf(text,"%d",&xScreenw);
  663.  
  664.      fgets(text, 80, weser);
  665.      sscanf(text,"%d",&xScreend);
  666.  
  667.      fgets(text, 80, weser);
  668.      sscanf(text,"%d",&xUhr);
  669.                               
  670.      fgets(text, 80, weser);
  671.      sscanf(text,"%d",&xSense); 
  672.      xJoySens=(float)xSense/100.0;
  673.      printf("xJoysense : %d \n",xSense);
  674.  
  675.      fgets(text, 80, weser);
  676.      sscanf(text,"%d",&xKanal);
  677.  
  678.      fgets(text, 80, weser);
  679.      sscanf(text,"%d",&xKaefig);
  680.  
  681.      fgets(text, 80, weser);
  682.      sscanf(text,"%d",&xJoy); 
  683.  
  684.      for(i=0; i<=7; i++)
  685.      {
  686.        fgets(text, 80, weser);
  687.        fgets(text, 80, weser);
  688.        sscanf(text,"%d",&RGB[i].rot);
  689.        fgets(text, 80, weser);
  690.        sscanf(text,"%d",&RGB[i].gruen);
  691.        fgets(text, 80, weser);
  692.        sscanf(text,"%d",&RGB[i].blau);
  693.      }
  694.  
  695.      fgets(text, 80, weser);
  696.      sscanf(text,"%d",&xToggleLX);
  697.  
  698.      fgets(text, 80, weser);
  699.      sscanf(text,"%d",&xToggleLY);
  700.  
  701.      fgets(text, 80, weser);
  702.      sscanf(text,"%d",&xToggleRX);
  703.  
  704.      fgets(text, 80, weser);
  705.      sscanf(text,"%d",&xToggleRY);
  706.  
  707.                                      /* Es folgt die normale Flusi-Datei ! */
  708.       fgets(text, 80, weser);
  709.       fgets(text, 80, weser);
  710.       sscanf(text,"%d",&xFrei);
  711.  
  712.       fgets(text, 80, weser);
  713.       fgets(text, 80, weser);
  714.       sscanf(text,"%d",&xFrei);
  715.  
  716.       fgets(text, 80, weser);
  717.       fgets(text, 80, weser);
  718.       sscanf(text,"%d",&xFrei);
  719.  
  720.       fgets(text, 80, weser);
  721.       fgets(text, 80, weser);
  722.       sscanf(text,"%d",&xFrei);
  723.  
  724.       fgets(text, 80, weser);
  725.       fgets(text, 80, weser);
  726.       sscanf(text,"%d",&xFrei);
  727.  
  728.       fgets(text, 80, weser);
  729.       fgets(text, 80, weser);
  730.       sscanf(text,"%d",&xFrei);
  731.  
  732.       fgets(text, 80, weser);
  733.       fgets(text, 80, weser);
  734.       sscanf(text,"%d",&xFrei); 
  735.  
  736.       fgets(text, 80, weser);
  737.       fgets(text, 80, weser);
  738.       sscanf(text,"%d",&xFrei);
  739.  
  740.       fgets(text, 80, weser);
  741.       fgets(text, 80, weser);
  742.       sscanf(text,"%d",&xFrei);
  743.  
  744.       fgets(text, 80, weser);
  745.       fgets(text, 80, weser);
  746.       sscanf(text,"%d",&xFrei);
  747.  
  748.       fgets(text, 80, weser);
  749.       fgets(text, 80, weser);
  750.       sscanf(text,"%d",&xPrg);
  751.  
  752.       fgets(text, 80, weser);
  753.       fgets(text, 80, weser);
  754.       sscanf(text,"%d",&xLaut);
  755.  
  756.       fgets(text, 80, weser);
  757.       fgets(text, 80, weser);
  758.       sscanf(text,"%d",&xKnall);
  759.  
  760.       fgets(text, 80, weser);
  761.       fgets(text, 80, weser);
  762.       sscanf(text,"%d",&xAchs);
  763.  
  764.       fgets(text, 80, weser);
  765.       fgets(text, 80, weser);
  766.       sscanf(text,"%d",&xSpeed);
  767.  
  768.       fgets(text, 80, weser);
  769.       fgets(text, 80, weser);
  770.       sscanf(text,"%d",&xBack);
  771.  
  772.       fgets(text, 80, weser);
  773.       fgets(text, 80, weser);
  774.       sscanf(text,"%d",&xQuer);
  775.  
  776.       fgets(text, 80, weser);
  777.       fgets(text, 80, weser);
  778.       sscanf(text,"%d",&xHoehe);
  779.  
  780.       fgets(text, 80, weser);
  781.       fgets(text, 80, weser);
  782.       sscanf(text,"%d",&xSeite);
  783.  
  784.       fgets(text, 80, weser);
  785.       fgets(text, 80, weser);
  786.       sscanf(text,"%d",&xDrossel);
  787.  
  788.       fgets(text, 80, weser);
  789.       fgets(text, 80, weser);
  790.       sscanf(text,"%d",&xMotor);
  791.  
  792.       fgets(text, 80, weser);
  793.       fgets(text, 80, weser);
  794.       sscanf(text,"%d",&xGewicht);
  795.       abtrieb= ((float)-xGewicht);
  796.  
  797.       fgets(text, 80, weser);
  798.       fgets(text, 80, weser);
  799.       sscanf(text,"%d",&xPower);
  800.  
  801.       HoeheFak  = xHoehe / HOEHESENS   * xJoySens;
  802.       QuerFak   = xQuer  / QUERSENS    * xJoySens;
  803.       PowerFak  = xPower / DROSSELSENS * xJoySens;
  804.       SeitenFak = xSeite / SEITENSENS  * xJoySens;
  805.  
  806.       fgets(text, 80, weser);
  807.       fgets(text, 80, weser);
  808.       sscanf(text,"%d",&xWiderstand);
  809.       xReibung=0.00001*(float)xWiderstand;
  810.       reibung = xReibung;
  811.  
  812.       fgets(text, 80, weser);
  813.       fgets(text, 80, weser);
  814.       sscanf(text,"%d",&FWart);
  815.  
  816.       fgets(text, 80, weser);
  817.       fgets(text, 80, weser);
  818.       sscanf(text,"%d",&abriss);
  819.  
  820. /* Farben einlesen : */
  821.      for(i=0; i<=7; i++)
  822.       {
  823.           fgets(text, 80, weser);
  824.           fgets(text, 80, weser);
  825.           sscanf(text,"%d",&RGB[i].rot);
  826.           fgets(text, 80, weser);
  827.           sscanf(text,"%d",&RGB[i].gruen);
  828.           fgets(text, 80, weser);
  829.           sscanf(text,"%d",&RGB[i].blau);
  830.       }
  831.  
  832.      fgets(text, 80, weser);
  833.      fgets(text, 80, weser);
  834.      sscanf(text,"%d",&polygone);
  835.  
  836.  
  837. /* fr Anzahl der Polygone : */
  838.      for(i=1; i<=polygone; i++)
  839.       {
  840.       fgets(text, 80, weser);
  841.       fgets(text, 80, weser);
  842.       sscanf(text,"%d",&polygon[i].ppunkte);
  843.  
  844.       fgets(text, 80, weser);
  845.       fgets(text, 80, weser);
  846.       sscanf(text,"%d",&polygon[i].pfarbe);
  847.  
  848.       fgets(text, 80, weser);
  849.       fgets(text, 80, weser);
  850.       sscanf(text,"%d",&polygon[i].pinvfarbe);
  851.  
  852.       /* fr Anzahl der Polygonpunkte : */
  853.       for(j=1; j<=polygon[i].ppunkte; j++)
  854.           {
  855.           fgets(text, 80, weser);
  856.           fgets(text, 80, weser);
  857.           sscanf(text,"%d",&polygon[i].ppx[j]);
  858.  
  859.           fgets(text, 80, weser);
  860.           fgets(text, 80, weser);
  861.           sscanf(text,"%d",&polygon[i].ppy[j]);
  862.  
  863.           fgets(text, 80, weser);
  864.           fgets(text, 80, weser);
  865.           sscanf(text,"%d",&polygon[i].ppz[j]);
  866.           }
  867.       }
  868.  
  869.      fclose(weser);
  870.  
  871. }
  872.  
  873.  
  874.