箱子不沉的插件

kaizongjiadao

求个箱子不沉的插件。顺便再说下怎么安装，详细点的。麻烦各位了

SiMen.K.

1. /*
   
2. .: Commands :.
   
3. 
   
4. kz_mpbhop < 0 | 1 >
   
5. 
   
6. This enables the plugin (set block so they can't move when players touch them)
   
7. 
   
8. Put this one on 1 in amxx.cfg in you run a bhop server, else, use per prefixes/maps
   
9. 
   
10. config files
    
11. 
    
12. kz_mpbhop_entitytouch < 0 | 1 >
    
13. 
    
14. This enables entity touch detection (set block so they can't move when other entities
    
15. 
    
16. than players touch them)
    
17. 
    
18. Put this one on 1 in amxx.cfg in you run a bhop server, else, use per prefixes/maps
    
19. 
    
20. config files.
    
21. 
    
22. This feature works only if kz_mpbhop is set to 1
    
23. 
    
24. kz_safe_inform < 0 | 1 >
    
25. 
    
26. Inform recorders that their demo will be safe or not safe according to plugin state
    
27. 
    
28. kz_showblocks < 0 | 1 >
    
29. 
    
30. This make non-movable block transparent and colored so you can quickly notice them.
    
31. 
    
32. This is high consuming, so enable it only to config the plugin
    
33. 
    
34. kz_mpbhopmenu
    
35. 
    
36. To open the menu and set a block, aim the block to make this cmd work.
    
37. 
    
38. Then use the menu options to set the block.
    
39. 
    
40. */
    
41. 
    
42. #include <amxmodx>
    
43. #include <amxmisc>
    
44. #include <fakemeta>
    
45. #include <hamsandwich>
    
46. #include <xs>
    
47. 
    
48. #define VERSION "1.0.2"
    
49. 
    
50. #pragma semicolon 1
    
51. 
    
52. #define MAKE_DOORS_SILENT
    
53. //#define MAKE_TELEPORT_FX
    
54. 
    
55. #define MAX_PLAYERS 32
    
56. 
    
57. const MAX_ENTS = 900 + MAX_PLAYERS * 15;
    
58. const MAX_ENTSARRAYS_SIZE = (MAX_ENTS / 32) + _:!!(MAX_ENTS % 32);
    
59. 
    
60. #define SF_BUTTON_TOUCH_ONLY 256
    
61. 
    
62. #define SetIdBits(%1,%2) %1 |= 1<<(%2 & 31)
    
63. #define ClearIdBits(%1,%2) %1 &= ~( 1<<(%2 & 31) )
    
64. #define GetIdBits(%1,%2) %1 & 1<<(%2 & 31)
    
65. 
    
66. #define SetEntBits(%1,%2) %1[%2>>5] |= 1<<(%2 & 31)
    
67. #define ClearEntBits(%1,%2) %1[%2>>5] &= ~( 1 << (%2 & 31) )
    
68. #define GetEntBits(%1,%2) %1[%2>>5] & 1<<(%2 & 31)
    
69. 
    
70. enum _:BlocksClasses
    
71. {
    
72. FUNC_DOOR,
    
73. FUNC_WALL_TOGGLE,
    
74. FUNC_BUTTON,
    
75. TRIGGER_MULTIPLE
    
76. }
    
77. 
    
78. enum _:Colors {
    
79. DONT_CHANGE,
    
80. TERRORIST,
    
81. CT,
    
82. SPECTATOR
    
83. }
    
84. 
    
85. new g_bitPresentClass;
    
86. 
    
87. const KEYS = ((1<<0)|(1<<1)|(1<<9));
    
88. 
    
89. const FL_ONGROUND2 = (FL_ONGROUND | FL_PARTIALGROUND | FL_INWATER | FL_CONVEYOR | FL_FLOAT);
    
90. 
    
91. new g_iBlock[MAX_PLAYERS+1];
    
92. new Float:g_flFirstTouch[MAX_PLAYERS+1];
    
93. 
    
94. new Float:g_flJumpOrigin[MAX_PLAYERS+1][3];
    
95. new Float:g_flJumpAnglesGravity[MAX_PLAYERS+1][3];
    
96. 
    
97. new g_bBlocks[MAX_ENTSARRAYS_SIZE], g_bBlocksByPlugin[MAX_ENTSARRAYS_SIZE], g_bBlocksByFile[MAX_ENTSARRAYS_SIZE];
    
98. new g_bAlives, g_bOnGround, g_bTeleported, g_bAdmin;
    
99. 
    
100. new bool:g_bBlockEntityTouch;
     
101. new bool:g_bActive;
     
102. new bool:g_bSafeInform = true;
     
103. 
     
104. new g_iFhAddToFullPack;
     
