t_func.c

The source code of Doom legacy for windows

    return;
  }

  mo = MobjForSvalue(t_argv[0]);
  if(t_argc > 1)
  {
    if(!mo)
      return;
    mo->momz = fixedvalue(t_argv[1]);
  }

  t_return.type = svt_fixed;
  t_return.value.f = mo ? mo->momz : 0;
}

/****************** Trig *********************/

void SF_PointToAngle()
{
  angle_t angle;
  int x1, y1, x2, y2;

  if(t_argc<4)
    {
      script_error("insufficient arguments to function\n");
      return;
    }

  x1 = intvalue(t_argv[0]) << FRACBITS;
  y1 = intvalue(t_argv[1]) << FRACBITS;
  x2 = intvalue(t_argv[2]) << FRACBITS;
  y2 = intvalue(t_argv[3]) << FRACBITS;

  angle = R_PointToAngle2(x1, y1, x2, y2);

  t_return.type = svt_fixed;
  t_return.value.f = AngleToFixed(angle);
}



void SF_PointToDist()
{
  int dist;
  int x1, x2, y1, y2;

  if(t_argc<4)
    {
      script_error("insufficient arguments to function\n");
      return;
    }

  x1 = intvalue(t_argv[0]) << FRACBITS;
  y1 = intvalue(t_argv[1]) << FRACBITS;
  x2 = intvalue(t_argv[2]) << FRACBITS;
  y2 = intvalue(t_argv[3]) << FRACBITS;

  dist = R_PointToDist2(x1, y1, x2, y2);
  t_return.type = svt_fixed;
  t_return.value.f = dist;
}




/************* Camera functions ***************/

camera_t script_camera = {false, 0, 0, 0, 0, NULL};
boolean  script_camera_on;


// setcamera(obj, [angle], [viewheight], [aiming])
void SF_SetCamera()
{
  mobj_t     *mo;
  angle_t    angle;
  fixed_t    aiming;


  if(t_argc < 1)
    {
      script_error("insufficient arguments to function\n");
      return;
    }

  mo = MobjForSvalue(t_argv[0]);
  if(!mo) return;         // nullptr check

  if(script_camera.mo != mo)
  {
    if(script_camera.mo)
      script_camera.mo->angle = script_camera.startangle;

    script_camera.startangle = mo->angle;
  }

  angle = t_argc < 2 ? mo->angle : FixedToAngle(fixedvalue(t_argv[1]));

  script_camera.mo = mo;
  script_camera.mo->angle = angle;
  script_camera.mo->z = t_argc < 3 ? (mo->subsector->sector->floorheight + (41 << FRACBITS)) : fixedvalue(t_argv[2]);
  aiming = t_argc < 4 ? 0 : fixedvalue(t_argv[3]);
  script_camera.aiming = G_ClipAimingPitch(&aiming);
  G_ClipAimingPitch(&script_camera.aiming);
  script_camera_on = true;
}




void SF_ClearCamera()
{
  script_camera_on = false;
  script_camera.mo->angle = script_camera.startangle;
  script_camera.mo = NULL;
}

