コード例 #1
0
ファイル: intersec.c プロジェクト: Luccifer/GishSources
int pointintersectline(float *point,float *vertex1,float *vertex2,float bias)
  {
  float vec[3],vec2[3];
  float normal[3];
  float scale;

  subtractvectors(normal,vertex2,vertex1);
  normalizevector(normal,normal);
  subtractvectors(vec,point,vertex1);
  scale=dotproduct(normal,vec);

  scalevector(vec2,normal,scale);
  subtractvectors(vec,vec,vec2);
  scale=vectorlength(vec);
  if (scale>bias)
    return(0);

  subtractvectors(vec,point,vertex1);
  subtractvectors(vec2,vertex2,vertex1);
  if (dotproduct(vec,vec2)<0.0f)
    return(0);

  subtractvectors(vec,point,vertex2);
  subtractvectors(vec2,vertex1,vertex2);
  if (dotproduct(vec,vec2)<0.0f)
    return(0);

  return(1);
  }
コード例 #2
0
ファイル: bond.c プロジェクト: aceiii/freegish
void checkbonds(void)
{
    int count/*,count2*/;
    //int numofbondstemp;
    int part1,part2;
    float vec[3]/*,vec2[3]*/;
    float veclength;
    //float scale;

    for (count=0; count<numofbonds; count++)
        if (bond[count].type==4 || bond[count].type==6 || bond[count].type==16)
            if (bond[count].timetolive!=-1)
            {
                part1=bond[count].part1;
                part2=bond[count].part2;

                subtractvectors(vec,particle[part2].position,particle[part1].position);

                scaleaddvectors(vec,vec,particle[part2].velocity,1.0f);
                scaleaddvectors(vec,vec,particle[part1].velocity,-1.0f);

                veclength=vectorlength(vec);

                if (bondtype[bond[count].type].compression!=0.0f)
                    if (veclength<bond[count].length*bond[count].compression)
                    {
                        bond[count].timetolive=-1;
                        /*
                        if (bond[count].type==6)
                          {
                          for (count2=0;count2<numofbonds;count2++)
                          if (bond[count2].type==6)
                            if (bond[count2].objectnum==bond[count].objectnum)
                              bond[count2].timetolive=-1;
                          }
                        */
                    }
                if (veclength>bond[count].length*bond[count].tension)
                {
                    bond[count].timetolive=-1;
                    /*
                    if (bond[count].type==6)
                      {
                      for (count2=0;count2<numofbonds;count2++)
                      if (bond[count2].type==6)
                        if (bond[count2].objectnum==bond[count].objectnum)
                          bond[count2].timetolive=-1;
                      }
                    */
                }
            }

    count=0;
    while (count<numofbonds)
    {
        while (count<numofbonds && bond[count].timetolive==-1)
            deletebond(count);
        count++;
    }
}
コード例 #3
0
ファイル: bond.c プロジェクト: aceiii/freegish
void bondsimulation(void)
{
    int count,count2;
    int part1,part2;
    float vec[3];
    float bondnormal[3];
    float veclength;
    float force[2];

    for (count=0; count<32; count++)
    {
        for (count2=0; count2<numofparticles; count2++)
            copyvector(particle[count2].prevvelocity,particle[count2].velocity);

        for (count2=0; count2<numofbonds; count2++)
            if ((count&bond[count2].cycles)==0)
            {
                part1=bond[count2].part1;
                part2=bond[count2].part2;

                subtractvectors(bondnormal,particle[part2].position,particle[part1].position);
                veclength=vectorlength(bondnormal)-bond[count2].length;
                normalizevector(bondnormal,bondnormal);

                zerovector(vec);
                scaleaddvectors(vec,vec,particle[part2].prevvelocity,1.0f);
                scaleaddvectors(vec,vec,particle[part1].prevvelocity,-1.0f);

                veclength+=dotproduct(vec,bondnormal);
                if (bondtype[bond[count2].type].compression==0.0f)
                    if (veclength<0.0f)
                        veclength=0.0f;

                veclength*=bond[count2].elasticity;

                veclength/=(particle[part1].mass+particle[part2].mass);

                force[0]=veclength*particle[part2].mass;
                force[1]=veclength*particle[part1].mass;

                scaleaddvectors(particle[part1].velocity,particle[part1].velocity,bondnormal,force[0]);
                scaleaddvectors(particle[part2].velocity,particle[part2].velocity,bondnormal,-force[1]);
            }
    }
}
コード例 #4
0
ファイル: vector.c プロジェクト: Luccifer/GishSources
INLINE void normalizevector(float *result,float *vec)
  {
  float vectorlengthvalue;

  vectorlengthvalue=vectorlength(vec);
  if (vectorlengthvalue!=0.0f)
    {
    vectorlengthvalue=1.0f/vectorlengthvalue;
    result[0]=vec[0]*vectorlengthvalue;
    result[1]=vec[1]*vectorlengthvalue;
    result[2]=vec[2]*vectorlengthvalue;
    }
  else
    {
    result[0]=0.0f;
    result[1]=0.0f;
    result[2]=0.0f;
    }
  }
コード例 #5
0
ファイル: bond.c プロジェクト: aceiii/freegish
void createbond(int part1,int part2,int type,int objectnum)
{
    int count;
    float vec[3];
    float length;

    if (part1>=numofparticles)
        return;
    if (part2>=numofparticles)
        return;

    for (count=0; count<numofbonds; count++)
    {
        if (bond[count].part1==part1 && bond[count].part2==part2)
            return;
        if (bond[count].part1==part2 && bond[count].part2==part1)
            return;
    }

    subtractvectors(vec,particle[part1].position,particle[part2].position);
    length=vectorlength(vec);
    if (length==0.0f)
        return;

    memset(&bond[numofbonds],0,sizeof(bond[numofbonds]));

    bond[numofbonds].part1=part1;
    bond[numofbonds].part2=part2;
    bond[numofbonds].type=type;
    bond[numofbonds].timetolive=10000;
    bond[numofbonds].length=length;
    bond[numofbonds].maxlength=length;

    bond[numofbonds].elasticity=bondtype[type].elasticity;
    bond[numofbonds].cycles=bondtype[type].cycles;
    bond[numofbonds].compression=bondtype[type].compression;
    bond[numofbonds].tension=bondtype[type].tension;

    bond[numofbonds].objectnum=objectnum;

    numofbonds++;
}
コード例 #6
0
ファイル: vector.c プロジェクト: Luccifer/GishSources
void rotateorientation(float orientation[3][3],float *rotationvector,float rotationangle)
  {
  int count;
  float pointtemp[3],cosnormal[3],sinnormal[3];
  float axisnormal[3];
  float vectorlengthvalue,dotproductvalue;

  normalizevector(axisnormal,rotationvector);

  if (fabs(rotationangle)<.003f)
    return;

  for (count=0;count<3;count++)
    {
    copyvector(pointtemp,orientation[count]);

    crossproduct(sinnormal,axisnormal,pointtemp);

    normalizevector(sinnormal,sinnormal);

    crossproduct(cosnormal,sinnormal,axisnormal);

    normalizevector(cosnormal,cosnormal);

    dotproductvalue=dotproduct(axisnormal,pointtemp);
    pointtemp[0]-=axisnormal[0]*dotproductvalue;
    pointtemp[1]-=axisnormal[1]*dotproductvalue;
    pointtemp[2]-=axisnormal[2]*dotproductvalue;
    vectorlengthvalue=vectorlength(pointtemp);

    orientation[count][0]=axisnormal[0]*dotproductvalue+cosnormal[0]*cos(rotationangle)*vectorlengthvalue+sinnormal[0]*sin(rotationangle)*vectorlengthvalue;
    orientation[count][1]=axisnormal[1]*dotproductvalue+cosnormal[1]*cos(rotationangle)*vectorlengthvalue+sinnormal[1]*sin(rotationangle)*vectorlengthvalue;
    orientation[count][2]=axisnormal[2]*dotproductvalue+cosnormal[2]*cos(rotationangle)*vectorlengthvalue+sinnormal[2]*sin(rotationangle)*vectorlengthvalue;

    normalizevector(orientation[count],orientation[count]);
    }
  }