105. new g_iAdminDoor[MAX_PLAYERS+1];
     
106. new szConfigFile[64];
     
107. 
     
108. new Trie:g_iBlocksClass;
     
109. 
     
110. new g_iMaxPlayers, g_iMaxEnts;
     
111. #define IsPlayer(%1) ( 1 <= %1 <= g_iMaxPlayers )
     
112. 
     
113. public plugin_init()
     
114. {
     
115. register_plugin("MultiPlayer Bhop", VERSION, "ConnorMcLeod");
     
116. new pCvar = register_cvar("mp_bhop_version", VERSION, FCVAR_SERVER|FCVAR_EXTDLL|FCVAR_SPONLY);
     
117. set_pcvar_string(pCvar, VERSION);
     
118. 
     
119. new const szPossibleBlockClass[][] = {"func_door", "func_wall_toggle", "func_button", "trigger_multiple"};
     
120. g_iBlocksClass = TrieCreate();
     
121. for(new i; i<sizeof(szPossibleBlockClass); i++)
     
122. {
     
123. TrieSetCell(g_iBlocksClass, szPossibleBlockClass[i], i);
     
124. }
     
125. 
     
126. register_event("Health", "Event_Health", "b");
     
127. register_event("ResetHUD", "Event_ResetHUD", "b");
     
128. 
     
129. register_concmd("kz_mpbhop", "ConsoleCommand_MpBhop", ADMIN_CFG, "<0/1>");
     
130. register_concmd("kz_mpbhop_entitytouch", "ConsoleCommand_EntityTouch", ADMIN_CFG, "<0/1>");
     
131. register_concmd("kz_safe_inform", "ConsoleCommand_SafeInform", ADMIN_CFG, "<0/1>");
     
132. 
     
133. register_clcmd("kz_mpbhopmenu", "ClientCommand_BhopMenu", ADMIN_CFG);
     
134. register_clcmd("kz_showblocks", "ClientCommand_ShowBlocks", ADMIN_CFG);
     
135. 
     
136. 
     
137. register_clcmd("fullupdate", "ClientCommand_FullUpdate");
     
138. 
     
139. register_menucmd(register_menuid("MpBhop Menu"), KEYS ,"MpBhopMenuAction");
     
140. 
     
141. g_iMaxPlayers = get_maxplayers();
     
142. g_iMaxEnts = global_get(glb_maxEntities);
     
143. 
     
144. Set_Doors();
     
145. Set_Wall_Toggle();
     
146. Set_Buttons();
     
147. 
     
148. SetBlocksByFile();
     
149. 
     
150. SetTriggerMultiple();
     
151. }
     
152. 
     
153. public ClientCommand_FullUpdate( id )
     
154. {
     
155. if( g_bSafeInform )
     
156. {
     
157. if( g_bActive )
     
158. {
     
159. client_print(id, print_console, "MpBhop is Activated, recording is NOT SAFE");
     
160. ColorChat(id, TERRORIST, "^1 * ^4[MpBhop] ^1MpBhop is ^4Activated^1, recording is ^3NOT SAFE");
     
161. }
     
162. else
     
163. {
     
164. client_print(id, print_console, "MpBhop is De-Activated, recording is SAFE");
     
165. ColorChat(id, TERRORIST, "^1 * ^4[MpBhop] ^1MpBhop is ^3De-Activated^1, recording is ^4SAFE");
     
166. }
     
167. }
     
168. }
     
169. 
     
170. public ConsoleCommand_SafeInform(id, lvl, cid)
     
171. {
     
172. if( cmd_access(id, lvl, cid, 2) )
     
173. {
     
174. new szStatus[2];
     
175. read_argv(1, szStatus, charsmax(szStatus));
     
176. g_bSafeInform = !!str_to_num(szStatus);
     
177. }
     
178. return PLUGIN_HANDLED;
     
179. }
     
180. 
     
181. public client_putinserver(id)
     
182. {
     
183. if( get_user_flags(id) & ADMIN_CFG )
     
184. {
     
185. SetIdBits(g_bAdmin, id);
     
186. }
     
187. else
     
188. {
     
189. ClearIdBits(g_bAdmin, id);
     
190. }
     
191. ClearIdBits(g_bAlives, id);
     
192. ClearIdBits(g_bOnGround, id);
     
193. ClearIdBits(g_bTeleported, id);
     
194. }
     
195. 
     
196. public client_disconnect(id)
     
197. {
     
198. ClearIdBits(g_bAdmin, id);
     
199. ClearIdBits(g_bAlives, id);
     
200. ClearIdBits(g_bOnGround, id);
     
201. ClearIdBits(g_bTeleported, id);
     
202. }
     
203. 
     
204. public ClientCommand_ShowBlocks(id, level, cid)
     
