Tricks, die ich meine zu kennen

Riecht nach Scherfgen^^

Mechanics

Wir müssen ja nicht gleich so unfreundlich reagieren. Mir ist aber echt nicht klar, worums geht. Wer sind "sie" und was für "magisches Zeug" machen die?

hustbaer

"Sie" sind die Spieleentwickler und das magische Zeugs sind ... naja all die Dinge/Techniken die man halt verwendet um heute Spiele zu machen.

Finde ich alles ein wenig einfach gedacht. Zwischen den Grundlagen und einem guten Produkt liegt ein himmelweiter Unterschied. Aber klar: Ohne Grundlagen geht nichts. Sie sind die Grundsteine und öffnen Tür und Tor.

delimitr

EOP schrieb:

In der Besessenheit würde ich es als durchaus behandlungswürdig einstufen.

Ich hab's geschrieben und es läuft garnicht mal soo langsam. Man lädt die Atomkkordinaten und die korrespondierenden Pixel aus der Eingabedatei.
Behandlungsbedürftig wäre dann auch mein Netzhautschaden, weil mir aber auch nie irgendjemand irgendwas erklärt. Wenn ich mir die "Nogger"-Eisverpackung mit dem linken Auge anschaue, sehe ich wirklich den Schriftzug "N )gger".
Wegen der Sonne vom 31.1.2007 .
Und der Doktor Zachariou hat mir bei meinen Leistenbrüchen 1985 und 1986 zwei Lyoduras in die Bauchdecke genäht.
Und Frau Hetzel-Kabiri hat mich ums Abitur beschissen. Und da sollte man doch mit aller Besessenheit dagegenwirken...

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

float sqrtab[1000000];

void sqrinit(void)
{
 int count=0;
 while ( count < 1000000 )
 {
  sqrtab[count]=sqrt((float)count/1000.0 ) ;
  count++;
 }

}

float SQRT(float quad)
{
  return ( sqrt(quad) );
 if ( quad < 0.0 ) quad*=-1.0 ;

 if (quad > 999 ) return ( sqrt(quad) );

 return sqrtab[ (unsigned int)( quad*1000.0) ];

}

float sintab[128];
float costab[128];

void sininit(void)
{
 float value;
 value=-6.4;

 while ( value < 6.4 )
 {
  sintab[(int)((value+6.4)*10.0)]=sin(value);
  value+=0.1;
 }

}

void cosinit(void)
{
 float value;
 value=-6.4;

 while ( value < 6.4 )
 {
  costab[(int)((value+6.4)*10.0)]=cos(value);
  value+=0.1;
 }

}

inline float SIN(float value)
{
 signed int sign;
 signed int index;

 if ( value < 0 ) sign=-1;
 else sign=+1;
  index= ((int)( value*10 )%64);
  index+=63;

 return sintab[index];
}

inline float COS(float value)
{
 signed int sign;
 signed int index;

 if ( value < 0 ) sign=-1;
 else sign=+1;
  index= ((int)( value*10 )%64);
  index+=63;

 return  costab[index];
}

struct
{
 long unsigned x_next, y_next; /* korrekte Abstaende von Atom 2 und 3 zu Atom 1 */
 unsigned int num_atoms;
 long signed int atoms[64][9]; /* die ersten drei bestimmen den Winkel, zweites x, drittes y,
                                 die restlichen vier sind die Nachbarbindungsatome */
 unsigned int num_pixels;
 signed long pixgroup[8192][4]; /* Pixeldarstellung */
 float x_angl, y_angl, z_angl; /* Drehwinkel des Objekts */
 float x,y,z; /* Koordinaten. Ergeben sich aber dann aus den Atomkoordinaten. */
}input_obj[32];

float pixelbuf[131072][4];
unsigned int pixelnum=0;
unsigned int objnum=0;

#define ZOOM 120.0 /* Skalierung der Zentralprojektion */
#define VOXDEPTH 1

