t_func.c

The source code of Doom legacy for windows

      {
        script_error("mobj not a player!\n");
        return;
      }
      playernum = t_argv[0].value.mobj->player - players;
    }
    else
      playernum = intvalue(t_argv[0]);

    ammonum = intvalue(t_argv[1]);
    if(!playeringame[playernum])
    {
      script_error("player %i not in game\n", playernum);
      return;
    }
    if(ammonum >= NUMAMMO)
    {
      script_error("ammonum out of range! %s\n", ammonum);
      return;
    }
    t_return.type = svt_int;
    t_return.value.i = players[playernum].ammo[ammonum];
    return;
  }
  else
  {
    if(t_argv[0].type == svt_mobj)
    {
      if(!t_argv[0].value.mobj->player)
      {
        script_error("mobj not a player!\n");
        return;
      }
      playernum = t_argv[0].value.mobj->player - players;
    }
    else
      playernum = intvalue(t_argv[0]);

    ammonum = intvalue(t_argv[1]);
    if(!playeringame[playernum])
    {
      script_error("player %i not in game\n", playernum);
      return;
    }
    if(ammonum > NUMAMMO)
    {
      script_error("ammonum out of range! %s\n", ammonum);
      return;
    }
    newammo = intvalue(t_argv[2]);
    newammo = newammo > players[playernum].maxammo[ammonum] ? players[playernum].maxammo[ammonum] : newammo;
    t_return.type = svt_int;
    t_return.value.i = players[playernum].ammo[ammonum] = newammo;
    return;
  }
}



void SF_MaxPlayerAmmo()
{
  int  playernum;
  int  ammonum;
  int  newmax;

  if(t_argc < 2)
  {
    script_error("missing parameters for maxplayerammo\n");
    return;
  }

  if(t_argc == 2)
  {
    if(t_argv[0].type == svt_mobj)
    {
      if(!t_argv[0].value.mobj->player)
      {
        script_error("mobj not a player!\n");
        return;
      }
      playernum = t_argv[0].value.mobj->player - players;
    }
    else
      playernum = intvalue(t_argv[0]);

    ammonum = intvalue(t_argv[1]);
    if(!playeringame[playernum])
    {
      script_error("player %i not in game\n", playernum);
      return;
    }
    if(ammonum >= NUMAMMO || ammonum < 0)
    {
      script_error("maxammonum out of range! %i\n", ammonum);
      return;
    }
    t_return.type = svt_int;
    t_return.value.i = players[playernum].maxammo[ammonum];
    return;
  }
  else
  {
    if(t_argv[0].type == svt_mobj)
    {
      if(!t_argv[0].value.mobj->player)
      {
        script_error("mobj not a player!\n");
        return;
      }
      playernum = t_argv[0].value.mobj->player - players;
    }
    else
      playernum = intvalue(t_argv[0]);

    ammonum = intvalue(t_argv[1]);
    if(!playeringame[playernum])
    {
      script_error("player %i not in game\n", playernum);
      return;
    }
    if(ammonum > NUMAMMO)
    {
      script_error("ammonum out of range! %s\n", ammonum);
      return;
    }
    newmax = intvalue(t_argv[2]);
    t_return.type = svt_int;
    t_return.value.i = players[playernum].maxammo[ammonum] = newmax;
    return;
  }
}



extern void SF_StartScript();      // in t_script.c
extern void SF_ScriptRunning();
extern void SF_Wait();
extern void SF_TagWait();
extern void SF_ScriptWait();

/*********** Mobj code ***************/

void SF_Player()
{
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) :
    current_script->trigger;

  t_return.type = svt_int;

  if(mo)
    {
      t_return.value.i = (int)(mo->player - players);
    }
  else
    {
      t_return.value.i = -1;
    }
}

        // spawn an object: type, x, y, [angle]
void SF_Spawn()
{
  int x, y, z, objtype;
  angle_t angle = 0;

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

  objtype = intvalue(t_argv[0]);
  x = intvalue(t_argv[1]) << FRACBITS;
  y = intvalue(t_argv[2]) << FRACBITS;
  if(t_argc >= 5)
    z = intvalue(t_argv[4]) << FRACBITS;
  else
  {
    // SoM: Check thing flags for spawn-on-ceiling types...
    z = R_PointInSubsector(x, y)->sector->floorheight;
  }

  if(t_argc >= 4)
    angle = intvalue(t_argv[3]) * (ANG45 / 45);

  // invalid object to spawn
  if(objtype < 0 || objtype >= NUMMOBJTYPES)
    { script_error("unknown object type: %i\n", objtype); return; }

  t_return.type = svt_mobj;
  t_return.value.mobj = P_SpawnMobj(x,y,z, objtype);
  t_return.value.mobj->angle = angle;
}


