X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Ftriggers%2Ftrigger%2Fswamp.qc;h=0f8d1a73eebb46b4780f2b2e1758fbeda3d7aff2;hb=c6ebaefab2aca7df4648dac3ccdd4b52de45d0ed;hp=b99332b984533c9853a79b0618c859e4c5a78eff;hpb=9c09a961b8674e3a808889d3f34d71855018d3bc;p=xonotic%2Fxonotic-data.pk3dir.git

diff --git a/qcsrc/common/triggers/trigger/swamp.qc b/qcsrc/common/triggers/trigger/swamp.qc
index b99332b98..0f8d1a73e 100644
--- a/qcsrc/common/triggers/trigger/swamp.qc
+++ b/qcsrc/common/triggers/trigger/swamp.qc
@@ -1,11 +1,10 @@
 #if defined(CSQC)
 #elif defined(MENUQC)
 #elif defined(SVQC)
-	#include "../../../server/_all.qh"
-    #include "../../../warpzonelib/util_server.qh"
-    #include "../../weapons/all.qh"
-    #include "../../../server/defs.qh"
-    #include "../../deathtypes.qh"
+    #include <lib/warpzone/util_server.qh>
+    #include <common/weapons/all.qh>
+    #include <server/defs.qh>
+    #include <common/deathtypes/all.qh>
 #endif
 
 /*
@@ -21,10 +20,10 @@
 .entity swampslug;
 
 #ifdef SVQC
-void spawnfunc_trigger_swamp(void);
+spawnfunc(trigger_swamp);
 #endif
-void swamp_touch(void);
-void swampslug_think();
+void swamp_touch(entity this, entity toucher);
+void swampslug_think(entity this);
 
 
 /*
@@ -37,17 +36,17 @@ void swampslug_think();
 *
 * I do it this way becuz there is no "untouch" event.
 */
-void swampslug_think(void)
+void swampslug_think(entity this)
 {
 	//Slowly kill the slug
-	self.health = self.health - 1;
+	this.health = this.health - 1;
 
 	//Slug dead? then remove curses.
-	if(self.health <= 0)
+	if(this.health <= 0)
 	{
-		self.owner.in_swamp = 0;
-		remove(self);
-		//centerprint(self.owner,"Killing slug...\n");
+		this.owner.in_swamp = 0;
+		remove(this);
+		//centerprint(this.owner,"Killing slug...\n");
 		return;
 	}
 
@@ -55,100 +54,103 @@ void swampslug_think(void)
 	// Or we have exited it very recently.
 	// Do the damage and renew the timer.
 #ifdef SVQC
-	Damage (self.owner, self, self, self.dmg, DEATH_SWAMP, other.origin, '0 0 0');
+	Damage (this.owner, this, this, this.dmg, DEATH_SWAMP.m_id, this.owner.origin, '0 0 0');
 #endif
 
-	self.nextthink = time + self.swamp_interval;
+	this.nextthink = time + this.swamp_interval;
 }
 
-void swamp_touch(void)
+void swamp_touch(entity this, entity toucher)
 {
 	// If whatever thats touching the swamp is not a player
 	// or if its a dead player, just dont care abt it.
-	if(!IS_PLAYER(other) || PHYS_DEAD(other))
+	if(!IS_PLAYER(toucher) || IS_DEAD(toucher))
 		return;
 
-	EXACTTRIGGER_TOUCH;
+	EXACTTRIGGER_TOUCH(this, toucher);
 
 	// Chech if player alredy got a swampslug.
-	if(other.in_swamp != 1)
+	if(toucher.in_swamp != 1)
 	{
 		// If not attach one.
-		//centerprint(other,"Entering swamp!\n");
-		other.swampslug = spawn();
-		other.swampslug.health = 2;
-		other.swampslug.think = swampslug_think;
-		other.swampslug.nextthink = time;
-		other.swampslug.owner = other;
-		other.swampslug.dmg = self.dmg;
-		other.swampslug.swamp_interval = self.swamp_interval;
-		other.swamp_slowdown = self.swamp_slowdown;
-		other.in_swamp = 1;
+		//centerprint(toucher,"Entering swamp!\n");
+		toucher.swampslug = spawn();
+		toucher.swampslug.health = 2;
+		setthink(toucher.swampslug, swampslug_think);
+		toucher.swampslug.nextthink = time;
+		toucher.swampslug.owner = toucher;
+		toucher.swampslug.dmg = this.dmg;
+		toucher.swampslug.swamp_interval = this.swamp_interval;
+		toucher.swamp_slowdown = this.swamp_slowdown;
+		toucher.in_swamp = 1;
 		return;
 	}
 
-	//other.in_swamp = 1;
+	//toucher.in_swamp = 1;
 
 	//Revitalize players swampslug
-	other.swampslug.health = 2;
+	toucher.swampslug.health = 2;
 }
 
