quake-rerelease-qc/quakec_hipnotic/hip_part.qc

/*  Copyright (C) 1996-2022 id Software LLC

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

    See file, 'COPYING', for details.
*/

/* Particle effects QuickC program
   By Jim Dose'  9/19/96

*/

//float START_OFF = 1;
float USE_COUNT = 1;

void () particlefield_XZ =
	{
	local vector pos;
   local vector start;
   local vector end;

   if ( ( self.spawnflags & USE_COUNT ) &&
      ( counter_GetCount( other ) != self.cnt ) )
      {
      return;
      }
//   dprint( "XZ\n" );

   self.ltime = time + 0.25;
   if ( self.noise )
      {
      sound(self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
      }

   // Only show particles if client is visible.
   // This helps to keep network traffic down to a minimum.
   if (!checkclient() )
      return;

   start = self.dest1 + self.origin;
   end   = self.dest2 + self.origin;
   pos_y = start_y;
   pos_z = start_z;
   while( pos_z <= end_z )
		{
      pos_x = start_x;
      while( pos_x <= end_x )
			{
         particle ( pos, '0 0 0', self.color, self.count );
         pos_x = pos_x + 16;
			}
      pos_z = pos_z + 16;
		}
	};

void () particlefield_YZ =
	{
	local vector pos;
   local vector start;
   local vector end;

   if ( ( self.spawnflags & USE_COUNT ) &&
      ( counter_GetCount( other ) != self.cnt ) )
      {
      return;
      }

//   dprint( "YZ: " );
//   dprint( vtos( self.dest1 ) );
//   dprint( " - " );
//   dprint( vtos( self.dest2 ) );
//   dprint( "\n" );
   self.ltime = time + 0.25;
   if ( self.noise )
      {
      sound(self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
      }

   // Only show particles if client is visible.
   // This helps to keep network traffic down to a minimum.
   if (!checkclient() )
      return;

   start = self.dest1 + self.origin;
   end   = self.dest2 + self.origin;
   pos_x = start_x;
   pos_z = start_z;
   while( pos_z < end_z )
		{
      pos_y = start_y;
      while( pos_y < end_y )
			{
         particle ( pos, '0 0 0', self.color, self.count );
			pos_y = pos_y + 16;
			}
		pos_z = pos_z + 16;
		}
	};

void () particlefield_XY =
	{
	local vector pos;
   local vector start;
   local vector end;

   if ( ( self.spawnflags & USE_COUNT ) &&
      ( counter_GetCount( other ) != self.cnt ) )
      {
      return;
      }

//   dprint( "XY\n" );
   self.ltime = time + 0.25;
   if ( self.noise )
      {
      sound(self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
      }

   // Only show particles if client is visible.
   // This helps to keep network traffic down to a minimum.
   if (!checkclient() )
      return;


   start = self.dest1 + self.origin;
   end   = self.dest2 + self.origin;
   pos_x = start_x;
   pos_z = start_z;
   while( pos_x < end_x )
		{
      pos_y = start_y;
      while( pos_y < end_y )
			{
         particle ( pos, '0 0 0', self.color, self.count );
			pos_y = pos_y + 16;
			}
		pos_x = pos_x + 16;
		}
	};

void () particlefield_touch =
	{
   if ( !self.dmg )
      return;

   if ( time > self.ltime)
      return;

	if (time < self.attack_finished)
		return;
	self.attack_finished = time + 0.5;
	T_Damage (other, self, self, self.dmg);
   };

/*QUAKED func_particlefield (0 .5 .8) ? USE_COUNT
Creates a brief particle flash roughly the size of the defining
brush each time it is triggered.

USE_COUNT when the activator is a func_counter, the field will only
   activate when count is equal to "cnt".  Same as using a func_oncount
   to trigger.

"cnt" is the count to activate on when USE_COUNT is set.
"color" is the color of the particles.  Default is 192 (yellow).
"count" is the density of the particles.  Default is 2.
"noise" is the sound to play when triggered.  Do not use a looping sound here.
"dmg" is the amount of damage to cause when touched.
*/

void() func_particlefield =
	{
   if ( !self.color )
	   {
      self.color = 192;
	   }
   if ( self.count == 0 )
	   {
      self.count = 2;
	   }
   self.classname = "particlefield";
   self.solid = SOLID_NOT;
   self.movetype = MOVETYPE_NONE;
   setmodel (self, self.model);
   self.model = string_null;

   self.origin = ( self.mins + self.maxs ) * 0.5;
   setorigin (self, self.origin);
   self.dest = self.maxs - self.mins - '16 16 16';
   self.dest1 = self.mins + '8 8 8' - self.origin;
   self.dest2 = self.maxs + '7.9 7.9 7.9' - self.origin;
   setsize (self, self.mins, self.maxs);
   self.touch = particlefield_touch;
//   dprint( vtos( self.dest ) );
//   dprint( "  " );
   if ( self.dest_x > self.dest_z )
		{
      if ( self.dest_y > self.dest_z )
			{
//         dprint( "XY1 - " );
//         dprint( ftos( self.cnt ) );
//         dprint( "\n" );
         self.use = particlefield_XY;
         self.dest1_z = ( self.dest1_z + self.dest2_z ) / 2;
			}
		else
			{
//         dprint( "XZ1 - " );
//         dprint( ftos( self.cnt ) );
//         dprint( "\n" );
         self.use = particlefield_XZ;
         self.dest1_y = ( self.dest1_y + self.dest2_y ) / 2;
			}
		}
	else
		{
      if ( self.dest_y > self.dest_x )
         {
//         dprint( "YZ2 - " );
//         dprint( ftos( self.cnt ) );
//         dprint( "\n" );
         self.use = particlefield_YZ;
         self.dest1_x = ( self.dest1_x + self.dest2_x ) / 2;
			}
		else
			{
//         dprint( "XZ2 - " );
//         dprint( ftos( self.cnt ) );
//         dprint( "\n" );
         self.use = particlefield_XZ;
         self.dest1_y = ( self.dest1_y + self.dest2_y ) / 2;
			}
		}

   if ( self.noise )
      {
      precache_sound( self.noise );
      }
   self.ltime = time;
   };

void () blocker_touch =
	{
   if ( !self.dmg )
      return;

	if (time < self.attack_finished)
		return;
	self.attack_finished = time + 0.5;
	T_Damage (other, self, self, self.dmg);
   };

void () blocker_use =
	{
   if ( !self.state )
      {
      self.state = 1;
      setorigin( self, self.origin - '8000 8000 8000' );
      sound(self, CHAN_VOICE, self.noise1, 1, ATTN_NORM);
      }
   else
      {
      self.state = 0;
      setorigin( self, self.origin + '8000 8000 8000' );
      sound(self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
      }
   };

/*QUAKED func_togglewall (0 .5 .8) ? START_OFF
Creates a invisible wall that can be toggled on and off.

START_OFF wall doesn't block until triggered.

"noise" is the sound to play when wall is turned off.
"noise1" is the sound to play when wall is blocking.
"dmg" is the amount of damage to cause when touched.
*/

void() func_togglewall =
	{
   self.classname = "togglewall";
   self.movetype = MOVETYPE_PUSH;
   self.mdl = self.model;
   setmodel (self, self.model);
   setsize (self, self.mins, self.maxs);
   setorigin (self, self.origin);
   self.touch = blocker_touch;
   self.use = blocker_use;
   if ( !self.noise )
      {
      self.noise = ("misc/null.wav");
      }
   if ( !self.noise1 )
      {
      self.noise1 = ("misc/null.wav");
      }

   precache_sound( self.noise );
   precache_sound( self.noise1 );

   self.solid = SOLID_BSP;
   self.model = string_null;
   if ( self.spawnflags & START_OFF )
      {
      self.state = 0;
      setorigin( self, self.origin + '8000 8000 8000' );
      }
   else
      {
      self.state = 1;
      sound(self, CHAN_VOICE, self.noise1, 1, ATTN_NORM);
      }
   };