8eaa5c3c8bfba2a42af183943af1341224a9148c
[xonotic/xonotic-data.pk3dir.git] / qcsrc / csqcmodellib / cl_player.qc
1 /*
2  * Copyright (c) 2011 Rudolf Polzer
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a copy
5  * of this software and associated documentation files (the "Software"), to
6  * deal in the Software without restriction, including without limitation the
7  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
8  * sell copies of the Software, and to permit persons to whom the Software is
9  * furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
20  * IN THE SOFTWARE.
21  */
22
23 var float autocvar_cl_predictionerrorcompensation = 0;
24
25 // engine stuff
26 .float pmove_flags;
27 float pmove_onground; // weird engine flag we shouldn't really use but have to for now
28 #define PMF_JUMP_HELD 1
29 #define PMF_DUCKED 4
30 #define PMF_ONGROUND 8
31 #define REFDEFFLAG_TELEPORTED 1
32 #define REFDEFFLAG_JUMPING 2
33
34 entity csqcplayer;
35 vector csqcplayer_origin, csqcplayer_velocity;
36 float csqcplayer_sequence, player_pmflags;
37 float csqcplayer_moveframe;
38 vector csqcplayer_predictionerror;
39 float csqcplayer_predictionerrortime;
40
41 vector CSQCPlayer_GetPredictionError()
42 {
43         if(!autocvar_cl_predictionerrorcompensation)
44                 return '0 0 0';
45         if(time < csqcplayer_predictionerrortime)
46                 return csqcplayer_predictionerror * (csqcplayer_predictionerrortime - time) * autocvar_cl_predictionerrorcompensation;
47         return '0 0 0';
48 }
49
50 void CSQCPlayer_SetPredictionError(vector v)
51 {
52         if(!autocvar_cl_predictionerrorcompensation)
53                 return;
54         csqcplayer_predictionerror = (csqcplayer_predictionerrortime - time) * autocvar_cl_predictionerrorcompensation * csqcplayer_predictionerror + v;
55         csqcplayer_predictionerrortime = time + 1.0 / autocvar_cl_predictionerrorcompensation;
56 }
57
58 void CSQCPlayer_Unpredict()
59 {
60         if(csqcplayer_status == CSQCPLAYERSTATUS_UNPREDICTED)
61                 return;
62         if(csqcplayer_status != CSQCPLAYERSTATUS_PREDICTED)
63                 error("Cannot unpredict in current status");
64         self.origin = csqcplayer_origin;
65         self.velocity = csqcplayer_velocity;
66         csqcplayer_moveframe = csqcplayer_sequence+1; //+1 because the recieved frame has the move already done (server side)
67         self.pmove_flags = player_pmflags;
68 }
69
70 void CSQCPlayer_SetMinsMaxs()
71 {
72         if(self.pmove_flags & PMF_DUCKED)
73         {
74                 self.mins = PL_CROUCH_MIN;
75                 self.maxs = PL_CROUCH_MAX;
76                 self.view_ofs = PL_CROUCH_VIEW_OFS;
77         }
78         else
79         {
80                 self.mins = PL_MIN;
81                 self.maxs = PL_MAX;
82                 self.view_ofs = PL_VIEW_OFS;
83         }
84 }
85
86 void CSQCPlayer_SavePrediction()
87 {
88         player_pmflags = self.pmove_flags;
89         csqcplayer_origin = self.origin;
90         csqcplayer_velocity = self.velocity;
91         csqcplayer_sequence = servercommandframe;
92         csqcplayer_status = CSQCPLAYERSTATUS_PREDICTED;
93 }
94
95 void CSQCPlayer_PredictTo(float endframe)
96 {
97         CSQCPlayer_Unpredict();
98         CSQCPlayer_SetMinsMaxs();
99
100         csqcplayer_status = CSQCPLAYERSTATUS_PREDICTED;
101
102         if (getstatf(STAT_HEALTH) <= 0)
103         {
104                 csqcplayer_moveframe = clientcommandframe;
105                 getinputstate(csqcplayer_moveframe-1);
106                 return;
107         }
108
109         while(csqcplayer_moveframe < endframe)
110         {
111                 if (!getinputstate(csqcplayer_moveframe))
112                 {
113                         break;
114                 }
115                 runstandardplayerphysics(self);
116                 CSQCPlayer_SetMinsMaxs();
117                 csqcplayer_moveframe++;
118         }
119
120         //add in anything that was applied after (for low packet rate protocols)
121         input_angles = view_angles;
122 }
123
124 float CSQCPlayer_IsLocalPlayer()
125 {
126         return (self == csqcplayer);
127 }
128
129 void(entity e, float fl) V_CalcRefdef = #640; // DP_CSQC_V_CALCREFDEF
130
131 void CSQCPlayer_SetCamera()
132 {
133         if(csqcplayer)
134         {
135                 entity oldself;
136                 oldself = self;
137                 self = csqcplayer;
138
139 #ifdef COMPAT_XON050_ENGINE
140                 if(servercommandframe == 0 || clientcommandframe == 0 || !(checkextension("DP_CSQC_V_CALCREFDEF") || checkextension("DP_CSQC_V_CALCREFDEF_WIP1")))
141 #else
142                 if(servercommandframe == 0 || clientcommandframe == 0)
143 #endif
144                 {
145                         InterpolateOrigin_Do();
146                         self.view_ofs = '0 0 1' * getstati(STAT_VIEWHEIGHT);
147
148                         // get crouch state from the server
149                         if(getstati(STAT_VIEWHEIGHT) == PL_VIEW_OFS_z)
150                                 self.pmove_flags &~= PMF_DUCKED;
151                         else if(getstati(STAT_VIEWHEIGHT) == PL_CROUCH_VIEW_OFS_z)
152                                 self.pmove_flags |= PMF_DUCKED;
153
154                         // get onground state from the server
155                         if(pmove_onground)
156                                 self.pmove_flags |= PMF_ONGROUND;
157                         else
158                                 self.pmove_flags &~= PMF_ONGROUND;
159
160                         CSQCPlayer_SetMinsMaxs();
161
162                         // override it back just in case
163                         self.view_ofs = '0 0 1' * getstati(STAT_VIEWHEIGHT);
164                 }
165                 else
166                 {
167                         if(csqcplayer_status == CSQCPLAYERSTATUS_FROMSERVER)
168                         {
169                                 vector o, v;
170                                 o = self.origin;
171                                 v = pmove_vel; // TRICK: pmove_vel is set by the engine when we get here. No need to network velocity
172                                 csqcplayer_status = CSQCPLAYERSTATUS_PREDICTED;
173                                 CSQCPlayer_PredictTo(servercommandframe + 1);
174                                 CSQCPlayer_SetPredictionError(o - self.origin);
175                                 self.origin = o;
176                                 self.velocity = v;
177
178                                 // get crouch state from the server
179                                 if(getstati(STAT_VIEWHEIGHT) == PL_VIEW_OFS_z)
180                                         self.pmove_flags &~= PMF_DUCKED;
181                                 else if(getstati(STAT_VIEWHEIGHT) == PL_CROUCH_VIEW_OFS_z)
182                                         self.pmove_flags |= PMF_DUCKED;
183
184                                 // get onground state from the server
185                                 if(pmove_onground)
186                                         self.pmove_flags |= PMF_ONGROUND;
187                                 else
188                                         self.pmove_flags &~= PMF_ONGROUND;
189
190                                 CSQCPlayer_SavePrediction();
191                         }
192                         CSQCPlayer_PredictTo(clientcommandframe + 1);
193
194                         CSQCPlayer_SetMinsMaxs();
195
196                         self.angles_y = input_angles_y;
197                 }
198
199                 // relink
200                 setorigin(self, self.origin);
201
202                 self = oldself;
203         }
204
205         entity view;
206 #ifdef COMPAT_XON050_ENGINE
207         view = CSQCModel_server2csqc((spectatee_status > 0) ? spectatee_status : player_localentnum);
208 #else
209         view = CSQCModel_server2csqc(player_localentnum);
210 #endif
211
212         if(view != csqcplayer)
213         {
214                 entity oldself = self;
215                 self = view;
216                 InterpolateOrigin_Do();
217                 self.view_ofs = '0 0 1' * getstati(STAT_VIEWHEIGHT);
218                 self = oldself;
219         }
220
221 #ifdef COMPAT_XON050_ENGINE
222         if(view && !(checkextension("DP_CSQC_V_CALCREFDEF") || checkextension("DP_CSQC_V_CALCREFDEF_WIP1")))
223         {
224                 // legacy code, not totally correct, but good enough for not having V_CalcRefdef
225                 setproperty(VF_ORIGIN, view.origin + '0 0 1' * getstati(STAT_VIEWHEIGHT));
226                 setproperty(VF_ANGLES, view_angles);
227         }
228         else
229 #endif
230         if(view)
231         {
232                 var float refdefflags = 0;
233
234                 if(view.csqcmodel_teleported)
235                         refdefflags |= REFDEFFLAG_TELEPORTED;
236
237                 if(input_buttons & 4)
238                         refdefflags |= REFDEFFLAG_JUMPING;
239
240                 V_CalcRefdef(view, refdefflags);
241         }
242         else
243         {
244                 setproperty(VF_ORIGIN, pmove_org + '0 0 1' * getstati(STAT_VIEWHEIGHT));
245                 setproperty(VF_ANGLES, view_angles);
246         }
247
248         { CSQCPLAYER_HOOK_POSTCAMERASETUP }
249 }
250
251 void CSQCPlayer_Remove()
252 {
253         csqcplayer = world;
254         cvar_clientsettemp("cl_movement_replay", "1");
255 }
256
257 float CSQCPlayer_PreUpdate()
258 {
259         if(self != csqcplayer)
260                 return 0;
261         if(csqcplayer_status != CSQCPLAYERSTATUS_FROMSERVER)
262                 CSQCPlayer_Unpredict();
263         return 1;
264 }
265
266 float CSQCPlayer_PostUpdate()
267 {
268         if(self.entnum != player_localnum + 1)
269                 return 0;
270         csqcplayer = self;
271         csqcplayer_status = CSQCPLAYERSTATUS_FROMSERVER;
272         cvar_clientsettemp("cl_movement_replay", "0");
273         self.entremove = CSQCPlayer_Remove;
274         return 1;
275 }