int main(void)
{
 FILE *input, *floor;

struct
 {
  float x,y,z;
  float xv,yv,zv;
  int elec_or_prot;

  float distance;
  unsigned int objID;
  signed int bondNum1, bondNum2, bondNum3, bondNum4, bondNum5, bondNum6;
  float nearest;
 }teilchen[2048];
unsigned int ATOMNUM=0;

 float power, old_power, x_buf, y_buf, z_buf, x_buf2, y_buf2, z_buf2, sign;
 float cmpadd_x, cmpadd_y;
 float x_cmp, y_cmp, z_cmp;

  signed int vox_x, vox_y, vox_z;

struct
{
 float x,y,z;
 float x_angl, y_angl, z_angl;

} cam; /* die Projektionsflaeche und der Projektionspunkt */

unsigned char floorLmap[512][512];
unsigned char floorHmap[512][512];
unsigned char screen[160][96];
unsigned int zbuf[160][96]; /* vorderster Z-Wert eines projizierten Punkts pro Bildschirmkoordinate. */
long int score=0;
float game_ended=1000;

unsigned char c;

float speed=0.0, driveangl=0.0, xtomid, ztomid;

signed long int counter=0;
float distsample;
long int old_pix_num;
signed long int counter2=0;
long unsigned int n,n2, n3;
signed int screen_x, screen_y;
int framereduce, framered2;

float x_turned, y_turned, z_turned,
      x_turned2, y_turned2, z_turned2,
      x_turned3, y_turned3, z_turned3;

      sqrinit(), sininit(), cosinit();

input=fopen(".\\3ddata.txt","rb");
floor=fopen(".\\floor.map", "rb");
if ( floor==NULL ) return;
fread(floorHmap, sizeof(unsigned char), 512*512, floor);
fread(floorLmap, sizeof(unsigned char), 512*512, floor);
fclose(floor);

vox_z=0;
while ( vox_z < 512 )
{
 vox_x=0;
 while ( vox_x < 512 )
 {

    c=floorLmap[vox_x][vox_z] ;
    if ( c < 64 ) c=' ';
    else
    if ( c < 128 ) c= 176;
    else
    if ( c < 196 ) c= 177;
    else
    if ( c < 255 )c= '@';
    floorLmap[vox_x][vox_z]=c;

  vox_x++;
 }
 vox_z++;
}

if ( input==NULL ) return;

   /* die Atomgruppen und die korrespondierenden Pixelgruppen mitsamt relativer
     Positionierung zueinander aus der Eingabedatei laden */

 while ( ! feof(input) )
 {

  fscanf(input,"%d %d", &input_obj[objnum].x_next,&input_obj[objnum].y_next );
  fscanf(input,"%d", &(input_obj[objnum].num_atoms) );
  counter=0;
  while ( counter < input_obj[objnum].num_atoms )
  {
   fscanf(input,"%d %d %d %d %d %d %d %d %d", &input_obj[objnum].atoms[(int)counter][0],
                                              &input_obj[objnum].atoms[(int)counter][1],
                                              &input_obj[objnum].atoms[(int)counter][2],

                                      &input_obj[objnum].atoms[(int)counter][3],
                                      &input_obj[objnum].atoms[(int)counter][4],
                                      &input_obj[objnum].atoms[(int)counter][5],
                                      &input_obj[objnum].atoms[(int)counter][6],
                                      &input_obj[objnum].atoms[(int)counter][7],
                                      &input_obj[objnum].atoms[(int)counter][8]  /* Bindungen */
                                        );

   counter++;
  }

  fscanf(input,"%d", &(input_obj[objnum].num_pixels) );
  counter=0;
  while ( counter < input_obj[objnum].num_pixels )
  {
   fscanf(input,"%d %d %d %d", &input_obj[objnum].pixgroup[(int)counter][0],
                               &input_obj[objnum].pixgroup[(int)counter][1],
                               &input_obj[objnum].pixgroup[(int)counter][2],
                               &input_obj[objnum].pixgroup[(int)counter][3] );

   counter++;
  }

  objnum++;

 }
fclose(input);
objnum--;

counter=0;
counter2=0;
ATOMNUM=0;

while ( counter2 < objnum ) /* Atomgruppen in die Physiksimulation uebertragen */
{
 counter=0;
 while ( counter < input_obj[counter2].num_atoms )
 {
  teilchen[ATOMNUM].x = input_obj[counter2].atoms[(int)counter][0];
  teilchen[ATOMNUM].y = input_obj[counter2].atoms[(int)counter][1];
  teilchen[ATOMNUM].z = input_obj[counter2].atoms[(int)counter][2];
  teilchen[ATOMNUM].bondNum1=input_obj[counter2].atoms[(int)counter][3];
  teilchen[ATOMNUM].bondNum2=input_obj[counter2].atoms[(int)counter][4];
  teilchen[ATOMNUM].bondNum3=input_obj[counter2].atoms[(int)counter][5];
  teilchen[ATOMNUM].bondNum4=input_obj[counter2].atoms[(int)counter][6];
  teilchen[ATOMNUM].bondNum5=input_obj[counter2].atoms[(int)counter][7];
  teilchen[ATOMNUM].bondNum6=input_obj[counter2].atoms[(int)counter][8];

  teilchen[ATOMNUM].elec_or_prot= (int)counter%1; /* mod */
  teilchen[ATOMNUM].objID = counter2;

  teilchen[ATOMNUM].xv=0;
  teilchen[ATOMNUM].yv=0;
  teilchen[ATOMNUM].zv=0;

  counter++;
  ATOMNUM++;
 }
 counter2++;
}

cam.x=0,cam.y=0, cam.z=0;
cam.x_angl=0, cam.y_angl=0, cam.z_angl=0;

while(1)
{
framered2=0;
for(framereduce=0; framereduce < 10 ; framereduce++ )
{

  /* Tastatureingaben entgegennehmen */

 if ( kbhit() )
 {
  c=getch();
  framered2=100;

 }
   else if ( framered2 == 0 ) c=0;
   framered2--;

   if(c=='u' ) cam.x-= -2*SIN(-cam.y_angl), cam.z-= -2*COS(-cam.y_angl);
   if(c=='j' ) cam.x+= -2*SIN(-cam.y_angl), cam.z+= -2*COS(-cam.y_angl);
   if(c=='h'  ) cam.y_angl+=0.04;
   if(c=='k' ) cam.y_angl-=0.04;
   if(c=='e') cam.y-=2;
   if(c=='d') cam.y+=2;
   if(c=='x') return;
   if ( c=='p' ) getch();

   if ( c=='v' ) if ( driveangl < 1.56 )driveangl+=0.04; /* eine Vektoraenderung koennte auch programmcodegesteuert erfolgen */
   if ( c=='n' ) if ( driveangl > - 1.56 ) driveangl-=0.04 ; /* z.B. zusaetzliche Angabe ueber Objekttyp */
   if ( c=='g' )  speed < 0.3 ? speed+=0.5 : (speed=0.3); /* vielleicht externer Bytecodeuebersetzer und Interpreter in diesem Programm */
   if ( c=='b' )  speed > -0.2 ? speed-=0.5 : (speed=-0.2);

     xtomid= -(teilchen[13].x - teilchen[4].x)*COS(-driveangl)
      -(teilchen[13].z - teilchen[4].z)*SIN(-driveangl);

      ztomid=  (teilchen[13].x - teilchen[4].x)*SIN(-driveangl)
      -(teilchen[13].z - teilchen[4].z)*COS(-driveangl);

     teilchen[4].xv+= xtomid*speed, teilchen[4].zv+=ztomid*speed;

     if ( speed > 0 ) speed-=0.005;
     else if ( speed < 0 ) speed+=0.005;

        if ( driveangl > 0.0 ) driveangl-=0.01;
        else if ( driveangl < 0.0 ) driveangl+=0.01;

    //  if ( fabs(speed) > 0.3 ) cam.x=teilchen[13].x - 30 , cam.z= teilchen[13].z + 120, cam.y_angl=driveangl+3.14, cam.y=14;

   /* Physik-Simulation. Je Eigenteilchen die Kraftwirkung aller umgebenden
     Fremdteilchen berechnen und auf die Vektoraenderung aufsummieren,
     danach bewegen. */

#define PHYSLICE 11

/* printf("Das X von Teilchen 0:%f Teilchen 1:%f",teilchen[0].x, teilchen[1].x); */

n3=0;
while( n3 < PHYSLICE )
{
   if ( n3%1 == 0 )
   {
   n=0;

   n=0;
   while (n < ATOMNUM )
   {

    n2=0;
    while ( n2 < ATOMNUM )
    {
     if ( n==n2 ) { n2++; continue; }
     power=
    SQRT(
    ( teilchen[n].x - teilchen[n2].x)  *
    ( teilchen[n].x - teilchen[n2].x )+
       ( teilchen[n].y - teilchen[n2].y) *
    ( teilchen[n].y - teilchen[n2].y)+
     ( teilchen[n].z - teilchen[n2].z) *
    ( teilchen[n].z - teilchen[n2].z) ) ;

    old_power=power;

   x_buf=(teilchen[n].x - teilchen[n2].x);
   y_buf=(teilchen[n].y - teilchen[n2].y);
   z_buf=(teilchen[n].z - teilchen[n2].z);

  #define SCHEITEL 10.0  /* die Stelle der ladungsneutralen Luecke um den Kern */
  #define LADUNG   17.0      /* neu --> war 17.0 */
  #define LADNULL 1.0   // war vorher 0.5, sofortige Kraftabgabe
  #define TRAEGSCHWELLE 0.1 /* ist die Kraft schwaecher als das, findet keine Abgabe statt */
  #define ELANLOSS 0.0 /* beim unelastischen Stoss mogelt man eine Koordinatenaenderung rein */
  #define MAXKRAFT 2.5 /* so wird die aus der Distanz sich ergebende Kraft nie zu gross */
  #define PROT 1
  #define ELEK 0

  #define TIMESLICE 45.0
  #define VERLANGSFAC 0.98 /* allgemeiner Verlust Richtung 0, vielleicht wegen der Schwerkraft */

  if ( power-SCHEITEL < 0.0 ) sign= -1.0; else sign= 1.0;
   power=power-SCHEITEL;

    power= ( LADUNG / ((power *power )+MAXKRAFT) *sign  ) ;

    if ( fabs ( power) > LADNULL ) power=0; /*  Energiebegrenzung */

          if ( old_power != 0 )
          {
          y_buf*=power/old_power;
          x_buf*=power/old_power;
          z_buf*=power/old_power;
        } else x_buf=0, y_buf=0, z_buf=0;

    if ( (( teilchen[n].elec_or_prot==PROT
            && teilchen[n2].elec_or_prot==ELEK ) ||
          ( teilchen[n].elec_or_prot==ELEK
           && teilchen[n2].elec_or_prot==PROT )
           ||

              (
           teilchen[n].objID==teilchen[n2].objID &&
           ( n2==teilchen[n].bondNum1 ||
                  n2==teilchen[n].bondNum2 ||
                  n2==teilchen[n].bondNum3 ||
                  n2==teilchen[n].bondNum4 ||
                  n2==teilchen[n].bondNum5 ||
                  n2==teilchen[n].bondNum6)
               )
           )

      ) {  y_buf*=-1.0; x_buf*=-1.0; z_buf*=-1.0;

           if ( ( n2==teilchen[n].bondNum1 ||
                  n2==teilchen[n].bondNum2 ||
                  n2==teilchen[n].bondNum3 ||
                  n2==teilchen[n].bondNum4 ||
                  n2==teilchen[n].bondNum5 ||
                  n2==teilchen[n].bondNum6)
                && teilchen[n].objID==teilchen[n2].objID )
           {
            #define KOHAERENZ 3
            x_buf*=KOHAERENZ,
            y_buf*=KOHAERENZ,
            z_buf*=KOHAERENZ;
              }

           }

    if ( (old_power=SQRT ( x_buf*x_buf+y_buf*y_buf +z_buf*z_buf)) > TRAEGSCHWELLE )
   {
    /*
      power= (old_power-TRAEGSCHWELLE)/ old_power;
      x_buf*=power; y_buf*=power; z_buf*=power;  das war der Fehler*/
    }  else x_buf=0, y_buf=0, z_buf=0;

     if ( old_power > 0 && old_power > TRAEGSCHWELLE )
          {
           x_buf2+=(x_buf*ELANLOSS/TIMESLICE);
           y_buf2+=(y_buf*ELANLOSS/TIMESLICE);
           z_buf2+=(z_buf*ELANLOSS/TIMESLICE);
          }

   if ( teilchen[n].objID != teilchen[n2].objID )
    {

        #define POLARAUS 0.3

      //x_buf*=0.1, y_buf*=0.1, z_buf*=0.1;
      if ( x_buf > 0 && x_buf < POLARAUS) x_buf=0;
      else if ( x_buf >= POLARAUS ) x_buf-=POLARAUS ;
      else if ( x_buf < 0 && x_buf > -POLARAUS) x_buf=0;
      else if ( x_buf <= -POLARAUS )  x_buf+=POLARAUS ;

      if ( y_buf > 0 && y_buf < POLARAUS) y_buf=0;
      else if ( y_buf >= POLARAUS )  y_buf-=POLARAUS ;
      else if ( y_buf < 0 && y_buf > -POLARAUS) y_buf=0;
      else if ( y_buf <= -POLARAUS ) y_buf+=POLARAUS ;

      if ( z_buf > 0 && z_buf < POLARAUS) z_buf=0;
      else if ( z_buf >= POLARAUS )  z_buf-=POLARAUS ;
      else if ( z_buf < 0 && z_buf > -POLARAUS) z_buf=0;
      else if ( z_buf <= -POLARAUS )  z_buf+=POLARAUS ;

      } // war je 2 alt

    n2++;

    teilchen[n].xv+=x_buf;
    teilchen[n].yv+=y_buf;
    teilchen[n].zv+=z_buf;

    }

    n++;
   }

   n=0;

  n=0;
  while ( n < ATOMNUM )
  {
   if ( teilchen[n].x < 512 && teilchen[n].z < 512 && teilchen[n].x >=0 && teilchen[n].z >=0 )
    { if ( teilchen[n].y < 30+ floorHmap[(int)teilchen[n].x][(int)teilchen[n].z]*VOXDEPTH  /* && n3 == 0 */ ) teilchen[n].yv+=0.009; else /* if ( *//* ! (n3 > 0 ) */ /* teilchen[n].yv> 0) */ teilchen[n].yv-= (teilchen[n].y - 30+ floorHmap[(int)teilchen[n].x][(int)teilchen[n].z]*VOXDEPTH )/TIMESLICE; } // Schwerkraft
   else if ( teilchen[n].y < 30 /* && n3 == 0 */ ) teilchen[n].yv+=0.009; else /* if ( *//* ! (n3 > 0 ) */ /* teilchen[n].yv> 0) */ teilchen[n].yv-=(teilchen[n].y-30)/TIMESLICE; // Schwerkraft

    n++;
  }
    n=0;

  } // Aussetzer Ende

 if ( n3%1 == 0 )
 {
     while ( n < ATOMNUM )
  {

    teilchen[n].xv*=VERLANGSFAC; teilchen[n].yv*=VERLANGSFAC; teilchen[n].zv*=VERLANGSFAC;

   teilchen[n].x+=(teilchen[n].xv/TIMESLICE); teilchen[n].y+=(teilchen[n].yv/TIMESLICE) ;
    teilchen[n].z+=(teilchen[n].zv/TIMESLICE);

   n++;
  }

  }

  n3++;
 }

} // Framereduce Ende

  counter=0;
  counter2=0;
 while ( counter2 < objnum )  /* Koordinaten des ersten Atoms zu Objektkoordinaten zuweisen */
 {
  input_obj[counter2].x=teilchen[(int)counter].x;
  input_obj[counter2].y=teilchen[(int)counter].y;
  input_obj[counter2].z=teilchen[(int)counter].z;
  teilchen[(int)counter].distance=0;
  teilchen[(int)counter].nearest=100000;
  counter++;

  while ( teilchen[(int)counter].objID == teilchen[(int)counter-1].objID ) counter++;
 counter2++;
 }

counter2=0;
counter=0;
while ( counter < objnum )  /* aus den Koordinaten der bewegten Atome
                               den naechsten korrespondierenden Drehwinkel der
                               grafischen Darstellung ermitteln (Winkel durchprobieren) */
{

   y_buf=-4.0;
   x_buf=-4.0;
   z_buf=-4.0;

  while ( x_buf < 4.0 )
  {
   y_buf=-4.0;
   while ( y_buf < 4.0 )
   {
    z_buf=-4.0;
    while ( z_buf < 4.0)
    {
     teilchen[counter2].distance=0;
     n=1;

while ( n < 3 )
{

        cmpadd_x=0, cmpadd_y=0;

       if ( n==1 ) cmpadd_x=input_obj[(int)counter].x_next;
       if ( n==2 ) cmpadd_y=input_obj[(int)counter].y_next;

    /* y-Achse */

       x_turned= +(cmpadd_x)*COS(y_buf)+(0)*SIN(y_buf);
       y_turned=cmpadd_y;
       z_turned= -(cmpadd_x)*SIN(y_buf)+(0)*COS(y_buf);

 /* x-Achse */

       y_turned2= +(y_turned)*COS(x_buf)-(z_turned)*SIN(x_buf);
       x_turned2=x_turned;
       z_turned2= (y_turned)*SIN(x_buf)+(z_turned)*COS(x_buf);

 /* z-Achse  */

       x_turned3= +(x_turned2)*COS(z_buf)-(y_turned2)*SIN(z_buf);
       z_turned3=z_turned2;
       y_turned3= (x_turned2)*SIN(z_buf)+(y_turned2)*COS(z_buf);

       x_cmp=x_turned3+teilchen[counter2].x,
       y_cmp=y_turned3+teilchen[counter2].y,
       z_cmp=z_turned3+teilchen[counter2].z;

       x_cmp= fabs(x_cmp-teilchen[counter2+n].x);
       y_cmp= fabs(y_cmp-teilchen[counter2+n].y);
       z_cmp= fabs(z_cmp-teilchen[counter2+n].z);

       teilchen[counter2].distance+= (x_cmp+y_cmp+z_cmp);

       n++;
}

       if ( teilchen[counter2].distance < teilchen[counter2].nearest )
      {
        input_obj[(int)counter].x_angl=x_buf,
        input_obj[(int)counter].y_angl=y_buf,
        input_obj[(int)counter].z_angl=z_buf;

        teilchen[counter2].nearest=teilchen[counter2].distance;

       }

     z_buf+=0.2;
    }

    y_buf+=0.2;
   }
   x_buf+=0.2;
  }

  while ( teilchen[counter2].objID == teilchen[counter2+1].objID && counter2 < ATOMNUM-1) counter2++;

  /*printf("X-Wink: %f Y-Wink: %f Z-Wink: %f\n",input_obj[counter].x_angl, input_obj[counter].y_angl,
                              input_obj[counter].z_angl ); *//* debug */

  counter2++;
 counter++;

}

/* printf("X-Wink: %f Y-Wink: %f Z-Wink: %f  %d\n",input_obj[1].x_angl, input_obj[1].y_angl,
                              input_obj[1].z_angl, counter2 ); */ /* debug */

   /* Bildschirm leeren, Z-Buffer initialisieren */
     screen_y=0;
  while(screen_y<96)
  {
   screen_x=0;
   while(screen_x<160)
   {
    screen[screen_x][screen_y]=219;
    zbuf[screen_x][screen_y]=100000;
    screen_x++;
   }
   screen_y++;
   }

#define BUFX 0
#define BUFY 1
#define BUFZ 2
#define VALUE 3

 pixelnum=0;

counter2=0;

while( counter2 < objnum ) /* fuer jeden einzelnen Pixel dessen Drehungen
                             anhand der Objektpositionierung berechnen */
{
 counter=0;
  while(counter < input_obj[counter2].num_pixels && counter < input_obj[counter2].num_pixels)
  {
   if ( input_obj[counter2].pixgroup[counter][VALUE] != 0 )
   {
    pixelbuf[pixelnum][BUFX]=input_obj[counter2].pixgroup[counter][BUFX]  +input_obj[counter2].x ;
    pixelbuf[pixelnum][BUFY]=input_obj[counter2].pixgroup[counter][BUFY] +input_obj[counter2].y ;
    pixelbuf[pixelnum][BUFZ]=input_obj[counter2].pixgroup[counter][BUFZ] +input_obj[counter2].z ;
    pixelbuf[pixelnum][VALUE]=(unsigned char)input_obj[counter2].pixgroup[counter][VALUE];

/* y-Achse */

       x_turned= +(pixelbuf[pixelnum][BUFX]-input_obj[counter2].x)*COS(input_obj[counter2].y_angl)+(pixelbuf[pixelnum][BUFZ]-input_obj[counter2].z)*SIN(input_obj[counter2].y_angl);
       y_turned=pixelbuf[pixelnum][BUFY]    -input_obj[counter2].y; /* Subtraktion eingefuegt */
       z_turned= -(pixelbuf[pixelnum][BUFX]-input_obj[counter2].x)*SIN(input_obj[counter2].y_angl)+(pixelbuf[pixelnum][BUFZ]-input_obj[counter2].z)*COS(input_obj[counter2].y_angl);

 /* x-Achse */

       z_turned2= (y_turned)*SIN(input_obj[counter2].x_angl)+(z_turned)*COS(input_obj[counter2].x_angl);
       y_turned2= (y_turned)*COS(input_obj[counter2].x_angl)-(z_turned)*SIN(input_obj[counter2].x_angl);
       x_turned2=x_turned;

 /* z-Achse  */

       y_turned3= (x_turned2)*SIN(input_obj[counter2].z_angl)+(y_turned2)*COS(input_obj[counter2].z_angl);
       x_turned3= (x_turned2)*COS(input_obj[counter2].z_angl)-(y_turned2)*SIN(input_obj[counter2].z_angl);
       z_turned3= z_turned2;

      pixelbuf[pixelnum][BUFX]=x_turned3+input_obj[counter2].x;
      pixelbuf[pixelnum][BUFY]=y_turned3+input_obj[counter2].y;
      pixelbuf[pixelnum][BUFZ]=z_turned3+input_obj[counter2].z;

     pixelnum++;
    }
     if ( pixelbuf[pixelnum-1][BUFZ]-cam.z > ZOOM*4 )    counter+=2;
    else counter++;
                    /* unterschiedliche Pixelzahlen nach Abstand */

  }
  counter2++;

}

 counter=0;

 old_pix_num=pixelnum;
 distsample=0.0;
 while ( counter < old_pix_num ) /* Projektion aller Pixel zur Kamera, vorher: Kameradrehung berechnen */
 {

/* y-Achse */

       x_turned= +(pixelbuf[(int)counter][BUFX]-cam.x)*COS(cam.y_angl)+(pixelbuf[(int)counter][BUFZ]-cam.z)*SIN(cam.y_angl);
       y_turned=pixelbuf[(int)counter][BUFY];
       z_turned= -(pixelbuf[(int)counter][BUFX]-cam.x)*SIN(cam.y_angl)+(pixelbuf[(int)counter][BUFZ]-cam.z)*COS(cam.y_angl);

         pixelbuf[(int)counter][BUFX]=x_turned+cam.x;
        pixelbuf[(int)counter][BUFY]=y_turned;
        pixelbuf[(int)counter][BUFZ]=z_turned+cam.z;

        if ( z_turned < ZOOM )
        {

        #define DOUBLEFILL(xoff,yoff) \
         pixelbuf[(int)pixelnum][BUFX]=x_turned+xoff+cam.x; \
        pixelbuf[(int)pixelnum][BUFY]=y_turned+yoff;\
        pixelbuf[(int)pixelnum][BUFZ]=z_turned+cam.z;\
        pixelbuf[(int)pixelnum][VALUE]=pixelbuf[(int)counter][VALUE];\
\
         pixelnum++;\

         DOUBLEFILL (-1*z_turned/ZOOM,-1*z_turned/ZOOM)
         DOUBLEFILL (1*z_turned/ZOOM,-1*z_turned/ZOOM)
         DOUBLEFILL (0,-1*z_turned/ZOOM)
         DOUBLEFILL (-1*z_turned/ZOOM,0)
         DOUBLEFILL (1*z_turned/ZOOM,0 )
         DOUBLEFILL (-1*z_turned/ZOOM,1*z_turned/ZOOM)
         DOUBLEFILL (0,1*z_turned/ZOOM)
         DOUBLEFILL (1*z_turned/ZOOM,1*z_turned/ZOOM)

        }

  counter++;
 }

 // Hoehenkarte

 vox_z=0;
 while ( vox_z < 512 )
 {
  vox_x=0;

  while ( vox_x < 512 )
  {
       x_turned= +(vox_x-cam.x)*COS(cam.y_angl)+(vox_z-cam.z)*SIN(cam.y_angl);
       y_turned=floorHmap[vox_x][vox_z];
       z_turned= -(vox_x-cam.x)*SIN(cam.y_angl)+(vox_z-cam.z)*COS(cam.y_angl);

       x_turned+=cam.x;
       z_turned+=cam.z;

    #define SETVOXEL(xf,yf,zf) \
  if ( (z_turned-(float)cam.z)/ZOOM>0  ) \
      { \
       if( (79.0 + ( (signed int)xf -cam.x)/(((signed int)zf-cam.z)/ZOOM)) < 160 && 47.0 + ((yf-cam.y)/(((signed int)zf-cam.z)/ZOOM)) < 90.0 && \
           79.0 + (( (signed int)xf -cam.x)/(((signed int)zf-cam.z)/ZOOM)) >= 0 && 47.0 + ((yf-cam.y)/(((signed int)zf-cam.z)/ZOOM)) >= 0   ) \
       if ( zbuf[ (signed int) (79.0 + (( (signed int)xf -cam.x)/(((signed int)zf-(float)cam.z)/ZOOM))) ] [ (signed int)(47.0 + ((yf-cam.y)/(((signed int)zf-cam.z)/ZOOM))) ] > ((signed int)zf-cam.z) ) \
            zbuf[ (signed int) (79.0 + \
            (( (signed int)xf -cam.x))/ \
            (((signed int)zf-(float)cam.z)/ZOOM)) ] \
            [ (signed int)(47.0 + ((yf-cam.y)/(((signed int)zf-(float)cam.z)/ZOOM))) ] \
            =((signed int)zf-cam.z), \
       screen[ (signed int) (79.0 + (( (signed int)xf -cam.x)/(((signed int)zf-(float)cam.z)/ZOOM))) ] [ (signed int)(47.0 + (((signed int)yf-cam.y)/(((signed int)zf-cam.z)/ZOOM))) ]=(unsigned char)floorLmap[vox_x][vox_z]; }\

    SETVOXEL(  ((signed int)x_turned-1),(30+y_turned), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned),(30+y_turned), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned+1),(30+y_turned-1), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned-1),(30+y_turned-1), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned),(30+y_turned-1), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned+1),(30+y_turned), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned-1),(30+y_turned+1), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned),(30+y_turned+1), ((signed int)z_turned ))
    SETVOXEL(  ((signed int)x_turned+1),(30+y_turned+1), ((signed int)z_turned ))

   vox_x++;
   if ( z_turned > ZOOM ) vox_x++;
   if ( z_turned > ZOOM*3 ) vox_x++;
   if ( z_turned > ZOOM*6 ) vox_x+=2;

  }

  if ( z_turned > ZOOM ) vox_z++;
   if ( z_turned > ZOOM*3 ) vox_z++;
   if ( z_turned > ZOOM*6 ) vox_z+=2;

  vox_z++;
 }

 while ( pixelnum > 0 )
 {
  pixelnum--;

   /* die eigentliche Projektion */

  if ( (pixelbuf[pixelnum][BUFZ]-(float)cam.z)/ZOOM>0  )
      {
       if( (79.0 + (pixelbuf[pixelnum][BUFX]-cam.x)/((pixelbuf[pixelnum][BUFZ]-cam.z)/ZOOM)) < 160 && 47.0 + ((pixelbuf[pixelnum][BUFY]-cam.y)/((pixelbuf[pixelnum][BUFZ]-cam.z)/ZOOM)) < 90.0 &&
           79.0 + ((pixelbuf[pixelnum][BUFX]-cam.x)/((pixelbuf[pixelnum][BUFZ]-cam.z)/ZOOM)) >= 0 && 47.0 + ((pixelbuf[pixelnum][BUFY]-cam.y)/((pixelbuf[pixelnum][BUFZ]-cam.z)/ZOOM)) >= 0   )
       if ( zbuf[ (signed int) (79.0 + ((pixelbuf[pixelnum][BUFX]-cam.x)/((pixelbuf[pixelnum][BUFZ]-(float)cam.z)/ZOOM))) ] [ (signed int)(47.0 + ((pixelbuf[pixelnum][BUFY]-cam.y)/((pixelbuf[pixelnum][BUFZ]-cam.z)/ZOOM))) ] > (pixelbuf[pixelnum][BUFZ]-cam.z) )
            zbuf[ (signed int) (79.0 +
            ((pixelbuf[pixelnum][BUFX]-cam.x))/
            ((pixelbuf[pixelnum][BUFZ]-(float)cam.z)/ZOOM)) ]
            [ (signed int)(47.0 + ((pixelbuf[pixelnum][BUFY]-cam.y)/((pixelbuf[pixelnum][BUFZ]-(float)cam.z)/ZOOM))) ]
            =(pixelbuf[pixelnum][BUFZ]-cam.z),
       screen[ (signed int) (79.0 + ((pixelbuf[pixelnum][BUFX]-cam.x)/((pixelbuf[pixelnum][BUFZ]-(float)cam.z)/ZOOM))) ] [ (signed int)(47.0 + ((pixelbuf[pixelnum][BUFY]-cam.y)/((pixelbuf[pixelnum][BUFZ]-cam.z)/ZOOM))) ]=pixelbuf[pixelnum][VALUE];
    }

 }

   /* Uebertragen des Screenbuffers auf den Bildschirm ( hier: Textmodus,
     zukuenftig: Grafikmodus ). */
  system("cls\n");

   /* Teilchendump debug */

   /*
  screen[(int)teilchen[0].x+80][(int)teilchen[0].y+20]='1';
  screen[(int)teilchen[1].x+80][(int)teilchen[1].y+20]='2';
  screen[(int)teilchen[2].x+80][(int)teilchen[2].y+20]='3';
  screen[(int)teilchen[3].x+80][(int)teilchen[3].y+20]='4';
  screen[(int)teilchen[4].x+80][(int)teilchen[4].y+20]='5';
  screen[(int)teilchen[5].x+80][(int)teilchen[5].y+20]='6';
  screen[(int)teilchen[6].x+80][(int)teilchen[6].y+20]='7'; */

  screen[79][47]='X'; /* debug */

  screen_y=0;

  while(screen_y<70)
  {
   screen_x=0;
   while(screen_x<160)
   {
    printf("%c%c%c%c%c%c%c%c",screen[screen_x][screen_y],
                              screen[screen_x+1][screen_y],
                              screen[screen_x+2][screen_y],
                              screen[screen_x+3][screen_y],
                              screen[screen_x+4][screen_y],
                              screen[screen_x+5][screen_y],
                              screen[screen_x+6][screen_y],
                              screen[screen_x+7][screen_y]);
    screen_x+=8;
   }
    printf("\n");
   screen_y++;
   }
    /*
    printf("%f %f %f\n"
           "%f %f %f\n"
           "%f %f %f\n",teilchen[0].x, teilchen[0].y, teilchen[0].z,
                        teilchen[4].x, teilchen[4].y, teilchen[4].z,  // war 4,5
                        teilchen[5].x, teilchen[5].y, teilchen[5].z );          */
    if ( score < 1000 && game_ended >= 5 )
    printf("%d %f\n", 1000-score, game_ended=SQRT( (256-teilchen[27].x)*(256-teilchen[27].x)+
                                   (256-teilchen[27].z)*(256-teilchen[27].z)+
                                   (32-teilchen[27].y)*(32-teilchen[27].y)) ),
     (game_ended > 5 ? score++ : 0);
     else { if ( game_ended > 5 ) printf("Game Over!"); else printf("%f Punkte",1000-score); };

  /*  printf("%f %f %d\n",cam.x,cam.y,pixelbuf[12][VALUE] ); */ /*debug*/
}