205. {
     
206. if( cmd_access(id, level, cid, 2) )
     
207. {
     
208. new szStatus[2];
     
209. read_argv(1, szStatus, charsmax(szStatus));
     
210. if( szStatus[0] == '1' )
     
211. {
     
212. if( !g_iFhAddToFullPack )
     
213. {
     
214. g_iFhAddToFullPack = register_forward(FM_AddToFullPack, "AddToFullPack", 1);
     
215. client_print(id, print_console, "Recording with this feature Activated is NOT SAFE");
     
216. ColorChat(id, TERRORIST, "^1 * ^4[MpBhop] ^1Recording with this feature ^4Activated ^1is ^3NOT SAFE");
     
217. }
     
218. }
     
219. else
     
220. {
     
221. if( g_iFhAddToFullPack )
     
222. {
     
223. unregister_forward(FM_AddToFullPack, g_iFhAddToFullPack, 1);
     
224. g_iFhAddToFullPack = 0;
     
225. }
     
226. }
     
227. }
     
228. return PLUGIN_HANDLED;
     
229. }
     
230. 
     
231. public MpBhopMenuAction(id, iKey)
     
232. {
     
233. new iEnt = g_iAdminDoor[id];
     
234. 
     
235. switch( iKey )
     
236. {
     
237. case 0:
     
238. {
     
239. if( GetEntBits(g_bBlocks, iEnt) )
     
240. {
     
241. ClearEntBits(g_bBlocks, iEnt);
     
242. SetEntBits(g_bBlocksByFile, iEnt);
     
243. ColorChat(id, _, "^1 * ^4[MpBhop] ^1Block has been set ^4movable^1.");
     
244. }
     
245. else
     
246. {
     
247. ColorChat(id, _, "^1 * ^4[MpBhop] ^1Block is already ^4movable^1.");
     
248. }
     
249. }
     
250. case 1:
     
251. {
     
252. if( GetEntBits(g_bBlocks, iEnt) )
     
253. {
     
254. ColorChat(id, TERRORIST, "^1 * ^4[MpBhop] ^1Block is already ^3unmovable^1.");
     
255. }
     
256. else
     
257. {
     
258. SetEntBits(g_bBlocks, iEnt);
     
259. SetEntBits(g_bBlocksByFile, iEnt);
     
260. ColorChat(id, TERRORIST, "^1 * ^4[MpBhop] ^1Block has been set ^3unmovable^1.");
     
261. }
     
262. }
     
263. }
     
264. return PLUGIN_HANDLED;
     
265. }
     
266. 
     
267. ShowMpBhopMenu(id, bIsBlocked)
     