コード例 #7
0
ファイル: animation.c プロジェクト: FrozenCow/gish
void objectanimation(void)
  {
  int count,count2;
  int particlelist[2];
  float vec[3];
  float intersectpoint[3];
  float normal[3];
  float scale;

  for (count=0;count<numofobjects;count++)
    {
    if (object[count].type==1)
      {
      /*
      for (count2=0;count2<object[count].numofparticles;count2++)
      if ((rand()&8191)==0)
        createparticle(5,particle[object[count].particle[count2]].position,particle[object[count].particle[count2]].velocity,0.125f,-1,100);
      */

      if (object[count].frame==12)
        {
        object[count].framedelay+=0.125f;
        if (object[count].framedelay>=1.0f)
          {
          object[count].frame=0;
          object[count].framedelay=0.0f;
          }
        }

      if (object[count].numoforientations==0)
        {
        if (object[count].frame>=5 && object[count].frame<=7)
          object[count].frame=1;
        if (object[count].frame<4)
          {
          object[count].framedelay+=1.0f;
          if (object[count].framedelay>=4.0f)
            {
            object[count].frame++;
            object[count].framedelay=0.0f;
            }
          }
        }
      else
        {
        if (object[count].frame>0 && object[count].frame<=4)
          {
          object[count].framedelay+=1.0f;
          if (object[count].framedelay>=4.0f)
            {
            object[count].frame--;
            object[count].framedelay=0.0f;
            }
          }
        if (object[count].frame==0)
          if ((rnd()&255)==0)
            object[count].frame=5;

        if (object[count].frame>=5 && object[count].frame<=7)
          {
          object[count].framedelay+=1.0f;
          if (object[count].framedelay>=4.0f)
            {
            object[count].frame++;
            if (object[count].frame==8)
              object[count].frame=0;
            object[count].framedelay=0.0f;
            }
          }
        }
      if ((object[count].button&8)==8)
      if (object[count].frame<8)
        {
        object[count].frame=8;
        object[count].framedelay=0.0f;
        }

      if (object[count].frame>=8 && object[count].frame<=11)
        {
        object[count].framedelay+=1.0f;
        if (object[count].framedelay>=4.0f)
          {
          if ((object[count].button&8)==8)
            {
            if (object[count].frame<11)
              object[count].frame++;
            }
          else
            {
            if (object[count].frame>7)
              object[count].frame--;
            if (object[count].frame==7)
              object[count].frame=0;
            }
          object[count].framedelay=0.0f;
          }
        }
      }
    if (object[count].type==4)
      {
      if (object[count].animationtype==0 || object[count].animationtype==1)
      if ((object[count].button&1)==1)
        {
        object[count].animationtype=2;
        object[count].frame=0;
        object[count].framedelay=0.0f;
        }
      if (object[count].beasttype==12)
      if (object[count].animationtype==0)
      if ((object[count].button&2)==2)
        {
        object[count].animationtype=1;
        object[count].frame=0;
        object[count].framedelay=0.0f;
        }
      if (object[count].animationtype==0)
        {
        if (object[count].link!=-1)
          {
          object[object[count].link].texturenum=animation[object[count].animationnum+32].stand[0];
          if (fabs(object[0].position[0]-object[count].position[0])<1.5f)
          if (object[0].position[1]>object[count].position[1])
            object[object[count].link].texturenum=animation[object[count].animationnum+32].stand[1];
          }

        object[count].framedelay+=0.1f;
        if (object[count].framedelay>=1.0f)
          {
          object[count].framedelay=0.0f;
          object[count].frame++;
          if (object[count].frame>=animation[object[count].animationnum].stand[1])
            object[count].frame=0;
          }
        object[count].texturenum=animation[object[count].animationnum].stand[0]+object[count].frame;
        if (vectorlength(object[count].velocity)>=0.01f)
          {
          object[count].animationtype=1;
          object[count].frame=0;
          object[count].framedelay=0.0f;
          }
        }
      if (object[count].animationtype==1)
        {
        if (object[count].link!=-1)
          {
          object[object[count].link].texturenum=animation[object[count].animationnum+32].walk[0];
          if (fabs(object[0].position[0]-object[count].position[0])<1.5f)
          if (object[0].position[1]>object[count].position[1])
            object[object[count].link].texturenum=animation[object[count].animationnum+32].stand[1];
          }
        if (object[count].beasttype!=12)
          object[count].framedelay+=vectorlength(object[count].velocity)*6.0f;
        else
          object[count].framedelay+=0.2f;
        if (object[count].framedelay>=1.0f)
          {
          object[count].framedelay=0.0f;
          object[count].frame++;
          if (object[count].frame>=animation[object[count].animationnum].walk[1])
            {
            object[count].frame=0;
            if (object[count].beasttype==12)
              object[count].animationtype=0;
            }
          }
        object[count].texturenum=animation[object[count].animationnum].walk[0]+object[count].frame;
        if (object[count].beasttype!=12)
        if (vectorlength(object[count].velocity)<0.01f)
          {
          object[count].animationtype=0;
          object[count].frame=0;
          object[count].framedelay=0.0f;
          }
        if (object[count].beasttype==12)
        if (object[count].frame==4)
        if (object[count].framedelay==0.0f)
          {
          addvectors(vec,object[count].position,yaxis);
          createbeast(11,vec,1.0f,1.0f,1.0f,0.2f);
          object[numofobjects-1].timetolive=512;
          object[numofobjects-1].link=-1;
          for (count2=0;count2<4;count2++)
            {
            particle[object[numofobjects-1].particle[count2]].velocity[1]=0.08f;
            if (object[count].direction==0)
              particle[object[numofobjects-1].particle[count2]].velocity[0]=-0.04f;
            else
              particle[object[numofobjects-1].particle[count2]].velocity[0]=0.04f;
            }
          }
        }
      if (object[count].animationtype==2)
        {
        if (object[count].link!=-1)
          object[object[count].link].texturenum=animation[object[count].animationnum+32].attack[0];

        object[count].framedelay+=0.2f;
        if (object[count].framedelay>=1.0f)
          {
          object[count].framedelay=0.0f;
          object[count].frame++;
          if (object[count].frame>=animation[object[count].animationnum].attack[1])
            {
            object[count].animationtype=0;
            object[count].frame=0;
            }
          }
        object[count].texturenum=animation[object[count].animationnum].attack[0]+object[count].frame;

        if (object[count].frame==1)
        if (object[count].framedelay==0.0f)
          {
          if (object[count].beasttype<3 || object[count].beasttype==8 || object[count].beasttype==11 || object[count].beasttype==16)
            playsound(11,object[count].position,NULL,0.25f,0,0.7f,-1,0);
          else if (object[count].beasttype==7 || object[count].beasttype==13)
            playsound(12,object[count].position,NULL,0.5f,0,1.0f,-1,0);
          else
            playsound(13,object[count].position,NULL,0.5f,0,1.0f,-1,0);
          }

        if (object[count].frame==5)
          {
          //if (object[count].beasttype!=7 && object[count].beasttype!=13)
            {
            scale=1.25f;
            if (object[count].beasttype<3 || object[count].beasttype==8 || object[count].beasttype==11 || object[count].beasttype==16)
              scale=0.75f;
            if (object[count].beasttype==15)
              scale=1.5f;
            if (object[count].beasttype==7 || object[count].beasttype==13)
              scale=3.0f;
  
            if (object[count].direction==0)
              scaleaddvectors(vec,object[count].position,object[count].orientation[0],-scale);
            if (object[count].direction==1)
              scaleaddvectors(vec,object[count].position,object[count].orientation[0],scale);
            if (lineintersectobject(intersectpoint,normal,&scale,object[count].position,vec,0,particlelist))
              {
              scale=0.06f;
              if (object[count].beasttype<3)
                scale=0.03f;
              if (object[count].beasttype==15)
                scale=0.15f;
  
              if (object[count].direction==0)
                {
                scaleaddvectors(particle[particlelist[0]].velocity,particle[particlelist[0]].velocity,object[count].orientation[0],-scale);
                scaleaddvectors(particle[particlelist[1]].velocity,particle[particlelist[1]].velocity,object[count].orientation[0],-scale);
                }
              if (object[count].direction==1)
                {
                scaleaddvectors(particle[particlelist[0]].velocity,particle[particlelist[0]].velocity,object[count].orientation[0],scale);
                scaleaddvectors(particle[particlelist[1]].velocity,particle[particlelist[1]].velocity,object[count].orientation[0],scale);
                }
              if (object[count].beasttype<3 || object[count].beasttype==11)
                object[0].hitpoints-=20;
              else
                object[0].hitpoints-=40;
              if (object[count].beasttype==15)
                object[0].hitpoints-=40;
              }
            }
          if (object[count].beasttype==7 || object[count].beasttype==13)
          if (object[count].framedelay==0.0f)
            {
            if (object[count].beasttype==7)
              createbeast(2,object[count].position,1.0f,1.0f,1.0f,0.2f);
            else
              createbeast(8,object[count].position,1.0f,1.0f,1.0f,0.2f);
            object[numofobjects-1].timetolive=512;
            object[numofobjects-1].link=-1;
            for (count2=0;count2<4;count2++)
              {
              if (object[count].direction==0)
                particle[object[numofobjects-1].particle[count2]].velocity[0]=-0.08f;
              else
                particle[object[numofobjects-1].particle[count2]].velocity[0]=0.08f;
              }
            }
          }
        }
      if (object[count].timetolive>=0 && object[count].timetolive<45)
        {
        if (object[count].timetolive==44)
          {
          if (object[count].beasttype<3 || object[count].beasttype==8 || object[count].beasttype==11 || object[count].beasttype==16)
            {
            game.score[0]+=100*game.combo;
            createsprite(100*game.combo,object[count].position);
            game.combo++;
            game.combodelay+=100;
            if (game.combodelay>250)
              game.combodelay=250;
            playsound(7,object[count].position,NULL,1.0f,0,1.0f,-1,0);
            }
          else
            {
            game.score[0]+=200*game.combo;
            createsprite(200*game.combo,object[count].position);
            game.combo++;
            game.combodelay+=100;
            if (game.combodelay>250)
              game.combodelay=250;
            playsound(19,object[count].position,NULL,1.0f,0,1.0f,-1,0);
            }

          for (count2=0;count2<10;count2++)
            {
            vec[0]=(float)((rnd()&255)-127)/1270.0f;
            vec[1]=(float)((rnd()&255)-127)/1270.0f;
            vec[2]=0.0f;
            addvectors(vec,vec,object[count].velocity);

            createparticle(5,object[count].position,vec,0.25f,-1,100+(rnd()&63));
            particle[numofparticles-1].rendersize=0.125+(float)(rnd()&127)/1000.0f;
            particle[numofparticles-1].texturenum=367;
            if (object[count].beasttype==11 || object[count].beasttype==12)
              particle[numofparticles-1].texturenum=364;
            if (object[count].beasttype==0 || object[count].beasttype==3 || object[count].beasttype==4)
              particle[numofparticles-1].texturenum=365;
            }
          }

        if (object[count].link!=-1)
          {
          object[object[count].link].texturenum=animation[object[count].animationnum+32].die[0];
          if (object[object[count].link].timetolive>150)
            object[object[count].link].timetolive=150;
          }
        object[count].animationtype=3;
        object[count].frame=8-object[count].timetolive/5;
        object[count].framedelay=0.0f;
        object[count].texturenum=animation[object[count].animationnum].die[0]+object[count].frame;
        }
      }
    }
  if (game.levelnum==34)
  if (object[1].type==2)
  if ((rnd()&255)==0)
    {
    object[1].texturenum=64+(rnd()&3);
    }
  }
