a3ecfb558499f6f4fa0b186ae396952dd158a0c5
[voretournament/voretournament.git] / data / qcsrc / server / vore.qc
1 .float stomachkick_delay, system_delay, action_delay, digest_button_delay_time, regurgitate_button_delay_time;\r
2 .float complain_vore;\r
3 .float vore_oldmovetype, vore_oldsolid;\r
4 \r
5 const float system_delay_time = 0.1;\r
6 const float complain_delay_time = 1;\r
7 const float button_delay_time = 0.5;\r
8 \r
9 entity Swallow_player_check()\r
10 {\r
11         // check if we can swallow a player instead of firing our weapon\r
12 \r
13         float swallow_range;\r
14         vector vore_w_shotorg, vore_w_shotdir;\r
15 \r
16         swallow_range = cvar("g_balance_vore_swallow_range");\r
17         if(cvar("g_healthsize")) // we can swallow from further or closer based on our size\r
18                 swallow_range *= self.scale;\r
19         makevectors(self.angles);\r
20         vore_w_shotorg = self.origin;\r
21         vore_w_shotdir = v_forward;\r
22 \r
23         if(self.antilag_debug)\r
24                 WarpZone_traceline_antilag(self, vore_w_shotorg, vore_w_shotorg + vore_w_shotdir * swallow_range, FALSE, self, self.antilag_debug);\r
25         else\r
26                 WarpZone_traceline_antilag(self, vore_w_shotorg, vore_w_shotorg + vore_w_shotdir * swallow_range, FALSE, self, ANTILAG_LATENCY(self));\r
27         if(trace_fraction < 1)\r
28         if(trace_ent.classname == "player")\r
29                 return trace_ent;\r
30         return world;\r
31 }\r
32 \r
33 float Swallow_condition_check(entity prey)\r
34 {\r
35         // checks the necessary conditions for swallowing a player\r
36 \r
37         if(prey != self)\r
38         if(prey.classname == "player" && !prey.stat_eaten && prey.deadflag == DEAD_NO) // we can't swallow someone who's already in someone else's stomach\r
39         if(self.classname == "player" && !self.stat_eaten && self.deadflag == DEAD_NO) // we can't swallow players while inside someone's stomach ourselves\r
40         if(!self.BUTTON_REGURGITATE && time > self.action_delay)\r
41         {\r
42                 float prey_mass;\r
43                 prey_mass = cvar("g_balance_vore_load_prey_mass");\r
44                 if(cvar("g_healthsize"))\r
45                         prey_mass *= prey.scale;\r
46 \r
47                 string swallow_complain;\r
48                 if(teams_matter && prey.team == self.team && !cvar("g_vore_teamvore"))\r
49                         swallow_complain = "You cannot swallow your team mates\n";\r
50                 else if(!cvar("g_vore_spawnshield") && prey.spawnshieldtime > time)\r
51                         swallow_complain = "You cannot swallow someone protected by the spawn shield\n";\r
52                 else if(self.stomach_load + prey_mass > self.stomach_maxload)\r
53                         swallow_complain = strcat("You don't have any room to swallow this player. Their mass is ^3", ftos(prey_mass), "^7 and your remaining capacity is ^3", ftos(self.stomach_maxload - self.stomach_load), "\n");\r
54                 else if(cvar("g_vore_biggergut") && prey.stomach_load > self.stomach_load)\r
55                         swallow_complain = "You cannot swallow someone with a bigger stomach than yours\n";\r
56                 else if(cvar("g_vore_biggersize") && prey.scale > self.scale)\r
57                         swallow_complain = "You cannot swallow someone larger than you\n";\r
58 \r
59                 if(swallow_complain != "")\r
60                 {\r
61                         if(time > self.complain_vore && self.BUTTON_ATCK)\r
62                         {\r
63                                 play2(self, "misc/forbidden.wav");\r
64                                 sprint(self, swallow_complain);\r
65                                 self.complain_vore = time + complain_delay_time;\r
66                         }\r
67                         return FALSE;\r
68                 }\r
69                 return TRUE;\r
70         }\r
71         return FALSE;\r
72 }\r
73 \r
74 float Stomach_TeamMates_check(entity pred)\r
75 {\r
76         // checks if a player's stomach contains any team mates\r
77 \r
78         entity head;\r
79         if(teams_matter)\r
80         {\r
81                 FOR_EACH_PLAYER(head)\r
82                 {\r
83                         if(head.predator == pred && head.team == pred.team)\r
84                                 return TRUE;\r
85                 }\r
86         }\r
87         return FALSE;\r
88 }\r
89 \r
90 float Stomach_HasLivePrey(entity pred)\r
91 {\r
92         entity head;\r
93         FOR_EACH_PLAYER(head)\r
94         {\r
95                 if(head.predator == pred)\r
96                 if(head.deadflag == DEAD_NO)\r
97                         return TRUE;\r
98         }\r
99         return FALSE;\r
100 }\r
101 \r
102 float Vore_CanLeave()\r
103 {\r
104         if(self.stat_eaten)\r
105         {\r
106                 if(!cvar("g_vore_kick")) // you are defenseless in the stomach if you can't kick, so allow leaving\r
107                         return TRUE;\r
108                 if(teams_matter && self.team == self.predator.team)\r
109                         return TRUE;\r
110                 if(g_rpg && cvar("g_rpg_canleave"))\r
111                         return TRUE;\r
112         }\r
113         return FALSE;\r
114 }\r
115 \r
116 // position the camera properly for prey\r
117 void Vore_SetPreyPositions(entity pred)\r
118 {\r
119         // pred is the predator and head is the prey\r
120 \r
121         local entity head;\r
122 \r
123         // In order to allow prey to see each other in the stomach, we must position each occupant differently,\r
124         // else all players overlap in the center. To do this, we use a random origin on all players in the same stomach.\r
125         FOR_EACH_PLAYER(head)\r
126         {\r
127                 if(head.predator == pred)\r
128                 {\r
129                         // since prey have their predators set as an aiment, view_ofs will specify the real origin of prey, not just the view offset\r
130                         head.view_ofs_x = PL_PREY_VIEW_OFS_x + crandom() * cvar("g_vore_neighborprey_distance");\r
131                         head.view_ofs_y = PL_PREY_VIEW_OFS_y + crandom() * cvar("g_vore_neighborprey_distance");\r
132                         head.view_ofs_z = PL_PREY_VIEW_OFS_z;\r
133                 }\r
134         }\r
135 }\r
136 \r
137 .float gurgle_oldstomachload;\r
138 void Vore_GurgleSound()\r
139 {\r
140         if(time > self.gurglesound_finished || (self.gurgle_oldstomachload != self.stomach_load && !self.digesting))\r
141         {\r
142                 GlobalSound(self.playersound_gurgle, CHAN_TRIGGER, VOICETYPE_GURGLE, VOL_BASE);\r
143 \r
144                 // yes, hard coded sound length. I know it's bad but what can I do?\r
145                 if(cvar("g_healthsize") && cvar("g_healthsize_pitch"))\r
146                         self.gurglesound_finished = time + 11 * pow(self.scale, -cvar("g_healthsize_pitch")); // modified sound pitch, based on player scale\r
147                 else\r
148                         self.gurglesound_finished = time + 11; // yes, hard coded sound length. I know it's bad but what can I do?\r
149 \r
150                 self.gurgle_oldstomachload = self.stomach_load;\r
151         }\r
152 }\r
153 \r
154 void Vore_AutoDigest(entity e)\r
155 {\r
156         // if the predator has the autodigest preference enabled, begin digesting new prey automatically\r
157 \r
158         if(!cvar("g_vore_digestion") || e.digesting)\r
159                 return;\r
160         if(g_rpg)\r
161                 return; // RPG is choice based, so don't do things automatically there\r
162         if(e.stomach_load)\r
163                 return; // don't start digestion if we already ate someone, as that means we manually disabled it after the first prey and want it off\r
164         if(clienttype(e) != CLIENTTYPE_REAL)\r
165                 return; // this feature is only for players, not bots\r
166         if(Stomach_TeamMates_check(e))\r
167                 return; // never begin automatic digestion if we've swallowed a team mate\r
168 \r
169         e.digesting = TRUE;\r
170 }\r
171 \r
172 void Vore_StomachLoad_Apply()\r
173 {\r
174         // apply stomach weight that makes you heavier and larger the more you eat\r
175         // slowing the player is done in cl_physics.qc\r
176         if(self.classname != "player")\r
177                 return;\r
178 \r
179         entity e;\r
180         float prey_mass, final_load;\r
181 \r
182         // apply the stomach capacity of the predator\r
183         self.stomach_maxload = cvar("g_balance_vore_load_pred_capacity");\r
184         if(cvar("g_healthsize"))\r
185                 self.stomach_maxload *= self.scale;\r
186         self.stomach_maxload = ceil(self.stomach_maxload);\r
187 \r
188         FOR_EACH_PLAYER(e)\r
189         {\r
190                 if(e.predator == self)\r
191                 {\r
192                         prey_mass = cvar("g_balance_vore_load_prey_mass");\r
193                         if(cvar("g_healthsize"))\r
194                                 prey_mass *= e.scale;\r
195                         final_load += ceil(prey_mass);\r
196                         if(self.cvar_cl_vore_autodigest > 1)\r
197                                 Vore_AutoDigest(self);\r
198                 }\r
199         }\r
200         for(e = world; (e = find(e, classname, "consumable")); )\r
201         {\r
202                 if(e.predator == self)\r
203                 {\r
204                         final_load += ceil(e.dmg);\r
205                         if(self.cvar_cl_vore_autodigest > 0)\r
206                                 Vore_AutoDigest(self);\r
207                 }\r
208         }\r
209         self.stomach_load = final_load;\r
210 \r
211         // apply weight\r
212         self.gravity = 1 * (cvar("g_healthsize") ? pow(self.scale, cvar("g_healthsize_weight")) : 1) + (self.stomach_load / self.stomach_maxload) * cvar("g_balance_vore_load_pred_weight");\r
213         if(!self.gravity && self.stomach_load)\r
214                 self.gravity = 0.00001; // 0 becomes 1 for gravity, so do this to allow 0 gravity\r
215 }\r
216 \r
217 .entity swallow_model;\r
218 float Vore_SwallowModel_CustomizeEntityForClient()\r
219 {\r
220         // use the same system as the weapon model\r
221 \r
222         self.viewmodelforclient = self.owner;\r
223         self.alpha = self.owner.cvar_cl_vore_swallowmodel;\r
224 \r
225         if(other.classname == "spectator")\r
226         if(other.enemy == self.owner)\r
227         {\r
228                 self.viewmodelforclient = other;\r
229                 self.alpha = other.cvar_cl_vore_swallowmodel;\r
230         }\r
231 \r
232         return TRUE;\r
233 }\r
234 \r
235 void Vore_SwallowModel_Think()\r
236 {\r
237         // update the position of the swallow model to match our swallow progress\r
238         float dist;\r
239         dist = (-0.5 + self.owner.swallow_progress_prey) * cvar("g_vore_swallowmodel_range"); // the model is centered at 0.5 progress\r
240         if(cvar("g_healthsize"))\r
241                 dist *= self.scale;\r
242         self.view_ofs = '1 0 0' * dist;\r
243 \r
244         // if our swallow progress is gone or we are dead, the swallow model also goes away\r
245         if(!self.owner.swallow_progress_prey || self.owner.deadflag != DEAD_NO || self.owner.classname != "player")\r
246         {\r
247                 remove(self.owner.swallow_model);\r
248                 self.owner.swallow_model = world;\r
249                 return;\r
250         }\r
251 \r
252         // properties that should update whenever possible, but when the predator is not available\r
253         self.nextthink = time;\r
254 }\r
255 \r
256 void Vore_SwallowModel_Update(entity prey, entity pred)\r
257 {\r
258         // if we don't have a swallow model already, spawn one\r
259         if(!prey.swallow_model)\r
260         {\r
261                 prey.swallow_model = spawn();\r
262                 prey.swallow_model.movetype = MOVETYPE_FOLLOW;\r
263                 prey.swallow_model.solid = SOLID_NOT;\r
264                 //prey.swallow_model.effects |= EF_NOGUNBOB; // let it bob\r
265                 prey.swallow_model.effects |= EF_NODEPTHTEST; // don't hide behind walls\r
266                 prey.swallow_model.owner = prey;\r
267                 prey.swallow_model.customizeentityforclient = Vore_SwallowModel_CustomizeEntityForClient;\r
268                 prey.swallow_model.think = Vore_SwallowModel_Think;\r
269                 prey.swallow_model.nextthink = time;\r
270         }\r
271 \r
272         // properties that should update whenever possible, but when the predator is available\r
273         string player_swallowmodel;\r
274         player_swallowmodel = strcat(substring(pred.playermodel, 0, strlen(pred.playermodel) - 4), "_swallow.iqm"); // 4 is the extension length\r
275         if(prey.swallow_model.model != player_swallowmodel) // player model can be changed while the predator is active\r
276                 setmodel(prey.swallow_model, player_swallowmodel);\r
277         if(prey.swallow_model.skin != pred.skin) // player skin can be changed while the predator is active\r
278                 prey.swallow_model.skin = pred.skin;\r
279         if(cvar("g_healthsize"))\r
280                 prey.swallow_model.scale = pred.scale / prey.scale; // player size difference\r
281         if(prey.swallow_model.enemy != pred)\r
282                 prey.swallow_model.enemy = pred; // enemy is the predator\r
283         if(prey.swallow_model.colormap != pred.colormap)\r
284                 prey.swallow_model.colormap = pred.colormap; // pants and shirt color\r
285         if(prey.swallow_model.glowmod != pred.glowmod)\r
286                 prey.swallow_model.glowmod = pred.glowmod; // glow color\r
287 }\r
288 \r
289 .entity pusher;\r
290 .float pushltime;\r
291 void Vore_Swallow(entity e)\r
292 {\r
293         // this player is being swallowed by another player, apply the proper changes\r
294 \r
295         e.vore_oldmovetype = e.movetype;\r
296         e.vore_oldsolid = e.solid;\r
297         e.punchvector_z = cvar("g_balance_vore_swallow_prey_punchvector");\r
298 \r
299         e.predator = self;\r
300         setorigin(e, e.predator.origin);\r
301         e.velocity = '0 0 0';\r
302         e.movetype = MOVETYPE_FOLLOW;\r
303         e.solid = SOLID_NOT;\r
304         e.aiment = e.predator; // follow the predator, automatically unset when regurgitated\r
305 \r
306         float scalediff;\r
307         scalediff = cvar("g_healthsize") ? e.scale / e.predator.scale : 1; // the tighter the gut, the greater the effect\r
308 \r
309         // drop keys (KH) and flags (CTF) when we get swallowed\r
310         kh_Key_DropAll(e, FALSE);\r
311         if(e.flagcarried)\r
312                 DropFlag(e.flagcarried, world, e.predator);\r
313 \r
314         if(stov(cvar_string("g_vore_regurgitatecolor_color_normal")))\r
315                 e.colormod = stov(cvar_string("g_vore_regurgitatecolor_color_normal"));\r
316 \r
317         if(teams_matter && e.team == e.predator.team)\r
318         {\r
319                 if(cvar("g_vore_kick"))\r
320                         centerprint(e, "^3You have been swallowed by a team mate, don't kick!");\r
321                 if(cvar("g_vore_digestion"))\r
322                         centerprint(e.predator, "^3You have swallowed a team mate, don't digest!");\r
323         }\r
324 \r
325         PlayerSound(e.predator, playersound_swallow, CHAN_VOICE, VOICETYPE_PLAYERSOUND);\r
326         setanim(e.predator, e.predator.anim_pain1, FALSE, TRUE, TRUE); // looks good for swallowing / regurgitating\r
327         e.predator.punchangle_x = crandom() * cvar("g_balance_vore_swallow_predator_punchangle") * scalediff;\r
328         e.predator.punchangle_y = crandom() * cvar("g_balance_vore_swallow_predator_punchangle") * scalediff;\r
329         e.predator.punchangle_z = crandom() * cvar("g_balance_vore_swallow_predator_punchangle") * scalediff;\r
330         e.predator.regurgitate_prepare = 0;\r
331         e.predator.spawnshieldtime = 0; // lose spawn shield when we vore\r
332         e.predator.hitsound += 1; // play this for team mates too, as we could be swallowing them to heal them\r
333         Vore_SetPreyPositions(e.predator);\r
334 \r
335         // block firing for a small amount of time, or we'll be firing the next frame after we swallow\r
336         e.predator.weapon_delay = time + button_delay_time;\r
337         e.predator.action_delay = time + cvar("g_balance_vore_action_delay");\r
338         e.system_delay = e.predator.system_delay = time + system_delay_time;\r
339         e.stomachkick_delay = time + cvar("g_balance_vore_kick_delay"); // don't kick immediately after being swallowed\r
340 }\r
341 \r
342 void Vore_SwallowStep(entity e)\r
343 {\r
344         if(!cvar("g_balance_vore_swallow_speed_fill_player"))\r
345         {\r
346                 Vore_Swallow(e);\r
347                 return;\r
348         }\r
349 \r
350         // when the predator starts swallowing, play his grab sound\r
351         if(!self.swallow_progress_pred)\r
352                 PlayerSound(self, playersound_grab, CHAN_PAIN, VOICETYPE_PLAYERSOUND);\r
353 \r
354         Vore_SwallowModel_Update(e, self);\r
355 \r
356         // increase the progress value until it reaches 1, then swallow the player\r
357         if(e.swallow_progress_prey < 1)\r
358         {\r
359                 float fill;\r
360                 fill = cvar("g_balance_vore_swallow_speed_fill_player") * frametime;\r
361                 if(cvar("g_healthsize") && cvar("g_balance_vore_swallow_speed_fill_scalediff_player")) // fill rate depends on predator size compared to prey size\r
362                         fill *= pow(self.scale / e.scale, cvar("g_balance_vore_swallow_speed_fill_scalediff_player"));\r
363                 if(cvar("g_balance_vore_swallow_speed_fill_stomachload") && e.stomach_load) // fill rate is influenced by the prey's stomach load\r
364                         fill *= (1 - ((e.stomach_load / e.stomach_maxload) * bound(0, cvar("g_balance_vore_swallow_speed_fill_stomachload"), 1)));\r
365 \r
366                 // skill-based speed offset for bots\r
367                 if(skill && cvar("skill_offset"))\r
368                 {\r
369                         float ofs;\r
370                         ofs = pow(skill / cvar("skill_offset_center"), cvar("skill_offset"));\r
371                         if(clienttype(self) == CLIENTTYPE_BOT)\r
372                                 fill *= ofs;\r
373                         if(clienttype(e) == CLIENTTYPE_BOT)\r
374                                 fill /= ofs;\r
375                 }\r
376 \r
377                 e.swallow_progress_prey += fill;\r
378         }\r
379         else\r
380         {\r
381                 Vore_Swallow(e);\r
382                 e.swallow_progress_prey = 0;\r
383         }\r
384 \r
385         // the predator's progress is how much the prey got swallowed\r
386         self.swallow_progress_pred = e.swallow_progress_prey;\r
387 }\r
388 \r
389 void Vore_Regurgitate(entity e)\r
390 {\r
391         // this player is being regurgitated by their predator, apply the proper changes\r
392 \r
393         e.movetype = e.vore_oldmovetype;\r
394         if(e.health > 0) // leave SOLID_NOT for dead bodies\r
395                 e.solid = e.vore_oldsolid;\r
396         e.view_ofs_z = PL_VIEW_OFS_z;\r
397         e.punchvector_z = -cvar("g_balance_vore_regurgitate_prey_punchvector");\r
398 \r
399         // if the prey has been fully digested, silently detach them\r
400         if(cvar("g_balance_vore_regurgitate_death_silent"))\r
401         if(e.deadflag != DEAD_NO && e.health <= cvar("g_balance_vore_digestion_limit"))\r
402         {\r
403                 e.predator = world;\r
404                 e.modelindex = 0; // hide the dead body\r
405                 return;\r
406         }\r
407 \r
408         float scalediff;\r
409         scalediff = cvar("g_healthsize") ? e.scale / e.predator.scale : 1; // the tighter the gut, the greater the effect\r
410 \r
411         // apply velocities\r
412         makevectors(e.predator.v_angle);\r
413         e.velocity = v_forward * cvar("g_balance_vore_regurgitate_force") * scalediff;\r
414         e.predator.velocity += -v_forward * cvar("g_balance_vore_regurgitate_predatorforce") * scalediff;\r
415         e.pusher = e.predator; // allows us to frag players by regurgitating them in deadly pits\r
416         e.pushltime = time + cvar("g_maxpushtime");\r
417 \r
418         // if the dead body of the prey is below gibbing health, gib it\r
419         e.stat_eaten = 0; // necessary for gibs to show\r
420         PlayerGib(e, e.predator);\r
421 \r
422         // regurgitated prey is given this amount of swallow progress, to simulate being more vulnerable\r
423         if(cvar("g_balance_vore_swallow_speed_fill_player") && cvar("g_balance_vore_regurgitate_swallowprogress"))\r
424         {\r
425                 e.swallow_progress_prey = cvar("g_balance_vore_regurgitate_swallowprogress");\r
426                 Vore_SwallowModel_Update(e, e.predator);\r
427         }\r
428 \r
429         // apply regurgitation damage to the predator\r
430         if(cvar("g_balance_vore_regurgitate_damage"))\r
431         {\r
432                 float regurgitate_dmg;\r
433                 regurgitate_dmg = cvar("g_balance_vore_regurgitate_damage");\r
434                 if(cvar("g_healthsize"))\r
435                         regurgitate_dmg *= e.scale / e.predator.scale;\r
436                 Damage(e.predator, e, e, regurgitate_dmg, DEATH_REGURGITATION, e.predator.origin, '0 0 0');\r
437         }\r
438 \r
439         PlayerSound(e.predator, playersound_regurgitate, CHAN_VOICE, VOICETYPE_PLAYERSOUND);\r
440         setanim(e.predator, e.predator.anim_pain1, FALSE, TRUE, TRUE); // looks good for swallowing / regurgitating\r
441         pointparticles(particleeffectnum("vore_regurgitate"), e.predator.origin, '0 0 0', floor(scalediff * PARTICLE_MULTIPLIER));\r
442         e.predator.punchangle_x = crandom() * cvar("g_balance_vore_regurgitate_predator_punchangle") * scalediff;\r
443         e.predator.punchangle_y = crandom() * cvar("g_balance_vore_regurgitate_predator_punchangle") * scalediff;\r
444         e.predator.punchangle_z = crandom() * cvar("g_balance_vore_regurgitate_predator_punchangle") * scalediff;\r
445         e.predator.regurgitate_prepare = 0;\r
446         e.predator.action_delay = time + cvar("g_balance_vore_action_delay");\r
447         Vore_SetPreyPositions(e.predator);\r
448 \r
449         // block firing for a small amount of time, or we'll be firing the next frame\r
450         e.weapon_delay = time + button_delay_time;\r
451         e.system_delay = e.predator.system_delay = time + system_delay_time;\r
452         e.predator = world;\r
453 }\r
454 \r
455 void Vore_Disconnect(float consumables)\r
456 {\r
457         // frees prey from their predators when someone disconnects or goes spectating, or in other circumstances\r
458         entity e;\r
459 \r
460         // prey disconnects or goes spectating while inside someone's belly\r
461         if(self.stat_eaten)\r
462                 Vore_Regurgitate(self);\r
463 \r
464         // pred disconnects or goes spectating with players in their belly\r
465         entity head;\r
466         FOR_EACH_PLAYER(head)\r
467         {\r
468                 if(head.predator == self)\r
469                         Vore_Regurgitate(head);\r
470         }\r
471         // remove consumable items when we disconnect\r
472         if(consumables)\r
473         {\r
474                 for(e = world; (e = find(e, classname, "consumable")); )\r
475                 {\r
476                         if(e.predator == self)\r
477                                 Item_Consumable_Remove(e, TRUE);\r
478                 }\r
479         }\r
480 \r
481         self.stomach_load = self.gravity = 0; // prevents a bug\r
482         Vore_GurgleSound(); // stop the gurgling sound\r
483 }\r
484 \r
485 .float digestion_step;\r
486 void Vore_Digest()\r
487 {\r
488         // apply digestion to prey\r
489 \r
490         if(self.predator.deadflag != DEAD_NO) // dead predators don't digest\r
491         {\r
492                 self.predator.digesting = FALSE;\r
493                 return;\r
494         }\r
495         if(self.health <= cvar("g_balance_vore_digestion_limit")) // don't digest below this amount of health\r
496                 return;\r
497 \r
498         if(time > self.digestion_step)\r
499         {\r
500                 // if distributed digestion is enabled, reduce digestion strength by the amount of prey in our stomach\r
501                 float damage, damage_offset;\r
502 \r
503                 damage_offset = 1;\r
504                 if(cvar("g_balance_vore_digestion_distribute")) // apply distributed digestion damage\r
505                         damage_offset /= (1 - (self.predator.stomach_load / self.predator.stomach_maxload) * bound(0, cvar("g_balance_vore_digestion_distribute"), 1));\r
506                 if(cvar("g_healthsize") && cvar("g_balance_vore_digestion_scalediff")) // apply player scale to digestion damage\r
507                         damage_offset *= pow(self.scale / self.predator.scale, cvar("g_balance_vore_digestion_scalediff"));\r
508 \r
509                 if(self.deadflag != DEAD_NO)\r
510                         damage = cvar("g_balance_vore_digestion_damage_death") / damage_offset;\r
511                 else\r
512                         damage = cvar("g_balance_vore_digestion_damage") / damage_offset;\r
513 \r
514                 Damage(self, self.predator, self.predator, damage, DEATH_DIGESTION, self.origin, '0 0 0');\r
515                 if(cvar("g_balance_vore_digestion_vampire") && self.predator.health < cvar("g_balance_vore_digestion_vampire_stable"))\r
516                 {\r
517                         self.predator.health += damage * cvar("g_balance_vore_digestion_vampire");\r
518                         self.predator.pauserothealth_finished = max(self.predator.pauserothealth_finished, time + cvar("g_balance_pause_health_rot"));\r
519                 }\r
520 \r
521                 self.digestion_step = time + vore_steptime;\r
522         }\r
523 \r
524         if(stov(cvar_string("g_vore_regurgitatecolor_color_digest")))\r
525                 self.colormod = stov(cvar_string("g_vore_regurgitatecolor_color_digest"));\r
526 }\r
527 \r
528 .float teamheal_step;\r
529 void Vore_Teamheal()\r
530 {\r
531         // apply teamheal\r
532 \r
533         if(self.deadflag != DEAD_NO)\r
534                 return;\r
535 \r
536         if(cvar("g_balance_vore_teamheal") && self.health < cvar("g_balance_vore_teamheal_stable"))\r
537         if(time > self.teamheal_step)\r
538         {\r
539                 self.health += cvar("g_balance_vore_teamheal");\r
540                 self.teamheal_step = time + vore_steptime;\r
541 \r
542                 // play beep sound when a team mate was healed to the maximum amount, to both the prey and the predator\r
543                 if(self.health >= cvar("g_balance_vore_teamheal_stable"))\r
544                 {\r
545                         play2(self, "misc/beep.wav");\r
546                         play2(self.predator, "misc/beep.wav");\r
547                 }\r
548         }\r
549 }\r
550 \r
551 .float kick_pressed;\r
552 void Vore_StomachKick()\r
553 {\r
554         // allows prey to kick the predator's stomach and do some damage or attempt to escape\r
555 \r
556         if(self.deadflag != DEAD_NO)\r
557                 return;\r
558 \r
559         float scalediff;\r
560         scalediff = pow(self.scale / self.predator.scale, cvar("g_balance_vore_kick_scalediff"));\r
561 \r
562         if(time > self.stomachkick_delay && !self.kick_pressed)\r
563         {\r
564                 float damage, vol, pitch;\r
565                 vector force;\r
566                 damage = cvar("g_balance_vore_kick_damage");\r
567                 force = v_forward * cvar("g_balance_vore_kick_force");\r
568                 vol = VOL_BASE;\r
569 \r
570                 // modified sound pitch, based on player scale\r
571                 if(cvar("g_healthsize") && cvar("g_healthsize_pitch"))\r
572                         pitch = pow(self.predator.scale, -cvar("g_healthsize_pitch"));\r
573 \r
574                 // apply player scale to the damage / force of the kick\r
575                 if(cvar("g_healthsize") && cvar("g_balance_vore_kick_scalediff"))\r
576                 {\r
577                         damage *= scalediff;\r
578                         force *= scalediff;\r
579                         vol *= scalediff; // kick sound volume based on the same scale\r
580                 }\r
581                 vol = bound(0, vol, 1);\r
582 \r
583                 Damage(self.predator, self, self, damage, DEATH_STOMACHKICK, self.predator.origin, force);\r
584                 sound7(self.predator, CHAN_PROJECTILE, strcat("weapons/hit", ftos(floor(random() * 8)), ".wav"), vol, ATTN_NORM, 100 * pitch, 0);\r
585                 self.predator.punchangle_x = crandom() * cvar("g_balance_vore_kick_predator_punchangle") * scalediff;\r
586                 self.predator.punchangle_y = crandom() * cvar("g_balance_vore_kick_predator_punchangle") * scalediff;\r
587                 self.predator.punchangle_z = crandom() * cvar("g_balance_vore_kick_predator_punchangle") * scalediff;\r
588                 self.punchangle_x = crandom() * cvar("g_balance_vore_kick_prey_punchangle") * scalediff;\r
589                 self.punchangle_y = crandom() * cvar("g_balance_vore_kick_prey_punchangle") * scalediff;\r
590                 self.punchangle_z = crandom() * cvar("g_balance_vore_kick_prey_punchangle") * scalediff;\r
591 \r
592                 // abort the predator's scheduled regurgitation\r
593                 if(random() < cvar("g_balance_vore_kick_cutregurgitate"))\r
594                         self.predator.regurgitate_prepare = 0;\r
595 \r
596                 self.stomachkick_delay = time + cvar("g_balance_vore_kick_delay");\r
597                 if(cvar("g_balance_vore_kick_repress"))\r
598                 if not(clienttype(self) == CLIENTTYPE_BOT) // not for bots, to prevent an issue\r
599                         self.kick_pressed = TRUE;\r
600         }\r
601 }\r
602 \r
603 void Vore_StomachLeave()\r
604 {\r
605         // allows players to get out of their predator at will in some circumstances, such as team mates\r
606 \r
607         if(self.deadflag != DEAD_NO)\r
608                 return;\r
609 \r
610         if(Vore_CanLeave())\r
611                 Vore_Regurgitate(self);\r
612         else if(time > self.complain_vore)\r
613         {\r
614                 play2(self, "misc/forbidden.wav");\r
615                 sprint(self, strcat("You cannot get out of ", self.predator.netname, "\n"));\r
616                 self.complain_vore = time + complain_delay_time;\r
617         }\r
618 }\r
619 \r
620 void Vore_AutoTaunt()\r
621 {\r
622         // triggers ambient vore taunts, for both pred and prey\r
623 \r
624         float taunt_time;\r
625 \r
626         // predator taunts\r
627         if((self.swallow_progress_pred || (self.stomach_load && Stomach_HasLivePrey(self))) && !Stomach_TeamMates_check(self))\r
628         {\r
629                 if(!self.taunt_soundtime) // taunt_soundtime becomes 0 once the taunt has played\r
630                 {\r
631                         taunt_time = random() * (cvar("sv_vore_autotaunt_repeat_max") - cvar("sv_vore_autotaunt_repeat_min")) + cvar("sv_vore_autotaunt_repeat_min");\r
632                         SetAutoTaunt(self, time + taunt_time, TAUNTTYPE_VOREPRED);\r
633                 }\r
634         }\r
635         else if(self.taunt_soundtype == TAUNTTYPE_VOREPRED)\r
636         {\r
637                 // we have a predator taunt scheduled, but are no longer a (suitable) predator, so remove it\r
638                 SetAutoTaunt(self, 0, 0);\r
639         }\r
640 \r
641         // prey taunts\r
642         if((self.swallow_progress_prey || (self.stat_eaten && !(teams_matter && self.team == self.predator.team))) && self.deadflag == DEAD_NO)\r
643         {\r
644                 if(!self.taunt_soundtime) // taunt_soundtime becomes 0 once the taunt has played\r
645                 {\r
646                         taunt_time = random() * (cvar("sv_vore_autotaunt_repeat_max") - cvar("sv_vore_autotaunt_repeat_min")) + cvar("sv_vore_autotaunt_repeat_min");\r
647                         SetAutoTaunt(self, time + taunt_time, TAUNTTYPE_VOREPREY);\r
648                 }\r
649         }\r
650         else if(self.taunt_soundtype == TAUNTTYPE_VOREPREY)\r
651         {\r
652                 // we have a prey taunt scheduled, but are no longer a (suitable) prey, so remove it\r
653                 SetAutoTaunt(self, 0, 0);\r
654         }\r
655 }\r
656 \r
657 void Vore_SetSbarRings()\r
658 {\r
659         // first clear the ring stats, then configure them if needed\r
660         self.stat_sbring1_type = self.stat_sbring1_clip = 0;\r
661         self.stat_sbring2_type = self.stat_sbring2_clip = 0;\r
662 \r
663         if(self.stat_eaten)\r
664         {\r
665                 if(time <= self.stomachkick_delay)\r
666                 {\r
667                         self.stat_sbring1_type = 3; // ring shows stomach kick delay, empties with progress\r
668                         self.stat_sbring1_clip = bound(0, (time / self.stomachkick_delay - 1) / ((self.stomachkick_delay - cvar("g_balance_vore_kick_delay")) / self.stomachkick_delay - 1), 1);\r
669                 }\r
670         }\r
671         else\r
672         {\r
673                 if(self.swallow_progress_pred)\r
674                 {\r
675                         self.stat_sbring1_type = 1; // ring shows predator swallow progress, fills with progress\r
676                         self.stat_sbring1_clip = bound(0, self.swallow_progress_pred, 1);\r
677                 }\r
678                 else if(time <= self.action_delay)\r
679                 {\r
680                         self.stat_sbring1_type = 2; // ring shows vore action delay, empties with progress\r
681                         self.stat_sbring1_clip = bound(0, (time / self.action_delay - 1) / ((self.action_delay - cvar("g_balance_vore_action_delay")) / self.action_delay - 1), 1);\r
682                 }\r
683 \r
684                 if(self.swallow_progress_prey)\r
685                 {\r
686                         self.stat_sbring2_type = 1; // ring shows prey swallow progress, fills with progress\r
687                         self.stat_sbring2_clip = bound(0, self.swallow_progress_prey, 1);\r
688                 }\r
689                 else if(time <= self.regurgitate_prepare)\r
690                 {\r
691                         self.stat_sbring2_type = 2; // ring shows regurgitation preparing, fills with progress\r
692                         self.stat_sbring2_clip = 1 - bound(0, (time / self.regurgitate_prepare - 1) / ((self.regurgitate_prepare - cvar("g_balance_vore_regurgitate_delay")) / self.regurgitate_prepare - 1), 1);\r
693                 }\r
694         }\r
695 }\r
696 \r
697 .float regurgitatecolor_particles_tick;\r
698 void Vore()\r
699 {\r
700         // main vore code, this is where it all happens\r
701 \r
702         Vore_AutoTaunt();\r
703 \r
704         if(!self.stat_eaten)\r
705         if(self.modelindex) // not if we're a gibbed dead body or not visible any more\r
706         if(self.colormod)\r
707         if(self.colormod != '1 1 1')\r
708         {\r
709                 // slowly wash stomach fluids off players once they're out of the stomach\r
710                 if(cvar("g_vore_regurgitatecolor_fade"))\r
711                 if(self.deadflag == DEAD_NO) // not for dead bodies\r
712                 {\r
713                         float goo_fade;\r
714                         goo_fade = cvar("g_vore_regurgitatecolor_fade") * frametime;\r
715                         goo_fade *= 1 + self.waterlevel; // fade faster when underwater\r
716 \r
717                         self.colormod_x += goo_fade;\r
718                         if(self.colormod_x > 1)\r
719                                 self.colormod_x = 1;\r
720                         self.colormod_y += goo_fade;\r
721                         if(self.colormod_y > 1)\r
722                                 self.colormod_y = 1;\r
723                         self.colormod_z += goo_fade;\r
724                         if(self.colormod_z > 1)\r
725                                 self.colormod_z = 1;\r
726                 }\r
727 \r
728                 // constant particles falling off dirty players\r
729                 if(cvar("g_vore_regurgitatecolor_particles"))\r
730                 if(self.regurgitatecolor_particles_tick < time)\r
731                 {\r
732                         pointparticles(particleeffectnum("vore_regurgitate_constant"), self.origin, '0 0 0', floor((cvar("g_healthsize") ? self.scale : 1) * PARTICLE_MULTIPLIER));\r
733                         self.regurgitatecolor_particles_tick = time + cvar("g_vore_regurgitatecolor_particles") * vlen(self.colormod); // particle time depends on how dirty the player is\r
734                 }\r
735         }\r
736 \r
737         // set all vore stats\r
738         Vore_SetSbarRings();\r
739         if(self.predator.classname == "player")\r
740         {\r
741                 self.stat_stomachload = self.predator.stomach_load; // necessary for the stomach board\r
742                 self.stat_stomachmaxload = self.predator.stomach_maxload; // necessary for the stomach board\r
743                 self.stat_digesting = self.predator.digesting; // necessary for the stomach board\r
744                 self.stat_eaten = num_for_edict(self.predator);\r
745         }\r
746         else\r
747         {\r
748                 self.stat_stomachload = self.stomach_load;\r
749                 self.stat_stomachmaxload = self.stomach_maxload;\r
750                 self.stat_digesting = self.digesting;\r
751                 self.stat_eaten = 0;\r
752         }\r
753         self.stat_canleave = Vore_CanLeave();\r
754 \r
755         // don't allow a player inside a player inside another player :)\r
756         // prevent this by checking if such has happened, and taking the proper measures\r
757         // this code has a high priority and must not be stopped by any delay, so run it here\r
758         if(self.predator.stat_eaten)\r
759                 Vore_Regurgitate(self);\r
760 \r
761         // the swallow progress of prey and preds idly decrease by this amount\r
762         if(cvar("g_balance_vore_swallow_speed_decrease"))\r
763         {\r
764                 if(self.swallow_progress_pred)\r
765                         self.swallow_progress_pred = max(0, self.swallow_progress_pred - cvar("g_balance_vore_swallow_speed_decrease") * frametime);\r
766                 if(self.swallow_progress_prey)\r
767                         self.swallow_progress_prey = max(0, self.swallow_progress_prey - cvar("g_balance_vore_swallow_speed_decrease") * frametime);\r
768         }\r
769 \r
770         // set the predator's stomach load and capacity\r
771         Vore_StomachLoad_Apply();\r
772 \r
773         // apply delays and skip the vore system under some circumstances\r
774         if(!cvar("g_vore")) // the vore system is disabled\r
775         {\r
776                 Vore_Disconnect(TRUE);\r
777                 return;\r
778         }\r
779         if(time < game_starttime || (time < warmup && !inWarmupStage)) // don't allow vore before a round begins\r
780         {\r
781                 Vore_Disconnect(FALSE);\r
782                 return;\r
783         }\r
784         if(self.spectatee_status)\r
785                 return;\r
786         if(time < self.system_delay)\r
787                 return;\r
788 \r
789 // --------------------------------\r
790 // Code that addresses predators:\r
791 // --------------------------------\r
792 \r
793         entity prey;\r
794         prey = Swallow_player_check();\r
795 \r
796         // attempt to swallow our new prey if we pressed the attack button, and there's any in range\r
797         self.stat_canswallow = 0;\r
798         if(Swallow_condition_check(prey))\r
799         {\r
800                 // canswallow stat, used by the HUD\r
801                 if(teams_matter && prey.team == self.team)\r
802                         self.stat_canswallow = 2;\r
803                 else\r
804                         self.stat_canswallow = 1;\r
805 \r
806                 if(self.BUTTON_ATCK)\r
807                         Vore_SwallowStep(prey);\r
808         }\r
809         else if(prey != world)\r
810                 self.stat_canswallow = -1;\r
811 \r
812         // toggle digestion, if the player has someone in their stomach\r
813         if(self.BUTTON_DIGEST && cvar("g_vore_digestion"))\r
814         {\r
815                 if(self.stomach_load)\r
816                 {\r
817                         if(time > self.digest_button_delay_time)\r
818                         {\r
819                                 self.digesting = !self.digesting;\r
820                                 self.digest_button_delay_time = time + button_delay_time;\r
821                         }\r
822                 }\r
823                 else if(time > self.complain_vore)\r
824                 {\r
825                         play2(self, "misc/forbidden.wav");\r
826                         sprint(self, "There is nothing to digest\n");\r
827                         self.complain_vore = time + complain_delay_time;\r
828                 }\r
829         }\r
830         if(!self.stomach_load || !cvar("g_vore_digestion"))\r
831                 self.digesting = FALSE;\r
832 \r
833         // predator wishes to regurgitate his prey\r
834         if(self.BUTTON_REGURGITATE && time > self.action_delay)\r
835         if(!self.regurgitate_prepare)\r
836         {\r
837                 if(self.stomach_load)\r
838                 {\r
839                         if(time > self.regurgitate_button_delay_time)\r
840                         {\r
841                                 self.regurgitate_prepare = time + cvar("g_balance_vore_regurgitate_delay");\r
842                                 PlayerSound(self, playersound_regurgitate_prepare, CHAN_VOICE, VOICETYPE_PLAYERSOUND);\r
843                                 setanim(self, self.anim_pain2, FALSE, TRUE, TRUE); // looks good for preparing regurgitation\r
844                                 self.regurgitate_button_delay_time = time + button_delay_time;\r
845                         }\r
846                 }\r
847                 else if(time > self.complain_vore)\r
848                 {\r
849                         play2(self, "misc/forbidden.wav");\r
850                         sprint(self, "There is nothing to regurgitate\n");\r
851                         self.complain_vore = time + complain_delay_time;\r
852                 }\r
853         }\r
854 \r
855         if(self.stomach_load > self.stomach_maxload) // the predator got beyond his capacity after eating, so some prey must pop out\r
856         {\r
857                 self.regurgitate_prepare = -1;\r
858                 return;\r
859         }\r
860         if(cvar("g_balance_vore_load_pred_speedcap") && self.stomach_load)\r
861         if(vlen(self.velocity) >= cvar("g_balance_vore_load_pred_speedcap") / (self.stomach_load / self.stomach_maxload)) // predator's going too fast, gets sick and throws up\r
862         {\r
863                 self.regurgitate_prepare = -1;\r
864                 return;\r
865         }\r
866 \r
867         if (self.digesting && self.digestsound_finished < time)\r
868         {\r
869                 PlayerSound (self, playersound_digest, CHAN_PLAYER, VOICETYPE_PLAYERSOUND);\r
870                 self.digestsound_finished = time + 0.5;\r
871         }\r
872         if(cvar("g_vore_gurglesound"))\r
873                 Vore_GurgleSound();\r
874 \r
875 // --------------------------------\r
876 // Code that addresses the prey:\r
877 // --------------------------------\r
878 \r
879         if(!self.stat_eaten)\r
880                 return;\r
881 \r
882         if(self.deadflag != DEAD_NO && self.health < cvar("g_balance_vore_digestion_limit")) // make sure health doesn't go below the limit\r
883                 self.health = cvar("g_balance_vore_digestion_limit");\r
884 \r
885         // automatically regurgitate prey that has reached their digestion limit\r
886         if(cvar("g_balance_vore_digestion_limit_regurgitate"))\r
887         if(self.health <= cvar("g_balance_vore_digestion_limit"))\r
888         {\r
889                 Vore_Regurgitate(self);\r
890                 return;\r
891         }\r
892 \r
893         // do we stick around inside dead furries? x_x\r
894         if(self.predator.deadflag != DEAD_NO)\r
895         {\r
896                 if(!cvar("g_balance_vore_deadpredator") || !self.predator.modelindex) // if the predator is gibbed, we are out\r
897                 {\r
898                         Vore_Regurgitate(self);\r
899                         return;\r
900                 }\r
901                 if(self.predator.regurgitate_prepare) // abort scheduled regurgitation\r
902                         self.predator.regurgitate_prepare = 0;\r
903         }\r
904 \r
905         // apply delayed regurgitating if it was scheduled\r
906         if(self.predator.regurgitate_prepare && time > self.predator.regurgitate_prepare)\r
907         {\r
908                 Vore_Regurgitate(self);\r
909                 self.predator.complain_vore = time + complain_delay_time; // prevent complaining the next frame if this empties our stomach\r
910         }\r
911 \r
912         // execute digesting and team healing\r
913         if(self.predator.digesting == TRUE)\r
914                 Vore_Digest();\r
915         if(teams_matter && self.team == self.predator.team)\r
916         if(cvar("g_balance_vore_teamheal") && cvar("g_vore_teamvore"))\r
917                 Vore_Teamheal();\r
918 \r
919         // execute prey commands\r
920         if(self.BUTTON_ATCK)\r
921         {\r
922                 if(cvar("g_vore_kick"))\r
923                         Vore_StomachKick();\r
924         }\r
925         else\r
926                 self.kick_pressed = FALSE;\r
927         if(self.BUTTON_JUMP)\r
928                 Vore_StomachLeave();\r
929 \r
930         // Ugly workaround for a Keyhunt issue. Your team's key can still be given to you while in the stomach\r
931         // (at round start), which is pretty ugly and wrong. So attempt to drop keys each frame for prey\r
932         kh_Key_DropAll(self, FALSE);\r
933 \r
934         // always position camera at the center of the stomach, to reduce probability of the view poking out\r
935         self.view_ofs_z = PL_PREY_VIEW_OFS_z * self.predator.scale;\r
936 }\r