89c659530b607bef5c7b9c4316f64b9c045da995
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / triggers / misc / laser.qc
1 #if defined(CSQC)
2         #include "../../../lib/csqcmodel/interpolate.qh"
3         #include "../../../client/main.qh"
4         #include "../../../lib/csqcmodel/cl_model.qh"
5 #elif defined(MENUQC)
6 #elif defined(SVQC)
7 #endif
8
9 REGISTER_NET_LINKED(ENT_CLIENT_LASER)
10
11 #ifdef SVQC
12 .float modelscale;
13 void misc_laser_aim()
14 {SELFPARAM();
15         vector a;
16         if(self.enemy)
17         {
18                 if(self.spawnflags & 2)
19                 {
20                         if(self.enemy.origin != self.mangle)
21                         {
22                                 self.mangle = self.enemy.origin;
23                                 self.SendFlags |= 2;
24                         }
25                 }
26                 else
27                 {
28                         a = vectoangles(self.enemy.origin - self.origin);
29                         a_x = -a_x;
30                         if(a != self.mangle)
31                         {
32                                 self.mangle = a;
33                                 self.SendFlags |= 2;
34                         }
35                 }
36         }
37         else
38         {
39                 if(self.angles != self.mangle)
40                 {
41                         self.mangle = self.angles;
42                         self.SendFlags |= 2;
43                 }
44         }
45         if(self.origin != self.oldorigin)
46         {
47                 self.SendFlags |= 1;
48                 self.oldorigin = self.origin;
49         }
50 }
51
52 void misc_laser_init()
53 {SELFPARAM();
54         if(self.target != "")
55                 self.enemy = find(world, targetname, self.target);
56 }
57
58 .entity pusher;
59 void misc_laser_think()
60 {SELFPARAM();
61         vector o;
62         entity hitent;
63         vector hitloc;
64
65         self.nextthink = time;
66
67         if(!self.state)
68                 return;
69
70         misc_laser_aim();
71
72         if(self.enemy)
73         {
74                 o = self.enemy.origin;
75                 if (!(self.spawnflags & 2))
76                         o = self.origin + normalize(o - self.origin) * 32768;
77         }
78         else
79         {
80                 makevectors(self.mangle);
81                 o = self.origin + v_forward * 32768;
82         }
83
84         if(self.dmg || self.enemy.target != "")
85         {
86                 traceline(self.origin, o, MOVE_NORMAL, self);
87         }
88         hitent = trace_ent;
89         hitloc = trace_endpos;
90
91         if(self.enemy.target != "") // DETECTOR laser
92         {
93                 if(trace_ent.iscreature)
94                 {
95                         self.pusher = hitent;
96                         if(!self.count)
97                         {
98                                 self.count = 1;
99
100                                 activator = self.enemy.pusher;
101                                 WITH(entity, self, self.enemy, SUB_UseTargets());
102                         }
103                 }
104                 else
105                 {
106                         if(self.count)
107                         {
108                                 self.count = 0;
109
110                                 activator = self.enemy.pusher;
111                                 WITH(entity, self, self.enemy, SUB_UseTargets());
112                         }
113                 }
114         }
115
116         if(self.dmg)
117         {
118                 if(self.team)
119                         if(((self.spawnflags & 8) == 0) == (self.team != hitent.team))
120                                 return;
121                 if(hitent.takedamage)
122                         Damage(hitent, self, self, ((self.dmg < 0) ? 100000 : (self.dmg * frametime)), DEATH_HURTTRIGGER.m_id, hitloc, '0 0 0');
123         }
124 }
125
126 bool laser_SendEntity(entity this, entity to, float fl)
127 {
128         WriteHeader(MSG_ENTITY, ENT_CLIENT_LASER);
129         fl = fl - (fl & 0xF0); // use that bit to indicate finite length laser
130         if(self.spawnflags & 2)
131                 fl |= 0x80;
132         if(self.alpha)
133                 fl |= 0x40;
134         if(self.scale != 1 || self.modelscale != 1)
135                 fl |= 0x20;
136         if(self.spawnflags & 4)
137                 fl |= 0x10;
138         WriteByte(MSG_ENTITY, fl);
139         if(fl & 1)
140         {
141                 WriteCoord(MSG_ENTITY, self.origin_x);
142                 WriteCoord(MSG_ENTITY, self.origin_y);
143                 WriteCoord(MSG_ENTITY, self.origin_z);
144         }
145         if(fl & 8)
146         {
147                 WriteByte(MSG_ENTITY, self.colormod_x * 255.0);
148                 WriteByte(MSG_ENTITY, self.colormod_y * 255.0);
149                 WriteByte(MSG_ENTITY, self.colormod_z * 255.0);
150                 if(fl & 0x40)
151                         WriteByte(MSG_ENTITY, self.alpha * 255.0);
152                 if(fl & 0x20)
153                 {
154                         WriteByte(MSG_ENTITY, bound(0, self.scale * 16.0, 255));
155                         WriteByte(MSG_ENTITY, bound(0, self.modelscale * 16.0, 255));
156                 }
157                 if((fl & 0x80) || !(fl & 0x10)) // effect doesn't need sending if the laser is infinite and has collision testing turned off
158                         WriteShort(MSG_ENTITY, self.cnt + 1);
159         }
160         if(fl & 2)
161         {
162                 if(fl & 0x80)
163                 {
164                         WriteCoord(MSG_ENTITY, self.enemy.origin_x);
165                         WriteCoord(MSG_ENTITY, self.enemy.origin_y);
166                         WriteCoord(MSG_ENTITY, self.enemy.origin_z);
167                 }
168                 else
169                 {
170                         WriteAngle(MSG_ENTITY, self.mangle_x);
171                         WriteAngle(MSG_ENTITY, self.mangle_y);
172                 }
173         }
174         if(fl & 4)
175                 WriteByte(MSG_ENTITY, self.state);
176         return 1;
177 }
178
179 /*QUAKED spawnfunc_misc_laser (.5 .5 .5) ? START_ON DEST_IS_FIXED
180 Any object touching the beam will be hurt
181 Keys:
182 "target"
183  spawnfunc_target_position where the laser ends
184 "mdl"
185  name of beam end effect to use
186 "colormod"
187  color of the beam (default: red)
188 "dmg"
189  damage per second (-1 for a laser that kills immediately)
190 */
191 void laser_use()
192 {SELFPARAM();
193         self.state = !self.state;
194         self.SendFlags |= 4;
195         misc_laser_aim();
196 }
197
198 void laser_reset(entity this)
199 {
200         if(this.spawnflags & 1)
201                 this.state = 1;
202         else
203                 this.state = 0;
204 }
205
206 spawnfunc(misc_laser)
207 {
208         if(this.mdl)
209         {
210                 if(this.mdl == "none")
211                         this.cnt = -1;
212                 else
213                 {
214                         this.cnt = _particleeffectnum(this.mdl);
215                         if(this.cnt < 0 && this.dmg)
216                 this.cnt = particleeffectnum(EFFECT_LASER_DEADLY);
217                 }
218         }
219         else if(!this.cnt)
220         {
221                 if(this.dmg)
222                         this.cnt = particleeffectnum(EFFECT_LASER_DEADLY);
223                 else
224                         this.cnt = -1;
225         }
226         if(this.cnt < 0)
227                 this.cnt = -1;
228
229         if(this.colormod == '0 0 0')
230                 if(!this.alpha)
231                         this.colormod = '1 0 0';
232         if(this.message == "") this.message = "saw the light";
233         if (this.message2 == "") this.message2 = "was pushed into a laser by";
234         if(!this.scale) this.scale = 1;
235         if(!this.modelscale) this.modelscale = 1;
236         else if(this.modelscale < 0) this.modelscale = 0;
237         this.think = misc_laser_think;
238         this.nextthink = time;
239         InitializeEntity(this, misc_laser_init, INITPRIO_FINDTARGET);
240
241         this.mangle = this.angles;
242
243         Net_LinkEntity(this, false, 0, laser_SendEntity);
244
245         IFTARGETED
246         {
247                 this.reset = laser_reset;
248                 this.reset(this);
249                 this.use = laser_use;
250         }
251         else
252                 this.state = 1;
253 }
254 #elif defined(CSQC)
255
256 // a laser goes from origin in direction angles
257 // it has color 'colormod'
258 // and stops when something is in the way
259 entityclass(Laser);
260 class(Laser) .int cnt; // end effect
261 class(Laser) .vector colormod;
262 class(Laser) .int state; // on-off
263 class(Laser) .int count; // flags for the laser
264 class(Laser) .vector velocity;
265 class(Laser) .float alpha;
266 class(Laser) .float scale; // scaling factor of the thickness
267 class(Laser) .float modelscale; // scaling factor of the dlight
268
269 void Draw_Laser(entity this)
270 {
271         if(!self.state)
272                 return;
273         InterpolateOrigin_Do(self);
274         if(self.count & 0x80)
275         {
276                 if(self.count & 0x10)
277                 {
278                         trace_endpos = self.velocity;
279                         trace_dphitq3surfaceflags = 0;
280                 }
281                 else
282                         traceline(self.origin, self.velocity, 0, self);
283         }
284         else
285         {
286                 if(self.count & 0x10)
287                 {
288                         makevectors(self.angles);
289                         trace_endpos = self.origin + v_forward * 1048576;
290                         trace_dphitq3surfaceflags = Q3SURFACEFLAG_SKY;
291                 }
292                 else
293                 {
294                         makevectors(self.angles);
295                         traceline(self.origin, self.origin + v_forward * 32768, 0, self);
296                         if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_SKY)
297                                 trace_endpos = self.origin + v_forward * 1048576;
298                 }
299         }
300         if(self.scale != 0)
301         {
302                 if(self.alpha)
303                 {
304                         Draw_CylindricLine(self.origin, trace_endpos, self.scale, "particles/laserbeam", 0, time * 3, self.colormod, self.alpha, DRAWFLAG_NORMAL, view_origin);
305                 }
306                 else
307                 {
308                         Draw_CylindricLine(self.origin, trace_endpos, self.scale, "particles/laserbeam", 0, time * 3, self.colormod, 0.5, DRAWFLAG_ADDITIVE, view_origin);
309                 }
310         }
311         if (!(trace_dphitq3surfaceflags & (Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NOIMPACT)))
312         {
313                 if(self.cnt >= 0)
314                         __pointparticles(self.cnt, trace_endpos, trace_plane_normal, drawframetime * 1000);
315                 if(self.colormod != '0 0 0' && self.modelscale != 0)
316                         adddynamiclight(trace_endpos + trace_plane_normal * 1, self.modelscale, self.colormod * 5);
317         }
318 }
319
320 NET_HANDLE(ENT_CLIENT_LASER, bool isnew)
321 {
322         InterpolateOrigin_Undo(self);
323
324         // 30 bytes, or 13 bytes for just moving
325         int f = ReadByte();
326         self.count = (f & 0xF0);
327
328         if(self.count & 0x80)
329                 self.iflags = IFLAG_VELOCITY | IFLAG_ORIGIN;
330         else
331                 self.iflags = IFLAG_ANGLES | IFLAG_ORIGIN;
332
333         if(f & 1)
334         {
335                 self.origin_x = ReadCoord();
336                 self.origin_y = ReadCoord();
337                 self.origin_z = ReadCoord();
338                 setorigin(self, self.origin);
339         }
340         if(f & 8)
341         {
342                 self.colormod_x = ReadByte() / 255.0;
343                 self.colormod_y = ReadByte() / 255.0;
344                 self.colormod_z = ReadByte() / 255.0;
345                 if(f & 0x40)
346                         self.alpha = ReadByte() / 255.0;
347                 else
348                         self.alpha = 0;
349                 self.scale = 2;
350                 self.modelscale = 50;
351                 if(f & 0x20)
352                 {
353                         self.scale *= ReadByte() / 16.0; // beam radius
354                         self.modelscale *= ReadByte() / 16.0; // dlight radius
355                 }
356                 if((f & 0x80) || !(f & 0x10))
357                         self.cnt = ReadShort() - 1; // effect number
358                 else
359                         self.cnt = 0;
360         }
361         if(f & 2)
362         {
363                 if(f & 0x80)
364                 {
365                         self.velocity_x = ReadCoord();
366                         self.velocity_y = ReadCoord();
367                         self.velocity_z = ReadCoord();
368                 }
369                 else
370                 {
371                         self.angles_x = ReadAngle();
372                         self.angles_y = ReadAngle();
373                 }
374         }
375         if(f & 4)
376                 self.state = ReadByte();
377
378         return = true;
379
380         InterpolateOrigin_Note(this);
381         self.draw = Draw_Laser;
382 }
383 #endif