コード例 #8
0
ファイル: objedit.c プロジェクト: Asmageddon/gish
void editlevelobjects(void)
  {
  int count,count2;
  int x,y;
  int simtimer;
  int simcount;
  float vec[3],vec2[3];

  simtimer=SDL_GetTicks();

  resetmenuitems();

  while (!menuitem[0].active && !windowinfo.shutdown)
    {
    glClearColor(0.0f,0.0f,0.0f,0.0f);
    glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
    glStencilMask(~0);
    glClearStencil(0);
    glClear(GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
    glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_FALSE);
    glStencilMask(0);

    setuptextdisplay();
    glColor3fv(level.ambient[3]);
    if (level.background[0]!=0)
      displaybackground(660);

    numofmenuitems=0;
    createmenuitem("",0,0,16,1.0f,1.0f,1.0f,1.0f);
    setmenuitem(MO_HOTKEY,SCAN_ESC);
    if (editor.objectnum!=-1)
      {
      createmenuitem("Mass   ",(640|TEXT_END),0,16,1.0f,1.0f,1.0f,1.0f);
      setmenuitem(MO_FLOATINPUT,&level.object[editor.objectnum].mass);
      setmenuitem(MO_HOTKEY,SCAN_M);
      createmenuitem("Friction",(640|TEXT_END),32,16,1.0f,1.0f,1.0f,1.0f);
      setmenuitem(MO_FLOATINPUT,&level.object[editor.objectnum].friction);
      setmenuitem(MO_HOTKEY,SCAN_F);
      createmenuitem("LType",(640|TEXT_END),64,16,1.0f,1.0f,1.0f,1.0f);
      setmenuitem(MO_INTINPUT,&level.object[editor.objectnum].lighttype);
      createmenuitem("Red  ",(640|TEXT_END),96,16,1.0f,1.0f,1.0f,1.0f);
      setmenuitem(MO_FLOATINPUT,&level.object[editor.objectnum].lightcolor[0]);
      createmenuitem("Green",(640|TEXT_END),128,16,1.0f,1.0f,1.0f,1.0f);
      setmenuitem(MO_FLOATINPUT,&level.object[editor.objectnum].lightcolor[1]);
      createmenuitem("Blue ",(640|TEXT_END),160,16,1.0f,1.0f,1.0f,1.0f);
      setmenuitem(MO_FLOATINPUT,&level.object[editor.objectnum].lightcolor[2]);
      createmenuitem("Inten",(640|TEXT_END),192,16,1.0f,1.0f,1.0f,1.0f);
      setmenuitem(MO_FLOATINPUT,&level.object[editor.objectnum].lightintensity);
      }

    checksystemmessages();
    checkkeyboard();
    checkmouse();
    checkmenuitems();

    view.zoom=10.0f;
    if (keyboard[SCAN_EQUALS])
      view.zoom=20.0f;
    if (keyboard[SCAN_MINUS])
      view.zoom=5.0f;

    view.zoomx=view.zoom+0.5f;
    view.zoomy=view.zoom*0.75f+0.5f;

    setuporthoviewport(0,0,640,480,view.zoom,view.zoom*0.75f,20.0f);
    setupviewpoint(view.position,view.orientation);

    setupframelighting();

    rendershadows();

    renderlevelback();
    renderlevel();
    //renderlevelfore();

    renderlevelfore();
    renderlevelobjects();

    if (keyboard[SCAN_L])
      renderlevellines();

    setuptextdisplay();

    drawtext(TXT_OBJECTSET":/i",0,352,16,1.0f,1.0f,1.0f,1.0f,editor.objecttype);
    drawtext(TXT_OBJECTNUM":/i",0,368,16,1.0f,1.0f,1.0f,1.0f,editor.objectnum);
    if (editor.objectnum!=-1)
      drawtext(TXT_OBJECTYPE":/i",0,384,16,1.0f,1.0f,1.0f,1.0f,level.object[editor.objectnum].type);
    drawtext(TXT_OBJECTS":/i",0,400,16,1.0f,1.0f,1.0f,1.0f,level.numofobjects);
    drawtext(TXT_ROPES":/i",0,416,16,1.0f,1.0f,1.0f,1.0f,level.numofropes);
    if (editor.objectnum!=-1)
      {
      drawtext(TXT_LINK":/i",0,432,16,1.0f,1.0f,1.0f,1.0f,level.object[editor.objectnum].link);
      }

    drawmenuitems();

    drawmousecursor(768+font.cursornum,mouse.x,mouse.y,16,1.0f,1.0f,1.0f,1.0f);

    SDL_GL_SwapBuffers();

    if (mouse.x<512 || mouse.y>224)
      {
      x=view.position[0]+(float)(mouse.x-320)/32.0f;
      y=view.position[1]+(float)(240-mouse.y)/32.0f;
      if (!keyboard[SCAN_K])
        {
        if (mouse.lmb && !prevmouse.lmb)
          {
          if (!keyboard[SCAN_H])
            {
            vec[0]=(float)x+0.5f;
            vec[1]=(float)y+0.5f;
            vec[2]=0.0f;
            }
          else
            {
            vec[0]=(float)x;
            vec[1]=(float)y;
            vec[2]=0.0f;
            }

    
          memset(&level.object[level.numofobjects],0,sizeof(level.object[level.numofobjects]));
          level.object[level.numofobjects].type=editor.objecttype;
          level.object[level.numofobjects].link=-1;
          copyvector(level.object[level.numofobjects].position,vec);
          if (editor.objectnum==-1 || level.object[level.numofobjects].type!=level.object[editor.objectnum].type)
            {
            level.object[level.numofobjects].texturenum=0;
            level.object[level.numofobjects].size[0]=1.0f;
            level.object[level.numofobjects].size[1]=1.0f;
            level.object[level.numofobjects].mass=1.0f;
            level.object[level.numofobjects].friction=0.8f;
            level.object[level.numofobjects].lightcolor[0]=1.0f;
            level.object[level.numofobjects].lightcolor[1]=1.0f;
            level.object[level.numofobjects].lightcolor[2]=1.0f;
            level.object[level.numofobjects].lightintensity=16.0f;
            }
          else
            {
            level.object[level.numofobjects].texturenum=level.object[editor.objectnum].texturenum;
            level.object[level.numofobjects].size[0]=level.object[editor.objectnum].size[0];
            level.object[level.numofobjects].size[1]=level.object[editor.objectnum].size[1];
            level.object[level.numofobjects].mass=level.object[editor.objectnum].mass;
            level.object[level.numofobjects].friction=level.object[editor.objectnum].friction;
            level.object[level.numofobjects].lighttype=level.object[editor.objectnum].lighttype;
            level.object[level.numofobjects].lightcolor[0]=level.object[editor.objectnum].lightcolor[0];
            level.object[level.numofobjects].lightcolor[1]=level.object[editor.objectnum].lightcolor[1];
            level.object[level.numofobjects].lightcolor[2]=level.object[editor.objectnum].lightcolor[2];
            level.object[level.numofobjects].lightintensity=level.object[editor.objectnum].lightintensity;
            }

          editor.objectnum=level.numofobjects;
          level.numofobjects++;
          }
        }
      if (keyboard[SCAN_K])
        {
        vec[0]=view.position[0]+(float)(mouse.x-320)/32.0f;
        vec[1]=view.position[1]+(float)(240-mouse.y)/32.0f;
        vec[2]=0.0f;

        if (mouse.lmb && !prevmouse.lmb)
          {
          if (editor.objectnum!=-1)
          for (count=0;count<level.numofobjects;count++)
            {
            subtractvectors(vec2,vec,level.object[count].position);
            if (vectorlength(vec2)<0.5f)
              level.object[editor.objectnum].link=count;
            }
          }
        if (mouse.rmb && !prevmouse.rmb)
          level.object[editor.objectnum].link=-1;
        }
      if (mouse.rmb && !prevmouse.rmb)
        {
        vec[0]=view.position[0]+(float)(mouse.x-320)/32.0f;
        vec[1]=view.position[1]+(float)(240-mouse.y)/32.0f;
        vec[2]=0.0f;
  
        editor.objectnum=-1;
  
        for (count=0;count<level.numofobjects;count++)
          {
          subtractvectors(vec2,vec,level.object[count].position);
          if (vectorlength(vec2)<0.5f)
            editor.objectnum=count;
          }
        }
      }
    if (!menuinputkeyboard)
      {
      if (editor.objectnum!=-1)
        {
        vec[0]=1.0f;
        if (level.object[editor.objectnum].type==6 || level.object[editor.objectnum].type==7 || level.object[editor.objectnum].type==17)
          vec[0]=0.2f;

        if (keyboard[SCAN_HOME] && !prevkeyboard[SCAN_HOME])
        if (level.numofobjects>1)
          {
          count2=0;
          if (keyboard[SCAN_SHIFT])
            count2=2;
          memcpy(&level.object[255],&level.object[count2],sizeof(level.object[0]));
          memcpy(&level.object[count2],&level.object[editor.objectnum],sizeof(level.object[0]));
          memcpy(&level.object[editor.objectnum],&level.object[255],sizeof(level.object[0]));

          for (count=0;count<level.numofobjects;count++)
            {
            if (level.object[count].link==count2)
              level.object[count].link=editor.objectnum;
            else if (level.object[count].link==editor.objectnum)
              level.object[count].link=count2;
            }

          for (count=0;count<level.numofropes;count++)
            {
            if (level.rope[count].obj1==count2)
              level.rope[count].obj1=editor.objectnum;
            else if (level.rope[count].obj1==editor.objectnum)
              level.rope[count].obj1=count2;
            if (level.rope[count].obj2==count2)
              level.rope[count].obj2=editor.objectnum;
            else if (level.rope[count].obj2==editor.objectnum)
              level.rope[count].obj2=count2;
            }
          editor.objectnum=count2;
          }
        if (keyboard[SCAN_END] && !prevkeyboard[SCAN_END])
        if (level.numofobjects>2)
          {
          count2=1;
          if (keyboard[SCAN_SHIFT])
            count2=3;
          memcpy(&level.object[255],&level.object[count2],sizeof(level.object[0]));
          memcpy(&level.object[count2],&level.object[editor.objectnum],sizeof(level.object[0]));
          memcpy(&level.object[editor.objectnum],&level.object[255],sizeof(level.object[0]));

          for (count=0;count<level.numofobjects;count++)
            {
            if (level.object[count].link==count2)
              level.object[count].link=editor.objectnum;
            else if (level.object[count].link==editor.objectnum)
              level.object[count].link=count2;
            }

          for (count=0;count<level.numofropes;count++)
            {
            if (level.rope[count].obj1==count2)
              level.rope[count].obj1=editor.objectnum;
            else if (level.rope[count].obj1==editor.objectnum)
              level.rope[count].obj1=count2;
            if (level.rope[count].obj2==count2)
              level.rope[count].obj2=editor.objectnum;
            else if (level.rope[count].obj2==editor.objectnum)
              level.rope[count].obj2=count2;
            }
          editor.objectnum=count2;
          }
        if (keyboard[SCAN_LEFT] && !prevkeyboard[SCAN_LEFT])
        if (level.object[editor.objectnum].size[0]>vec[0])
          level.object[editor.objectnum].size[0]-=vec[0];
    
        if (keyboard[SCAN_RIGHT] && !prevkeyboard[SCAN_RIGHT])
        if (level.object[editor.objectnum].size[0]<16.0f)
          level.object[editor.objectnum].size[0]+=vec[0];
  
        if (keyboard[SCAN_DOWN] && !prevkeyboard[SCAN_DOWN])
        if (level.object[editor.objectnum].size[1]>vec[0])
          level.object[editor.objectnum].size[1]-=vec[0];
    
        if (keyboard[SCAN_UP] && !prevkeyboard[SCAN_UP])
        if (level.object[editor.objectnum].size[1]<16.0f)
          level.object[editor.objectnum].size[1]+=vec[0];

        if (keyboard[SCAN_LFT_BRACKET] && !prevkeyboard[SCAN_LFT_BRACKET])
          {
          if (!keyboard[SCAN_SHIFT])
            level.object[editor.objectnum].texturenum--;
          else
            level.object[editor.objectnum].texturenum-=10;
          if (level.object[editor.objectnum].texturenum<0)
            level.object[editor.objectnum].texturenum=0;
          }
        if (keyboard[SCAN_RGT_BRACKET] && !prevkeyboard[SCAN_RGT_BRACKET])
          {
          if (!keyboard[SCAN_SHIFT])
            level.object[editor.objectnum].texturenum++;
          else
            level.object[editor.objectnum].texturenum+=10;
          if (level.object[editor.objectnum].texturenum>255)
            level.object[editor.objectnum].texturenum=255;
          }
        }
  
      if (keyboard[SCAN_Q] && !prevkeyboard[SCAN_Q])
        {
        if (!keyboard[SCAN_SHIFT])
          editor.objecttype++;
        else
          editor.objecttype+=10;
        if (editor.objecttype>255)
          editor.objecttype=255;
        }
      if (keyboard[SCAN_Z] && !prevkeyboard[SCAN_Z])
        {
        if (!keyboard[SCAN_SHIFT])
          editor.objecttype--;
        else
          editor.objecttype-=10;
        if (editor.objecttype<0)
          editor.objecttype=0;
        }
      if (keyboard[SCAN_DELETE] && !prevkeyboard[SCAN_DELETE])
        deletelevelobject(editor.objectnum);
      if (keyboard[SCAN_F5] && !prevkeyboard[SCAN_F5])
        {
        setuplevel();
        setupgame();
        }
      }

    simcount=0;
    while (SDL_GetTicks()-simtimer>20 && simcount<5)
      {
      simcount++;
      count=SDL_GetTicks()-simtimer-20;
      simtimer=SDL_GetTicks()-count;

      if (!menuinputkeyboard)
        {
        if (keyboard[SCAN_W])
          view.position[1]+=0.2f;
        if (keyboard[SCAN_S])
          view.position[1]-=0.2f;
        if (keyboard[SCAN_A])
          view.position[0]-=0.2f;
        if (keyboard[SCAN_D])
          view.position[0]+=0.2f;
        }
      }
    }

  resetmenuitems();
  }