+REGISTER_NET_LINKED(ENT_CLIENT_SWAMP)
+
 #ifdef SVQC
-float swamp_send(entity to, float sf)
+float swamp_send(entity this, entity to, float sf)
 {
-	WriteByte(MSG_ENTITY, ENT_CLIENT_LADDER);
+	WriteHeader(MSG_ENTITY, ENT_CLIENT_SWAMP);
 
-	WriteByte(MSG_ENTITY, self.dmg); // can probably get away with using a single byte here
-	WriteByte(MSG_ENTITY, self.swamp_slowdown);
-	WriteByte(MSG_ENTITY, self.swamp_interval);
+	WriteByte(MSG_ENTITY, this.dmg); // can probably get away with using a single byte here
+	WriteByte(MSG_ENTITY, this.swamp_slowdown);
+	WriteByte(MSG_ENTITY, this.swamp_interval);
 
-	trigger_common_write(false);
+	trigger_common_write(this, false);
 
 	return true;
 }
 
-void swamp_link()
+void swamp_link(entity this)
 {
-	Net_LinkEntity(self, false, 0, func_ladder_send);
+	trigger_link(this, swamp_send);
 }
 
 /*QUAKED spawnfunc_trigger_swamp (.5 .5 .5) ?
 Players gettin into the swamp will
 get slowd down and damaged
 */
-void spawnfunc_trigger_swamp(void)
+spawnfunc(trigger_swamp)
 {
 	// Init stuff
-	EXACTTRIGGER_INIT;
-	self.touch = swamp_touch;
+	trigger_init(this);
+	settouch(this, swamp_touch);
 
 	// Setup default keys, if missing
-	if(self.dmg <= 0)
-		self.dmg = 5;
-	if(self.swamp_interval <= 0)
-		self.swamp_interval = 1;
-	if(self.swamp_slowdown <= 0)
-		self.swamp_slowdown = 0.5;
-
-	swamp_link();
+	if(this.dmg <= 0)
+		this.dmg = 5;
+	if(this.swamp_interval <= 0)
+		this.swamp_interval = 1;
+	if(this.swamp_slowdown <= 0)
+		this.swamp_slowdown = 0.5;
+
+	swamp_link(this);
 }
 
 #elif defined(CSQC)
 
-void ent_swamp()
+NET_HANDLE(ENT_CLIENT_SWAMP, bool isnew)
 {
-	self.dmg = ReadByte();
-	self.swamp_slowdown = ReadByte();
-	self.swamp_interval = ReadByte();
-
-	trigger_common_read(false);
-
-	self.classname = "trigger_swamp";
-	self.solid = SOLID_TRIGGER;
-	self.draw = trigger_draw_generic;
-	self.trigger_touch = swamp_touch;
-	self.drawmask = MASK_NORMAL;
-	self.move_time = time;
-	self.entremove = trigger_remove_generic;
+	this.dmg = ReadByte();
+	this.swamp_slowdown = ReadByte();
+	this.swamp_interval = ReadByte();
+
+	trigger_common_read(this, false);
+
+	return = true;
+
+	this.classname = "trigger_swamp";
+	this.solid = SOLID_TRIGGER;
+	settouch(this, swamp_touch);
+	this.drawmask = MASK_NORMAL;
+	this.move_time = time;
+	this.entremove = trigger_remove_generic;
 }
 #endif