/* Klar macht es erstmal einen Scheisseindruck.
  Aber ich irre mich nicht in der Annahme, dass der Grundstein gelegt ist und dass
  hier ein enormes Potential drinsteckt.
  Es ist der Grundstock fuer eine 3D-Engine und eine Physik-Simulation.
  Mit den richtigen Parametern kann das eindrucksvoll und toll werden. */

 }

delimitr

das war die Originalgrafik von Doom.
Da gab es 1993/1994 Riesendiskussionen drüber, weil nämlich die mit der Zentralprojektion projizierten Sprites zu real wirkten.
Und dann machte die BPJM, die damals noch BPJS hieß, eine Studie über schädigende Medienwirkungen. Dazu wurden über die staatlichen Lizenzen ein Haufen Scheißinhalte unters Volk gestreut.
Lest ihr zum Beispiel "AMERICAN BLEND" und streicht das italienische "CREMA" für Sonnencreme raus, erhaltet ihr ein Anagramm für "Bin Laden".
Aber es ging beim Rauchen wohl garnicht um Krebs, sondern um den Mediendachschaden, der durch den medialen Verzehr von Krebs-Melodramen entsteht.
Und Lyodura ist eine Zombiescheiße. Wenn ihr euch "Zombie im Kaufhaus" angeschaut habt, wo Peter gebissen wird und langsam innerhalb von drei Tagen verblödet, ist psychoanalytisch die Wirkung, daß ihr hinterher meint, an einer Gehirnzehrung zu meiden.
"BRAUN MELSUNGEN".
Vom Melanin wird man in der Sonne genetisch bevorzugt braun.
Und "SANG" auf lateinisch oder französisch bedeutet "Blut".
Und meint ihr, bei einer Verbrennung wird eure Haut nicht anfangen zu bluten?
Beim Jugendschutz geht es um Medienwirkungen. Und sowohl Siechtum als auch Gewalt (Hitler, Rassismus), gelten als hochgradig jugendgefährdend.
Und sie kennen die Wirkungen differenzierter, als ihr meint.
Das ist meine Idee. Aber ich selber schiebe schon jetzt wieder Panik, weil ich aufpassen muß, was ich sage. Ich baue nach...
Blond und Blood und Blind.
Erstes französisches Opfer in Lyon.
Osama bedeutet Löwe.
Brown und Brain -- "Rainbow".