コード例 #9
0
ファイル: ropeedit.c プロジェクト: Asmageddon/gish
void editlevelrope(void)
  {
  int count,count2;
  int simtimer;
  int simcount;
  float vec[3],vec2[3];

  ropeedit.numofpoints=0;
  for (count=0;count<level.numofobjects;count++)
    {
    if (level.object[count].type>=2 && level.object[count].type<=5)
      {
      for (count2=0;count2<4;count2++)
        {
        if (count2==0 || count2==3)
          vec[0]=level.object[count].position[0]-level.object[count].size[0]*0.5f;
        else
          vec[0]=level.object[count].position[0]+level.object[count].size[0]*0.5f;
        if (count2<2)
          vec[1]=level.object[count].position[1]+level.object[count].size[1]*0.5f;
        else
          vec[1]=level.object[count].position[1]-level.object[count].size[1]*0.5f;
        vec[2]=0.0f;
        copyvector(ropeedit.point[ropeedit.numofpoints].position,vec);
        ropeedit.point[ropeedit.numofpoints].objectnum=count;
        ropeedit.point[ropeedit.numofpoints].particlenum=count2;
        ropeedit.numofpoints++;

        copyvector(level.object[count].vertex[count2],vec);
        }
      }
    if (level.object[count].type>=6 && level.object[count].type<=7)
      {
      for (count2=0;count2<4;count2++)
        {
        vec[0]=level.object[count].position[0];
        vec[1]=level.object[count].position[1];
        if (count2==0)
          vec[0]=level.object[count].position[0]+level.object[count].size[0]*0.5f;
        if (count2==1)
          vec[1]=level.object[count].position[1]-level.object[count].size[1]*0.5f;
        if (count2==2)
          vec[0]=level.object[count].position[0]-level.object[count].size[0]*0.5f;
        if (count2==3)
          vec[1]=level.object[count].position[1]+level.object[count].size[1]*0.5f;
        vec[2]=0.0f;
        copyvector(ropeedit.point[ropeedit.numofpoints].position,vec);
        ropeedit.point[ropeedit.numofpoints].objectnum=count;
        ropeedit.point[ropeedit.numofpoints].particlenum=count2*4;
        ropeedit.numofpoints++;

        copyvector(level.object[count].vertex[count2],vec);
        }

      count2=4;
      vec[0]=level.object[count].position[0];
      vec[1]=level.object[count].position[1];
      vec[2]=0.0f;

      copyvector(ropeedit.point[ropeedit.numofpoints].position,vec);
      ropeedit.point[ropeedit.numofpoints].objectnum=count;
      ropeedit.point[ropeedit.numofpoints].particlenum=16;
      ropeedit.numofpoints++;

      copyvector(level.object[count].vertex[count2],vec);
      }
    if (level.object[count].type==8)
      {
      vec[0]=level.object[count].position[0];
      vec[1]=level.object[count].position[1];
      vec[2]=0.0f;
      copyvector(ropeedit.point[ropeedit.numofpoints].position,vec);
      ropeedit.point[ropeedit.numofpoints].objectnum=count;
      ropeedit.point[ropeedit.numofpoints].particlenum=0;
      ropeedit.numofpoints++;
      copyvector(level.object[count].vertex[0],vec);
      }
    }
  ropeedit.pointnum=-1;

  simtimer=SDL_GetTicks();

  resetmenuitems();

  while (!menuitem[0].active && !windowinfo.shutdown)
    {
    glClearColor(0.0f,0.0f,0.0f,0.0f);
    glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
    glStencilMask(~0);
    glClearStencil(0);
    glClear(GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
    glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_FALSE);
    glStencilMask(0);

    setuptextdisplay();
    glColor3fv(level.ambient[3]);
    if (level.background[0]!=0)
      displaybackground(660);

    numofmenuitems=0;
    createmenuitem("",0,0,16,1.0f,1.0f,1.0f,1.0f);
    setmenuitem(MO_HOTKEY,SCAN_ESC);

    checksystemmessages();
    checkkeyboard();
    checkmouse();
    checkmenuitems();

    //setupperspectiveviewport(0,0,640,480,1.0f,100.0f);
    setuporthoviewport(0,0,640,480,10.0f,7.5f,20.0f);
    setupviewpoint(view.position,view.orientation);

    setupframelighting();

    rendershadows();

    glEnable(GL_ALPHA_TEST);
    glAlphaFunc(GL_GREATER,0.0f);

    renderlevelback();
    renderlevel();
    renderlevelobjects();
    renderlevelfore();

    glDisable(GL_ALPHA_TEST);

    renderropeedit();

    setuptextdisplay();

    drawtext(TXT_NUMOFROPES":/i",0,368,16,1.0f,1.0f,1.0f,1.0f,level.numofropes);
    drawtext(TXT_TEXTURENUM":/i",0,384,16,1.0f,1.0f,1.0f,1.0f,ropeedit.texturenum);

    drawmenuitems();

    drawmousecursor(768+font.cursornum,mouse.x,mouse.y,16,1.0f,1.0f,1.0f,1.0f);

    SDL_GL_SwapBuffers();

    vec[0]=view.position[0]+(float)(mouse.x-320)/32.0f;
    vec[1]=view.position[1]+(float)(240-mouse.y)/32.0f;
    vec[2]=0.0f;

    ropeedit.pointhighlight=-1;
    for (count=0;count<ropeedit.numofpoints;count++)
      {
      subtractvectors(vec2,ropeedit.point[count].position,vec);
      if (vectorlength(vec2)<0.25f)
        ropeedit.pointhighlight=count;
      }

    if (ropeedit.pointnum==-1)
      {
      if (mouse.lmb && !prevmouse.lmb)
      if (ropeedit.pointhighlight!=-1)
        ropeedit.pointnum=ropeedit.pointhighlight;
      }
    else
      {
      if (mouse.lmb && !prevmouse.lmb)
        {
        if (ropeedit.pointhighlight!=-1)
        if (ropeedit.point[ropeedit.pointnum].objectnum!=ropeedit.point[ropeedit.pointhighlight].objectnum)
          {
          level.rope[level.numofropes].type=1;
          if (keyboard[SCAN_2])
            level.rope[level.numofropes].type=2;
          if (keyboard[SCAN_3])
            level.rope[level.numofropes].type=3;
          if (keyboard[SCAN_4])
            level.rope[level.numofropes].type=4;
          if (keyboard[SCAN_5])
            level.rope[level.numofropes].type=5;
          if (keyboard[SCAN_6])
            level.rope[level.numofropes].type=6;
          if (keyboard[SCAN_7])
            level.rope[level.numofropes].type=7;
          if (keyboard[SCAN_8])
            level.rope[level.numofropes].type=8;
          if (keyboard[SCAN_9])
            level.rope[level.numofropes].type=9;
          if (keyboard[SCAN_0])
            level.rope[level.numofropes].type=10;
          level.rope[level.numofropes].obj1=ropeedit.point[ropeedit.pointnum].objectnum;
          level.rope[level.numofropes].obj1part=ropeedit.point[ropeedit.pointnum].particlenum;
  
          level.rope[level.numofropes].obj2=ropeedit.point[ropeedit.pointhighlight].objectnum;
          level.rope[level.numofropes].obj2part=ropeedit.point[ropeedit.pointhighlight].particlenum;
          level.rope[level.numofropes].texturenum=ropeedit.texturenum;
  
          level.numofropes++;
          }
        ropeedit.pointnum=-1;
        }
      }

    if (mouse.rmb && !prevmouse.rmb)
      {
      for (count=0;count<level.numofropes;count++)
        {
        if (ropeedit.point[ropeedit.pointhighlight].objectnum==level.rope[count].obj1 && ropeedit.point[ropeedit.pointhighlight].particlenum==level.rope[count].obj1part)
          deletelevelrope(count);
        }
      for (count=0;count<level.numofropes;count++)
        {
        if (ropeedit.point[ropeedit.pointhighlight].objectnum==level.rope[count].obj2 && ropeedit.point[ropeedit.pointhighlight].particlenum==level.rope[count].obj2part)
          deletelevelrope(count);
        }
      /*
      for (count=0;count<level.numofropes;count++)
        {
        if (pointintersectline(vec,level.object[level.rope[count].obj1].vertex[level.rope[count].obj1part],level.object[level.rope[count].obj2].vertex[level.rope[count].obj2part],0.25f))
          deletelevelrope(count);
        }
      */
      }

    simcount=0;
    while (SDL_GetTicks()-simtimer>20 && simcount<5)
      {
      simcount++;
      count=SDL_GetTicks()-simtimer-20;
      simtimer=SDL_GetTicks()-count;

      if (!menuinputkeyboard)
        {
        if (keyboard[SCAN_W])
          view.position[1]+=0.2f;
        if (keyboard[SCAN_S])
          view.position[1]-=0.2f;
        if (keyboard[SCAN_A])
          view.position[0]-=0.2f;
        if (keyboard[SCAN_D])
          view.position[0]+=0.2f;
        }
      }

    if (keyboard[SCAN_Q] && !prevkeyboard[SCAN_Q])
    if (ropeedit.texturenum<3)
      ropeedit.texturenum++;

    if (keyboard[SCAN_Z] && !prevkeyboard[SCAN_Z])
    if (ropeedit.texturenum>0)
      ropeedit.texturenum--;
    }

  resetmenuitems();
  }