// movecamera(cameraobj, targetobj, targetheight, movespeed, targetangle, anglespeed)
void SF_MoveCamera()
{
  fixed_t    x, y, z;
  fixed_t    xdist, ydist, zdist, xydist, movespeed;
  fixed_t    xstep, ystep, zstep, targetheight;
  angle_t    anglespeed, anglestep, angledist, targetangle, mobjangle, bigangle, smallangle;
  // I have to use floats for the math where angles are divided by fixed
  // values.
  double     fangledist, fanglestep, fmovestep;
  int        angledir = 0;
  mobj_t*    camera;
  mobj_t*    target;
  int        moved = 0;
  int        quad1, quad2;

  if(t_argc < 6)
  {
    script_error("movecamera: insufficient arguments to function\n");
    return;
  }

  camera = MobjForSvalue(t_argv[0]);
  target = MobjForSvalue(t_argv[1]);
  targetheight = fixedvalue(t_argv[2]);
  movespeed = fixedvalue(t_argv[3]);
  targetangle = FixedToAngle(fixedvalue(t_argv[4]));
  anglespeed = FixedToAngle(fixedvalue(t_argv[5]));


  // Figure out how big the step will be
  xdist = target->x - camera->x;
  ydist = target->y - camera->y;
  zdist = targetheight - camera->z;

  // Angle checking...
  //    90
  //   Q1|Q0
  //180--+--0
  //   Q2|Q3
  //    270
  quad1 = targetangle / ANG90;
  quad2 = camera->angle / ANG90;
  bigangle = targetangle > camera->angle ? targetangle : camera->angle;
  smallangle = targetangle < camera->angle ? targetangle : camera->angle;
  if((quad1 > quad2 && quad1 - 1 == quad2) || (quad2 > quad1 && quad2 - 1 == quad1) || quad1 == quad2)
  {
    angledist = bigangle - smallangle;
    angledir = targetangle > camera->angle ? 1 : -1;
  }
  else
  {
    if(quad2 == 3 && quad1 == 0)
    {
      angledist = (bigangle + ANG180) - (smallangle + ANG180);
      angledir = 1;
    }
    else if(quad1 == 3 && quad2 == 0)
    {
      angledist = (bigangle + ANG180) - (smallangle + ANG180);
      angledir = -1;
    }
    else
    {
      angledist = bigangle - smallangle;
      if(angledist > ANG180)
      {
        angledist = (bigangle + ANG180) - (smallangle + ANG180);
        angledir = targetangle > camera->angle ? -1 : 1;
      }
      else
        angledir = targetangle > camera->angle ? 1 : -1;
    }
  }

  //CONS_Printf("angle: cam=%i, target=%i; dir: %i; quads: 1=%i, 2=%i\n", camera->angle / ANGLE_1, targetangle / ANGLE_1, angledir, quad1, quad2);
  // set the step variables based on distance and speed...
  mobjangle = R_PointToAngle2(camera->x, camera->y, target->x, target->y);

  xydist = R_PointToDist2(camera->x, camera->y, target->x, target->y);
  xstep = FixedMul(finecosine[mobjangle >> ANGLETOFINESHIFT], movespeed);
  ystep = FixedMul(finesine[mobjangle >> ANGLETOFINESHIFT], movespeed);
  if(xydist && movespeed)
    zstep = FixedDiv(zdist, FixedDiv(xydist, movespeed));
  else
    zstep = zdist > 0 ? movespeed : -movespeed;

  if(xydist && movespeed && !anglespeed)
  {
    fangledist = ((double)angledist / ANGLE_1);
    fmovestep = ((double)FixedDiv(xydist, movespeed) / FRACUNIT);
    if(fmovestep)
      fanglestep = (fangledist / fmovestep);
    else
      fanglestep = 360;

    //CONS_Printf("fstep: %f, fdist: %f, fmspeed: %f, ms: %i\n", fanglestep, fangledist, fmovestep, FixedDiv(xydist, movespeed) >> FRACBITS);

    anglestep = (fanglestep * ANGLE_1);
  }
  else
    anglestep = anglespeed;

  if(abs(xstep) >= (abs(xdist) - 1))
    x = target->x;
  else
  {
    x = camera->x + xstep;
    moved = 1;
  }

  if(abs(ystep) >= (abs(ydist) - 1))
    y = target->y;
  else
  {
    y = camera->y + ystep;
    moved = 1;
  }

  if(abs(zstep) >= abs(zdist) - 1)
    z = targetheight;
  else
  {
    z = camera->z + zstep;
    moved = 1;
  }

  if(anglestep >= angledist)
    camera->angle = targetangle;
  else
  {
    if(angledir == 1)
    {
      moved = 1;
      camera->angle += anglestep;
    }
    else if(angledir == -1)
    {
      moved = 1;
      camera->angle -= anglestep;
    }
  }

  if(!P_TryMove(camera, x, y, true))
  {
    script_error("Illegal camera move\n");
    return;
  }
  camera->z = z;

  t_return.type = svt_int;
  t_return.value.i = moved;
}




/*********** sounds ******************/

        // start sound from thing