SeppJ

Ich wiederhole noch einmal die Frage: Willst du hier irgendetwas diskutieren oder hast du das Forum mit deinem persönlichem Blog verwechselt?

hustbaer

SeppJ schrieb:

oder hast du das Forum mit deinem persönlichem Blog verwechselt?

Das. Wobei ich es nicht so höflich formuliert hätte

SeppJ

hustbaer schrieb:

SeppJ schrieb:

oder hast du das Forum mit deinem persönlichem Blog verwechselt?

Das. Wobei ich es nicht so höflich formuliert hätte

Ich wollte eigentlich noch einen schnippischen Kommentar abgeben, warum wohl niemand sein Blog liest, habe es mir aber in letzter Sekunde verkniffen. Da ich nun gesagt habe, dass ich dazu etwas zu sagen gehabt hätte, kann er sich nun natürlich denken, was ich wohl zu sagen gehabt hätte

tenim

kommt mir vor wie ein typ von hier

http://mahag.com/neufor/index.php?sid=5ec9b26512b994bcf47f87fc4dafc7ce

da geht es im prinzip nicht um das finden von lösungen bzw. der wahrheit sondern nur um labern, geistiges ejakulieren und andere zu diskussionen zu provozieren um das eigene ego zu stärken/zu befüttern.