コード例 #10
0
ファイル: world.c プロジェクト: matthewearl/Raycaster
/* root of the monster's thinking - make a decision about
 * what to do
 */
void
monster_think ( world_t *world, entity_t *ent )
{
	vector2d_t dir;
	float dist;

	ent->wishdir.x = ent->wishdir.y = 0.0f;
	
	ent->think = monster_think;
	ent->nextthink = world->time + MONSTER_WIT;
	
	if(!world->playerentity)
	{
		ent->texture = ent->frames[MONSTERFRAME_STAND];
		ent->shoottime = -1;
		return;
	}
	if(!pointcanseepoint(world->raycaster,
			&world->playerentity->pos,world->playerentity->vpos+VIEW_HEIGHT,
			&ent->pos,ent->vpos+MONSTER_MUZZLEHEIGHT))
	{
		ent->texture = ent->frames[MONSTERFRAME_STAND];
		ent->nextthink = world->time + MONSTER_WIT*5;	/* monster is not very alert in the absence of
					   the player */
		ent->shoottime = -1;
		return;
	}
	vectorsubtract(&world->playerentity->pos,&ent->pos,&dir);
	dist = vectorlength(&dir);
	vectorscale(&dir,1.0f/dist,&dir);

	if(dist > MONSTER_SHOOTRANGE)
	{
		if((world->time/276)%2)
		{
			ent->texture = ent->frames[MONSTERFRAME_WALK1];
		} else
		{
			ent->texture = ent->frames[MONSTERFRAME_WALK2];
		}
		vectorcopy(&ent->wishdir,&dir);
		ent->shoottime = -1;		/* if we back off and re-approach
						 * the monster still has to take aim
						 */
		return;
	} else if(ent->shoottime > 0 && world->time > ent->shoottime )
	{
		ent->texture = ent->frames[MONSTERFRAME_FIRE];
		ent->shoottime = world->time + MONSTER_RELOADTIME;
		ent->think = monster_aimpose;				/* return to aim pose */
		ent->nextthink = world->time + MONSTER_FIRETIME;
		return;
	} else
	{
		if(ent->shoottime < 0)
		{
			ent->texture = ent->frames[MONSTERFRAME_AIM];
			ent->shoottime = world->time + MONSTER_AIMTIME;
		}
	}
}
コード例 #11
0
ファイル: gameobject.c プロジェクト: SysLord/gish
void createrope(int type,int particlenum,int particlenum2,int objectnum,int objectnum2,int texturenum)
  {
  int count/*,count2*/;
  int length;
  float vec[3],vec2[3];
  float mass;

  if (type<5)
    {
    if (type==1)
      mass=0.125f;
    if (type==2)
      mass=0.25f;
    if (type==3)
      mass=1.0f;
    if (type==4)
      mass=2.0f;

    subtractvectors(vec,particle[particlenum2].position,particle[particlenum].position);
    length=vectorlength(vec);
    if (length<1)
      length=1;
    length*=2;
  
    scalevector(vec,vec,1.0f/(float)length);
    copyvector(vec2,particle[particlenum].position);
    addvectors(vec2,vec2,vec);
    createparticle(4,vec2,NULL,mass,-1,10000);
    createbond(particlenum,numofparticles-1,4,numofropes);
    rope[numofropes].type=type;
    rope[numofropes].part1=particlenum;
    rope[numofropes].part2=numofparticles-1;
    if (type<3)
      rope[numofropes].texturenum=360;
    else
      rope[numofropes].texturenum=361;
    numofropes++;
  
    for (count=1;count<length-1;count++)
      {
      addvectors(vec2,vec2,vec);
      createparticle(4,vec2,NULL,mass,-1,10000);
      createbond(numofparticles-2,numofparticles-1,4,numofropes);
      rope[numofropes].type=type;
      rope[numofropes].part1=numofparticles-2;
      rope[numofropes].part2=numofparticles-1;
      if (type<3)
        rope[numofropes].texturenum=360;
      else
        rope[numofropes].texturenum=361;
      numofropes++;
      }
    createbond(numofparticles-1,particlenum2,4,numofropes);
    rope[numofropes].type=type;
    rope[numofropes].part1=numofparticles-1;
    rope[numofropes].part2=particlenum2;
    if (type<3)
      rope[numofropes].texturenum=360;
    else
      rope[numofropes].texturenum=361;
    numofropes++;
    }
  else 
    {
    if (type<10)
      createbond(particlenum,particlenum2,7,numofropes);
    else
      createbond(particlenum,particlenum2,8,numofropes);

    if (type<9)
      {
      if (level.object[objectnum2].type==6 || level.object[objectnum2].type==7)
        {
        subtractvectors(vec,level.object[objectnum2].position,particle[particlenum].position);
        subtractvectors(vec2,particle[particlenum2].position,object[objectnum2].position);
        rope[numofropes].range=vectorlength(vec2);
  
        bond[numofbonds-1].length=vectorlength(vec)-rope[numofropes].range;
        bond[numofbonds-1].maxlength=vectorlength(vec)-rope[numofropes].range;
        }
      if (level.object[objectnum2].type>=2 && level.object[objectnum2].type<6)
        {
        subtractvectors(vec2,level.object[objectnum2].position,object[objectnum].position);
        subtractvectors(vec,particle[particlenum2].position,particle[particlenum].position);
  
        if (fabs(vec2[0])>fabs(vec2[1]))
          vec[1]=0.0f;
        else
          vec[0]=0.0f;
  
        normalizevector(vec,vec);
  
        if (type==5 || type==9)
          copyvector(vec2,particle[particlenum2].position);
        if (type==6 || type==8)
          scaleaddvectors(vec2,particle[particlenum2].position,vec,-level.object[objectnum].lightcolor[0]*0.5f);
        if (type==7)
          scaleaddvectors(vec2,particle[particlenum2].position,vec,-level.object[objectnum].lightcolor[0]);
        subtractvectors(vec2,particle[particlenum].position,vec2);
        bond[numofbonds-1].length=vectorlength(vec2);
        bond[numofbonds-1].maxlength=vectorlength(vec2);
  
        if (type==5)
          scaleaddvectors(vec2,particle[particlenum2].position,vec,level.object[objectnum].lightcolor[0]);
        if (type==6 || type==8)
          scaleaddvectors(vec2,particle[particlenum2].position,vec,level.object[objectnum].lightcolor[0]*0.5f);
        if (type==7 || type==9)
          copyvector(vec2,particle[particlenum2].position);
        subtractvectors(vec2,particle[particlenum].position,vec2);
        rope[numofropes].range=(vectorlength(vec2)-bond[numofbonds-1].maxlength)*0.5f;
        }
      }

    rope[numofropes].type=type;
    rope[numofropes].part1=particlenum;
    rope[numofropes].part2=particlenum2;
    rope[numofropes].bondnum=numofbonds-1;
    if (type==5)
      rope[numofropes].angle=0.0f;
    if (type==6)
      rope[numofropes].angle=pi/2.0f;
    if (type==7)
      rope[numofropes].angle=pi;
    if (type==8)
      rope[numofropes].angle=3.0f*pi/2.0f;

    rope[numofropes].cycle=level.object[objectnum].lightcolor[1];
    rope[numofropes].cyclelength=level.object[objectnum].lightcolor[2];
    rope[numofropes].cyclecount=0.0f;
    rope[numofropes].link=level.object[objectnum].link;
    if (texturenum==0)
      rope[numofropes].texturenum=0;
    if (texturenum==1)
      rope[numofropes].texturenum=362;
    if (texturenum==2)
      rope[numofropes].texturenum=362;
    if (texturenum==3)
      rope[numofropes].texturenum=362;

    numofropes++;
    }
  }
