Merge branch 'samual/water_and_damage_blur' into samual/hud_contents
[xonotic/xonotic-data.pk3dir.git] / qcsrc / client / hook.qc
1 .float HookType; // ENT_CLIENT_*
2 .vector origin;
3 .vector velocity;
4 .float HookSilent;
5 .float HookRange;
6
7 void Draw_CylindricLine(vector from, vector to, float thickness, string texture, float aspect, float shift, vector rgb, float alpha, float drawflag, vector vieworg)
8 {
9         // I want to draw a quad...
10         // from and to are MIDPOINTS.
11         
12         vector axis, thickdir, A, B, C, D;
13         float length_tex;
14
15         axis = normalize(to - from);
16         length_tex = aspect * vlen(to - from) / thickness;
17
18         // direction is perpendicular to the view normal, and perpendicular to the axis
19         thickdir = normalize(cross(axis, vieworg - from));
20
21         A = from - thickdir * (thickness / 2);
22         B = from + thickdir * (thickness / 2);
23         C = to + thickdir * (thickness / 2);
24         D = to - thickdir * (thickness / 2);
25
26         R_BeginPolygon(texture, drawflag);
27         R_PolygonVertex(A, '0 0 0' + shift * '1 0 0', rgb, alpha);
28         R_PolygonVertex(B, '0 1 0' + shift * '1 0 0', rgb, alpha);
29         R_PolygonVertex(C, '0 1 0' + (shift + length_tex) * '1 0 0', rgb, alpha);
30         R_PolygonVertex(D, '0 0 0' + (shift + length_tex) * '1 0 0', rgb, alpha);
31         R_EndPolygon();
32 }
33
34 string Draw_GrapplingHook_trace_callback_tex;
35 float Draw_GrapplingHook_trace_callback_rnd;
36 vector Draw_GrapplingHook_trace_callback_rgb;
37 float Draw_GrapplingHook_trace_callback_a;
38 void Draw_GrapplingHook_trace_callback(vector start, vector hit, vector end)
39 {
40         float i;
41         vector vorg;
42         vorg = WarpZone_TransformOrigin(WarpZone_trace_transform, view_origin);
43         for(i = 0; i < Draw_GrapplingHook_trace_callback_a; ++i)
44                 Draw_CylindricLine(hit, start, 8, Draw_GrapplingHook_trace_callback_tex, 0.25, Draw_GrapplingHook_trace_callback_rnd, Draw_GrapplingHook_trace_callback_rgb, min(1, Draw_GrapplingHook_trace_callback_a - i), DRAWFLAG_NORMAL, vorg);
45         Draw_GrapplingHook_trace_callback_rnd += 0.25 * vlen(hit - start) / 8;
46 }
47
48 .float teleport_time;
49 void Draw_GrapplingHook()
50 {
51         vector a, b, atrans;
52         string tex;
53         vector rgb;
54         float t;
55         float s;
56         vector vs;
57         float intensity, offset;
58
59         if(self.teleport_time)
60         if(time > self.teleport_time)
61         {
62                 sound (self, CHAN_PROJECTILE, "misc/null.wav", VOL_BASE, ATTN_NORM); // safeguard
63                 self.teleport_time = 0;
64         }
65
66         InterpolateOrigin_Do();
67
68         s = autocvar_cl_gunalign;
69         if(s != 1 && s != 2 && s != 4)
70                 s = 3; // default value
71         --s;
72         switch(self.HookType)
73         {
74                 default:
75                 case ENT_CLIENT_HOOK:
76                         vs = hook_shotorigin[s];
77                         break;
78                 case ENT_CLIENT_LGBEAM:
79                         vs = electro_shotorigin[s];
80                         break;
81                 case ENT_CLIENT_GAUNTLET:
82                         vs = gauntlet_shotorigin[s];
83                         break;
84         }
85
86         if((self.owner.sv_entnum == player_localentnum - 1))
87         {
88                 switch(self.HookType)
89                 {
90                         default:
91                         case ENT_CLIENT_HOOK:
92                                 a = view_origin + view_forward * vs_x + view_right * -vs_y + view_up * vs_z;
93                                 b = self.origin;
94                                 break;
95                         case ENT_CLIENT_LGBEAM:
96                         case ENT_CLIENT_GAUNTLET:
97                                 if(self.HookRange)
98                                         b = view_origin + view_forward * self.HookRange;
99                                 else
100                                         b = view_origin + view_forward * vlen(self.velocity - self.origin); // honor original length of beam!
101                                 WarpZone_TraceLine(view_origin, b, MOVE_NORMAL, world);
102                                 b = WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos);
103                                 a = view_origin + view_forward * vs_x + view_right * -vs_y + view_up * vs_z;
104                                 break;
105                 }
106         }
107         else
108         {
109                 switch(self.HookType)
110                 {
111                         default:
112                         case ENT_CLIENT_HOOK:
113                                 a = self.velocity;
114                                 b = self.origin;
115                                 break;
116                         case ENT_CLIENT_LGBEAM:
117                         case ENT_CLIENT_GAUNTLET:
118                                 a = self.origin;
119                                 b = self.velocity;
120                                 break;
121                 }
122         }
123
124         t = GetPlayerColorForce(self.owner.sv_entnum);
125
126         switch(self.HookType)
127         {
128                 default:
129                 case ENT_CLIENT_HOOK:
130                         intensity = 1;
131                         offset = 0;
132                         if(t == COLOR_TEAM1)
133                         {
134                                 tex = "particles/hook_red";
135                                 rgb = '1 .3 .3';
136                         }
137                         else if(t == COLOR_TEAM2)
138                         {
139                                 tex = "particles/hook_blue";
140                                 rgb = '.3 .3 1';
141                         }
142                         else if(t == COLOR_TEAM3)
143                         {
144                                 tex = "particles/hook_yellow";
145                                 rgb = '1 1 .3';
146                         }
147                         else if(t == COLOR_TEAM4)
148                         {
149                                 tex = "particles/hook_pink";
150                                 rgb = '1 .3 1';
151                         }
152                         else
153                         {
154                                 tex = "particles/hook_green";
155                                 rgb = '.3 1 .3';
156                         }
157                         break;
158                 case ENT_CLIENT_LGBEAM:
159                         intensity = bound(0.2, 1 + Noise_Pink(self, frametime) * 1 + Noise_Burst(self, frametime, 0.03) * 0.3, 2);
160                         offset = Noise_Brown(self, frametime) * 10;
161                         tex = "particles/lgbeam";
162                         rgb = '1 1 1';
163                         break;
164                 case ENT_CLIENT_GAUNTLET:
165                         intensity = 1;
166                         offset = Noise_White(self, frametime);
167                         tex = "particles/gauntletbeam";
168                         rgb = '1 1 1';
169                         break;
170         }
171
172         Draw_GrapplingHook_trace_callback_tex = tex;
173         Draw_GrapplingHook_trace_callback_rnd = offset;
174         Draw_GrapplingHook_trace_callback_rgb = rgb;
175         Draw_GrapplingHook_trace_callback_a = intensity;
176         WarpZone_TraceBox_ThroughZone(a, '0 0 0', '0 0 0', b, ((self.HookType == ENT_CLIENT_HOOK) ? MOVE_NOTHING : MOVE_NORMAL), world, world, Draw_GrapplingHook_trace_callback);
177         Draw_GrapplingHook_trace_callback_tex = string_null;
178
179         atrans = WarpZone_TransformOrigin(WarpZone_trace_transform, a);
180
181         switch(self.HookType)
182         {
183                 default:
184                 case ENT_CLIENT_HOOK:
185                         if(vlen(trace_endpos - atrans) > 0.5)
186                         {
187                                 setorigin(self, trace_endpos); // hook endpoint!
188                                 self.angles = vectoangles(trace_endpos - atrans);
189                                 self.drawmask = MASK_NORMAL;
190                         }
191                         else
192                         {
193                                 self.drawmask = 0;
194                         }
195                         break;
196                 case ENT_CLIENT_LGBEAM:
197                 case ENT_CLIENT_GAUNTLET:
198                         setorigin(self, a); // beam origin!
199                         break;
200         }
201
202         switch(self.HookType)
203         {
204                 default:
205                 case ENT_CLIENT_HOOK:
206                         break;
207                 case ENT_CLIENT_LGBEAM:
208                         pointparticles(particleeffectnum("electro_lightning"), trace_endpos, normalize(atrans - trace_endpos), frametime * intensity);
209                         break;
210                 case ENT_CLIENT_GAUNTLET:
211                         pointparticles(particleeffectnum("gauntlet_lightning"), b, normalize(a - b), frametime * intensity);
212                         break;
213         }
214 }
215
216 void Remove_GrapplingHook()
217 {
218         sound (self, CHAN_PROJECTILE, "misc/null.wav", VOL_BASE, ATTN_NORM);
219 }
220
221 void Ent_ReadHook(float bIsNew, float type)
222 {
223         self.HookType = type;
224
225         float sf;
226         sf = ReadByte();
227
228         self.HookSilent = (sf & 0x80);
229         self.iflags = IFLAG_VELOCITY;
230
231         InterpolateOrigin_Undo();
232
233         if(sf & 1)
234         {
235                 self.owner = playerslots[ReadByte() - 1];
236                 switch(self.HookType)
237                 {
238                         default:
239                         case ENT_CLIENT_HOOK:
240                         case ENT_CLIENT_GAUNTLET:
241                                 self.HookRange = 0;
242                                 break;
243                         case ENT_CLIENT_LGBEAM:
244                                 self.HookRange = ReadCoord();
245                                 break;
246                 }
247         }
248         if(sf & 2)
249         {
250                 self.origin_x = ReadCoord();
251                 self.origin_y = ReadCoord();
252                 self.origin_z = ReadCoord();
253                 setorigin(self, self.origin);
254         }
255         if(sf & 4)
256         {
257                 self.velocity_x = ReadCoord();
258                 self.velocity_y = ReadCoord();
259                 self.velocity_z = ReadCoord();
260         }
261
262         InterpolateOrigin_Note();
263
264         if(bIsNew || !self.teleport_time)
265         {
266                 self.draw = Draw_GrapplingHook;
267                 self.entremove = Remove_GrapplingHook;
268
269                 switch(self.HookType)
270                 {
271                         default:
272                         case ENT_CLIENT_HOOK:
273                                 // for the model
274                                 setmodel(self, "models/hook.md3");
275                                 self.drawmask = MASK_NORMAL;
276                                 break;
277                         case ENT_CLIENT_LGBEAM:
278                                 sound (self, CHAN_PROJECTILE, "weapons/lgbeam_fly.wav", VOL_BASE, ATTN_NORM);
279                                 break;
280                         case ENT_CLIENT_GAUNTLET:
281                                 sound (self, CHAN_PROJECTILE, "weapons/gauntletbeam_fly.wav", VOL_BASE, ATTN_NORM);
282                                 break;
283                 }
284         }
285
286         self.teleport_time = time + 10;
287 }
288
289 void Hook_Precache()
290 {
291         precache_sound("weapons/lgbeam_fly.wav");
292         precache_sound("weapons/gauntletbeam_fly.wav");
293         precache_model("models/hook.md3");
294 }
295
296 // TODO: hook: temporarily transform self.origin for drawing the model along warpzones!