arm.

Immerhin hat dieser Thread schon 800+ Hits und damit wohl mehr Aufmerksamkeit als ein Blog zu diesem Thema.

EOP

Als hätte ich nicht schon von Anfang an gemerkt, dass da ein behandlungswürdiger Fall vorliegt...

delimitr

tenim schrieb:

kommt mir vor wie ein typ von hier

http://mahag.com/neufor/index.php?sid=5ec9b26512b994bcf47f87fc4dafc7ce

da geht es im prinzip nicht um das finden von lösungen bzw. der wahrheit sondern nur um labern, geistiges ejakulieren und andere zu diskussionen zu provozieren um das eigene ego zu stärken/zu befüttern.

arm.

Naja, wenn man die richtigen Datensätze reinlädt, stellt es wirklich die Pixeldarstellung von zwei Autos auf einer Straße mit einem Tal dar.
Und wenn man dann einen Würfel aus 3x3x3 Einzelteilchen der grafischen Darstellung
zuordnet, kann man Kräfte auf den Würfel wirken lassen, den dreht und verschiebt es dann und er hebt trotzdem zusammen und die Positionierung und die Drehung der grafischen Darstellung passt es dann entsprechend an, das Auto bewegt sich dann sozusagen mit.
Man muß die Auflösung des Konsolenfensters umstellen und dann stellt es mit vier bstimmten ASCII-Werten vier Graustufen mit einer Auflösung von 160x70(?) dar.
Wenn man die Physik richtig anpasst, könnte es hinkommen.
Ich will keine Diskussionen provozieren, ich habe wirklich keinen Durchblick mehr. Und möchte man nur die Dynamik simulieren, landet man gleich bei der blöden Atombombe.