コード例 #12
0
ファイル: ai.c プロジェクト: Luccifer/GishSources
void objectai(int objectnum)
  {
  float vec[3];
  float intersectpoint[3];
  float normal[3];
  float scale;

  object[objectnum].axis[0]=0.0f;
  object[objectnum].axis[1]=0.0f;
  object[objectnum].button=0;

  if (object[objectnum].type==1)
  if (game.levelnum==34)
    {
    /*
    object[objectnum].axis[0]=-object[0].axis[0];
    object[objectnum].axis[1]=object[0].axis[0];
    object[objectnum].button=object[0].button;
    */
    subtractvectors(vec,object[0].position,object[objectnum].position);
    if (vec[0]<-0.5f)
      object[objectnum].axis[0]=-1.0f;
    if (vec[0]>0.5f)
      object[objectnum].axis[0]=1.0f;
    if (vectorlength(vec)<2.0f)
      object[objectnum].button|=8;
    /*
    subtractvectors(vec,object[2].position,object[objectnum].position);
    if (vectorlength(vec)>3.0f)
      object[objectnum].button=1;
    */
    }
  if (object[objectnum].type==4)
    {
    if (object[0].idata[0]==0)
    if (fabs(object[0].position[0]-object[objectnum].position[0])<12.0f)
    if (fabs(object[0].position[1]-object[objectnum].position[1])<8.0f)
      {
      if (object[objectnum].beasttype!=7 && object[objectnum].beasttype!=13)
        {
        subtractvectors(vec,object[0].position,object[objectnum].position);
        if ((vec[0]>-2.5f && vec[0]<0.0f && object[objectnum].direction==0) || (vec[0]<2.5f && vec[0]>0.0f && object[objectnum].direction==1))
        if (fabs(vec[1])<1.0f)
          object[objectnum].button|=1;

        //if (object[objectnum].beasttype==12)
        //if ((game.framenum&511)==0)
        //  object[objectnum].button|=2;

        if ((rnd()&7)!=7)
          {
          if (object[0].position[0]<object[objectnum].position[0])
            object[objectnum].axis[0]-=1.0f;
          else
            object[objectnum].axis[0]+=1.0f;
  
          if (object[objectnum].beasttype!=12)
          if ((rnd()&255)==0)
            object[objectnum].button|=2;

          if (object[objectnum].beasttype==12)
          if ((rnd()&255)==0 && (rnd()&1)==0)
            object[objectnum].button|=2;
          }
        }
      else
        {
        subtractvectors(vec,object[0].position,object[objectnum].position);
        if (vec[0]>-8.0f && vec[0]<8.0f)
        if (fabs(vec[1])<6.0f)
        if ((game.framenum&127)==0)
          object[objectnum].button|=1;
        /*
          if (object[0].position[0]<object[objectnum].position[0]-5.0f)
            object[objectnum].axis[0]-=1.0f;
          if (object[0].position[0]>object[objectnum].position[0]+5.0f)
            object[objectnum].axis[0]+=1.0f;
        */
        //if (object[0].position[0]<object[objectnum].position[0])
        if (object[0].position[0]<object[objectnum].position[0]-5.0f)
          {
          scaleaddvectors(vec,object[objectnum].position,object[objectnum].orientation[0],-3.0f);
          scaleaddvectors(vec,vec,object[objectnum].orientation[1],-2.0);
          if (lineintersectlevel(intersectpoint,normal,&scale,object[objectnum].position,vec))
            object[objectnum].axis[0]-=1.0f;
          else
            {
            if (object[objectnum].velocity[0]<-0.01f)
              object[objectnum].axis[0]+=1.0f;
            }
          }
        if (object[0].position[0]>object[objectnum].position[0]+5.0f)
          {
          scaleaddvectors(vec,object[objectnum].position,object[objectnum].orientation[0],3.0f);
          scaleaddvectors(vec,vec,object[objectnum].orientation[1],-2.0f);
          if (lineintersectlevel(intersectpoint,normal,&scale,object[objectnum].position,vec))
            object[objectnum].axis[0]+=1.0f;
          else
            {
            if (object[objectnum].velocity[0]>0.01f)
              object[objectnum].axis[0]-=1.0f;
            }
          }
        }
      }
    }

  if (object[objectnum].axis[0]<-1.0f)
    object[objectnum].axis[0]=-1.0f;
  if (object[objectnum].axis[0]>1.0f)
    object[objectnum].axis[0]=1.0f;
  if (object[objectnum].axis[1]<-1.0f)
    object[objectnum].axis[1]=-1.0f;
  if (object[objectnum].axis[1]>1.0f)
    object[objectnum].axis[1]=1.0f;
  }
コード例 #13
0
ファイル: objfunc.c プロジェクト: miquella/gish
void objectsound(int objectnum)
  {
  int x,y;
  float vec[3];
  float scale;
  float pitch;

  x=object[objectnum].position[0];
  y=object[objectnum].position[1];
  if (block[level.foregrid[y][x]].density!=0.0f)
    {
    x=object[objectnum].prevposition[0];
    y=object[objectnum].prevposition[1];
    if (block[level.foregrid[y][x]].density==0.0f)
      {
      pitch=4.0f/object[objectnum].mass;

      if (pitch<0.5f)
        pitch=0.5f;

      if (pitch>1.0f)
        pitch=1.0f;

      scale=vectorlength(object[objectnum].velocity)*2.5f;

      x=object[objectnum].position[0];
      y=object[objectnum].position[1];

      if (block[level.foregrid[y][x]].foredamage==0)
        playsound(17,object[objectnum].position,NULL,scale,0,pitch,objectnum,3);
      else
        playsound(18,object[objectnum].position,NULL,scale,0,pitch,objectnum,3);
      }
    }
  if (object[objectnum].type==2 || object[objectnum].type==3)
    {
    subtractvectors(vec,object[objectnum].velocity,object[objectnum].prevvelocity);
    scale=vectorlength(vec);
    if (scale>0.025f)
      {
      pitch=1.0f/(object[objectnum].mass*0.2f);

      scale*=(1.0f/pitch);

      if (pitch<0.2f)
        pitch=0.2f;

      if (pitch>1.0f)
        pitch=1.0f;

      playsound(1,object[objectnum].position,NULL,scale*5.0f,0,pitch,objectnum,0);
      }
    }
  /*
  if (object[objectnum].type==2 || object[objectnum].type==3)
    {
    //scale=object[objectnum].frictionapplied;

    if (object[objectnum].numoforientations!=0)
      {
      vec[0]=vectorlength(object[objectnum].velocity);
      vec[1]=dotproduct(object[objectnum].velocity,object[objectnum].orientation[1]);
      scale=sqrt(vec[0]*vec[0]-vec[1]*vec[1]);
      }
    else
      scale=0.0f;

    if (scale>0.01f)
      {
      pitch=1.0f/(object[objectnum].mass*0.2f);
      scale*=(1.0f/pitch);

      if (pitch<0.2f)
        pitch=0.2f;

      if (pitch>1.0f)
        pitch=1.0f;

      if (object[objectnum].soundnum[1]==-1)
        playsound(6,object[objectnum].position,NULL,scale*5.0f,1,pitch,objectnum,1);
      }
    if (object[objectnum].soundnum[1]!=-1)
      {
      if (scale<0.005f)
        deletesound(object[objectnum].soundnum[1]);
      else
        {
        pitch=1.0f/(object[objectnum].mass*0.2f);
        scale*=(1.0f/pitch);

        alSourcef(sound[object[objectnum].soundnum[1]].alname,AL_GAIN,scale*5.0f);
        }
      }
    }
  */
  if (object[objectnum].type==4)
    {
    subtractvectors(vec,object[objectnum].velocity,object[objectnum].prevvelocity);
    scale=vectorlength(vec);
    if (scale>0.025f)
      {
      pitch=1.0f/(object[objectnum].mass*0.2f);

      scale*=(2.0f/pitch);

      if (pitch<0.2f)
        pitch=0.2f;

      if (pitch>1.0f)
        pitch=1.0f;

      playsound(2,object[objectnum].position,NULL,scale*5.0f,0,pitch,objectnum,0);
      }
    }
  if (object[objectnum].type==1)
    {
    subtractvectors(vec,object[objectnum].velocity,object[objectnum].prevvelocity);
    scale=vectorlength(vec);
    if (scale>0.025f)
      {
      if ((object[objectnum].button&8)==0)
        playsound(5,object[objectnum].position,NULL,scale*7.0f,0,1.0f,objectnum,0);
      else
        playsound(2,object[objectnum].position,NULL,scale*7.0f,0,1.0f,objectnum,0);
      }
    }

  copyvector(object[objectnum].prevvelocity,object[objectnum].velocity);
  object[objectnum].frictionapplied=0.0f;
  }