268. {
     
269. new szMenuBody[150];
     
270. 
     
271. formatex(szMenuBody, charsmax(szMenuBody), "\rMpBhop Menu^n\dThis block is actually \
     
272. \y%smovable \d:^n^n\r1\w. Mark this block as movable^n\r2\w. Mark this block as \
     
273. unmovable^n^n\r0\w. Exit", bIsBlocked ? "un" : "");
     
274. 
     
275. show_menu(id, KEYS, szMenuBody, _, "MpBhop Menu");
     
276. }
     
277. 
     
278. public ClientCommand_BhopMenu(id, level, cid)
     
279. {
     
280. if( cmd_access(id, level, cid, 1) )
     
281. {
     
282. new iEnt, crap, iClassType;
     
283. get_user_aiming(id, iEnt, crap);
     
284. if( iEnt && pev_valid(iEnt) )
     
285. {
     
286. new szClassName[32];
     
287. pev(iEnt, pev_classname, szClassName, charsmax(szClassName));
     
288. if( TrieGetCell(g_iBlocksClass, szClassName, iClassType) )
     
289. {
     
290. g_bitPresentClass |= 1<<iClassType;
     
291. g_iAdminDoor[id] = iEnt;
     
292. ShowMpBhopMenu(id, !!(GetEntBits(g_bBlocks, iEnt)));
     
293. }
     
294. }
     
295. }
     
296. return PLUGIN_HANDLED;
     
297. }
     
298. 
     
299. public AddToFullPack(es, e, iEnt, id, hostflags, player, pSet)
     
300. {
     
301. if( !player && GetIdBits(g_bAdmin, id) && GetEntBits(g_bBlocks, iEnt) )
     
302. {
     
303. set_es(es, ES_RenderMode, kRenderTransColor);
     
304. set_es(es, ES_RenderAmt, 150);
     
305. set_es(es, ES_RenderColor, {120,75,170});
     
306. set_es(es, ES_RenderFx, kRenderFxGlowShell);
     
307. }
     
308. }
     
309. 
     
310. public Event_Health(id)
     
311. {
     
312. if( is_user_alive(id) )
     
313. {
     
314. SetIdBits(g_bAlives, id);
     
315. }
     
316. else
     
317. {
     
318. ClearIdBits(g_bAlives, id);
     
319. }
     
320. }
     
321. 
     
322. public Event_ResetHUD(id)
     
323. {
     
324. if( is_user_alive(id) )
     
325. {
     
326. SetIdBits(g_bAlives, id);
     
327. }
     
328. else
     
329. {
     
330. ClearIdBits(g_bAlives, id);
     
331. }
     
332. }
     
333. 
     
334. public CBasePlayer_PreThink(id)
     
335. {
     
336. if( GetIdBits(g_bAlives, id) )
     
337. {
     
338. if( GetIdBits(g_bTeleported, id) )
     
339. {
     
340. ClearIdBits(g_bTeleported, id);
     
341. set_pev(id, pev_velocity, 0);
     
342. return;
     
343. }
     
344. 
     
345. static fFlags;
     
346. fFlags = pev(id, pev_flags);
     
347. if( fFlags & FL_ONGROUND )
     
348. {
     
349. static iEnt, Float:flVelocity[3], Float:flVecOrigin[3];
     
350. iEnt = pev(id, pev_groundentity);
     
351. if( !iEnt || !(GetEntBits(g_bBlocks, iEnt)) )
     
352. {
     
353. if( iEnt )
     
354. {
     
355. pev(iEnt, pev_velocity, flVelocity);
     
356. if( flVelocity[0] || flVelocity[1] || flVelocity[2] )
     
357. {
     
358. ClearIdBits(g_bOnGround, id);
     
359. return;
     
360. }
     
361. }
     
362. 
     
363. if( fFlags & FL_DUCKING )
     
364. {
     
365. pev(id, pev_origin, flVecOrigin);
     
366. flVecOrigin[2] += 18.0;
     
367. engfunc(EngFunc_TraceHull, flVecOrigin, flVecOrigin, IGNORE_MONSTERS, HULL_HUMAN, id, 0);
     
368. if( !get_tr2(0, TR_StartSolid) && !get_tr2(0, TR_AllSolid) && get_tr2(0, TR_InOpen) )
     
369. {
     
370. flVecOrigin[2] -= 18.0;
     
371. xs_vec_copy(flVecOrigin, g_flJumpOrigin[id]);
     
372. SetIdBits(g_bOnGround, id);
     
373. }
     
374. else
     
375. {
     
376. ClearIdBits(g_bOnGround, id);
     
377. return;
     
378. }
     
379. }
     
380. else
     
381. {
     
382. pev(id, pev_origin, g_flJumpOrigin[id]);
     
383. SetIdBits(g_bOnGround, id);
     
384. }
     
385. }
     
386. else
     
387. {
     
388. ClearIdBits(g_bOnGround, id);
     
389. }
     
390. }
     
391. else if( GetIdBits(g_bOnGround, id) )
     
392. {
     
393. ClearIdBits(g_bOnGround, id);
     
394. pev(id, pev_v_angle, g_flJumpAnglesGravity[id]);
     
395. pev(id, pev_gravity, g_flJumpAnglesGravity[id][2]);
     
396. }
     
397. }
     
398. }
     
399. 
     
400. public TriggerMultiple_Touch(iEnt, id)
     
401. {
     
402. if( (IsPlayer(id) || g_bBlockEntityTouch) && GetEntBits(g_bBlocks, iEnt) )
     
403. {
     
404. return HAM_SUPERCEDE;
     
405. }
     
406. return HAM_IGNORED;
     
407. }
     
408. 
     
409. public Touch_Block(iBlock, id)
     
410. {
     
411. if( !(GetEntBits(g_bBlocks, iBlock)) )
     
412. {
     
413. return HAM_IGNORED;
     
414. }
     
415. 
     
416. if( IsPlayer(id) )
     
417. {
     
418. if( ~GetIdBits(g_bAlives, id) )
     
419. {
     
420. return HAM_SUPERCEDE;
     
421. }
     
422. }
     
423. else
     
424. {
     
425. return g_bBlockEntityTouch ? HAM_SUPERCEDE : HAM_IGNORED;
     
426. }
     
427. 
     
428. if( pev(id, pev_groundentity) != iBlock )
     
429. {
     
430. return HAM_SUPERCEDE;
     
431. }
     
432. 
     
433. if( g_iBlock[id] != iBlock )
     
434. {
     
435. g_iBlock[id] = iBlock;
     
436. g_flFirstTouch[id] = get_gametime();
     
437. return HAM_SUPERCEDE;
     
438. }
     
439. 
     
440. static Float:flTime;
     
441. flTime = get_gametime();
     
442. 
     
443. if( flTime - g_flFirstTouch[id] > 0.25 ) // 0.3 == exploit on cg_cbblebhop oO
     
444. {
     
445. if( flTime - g_flFirstTouch[id] > 0.7 )
     
446. {
     
447. g_flFirstTouch[id] = flTime;
     
448. return HAM_SUPERCEDE;
     
449. }
     
450. 
     
451. #if defined MAKE_TELEPORT_FX
     
452. new iOrigin[3];
     
453. get_user_origin(id, iOrigin);
     
454. message_begin(MSG_PVS, SVC_TEMPENTITY, iOrigin);
     
455. write_byte(TE_TELEPORT);
     
456. write_coord(iOrigin[0]);
     
457. write_coord(iOrigin[1]);
     
458. write_coord(iOrigin[2]);
     
459. message_end();
     
460. #endif
     
461. static const Float:VEC_DUCK_HULL_MIN[3] = {-16.0, -16.0, -18.0 };
     
462. static const Float:VEC_DUCK_HULL_MAX[3] = { 16.0, 16.0, 32.0 };
     
463. static const Float:VEC_DUCK_VIEW[3] = { 0.0, 0.0, 12.0 };
     
464. 
     
465. set_pev(id, pev_flags, pev(id, pev_flags) | FL_DUCKING);
     
466. engfunc(EngFunc_SetSize, id, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX);
     
467. engfunc(EngFunc_SetOrigin, id, g_flJumpOrigin[id]);
     
468. set_pev(id, pev_view_ofs, VEC_DUCK_VIEW);
     
469. 
     
470. set_pev(id, pev_v_angle, 0);
     
471. set_pev(id, pev_velocity, 0);
     
472. set_pev(id, pev_angles, g_flJumpAnglesGravity[id]);
     
473. set_pev(id, pev_punchangle, 0);
     
474. set_pev(id, pev_fixangle, 1);
     
475. set_pev(id, pev_gravity, g_flJumpAnglesGravity[id][2]);
     
476. 
     
477. SetIdBits(g_bTeleported, id);
     
478. }
     
479. return HAM_SUPERCEDE;
     
480. }
     
481. 
     
482. public ConsoleCommand_MpBhop(id, lvl, cid)
     
483. {
     
484. if( cmd_access(id, lvl, cid, 2) )
     
485. {
     
486. new szStatus[2];
     
487. read_argv(1, szStatus, charsmax(szStatus));
     
488. static HamHook:iHhPlayerPreThink;
     
489. switch( szStatus[0] )
     
490. {
     
491. case '0':
     
492. {
     
493. if( !g_bActive )
     
494. {
     
495. return PLUGIN_HANDLED;
     
496. }
     
497. if( iHhPlayerPreThink )
     
498. {
     
499. DisableHamForward( iHhPlayerPreThink );
     
500. }
     
501. SetTouch( false );
     
502. g_bActive = false;
     
503. 
     
504. if( g_bSafeInform )
     
505. {
     
506. client_print(0, print_console, "MpBhop has been De-Activated, recording is now SAFE");
     
507. ColorChat(0, TERRORIST, "^1 * ^4[MpBhop] ^1MpBhop has been ^3De-Activated^1, recording is now ^4SAFE");
     
508. }
     
509. }
     
510. case '1':
     
511. {
     
512. if( g_bActive )
     
513. {
     
514. return PLUGIN_HANDLED;
     
515. }
     
516. if( !iHhPlayerPreThink )
     
517. {
     
518. RegisterHam(Ham_Player_PreThink, "player", "CBasePlayer_PreThink");
     
519. }
     
520. else
     
521. {
     
522. EnableHamForward( iHhPlayerPreThink );
     
523. }
     
524. SetTouch( true );
     
525. g_bActive = true;
     
526. if( g_bSafeInform )
     
527. {
     
528. client_print(0, print_console, "MpBhop has been Activated, recording is now NOT SAFE");
     
529. ColorChat(0, TERRORIST, "^1 * ^4[MpBhop] ^1MpBhop has been ^4Activated^1, recording is now ^3NOT SAFE");
     
530. }
     
531. }
     
532. default:
     
533. {
     
534. client_print(id, print_console, "Usage: kz_mpbhop <0/1>");
     
535. }
     
536. }
     
537. }
     
538. return PLUGIN_HANDLED;
     
539. }
     
540. 
     
541. public ConsoleCommand_EntityTouch(id, lvl, cid)
     
542. {
     
543. if( cmd_access(id, lvl, cid, 2) )
     
544. {
     
545. new szStatus[2];
     
546. read_argv(1, szStatus, charsmax(szStatus));
     
547. g_bBlockEntityTouch = !!str_to_num(szStatus);
     
548. }
     
549. return PLUGIN_HANDLED;
     
550. }
     
551. 
     
552. Set_Doors()
     
553. {
     
554. new iDoor = FM_NULLENT;
     
555. new Float:flMovedir[3], szNoise[32], Float:flSize[3], Float:flDmg, Float:flSpeed;
     
556. new const szNull[] = "common/null.wav";
     
557. while( (iDoor = engfunc(EngFunc_FindEntityByString, iDoor, "classname", "func_door")) )
     
558. {
     
559. // definitly not a bhop block
     
560. pev(iDoor, pev_dmg, flDmg);
     
561. if( flDmg )
     
562. {
     
563. #if defined MAKE_DOORS_SILENT
     
564. set_pev(iDoor, pev_noise1, szNull); // while here, set healing doors silent xD
     
565. set_pev(iDoor, pev_noise2, szNull);
     
566. set_pev(iDoor, pev_noise3, szNull);
     
567. #endif
     
568. continue;
     
569. }
     
570. 
     
571. // this func_door goes UP, not a bhop block ?
     
572. // or bhop block but let them move up (kz_megabhop for example)
     
573. pev(iDoor, pev_movedir, flMovedir);
     
574. if( flMovedir[2] > 0.0 )
     
575. {
     
576. continue;
     
577. }
     
578. 
     
579. // too small : real door ? could this one be skipped ?
     
580. pev(iDoor, pev_size, flSize);
     
581. if( flSize[0] < 24.0 || flSize[1] < 24.0 )
     
582. {
     
583. continue;
     
584. }
     
585. 
     
586. // real door ? not all doors make sound though...
     
587. pev(iDoor, pev_noise1, szNoise, charsmax(szNoise));
     
588. if( szNoise[0] && !equal(szNoise, szNull) )
     
589. {
     
590. continue;
     
591. }
     
592. pev(iDoor, pev_noise2, szNoise, charsmax(szNoise));
     
593. if( szNoise[0] && !equal(szNoise, szNull) )
     
594. {
     
595. continue;
     
596. }
     
597. 
     
598. // not a bhop block ? too slow // this at least detects the big ent on kzsca_sewerbhop
     
599. pev(iDoor, pev_speed, flSpeed);
     
600. if( flSpeed < 100.0 )
     
601. {
     
602. continue;
     
603. }
     
604. 
     
605. // Pray for this to be a bhop block
     
606. SetEntBits(g_bBlocksByPlugin, iDoor);
     
607. SetEntBits(g_bBlocks, iDoor);
     
608. g_bitPresentClass |= 1<<FUNC_DOOR;
     
609. }
     
610. }
     
611. 
     
612. Set_Wall_Toggle()
     
613. {
     
614. new iEnt = FM_NULLENT;
     
615. while( (iEnt = engfunc(EngFunc_FindEntityByString, iEnt, "classname", "func_wall_toggle")) )
     
616. {
     
617. g_bitPresentClass |= 1<<FUNC_WALL_TOGGLE;
     
618. SetEntBits(g_bBlocksByPlugin, iEnt);
     
619. SetEntBits(g_bBlocks, iEnt);
     
620. }
     
621. }
     
622. 
     
623. Set_Buttons()
     
624. {
     
625. new const szStartStopButtons[][] = {"counter_start", "clockstartbutton", "firsttimerelay", "multi_start",
     
626. "counter_start_button", "counter_off", "clockstop", "clockstopbutton", "multi_stop", "stop_counter" };
     
627. 
     
628. new Trie:tButtons = TrieCreate();
     
629. 
     
630. for(new i; i<sizeof(szStartStopButtons); i++)
     
631. {
     
632. TrieSetCell(tButtons, szStartStopButtons[i], 1);
     
633. }
     
634. 
     
635. new iEnt = FM_NULLENT, szTarget[32];
     
636. while( (iEnt = engfunc(EngFunc_FindEntityByString, iEnt, "classname", "func_button")) )
     
637. {
     
638. if( pev(iEnt, pev_spawnflags) & SF_BUTTON_TOUCH_ONLY )
     
639. {
     
640. pev(iEnt, pev_target, szTarget, charsmax(szTarget));
     
641. if( !szTarget[0] || !TrieKeyExists(tButtons, szTarget))
     
642. {
     
643. pev(iEnt, pev_targetname, szTarget, charsmax(szTarget));
     
644. if( !szTarget[0] || !TrieKeyExists(tButtons, szTarget))
     
645. {
     
646. g_bitPresentClass |= 1<<FUNC_BUTTON;
     
647. SetEntBits(g_bBlocksByPlugin, iEnt);
     
648. SetEntBits(g_bBlocks, iEnt);
     
649. }
     
650. }
     
651. }
     
652. }
     
653. TrieDestroy(tButtons);
     
654. }
     
655. 
     
656. SetTouch(bool:bActive)
     
657. {
     
658. static HamHook:iHhBlockTouch[BlocksClasses];
     
659. if( bActive )
     
660. {
     
661. static const szClassesAndHandlers[BlocksClasses][][] = {
     
662. {"func_door", "Touch_Block"},
     
663. {"func_wall_toggle", "Touch_Block"},
     
664. {"func_button", "Touch_Block"},
     
665. {"trigger_multiple", "TriggerMultiple_Touch"}
     
666. };
     
667. for(new i; i<sizeof(iHhBlockTouch); i++)
     
668. {
     
669. if( g_bitPresentClass & (1<<i) )
     
670. {
     
671. if( iHhBlockTouch[i] )
     
672. {
     
673. EnableHamForward( iHhBlockTouch[i] );
     
674. }
     
675. else
     
676. {
     
677. iHhBlockTouch[i] = RegisterHam(Ham_Touch, szClassesAndHandlers[i][0], szClassesAndHandlers[i][1]);
     
678. }
     
679. }
     
680. }
     
681. }
     
682. else
     
683. {
     
684. for(new i; i<sizeof(iHhBlockTouch); i++)
     
685. {
     
686. if( g_bitPresentClass & (1<<i) && iHhBlockTouch[i] )
     
687. {
     
688. DisableHamForward( iHhBlockTouch[i] );
     
689. }
     
690. }
     
691. }
     
692. }
     
693. 
     
694. SetBlocksByFile()
     
695. {
     
696. get_localinfo("amxx_datadir", szConfigFile, charsmax(szConfigFile));
     
697. format(szConfigFile, charsmax(szConfigFile), "%s/mpbhop", szConfigFile);
     
698. if( !dir_exists(szConfigFile) )
     
699. {
     
700. mkdir(szConfigFile);
     
701. }
     
702. 
     
703. new szMapName[32];
     
704. get_mapname(szMapName, charsmax(szMapName));
     
705. format(szConfigFile, charsmax(szConfigFile), "%s/%s.dat", szConfigFile, szMapName);
     
706. 
     
707. new iFile = fopen(szConfigFile, "rt");
     
708. if( iFile )
     
709. {
     
710. new szDatas[48], szBrushOrigin[3][13], szType[2], Float:flBrushOrigin[3], i, iEnt;
     
711. new szClassName[32], iClassType;
     
712. while( !feof(iFile) )
     
713. {
     
714. fgets(iFile, szDatas, charsmax(szDatas));
     
715. trim(szDatas);
     
716. if(!szDatas[0] || szDatas[0] == ';' || szDatas[0] == '#' || (szDatas[0] == '/' && szDatas[1] == '/'))
     
717. {
     
718. continue;
     
719. }
     
720. 
     
721. parse(szDatas, szBrushOrigin[0], 12, szBrushOrigin[1], 12, szBrushOrigin[2], 12, szType, charsmax(szType));
     
722. for(i=0; i<3; i++)
     
723. {
     
724. flBrushOrigin[i] = str_to_float( szBrushOrigin[i] );
     
725. }
     
726. 
     
727. iEnt = FindEntByBrushOrigin( flBrushOrigin );
     
728. if( iEnt )
     
729. {
     
730. if( szType[0] == '1' )
     
731. {
     
732. pev(iEnt, pev_classname, szClassName, charsmax(szClassName));
     
733. if( TrieGetCell(g_iBlocksClass, szClassName, iClassType) )
     
734. {
     
735. g_bitPresentClass |= iClassType;
     
736. }
     
737. SetEntBits(g_bBlocks, iEnt);
     
738. }
     
739. else
     
740. {
     
741. ClearEntBits(g_bBlocks, iEnt);
     
742. }
     
743. SetEntBits(g_bBlocksByFile, iEnt);
     
744. }
     
745. }
     
746. fclose(iFile);
     
747. }
     
748. }
     
749. 
     
750. FindEntByBrushOrigin(Float:flOrigin[3])
     
751. {
     
752. new Float:flBrushOrigin[3];
     
753. for( new iEnt=g_iMaxPlayers+1; iEnt<=g_iMaxEnts; iEnt++ )
     
754. {
     
755. if( pev_valid(iEnt) )
     
756. {
     
757. fm_get_brush_entity_origin(iEnt, flBrushOrigin);
     
758. if( xs_vec_nearlyequal(flBrushOrigin, flOrigin) )
     
759. {
     
760. return iEnt;
     
761. }
     
762. }
     
763. }
     
764. return 0;
     
765. }
     
766. 
     
767. fm_get_brush_entity_origin(ent, Float:orig[3])
     
768. {
     
769. new Float:Min[3], Float:Max[3];
     
770. 
     
771. pev(ent, pev_origin, orig);
     
772. pev(ent, pev_mins, Min);
     
773. pev(ent, pev_maxs, Max);
     
774. 
     
775. orig[0] += (Min[0] + Max[0]) * 0.5;
     
776. orig[1] += (Min[1] + Max[1]) * 0.5;
     
777. orig[2] += (Min[2] + Max[2]) * 0.5;
     
778. 
     
779. return 1;
     
780. }
     
781. 
     
782. SetTriggerMultiple()
     
783. {
     
784. new iEnt = FM_NULLENT, szTarget[32], iBlock;
     
785. while( (iEnt = engfunc(EngFunc_FindEntityByString, iEnt, "classname", "trigger_multiple")) )
     
786. {
     
787. pev(iEnt, pev_target, szTarget, charsmax(szTarget));
     
788. iBlock = engfunc(EngFunc_FindEntityByString, -1, "targetname", szTarget);
     
789. if( iBlock && GetEntBits(g_bBlocks, iBlock) )
     
790. {
     
791. g_bitPresentClass |= 1<<TRIGGER_MULTIPLE;
     
792. SetEntBits(g_bBlocksByPlugin, iEnt);
     
793. SetEntBits(g_bBlocks, iEnt);
     
794. }
     
795. }
     
796. }
     
797. 
     
798. public plugin_end()
     
799. {
     
800. TrieDestroy(g_iBlocksClass);
     
801. delete_file(szConfigFile);
     
802. 
     
803. new iFile;
     
804. 
     
805. new Float:flBrushOrigin[3], iUnMovable;
     
806. for(new iEnt=g_iMaxPlayers+1; iEnt<=g_iMaxEnts; iEnt++)
     
807. {
     
808. if( GetEntBits(g_bBlocksByFile, iEnt) && pev_valid(iEnt) )
     
809. {
     
810. iUnMovable = ( GetEntBits(g_bBlocks, iEnt) );
     
811. if( !!iUnMovable
     
812. != !!( GetEntBits(g_bBlocksByPlugin, iEnt) ) )
     
813. {
     
814. if( !iFile )
     
815. {
     
816. iFile = fopen(szConfigFile, "wt");
     
817. }
     
818. fm_get_brush_entity_origin(iEnt, flBrushOrigin);
     
819. fprintf(iFile, "%f %f %f %d^n",
     
820. flBrushOrigin[0], flBrushOrigin[1], flBrushOrigin[2], !!iUnMovable);
     
821. }
     
822. }
     
823. }
     
824. if( iFile )
     
825. {
     
826. fclose( iFile );
     
827. }
     
828. }
     
829. 
     
830. ColorChat(id, COLOR=DONT_CHANGE, fmt[], any:...)
     
831. {
     
832. new szMsg[192];
     
833. szMsg[0] = 0x04;
     
834. vformat(szMsg[1], charsmax(szMsg)-1, fmt, 4);
     
835. 
     
836. new szTeam[11], MSG_DEST = id ? MSG_ONE : MSG_ALL;
     
837. 
     
838. static const szTeamNames[Colors][] = {"", "TERRORIST", "CT", "SPECTATOR"};
     
839. 
     
840. if( COLOR )
     
841. {
     
842. Send_TeamInfo(id, szTeamNames[COLOR], MSG_DEST);
     
843. }
     
844. 
     
845. static iSayText;
     
846. 
     
847. if( iSayText || (iSayText = get_user_msgid("SayText")) )
     
848. {
     
849. message_begin(MSG_DEST, iSayText, _, id);
     
850. {
     
851. write_byte(id ? id : g_iMaxPlayers);
     
852. write_string(szMsg);
     
853. }
     
854. message_end();
     
855. }
     
856. 
     
857. if( COLOR )
     
858. {
     
859. if( id || is_user_connected(g_iMaxPlayers) )
     
860. {
     
861. get_user_team(id ? id : g_iMaxPlayers, szTeam, charsmax(szTeam));
     
862. Send_TeamInfo(id, szTeam, MSG_DEST);
     
863. }
     
864. else
     
865. {
     
866. Send_TeamInfo(0, "UNASSIGNED", MSG_DEST);
     
867. }
     
868. }
     
869. }
     
870. 
     
871. Send_TeamInfo(const id, const szTeam[], MSG_DEST)
     
872. {
     
873. static iTeamInfo;
     
874. if( iTeamInfo || (iTeamInfo = get_user_msgid("TeamInfo")) )
     
875. {
     
876. message_begin(MSG_DEST, iTeamInfo, _, id);
     
877. {
     
878. write_byte(id ? id : g_iMaxPlayers);
     
879. write_string(szTeam);
     
880. }
     
881. message_end();
     
882. }
     
883. }

复制代码