]> de.git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blob - qcsrc/server/mutators/mutator_dodging.qc
- removed commented out lines
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / mutators / mutator_dodging.qc
1
2 .float cvar_cl_dodging_timeout;
3
4
5 // these are used to store the last key press time for each of the keys..
6 .float last_FORWARD_KEY_time;
7 .float last_BACKWARD_KEY_time;
8 .float last_LEFT_KEY_time;
9 .float last_RIGHT_KEY_time;
10
11 // these store the movement direction at the time of the dodge action happening.
12 .float dodging_direction_x;
13 .float dodging_direction_y;
14
15 // this indicates the last time a dodge was executed. used to check if another one is allowed
16 // and to ramp up the dodge acceleration in the physics hook.
17 .float last_dodging_time;
18
19 // set to 1 to indicate dodging has started.. reset by physics hook after dodge has been done..
20 .float dodging_action;
21
22 // the jump part of the dodge cannot be ramped
23 .float dodging_single_action;
24
25 void dodging_Initialize() {
26         // print("dodging_Initialize\n");
27
28         self.last_FORWARD_KEY_time = 0;
29         self.last_BACKWARD_KEY_time = 0;
30         self.last_RIGHT_KEY_time = 0;
31         self.last_LEFT_KEY_time = 0;
32         self.last_dodging_time = 0;
33         self.dodging_action = 0;
34         self.dodging_single_action = 0;
35         self.dodging_direction_x = 0;
36         self.dodging_direction_y = 0;
37 }
38
39 MUTATOR_HOOKFUNCTION(dodging_GetCvars) {
40         GetCvars_handleFloat(get_cvars_s, get_cvars_f, cvar_cl_dodging_timeout, "cl_dodging_timeout");
41         return 0;
42 }
43
44 MUTATOR_HOOKFUNCTION(dodging_PlayerPhysics) {
45         // print("dodging_PlayerPhysics\n");
46
47         float common_factor;
48
49         // is dodging enabled at all? if not, do nothing..
50         if (g_dodging == 0)
51                 return 0;
52
53         // make sure v_up, v_right and v_forward are sane
54         makevectors(self.angles);
55
56         // if we have e.g. 0.5 sec ramptime and a frametime of 0.25, then the ramp code 
57         // will be called ramp_time/frametime times = 2 times. so, we need to 
58         // add 0.5 * the total speed each frame until the dodge action is done..
59         common_factor = sys_frametime / cvar("sv_dodging_ramp_time");
60
61         // if ramp time is smaller than frametime we get problems ;D
62         if (common_factor > 1) 
63                 common_factor = 1;
64
65
66         // ramp up dodging speed by adding some velocity each frame.. TODO: do it! :D
67         if (self.dodging_action == 1) {
68                 //disable jump key during dodge accel phase
69                 if (self.movement_z > 0) self.movement_z = 0;
70
71                 self.velocity = 
72                           self.velocity 
73                         + (common_factor * (self.dodging_direction_y * cvar("sv_dodging_horiz_speed")) * v_right) 
74                         + (common_factor * (self.dodging_direction_x * cvar("sv_dodging_horiz_speed")) * v_forward);
75         }
76
77         // the up part of the dodge is a single shot action
78         if (self.dodging_single_action == 1) {
79                 self.velocity = 
80                           self.velocity 
81                         + (cvar("sv_dodging_up_speed") * v_up);
82
83                 self.dodging_single_action = 0;
84         }
85
86         // are we done with the dodging ramp yet?
87         if((self.dodging_action == 1) && ((time - self.last_dodging_time) > cvar("sv_dodging_ramp_time")))
88         {
89                 // reset state so next dodge can be done correctly
90                 self.dodging_action = 0;
91                 self.dodging_direction_x = 0;
92                 self.dodging_direction_y = 0;
93         }
94
95         return 0;
96 }
97
98 MUTATOR_HOOKFUNCTION(dodging_GetPressedKeys) {
99         // print("dodging_PlayerPhysics\n");
100
101         float length;
102         float dodge_detected;
103         vector trace_start;
104         vector trace_end;
105         float height_above_ground;
106
107         if (g_dodging == 0)
108                 return 0;
109
110         dodge_detected = 0;
111
112         // no dodging and jumping at the same time..
113         if (self.BUTTON_JUMP)
114                 return 0;
115
116         // first check if the last dodge is far enough back in time so we can dodge again
117         if ((time - self.last_dodging_time) < cvar("sv_dodging_delay"))
118                 return 0;
119
120         // determine height above ground is below a threshold
121         trace_start = self.origin;
122         trace_end = self.origin - (100*v_up);
123
124         traceline(trace_start, trace_end, TRUE, self);
125         height_above_ground = self.origin_z - trace_endpos_z;
126
127         // check if our feet are on the ground or at least close :D
128         if (height_above_ground > (fabs(PL_MIN_z) + cvar("sv_dodging_height_threshold")))
129                 return 0;
130
131         if (self.movement_x > 0) {
132                 // is this a state change?
133                 if (!(self.pressedkeys & KEY_FORWARD)) {
134                         if ((time - self.last_FORWARD_KEY_time) < self.cvar_cl_dodging_timeout) { 
135                                 dodge_detected = 1;
136                                 self.dodging_direction_x = 1.0;
137                         }
138                         self.last_FORWARD_KEY_time = time;
139                 }
140         }
141
142         if (self.movement_x < 0) {
143                 // is this a state change?
144                 if (!(self.pressedkeys & KEY_BACKWARD)) {
145                         if ((time - self.last_BACKWARD_KEY_time) < self.cvar_cl_dodging_timeout)        { 
146                                 dodge_detected = 1;
147                                 self.dodging_direction_x = -1.0;
148                         }
149                         self.last_BACKWARD_KEY_time = time;
150                 }
151         }
152
153         if (self.movement_y > 0) {
154                 // is this a state change?
155                 if (!(self.pressedkeys & KEY_RIGHT)) {
156                         if ((time - self.last_RIGHT_KEY_time) < self.cvar_cl_dodging_timeout)   { 
157                                 dodge_detected = 1;
158                                 self.dodging_direction_y = 1.0;
159                         }
160                         self.last_RIGHT_KEY_time = time;
161                 }
162         }
163
164         if (self.movement_y < 0) {
165                 // is this a state change?
166                 if (!(self.pressedkeys & KEY_LEFT)) {
167                         if ((time - self.last_LEFT_KEY_time) < self.cvar_cl_dodging_timeout)    { 
168                                 dodge_detected = 1;
169                                 self.dodging_direction_y = -1.0;
170                         }
171                         self.last_LEFT_KEY_time = time;
172                 }
173         }
174
175
176
177         if (dodge_detected == 1) {
178                 if (self.movement_z > 0)
179                         self.movement_z = 0;
180
181                 self.last_dodging_time = time;
182
183                 self.dodging_action = 1;
184                 self.dodging_single_action = 1;
185
186                 // normalize the dodging_direction vector.. (unlike UT99) XD
187                 length = length + self.dodging_direction_x * self.dodging_direction_x;
188                 length = length + self.dodging_direction_y * self.dodging_direction_y;
189                 length = sqrt(length);
190
191                 self.dodging_direction_x = self.dodging_direction_x * 1.0/length;
192                 self.dodging_direction_y = self.dodging_direction_y * 1.0/length;
193         }
194
195         return 0;
196 }
197
198 MUTATOR_DEFINITION(dodging)
199 {
200         // we need to be called before GetPressedKey does its thing so we can
201         // detect state changes and therefore dodging actions..
202         MUTATOR_HOOK(GetPressedKeys, dodging_GetPressedKeys, CBC_ORDER_ANY);
203
204         // in the physics hook we actually implement the dodge..
205         MUTATOR_HOOK(PlayerPhysics, dodging_PlayerPhysics, CBC_ORDER_ANY);
206
207         MUTATOR_HOOK(GetCvars, dodging_GetCvars, CBC_ORDER_ANY);
208
209         // this just turns on the cvar.
210         MUTATOR_ONADD
211         {
212                 g_dodging = 1;
213                 dodging_Initialize();
214         }
215
216         // this just turns off the cvar.
217         MUTATOR_ONREMOVE
218         {        
219                 g_dodging = 0;
220         }
221
222         return 0;
223 }