コード例 #14
0
ファイル: objfunc.c プロジェクト: miquella/gish
void objectcycle(void)
  {
  int count,count2,count3,count4;
  int x,y;
  float vec[3],vec2[3];
  float veclength,bondlength;
  float angle,spin;
  float intersectpoint[3];
  float normal[3];
  float scale,scale2;

  for (count=0;count<numofropes;count++)
    {
    updateogg();

    if (rope[count].type>=5 && rope[count].type<9)
      {
      bond[rope[count].bondnum].length=bond[rope[count].bondnum].maxlength+(rope[count].range-cos(rope[count].angle)*rope[count].range);

      if (rope[count].cyclelength==0.0f)
        {
        if (rope[count].link==-1 || object[rope[count].link].idata[0]==1)
          {
          rope[count].angle+=2.0f*pi/(50.0f*rope[count].cycle);
          if (rope[count].angle>2.0f*pi)
            rope[count].angle-=2.0f*pi;
          }
        }
      else
        {
        if (rope[count].link==-1)
          {
          if (rope[count].cyclecount<rope[count].cyclelength*2.0f*pi)
            {
            rope[count].angle+=2.0f*pi/(50.0f*rope[count].cycle);
            if (rope[count].angle>2.0f*pi)
              rope[count].angle-=2.0f*pi;
            rope[count].cyclecount+=2.0f*pi/(50.0f*rope[count].cycle);
            }
          }
        else
          {
          count2=0;
          if (object[rope[count].link].idata[0]==1 && rope[count].cyclecount==0.0f)
            count2=1;
          if (rope[count].cyclecount>0.0f && rope[count].cyclecount<rope[count].cyclelength*2.0f*pi)
            count2=1;
          if (rope[count].cyclecount>rope[count].cyclelength*2.0f*pi+2.0f*pi/(50.0f*rope[count].cycle))
            count2=1;
          if (object[rope[count].link].idata[0]==0 && rope[count].cyclecount>0.0f)
            count2=1;

          if (count2==1)
            {
            rope[count].angle+=2.0f*pi/(50.0f*rope[count].cycle);
            if (rope[count].angle>2.0f*pi)
              rope[count].angle-=2.0f*pi;
            rope[count].cyclecount+=2.0f*pi/(50.0f*rope[count].cycle);
            if (rope[count].cyclecount>=rope[count].cyclelength*4.0f*pi)
              rope[count].cyclecount=0.0f;
            }
          }
        }
      }
    }

  for (count=0;count<numofobjects;count++)
    {
    updateogg();

    if (object[count].damagedelay>0)
      object[count].damagedelay--;

    if (object[count].numofparticles!=0)
      {
      zerovector(object[count].velocity);
      for (count2=0;count2<object[count].numofparticles;count2++)
        addvectors(object[count].velocity,object[count].velocity,particle[object[count].particle[count2]].velocity);
      scalevector(object[count].velocity,object[count].velocity,1.0f/(float)object[count].numofparticles);
  
      zerovector(object[count].position);
      for (count2=0;count2<object[count].numofparticles;count2++)
        addvectors(object[count].position,object[count].position,particle[object[count].particle[count2]].position);
      scalevector(object[count].position,object[count].position,1.0f/(float)object[count].numofparticles);
      }

    objectsound(count);

    if (object[count].link!=-1)
      {
      if (object[count].lighttype==1 || object[count].lighttype==3)
        {
        if (object[object[count].link].idata[0])
          object[count].lighton=0;
        else
          object[count].lighton=1;
        }
      if (object[count].lighttype==2)
        {
        if (object[object[count].link].idata[0])
          object[count].lighton=1;
        else
          object[count].lighton=0;
        }
      }
    if (object[count].lighttype==3)
      {
      object[count].lightintensity+=((rand()&255)/255.0f-0.5f)*0.2f*object[count].lightintensitymax;
      if (object[count].lightintensity<object[count].lightintensitymax*0.5f)
        object[count].lightintensity=object[count].lightintensitymax*0.5f;
      if (object[count].lightintensity>object[count].lightintensitymax*1.5f)
        object[count].lightintensity=object[count].lightintensitymax*1.5f;
      }

    if (object[count].type==9)
    if (object[count].idata[0]==0 || object[count].idata[1]==0)
      {
      vec[1]=particle[object[count].particle[6]].position[1]-particle[object[count].particle[4]].position[1];
      vec[1]*=0.08f;
      vec[1]-=particle[object[count].particle[4]].velocity[1];
      particle[object[count].particle[4]].velocity[1]+=vec[1];

      vec[1]=particle[object[count].particle[6]].position[1]-particle[object[count].particle[5]].position[1];
      vec[1]*=0.08f;
      vec[1]-=particle[object[count].particle[5]].velocity[1];
      particle[object[count].particle[5]].velocity[1]+=vec[1];

      if (particle[object[count].particle[4]].position[1]>particle[object[count].particle[6]].position[1]-0.1f)
      if (particle[object[count].particle[5]].position[1]>particle[object[count].particle[6]].position[1]-0.1f)
        {
        if (object[count].idata[0]==1)
          playsound(14,object[count].position,NULL,0.2f,0,1.0f,-1,0);
        object[count].idata[0]=0;
        }
      if (particle[object[count].particle[4]].position[1]<particle[object[count].particle[6]].position[1]-0.2f)
      if (particle[object[count].particle[5]].position[1]<particle[object[count].particle[6]].position[1]-0.2f)
        {
        if (object[count].idata[0]==0)
          playsound(14,object[count].position,NULL,0.2f,0,1.0f,-1,0);
        object[count].idata[0]=1;
        }

      if (object[count].link!=-1)
        if (object[object[count].link].idata[0]==1)
          object[count].idata[0]=1;
      }
    if (object[count].type==9)
    if (object[count].idata[0]==1 && object[count].idata[1]==1)
      {
      vec[1]=particle[object[count].particle[6]].position[1]-0.375f-particle[object[count].particle[4]].position[1];
      vec[1]*=0.08f;
      vec[1]-=particle[object[count].particle[4]].velocity[1];
      particle[object[count].particle[4]].velocity[1]+=vec[1];

      vec[1]=particle[object[count].particle[6]].position[1]-0.375f-particle[object[count].particle[5]].position[1];
      vec[1]*=0.08f;
      vec[1]-=particle[object[count].particle[5]].velocity[1];
      particle[object[count].particle[5]].velocity[1]+=vec[1];
      }
    if (object[count].type==16)
    if (object[count].idata[0]==0 || object[count].idata[1]==0)
      {
      object[count].idata[0]=0;
      if (fabs(object[0].position[0]-object[count].position[0])<object[count].size[0]*0.5f)
      if (fabs(object[0].position[1]-object[count].position[1])<object[count].size[1]*0.5f)
        {
        object[count].idata[0]=1;
        if (object[count].idata[1]==2)
          {
          if ((rand()&3)==0)
            playsound(8,object[count].position,NULL,1.0f,0,1.0f,-1,0);
          else
            playsound(9,object[count].position,NULL,1.0f,0,1.0f,-1,0);
          game.bonus[8]++;
          }
        }
      if (level.gametype==11)
      if (fabs(object[1].position[0]-object[count].position[0])<object[count].size[0]*0.5f)
      if (fabs(object[1].position[1]-object[count].position[1])<object[count].size[1]*0.5f)
        {
        object[count].idata[0]=1;
        if (object[count].idata[1]==2)
          {
          if ((rand()&3)==0)
            playsound(8,object[count].position,NULL,1.0f,0,1.0f,-1,0);
          else
            playsound(9,object[count].position,NULL,1.0f,0,1.0f,-1,0);
          game.bonus[8]++;
          }
        }
      }
    if (object[count].type==15)
      {
      if (object[count].link==-1 || object[object[count].link].idata[0]==1)
      if ((game.framenum&255)==128)
        {
        createwheel(object[count].position,object[count].size[0],object[count].size[1],object[count].mass,0.8f,0);
        object[numofobjects-1].texturenum=object[count].texturenum;
        object[numofobjects-1].timetolive=512;
        object[numofobjects-1].link=-1;
        for (count2=0;count2<object[numofobjects-1].numofparticles;count2++)
          {
          particle[object[numofobjects-1].particle[count2]].velocity[0]=object[count].lightcolor[0]/PHYSICSCYCLE;
          particle[object[numofobjects-1].particle[count2]].velocity[1]=object[count].lightcolor[1]/PHYSICSCYCLE;
          }
        }
      }

    if (object[count].type==10)
      {
      if (object[count].rotate==0 || object[count].rotate==2)
        count3=1;
      else
        count3=0;
      for (count2=1;count2<=2;count2++)
        {
        vec[count3]=particle[object[count].particle[4]].position[count3]-particle[object[count].particle[count2]].position[count3];

        if (vec[count3]<0.0f)
          vec[count3]+=0.25f;
        else
          vec[count3]-=0.25f;

        if (vec[count3]<0.0f)
          {
          vec[2]=-0.04f;
          if (vec[2]<vec[count3])
            vec[2]=vec[count3];
          }
        else
          {
          vec[2]=0.04f;
          if (vec[2]>vec[count3])
            vec[2]=vec[count3];
          }


        vec[2]-=particle[object[count].particle[count2]].velocity[count3];

        particle[object[count].particle[count2]].velocity[count3]+=vec[2];

        if (particle[object[count].particle[count2]].position[count3]>particle[object[count].particle[4]].position[count3]+0.25f)
          particle[object[count].particle[count2]].position[count3]=particle[object[count].particle[4]].position[count3]+0.25f;
        if (particle[object[count].particle[count2]].position[count3]<particle[object[count].particle[4]].position[count3]-0.25f)
          particle[object[count].particle[count2]].position[count3]=particle[object[count].particle[4]].position[count3]-0.25f;
        }

      vec[0]=particle[object[count].particle[4]].position[count3]-particle[object[count].particle[1]].position[count3];
      if (object[count].rotate==3)
        vec[0]=-vec[0];

      if (vec[0]<-0.2f)
        {
        if (object[count].idata[0]==1)
          playsound(14,object[count].position,NULL,0.2f,0,1.0f,-1,0);
        object[count].idata[0]=0;
        }
      if (vec[0]>0.2f)
        {
        if (object[count].idata[0]==0)
          playsound(14,object[count].position,NULL,0.2f,0,1.0f,-1,0);
        object[count].idata[0]=1;
        }

      if (object[count].link!=-1)
        if (object[object[count].link].idata[0]==1)
          object[count].idata[0]=1;
      }
    if (object[count].type==1)
      {
      if (count!=0)
      if (level.gametype==0 && game.levelnum==34)
        objectai(count);

      for (count2=0;count2<16;count2++)
        {
        x=particle[object[count].particle[count2]].position[0];
        y=particle[object[count].particle[count2]].position[1];

        if (x>0 && x<254)
        if (y>0 && y<254)
          {
          if (block[level.foregrid[y][x]].density!=0.0f)
          if ((rand()&255)==0)
            {
            createparticle(5,object[count].position,object[count].velocity,0.125f*0.25f,-1,100+(rand()&63));
            particle[numofparticles-1].rendersize=0.125+(float)(rand()&127)/1000.0f;
            particle[numofparticles-1].texturenum=366;
            }
          if (block[level.foregrid[y][x]].foredamage!=0)
            object[count].hitpoints-=block[level.foregrid[y][x]].foredamage;
          if ((level.grid[y][x]>=248 && level.grid[y][x]<=255 && level.gridmod[y][x]==0) || (level.grid[y][x]>=240 && level.grid[y][x]<=247 && level.gridmod[y][x]==2))
            {
            vec[0]=(float)x+0.5f;
            vec[1]=(float)y+0.5f;
            vec[2]=0.0f;
            subtractvectors(vec2,vec,particle[object[count].particle[count2]].position);
            if (vectorlength(vec2)<0.45f)
              {
              scale=1.0f;

              if (level.grid[y][x]==251 || (level.grid[y][x]==251-8 && level.gridmod[y][x]==2))
                {
                if (game.numoflives<99 && game.difficulty!=3)
                  {
                  game.numoflives++;
                  createsprite(0,vec);
                  sprintf(sprite[numofsprites-1].text,"1UP");
                  sprite[numofsprites-1].size=14;
                  }
                else
                  {
                  game.score[0]+=1000;
                  createsprite(1000,vec);
                  }
                }
              if (level.grid[y][x]==252 || (level.grid[y][x]==252-8 && level.gridmod[y][x]==2))
                {
                if (object[count].hitpoints<900)
                  object[count].hitpoints+=100;
                else
                  object[count].hitpoints=1000;
                }
              if (level.grid[y][x]==253 || (level.grid[y][x]==253-8 && level.gridmod[y][x]==2))
                {
                if (level.gametype!=15)
                  {
                  game.score[0]+=50;
                  createsprite(50,vec);
                  }
                else
                  game.score[count]++;
                }
              if (level.grid[y][x]==254 || (level.grid[y][x]==254-8 && level.gridmod[y][x]==2))
                {
                game.score[0]+=100;
                createsprite(100,vec);
                if (game.oldschool==0)
                  scale=0.9f;
                }
              if (level.grid[y][x]==255 || (level.grid[y][x]==255-8 && level.gridmod[y][x]==2))
                {
                game.score[0]+=1000;
                createsprite(1000,vec);
                if (game.oldschool==0)
                  scale=0.8f;
                }

              if (level.grid[y][x]==252 || (level.grid[y][x]==252-8 && level.gridmod[y][x]==2))
                playsound(20,vec,NULL,0.7f,0,scale,-1,0);
              else
                playsound(10,vec,NULL,0.4f,0,scale,-1,0);

              level.gridmod[y][x]=1;

              if (level.grid[y][x]>=248 && level.grid[y][x]<=255)
                game.bonus[level.grid[y][x]-248]++;
              if (level.grid[y][x]>=240 && level.grid[y][x]<=247)
                game.bonus[level.grid[y][x]-240]++;
              }
            }
          }
        }

      count4=0;
      for (count2=0;count2<16;count2++)
      for (count3=0;count3<16;count3++)
      if (abs(count2-count3)>6)
        {
        subtractvectors(vec,particle[object[count].particle[count3]].position,particle[object[count].particle[count2]].position);
        veclength=vectorlength(vec);
        if (veclength<0.15f)
          count4++;
        //if (veclength<0.15f)
        //  object[count].hitpoints-=(0.2f-veclength)*500.0f;
        }

      if (count4>=2)
        object[count].hitpoints-=(count4-1)*50;

      if (object[count].numoforientations==0)
        copyvector(object[count].orientation[1],yaxis);
      else
        normalizevector(object[count].orientation[1],object[count].orientation[1]);
      crossproduct(object[count].orientation[0],zaxis,object[count].orientation[1]);
      normalizevector(object[count].orientation[0],object[count].orientation[0]);

      if (dotproduct(object[count].velocity,object[count].orientation[0])<-0.02f)
        object[count].direction=0;
      if (dotproduct(object[count].velocity,object[count].orientation[0])>0.02f)
        object[count].direction=1;

      angle=atan2(object[count].orientation[0][1],object[count].orientation[0][0]);
      spin=cos(angle)*fabs(cos(angle))*object[count].axis[0]+sin(angle)*fabs(sin(angle))*object[count].axis[1];

      if (spin<-1.0f)
        spin=-1.0f;
      if (spin>1.0f)
        spin=1.0f;
      if (angle<object[count].angle-pi)
        angle+=2.0f*pi;
      if (angle>object[count].angle+pi)
        angle-=2.0f*pi;
      /*
      scale=(angle-object[count].angle);
      if (scale<-0.1f)
        scale=-0.1f;
      if (scale>0.1f)
        scale=0.1f;

      object[count].angle+=scale;
      */
      object[count].angle+=(angle-object[count].angle)*0.05f;

      if (object[count].angle<0.0f)
        object[count].angle+=2.0f*pi;
      if (object[count].angle>2.0f*pi)
        object[count].angle-=2.0f*pi;

      for (count2=0;count2<16;count2++)
        {
        subtractvectors(vec,particle[object[count].particle[count2]].position,object[count].position);
        crossproduct(vec2,zaxis,vec);
        normalizevector(vec2,vec2);

        if (object[count].numoforientations!=0)
          {
          scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,vec2,spin*0.004f);
          }

        //if (object[count].numoforientations==0)
          {
          scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,xaxis,object[count].axis[0]*0.001f);
          if (object[count].axis[1]<0.0f)
            scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,yaxis,object[count].axis[1]*0.001f);
          else
            scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,yaxis,object[count].axis[1]*0.0005f);
          }
        }

      if ((object[count].button&4)==4)
        object[count].friction=0.01f;
      else
        object[count].friction=1.2f;
      if ((object[count].button&2)==2 || (object[count].button&8)==8)
        {
        for (count2=0;count2<numofbonds;count2++)
        if (bond[count2].objectnum==count && bond[count2].type==2)
          {
          bond[count2].cycles=0;
          //bond[count2].elasticity=0.02f;
          }
        }
      else
        {
        for (count2=0;count2<numofbonds;count2++)
        if (bond[count2].objectnum==count && bond[count2].type==2)
          {
          bond[count2].cycles=31;
          /*
          if ((object[count].button&4)==4)
            bond[count2].elasticity=0.005f;
          else
            bond[count2].elasticity=0.02f;
          */
          }
        }
      if ((object[count].button&8)==8)
        {
        for (count2=0;count2<object[count].numofparticles;count2++)
          {
          particle[object[count].particle[count2]].gravity=10.0f/(PHYSICSCYCLE*PHYSICSCYCLE);
          particle[object[count].particle[count2]].mass=0.5f;
          }
        }
      else
        {
        for (count2=0;count2<object[count].numofparticles;count2++)
          {
          particle[object[count].particle[count2]].gravity=4.0f/(PHYSICSCYCLE*PHYSICSCYCLE);
          particle[object[count].particle[count2]].mass=0.25f;
          }
        }
      }
    if (object[count].type==20)
      {
      subtractvectors(object[count].orientation[1],particle[object[count].particle[0]].position,particle[object[count].particle[3]].position);
      normalizevector(object[count].orientation[1],object[count].orientation[1]);
      object[count].orientation[0][0]=object[count].orientation[1][1];
      object[count].orientation[0][1]=-object[count].orientation[1][0];
      object[count].orientation[0][2]=0.0f;

      object[count].data[0]+=object[count].axis[0]*0.05f;
      if (object[count].data[0]<0.0f)
        object[count].data[0]+=0.02f;
      if (object[count].data[0]>0.0f)
        object[count].data[0]-=0.02f;
      if (object[count].data[0]<-0.5f)
        object[count].data[0]=-0.5f;
      if (object[count].data[0]>0.5f)
        object[count].data[0]=0.5f;

      object[count].data[1]+=object[count].axis[1]*0.008f;
      if ((object[count].button&2)==2)
        object[count].data[1]=0.0f;
      if (object[count].data[1]<0.0f)
        object[count].data[1]+=0.004f;
      if (object[count].data[1]>0.0f)
        object[count].data[1]-=0.004f;
      if (object[count].data[1]<-0.3f)
        object[count].data[1]=-0.3f;
      if (object[count].data[1]>0.3f)
        object[count].data[1]=0.3f;

      for (count2=0;count2<4;count2++)
        {
        copyvector(vec,particle[object[count].particle[count2]].velocity);
        if (count2==1 || count2==2)
          {
          //normal[0]=object[count].orientation[0][0]*cos(object[count].data[0])+object[count].orientation[0][1]*sin(object[count].data[0]);
          //normal[1]=object[count].orientation[1][1]*cos(object[count].data[0])-object[count].orientation[1][0]*sin(object[count].data[0]);
          scalevector(normal,object[count].orientation[0],cos(object[count].data[0]));
          scaleaddvectors(normal,normal,object[count].orientation[1],-sin(object[count].data[0]));
          calculatefriction(vec,vec2,normal,0.8f);
          subtractvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,vec2);
          }
        else
          {
          copyvector(normal,object[count].orientation[0]);
          scaleaddvectors(vec,vec,normal,-object[count].data[1]);
          vec[2]=1.0f/PHYSICSCYCLE;
          calculatefriction(vec,vec2,zaxis,0.8f);
          vec2[2]=0.0f;
          subtractvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,vec2);
          }
        //copyvector(particle[object[count].particle[count2]].velocity,vec);
        }

      for (count2=0;count2<4;count2++)
        {
        subtractvectors(vec,particle[object[count].particle[count2]].position,object[count].position);
        crossproduct(vec2,zaxis,vec);
        normalizevector(vec2,vec2);

        //scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,vec2,object[count].axis[0]*0.002f);
        //scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,object[count].orientation[0],object[count].axis[1]*0.003f);
        }
      }
    if (object[count].type==4)
      {
      for (count2=0;count2<4;count2++)
        {
        x=particle[object[count].particle[count2]].position[0];
        y=particle[object[count].particle[count2]].position[1];

        if (x>0 && x<254)
        if (y>0 && y<254)
          {
          if (block[level.foregrid[y][x]].foredamage!=0)
            object[count].hitpoints-=block[level.foregrid[y][x]].foredamage*4;
          }
        }
      if (object[count].hitpoints<0)
      if (object[count].timetolive>45)
        object[count].timetolive=45;

      subtractvectors(object[count].orientation[1],particle[object[count].particle[0]].position,particle[object[count].particle[3]].position);
      normalizevector(object[count].orientation[1],object[count].orientation[1]);
      object[count].orientation[0][0]=object[count].orientation[1][1];
      object[count].orientation[0][1]=-object[count].orientation[1][0];
      object[count].orientation[0][2]=0.0f;

      objectai(count);

      if (object[0].position[0]<object[count].position[0])
        object[count].direction=0;
      else
        object[count].direction=1;

      if (object[count].velocity[0]<-0.01f)
        object[count].direction=0;
      if (object[count].velocity[0]>0.01f)
        object[count].direction=1;
      if (object[count].link!=-1)
        object[object[count].link].direction=object[count].direction;

      if (dotproduct(object[count].orientation[1],yaxis)>0.7f)
      if (object[count].numoforientations!=0)
        {
        if (object[count].beasttype>=0 && object[count].beasttype<=2)
          scale=2.0f;
        if (object[count].beasttype==8 || object[count].beasttype==11)
          scale=2.0f;
        if (object[count].beasttype==16)
          scale=2.0f;
        if (object[count].beasttype>=3 && object[count].beasttype<=6)
          scale=2.0f;
        if (object[count].beasttype==9 || object[count].beasttype==10)
          scale=2.0f;
        if (object[count].beasttype==7 || object[count].beasttype==13)
          scale=1.5f;
        if (object[count].beasttype==15)
          scale=2.5f;

        if (object[count].axis[0]==-1.0f)
          {
          for (count2=0;count2<4;count2++)
          if (particle[object[count].particle[count2]].velocity[0]>-3.0f/PHYSICSCYCLE)
            particle[object[count].particle[count2]].velocity[0]-=scale/(PHYSICSCYCLE*PHYSICSCYCLE);
          }
        if (object[count].axis[0]==1.0f)
          {
          for (count2=0;count2<4;count2++)
          if (particle[object[count].particle[count2]].velocity[0]<3.0f/PHYSICSCYCLE)
            particle[object[count].particle[count2]].velocity[0]+=scale/(PHYSICSCYCLE*PHYSICSCYCLE);
          }
        }

      if (object[count].beasttype==0 || object[count].beasttype==2 || object[count].beasttype==8 || object[count].beasttype==16)
      if (object[count].numoforientations!=0)
      if ((object[count].button&2)==2)
        for (count2=0;count2<4;count2++)
          {
          if (object[count].beasttype!=8)
            scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,yaxis,0.08f);
          else
            scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,yaxis,0.12f);
          }
      if (object[count].beasttype==15)
      if (object[count].numoforientations!=0)
      if ((object[count].button&2)==2)
        for (count2=0;count2<2;count2++)
          scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,yaxis,0.08f);

      if (object[count].numoforientations!=0)
      if (dotproduct(object[count].orientation[1],yaxis)<0.7f)
        {
        if (object[count].orientation[1][0]<0.0f)
          spin=1.0f;
        else
          spin=-1.0f;
        for (count2=0;count2<4;count2++)
          {
          subtractvectors(vec,particle[object[count].particle[count2]].position,object[count].position);
          crossproduct(vec2,zaxis,vec);
          normalizevector(vec2,vec2);
  
          scaleaddvectors(particle[object[count].particle[count2]].velocity,particle[object[count].particle[count2]].velocity,vec2,spin*0.003f);
          }
        }
      }
    }
  }