tenim

das ist jetzt auf keinen fall böse gemeint, aber du solltest wirklich erwägen, in psychiatrische behandlung zu gehen.

tenim schrieb:

das ist jetzt auf keinen fall böse gemeint, aber du solltest wirklich erwägen, in psychiatrische behandlung zu gehen.

Das Känguru hat seine eigene Art und Weise.

Warum passiert sowas eigentlich immer hier? Ich hab sowas noch nie irgendwo anders erlebt, immer nur in diesem Forum.

Sogar wenn das die selbe Person ist und ein Scherz sein soll, ist die Art von Humor trotzdem sehr beunruhigend.

FR schrieb:

Warum passiert sowas eigentlich immer hier? Ich hab sowas noch nie irgendwo anders erlebt, immer nur in diesem Forum.

Dann hast du wohl nicht sehr viel Erfahrung mit Foren.

Manche offentsichtliche Sachen sollte man auch aussprechen (dürfen).

delimitr

Es verstärkt die zu filternde Frequenz.
Und laute Punkte kann man abgreifen, um eine Umwandlung in die Frequenzdarstellung hinzubekommen.
Dann kommt noch die Häufung einer bestimmten Frequenzresonanz über die Zeit hinzu, und am Ende kriegt man eine gespielte Melodie wirklich automatisiert in Notenschrift übertragen, zum Beispiel.