void SF_StartSound()
{
  mobj_t *mo;

  if(t_argc < 2)
    {
      script_error("insufficient arguments to function\n");
      return;
    }

  if(t_argv[1].type != svt_string)
    {
      script_error("sound lump argument not a string!\n");
      return;
    }

  mo = MobjForSvalue(t_argv[0]);
  if(!mo) return;

  S_StartSoundName(mo, t_argv[1].value.s);
}




        // start sound from sector
void SF_StartSectorSound()
{
  sector_t *sector;
  int tagnum, secnum;

  if(t_argc < 2)
    { script_error("insufficient arguments to function\n"); return; }
  if(t_argv[1].type != svt_string)
    { script_error("sound lump argument not a string!\n"); return;}

  tagnum = intvalue(t_argv[0]);
  // argv is sector tag

  secnum = P_FindSectorFromTag(tagnum, -1);

  if(secnum < 0)
    { script_error("sector not found with tagnum %i\n", tagnum); return;}

  secnum = -1;
  while ((secnum = P_FindSectorFromTag(tagnum, secnum)) >= 0)
  {
    sector = &sectors[secnum];
    S_StartSoundName((mobj_t *)&sector->soundorg, t_argv[1].value.s);
  }
}


void SF_AmbiantSound()
{
  if(t_argc != 1)
    { script_error("insufficient arguments to function\n"); return; }
  if(t_argv[0].type != svt_string)
    { script_error("sound lump argument not a string!\n"); return;}

  S_StartSoundName(NULL, t_argv[0].value.s);
}


/************* Sector functions ***************/

        // floor height of sector
void SF_FloorHeight()
{
  sector_t *sector;
  int tagnum;
  int secnum;
  int returnval = 1;

  if(!t_argc)
    { script_error("insufficient arguments to function\n"); return; }

  tagnum = intvalue(t_argv[0]);

  // argv is sector tag
  secnum = P_FindSectorFromTag(tagnum, -1);

  if(secnum < 0)
    { script_error("sector not found with tagnum %i\n", tagnum); return;}

  sector = &sectors[secnum];

  if(t_argc > 1)          // > 1: set floorheight
    {
      int i = -1;
      boolean crush = t_argc == 3 ? intvalue(t_argv[2]) : false;

      // set all sectors with tag
      while ((i = P_FindSectorFromTag(tagnum, i)) >= 0)
        {
          //sectors[i].floorheight = intvalue(t_argv[1]) << FRACBITS;
          if(T_MovePlane(&sectors[i], abs(fixedvalue(t_argv[1]) - sectors[i].floorheight), fixedvalue(t_argv[1]), crush, 0, fixedvalue(t_argv[1]) > sectors[i].floorheight ? 1 : -1) == crushed)
            returnval = 0;
        }
    }
  else
    returnval = sectors[secnum].floorheight >> FRACBITS;

  // return floorheight

  t_return.type = svt_int;
  t_return.value.i = returnval;
}




void SF_MoveFloor()
{
  int secnum = -1;
  sector_t *sec;
  floormove_t *floor;
  int tagnum, platspeed = 1, destheight;

  if(t_argc < 2)
    { script_error("insufficient arguments to function\n"); return; }

  tagnum = intvalue(t_argv[0]);
  destheight = intvalue(t_argv[1]) << FRACBITS;
  platspeed = FLOORSPEED * (t_argc > 2 ? intvalue(t_argv[2]) : 1);

  // move all sectors with tag

  while ((secnum = P_FindSectorFromTag(tagnum, secnum)) >= 0)
    {
      sec = &sectors[secnum];

      // Don't start a second thinker on the same floor
      if (P_SectorActive(floor_special,sec))
        continue;

      floor = Z_Malloc(sizeof(floormove_t), PU_LEVSPEC, 0);
      P_AddThinker(&floor->thinker);
      sec->floordata = floor;
      floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
      floor->type = -1;   // not done by line
      floor->crush = false;

      floor->direction =
        destheight < sec->floorheight ? -1 : 1;
      floor->sector = sec;
      floor->speed = platspeed;
      floor->floordestheight = destheight;
    }
}



        // ceiling height of sector