void SF_SpawnExplosion()
{
  int       type;
  fixed_t   x, y, z;
  mobj_t*   spawn;


  if(t_argc < 3)
  {
    script_error("SpawnExplosion: Missing arguments\n");
    return;
  }

  type = intvalue(t_argv[0]);
  if(type < 0 || type >= NUMMOBJTYPES)
  {
    script_error("SpawnExplosion: Invalud type number\n");
    return;
  }

  x = fixedvalue(t_argv[1]);
  y = fixedvalue(t_argv[2]);
  if(t_argc > 3)
    z = fixedvalue(t_argv[3]);
  else
    z = R_PointInSubsector(x, y)->sector->floorheight;

  spawn = P_SpawnMobj(x, y, z, type);
  t_return.type = svt_int;
  t_return.value.i = P_SetMobjState(spawn, spawn->info->deathstate);
  if(spawn->info->deathsound)
    S_StartSound(spawn, spawn->info->deathsound);
}



void SF_RemoveObj()
{
  mobj_t *mo;

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

  mo = MobjForSvalue(t_argv[0]);
  if(mo)  // nullptr check
    P_RemoveMobj(mo);
}

void SF_KillObj()
{
  mobj_t *mo;

  if(t_argc)
    mo = MobjForSvalue(t_argv[0]);
  else
    mo = current_script->trigger;  // default to trigger object

  if(mo)  // nullptr check
    P_KillMobj(mo, NULL, current_script->trigger);         // kill it
}

        // mobj x, y, z
void SF_ObjX()
{
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) : current_script->trigger;

  t_return.type = svt_fixed;
  t_return.value.f = mo ? mo->x : 0;   // null ptr check
}

void SF_ObjY()
{
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) : current_script->trigger;

  t_return.type = svt_fixed;
  t_return.value.f = mo ? mo->y : 0; // null ptr check
}

void SF_ObjZ()
{
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) : current_script->trigger;

  t_return.type = svt_fixed;
  t_return.value.f = mo ? mo->z : 0; // null ptr check
}

        // mobj angle
void SF_ObjAngle()
{
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) : current_script->trigger;

  t_return.type = svt_fixed;
  t_return.value.f = mo ? AngleToFixed(mo->angle) : 0;   // null ptr check
}


        // teleport: object, sector_tag
void SF_Teleport()
{
  line_t line;    // dummy line for teleport function
  mobj_t *mo;

  if(t_argc==0)   // no arguments
    {
      script_error("insufficient arguments to function\n");
      return;
    }
  else if(t_argc == 1)    // 1 argument: sector tag
    {
      mo = current_script->trigger;   // default to trigger
      line.tag = intvalue(t_argv[0]);
    }
  else    // 2 or more
    {                       // teleport a given object
      mo = MobjForSvalue(t_argv[0]);
      line.tag = intvalue(t_argv[1]);
    }

  if(mo)
    EV_Teleport(&line, 0, mo);
}



void SF_SilentTeleport()
{
  line_t line;    // dummy line for teleport function
  mobj_t *mo;

  if(t_argc==0)   // no arguments
    {
      script_error("insufficient arguments to function\n");
      return;
    }
  else if(t_argc == 1)    // 1 argument: sector tag
    {
      mo = current_script->trigger;   // default to trigger
      line.tag = intvalue(t_argv[0]);
    }
  else    // 2 or more
    {                       // teleport a given object
      mo = MobjForSvalue(t_argv[0]);
      line.tag = intvalue(t_argv[1]);
    }

  if(mo)
    EV_SilentTeleport(&line, 0, mo);
}



void SF_DamageObj()
{
  mobj_t *mo;
  int damageamount;

  if(t_argc==0)   // no arguments
    {
      script_error("insufficient arguments to function\n");
      return;
    }
  else if(t_argc == 1)    // 1 argument: damage trigger by amount
    {
      mo = current_script->trigger;   // default to trigger
      damageamount = intvalue(t_argv[0]);
    }
  else    // 2 or more
    {                       // teleport a given object
      mo = MobjForSvalue(t_argv[0]);
      damageamount = intvalue(t_argv[1]);
    }

  if(mo)
    P_DamageMobj(mo, NULL, current_script->trigger, damageamount);
}

        // the tag number of the sector the thing is in