/* ist die angegebene Frequenz im Signal enthalten, wird sie verstaerkt, weil auf jede Signalaenderung in der
 entsprechenden Richtung und Staerke eine Sinusschwingung nachhallt.
 Das erzeugt dann einen Resonanzeffekt.
 Raw oder .snd - Eingabedatei mit 8 Bit unsigned char, an der Kommandozeile die Frequenz angeben und dann verstärkt
 es in der Ausgabe die gewuenschte Frequenz, falls da vorhanden.
 */

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

unsigned char signal[1000000];
unsigned char filtered[1000000];

int main(int argc, char*argv[])
{

  FILE *input, *input2;
  unsigned int n=0, n2=0;
  float steigung, frequenz, stoplen;

  if ( argc != 4 )
  {
   printf("Falsche Anzahl Argumente!\n");
   return 1;

  }

  stoplen=44100/(float)atoi(argv[3]);
  frequenz= 3.14 /(44100/(float)atoi(argv[3]) );

  input=fopen(argv[1],"rb");
  input2=fopen(argv[2],"wb");

  if ( input == NULL )
  {
   printf("Datei nicht gefunden!\n");
   return 1;
  }

 fread( signal, sizeof(unsigned char), 1000000, input);
 fclose(input);

   n=0;
   while ( n < 500000 )
   {
    filtered[n]=127;n++;
   }

  n=0;
  stoplen=1; // Geschwindigkeit
  while ( n < 500000 )
  {
   n+=stoplen;
   steigung= signal[n]-signal[n-(int)stoplen];
   steigung/=4;

    n2=0;
    while ( n2 < 2048 )
    {
     filtered[n2+n]+= (signed char)(sin((float)n2*frequenz)*steigung);

     n2++;
    }

  }

 fwrite( filtered, sizeof(unsigned char), 1000000, input2);
 fclose(input2);

}

