DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / d2df-sdl.git / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
panels: handle panel animation in render (bump protocol)
[d2df-sdl.git] / src / game / g_netmsg.pas
1 (* Copyright (C) Doom 2D: Forever Developers
2 *
3 * This program is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, version 3 of the License ONLY.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program. If not, see <http://www.gnu.org/licenses/>.
14 *)
15 {$INCLUDE ../shared/a_modes.inc}
16 unit g_netmsg;
17
18 interface
19
20 uses e_msg, g_net, g_triggers, Classes, SysUtils, md5;
21
22 const
23 NET_MSG_INFO = 100;
24
25 NET_MSG_CHAT = 101;
26 NET_MSG_SND = 102;
27 NET_MSG_GFX = 103;
28 NET_MSG_GEVENT = 104;
29 NET_MSG_SCORE = 105;
30 NET_MSG_COOP = 106;
31 NET_MSG_FLAG = 107;
32 NET_MSG_REQFST = 108;
33 NET_MSG_GSET = 109;
34 NET_MSG_FLAGPOS= 110;
35
36 NET_MSG_PLR = 111;
37 NET_MSG_PLRPOS = 112;
38 NET_MSG_PLRSTA = 113;
39 NET_MSG_PLRDEL = 114;
40 NET_MSG_PLRDMG = 115;
41 NET_MSG_PLRDIE = 116;
42 NET_MSG_PLRFIRE= 117;
43 NET_MSG_PLRSET = 119;
44 NET_MSG_CHEAT = 120;
45
46 NET_MSG_ISPAWN = 121;
47 NET_MSG_IDEL = 122;
48 NET_MSG_IPOS = 123;
49
50 NET_MSG_MSPAWN = 131;
51 NET_MSG_MPOS = 132;
52 NET_MSG_MSTATE = 133;
53 NET_MSG_MSHOT = 134;
54 NET_MSG_MDEL = 135;
55
56 NET_MSG_PSTATE = 141;
57 NET_MSG_PTEX = 142;
58
59 NET_MSG_TSOUND = 151;
60 NET_MSG_TMUSIC = 152;
61
62 NET_MSG_SHDEL = 161;
63 NET_MSG_SHADD = 162;
64 NET_MSG_SHPOS = 163;
65
66 NET_MSG_RCON_AUTH = 191;
67 NET_MSG_RCON_CMD = 192;
68 NET_MSG_TIME_SYNC = 194;
69 NET_MSG_VOTE_EVENT = 195;
70
71 {
72 NET_MSG_MAP_REQUEST = 201;
73 NET_MSG_MAP_RESPONSE = 202;
74 NET_MSG_RES_REQUEST = 203;
75 NET_MSG_RES_RESPONSE = 204;
76 }
77
78 NET_CHAT_SYSTEM = 0;
79 NET_CHAT_PLAYER = 1;
80 NET_CHAT_TEAM = 2;
81
82 NET_RCON_NOAUTH = 0;
83 NET_RCON_PWGOOD = 1;
84 NET_RCON_PWBAD = 2;
85
86 NET_GFX_SPARK = 1;
87 NET_GFX_TELE = 2;
88 NET_GFX_RESPAWN = 3;
89 NET_GFX_FIRE = 4;
90 NET_GFX_EXPLODE = 5;
91 NET_GFX_BFGEXPL = 6;
92 NET_GFX_BFGHIT = 7;
93 NET_GFX_SHELL1 = 8;
94 NET_GFX_SHELL2 = 9;
95 NET_GFX_SHELL3 = 10;
96
97 NET_EV_MAPSTART = 1;
98 NET_EV_MAPEND = 2;
99 NET_EV_CHANGE_TEAM = 3;
100 NET_EV_PLAYER_KICK = 4;
101 NET_EV_PLAYER_BAN = 5;
102 NET_EV_LMS_WARMUP = 6;
103 NET_EV_LMS_SURVIVOR = 7;
104 NET_EV_RCON = 8;
105 NET_EV_BIGTEXT = 9;
106 NET_EV_SCORE = 10;
107 NET_EV_SCORE_MSG = 11;
108 NET_EV_LMS_START = 12;
109 NET_EV_LMS_WIN = 13;
110 NET_EV_TLMS_WIN = 14;
111 NET_EV_LMS_LOSE = 15;
112 NET_EV_LMS_DRAW = 16;
113 NET_EV_KILLCOMBO = 17;
114 NET_EV_PLAYER_TOUCH = 18;
115 NET_EV_SECRET = 19;
116 NET_EV_INTER_READY = 20;
117 NET_EV_LMS_NOSPAWN = 21;
118
119 NET_VE_STARTED = 1;
120 NET_VE_PASSED = 2;
121 NET_VE_FAILED = 3;
122 NET_VE_VOTE = 4;
123 NET_VE_REVOKE = 5;
124 NET_VE_INPROGRESS = 6;
125
126 NET_FLAG_GET = 1;
127 NET_FLAG_DROP = 2;
128 NET_FLAG_CAP = 3;
129 NET_FLAG_RETURN = 4;
130
131 NET_CHEAT_SUICIDE = 1;
132 NET_CHEAT_SPECTATE = 2;
133 NET_CHEAT_READY = 3;
134 NET_CHEAT_DROPFLAG = 4;
135
136 NET_MAX_DIFFTIME = 5000 div 36;
137
138 // HOST MESSAGES
139
140 procedure MH_MalformedPacket(C: pTNetClient);
141 procedure MH_ProcessFirstSpawn (C: pTNetClient);
142
143 procedure MH_RECV_Info(C: pTNetClient; var M: TMsg);
144 procedure MH_RECV_Chat(C: pTNetClient; var M: TMsg);
145 procedure MH_RECV_FullStateRequest(C: pTNetClient; var M: TMsg);
146 function MH_RECV_PlayerPos(C: pTNetClient; var M: TMsg): Word;
147 procedure MH_RECV_PlayerSettings(C: pTNetClient; var M: TMsg);
148 procedure MH_RECV_CheatRequest(C: pTNetClient; var M: TMsg);
149 procedure MH_RECV_RCONPassword(C: pTNetClient; var M: TMsg);
150 procedure MH_RECV_RCONCommand(C: pTNetClient; var M: TMsg);
151 //procedure MH_RECV_MapRequest(C: pTNetClient; var M: TMsg);
152 //procedure MH_RECV_ResRequest(C: pTNetClient; var M: TMsg);
153 procedure MH_RECV_Vote(C: pTNetClient; var M: TMsg);
154
155 // GAME
156 procedure MH_SEND_Everything(CreatePlayers: Boolean {= False}; ID: Integer {= NET_EVERYONE});
157 procedure MH_SEND_Info(ID: Byte);
158 procedure MH_SEND_Chat(Txt: string; Mode: Byte; ID: Integer = NET_EVERYONE);
159 procedure MH_SEND_Effect(X, Y: Integer; Ang: SmallInt; Kind: Byte; ID: Integer = NET_EVERYONE);
160 procedure MH_SEND_Sound(X, Y: Integer; Name: string; Pos: Boolean = True; ID: Integer = NET_EVERYONE);
161 procedure MH_SEND_CreateShot(Proj: LongInt; ID: Integer = NET_EVERYONE);
162 procedure MH_SEND_UpdateShot(Proj: LongInt; ID: Integer = NET_EVERYONE);
163 procedure MH_SEND_DeleteShot(Proj: LongInt; X, Y: LongInt; Loud: Boolean = True; ID: Integer = NET_EVERYONE);
164 procedure MH_SEND_GameStats(ID: Integer = NET_EVERYONE);
165 procedure MH_SEND_CoopStats(ID: Integer = NET_EVERYONE);
166 procedure MH_SEND_GameEvent(EvType: Byte; EvNum: Integer = 0; EvStr: string = 'N'; ID: Integer = NET_EVERYONE);
167 procedure MH_SEND_FlagEvent(EvType: Byte; Flag: Byte; PID: Word; Quiet: Boolean = False; ID: Integer = NET_EVERYONE);
168 procedure MH_SEND_FlagPos(Flag: Byte; ID: Integer = NET_EVERYONE);
169 procedure MH_SEND_GameSettings(ID: Integer = NET_EVERYONE);
170 // PLAYER
171 procedure MH_SEND_PlayerCreate(PID: Word; ID: Integer = NET_EVERYONE);
172 procedure MH_SEND_PlayerPos(Reliable: Boolean; PID: Word; ID: Integer = NET_EVERYONE);
173 procedure MH_SEND_PlayerStats(PID: Word; ID: Integer = NET_EVERYONE);
174 procedure MH_SEND_PlayerDelete(PID: Word; ID: Integer = NET_EVERYONE);
175 procedure MH_SEND_PlayerDamage(PID: Word; Kind: Byte; Attacker, Value: Word; VX, VY: Integer; ID: Integer = NET_EVERYONE);
176 procedure MH_SEND_PlayerFire(PID: Word; Weapon: Byte; X, Y, AX, AY: Integer; ShotID: Integer = -1; ID: Integer = NET_EVERYONE);
177 procedure MH_SEND_PlayerDeath(PID: Word; KillType, DeathType: Byte; Attacker: Word; ID: Integer = NET_EVERYONE);
178 procedure MH_SEND_PlayerSettings(PID: Word; Mdl: string = ''; ID: Integer = NET_EVERYONE);
179 // ITEM
180 procedure MH_SEND_ItemSpawn(Quiet: Boolean; IID: Word; ID: Integer = NET_EVERYONE);
181 procedure MH_SEND_ItemDestroy(Quiet: Boolean; IID: Word; ID: Integer = NET_EVERYONE);
182 procedure MH_SEND_ItemPos(IID: Word; ID: Integer = NET_EVERYONE);
183 // PANEL
184 procedure MH_SEND_PanelTexture(PGUID: Integer; ID: Integer = NET_EVERYONE);
185 procedure MH_SEND_PanelState(PGUID: Integer; ID: Integer = NET_EVERYONE);
186 // MONSTER
187 procedure MH_SEND_MonsterSpawn(UID: Word; ID: Integer = NET_EVERYONE);
188 procedure MH_SEND_MonsterPos(UID: Word; ID: Integer = NET_EVERYONE);
189 procedure MH_SEND_MonsterState(UID: Word; ForcedAnim: Byte = 255; ID: Integer = NET_EVERYONE);
190 procedure MH_SEND_MonsterShot(UID: Word; X, Y, VX, VY: Integer; ID: Integer = NET_EVERYONE);
191 procedure MH_SEND_MonsterDelete(UID: Word; ID: Integer = NET_EVERYONE);
192 // TRIGGER
193 procedure MH_SEND_TriggerSound(var T: TTrigger; ID: Integer = NET_EVERYONE);
194 procedure MH_SEND_TriggerMusic(ID: Integer = NET_EVERYONE);
195 // MISC
196 procedure MH_SEND_TimeSync(Time: LongWord; ID: Integer = NET_EVERYONE);
197 procedure MH_SEND_VoteEvent(EvType: Byte;
198 StrArg1: string = 'a'; StrArg2: string = 'b';
199 IntArg1: SmallInt = 0; IntArg2: SmallInt = 0;
200 ID: Integer = NET_EVERYONE);
201
202 // CLIENT MESSAGES //
203
204 // GAME
205 procedure MC_RECV_Chat(var M: TMsg);
206 procedure MC_RECV_Effect(var M: TMsg);
207 procedure MC_RECV_Sound(var M: TMsg);
208 procedure MC_RECV_GameStats(var M: TMsg);
209 procedure MC_RECV_CoopStats(var M: TMsg);
210 procedure MC_RECV_GameEvent(var M: TMsg);
211 procedure MC_RECV_FlagEvent(var M: TMsg);
212 procedure MC_RECV_FlagPos(var M: TMsg);
213 procedure MC_RECV_GameSettings(var M: TMsg);
214 // PLAYER
215 function MC_RECV_PlayerCreate(var M: TMsg): Word;
216 function MC_RECV_PlayerPos(var M: TMsg): Word;
217 function MC_RECV_PlayerStats(var M: TMsg): Word;
218 function MC_RECV_PlayerDelete(var M: TMsg): Word;
219 function MC_RECV_PlayerDamage(var M: TMsg): Word;
220 function MC_RECV_PlayerDeath(var M: TMsg): Word;
221 function MC_RECV_PlayerFire(var M: TMsg): Word;
222 procedure MC_RECV_PlayerSettings(var M: TMsg);
223 // ITEM
224 procedure MC_RECV_ItemSpawn(var M: TMsg);
225 procedure MC_RECV_ItemDestroy(var M: TMsg);
226 procedure MC_RECV_ItemPos(var M: TMsg);
227 // PANEL
228 procedure MC_RECV_PanelTexture(var M: TMsg);
229 procedure MC_RECV_PanelState(var M: TMsg);
230 // MONSTER
231 procedure MC_RECV_MonsterSpawn(var M: TMsg);
232 procedure MC_RECV_MonsterPos(var M: TMsg);
233 procedure MC_RECV_MonsterState(var M: TMsg);
234 procedure MC_RECV_MonsterShot(var M: TMsg);
235 procedure MC_RECV_MonsterDelete(var M: TMsg);
236 // SHOT
237 procedure MC_RECV_CreateShot(var M: TMsg);
238 procedure MC_RECV_UpdateShot(var M: TMsg);
239 procedure MC_RECV_DeleteShot(var M: TMsg);
240 // TRIGGER
241 procedure MC_RECV_TriggerSound(var M: TMsg);
242 procedure MC_RECV_TriggerMusic(var M: TMsg);
243 // MISC
244 procedure MC_RECV_TimeSync(var M: TMsg);
245 procedure MC_RECV_VoteEvent(var M: TMsg);
246 // SERVICE
247 procedure MC_SEND_Info(Password: string);
248 procedure MC_SEND_Chat(Txt: string; Mode: Byte);
249 procedure MC_SEND_PlayerPos();
250 procedure MC_SEND_FullStateRequest();
251 procedure MC_SEND_PlayerSettings();
252 procedure MC_SEND_CheatRequest(Kind: Byte);
253 procedure MC_SEND_RCONPassword(Password: string);
254 procedure MC_SEND_RCONCommand(Cmd: string);
255 procedure MC_SEND_Vote(Start: Boolean = False; Command: string = 'a');
256 // DOWNLOAD
257 //procedure MC_SEND_MapRequest();
258 //procedure MC_SEND_ResRequest(const resName: AnsiString);
259
260
261 type
262 TExternalResourceInfo = record
263 Name: string[255];
264 md5: TMD5Digest;
265 end;
266
267 TResDataMsg = record
268 MsgId: Byte;
269 FileSize: Integer;
270 FileData: AByte;
271 end;
272
273 TMapDataMsg = record
274 MsgId: Byte;
275 FileSize: Integer;
276 FileData: AByte;
277 ExternalResources: array of TExternalResourceInfo;
278 end;
279
280 function IsValidFileName(const S: String): Boolean;
281 function IsValidFilePath(const S: String): Boolean;
282
283
284 implementation
285
286 uses
287 {$IFDEF ENABLE_MENU}
288 g_gui,
289 {$ENDIF}
290 {$IFDEF ENABLE_GFX}
291 g_gfx,
292 {$ENDIF}
293 {$IFDEF ENABLE_GIBS}
294 g_gibs,
295 {$ENDIF}
296 {$IFDEF ENABLE_SHELLS}
297 g_shells,
298 {$ENDIF}
299 {$IFDEF ENABLE_CORPSES}
300 g_corpses,
301 {$ENDIF}
302 Math, ENet, e_input, e_log, g_base, g_basic,
303 g_sound, g_console, g_options,
304 g_game, g_player, g_map, g_panel, g_items, g_weapons, g_phys,
305 g_language, g_monsters, g_netmaster, utils, wadreader, MAPDEF
306 ;
307
308 const
309 NET_KEY_LEFT = 1 shl 0;
310 NET_KEY_RIGHT = 1 shl 1;
311 NET_KEY_UP = 1 shl 2;
312 NET_KEY_DOWN = 1 shl 3;
313 NET_KEY_JUMP = 1 shl 4;
314 NET_KEY_FIRE = 1 shl 5;
315 NET_KEY_OPEN = 1 shl 6;
316 NET_KEY_CHAT = 1 shl 7;
317 NET_KEY_FORCEDIR = 1 shl 8;
318
319 //var
320 //kBytePrev: Word = 0;
321 //kDirPrev: TDirection = D_LEFT;
322 //HostGameTime: Word = 0;
323
324
325 function IsValidFileName(const S: String): Boolean;
326 const
327 Forbidden: set of Char = ['<', '>', '|', '"', ':', '*', '?'];
328 var
329 I: Integer;
330 begin
331 Result := S <> '';
332 for I := 1 to Length(S) do
333 Result := Result and (not(S[I] in Forbidden));
334 end;
335
336 function IsValidFilePath(const S: String): Boolean;
337 var
338 I: Integer;
339 begin
340 Result := False;
341 if not IsValidFileName(S) then exit;
342 if FileExists(S) then exit;
343 I := LastDelimiter('\/', S);
344 if (I > 0) then
345 if (not DirectoryExists(Copy(S, 1, I-1))) then
346 exit;
347 Result := True;
348 end;
349
350
351 // HOST MESSAGES //
352
353
354 // GAME
355
356 procedure MH_MalformedPacket(C: pTNetClient);
357 begin
358 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
359 _lc[I_NET_DISC_PROTOCOL]);
360 g_Net_Host_Kick(C^.ID, NET_DISC_PROTOCOL);
361 end;
362
363 procedure MH_RECV_Chat(C: pTNetClient; var M: TMsg);
364 var
365 Txt: string;
366 Mode: Byte;
367 PID: Word;
368 Pl: TPlayer;
369 Err: Boolean;
370 begin
371 PID := C^.Player;
372 Pl := g_Player_Get(PID);
373
374 Err := False;
375 try
376 Txt := M.ReadString();
377 Mode := M.ReadByte();
378 except
379 Err := True;
380 end;
381
382 if Err then begin MH_MalformedPacket(C); Exit; end;
383
384 if (Mode = NET_CHAT_SYSTEM) then
385 Mode := NET_CHAT_PLAYER; // prevent sending system messages from clients
386 if (Mode = NET_CHAT_TEAM) and (not gGameSettings.GameMode in [GM_TDM, GM_CTF]) then
387 Mode := NET_CHAT_PLAYER; // revert to player chat in non-team game
388
389 if Pl = nil then
390 MH_SEND_Chat(Txt, Mode)
391 else
392 MH_SEND_Chat(Pl.Name + ': ' + Txt, Mode, IfThen(Mode = NET_CHAT_TEAM, Pl.Team, NET_EVERYONE));
393 end;
394
395 procedure MH_RECV_Info(C: pTNetClient; var M: TMsg);
396 var
397 Ver, PName, Model, Pw: string;
398 R, G, B, T: Byte;
399 WeapSwitch: Byte;
400 TmpPrefArray: Array [WP_FIRST .. WP_LAST + 1] of Byte;
401 SwitchEmpty: Byte;
402 SkipF: Byte;
403 PID: Word;
404 Color: TRGB;
405 I: Integer;
406 Err: Boolean;
407 begin
408 Err := False;
409 try
410 Ver := M.ReadString();
411 Pw := M.ReadString();
412 PName := M.ReadString();
413 Model := M.ReadString();
414 R := M.ReadByte();
415 G := M.ReadByte();
416 B := M.ReadByte();
417 T := M.ReadByte();
418 WeapSwitch := M.ReadByte();
419 for I := WP_FIRST to WP_LAST + 1 do
420 TmpPrefArray[I] := M.ReadByte();
421 SwitchEmpty := M.ReadByte();
422 SkipF := M.ReadByte();
423 except
424 Err := True;
425 end;
426
427 if Err then begin MH_MalformedPacket(C); Exit; end;
428
429 if Ver <> GAME_VERSION then
430 begin
431 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
432 _lc[I_NET_DISC_VERSION]);
433 g_Net_Host_Kick(C^.ID, NET_DISC_VERSION);
434 Exit;
435 end;
436
437 if g_Net_IsHostBanned(C^.Peer^.address.host) then
438 begin
439 if g_Net_IsHostBanned(C^.Peer^.address.host, True) then
440 begin
441 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
442 _lc[I_NET_DISC_BAN]);
443 g_Net_Host_Kick(C^.ID, NET_DISC_BAN);
444 end
445 else
446 begin
447 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
448 _lc[I_NET_DISC_BAN]);
449 g_Net_Host_Kick(C^.ID, NET_DISC_TEMPBAN);
450 end;
451 Exit;
452 end;
453
454 if NetPassword <> '' then
455 if AnsiLowerCase(NetPassword) <> AnsiLowerCase(Pw) then
456 begin
457 g_Console_Add(_lc[I_NET_MSG] + _lc[I_NET_MSG_HOST_REJECT] +
458 _lc[I_NET_DISC_PASSWORD]);
459 g_Net_Host_Kick(C^.ID, NET_DISC_PASSWORD);
460 Exit;
461 end;
462
463 if (C^.Player <> 0) then
464 begin
465 // already received info
466 g_Net_Penalize(C, 'client info spam');
467 Exit;
468 end;
469
470 Color.R := R;
471 Color.B := B;
472 Color.G := G;
473
474 PID := g_Player_Create(Model, Color, T, False);
475 with g_Player_Get(PID) do
476 begin
477 Name := PName;
478 WeapSwitchMode := WeapSwitch;
479 SetWeaponPrefs(TmpPrefArray);
480 SwitchToEmpty := SwitchEmpty;
481 SkipFist := SkipF;
482 if (g_Force_Model_Get() <> 0) then
483 SetModel(g_Forced_Model_GetName());
484 Reset(True);
485 end;
486
487 C^.Player := PID;
488 C^.WaitForFirstSpawn := false;
489 C^.AuthTime := 0;
490
491 g_Console_Add(Format(_lc[I_PLAYER_JOIN], [PName]), True);
492 e_WriteLog('NET: Client ' + PName + ' [' + IntToStr(C^.ID) +
493 '] connected. Assigned player #' + IntToStr(PID) + '.', TMsgType.Notify);
494
495 MH_SEND_Info(C^.ID);
496
497 with g_Player_Get(PID) do
498 begin
499 Name := PName;
500 FClientID := C^.ID;
501 // round in progress, don't spawn
502 e_LogWritefln('*** client #%u (cid #%u) authenticated...', [C.ID, C.Player]);
503 //e_LogWritefln('spawning player with pid #%u...', [PID]);
504 //Respawn(gGameSettings.GameType = GT_SINGLE);
505 //k8: no, do not spawn a player yet, wait for "request full state" packet
506 Lives := 0;
507 Spectate;
508 FNoRespawn := True;
509 // `FWantsInGame` seems to mean "spawn the player on the next occasion".
510 // that is, if we'll set it to `true`, the player can be spawned after
511 // warmup time ran out, for example, regardless of the real player state.
512 // also, this seems to work only for the initial connection. further
513 // map changes could initiate resource downloading, but the player will
514 // be spawned immediately.
515 // the proper solution will require another player state, "ephemeral".
516 // the player should start any map in "ephemeral" state, and turned into
517 // real mobj only when they sent a special "i am ready" packet. this packet
518 // must be sent after receiving the full state, so the player will get a full
519 // map view before going into game.
520 FWantsInGame := false;
521 C^.WaitForFirstSpawn := true;
522 end;
523
524 //if not C^.WaitForFirstSpawn then
525 begin
526 for I := Low(NetClients) to High(NetClients) do
527 begin
528 if NetClients[I].ID = C^.ID then Continue;
529 MH_SEND_PlayerCreate(PID, NetClients[I].ID);
530 MH_SEND_PlayerPos(True, PID, NetClients[I].ID);
531 MH_SEND_PlayerStats(PID, NetClients[I].ID);
532 end;
533 end;
534
535 if gState in [STATE_INTERCUSTOM, STATE_FOLD] then
536 MH_SEND_GameEvent(NET_EV_MAPEND, 0, 'N', C^.ID);
537
538 if NetUseMaster then
539 begin
540 //g_Net_Slist_Update;
541 g_Net_Slist_Pulse();
542 end;
543 end;
544
545
546 procedure MH_ProcessFirstSpawn (C: pTNetClient);
547 var
548 plr: TPlayer;
549 begin
550 if not C.WaitForFirstSpawn then exit;
551 plr := g_Player_Get(C^.Player);
552 if not assigned(plr) then exit;
553 g_Net_Slist_ServerPlayerComes();
554 e_LogWritefln('*** client #%u (cid #%u) first spawn', [C.ID, C.Player]);
555 C.WaitForFirstSpawn := false;
556 plr.FNoRespawn := false;
557 plr.FWantsInGame := true; // TODO: look into this later
558
559 if (gGameSettings.MaxLives > 0) and (gLMSRespawn = LMS_RESPAWN_NONE) then
560 begin
561 plr.Spectate;
562 MH_SEND_GameEvent(NET_EV_LMS_NOSPAWN, 0, 'N', C.ID);
563 end
564 else
565 begin
566 plr.Respawn(False);
567 if gLMSRespawn > LMS_RESPAWN_NONE then
568 MH_SEND_GameEvent(NET_EV_LMS_WARMUP, gLMSRespawnTime - gTime, 'N', C.ID);
569 end;
570 end;
571
572
573 procedure MH_RECV_FullStateRequest(C: pTNetClient; var M: TMsg);
574 begin
575 //e_LogWritefln('*** client #%u (cid #%u) full state request', [C.ID, C.Player]);
576
577 if C^.FullUpdateSent then
578 begin
579 // FullStateRequest spam?
580 g_Net_Penalize(C, 'duplicate full state request');
581 exit;
582 end;
583
584 if gGameOn then
585 begin
586 MH_SEND_Everything((C^.State = NET_STATE_AUTH), C^.ID)
587 end
588 else
589 begin
590 C^.RequestedFullUpdate := True;
591 end;
592 end;
593
594 // PLAYER
595
596 function MH_RECV_PlayerPos(C: pTNetClient; var M: TMsg): Word;
597 var
598 Dir, i: Byte;
599 WeaponAct: Byte;
600 WeaponSelect: Word;
601 PID: Word;
602 kByte: Word;
603 Pl: TPlayer;
604 GT: LongWord;
605 Err: Boolean;
606 begin
607 Result := 0;
608 Err := False;
609 if not gGameOn then Exit;
610
611 try
612 GT := M.ReadLongWord();
613 except
614 Err := True;
615 end;
616
617 if Err then begin MH_MalformedPacket(C); Exit; end;
618
619 PID := C^.Player;
620 Pl := g_Player_Get(PID);
621 if Pl = nil then
622 Exit;
623
624 if (GT > gTime + NET_MAX_DIFFTIME) or (GT < Pl.NetTime) then Exit;
625
626 with Pl do
627 begin
628 NetTime := GT;
629 try
630 kByte := M.ReadWord();
631 Dir := M.ReadByte();
632 WeaponAct := M.ReadByte();
633 WeaponSelect := M.ReadWord();
634 except
635 Err := True;
636 end;
637
638 if Err then begin MH_MalformedPacket(C); Exit; end;
639
640 //e_WriteLog(Format('R:ws=%d', [WeaponSelect]), MSG_WARNING);
641 if Direction <> TDirection(Dir) then
642 JustTeleported := False;
643
644 SetDirection(TDirection(Dir));
645 ReleaseKeys;
646
647 if kByte = NET_KEY_CHAT then
648 begin
649 PressKey(KEY_CHAT, 10000);
650 Exit;
651 end;
652
653 if LongBool(kByte and NET_KEY_LEFT) then PressKey(KEY_LEFT, 10000);
654 if LongBool(kByte and NET_KEY_RIGHT) then PressKey(KEY_RIGHT, 10000);
655 if LongBool(kByte and NET_KEY_UP) then PressKey(KEY_UP, 10000);
656 if LongBool(kByte and NET_KEY_DOWN) then PressKey(KEY_DOWN, 10000);
657 if LongBool(kByte and NET_KEY_JUMP) then PressKey(KEY_JUMP, 10000);
658 if LongBool(kByte and NET_KEY_FIRE) then PressKey(KEY_FIRE, 10000);
659 if LongBool(kByte and NET_KEY_OPEN) then PressKey(KEY_OPEN, 10000);
660
661 for i := 0 to 7 do
662 begin
663 if (WeaponAct and Byte(1 shl i)) <> 0 then
664 begin
665 //e_WriteLog(Format(' R:wn=%d', [i]), MSG_WARNING);
666 ProcessWeaponAction(i);
667 end;
668 end;
669
670 for i := 0 to 15 do
671 begin
672 if (WeaponSelect and Word(1 shl i)) <> 0 then
673 begin
674 //e_WriteLog(Format(' R:wn=%d', [i]), MSG_WARNING);
675 QueueWeaponSwitch(i);
676 end;
677 end;
678 end;
679
680 // MH_SEND_PlayerPos(False, PID, C^.ID);
681 end;
682
683 procedure MH_RECV_CheatRequest(C: pTNetClient; var M: TMsg);
684 var
685 CheatKind: Byte;
686 Pl: TPlayer;
687 Err: Boolean;
688 begin
689 Err := False;
690 Pl := g_Player_Get(C^.Player);
691 if Pl = nil then Exit;
692
693 try
694 CheatKind := M.ReadByte();
695 except
696 Err := True;
697 end;
698
699 if Err then begin MH_MalformedPacket(C); Exit; end;
700
701 case CheatKind of
702 NET_CHEAT_SUICIDE:
703 Pl.Damage(SUICIDE_DAMAGE, Pl.UID, 0, 0, HIT_SELF);
704 NET_CHEAT_SPECTATE:
705 begin
706 if Pl.FSpectator then
707 begin
708 if (gGameSettings.MaxLives = 0) or (gLMSRespawn > LMS_RESPAWN_NONE) then
709 Pl.Respawn(False)
710 else
711 MH_SEND_GameEvent(NET_EV_LMS_NOSPAWN, Pl.UID);
712 end
713 else
714 Pl.Spectate;
715 end;
716 NET_CHEAT_READY:
717 begin
718 if gState <> STATE_INTERCUSTOM then Exit;
719 Pl.FReady := not Pl.FReady;
720 if Pl.FReady then
721 begin
722 MH_SEND_GameEvent(NET_EV_INTER_READY, Pl.UID, 'Y');
723 Inc(gInterReadyCount);
724 end
725 else
726 begin
727 MH_SEND_GameEvent(NET_EV_INTER_READY, Pl.UID, 'N');
728 Dec(gInterReadyCount);
729 end;
730 end;
731 NET_CHEAT_DROPFLAG:
732 Pl.TryDropFlag();
733 end;
734 end;
735
736 procedure MH_RECV_PlayerSettings(C: pTNetClient; var M: TMsg);
737 var
738 TmpName: string;
739 TmpModel: string;
740 TmpColor: TRGB;
741 TmpTeam: Byte;
742 TmpWeapSwitch: Byte;
743 TmpPrefArray: Array [WP_FIRST .. WP_LAST + 1] of Byte;
744 TmpSwEmpty: Byte;
745 TmpSkipF: Byte;
746 I: Integer;
747 Pl: TPlayer;
748 Err: Boolean;
749 begin
750 Err := False;
751 try
752 TmpName := M.ReadString();
753 TmpModel := M.ReadString();
754 TmpColor.R := M.ReadByte();
755 TmpColor.G := M.ReadByte();
756 TmpColor.B := M.ReadByte();
757 TmpTeam := M.ReadByte();
758 TmpWeapSwitch := M.ReadByte();
759 for I := WP_FIRST to WP_LAST + 1 do
760 TmpPrefArray[I] := M.ReadByte();
761 TmpSwEmpty := M.ReadByte();
762 TmpSkipF := M.ReadByte();
763 except
764 Err := True;
765 end;
766
767 if Err then begin MH_MalformedPacket(C); Exit; end;
768
769 Pl := g_Player_Get(C^.Player);
770 if Pl = nil then Exit;
771
772 if (gGameSettings.GameMode in [GM_TDM, GM_CTF]) and (Pl.Team <> TmpTeam) then
773 Pl.SwitchTeam
774 else
775 Pl.SetColor(TmpColor);
776
777 if Pl.Name <> TmpName then
778 begin
779 g_Console_Add(Format(_lc[I_PLAYER_NAME], [Pl.Name, TmpName]), True);
780 Pl.Name := TmpName;
781 end;
782
783 if (g_Force_Model_Get() <> 0) then
784 TmpModel := g_Forced_Model_GetName();
785 if TmpModel <> Pl.Model.GetName() then
786 Pl.SetModel(TmpModel);
787
788 if (TmpWeapSwitch <> Pl.WeapSwitchMode) then
789 Pl.WeapSwitchMode := TmpWeapSwitch;
790
791 Pl.SetWeaponPrefs(TmpPrefArray);
792 if (TmpSwEmpty <> Pl.SwitchToEmpty) then
793 Pl.SwitchToEmpty := TmpSwEmpty;
794
795 if (TmpSkipF <> Pl.SkipFist) then
796 Pl.SkipFist := TmpSkipF;
797
798 MH_SEND_PlayerSettings(Pl.UID, TmpModel);
799 end;
800
801 // RCON
802
803 procedure MH_RECV_RCONPassword(C: pTNetClient; var M: TMsg);
804 var
805 Pwd: string;
806 Err: Boolean;
807 begin
808 Err := False;
809 try
810 Pwd := M.ReadString();
811 except
812 Err := True;
813 end;
814 if Err then begin MH_MalformedPacket(C); Exit; end;
815 if not NetAllowRCON then Exit;
816 if Pwd = NetRCONPassword then
817 begin
818 C^.RCONAuth := True;
819 MH_SEND_GameEvent(NET_EV_RCON, NET_RCON_PWGOOD, 'N', C^.ID);
820 end
821 else
822 MH_SEND_GameEvent(NET_EV_RCON, NET_RCON_PWBAD, 'N', C^.ID);
823 end;
824
825 procedure MH_RECV_RCONCommand(C: pTNetClient; var M: TMsg);
826 var
827 Cmd: string;
828 Err: Boolean;
829 begin
830 Err := False;
831 try
832 Cmd := M.ReadString();
833 except
834 Err := True;
835 end;
836 if Err then begin MH_MalformedPacket(C); Exit; end;
837 if not NetAllowRCON then Exit;
838 if not C^.RCONAuth then
839 begin
840 MH_SEND_GameEvent(NET_EV_RCON, NET_RCON_NOAUTH, 'N', C^.ID);
841 Exit;
842 end;
843 g_Console_Process(Cmd);
844 end;
845
846 // MISC
847
848 procedure MH_RECV_Vote(C: pTNetClient; var M: TMsg);
849 var
850 Start: Boolean;
851 Name, Command: string;
852 Need: Integer;
853 Pl: TPlayer;
854 Err: Boolean;
855 begin
856 Err := False;
857 try
858 Start := M.ReadByte() <> 0;
859 Command := M.ReadString();
860 except
861 Err := True;
862 end;
863
864 if Err then begin MH_MalformedPacket(C); Exit; end;
865
866 Pl := g_Player_Get(C^.Player);
867 if Pl = nil then Exit;
868 Name := Pl.Name;
869
870 if Start then
871 begin
872 if not g_Console_CommandBlacklisted(Command) then
873 g_Game_StartVote(Command, Name);
874 end
875 else if gVoteInProgress then
876 begin
877 if (gPlayer1 <> nil) or (gPlayer2 <> nil) then
878 Need := Floor((NetClientCount+1)/2.0) + 1
879 else
880 Need := Floor(NetClientCount/2.0) + 1;
881 if C^.Voted then
882 begin
883 Dec(gVoteCount);
884 C^.Voted := False;
885 g_Console_Add(Format(_lc[I_MESSAGE_VOTE_REVOKED], [Name, gVoteCount, Need]), True);
886 MH_SEND_VoteEvent(NET_VE_REVOKE, Name, 'a', gVoteCount, Need);
887 end
888 else
889 begin
890 Inc(gVoteCount);
891 C^.Voted := True;
892 g_Console_Add(Format(_lc[I_MESSAGE_VOTE_VOTE], [Name, gVoteCount, Need]), True);
893 MH_SEND_VoteEvent(NET_VE_VOTE, Name, 'a', gVoteCount, Need);
894 g_Game_CheckVote;
895 end;
896 end;
897 end;
898
899 // GAME (SEND)
900
901 procedure MH_SEND_Everything(CreatePlayers: Boolean {= False}; ID: Integer {= NET_EVERYONE});
902
903 function sendItemRespawn (it: PItem): Boolean;
904 begin
905 result := false; // don't stop
906 MH_SEND_ItemSpawn(True, it.myid, ID);
907 end;
908
909 function sendMonSpawn (mon: TMonster): Boolean;
910 begin
911 result := false; // don't stop
912 MH_SEND_MonsterSpawn(mon.UID, ID);
913 end;
914
915 function sendPanelState (pan: TPanel): Boolean;
916 begin
917 result := false; // don't stop
918 MH_SEND_PanelState(pan.guid, ID); // anyway, to sync mplats
919 if (pan.CanChangeTexture) then MH_SEND_PanelTexture(pan.guid, ID);
920 end;
921
922 var
923 I: Integer;
924 begin
925 if (ID < 0) or (ID >= Length(NetClients)) then
926 exit; // bogus client, this shouldn't happen
927
928 NetClients[ID].FullUpdateSent := True;
929
930 e_LogWritefln('*** client #%u (cid #%u) will get everything', [ID, NetClients[ID].Player]);
931
932 MH_ProcessFirstSpawn(@NetClients[ID]);
933
934 if gPlayers <> nil then
935 begin
936 for I := Low(gPlayers) to High(gPlayers) do
937 begin
938 if gPlayers[I] <> nil then
939 begin
940 if CreatePlayers then MH_SEND_PlayerCreate(gPlayers[I].UID, ID);
941 MH_SEND_PlayerPos(True, gPlayers[I].UID, ID);
942 MH_SEND_PlayerStats(gPlayers[I].UID, ID);
943
944 if (gPlayers[I].Flag <> FLAG_NONE) and (gGameSettings.GameMode = GM_CTF) then
945 begin
946 MH_SEND_FlagEvent(FLAG_STATE_CAPTURED, gPlayers[I].Flag, gPlayers[I].UID, True, ID);
947 end;
948 end;
949 end;
950 end;
951
952 g_Items_ForEachAlive(sendItemRespawn, true); // backwards
953 g_Mons_ForEach(sendMonSpawn);
954 g_Map_ForEachPanel(sendPanelState);
955
956 if gTriggers <> nil then
957 begin
958 for I := Low(gTriggers) to High(gTriggers) do
959 begin
960 if gTriggers[I].TriggerType = TRIGGER_SOUND then
961 begin
962 MH_SEND_TriggerSound(gTriggers[I], ID);
963 end;
964 end;
965 end;
966
967 if Shots <> nil then
968 begin
969 for I := Low(Shots) to High(Shots) do
970 begin
971 if Shots[i].ShotType in [6, 7, 8] then
972 begin
973 MH_SEND_CreateShot(i, ID);
974 end;
975 end;
976 end;
977
978 MH_SEND_TriggerMusic(ID);
979
980 MH_SEND_GameStats(ID);
981 MH_SEND_CoopStats(ID);
982
983 if gGameSettings.GameMode = GM_CTF then
984 begin
985 if gFlags[FLAG_RED].State <> FLAG_STATE_CAPTURED then MH_SEND_FlagEvent(gFlags[FLAG_RED].State, FLAG_RED, 0, True, ID);
986 if gFlags[FLAG_BLUE].State <> FLAG_STATE_CAPTURED then MH_SEND_FlagEvent(gFlags[FLAG_BLUE].State, FLAG_BLUE, 0, True, ID);
987 end;
988
989 if CreatePlayers and (ID >= 0) then NetClients[ID].State := NET_STATE_GAME;
990
991 g_Net_Flush();
992 end;
993
994 procedure MH_SEND_Info(ID: Byte);
995 begin
996 NetOut.Clear();
997
998 NetOut.Write(Byte(NET_MSG_INFO));
999 NetOut.Write(ID);
1000 NetOut.Write(NetClients[ID].Player);
1001 NetOut.Write(ExtractFileName(gGameSettings.WAD));
1002 NetOut.Write(g_ExtractFileName(gMapInfo.Map));
1003 NetOut.Write(gWADHash);
1004 NetOut.Write(gGameSettings.GameMode);
1005 NetOut.Write(gGameSettings.ScoreLimit);
1006 NetOut.Write(gGameSettings.TimeLimit);
1007 NetOut.Write(gGameSettings.MaxLives);
1008 NetOut.Write(gGameSettings.Options);
1009 NetOut.Write(gTime);
1010
1011 g_Net_Host_Send(ID, True, NET_CHAN_SERVICE);
1012 end;
1013
1014 procedure MH_SEND_Chat(Txt: string; Mode: Byte; ID: Integer = NET_EVERYONE);
1015 var
1016 Name: string;
1017 i: Integer;
1018 Team: Byte;
1019 begin
1020 if (Mode = NET_CHAT_TEAM) and (not gGameSettings.GameMode in [GM_TDM, GM_CTF]) then
1021 Mode := NET_CHAT_PLAYER;
1022
1023 Team := 0;
1024 if (Mode = NET_CHAT_TEAM) then
1025 begin
1026 for i := Low(gPlayers) to High(gPlayers) do
1027 if (gPlayers[i] <> nil) and (gPlayers[i].FClientID >= 0) and
1028 (gPlayers[i].Team = ID) then
1029 begin
1030 NetOut.Write(Byte(NET_MSG_CHAT));
1031 NetOut.Write(Txt);
1032 NetOut.Write(Mode);
1033 g_Net_Host_Send(gPlayers[i].FClientID, True, NET_CHAN_CHAT);
1034 end;
1035 Team := ID;
1036 ID := NET_EVERYONE;
1037 end
1038 else
1039 begin
1040 NetOut.Write(Byte(NET_MSG_CHAT));
1041 NetOut.Write(Txt);
1042 NetOut.Write(Mode);
1043 g_Net_Host_Send(ID, True, NET_CHAN_CHAT);
1044 end;
1045
1046 if Mode = NET_CHAT_SYSTEM then
1047 Exit;
1048
1049 if ID = NET_EVERYONE then
1050 begin
1051 if Mode = NET_CHAT_PLAYER then
1052 begin
1053 g_Console_Add(Txt, True);
1054 e_WriteLog('[Chat] ' + b_Text_Unformat(Txt), TMsgType.Notify);
1055 g_Game_ChatSound(b_Text_Unformat(Txt));
1056 end
1057 else
1058 if Mode = NET_CHAT_TEAM then
1059 if gPlayer1 <> nil then
1060 begin
1061 if (gPlayer1.Team = TEAM_RED) and (Team = TEAM_RED) then
1062 begin
1063 g_Console_Add(#18'[Team] '#2 + Txt, True);
1064 e_WriteLog('[Team Chat] ' + b_Text_Unformat(Txt), TMsgType.Notify);
1065 g_Game_ChatSound(b_Text_Unformat(Txt));
1066 end
1067 else if (gPlayer1.Team = TEAM_BLUE) and (Team = TEAM_BLUE) then
1068 begin
1069 g_Console_Add(#20'[Team] '#2 + Txt, True);
1070 e_WriteLog('[Team Chat] ' + b_Text_Unformat(Txt), TMsgType.Notify);
1071 g_Game_ChatSound(b_Text_Unformat(Txt));
1072 end;
1073 end;
1074 end
1075 else
1076 begin
1077 Name := g_Net_ClientName_ByID(ID);
1078 g_Console_Add('-> ' + Name + ': ' + Txt, True);
1079 e_WriteLog('[Tell ' + Name + '] ' + b_Text_Unformat(Txt), TMsgType.Notify);
1080 g_Game_ChatSound(b_Text_Unformat(Txt), False);
1081 end;
1082 end;
1083
1084 procedure MH_SEND_Effect(X, Y: Integer; Ang: SmallInt; Kind: Byte; ID: Integer = NET_EVERYONE);
1085 begin
1086 NetOut.Write(Byte(NET_MSG_GFX));
1087 NetOut.Write(Kind);
1088 NetOut.Write(X);
1089 NetOut.Write(Y);
1090 NetOut.Write(Ang);
1091
1092 g_Net_Host_Send(ID, False, NET_CHAN_GAME);
1093 end;
1094
1095 procedure MH_SEND_Sound(X, Y: Integer; Name: string; Pos: Boolean = True; ID: Integer = NET_EVERYONE);
1096 begin
1097 NetOut.Write(Byte(NET_MSG_SND));
1098 NetOut.Write(Name);
1099 if Pos then
1100 begin
1101 NetOut.Write(Byte(1));
1102 NetOut.Write(X);
1103 NetOut.Write(Y);
1104 end
1105 else
1106 NetOut.Write(Byte(0));
1107
1108 g_Net_Host_Send(ID, False, NET_CHAN_GAME);
1109 end;
1110
1111 procedure MH_SEND_CreateShot(Proj: LongInt; ID: Integer = NET_EVERYONE);
1112 begin
1113 if (Shots = nil) or (Proj < 0) or (Proj > High(Shots)) then Exit;
1114
1115 NetOut.Write(Byte(NET_MSG_SHADD));
1116 NetOut.Write(Proj);
1117 NetOut.Write(Shots[Proj].ShotType);
1118 NetOut.Write(Shots[Proj].Target);
1119 NetOut.Write(Shots[Proj].SpawnerUID);
1120 NetOut.Write(Shots[Proj].Timeout);
1121 NetOut.Write(Shots[Proj].Obj.X);
1122 NetOut.Write(Shots[Proj].Obj.Y);
1123 NetOut.Write(Shots[Proj].Obj.Vel.X);
1124 NetOut.Write(Shots[Proj].Obj.Vel.Y);
1125
1126 g_Net_Host_Send(ID, True, NET_CHAN_SHOTS);
1127 end;
1128
1129 procedure MH_SEND_UpdateShot(Proj: LongInt; ID: Integer = NET_EVERYONE);
1130 begin
1131 if (Shots = nil) or (Proj < 0) or (Proj > High(Shots)) then Exit;
1132
1133 NetOut.Write(Byte(NET_MSG_SHPOS));
1134 NetOut.Write(Proj);
1135 NetOut.Write(Shots[Proj].Obj.X);
1136 NetOut.Write(Shots[Proj].Obj.Y);
1137 NetOut.Write(Shots[Proj].Obj.Vel.X);
1138 NetOut.Write(Shots[Proj].Obj.Vel.Y);
1139
1140 g_Net_Host_Send(ID, False, NET_CHAN_SHOTS);
1141 end;
1142
1143 procedure MH_Send_DeleteShot(Proj: LongInt; X, Y: LongInt; Loud: Boolean = True; ID: Integer = NET_EVERYONE);
1144 begin
1145 NetOut.Write(Byte(NET_MSG_SHDEL));
1146 NetOut.Write(Proj);
1147 NetOut.Write(Byte(Loud));
1148 NetOut.Write(X);
1149 NetOut.Write(Y);
1150
1151 g_Net_Host_Send(ID, True, NET_CHAN_SHOTS);
1152 end;
1153
1154 procedure MH_SEND_GameStats(ID: Integer = NET_EVERYONE);
1155 begin
1156 NetOut.Write(Byte(NET_MSG_SCORE));
1157 if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
1158 begin
1159 NetOut.Write(gTeamStat[TEAM_RED].Score);
1160 NetOut.Write(gTeamStat[TEAM_BLUE].Score);
1161 end
1162 else
1163 if gGameSettings.GameMode = GM_COOP then
1164 begin
1165 NetOut.Write(gCoopMonstersKilled);
1166 NetOut.Write(gCoopSecretsFound);
1167 end;
1168
1169 g_Net_Host_Send(ID, True, NET_CHAN_IMPORTANT);
1170 end;
1171
1172 procedure MH_SEND_CoopStats(ID: Integer = NET_EVERYONE);
1173 begin
1174 NetOut.Write(Byte(NET_MSG_COOP));
1175 NetOut.Write(gTotalMonsters);
1176 NetOut.Write(gSecretsCount);
1177 NetOut.Write(gCoopTotalMonstersKilled);
1178 NetOut.Write(gCoopTotalSecretsFound);
1179 NetOut.Write(gCoopTotalMonsters);
1180 NetOut.Write(gCoopTotalSecrets);
1181 end;
1182
1183 procedure MH_SEND_GameEvent(EvType: Byte; EvNum: Integer = 0; EvStr: string = 'N'; ID: Integer = NET_EVERYONE);
1184 begin
1185 NetOut.Write(Byte(NET_MSG_GEVENT));
1186 NetOut.Write(EvType);
1187 NetOut.Write(EvNum);
1188 NetOut.Write(EvStr);
1189 NetOut.Write(Byte(gLastMap));
1190 NetOut.Write(gTime);
1191 if (EvType = NET_EV_MAPSTART) and isWadPath(EvStr) then
1192 begin
1193 NetOut.Write(Byte(1));
1194 NetOut.Write(gWADHash);
1195 end else
1196 NetOut.Write(Byte(0));
1197
1198 g_Net_Host_Send(ID, True, NET_CHAN_SERVICE);
1199 end;
1200
1201 procedure MH_SEND_FlagEvent(EvType: Byte; Flag: Byte; PID: Word; Quiet: Boolean = False; ID: Integer = NET_EVERYONE);
1202 begin
1203 NetOut.Write(Byte(NET_MSG_FLAG));
1204 NetOut.Write(EvType);
1205 NetOut.Write(Flag);
1206 NetOut.Write(Byte(Quiet));
1207 NetOut.Write(PID);
1208 NetOut.Write(gFlags[Flag].State);
1209 NetOut.Write(gFlags[Flag].CaptureTime);
1210 NetOut.Write(gFlags[Flag].Obj.X);
1211 NetOut.Write(gFlags[Flag].Obj.Y);
1212 NetOut.Write(gFlags[Flag].Obj.Vel.X);
1213 NetOut.Write(gFlags[Flag].Obj.Vel.Y);
1214 NetOut.Write(Byte(gFlags[Flag].Direction));
1215
1216 g_Net_Host_Send(ID, True, NET_CHAN_IMPORTANT);
1217 end;
1218
1219 procedure MH_SEND_FlagPos(Flag: Byte; ID: Integer = NET_EVERYONE);
1220 begin
1221 NetOut.Write(Byte(NET_MSG_FLAGPOS));
1222 NetOut.Write(Flag);
1223 NetOut.Write(gFlags[Flag].Obj.X);
1224 NetOut.Write(gFlags[Flag].Obj.Y);
1225 NetOut.Write(gFlags[Flag].Obj.Vel.X);
1226 NetOut.Write(gFlags[Flag].Obj.Vel.Y);
1227
1228 g_Net_Host_Send(ID, False, NET_CHAN_IMPORTANT);
1229 end;
1230
1231 procedure MH_SEND_GameSettings(ID: Integer = NET_EVERYONE);
1232 begin
1233 NetOut.Write(Byte(NET_MSG_GSET));
1234 NetOut.Write(gGameSettings.GameMode);
1235 NetOut.Write(gGameSettings.ScoreLimit);
1236 NetOut.Write(gGameSettings.TimeLimit);
1237 NetOut.Write(gGameSettings.MaxLives);
1238 NetOut.Write(gGameSettings.Options);
1239
1240 g_Net_Host_Send(ID, True, NET_CHAN_IMPORTANT);
1241 end;
1242
1243 // PLAYER (SEND)
1244
1245 procedure MH_SEND_PlayerCreate(PID: Word; ID: Integer = NET_EVERYONE);
1246 var
1247 P: TPlayer;
1248 begin
1249 P := g_Player_Get(PID);
1250 if P = nil then Exit;
1251
1252 NetOut.Write(Byte(NET_MSG_PLR));
1253 NetOut.Write(PID);
1254 NetOut.Write(P.Name);
1255
1256 NetOut.Write(P.FActualModelName);
1257 NetOut.Write(P.FColor.R);
1258 NetOut.Write(P.FColor.G);
1259 NetOut.Write(P.FColor.B);
1260 NetOut.Write(P.Team);
1261
1262 g_Net_Host_Send(ID, True, NET_CHAN_IMPORTANT)
1263 end;
1264
1265 procedure MH_SEND_PlayerPos(Reliable: Boolean; PID: Word; ID: Integer = NET_EVERYONE);
1266 var
1267 kByte: Word;
1268 Pl: TPlayer;
1269 begin
1270 Pl := g_Player_Get(PID);
1271 if Pl = nil then Exit;
1272 if Pl.FDummy then Exit;
1273
1274 NetOut.Write(Byte(NET_MSG_PLRPOS));
1275 NetOut.Write(gTime);
1276 NetOut.Write(PID);
1277
1278 kByte := 0;
1279
1280 with Pl do
1281 begin
1282 NetOut.Write(FPing);
1283 NetOut.Write(FLoss);
1284 if IsKeyPressed(KEY_CHAT) then
1285 kByte := NET_KEY_CHAT
1286 else
1287 begin
1288 if IsKeyPressed(KEY_LEFT) then kByte := kByte or NET_KEY_LEFT;
1289 if IsKeyPressed(KEY_RIGHT) then kByte := kByte or NET_KEY_RIGHT;
1290 if IsKeyPressed(KEY_UP) then kByte := kByte or NET_KEY_UP;
1291 if IsKeyPressed(KEY_DOWN) then kByte := kByte or NET_KEY_DOWN;
1292 if IsKeyPressed(KEY_JUMP) then kByte := kByte or NET_KEY_JUMP;
1293 end;
1294
1295 if JustTeleported then kByte := kByte or NET_KEY_FORCEDIR;
1296
1297 NetOut.Write(kByte);
1298 if Direction = TDirection.D_LEFT then NetOut.Write(Byte(0)) else NetOut.Write(Byte(1));
1299 NetOut.Write(GameX);
1300 NetOut.Write(GameY);
1301 NetOut.Write(GameVelX);
1302 NetOut.Write(GameVelY);
1303 NetOut.Write(GameAccelX);
1304 NetOut.Write(GameAccelY);
1305 end;
1306
1307 g_Net_Host_Send(ID, Reliable, NET_CHAN_PLAYERPOS);
1308 end;
1309
1310 procedure MH_SEND_PlayerStats(PID: Word; ID: Integer = NET_EVERYONE);
1311 var
1312 P: TPlayer;
1313 I: Integer;
1314 begin
1315 P := g_Player_Get(PID);
1316 if P = nil then Exit;
1317
1318 NetOut.Write(Byte(NET_MSG_PLRSTA));
1319 NetOut.Write(PID);
1320
1321 with P do
1322 begin
1323 NetOut.Write(Byte(alive));
1324 NetOut.Write(Byte(GodMode));
1325 NetOut.Write(Health);
1326 NetOut.Write(Armor);
1327 NetOut.Write(Air);
1328 NetOut.Write(JetFuel);
1329 NetOut.Write(Lives);
1330 NetOut.Write(Team);
1331
1332 for I := WP_FIRST to WP_LAST do
1333 NetOut.Write(Byte(FWeapon[I]));
1334
1335 for I := A_BULLETS to A_HIGH do
1336 NetOut.Write(FAmmo[I]);
1337
1338 for I := A_BULLETS to A_HIGH do
1339 NetOut.Write(FMaxAmmo[I]);
1340
1341 for I := MR_SUIT to MR_MAX do
1342 NetOut.Write(LongWord(FMegaRulez[I]));
1343
1344 NetOut.Write(Byte(R_ITEM_BACKPACK in FRulez));
1345 NetOut.Write(Byte(R_KEY_RED in FRulez));
1346 NetOut.Write(Byte(R_KEY_GREEN in FRulez));
1347 NetOut.Write(Byte(R_KEY_BLUE in FRulez));
1348 NetOut.Write(Byte(R_BERSERK in FRulez));
1349
1350 NetOut.Write(Frags);
1351 NetOut.Write(Death);
1352
1353 NetOut.Write(CurrWeap);
1354
1355 NetOut.Write(Byte(FSpectator));
1356 NetOut.Write(Byte(FGhost));
1357 NetOut.Write(Byte(FPhysics));
1358 NetOut.Write(Byte(FNoRespawn));
1359 NetOut.Write(Byte(FJetpack));
1360 NetOut.Write(FFireTime);
1361 NetOut.Write(Byte(FFlaming));
1362 NetOut.Write(FSpawnInvul);
1363 end;
1364
1365 g_Net_Host_Send(ID, True, NET_CHAN_PLAYER);
1366 end;
1367
1368 procedure MH_SEND_PlayerDamage(PID: Word; Kind: Byte; Attacker, Value: Word; VX, VY: Integer; ID: Integer = NET_EVERYONE);
1369 begin
1370 NetOut.Write(Byte(NET_MSG_PLRDMG));
1371 NetOut.Write(PID);
1372 NetOut.Write(Kind);
1373 NetOut.Write(Attacker);
1374 NetOut.Write(Value);
1375 NetOut.Write(VX);
1376 NetOut.Write(VY);
1377
1378 g_Net_Host_Send(ID, False, NET_CHAN_PLAYER);
1379 end;
1380
1381 procedure MH_SEND_PlayerDeath(PID: Word; KillType, DeathType: Byte; Attacker: Word; ID: Integer = NET_EVERYONE);
1382 begin
1383 NetOut.Write(Byte(NET_MSG_PLRDIE));
1384 NetOut.Write(PID);
1385 NetOut.Write(KillType);
1386 NetOut.Write(DeathType);
1387 NetOut.Write(Attacker);
1388
1389 g_Net_Host_Send(ID, True, NET_CHAN_PLAYER);
1390 end;
1391
1392 procedure MH_SEND_PlayerFire(PID: Word; Weapon: Byte; X, Y, AX, AY: Integer; ShotID: Integer = -1; ID: Integer = NET_EVERYONE);
1393 begin
1394 NetOut.Write(Byte(NET_MSG_PLRFIRE));
1395 NetOut.Write(PID);
1396 NetOut.Write(Weapon);
1397 NetOut.Write(X);
1398 NetOut.Write(Y);
1399 NetOut.Write(AX);
1400 NetOut.Write(AY);
1401 NetOut.Write(ShotID);
1402
1403 g_Net_Host_Send(ID, True, NET_CHAN_SHOTS);
1404 end;
1405
1406 procedure MH_SEND_PlayerDelete(PID: Word; ID: Integer = NET_EVERYONE);
1407 begin
1408 NetOut.Write(Byte(NET_MSG_PLRDEL));
1409 NetOut.Write(PID);
1410
1411 g_Net_Host_Send(ID, True, NET_CHAN_IMPORTANT);
1412 end;
1413
1414 procedure MH_SEND_PlayerSettings(PID: Word; Mdl: string = ''; ID: Integer = NET_EVERYONE);
1415 var
1416 Pl: TPlayer;
1417 begin
1418 Pl := g_Player_Get(PID);
1419 if Pl = nil then Exit;
1420
1421 NetOut.Write(Byte(NET_MSG_PLRSET));
1422 NetOut.Write(PID);
1423 NetOut.Write(Pl.Name);
1424 if Mdl = '' then
1425 NetOut.Write(Pl.Model.GetName())
1426 else
1427 NetOut.Write(Mdl);
1428 NetOut.Write(Pl.FColor.R);
1429 NetOut.Write(Pl.FColor.G);
1430 NetOut.Write(Pl.FColor.B);
1431 NetOut.Write(Pl.Team);
1432
1433 g_Net_Host_Send(ID, True, NET_CHAN_IMPORTANT);
1434 end;
1435
1436 // ITEM (SEND)
1437
1438 procedure MH_SEND_ItemSpawn(Quiet: Boolean; IID: Word; ID: Integer = NET_EVERYONE);
1439 var
1440 it: PItem;
1441 tt: Byte;
1442 begin
1443 it := g_Items_ByIdx(IID);
1444
1445 NetOut.Write(Byte(NET_MSG_ISPAWN));
1446 NetOut.Write(IID);
1447 NetOut.Write(Byte(Quiet));
1448 tt := it.ItemType;
1449 if it.dropped then tt := tt or $80;
1450 NetOut.Write(tt);
1451 NetOut.Write(Byte(it.Fall));
1452 NetOut.Write(Byte(it.Respawnable));
1453 NetOut.Write(it.Obj.X);
1454 NetOut.Write(it.Obj.Y);
1455 NetOut.Write(it.Obj.Vel.X);
1456 NetOut.Write(it.Obj.Vel.Y);
1457
1458 g_Net_Host_Send(ID, True, NET_CHAN_LARGEDATA);
1459 end;
1460
1461 procedure MH_SEND_ItemDestroy(Quiet: Boolean; IID: Word; ID: Integer = NET_EVERYONE);
1462 begin
1463 NetOut.Write(Byte(NET_MSG_IDEL));
1464 NetOut.Write(IID);
1465 NetOut.Write(Byte(Quiet));
1466
1467 g_Net_Host_Send(ID, True, NET_CHAN_LARGEDATA);
1468 end;
1469
1470 procedure MH_SEND_ItemPos(IID: Word; ID: Integer = NET_EVERYONE);
1471 var
1472 it: PItem;
1473 begin
1474 it := g_Items_ByIdx(IID);
1475
1476 NetOut.Write(Byte(NET_MSG_IPOS));
1477 NetOut.Write(IID);
1478 NetOut.Write(it.Obj.X);
1479 NetOut.Write(it.Obj.Y);
1480 NetOut.Write(it.Obj.Vel.X);
1481 NetOut.Write(it.Obj.Vel.Y);
1482
1483 g_Net_Host_Send(ID, False, NET_CHAN_LARGEDATA);
1484 end;
1485
1486 // PANEL
1487
1488 procedure MH_SEND_PanelTexture(PGUID: Integer; ID: Integer = NET_EVERYONE);
1489 var
1490 TP: TPanel;
1491 begin
1492 TP := g_Map_PanelByGUID(PGUID);
1493 if (TP = nil) then exit;
1494
1495 NetOut.Write(Byte(NET_MSG_PTEX));
1496 NetOut.Write(LongWord(PGUID));
1497 NetOut.Write(TP.FCurTexture);
1498 NetOut.Write(TP.AnimTime);
1499 NetOut.Write(TP.LastAnimLoop);
1500
1501 g_Net_Host_Send(ID, True, NET_CHAN_LARGEDATA);
1502 end;
1503
1504 procedure MH_SEND_PanelState(PGUID: Integer; ID: Integer = NET_EVERYONE);
1505 var
1506 TP: TPanel;
1507 mpflags: Byte = 0;
1508 begin
1509 TP := g_Map_PanelByGUID(PGUID);
1510 if (TP = nil) then exit;
1511
1512 NetOut.Write(Byte(NET_MSG_PSTATE));
1513 NetOut.Write(LongWord(PGUID));
1514 NetOut.Write(Byte(TP.Enabled));
1515 NetOut.Write(TP.LiftType);
1516 NetOut.Write(TP.X);
1517 NetOut.Write(TP.Y);
1518 NetOut.Write(Word(TP.Width));
1519 NetOut.Write(Word(TP.Height));
1520 // mplats
1521 NetOut.Write(LongInt(TP.movingSpeedX));
1522 NetOut.Write(LongInt(TP.movingSpeedY));
1523 NetOut.Write(LongInt(TP.movingStartX));
1524 NetOut.Write(LongInt(TP.movingStartY));
1525 NetOut.Write(LongInt(TP.movingEndX));
1526 NetOut.Write(LongInt(TP.movingEndY));
1527 NetOut.Write(LongInt(TP.sizeSpeedX));
1528 NetOut.Write(LongInt(TP.sizeSpeedY));
1529 NetOut.Write(LongInt(TP.sizeEndX));
1530 NetOut.Write(LongInt(TP.sizeEndY));
1531 if TP.movingActive then mpflags := mpflags or 1;
1532 if TP.moveOnce then mpflags := mpflags or 2;
1533 NetOut.Write(Byte(mpflags));
1534
1535 g_Net_Host_Send(ID, True, NET_CHAN_LARGEDATA);
1536 end;
1537
1538 // TRIGGER
1539
1540 procedure MH_SEND_TriggerSound(var T: TTrigger; ID: Integer = NET_EVERYONE);
1541 begin
1542 if gTriggers = nil then Exit;
1543 if T.Sound = nil then Exit;
1544
1545 NetOut.Write(Byte(NET_MSG_TSOUND));
1546 NetOut.Write(T.ClientID);
1547 NetOut.Write(Byte(T.Sound.IsPlaying));
1548 NetOut.Write(LongWord(T.Sound.GetPosition));
1549 NetOut.Write(T.SoundPlayCount);
1550
1551 g_Net_Host_Send(ID, True);
1552 end;
1553
1554 procedure MH_SEND_TriggerMusic(ID: Integer = NET_EVERYONE);
1555 begin
1556 NetOut.Write(Byte(NET_MSG_TMUSIC));
1557 NetOut.Write(gMusic.Name);
1558 NetOut.Write(Byte(gMusic.IsPlaying));
1559 NetOut.Write(LongWord(gMusic.GetPosition));
1560 NetOut.Write(Byte(gMusic.SpecPause or gMusic.IsPaused));
1561
1562 g_Net_Host_Send(ID, True);
1563 end;
1564
1565 // MONSTER
1566
1567 procedure MH_SEND_MonsterSpawn(UID: Word; ID: Integer = NET_EVERYONE);
1568 var
1569 M: TMonster;
1570 begin
1571 M := g_Monsters_ByUID(UID);
1572 if M = nil then
1573 Exit;
1574
1575 with M do
1576 begin
1577 NetOut.Write(Byte(NET_MSG_MSPAWN));
1578 NetOut.Write(UID);
1579 NetOut.Write(MonsterType);
1580 NetOut.Write(MonsterState);
1581 NetOut.Write(MonsterAnim);
1582 NetOut.Write(MonsterTargetUID);
1583 NetOut.Write(MonsterTargetTime);
1584 NetOut.Write(MonsterBehaviour);
1585 NetOut.Write(MonsterSleep);
1586 NetOut.Write(MonsterHealth);
1587 NetOut.Write(MonsterAmmo);
1588 NetOut.Write(GameX);
1589 NetOut.Write(GameY);
1590 NetOut.Write(GameVelX);
1591 NetOut.Write(GameVelY);
1592 NetOut.Write(Byte(GameDirection));
1593 end;
1594
1595 g_Net_Host_Send(ID, True, NET_CHAN_LARGEDATA);
1596 end;
1597
1598 procedure MH_SEND_MonsterPos(UID: Word; ID: Integer = NET_EVERYONE);
1599 var
1600 M: TMonster;
1601 begin
1602 M := g_Monsters_ByUID(UID);
1603 if M = nil then Exit;
1604
1605 NetOut.Write(Byte(NET_MSG_MPOS));
1606 NetOut.Write(UID);
1607
1608 with M do
1609 begin
1610 NetOut.Write(GameX);
1611 NetOut.Write(GameY);
1612 NetOut.Write(GameVelX);
1613 NetOut.Write(GameVelY);
1614 NetOut.Write(Byte(GameDirection));
1615 end;
1616
1617 g_Net_Host_Send(ID, False, NET_CHAN_MONSTERPOS);
1618 end;
1619
1620 procedure MH_SEND_MonsterState(UID: Word; ForcedAnim: Byte = 255; ID: Integer = NET_EVERYONE);
1621 var
1622 M: TMonster;
1623 begin
1624 M := g_Monsters_ByUID(UID);
1625 if M = nil then Exit;
1626
1627 NetOut.Write(Byte(NET_MSG_MSTATE));
1628 NetOut.Write(UID);
1629
1630 with M do
1631 begin
1632 NetOut.Write(MonsterState);
1633 NetOut.Write(ForcedAnim);
1634 NetOut.Write(MonsterTargetUID);
1635 NetOut.Write(MonsterTargetTime);
1636 NetOut.Write(MonsterSleep);
1637 NetOut.Write(MonsterHealth);
1638 NetOut.Write(MonsterAmmo);
1639 NetOut.Write(MonsterPain);
1640 NetOut.Write(Byte(AnimIsReverse));
1641 NetOut.Write(FFireTime);
1642 end;
1643
1644 g_Net_Host_Send(ID, True, NET_CHAN_MONSTER);
1645 end;
1646
1647 procedure MH_SEND_MonsterShot(UID: Word; X, Y, VX, VY: Integer; ID: Integer = NET_EVERYONE);
1648 begin
1649 NetOut.Write(Byte(NET_MSG_MSHOT));
1650 NetOut.Write(UID);
1651 NetOut.Write(X);
1652 NetOut.Write(Y);
1653 NetOut.Write(VX);
1654 NetOut.Write(VY);
1655
1656 g_Net_Host_Send(ID, True, NET_CHAN_MONSTER);
1657 end;
1658
1659 procedure MH_SEND_MonsterDelete(UID: Word; ID: Integer = NET_EVERYONE);
1660 var
1661 M: TMonster;
1662 begin
1663 M := g_Monsters_ByUID(UID);
1664 if M = nil then Exit;
1665
1666 NetOut.Write(Byte(NET_MSG_MDEL));
1667 NetOut.Write(UID);
1668
1669 g_Net_Host_Send(ID, True, NET_CHAN_LARGEDATA);
1670 end;
1671
1672 // MISC
1673
1674 procedure MH_SEND_TimeSync(Time: LongWord; ID: Integer = NET_EVERYONE);
1675 begin
1676 NetOut.Write(Byte(NET_MSG_TIME_SYNC));
1677 NetOut.Write(Time);
1678
1679 g_Net_Host_Send(ID, False, NET_CHAN_SERVICE);
1680 end;
1681
1682 procedure MH_SEND_VoteEvent(EvType: Byte;
1683 StrArg1: string = 'a'; StrArg2: string = 'b';
1684 IntArg1: SmallInt = 0; IntArg2: SmallInt = 0;
1685 ID: Integer = NET_EVERYONE);
1686 begin
1687 NetOut.Write(Byte(NET_MSG_VOTE_EVENT));
1688 NetOut.Write(EvType);
1689 NetOut.Write(IntArg1);
1690 NetOut.Write(IntArg2);
1691 NetOut.Write(StrArg1);
1692 NetOut.Write(StrArg2);
1693
1694 g_Net_Host_Send(ID, True, NET_CHAN_IMPORTANT);
1695 end;
1696
1697 // CLIENT MESSAGES //
1698
1699 // GAME
1700
1701 procedure MC_RECV_Chat(var M: TMsg);
1702 var
1703 Txt: string;
1704 Mode: Byte;
1705 begin
1706 Txt := M.ReadString();
1707 Mode := M.ReadByte();
1708
1709 if Mode <> NET_CHAT_SYSTEM then
1710 begin
1711 if NetDeafLevel = 0 then
1712 begin
1713 if Mode = NET_CHAT_PLAYER then
1714 begin
1715 g_Console_Add(Txt, True);
1716 e_WriteLog('[Chat] ' + b_Text_Unformat(Txt), TMsgType.Notify);
1717 g_Game_ChatSound(b_Text_Unformat(Txt));
1718 end else
1719 if (Mode = NET_CHAT_TEAM) and (gPlayer1 <> nil) then
1720 begin
1721 if gPlayer1.Team = TEAM_RED then
1722 g_Console_Add(b_Text_Format('\r[Team] ') + Txt, True);
1723 if gPlayer1.Team = TEAM_BLUE then
1724 g_Console_Add(b_Text_Format('\b[Team] ') + Txt, True);
1725 e_WriteLog('[Team Chat] ' + b_Text_Unformat(Txt), TMsgType.Notify);
1726 g_Game_ChatSound(b_Text_Unformat(Txt));
1727 end;
1728 end;
1729 end else if (NetDeafLevel < 2) then
1730 g_Console_Add(Txt, True);
1731 end;
1732
1733 procedure MC_RECV_Effect(var M: TMsg);
1734 var
1735 Kind: Byte;
1736 X, Y: Integer;
1737 Ang: SmallInt;
1738 begin
1739 if not gGameOn then Exit;
1740 Kind := M.ReadByte();
1741 X := M.ReadLongInt();
1742 Y := M.ReadLongInt();
1743 Ang := M.ReadSmallInt();
1744
1745 case Kind of
1746 NET_GFX_SPARK:
1747 begin
1748 {$IFDEF ENABLE_GFX}
1749 g_GFX_Spark(X, Y, 2 + Random(2), Ang, 0, 0);
1750 {$ENDIF}
1751 end;
1752 NET_GFX_TELE:
1753 begin
1754 {$IFDEF ENABLE_GFX}
1755 g_GFX_QueueEffect(R_GFX_TELEPORT_FAST, X, Y);
1756 {$ENDIF}
1757 if Ang = 1 then
1758 g_Sound_PlayExAt('SOUND_GAME_TELEPORT', X, Y);
1759 end;
1760 NET_GFX_EXPLODE:
1761 begin
1762 {$IFDEF ENABLE_GFX}
1763 g_GFX_QueueEffect(R_GFX_EXPLODE_ROCKET, X - 64, Y - 64);
1764 {$ENDIF}
1765 if Ang = 1 then
1766 g_Sound_PlayExAt('SOUND_WEAPON_EXPLODEROCKET', X, Y);
1767 end;
1768 NET_GFX_BFGEXPL:
1769 begin
1770 {$IFDEF ENABLE_GFX}
1771 g_GFX_QueueEffect(R_GFX_EXPLODE_BFG, X - 64, Y - 64);
1772 {$ENDIF}
1773 if Ang = 1 then
1774 g_Sound_PlayExAt('SOUND_WEAPON_EXPLODEBFG', X, Y);
1775 end;
1776 NET_GFX_BFGHIT:
1777 begin
1778 {$IFDEF ENABLE_GFX}
1779 g_GFX_QueueEffect(R_GFX_BFG_HIT, X - 32, Y - 32);
1780 {$ENDIF}
1781 end;
1782 NET_GFX_FIRE:
1783 begin
1784 {$IFDEF ENABLE_GFX}
1785 g_GFX_QueueEffect(R_GFX_FIRE, X, Y);
1786 {$ENDIF}
1787 if Ang = 1 then
1788 g_Sound_PlayExAt('SOUND_FIRE', X, Y);
1789 end;
1790 NET_GFX_RESPAWN:
1791 begin
1792 {$IFDEF ENABLE_GFX}
1793 g_GFX_QueueEffect(R_GFX_ITEM_RESPAWN, X, Y);
1794 {$ENDIF}
1795 if Ang = 1 then
1796 g_Sound_PlayExAt('SOUND_ITEM_RESPAWNITEM', X, Y);
1797 end;
1798 NET_GFX_SHELL1:
1799 begin
1800 {$IFDEF ENABLE_SHELLS}
1801 g_Shells_Create(X, Y, 0, -2, SHELL_BULLET);
1802 {$ENDIF}
1803 end;
1804 NET_GFX_SHELL2:
1805 begin
1806 {$IFDEF ENABLE_SHELLS}
1807 g_Shells_Create(X, Y, 0, -2, SHELL_SHELL);
1808 {$ENDIF}
1809 end;
1810 NET_GFX_SHELL3:
1811 begin
1812 {$IFDEF ENABLE_SHELLS}
1813 g_Shells_Create(X, Y, 0, -2, SHELL_SHELL);
1814 g_Shells_Create(X, Y, 0, -2, SHELL_SHELL);
1815 {$ENDIF}
1816 end;
1817 end;
1818 end;
1819
1820 procedure MC_RECV_Sound(var M: TMsg);
1821 var
1822 Name: string;
1823 X, Y: Integer;
1824 Pos: Boolean;
1825 begin
1826 Name := M.ReadString();
1827 Pos := M.ReadByte() <> 0;
1828 if Pos then
1829 begin
1830 X := M.ReadLongInt();
1831 Y := M.ReadLongInt();
1832 g_Sound_PlayExAt(Name, X, Y);
1833 end
1834 else
1835 g_Sound_PlayEx(Name);
1836 end;
1837
1838 procedure MC_RECV_CreateShot(var M: TMsg);
1839 var
1840 I, X, Y, XV, YV: Integer;
1841 Timeout: LongWord;
1842 Target, Spawner: Word;
1843 ShType: Byte;
1844 begin
1845 I := M.ReadLongInt();
1846 ShType := M.ReadByte();
1847 Target := M.ReadWord();
1848 Spawner := M.ReadWord();
1849 Timeout := M.ReadLongWord();
1850 X := M.ReadLongInt();
1851 Y := M.ReadLongInt();
1852 XV := M.ReadLongInt();
1853 YV := M.ReadLongInt();
1854
1855 I := g_Weapon_CreateShot(I, ShType, Spawner, Target, X, Y, XV, YV);
1856 if (Shots <> nil) and (I <= High(Shots)) then
1857 begin
1858 Shots[I].Timeout := Timeout;
1859 //Shots[I].Target := Target; // TODO: find a use for Target later
1860 end;
1861 end;
1862
1863 procedure MC_RECV_UpdateShot(var M: TMsg);
1864 var
1865 I, TX, TY, TXV, TYV: Integer;
1866 begin
1867 I := M.ReadLongInt();
1868 TX := M.ReadLongInt();
1869 TY := M.ReadLongInt();
1870 TXV := M.ReadLongInt();
1871 TYV := M.ReadLongInt();
1872
1873 if (Shots <> nil) and (I <= High(Shots)) then
1874 with (Shots[i]) do
1875 begin
1876 Obj.X := TX;
1877 Obj.Y := TY;
1878 Obj.Vel.X := TXV;
1879 Obj.Vel.Y := TYV;
1880 end;
1881 end;
1882
1883 procedure MC_RECV_DeleteShot(var M: TMsg);
1884 var
1885 I, X, Y: Integer;
1886 L: Boolean;
1887 begin
1888 if not gGameOn then Exit;
1889 I := M.ReadLongInt();
1890 L := (M.ReadByte() <> 0);
1891 X := M.ReadLongInt();
1892 Y := M.ReadLongInt();
1893
1894 g_Weapon_DestroyShot(I, X, Y, L);
1895 end;
1896
1897 procedure MC_RECV_GameStats(var M: TMsg);
1898 begin
1899 if gGameSettings.GameMode in [GM_TDM, GM_CTF] then
1900 begin
1901 gTeamStat[TEAM_RED].Score := M.ReadSmallInt();
1902 gTeamStat[TEAM_BLUE].Score := M.ReadSmallInt();
1903 end
1904 else
1905 if gGameSettings.GameMode = GM_COOP then
1906 begin
1907 gCoopMonstersKilled := M.ReadWord();
1908 gCoopSecretsFound := M.ReadWord();
1909 end;
1910 end;
1911
1912 procedure MC_RECV_CoopStats(var M: TMsg);
1913 begin
1914 gTotalMonsters := M.ReadLongInt();
1915 gSecretsCount := M.ReadLongInt();
1916 gCoopTotalMonstersKilled := M.ReadWord();
1917 gCoopTotalSecretsFound := M.ReadWord();
1918 gCoopTotalMonsters := M.ReadWord();
1919 gCoopTotalSecrets := M.ReadWord();
1920 end;
1921
1922 procedure MC_RECV_GameEvent(var M: TMsg);
1923 var
1924 EvType: Byte;
1925 EvNum: Integer;
1926 EvStr: string;
1927 EvTime: LongWord;
1928 BHash: Boolean;
1929 EvHash: TMD5Digest;
1930 pl: TPlayer;
1931 i1, i2: TStrings_Locale;
1932 pln: String;
1933 cnt: Byte;
1934 goodCmd: Boolean = true;
1935 begin
1936 FillChar(EvHash, Sizeof(EvHash), 0);
1937 EvType := M.ReadByte();
1938 EvNum := M.ReadLongInt();
1939 EvStr := M.ReadString();
1940 gLastMap := M.ReadByte() <> 0;
1941 if gLastMap and (gGameSettings.GameMode = GM_COOP) then gStatsOff := True;
1942 gStatsPressed := True;
1943 EvTime := M.ReadLongWord();
1944 BHash := M.ReadByte() <> 0;
1945 if BHash then
1946 EvHash := M.ReadMD5();
1947
1948 gTime := EvTime;
1949
1950 if (g_Res_received_map_start <> 0) then
1951 begin
1952 if (g_Res_received_map_start < 0) then exit;
1953 goodCmd := false;
1954 case EvType of
1955 NET_EV_MAPSTART: goodCmd := true;
1956 NET_EV_MAPEND: goodCmd := true;
1957 NET_EV_PLAYER_KICK: goodCmd := true;
1958 NET_EV_PLAYER_BAN: goodCmd := true;
1959 NET_EV_LMS_WARMUP: goodCmd := true;
1960 end;
1961 if not goodCmd then exit;
1962 end;
1963
1964 case EvType of
1965 NET_EV_MAPSTART:
1966 begin
1967 if (g_Res_received_map_start <> 0) then
1968 begin
1969 g_Res_received_map_start := -1;
1970 end
1971 else
1972 begin
1973 gGameOn := False;
1974 g_Game_ClearLoading();
1975 g_Game_StopAllSounds(True);
1976
1977 gSwitchGameMode := Byte(EvNum);
1978 gGameSettings.GameMode := gSwitchGameMode;
1979
1980 gWADHash := EvHash;
1981 if not g_Game_StartMap(false{asMegawad}, EvStr, True) then
1982 begin
1983 if not isWadPath(EvStr) then
1984 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_LOAD], [gGameSettings.WAD + ':\' + EvStr]))
1985 else
1986 g_FatalError(Format(_lc[I_GAME_ERROR_MAP_LOAD], [EvStr]));
1987 Exit;
1988 end;
1989
1990 MC_SEND_FullStateRequest;
1991 end;
1992 end;
1993
1994 NET_EV_MAPEND:
1995 begin
1996 gLMSRespawn := LMS_RESPAWN_NONE;
1997 gLMSRespawnTime := 0;
1998 if (g_Res_received_map_start <> 0) then
1999 begin
2000 g_Res_received_map_start := -1;
2001 end
2002 else
2003 begin
2004 gMissionFailed := EvNum <> 0;
2005 gExit := EXIT_ENDLEVELCUSTOM;
2006 end;
2007 end;
2008
2009 NET_EV_RCON:
2010 begin
2011 case EvNum of
2012 NET_RCON_NOAUTH:
2013 g_Console_Add(_lc[I_NET_RCON_NOAUTH], True);
2014 NET_RCON_PWGOOD:
2015 g_Console_Add(_lc[I_NET_RCON_PWD_VALID], True);
2016 NET_RCON_PWBAD:
2017 g_Console_Add(_lc[I_NET_RCON_PWD_INVALID], True);
2018 end;
2019 end;
2020
2021 NET_EV_CHANGE_TEAM:
2022 begin
2023 if NetDeafLevel < 2 then
2024 begin
2025 if EvNum = TEAM_RED then
2026 g_Console_Add(Format(_lc[I_PLAYER_CHTEAM_RED], [EvStr]), True);
2027 if EvNum = TEAM_BLUE then
2028 g_Console_Add(Format(_lc[I_PLAYER_CHTEAM_BLUE], [EvStr]), True);
2029 end;
2030 end;
2031
2032 NET_EV_PLAYER_KICK:
2033 begin
2034 g_Console_Add(Format(_lc[I_PLAYER_KICK], [EvStr]), True);
2035 if (g_Res_received_map_start <> 0) then g_Res_received_map_start := -1;
2036 end;
2037
2038 NET_EV_PLAYER_BAN:
2039 begin
2040 g_Console_Add(Format(_lc[I_PLAYER_BAN], [EvStr]), True);
2041 if (g_Res_received_map_start <> 0) then g_Res_received_map_start := -1;
2042 end;
2043
2044 NET_EV_LMS_WARMUP:
2045 begin
2046 if EvNum > 0 then
2047 begin
2048 gLMSRespawn := LMS_RESPAWN_WARMUP;
2049 gLMSRespawnTime := gTime + EvNum;
2050 g_Console_Add(Format(_lc[I_MSG_WARMUP_START], [EvNum div 1000]), True);
2051 end
2052 else if gPlayer1 = nil then
2053 begin
2054 g_Console_Add(_lc[I_PLAYER_SPECT4], True);
2055 end;
2056 end;
2057
2058 NET_EV_LMS_SURVIVOR:
2059 g_Console_Add('*** ' + _lc[I_MESSAGE_LMS_SURVIVOR] + ' ***', True);
2060
2061 NET_EV_BIGTEXT:
2062 if NetDeafLevel < 2 then g_Game_Message(AnsiUpperCase(EvStr), Word(EvNum));
2063
2064 NET_EV_SCORE:
2065 begin
2066 pl := g_Player_Get(EvNum and $FFFF);
2067 if pl = nil then
2068 pln := '?'
2069 else
2070 pln := pl.Name;
2071 cnt := (EvNum shr 16) and $FF;
2072 if Pos('w', EvStr) = 0 then
2073 begin
2074 // Default score
2075 if Pos('t', EvStr) = 0 then
2076 begin
2077 // Player +/- score
2078 if Pos('-', EvStr) = 0 then
2079 begin
2080 if Pos('e', EvStr) = 0 then
2081 i1 := I_PLAYER_SCORE_ADD_OWN
2082 else
2083 i1 := I_PLAYER_SCORE_ADD_ENEMY;
2084 end else
2085 begin
2086 if Pos('e', EvStr) = 0 then
2087 i1 := I_PLAYER_SCORE_SUB_OWN
2088 else
2089 i1 := I_PLAYER_SCORE_SUB_ENEMY;
2090 end;
2091 // Which team
2092 if Pos('r', EvStr) > 0 then
2093 i2 := I_PLAYER_SCORE_TO_RED
2094 else
2095 i2 := I_PLAYER_SCORE_TO_BLUE;
2096 g_Console_Add(Format(_lc[i1], [pln, cnt, _lc[i2]]), True);
2097 end else
2098 begin
2099 // Team +/- score
2100 if Pos('-', EvStr) = 0 then
2101 i1 := I_PLAYER_SCORE_ADD_TEAM
2102 else
2103 i1 := I_PLAYER_SCORE_SUB_TEAM;
2104 // Which team
2105 if Pos('r', EvStr) > 0 then
2106 i2 := I_PLAYER_SCORE_RED
2107 else
2108 i2 := I_PLAYER_SCORE_BLUE;
2109 g_Console_Add(Format(_lc[i1], [_lc[i2], cnt]), True);
2110 end;
2111 end else
2112 begin
2113 // Game Win
2114 if Pos('e', EvStr) = 0 then
2115 i1 := I_PLAYER_SCORE_WIN_OWN
2116 else
2117 i1 := I_PLAYER_SCORE_WIN_ENEMY;
2118 // Which team
2119 if Pos('r', EvStr) > 0 then
2120 i2 := I_PLAYER_SCORE_TO_RED
2121 else
2122 i2 := I_PLAYER_SCORE_TO_BLUE;
2123 g_Console_Add(Format(_lc[i1], [pln, _lc[i2]]), True);
2124 end;
2125 end;
2126
2127 NET_EV_SCORE_MSG:
2128 begin
2129 if EvNum = TEAM_RED then
2130 g_Game_Message(Format(_lc[I_MESSAGE_SCORE_ADD], [AnsiUpperCase(_lc[I_GAME_TEAM_RED])]), 108);
2131 if EvNum = TEAM_BLUE then
2132 g_Game_Message(Format(_lc[I_MESSAGE_SCORE_ADD], [AnsiUpperCase(_lc[I_GAME_TEAM_BLUE])]), 108);
2133 if EvNum = -TEAM_RED then
2134 g_Game_Message(Format(_lc[I_MESSAGE_SCORE_SUB], [AnsiUpperCase(_lc[I_GAME_TEAM_RED])]), 108);
2135 if EvNum = -TEAM_BLUE then
2136 g_Game_Message(Format(_lc[I_MESSAGE_SCORE_SUB], [AnsiUpperCase(_lc[I_GAME_TEAM_BLUE])]), 108);
2137 end;
2138
2139 NET_EV_LMS_START:
2140 begin
2141 {$IFDEF ENABLE_GIBS}
2142 g_Gibs_RemoveAll;
2143 {$ENDIF}
2144 {$IFDEF ENALBE_SHELLS}
2145 g_Shells_RemoveAll;
2146 {$ENDIF}
2147 {$IFDEF ENABLE_CORPSES}
2148 g_Corpses_RemoveAll;
2149 {$ENDIF}
2150 gLMSRespawn := LMS_RESPAWN_NONE;
2151 g_Game_Message(_lc[I_MESSAGE_LMS_START], 144);
2152 end;
2153
2154 NET_EV_LMS_WIN:
2155 g_Game_Message(Format(_lc[I_MESSAGE_LMS_WIN], [AnsiUpperCase(EvStr)]), 144);
2156
2157 NET_EV_TLMS_WIN:
2158 begin
2159 if EvNum = TEAM_RED then
2160 g_Game_Message(Format(_lc[I_MESSAGE_TLMS_WIN], [AnsiUpperCase(_lc[I_GAME_TEAM_RED])]), 144);
2161 if EvNum = TEAM_BLUE then
2162 g_Game_Message(Format(_lc[I_MESSAGE_TLMS_WIN], [AnsiUpperCase(_lc[I_GAME_TEAM_BLUE])]), 144);
2163 end;
2164
2165 NET_EV_LMS_LOSE:
2166 g_Game_Message(_lc[I_MESSAGE_LMS_LOSE], 144);
2167
2168 NET_EV_LMS_DRAW:
2169 g_Game_Message(_lc[I_GAME_WIN_DRAW], 144);
2170
2171 NET_EV_LMS_NOSPAWN:
2172 g_Console_Add(_lc[I_PLAYER_SPECT4], True);
2173
2174 NET_EV_KILLCOMBO:
2175 g_Game_Announce_KillCombo(EvNum);
2176
2177 NET_EV_PLAYER_TOUCH:
2178 begin
2179 pl := g_Player_Get(EvNum);
2180 if pl <> nil then
2181 pl.Touch();
2182 end;
2183
2184 NET_EV_SECRET:
2185 begin
2186 pl := g_Player_Get(EvNum);
2187 if pl <> nil then
2188 begin
2189 g_Console_Add(Format(_lc[I_PLAYER_SECRET], [pl.Name]), True);
2190 g_Sound_PlayEx('SOUND_GAME_SECRET');
2191 end;
2192 end;
2193
2194 NET_EV_INTER_READY:
2195 begin
2196 pl := g_Player_Get(EvNum);
2197 if pl <> nil then pl.FReady := (EvStr = 'Y');
2198 end;
2199 end;
2200 end;
2201
2202 procedure MC_RECV_FlagPos(var M: TMsg);
2203 var
2204 Fl: Byte;
2205 begin
2206 Fl := M.ReadByte();
2207 if Fl = FLAG_NONE then Exit;
2208 gFlags[Fl].Obj.X := M.ReadLongInt();
2209 gFlags[Fl].Obj.Y := M.ReadLongInt();
2210 gFlags[Fl].Obj.Vel.X := M.ReadLongInt();
2211 gFlags[Fl].Obj.Vel.Y := M.ReadLongInt();
2212 end;
2213
2214 procedure MC_RECV_FlagEvent(var M: TMsg);
2215 var
2216 PID: Word;
2217 Pl: TPlayer;
2218 EvType: Byte;
2219 Fl, a: Byte;
2220 Quiet: Boolean;
2221 s, ts: string;
2222 begin
2223 EvType := M.ReadByte();
2224 Fl := M.ReadByte();
2225
2226 if Fl = FLAG_NONE then Exit;
2227
2228 Quiet := (M.ReadByte() <> 0);
2229 PID := M.ReadWord();
2230
2231 gFlags[Fl].State := M.ReadByte();
2232 gFlags[Fl].CaptureTime := M.ReadLongWord();
2233 gFlags[Fl].Obj.X := M.ReadLongInt();
2234 gFlags[Fl].Obj.Y := M.ReadLongInt();
2235 gFlags[Fl].Obj.Vel.X := M.ReadLongInt();
2236 gFlags[Fl].Obj.Vel.Y := M.ReadLongInt();
2237 gFlags[Fl].Direction := TDirection(M.ReadByte());
2238
2239 Pl := g_Player_Get(PID);
2240 if (Pl = nil) and
2241 (EvType <> FLAG_STATE_NORMAL) and
2242 (EvType <> FLAG_STATE_DROPPED) and
2243 (EvType <> FLAG_STATE_RETURNED) then
2244 Exit;
2245
2246 case EvType of
2247 FLAG_STATE_NORMAL:
2248 begin
2249 if Quiet or (Pl = nil) then Exit;
2250
2251 if Fl = FLAG_RED then
2252 s := _lc[I_PLAYER_FLAG_RED]
2253 else
2254 s := _lc[I_PLAYER_FLAG_BLUE];
2255
2256 g_Game_Message(Format(_lc[I_MESSAGE_FLAG_RETURN], [AnsiUpperCase(s)]), 144);
2257
2258 if ((Pl = gPlayer1) or (Pl = gPlayer2)
2259 or ((gPlayer1 <> nil) and (gPlayer1.Team = Pl.Team))
2260 or ((gPlayer2 <> nil) and (gPlayer2.Team = Pl.Team))) then
2261 a := 0
2262 else
2263 a := 1;
2264
2265 if not sound_ret_flag[a].IsPlaying() then
2266 sound_ret_flag[a].Play();
2267 end;
2268
2269 FLAG_STATE_CAPTURED:
2270 begin
2271 if (Pl <> nil) then Pl.SetFlag(Fl);
2272
2273 if Quiet then Exit;
2274
2275 if Fl = FLAG_RED then
2276 s := _lc[I_PLAYER_FLAG_RED]
2277 else
2278 s := _lc[I_PLAYER_FLAG_BLUE];
2279
2280 g_Console_Add(Format(_lc[I_PLAYER_FLAG_GET], [Pl.Name, s]), True);
2281 g_Game_Message(Format(_lc[I_MESSAGE_FLAG_GET], [AnsiUpperCase(s)]), 144);
2282
2283 if ((Pl = gPlayer1) or (Pl = gPlayer2)
2284 or ((gPlayer1 <> nil) and (gPlayer1.Team = Pl.Team))
2285 or ((gPlayer2 <> nil) and (gPlayer2.Team = Pl.Team))) then
2286 a := 0
2287 else
2288 a := 1;
2289
2290 if not sound_get_flag[a].IsPlaying() then
2291 sound_get_flag[a].Play();
2292 end;
2293
2294 FLAG_STATE_DROPPED:
2295 begin
2296 if (Pl <> nil) then Pl.SetFlag(FLAG_NONE);
2297
2298 if Quiet or (Pl = nil) then Exit;
2299
2300 if Fl = FLAG_RED then
2301 s := _lc[I_PLAYER_FLAG_RED]
2302 else
2303 s := _lc[I_PLAYER_FLAG_BLUE];
2304
2305 g_Console_Add(Format(_lc[I_PLAYER_FLAG_DROP], [Pl.Name, s]), True);
2306 g_Game_Message(Format(_lc[I_MESSAGE_FLAG_DROP], [AnsiUpperCase(s)]), 144);
2307
2308 if ((Pl = gPlayer1) or (Pl = gPlayer2)
2309 or ((gPlayer1 <> nil) and (gPlayer1.Team = Pl.Team))
2310 or ((gPlayer2 <> nil) and (gPlayer2.Team = Pl.Team))) then
2311 a := 0
2312 else
2313 a := 1;
2314
2315 if not sound_lost_flag[a].IsPlaying() then
2316 sound_lost_flag[a].Play();
2317 end;
2318
2319 FLAG_STATE_SCORED:
2320 begin
2321 g_Map_ResetFlag(FLAG_RED);
2322 g_Map_ResetFlag(FLAG_BLUE);
2323 if Quiet or (Pl = nil) then Exit;
2324 Pl.SetFlag(FLAG_NONE);
2325
2326 if Fl = FLAG_RED then
2327 s := _lc[I_PLAYER_FLAG_RED]
2328 else
2329 s := _lc[I_PLAYER_FLAG_BLUE];
2330
2331 ts := Format('%.4d', [gFlags[Fl].CaptureTime]);
2332 Insert('.', ts, Length(ts) + 1 - 3);
2333 g_Console_Add(Format(_lc[I_PLAYER_FLAG_CAPTURE], [Pl.Name, s, ts]), True);
2334 g_Game_Message(Format(_lc[I_MESSAGE_FLAG_CAPTURE], [AnsiUpperCase(s)]), 144);
2335
2336 if ((Pl = gPlayer1) or (Pl = gPlayer2)
2337 or ((gPlayer1 <> nil) and (gPlayer1.Team = Pl.Team))
2338 or ((gPlayer2 <> nil) and (gPlayer2.Team = Pl.Team))) then
2339 a := 0
2340 else
2341 a := 1;
2342
2343 if not sound_cap_flag[a].IsPlaying() then
2344 sound_cap_flag[a].Play();
2345 end;
2346
2347 FLAG_STATE_RETURNED:
2348 begin
2349 g_Map_ResetFlag(Fl);
2350 if Quiet then Exit;
2351
2352 if Fl = FLAG_RED then
2353 s := _lc[I_PLAYER_FLAG_RED]
2354 else
2355 s := _lc[I_PLAYER_FLAG_BLUE];
2356
2357 g_Game_Message(Format(_lc[I_MESSAGE_FLAG_RETURN], [AnsiUpperCase(s)]), 144);
2358
2359 if ((Pl = gPlayer1) or (Pl = gPlayer2)
2360 or ((gPlayer1 <> nil) and (gPlayer1.Team = Pl.Team))
2361 or ((gPlayer2 <> nil) and (gPlayer2.Team = Pl.Team))) then
2362 a := 0
2363 else
2364 a := 1;
2365
2366 if not sound_ret_flag[a].IsPlaying() then
2367 sound_ret_flag[a].Play();
2368 end;
2369 end;
2370 end;
2371
2372 procedure MC_RECV_GameSettings(var M: TMsg);
2373 begin
2374 gGameSettings.GameMode := M.ReadByte();
2375 gGameSettings.ScoreLimit := M.ReadWord();
2376 gGameSettings.TimeLimit := M.ReadWord();
2377 gGameSettings.MaxLives := M.ReadByte();
2378 gGameSettings.Options := M.ReadLongWord();
2379 end;
2380
2381 // PLAYER
2382
2383 function MC_RECV_PlayerCreate(var M: TMsg): Word;
2384 var
2385 PID, DID: Word;
2386 PName, Model: string;
2387 Color: TRGB;
2388 T: Byte;
2389 Pl: TPlayer;
2390 begin
2391 PID := M.ReadWord();
2392 Pl := g_Player_Get(PID);
2393
2394 PName := M.ReadString();
2395 Model := M.ReadString();
2396 Color.R := M.ReadByte();
2397 Color.G := M.ReadByte();
2398 Color.B := M.ReadByte();
2399 T := M.ReadByte();
2400
2401 Result := 0;
2402 if (PID <> NetPlrUID1) and (PID <> NetPlrUID2) then
2403 begin
2404 if (Pl <> nil) then Exit;
2405 if (g_Force_Model_Get() <> 0) then
2406 Model := g_Forced_Model_GetName();
2407 DID := g_Player_Create(Model, Color, T, False);
2408 with g_Player_Get(DID) do
2409 begin
2410 UID := PID;
2411 Name := PName;
2412 Reset(True);
2413 end;
2414 end
2415 else
2416 begin
2417 if (PID = NetPlrUID1) and (gPlayer1 <> nil) then begin
2418 gPlayer1.UID := PID;
2419 gPlayer1.Model.SetColor(Color.R, Color.G, Color.B);
2420 gPlayer1.ChangeTeam(T);
2421 end;
2422 if (PID = NetPlrUID2) and (gPlayer2 <> nil) then begin
2423 gPlayer2.UID := PID;
2424 gPlayer2.Model.SetColor(Color.R, Color.G, Color.B);
2425 gPlayer2.ChangeTeam(T);
2426 end;
2427 end;
2428
2429 if NetDeafLevel < 3 then
2430 g_Console_Add(Format(_lc[I_PLAYER_JOIN], [PName]), True);
2431 e_WriteLog('NET: Player ' + PName + ' [' + IntToStr(PID) + '] added.', TMsgType.Notify);
2432 Result := PID;
2433 end;
2434
2435 function MC_RECV_PlayerPos(var M: TMsg): Word;
2436 var
2437 GT: LongWord;
2438 PID: Word;
2439 kByte: Word;
2440 Pl: TPlayer;
2441 Dir: Byte;
2442 TmpX, TmpY: Integer;
2443 begin
2444 Result := 0;
2445
2446 GT := M.ReadLongWord();
2447 if GT < gTime - NET_MAX_DIFFTIME then
2448 begin
2449 gTime := GT;
2450 Exit;
2451 end;
2452 gTime := GT;
2453
2454 PID := M.ReadWord();
2455 Pl := g_Player_Get(PID);
2456
2457 if Pl = nil then Exit;
2458
2459 Result := PID;
2460
2461 with Pl do
2462 begin
2463 FPing := M.ReadWord();
2464 FLoss := M.ReadByte();
2465 kByte := M.ReadWord();
2466 Dir := M.ReadByte();
2467
2468 TmpX := M.ReadLongInt();
2469 TmpY := M.ReadLongInt();
2470
2471 ReleaseKeys;
2472
2473 if LongBool(kByte and NET_KEY_CHAT) then
2474 PressKey(KEY_CHAT, 10000)
2475 else
2476 begin
2477 if LongBool(kByte and NET_KEY_LEFT) then PressKey(KEY_LEFT, 10000);
2478 if LongBool(kByte and NET_KEY_RIGHT) then PressKey(KEY_RIGHT, 10000);
2479 if LongBool(kByte and NET_KEY_UP) then PressKey(KEY_UP, 10000);
2480 if LongBool(kByte and NET_KEY_DOWN) then PressKey(KEY_DOWN, 10000);
2481 if LongBool(kByte and NET_KEY_JUMP) then PressKey(KEY_JUMP, 10000);
2482 end;
2483
2484 JustTeleported := LongBool(kByte and NET_KEY_FORCEDIR);
2485
2486 if ((Pl <> gPlayer1) and (Pl <> gPlayer2)) or JustTeleported then
2487 SetDirection(TDirection(Dir));
2488
2489 GameVelX := M.ReadLongInt();
2490 GameVelY := M.ReadLongInt();
2491 GameAccelX := M.ReadLongInt();
2492 GameAccelY := M.ReadLongInt();
2493 SetLerp(TmpX, TmpY);
2494 if NetForcePlayerUpdate then Update();
2495 end;
2496 end;
2497
2498 function MC_RECV_PlayerStats(var M: TMsg): Word;
2499 var
2500 PID: Word;
2501 Pl: TPlayer;
2502 I, OldFire: Integer;
2503 OldJet, Flam: Boolean;
2504 NewTeam: Byte;
2505 begin
2506 PID := M.ReadWord();
2507 Pl := g_Player_Get(PID);
2508 Result := 0;
2509 if Pl = nil then
2510 Exit;
2511
2512 with Pl do
2513 begin
2514 alive := (M.ReadByte() <> 0);
2515 GodMode := (M.ReadByte() <> 0);
2516 Health := M.ReadLongInt();
2517 Armor := M.ReadLongInt();
2518 Air := M.ReadLongInt();
2519 JetFuel := M.ReadLongInt();
2520 Lives := M.ReadByte();
2521 NewTeam := M.ReadByte();
2522
2523 for I := WP_FIRST to WP_LAST do
2524 FWeapon[I] := (M.ReadByte() <> 0);
2525
2526 for I := A_BULLETS to A_HIGH do
2527 FAmmo[I] := M.ReadWord();
2528
2529 for I := A_BULLETS to A_HIGH do
2530 FMaxAmmo[I] := M.ReadWord();
2531
2532 for I := MR_SUIT to MR_MAX do
2533 FMegaRulez[I] := M.ReadLongWord();
2534
2535 FRulez := [];
2536 if (M.ReadByte() <> 0) then
2537 FRulez := FRulez + [R_ITEM_BACKPACK];
2538 if (M.ReadByte() <> 0) then
2539 FRulez := FRulez + [R_KEY_RED];
2540 if (M.ReadByte() <> 0) then
2541 FRulez := FRulez + [R_KEY_GREEN];
2542 if (M.ReadByte() <> 0) then
2543 FRulez := FRulez + [R_KEY_BLUE];
2544 if (M.ReadByte() <> 0) then
2545 FRulez := FRulez + [R_BERSERK];
2546
2547 Frags := M.ReadLongInt();
2548 Death := M.ReadLongInt();
2549
2550 SetWeapon(M.ReadByte());
2551
2552 FSpectator := M.ReadByte() <> 0;
2553 if FSpectator then
2554 begin
2555 if UID = NetPlrUID1 then
2556 begin
2557 gSpectLatchPID1 := UID;
2558 gPlayer1 := nil;
2559 end;
2560 if UID = NetPlrUID2 then
2561 begin
2562 gSpectLatchPID2 := UID;
2563 gPlayer2 := nil;
2564 end;
2565 end
2566 else
2567 begin
2568 if (gPlayer1 = nil) and (gSpectLatchPID1 > 0) and (UID = gSpectLatchPID1) then
2569 begin
2570 gPlayer1 := Pl;
2571 gSpectLatchPID1 := 0;
2572 end;
2573 if (gPlayer2 = nil) and (gSpectLatchPID2 > 0) and (UID = gSpectLatchPID2) then
2574 begin
2575 gPlayer2 := Pl;
2576 gSpectLatchPID2 := 0;
2577 end;
2578 end;
2579 FGhost := M.ReadByte() <> 0;
2580 FPhysics := M.ReadByte() <> 0;
2581 FNoRespawn := M.ReadByte() <> 0;
2582 OldJet := FJetpack;
2583 FJetpack := M.ReadByte() <> 0;
2584 OldFire := FFireTime;
2585 FFireTime := M.ReadLongInt();
2586 if (OldFire <= 0) and (FFireTime > 0) then
2587 g_Sound_PlayExAt('SOUND_IGNITE', Obj.X, Obj.Y);
2588 Flam := M.ReadByte() <> 0;
2589 FSpawnInvul := M.ReadLongInt();
2590 if OldJet and not FJetpack then
2591 JetpackOff
2592 else if not OldJet and FJetpack then
2593 JetpackOn;
2594 if FFlaming and not Flam then
2595 FlamerOff;
2596 if Team <> NewTeam then
2597 Pl.ChangeTeam(NewTeam);
2598 end;
2599
2600 Result := PID;
2601 end;
2602
2603 function MC_RECV_PlayerDamage(var M: TMsg): Word;
2604 var
2605 PID: Word;
2606 Pl: TPlayer;
2607 Kind: Byte;
2608 Attacker, Value: Word;
2609 VX, VY: Integer;
2610 begin
2611 Result := 0;
2612 if not gGameOn then Exit;
2613 PID := M.ReadWord();
2614 Pl := g_Player_Get(PID);
2615 if Pl = nil then Exit;
2616
2617 Kind := M.ReadByte();
2618 Attacker := M.ReadWord();
2619 Value := M.ReadWord();
2620 VX := M.ReadWord();
2621 VY := M.ReadWord();
2622
2623 with Pl do
2624 Damage(Value, Attacker, VX, VY, Kind);
2625
2626 Result := PID;
2627 end;
2628
2629 function MC_RECV_PlayerDeath(var M: TMsg): Word;
2630 var
2631 PID: Word;
2632 Pl: TPlayer;
2633 KillType, DeathType: Byte;
2634 Attacker: Word;
2635 begin
2636 Result := 0;
2637 if not gGameOn then Exit;
2638 PID := M.ReadWord();
2639 Pl := g_Player_Get(PID);
2640 if Pl = nil then Exit;
2641
2642 KillType := M.ReadByte();
2643 DeathType := M.ReadByte();
2644 Attacker := M.ReadWord();
2645
2646 with Pl do
2647 begin
2648 Kill(KillType, Attacker, DeathType);
2649 SoftReset;
2650 end;
2651 end;
2652
2653 function MC_RECV_PlayerDelete(var M: TMsg): Word;
2654 var
2655 PID: Word;
2656 Pl: TPlayer;
2657 begin
2658 PID := M.ReadWord();
2659 Pl := g_Player_Get(PID);
2660 Result := 0;
2661 if Pl = nil then Exit;
2662
2663 if NetDeafLevel < 3 then
2664 g_Console_Add(Format(_lc[I_PLAYER_LEAVE], [Pl.Name]), True);
2665 e_WriteLog('NET: Player ' + Pl.Name + ' [' + IntToStr(PID) + '] removed.', TMsgType.Notify);
2666
2667 g_Player_Remove(PID);
2668
2669 Result := PID;
2670 end;
2671
2672 function MC_RECV_PlayerFire(var M: TMsg): Word;
2673 var
2674 PID: Word;
2675 Weap: Byte;
2676 Pl: TPlayer;
2677 X, Y, AX, AY: Integer;
2678 SHID: Integer;
2679 begin
2680 Result := 0;
2681 if not gGameOn then Exit;
2682 PID := M.ReadWord();
2683 Pl := g_Player_Get(PID);
2684 if Pl = nil then Exit;
2685
2686 Weap := M.ReadByte();
2687 X := M.ReadLongInt();
2688 Y := M.ReadLongInt();
2689 AX := M.ReadLongInt();
2690 AY := M.ReadLongInt();
2691 SHID := M.ReadLongInt();
2692
2693 with Pl do
2694 if alive then NetFire(Weap, X, Y, AX, AY, SHID);
2695 end;
2696
2697 procedure MC_RECV_PlayerSettings(var M: TMsg);
2698 var
2699 TmpName: string;
2700 TmpModel: string;
2701 CheckModel: string;
2702 TmpColor: TRGB;
2703 TmpTeam: Byte;
2704 Pl: TPlayer;
2705 PID: Word;
2706 begin
2707 PID := M.ReadWord();
2708 Pl := g_Player_Get(PID);
2709 if Pl = nil then Exit;
2710
2711 TmpName := M.ReadString();
2712 TmpModel := M.ReadString();
2713 TmpColor.R := M.ReadByte();
2714 TmpColor.G := M.ReadByte();
2715 TmpColor.B := M.ReadByte();
2716 TmpTeam := M.ReadByte();
2717
2718 if (gGameSettings.GameMode in [GM_TDM, GM_CTF]) and (Pl.Team <> TmpTeam) then
2719 begin
2720 Pl.ChangeTeam(TmpTeam);
2721 if gPlayer1 = Pl then
2722 gPlayer1Settings.Team := TmpTeam;
2723 if gPlayer2 = Pl then
2724 gPlayer2Settings.Team := TmpTeam;
2725 end else
2726 Pl.SetColor(TmpColor);
2727
2728 if Pl.Name <> TmpName then
2729 begin
2730 if NetDeafLevel < 3 then
2731 g_Console_Add(Format(_lc[I_PLAYER_NAME], [Pl.Name, TmpName]), True);
2732 Pl.Name := TmpName;
2733 end;
2734
2735 if (g_Force_Model_Get() <> 0) then
2736 TmpModel := g_Forced_Model_GetName();
2737 if TmpModel <> Pl.Model.GetName() then
2738 Pl.SetModel(TmpModel);
2739 end;
2740
2741 // ITEM
2742
2743 procedure MC_RECV_ItemSpawn(var M: TMsg);
2744 var
2745 ID: Word;
2746 X, Y, VX, VY: Integer;
2747 T: Byte;
2748 Quiet, Fall{, Resp}: Boolean;
2749 it: PItem;
2750 begin
2751 if not gGameOn then Exit;
2752 ID := M.ReadWord();
2753 Quiet := M.ReadByte() <> 0;
2754 T := M.ReadByte();
2755 Fall := M.ReadByte() <> 0;
2756 {Resp :=} M.ReadByte();
2757 X := M.ReadLongInt();
2758 Y := M.ReadLongInt();
2759 VX := M.ReadLongInt();
2760 VY := M.ReadLongInt();
2761
2762 g_Items_Create(X, Y, T and $7F, Fall, False, False, ID);
2763 if ((T and $80) <> 0) then g_Items_SetDrop(ID);
2764
2765 it := g_Items_ByIdx(ID);
2766 it.Obj.Vel.X := VX;
2767 it.Obj.Vel.Y := VY;
2768
2769 if not Quiet then
2770 begin
2771 g_Sound_PlayExAt('SOUND_ITEM_RESPAWNITEM', X, Y);
2772 {$IFDEF ENABLE_GFX}
2773 g_GFX_QueueEffect(R_GFX_ITEM_RESPAWN, X+(it.Obj.Rect.Width div 2)-16, Y+(it.Obj.Rect.Height div 2)-16);
2774 {$ENDIF}
2775 end;
2776 end;
2777
2778 procedure MC_RECV_ItemDestroy(var M: TMsg);
2779 var
2780 ID: Word;
2781 Quiet: Boolean;
2782 begin
2783 if not gGameOn then Exit;
2784 ID := M.ReadWord();
2785 Quiet := M.ReadByte() <> 0;
2786
2787 if not g_Items_ValidId(ID) then exit;
2788
2789 if not Quiet then g_Items_EmitPickupSound(ID);
2790
2791 g_Items_Remove(ID);
2792 end;
2793
2794 procedure MC_RECV_ItemPos(var M: TMsg);
2795 var
2796 ID: Word;
2797 X, Y, VX, VY: Integer;
2798 it: PItem;
2799 begin
2800 if not gGameOn then Exit;
2801
2802 ID := M.ReadWord();
2803 X := M.ReadLongInt();
2804 Y := M.ReadLongInt();
2805 VX := M.ReadLongInt();
2806 VY := M.ReadLongInt();
2807
2808 if g_Items_ValidId(ID) then
2809 begin
2810 it := g_Items_ByIdx(ID);
2811 it.Obj.X := X;
2812 it.Obj.Y := Y;
2813 it.Obj.Vel.X := VX;
2814 it.Obj.Vel.Y := VY;
2815 it.positionChanged();
2816 end;
2817 end;
2818
2819 // PANEL
2820
2821 procedure MC_RECV_PanelTexture(var M: TMsg);
2822 var TP: TPanel; PGUID, Tex: Integer; AnimTime: LongWord; Loop: Byte;
2823 begin
2824 if not gGameOn then Exit;
2825
2826 PGUID := Integer(M.ReadLongWord());
2827 Tex := M.ReadLongInt();
2828 AnimTime := M.ReadLongWord();
2829 Loop := M.ReadByte();
2830
2831 TP := g_Map_PanelByGUID(PGUID);
2832 if (TP <> nil) then
2833 begin
2834 // switch texture
2835 TP.SetTexture(Tex, Loop);
2836 TP.SetFrame(AnimTime);
2837 end;
2838 end;
2839
2840 procedure MC_RECV_PanelState(var M: TMsg);
2841 var
2842 PGUID: Integer;
2843 E: Boolean;
2844 Lift: Byte;
2845 X, Y, W, H: Integer;
2846 TP: TPanel;
2847 speedX, speedY, startX, startY, endX, endY: Integer;
2848 sizeSpX, sizeSpY, sizeEX, sizeEY: Integer;
2849 mpflags: Byte;
2850 begin
2851 if not gGameOn then Exit;
2852
2853 PGUID := Integer(M.ReadLongWord());
2854 E := (M.ReadByte() <> 0);
2855 Lift := M.ReadByte();
2856 X := M.ReadLongInt();
2857 Y := M.ReadLongInt();
2858 W := M.ReadWord();
2859 H := M.ReadWord();
2860 // mplats
2861 speedX := M.ReadLongInt();
2862 speedY := M.ReadLongInt();
2863 startX := M.ReadLongInt();
2864 startY := M.ReadLongInt();
2865 endX := M.ReadLongInt();
2866 endY := M.ReadLongInt();
2867 sizeSpX := M.ReadLongInt();
2868 sizeSpY := M.ReadLongInt();
2869 sizeEX := M.ReadLongInt();
2870 sizeEY := M.ReadLongInt();
2871 mpflags := M.ReadByte(); // bit0: TP.movingActive; bit1: TP.moveOnce
2872
2873 TP := g_Map_PanelByGUID(PGUID);
2874 if (TP = nil) then exit;
2875
2876 // update lifts state
2877 if TP.isGLift then g_Map_SetLiftGUID(PGUID, Lift);
2878
2879 // update enabled/disabled state for all panels
2880 if E then g_Map_EnableWallGUID(PGUID) else g_Map_DisableWallGUID(PGUID);
2881
2882 // update panel position, as it can be moved (mplat)
2883 TP.X := X;
2884 TP.Y := Y;
2885 TP.Width := W;
2886 TP.Height := H;
2887 // update mplat state
2888 TP.movingSpeedX := speedX;
2889 TP.movingSpeedY := speedY;
2890 TP.movingStartX := startX;
2891 TP.movingStartY := startY;
2892 TP.movingEndX := endX;
2893 TP.movingEndY := endY;
2894 TP.sizeSpeedX := sizeSpX;
2895 TP.sizeSpeedY := sizeSpY;
2896 TP.sizeEndX := sizeEX;
2897 TP.sizeEndY := sizeEY;
2898 TP.movingActive := ((mpflags and 1) <> 0);
2899 TP.moveOnce := ((mpflags and 2) <> 0);
2900 // notify panel of it's position/size change, so it can fix other internal structures
2901 TP.positionChanged();
2902 end;
2903
2904 // TRIGGERS
2905
2906 procedure MC_RECV_TriggerSound(var M: TMsg);
2907 var
2908 SPlaying: Boolean;
2909 SPos, SID: LongWord;
2910 SCount: LongInt;
2911 I: Integer;
2912 begin
2913 if not gGameOn then Exit;
2914 if gTriggers = nil then Exit;
2915
2916 SID := M.ReadLongWord();
2917 SPlaying := M.ReadByte() <> 0;
2918 SPos := M.ReadLongWord();
2919 SCount := M.ReadLongInt();
2920
2921 for I := Low(gTriggers) to High(gTriggers) do
2922 if gTriggers[I].TriggerType = TRIGGER_SOUND then
2923 if gTriggers[I].ClientID = SID then
2924 with gTriggers[I] do
2925 begin
2926 if Sound <> nil then
2927 begin
2928 if SPlaying then
2929 begin
2930 if tgcLocal then
2931 Sound.PlayVolumeAt(X+(Width div 2), Y+(Height div 2), tgcVolume/255.0)
2932 else
2933 Sound.PlayPanVolume((tgcPan-127.0)/128.0, tgcVolume/255.0);
2934 Sound.SetPosition(SPos);
2935 end
2936 else
2937 if Sound.IsPlaying then Sound.Stop;
2938 end;
2939
2940 SoundPlayCount := SCount;
2941 end;
2942 end;
2943
2944 procedure MC_RECV_TriggerMusic(var M: TMsg);
2945 var
2946 MName: string;
2947 MPlaying: Boolean;
2948 MPos: LongWord;
2949 MPaused: Boolean;
2950 begin
2951 if not gGameOn then Exit;
2952
2953 MName := M.ReadString();
2954 MPlaying := M.ReadByte() <> 0;
2955 MPos := M.ReadLongWord();
2956 MPaused := M.ReadByte() <> 0;
2957 MPos := MPos+1; //k8: stfu, fpc!
2958
2959 if MPlaying then
2960 begin
2961 gMusic.SetByName(MName);
2962 gMusic.Play(True);
2963 // gMusic.SetPosition(MPos);
2964 gMusic.SpecPause := MPaused;
2965 end
2966 else
2967 if gMusic.IsPlaying then gMusic.Stop;
2968 end;
2969
2970 // MONSTERS
2971
2972 procedure MC_RECV_MonsterSpawn(var M: TMsg);
2973 var
2974 ID: Word;
2975 MType, MState, MDir, MAnim, MBehav: Byte;
2976 X, Y, VX, VY, MTargTime, MHealth, MAmmo, MSleep: Integer;
2977 MTarg: Word;
2978 Mon: TMonster;
2979 begin
2980 ID := M.ReadWord();
2981 Mon := g_Monsters_ByUID(ID);
2982 if Mon <> nil then
2983 Exit;
2984
2985 MType := M.ReadByte();
2986 MState := M.ReadByte();
2987 MAnim := M.ReadByte();
2988 MTarg := M.ReadWord();
2989 MTargTime := M.ReadLongInt();
2990 MBehav := M.ReadByte();
2991 MSleep := M.ReadLongInt();
2992 MHealth := M.ReadLongInt();
2993 MAmmo := M.ReadLongInt();
2994
2995 X := M.ReadLongInt();
2996 Y := M.ReadLongInt();
2997 VX := M.ReadLongInt();
2998 VY := M.ReadLongInt();
2999 MDir := M.ReadByte();
3000
3001 g_Monsters_Create(MType, X, Y, TDirection(MDir), False, ID);
3002 Mon := g_Monsters_ByUID(ID);
3003 if Mon = nil then
3004 Exit;
3005
3006 with Mon do
3007 begin
3008
3009 MonsterAnim := MAnim;
3010 MonsterTargetUID := MTarg;
3011 MonsterTargetTime := MTargTime;
3012 MonsterBehaviour := MBehav;
3013 MonsterSleep := MSleep;
3014 MonsterAmmo := MAmmo;
3015 SetHealth(MHealth);
3016
3017 SetState(MState);
3018
3019 setPosition(X, Y); // this will call positionChanged();
3020 GameVelX := VX;
3021 GameVelY := VY;
3022 end;
3023 end;
3024
3025 procedure MC_RECV_MonsterPos(var M: TMsg);
3026 var
3027 Mon: TMonster;
3028 ID: Word;
3029 X, Y: Integer;
3030 begin
3031 ID := M.ReadWord();
3032 Mon := g_Monsters_ByUID(ID);
3033 if Mon = nil then
3034 Exit;
3035
3036 with Mon do
3037 begin
3038 X := M.ReadLongInt();
3039 Y := M.ReadLongInt();
3040 Mon.setPosition(X, Y); // this will call `positionChanged()`
3041 GameVelX := M.ReadLongInt();
3042 GameVelY := M.ReadLongInt();
3043 GameDirection := TDirection(M.ReadByte());
3044 end;
3045 end;
3046
3047 procedure MC_RECV_MonsterState(var M: TMsg);
3048 var
3049 ID, OldFire: Integer;
3050 MState, MFAnm: Byte;
3051 Mon: TMonster;
3052 AnimRevert: Boolean;
3053 begin
3054 ID := M.ReadWord();
3055 Mon := g_Monsters_ByUID(ID);
3056 if Mon = nil then Exit;
3057
3058 MState := M.ReadByte();
3059 MFAnm := M.ReadByte();
3060
3061 with Mon do
3062 begin
3063 MonsterTargetUID := M.ReadWord();
3064 MonsterTargetTime := M.ReadLongInt();
3065 MonsterSleep := M.ReadLongInt();
3066 MonsterHealth := M.ReadLongInt();
3067 MonsterAmmo := M.ReadLongInt();
3068 MonsterPain := M.ReadLongInt();
3069 AnimRevert := M.ReadByte() <> 0;
3070 OldFire := FFireTime;
3071 FFireTime := M.ReadLongInt();
3072 if (OldFire <= 0) and (FFireTime > 0) then
3073 g_Sound_PlayExAt('SOUND_IGNITE', Obj.X, Obj.Y);
3074 RevertAnim(AnimRevert);
3075
3076 if MonsterState <> MState then
3077 begin
3078 if (MState = MONSTATE_GO) and (MonsterState = MONSTATE_SLEEP) then WakeUpSound();
3079 if (MState = MONSTATE_DIE) then DieSound();
3080 if (MState = MONSTATE_PAIN) then MakeBloodSimple(Min(200, MonsterPain));
3081 if (MState = MONSTATE_ATTACK) then kick(nil);
3082 if (MState = MONSTATE_DEAD) then SetDeadAnim();
3083
3084 SetState(MState, MFAnm);
3085 end;
3086 end;
3087 end;
3088
3089 procedure MC_RECV_MonsterShot(var M: TMsg);
3090 var
3091 ID: Integer;
3092 Mon: TMonster;
3093 X, Y, VX, VY: Integer;
3094 begin
3095 ID := M.ReadWord();
3096
3097 Mon := g_Monsters_ByUID(ID);
3098 if Mon = nil then Exit;
3099
3100 X := M.ReadLongInt();
3101 Y := M.ReadLongInt();
3102 VX := M.ReadLongInt();
3103 VY := M.ReadLongInt();
3104
3105 Mon.ClientAttack(X, Y, VX, VY);
3106 end;
3107
3108 procedure MC_RECV_MonsterDelete(var M: TMsg);
3109 var
3110 ID: Integer;
3111 Mon: TMonster;
3112 begin
3113 ID := M.ReadWord();
3114 Mon := g_Monsters_ByUID(ID);
3115 if Mon = nil then Exit;
3116 Mon.SetState(5);
3117 Mon.MonsterRemoved := True;
3118 end;
3119
3120 procedure MC_RECV_TimeSync(var M: TMsg);
3121 var
3122 Time: LongWord;
3123 begin
3124 Time := M.ReadLongWord();
3125
3126 if gState = STATE_INTERCUSTOM then
3127 gServInterTime := Min(Time, 255);
3128 end;
3129
3130 procedure MC_RECV_VoteEvent(var M: TMsg);
3131 var
3132 EvID: Byte;
3133 Str1, Str2: string;
3134 Int1, Int2: SmallInt;
3135 begin
3136 EvID := M.ReadByte();
3137 Int1 := M.ReadSmallInt();
3138 Int2 := M.ReadSmallInt();
3139 Str1 := M.ReadString();
3140 Str2 := M.ReadString();
3141
3142 if NetDeafLevel < 2 then
3143 case EvID of
3144 NET_VE_STARTED:
3145 g_Console_Add(Format(_lc[I_MESSAGE_VOTE_STARTED], [Str1, Str2, Int1]), True);
3146 NET_VE_PASSED:
3147 g_Console_Add(Format(_lc[I_MESSAGE_VOTE_PASSED], [Str1]), True);
3148 NET_VE_FAILED:
3149 g_Console_Add(_lc[I_MESSAGE_VOTE_FAILED], True);
3150 NET_VE_VOTE:
3151 g_Console_Add(Format(_lc[I_MESSAGE_VOTE_VOTE], [Str1, Int1, Int2]), True);
3152 NET_VE_INPROGRESS:
3153 g_Console_Add(Format(_lc[I_MESSAGE_VOTE_INPROGRESS], [Str1]), True);
3154 end;
3155 end;
3156
3157 // CLIENT SEND
3158
3159 procedure MC_SEND_Info(Password: string);
3160 var i: Integer;
3161 begin
3162 NetOut.Clear();
3163
3164 NetOut.Write(Byte(NET_MSG_INFO));
3165 NetOut.Write(GAME_VERSION);
3166 NetOut.Write(Password);
3167 NetOut.Write(gPlayer1Settings.Name);
3168 NetOut.Write(gPlayer1Settings.Model);
3169 NetOut.Write(gPlayer1Settings.Color.R);
3170 NetOut.Write(gPlayer1Settings.Color.G);
3171 NetOut.Write(gPlayer1Settings.Color.B);
3172 NetOut.Write(gPlayer1Settings.Team);
3173 NetOut.Write(gPlayer1Settings.WeaponSwitch);
3174 for i := WP_FIRST to WP_LAST + 1 do
3175 NetOut.Write(gPlayer1Settings.WeaponPreferences[i]);
3176 NetOut.Write(gPlayer1Settings.SwitchToEmpty);
3177 NetOut.Write(gPlayer1Settings.SkipFist);
3178
3179 g_Net_Client_Send(True, NET_CHAN_SERVICE);
3180 end;
3181
3182 procedure MC_SEND_Chat(Txt: string; Mode: Byte);
3183 begin
3184 NetOut.Write(Byte(NET_MSG_CHAT));
3185 NetOut.Write(Txt);
3186 NetOut.Write(Mode);
3187
3188 g_Net_Client_Send(True, NET_CHAN_CHAT);
3189 end;
3190
3191 procedure MC_SEND_PlayerPos();
3192 var
3193 kByte: Word;
3194 Predict: Boolean;
3195 strafeDir: Byte;
3196 WeaponAct: Byte = 0;
3197 WeaponSelect: Word = 0;
3198 i: Integer;
3199 begin
3200 if not gGameOn then Exit;
3201 if gPlayers = nil then Exit;
3202 if gPlayer1 = nil then Exit;
3203
3204 kByte := 0;
3205 Predict := NetPredictSelf; // and (not NetGotKeys);
3206
3207 {$IFDEF DISABLE_MENU}
3208 if (not gConsoleShow) and (not gChatShow) then
3209 {$ELSE}
3210 if (not gConsoleShow) and (not gChatShow) and (g_ActiveWindow = nil) then
3211 {$ENDIF}
3212 begin
3213 strafeDir := P1MoveButton shr 4;
3214 P1MoveButton := P1MoveButton and $0F;
3215
3216 if gPlayerAction[0, ACTION_MOVELEFT] and (not gPlayerAction[0, ACTION_MOVERIGHT]) then
3217 P1MoveButton := 1
3218 else if (not gPlayerAction[0, ACTION_MOVELEFT]) and gPlayerAction[0, ACTION_MOVERIGHT] then
3219 P1MoveButton := 2
3220 else if (not gPlayerAction[0, ACTION_MOVELEFT]) and (not gPlayerAction[0, ACTION_MOVERIGHT]) then
3221 P1MoveButton := 0;
3222
3223 // strafing
3224 if gPlayerAction[0, ACTION_STRAFE] then
3225 begin
3226 // new strafe mechanics
3227 if (strafeDir = 0) then
3228 strafeDir := P1MoveButton; // start strafing
3229 // now set direction according to strafe (reversed)
3230 if (strafeDir = 2) then
3231 gPlayer1.SetDirection(TDirection.D_LEFT)
3232 else if (strafeDir = 1) then
3233 gPlayer1.SetDirection(TDirection.D_RIGHT)
3234 end
3235 else
3236 begin
3237 strafeDir := 0; // not strafing anymore
3238 if (P1MoveButton = 2) and gPlayerAction[0, ACTION_MOVELEFT] then
3239 gPlayer1.SetDirection(TDirection.D_LEFT)
3240 else if (P1MoveButton = 1) and gPlayerAction[0, ACTION_MOVERIGHT] then
3241 gPlayer1.SetDirection(TDirection.D_RIGHT)
3242 else if P1MoveButton <> 0 then
3243 gPlayer1.SetDirection(TDirection(P1MoveButton-1));
3244 end;
3245
3246 gPlayer1.ReleaseKeys;
3247 if P1MoveButton = 1 then
3248 begin
3249 kByte := kByte or NET_KEY_LEFT;
3250 if Predict then gPlayer1.PressKey(KEY_LEFT, 10000);
3251 end;
3252 if P1MoveButton = 2 then
3253 begin
3254 kByte := kByte or NET_KEY_RIGHT;
3255 if Predict then gPlayer1.PressKey(KEY_RIGHT, 10000);
3256 end;
3257 if gPlayerAction[0, ACTION_LOOKUP] then
3258 begin
3259 kByte := kByte or NET_KEY_UP;
3260 gPlayer1.PressKey(KEY_UP, 10000);
3261 end;
3262 if gPlayerAction[0, ACTION_LOOKDOWN] then
3263 begin
3264 kByte := kByte or NET_KEY_DOWN;
3265 gPlayer1.PressKey(KEY_DOWN, 10000);
3266 end;
3267 if gPlayerAction[0, ACTION_JUMP] then
3268 begin
3269 kByte := kByte or NET_KEY_JUMP;
3270 // gPlayer1.PressKey(KEY_JUMP, 10000); // TODO: Make a prediction option
3271 end;
3272 if gPlayerAction[0, ACTION_ATTACK] then kByte := kByte or NET_KEY_FIRE;
3273 if gPlayerAction[0, ACTION_ACTIVATE] then kByte := kByte or NET_KEY_OPEN;
3274
3275 for i := WP_FACT to WP_LACT do
3276 begin
3277 if gWeaponAction[0, i] then
3278 begin
3279 WeaponAct := WeaponAct or Byte(1 shl i);
3280 gWeaponAction[0, i] := False
3281 end
3282 end;
3283
3284 for i := WP_FIRST to WP_LAST do
3285 begin
3286 if gSelectWeapon[0, i] then
3287 begin
3288 WeaponSelect := WeaponSelect or Word(1 shl i);
3289 gSelectWeapon[0, i] := False
3290 end
3291 end;
3292
3293 // fix movebutton state
3294 P1MoveButton := P1MoveButton or (strafeDir shl 4);
3295 end
3296 else
3297 kByte := NET_KEY_CHAT;
3298
3299 NetOut.Write(Byte(NET_MSG_PLRPOS));
3300 NetOut.Write(gTime);
3301 NetOut.Write(kByte);
3302 NetOut.Write(Byte(gPlayer1.Direction));
3303 NetOut.Write(WeaponAct);
3304 NetOut.Write(WeaponSelect);
3305 //e_WriteLog(Format('S:ws=%d', [WeaponSelect]), MSG_WARNING);
3306 g_Net_Client_Send(True, NET_CHAN_PLAYERPOS);
3307
3308 //kBytePrev := kByte;
3309 //kDirPrev := gPlayer1.Direction;
3310 end;
3311
3312 procedure MC_SEND_Vote(Start: Boolean = False; Command: string = 'a');
3313 begin
3314 NetOut.Write(Byte(NET_MSG_VOTE_EVENT));
3315 NetOut.Write(Byte(Start));
3316 NetOut.Write(Command);
3317 g_Net_Client_Send(True, NET_CHAN_IMPORTANT);
3318 end;
3319
3320 procedure MC_SEND_PlayerSettings();
3321 var i: Integer;
3322 begin
3323 NetOut.Write(Byte(NET_MSG_PLRSET));
3324 NetOut.Write(gPlayer1Settings.Name);
3325 NetOut.Write(gPlayer1Settings.Model);
3326 NetOut.Write(gPlayer1Settings.Color.R);
3327 NetOut.Write(gPlayer1Settings.Color.G);
3328 NetOut.Write(gPlayer1Settings.Color.B);
3329 NetOut.Write(gPlayer1Settings.Team);
3330 NetOut.Write(gPlayer1Settings.WeaponSwitch);
3331 for i := WP_FIRST to WP_LAST + 1 do
3332 NetOut.Write(gPlayer1Settings.WeaponPreferences[i]);
3333 NetOut.Write(gPlayer1Settings.SwitchToEmpty);
3334 NetOut.Write(gPlayer1Settings.SkipFist);
3335
3336 g_Net_Client_Send(True, NET_CHAN_IMPORTANT);
3337 end;
3338
3339 procedure MC_SEND_FullStateRequest();
3340 begin
3341 NetOut.Write(Byte(NET_MSG_REQFST));
3342
3343 g_Net_Client_Send(True, NET_CHAN_SERVICE);
3344 end;
3345
3346 procedure MC_SEND_CheatRequest(Kind: Byte);
3347 begin
3348 NetOut.Write(Byte(NET_MSG_CHEAT));
3349 NetOut.Write(Kind);
3350
3351 g_Net_Client_Send(True, NET_CHAN_IMPORTANT);
3352 end;
3353 procedure MC_SEND_RCONPassword(Password: string);
3354 begin
3355 NetOut.Write(Byte(NET_MSG_RCON_AUTH));
3356 NetOut.Write(Password);
3357
3358 g_Net_Client_Send(True, NET_CHAN_SERVICE);
3359 end;
3360 procedure MC_SEND_RCONCommand(Cmd: string);
3361 begin
3362 NetOut.Write(Byte(NET_MSG_RCON_CMD));
3363 NetOut.Write(Cmd);
3364
3365 g_Net_Client_Send(True, NET_CHAN_SERVICE);
3366 end;
3367
3368
3369 end.
[MIRROR] a port of Doom 2D Forever to FPC/SDL
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024