void SF_CeilingHeight()
{
  sector_t *sector;
  int secnum;
  int tagnum;
  int returnval = 1;

  if(!t_argc)
    { script_error("insufficient arguments to function\n"); return; }

  tagnum = intvalue(t_argv[0]);

  // argv is sector tag
  secnum = P_FindSectorFromTag(tagnum, -1);

  if(secnum < 0)
    { script_error("sector not found with tagnum %i\n", tagnum); return;}

  sector = &sectors[secnum];

  if(t_argc > 1)          // > 1: set ceilheight
    {
      int i = -1;
      boolean crush = t_argc == 3 ? intvalue(t_argv[2]) : false;

      // set all sectors with tag
      while ((i = P_FindSectorFromTag(tagnum, i)) >= 0)
        {
          //sectors[i].ceilingheight = intvalue(t_argv[1]) << FRACBITS;
          if(T_MovePlane(&sectors[i], abs(fixedvalue(t_argv[1]) - sectors[i].ceilingheight), fixedvalue(t_argv[1]), crush, 1, fixedvalue(t_argv[1]) > sectors[i].ceilingheight ? 1 : -1) == crushed)
            returnval = 0;
        }
    }
  else
    returnval = sectors[secnum].ceilingheight >> FRACBITS;

  // return floorheight
  t_return.type = svt_int;
  t_return.value.i = returnval;
}




void SF_MoveCeiling()
{
  int secnum = -1;
  sector_t *sec;
  ceiling_t *ceiling;
  int tagnum, platspeed = 1, destheight;

  if(t_argc < 2)
    { script_error("insufficient arguments to function\n"); return; }

  tagnum = intvalue(t_argv[0]);
  destheight = intvalue(t_argv[1]) << FRACBITS;
  platspeed = FLOORSPEED * (t_argc > 2 ? intvalue(t_argv[2]) : 1);

  // move all sectors with tag

  while ((secnum = P_FindSectorFromTag(tagnum, secnum)) >= 0)
    {
      sec = &sectors[secnum];

      // Don't start a second thinker on the same floor
      if (P_SectorActive(ceiling_special,sec))
        continue;

      ceiling = Z_Malloc(sizeof(*ceiling), PU_LEVSPEC, 0);
      P_AddThinker(&ceiling->thinker);
      sec->ceilingdata = ceiling;
      ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;
      ceiling->type = genCeiling;   // not done by line
      ceiling->crush = false;

      ceiling->direction =
        destheight < sec->ceilingheight ? -1 : 1;
      ceiling->sector = sec;
      ceiling->speed = platspeed;
      // just set top and bottomheight the same
      ceiling->topheight = ceiling->bottomheight = destheight;

      ceiling->tag = sec->tag;
      P_AddActiveCeiling(ceiling);
    }
}




void SF_LightLevel()
{
  sector_t *sector;
  int secnum;
  int tagnum;

  if(!t_argc)
    { script_error("insufficient arguments to function\n"); return; }

  tagnum = intvalue(t_argv[0]);

  // argv is sector tag
  secnum = P_FindSectorFromTag(tagnum, -1);

  if(secnum < 0)
    { script_error("sector not found with tagnum %i\n", tagnum); return;}

  sector = &sectors[secnum];

  if(t_argc > 1)          // > 1: set ceilheight
    {
      int i = -1;

      // set all sectors with tag
      while ((i = P_FindSectorFromTag(tagnum, i)) >= 0)
        {
          sectors[i].lightlevel = intvalue(t_argv[1]);
        }
    }

  // return lightlevel
  t_return.type = svt_int;
  t_return.value.i = sector->lightlevel;
}




void SF_FadeLight()
{
  int sectag, destlevel, speed = 1;

  if(t_argc < 2)
    { script_error("insufficient arguments to function\n"); return; }

  sectag = intvalue(t_argv[0]);
  destlevel = intvalue(t_argv[1]);
  speed = t_argc>2 ? intvalue(t_argv[2]) : 1;

  P_FadeLight(sectag, destlevel, speed);
}




void SF_FloorTexture()
{
  int tagnum, secnum;
  sector_t *sector;

  if(!t_argc)
    { script_error("insufficient arguments to function\n"); return; }

  tagnum = intvalue(t_argv[0]);

  // argv is sector tag
  secnum = P_FindSectorFromTag(tagnum, -1);

  if(secnum < 0)
    { script_error("sector not found with tagnum %i\n", tagnum); return;}