void SF_ObjSector()
{
  // use trigger object if not specified
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) : current_script->trigger;

  t_return.type = svt_int;
  t_return.value.i = mo ? mo->subsector->sector->tag : 0; // nullptr check
}

        // the health number of an object
void SF_ObjHealth()
{
  // use trigger object if not specified
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) : current_script->trigger;

  t_return.type = svt_int;
  t_return.value.i = mo ? mo->health : 0;
}


void SF_ObjDead()
{
  mobj_t *mo = t_argc ? MobjForSvalue(t_argv[0]) : current_script->trigger;

  t_return.type = svt_int;
  if(mo && (mo->health <= 0 || mo->flags & MF_CORPSE))
    t_return.value.i = 1;
  else
    t_return.value.i = 0;
}


void SF_ObjFlag()
{
  mobj_t *mo;
  int flagnum;

  if(t_argc==0)   // no arguments
    {
      script_error("no arguments for function\n");
      return;
    }
  else
    if(t_argc == 1)         // use trigger, 1st is flag
      {
        // use trigger:
        mo = current_script->trigger;
        flagnum = intvalue(t_argv[0]);
      }
    else
      if(t_argc == 2)
        {
          // specified object
          mo = MobjForSvalue(t_argv[0]);
          flagnum = intvalue(t_argv[1]);
        }
      else                     // >= 3 : SET flags
        {
          mo = MobjForSvalue(t_argv[0]);
          flagnum = intvalue(t_argv[1]);

          if(mo)          // nullptr check
            {
              long newflag;
              // remove old bit
              mo->flags = mo->flags & ~(1 << flagnum);

              // make the new flag
              newflag = (!!intvalue(t_argv[2])) << flagnum;
              mo->flags |= newflag;   // add new flag to mobj flags
            }

          //P_UpdateThinker(&mo->thinker);     // update thinker

        }

  t_return.type = svt_int;
  // nullptr check:
  t_return.value.i = mo ? !!(mo->flags & (1 << flagnum)) : 0;
}



        // apply momentum to a thing
void SF_PushThing()
{
  mobj_t *mo;
  angle_t angle;
  fixed_t force;

  if(t_argc<3)   // missing arguments
    {
      script_error("insufficient arguments for function\n");
      return;
    }

  mo = MobjForSvalue(t_argv[0]);

  if(!mo) return;

  angle = FixedToAngle(fixedvalue(t_argv[1]));
  force = fixedvalue(t_argv[2]);

  mo->momx += FixedMul(finecosine[angle >> ANGLETOFINESHIFT], force);
  mo->momy += FixedMul(finesine[angle >> ANGLETOFINESHIFT], force);
}



void SF_ReactionTime()
{
  mobj_t *mo;

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

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

  if(t_argc > 1)
  {
    mo->reactiontime = (intvalue(t_argv[1]) * 35) / 100;
  }

  t_return.type = svt_int;
  t_return.value.i = mo->reactiontime;
}


// Sets a mobj's Target! >:)
void SF_MobjTarget()
{
  mobj_t*  mo;
  mobj_t*  target;

  if(t_argc < 1)
  {
    script_error("Missing parameters!\n");
    return;
  }

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

  if(t_argc >= 2)
  {
    if(t_argv[1].type != svt_mobj && intvalue(t_argv[1]) == -1)
    {
      // Set target to NULL
      mo->target = NULL;
      P_SetMobjState(mo, mo->info->spawnstate);
    }
    else
    {
      target = MobjForSvalue(t_argv[1]);
      mo->target = target;
      P_SetMobjState(mo, mo->info->seestate);
    }
  }

  t_return.type = svt_mobj;
  t_return.value.mobj = mo->target;
}


void SF_MobjMomx()
{
  mobj_t*   mo;

  if(t_argc < 1)
  {
    script_error("missing parameters\n");
    return;
  }

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

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


void SF_MobjMomy()
{
  mobj_t*   mo;

  if(t_argc < 1)
  {
    script_error("missing parameters\n");
    return;
  }

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

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


void SF_MobjMomz()
{
  mobj_t*   mo;

  if(t_argc < 1)
  {
    script_error("missing parameters\n");