Damit kann man ein Fraktal erzeugen...

/*
  Es ist einfach nur die rekursive Pixeldarstellung.
  Man lädt ein Muster und das Programm schreibt daraus ein Fraktal in die Ausgabe.
  */

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

unsigned char bild[4];
unsigned char ausgabe[1024000];

#define PLOTDEPTH 11

void fractal(unsigned char *buf, int x_off, int y_off, int x_spacing, int y_spacing, int depth)
{
 int x=0,y=0;
 y=0;
 while ( y < 2 )
 {
  x=0;
  while ( x < 2 )
  {
   if ( buf[x+y*2]!= 32 )
    {
    if ( depth < PLOTDEPTH )
     fractal(buf,x_off+x*x_spacing, y_off+y*y_spacing, x_spacing/2, y_spacing/2, depth+1 );

    else if ( (x+x_off)/1>0 && (x+x_off)/1 < 1280 && (y+y_off)/1 >0 && (y+y_off)/1 < 800 ) ausgabe[(int)((x+x_off)/1)+((y+y_off)/1)*1280]=0;

    }
   x++;
  }

  y++;
 }

}

int main(int argc, char*argv[])
{

  FILE *input, *output;
  int n=0, n2=0;

  input=fopen(argv[1],"rb");

  if ( argc != 3 )
  {
   printf("Falsche Anzahl Argumente!\n");
   return 1;

  }

  if ( input == NULL )
  {
   printf("Datei nicht gefunden!\n");
   return 1;
  }

  output=fopen(argv[2],"wb");
  if ( output==NULL )
  {
   printf("E/A-Fehler.\n");
   return 1;
  }

 fread( bild, sizeof(unsigned char), 4, input);
 fclose(input);

 n=0; while ( n < 1024000 ) { ausgabe[n]=255, n++; }

 fractal( bild, 0, 0, 2048,2048, 0 );

 fwrite ( ausgabe, sizeof(unsigned char), 1024000, output );
 fflush(output );

  fclose(output);

}

Das ist alles, womit ich noch produktiv beitragen kann.
Soll ich noch was zu Einstein sagen?
Um uns herum befindet sich ein Schwerefeld (100 Milliarden Galaxien), das sich in der Schwebe auf eine bestimmte Dichte hält. Bewegt sich drin ein Teilchen, reißt es das aus der Schwebe, hinten zieht es bis zu einem Maximum verdichtende Halbkreise nach,
und die erzeugen den Strahlungsdruck, reißen also alles im Weg nach außen.
Das vodere zuerst ( Absorption).
Und so entsteht Licht.
Zwei Kräfte: Gravitation und elektrische Anziehung, und drei Sorten Teilchen: Elektronen, Protonen, Neutronen (ich nenne sie halt mal so).
Gleiche ziehen sich an, selbe stoßen sich ab, und dann kommt noch eine schwache Gravitation dazu. Und der Radius der Anziehung endet schon vor dem Mittelpunkt eines Teilchens.
Ob das nun wirklich stimmt, spielt keine Rolle, aber man kann damit hoffentlich alle Physik-Vorgänge in einem Computer modellieren und simulieren.
Und zur seelischen Gesundheit noch drei Zitate:
"Man sollte auf keinen Fall in die Sonne schauen, das ist wirklich sehr gefährlich, man kann dabei sogar blind werden." (öffentlich-rechtlicher Wetterfrosch)

"Und was haben wir im Auge? Melanin. Das schützt das Gehirn vor der UV-Strahlung. Im Norden wurde kein Melanin benötigt. Und das ist einer der Gründe, weshalb blauäugige dümmer sind." (ZDF Neo-Rassismusexperimentsdokumentation)

"Blacks were not educated at all or only were told enough to be servants."

War is Dirie und Ìride ( italienisch "Iris" und "Regenbogen"). Das gab uns unser Deutschlehrer mal zu lesen.

Weiterentwicklung von Blurry?

delimitr schrieb:

Das ist alles, womit ich noch produktiv beitragen kann.

Alles, was ich noch dazu beitragen kann, ist:
Denk mal drüber nach, dein Haloperidol regelmäßig einzunehmen.

Naja, John Forbes Nash Jr. leider auch unter Schizophrenie. Ich denke, dass delimitr unter bestimmten Bedingungen bestimmt auch zu Höchstleistungen fähig ist, aber das klappt halt nicht in einer Welt, in der man Leute, die von der Norm abweichend anders ticken, sofort mit Medikamenten und Therapien ruhig stellen will.