HLMOD.HU Forrás Megtekintés - www.hlmod.hu
  1. /*	=============================================
  2. *	- NAME:
  3. *	  + Shoop da Whoop Slay
  4. *
  5. *	- DESCRIPTION:
  6. *	  + 
  7. *	  + This plugin will spawn 'Shoop da Whoop' to slay a player with his laser.
  8. *	  + It's exactly like the regular amx_slay but with the added style.
  9. *	  + 
  10. *
  11. *	- CREDITS:
  12. *	  + Max: For making the awesome Shoop da Whoop model and testing.
  13. *	  + Almightynoob: For helping with demo video and testing.
  14. *	  + TonyCip/Tyrant/Psy/Muchez: For testing.
  15. *
  16. *
  17. *	---------------
  18. *	Admin commands:
  19. *	---------------
  20. *	- amx_shoopslay <name or #userid>
  21. *	 + Lets an admin slay players using Shoop da Whoop.
  22. *
  23. *
  24. *	----------
  25. *	Changelog:
  26. *	----------
  27. *	Version 1.0 ( 08-18-2009 )
  28. *	-- Initial release.
  29. * 
  30. *	Version 1.1 ( 08-21-2009 )
  31. *	-- Now using hamsandwiches think forward instead of fakemetas.
  32. *	-- Fixed bug where players with god mode would not be slayed.
  33. * 
  34. *	Version 1.2 ( 08-21-2009 )
  35. *	-- No longer using #define for strings (thanks Exolent).
  36. *	-- Removed the player check in Ham_TakeDamage (thanks joaquimandrade).
  37. *	-- CanShoopSpawn() now uses loop instead of code repetition (thanks joaquimandrade).
  38. *	-- Now using TraceHull instead of a custom trace function (thanks joaquimandrade).
  39. * 
  40. *	Version 1.3 ( 08-23-2009 )
  41. *	-- Fixed the god mode private data offset for Linux servers.
  42. *	-- Added back a player check I removed in version 1.2 (thanks koleos).
  43. * 
  44. *	Version 1.4 ( 08-24-2009 )
  45. *	-- Changed MSG_BROADCAST to MSG_PVS for tempents.
  46. *	-- Added the ability to slay everyone at once using @all.
  47. * 
  48. */
  49.  
  50. #include <amxmodx>
  51. #include <amxmisc>
  52. #include <fakemeta>
  53. #include <hamsandwich>
  54.  
  55. new const PLUGIN[]  = "Shoop da Whoop Slay";
  56. new const VERSION[] = "1.4";
  57. new const AUTHOR[]  = "hlstriker";
  58.  
  59. new g_iMaxplayers;
  60. #define MAX_PLAYERS 32
  61.  
  62. #define POWERUP_GOD_OFFSET 271
  63. #define POWERUP_GOD_LINUX_DIFF 3
  64.  
  65. new bool:g_bBeingShooped[MAX_PLAYERS+1];
  66. new Float:g_flAngles[MAX_PLAYERS+1][3];
  67. new Float:g_flSpawnOrigin[MAX_PLAYERS+1][3];
  68.  
  69. #define NUM_EXPLOSIONS 7
  70. #define SHOOPS_ID 9281
  71.  
  72. #define DISTANCE_SHOOP 165.0
  73. new Float:g_flShoopMins[3] = {-15.0, -15.0, -15.0}; // No smaller than: Vector(-16, -16, -18)
  74. new Float:g_flShoopMaxs[3] = {15.0, 15.0, 15.0}; // No bigger than: Vector( 16,  16,  18)
  75.  
  76. new const SHOOP_MODEL[] = "models/shoopslay/shoop_b7.mdl";
  77. new const SHOOP_SOUND[] = "shoopslay/shoop_b4.wav";
  78.  
  79. new g_iExplosion;
  80. new g_iBeam;
  81. new const EXPLOSION_SPRITE[] = "sprites/explode1.spr";
  82. new const BEAM_SPRITE[] = "sprites/xbeam3.spr";
  83.  
  84. public plugin_init()
  85. {
  86. 	register_plugin(PLUGIN, VERSION, AUTHOR);
  87. 	register_cvar("shoopslay_version", VERSION, FCVAR_SERVER|FCVAR_SPONLY);
  88. 	register_forward(FM_ClientKill, "fwd_ClientKill");
  89. 	RegisterHam(Ham_Player_PreThink, "player", "fwd_Player_PreThink");
  90. 	RegisterHam(Ham_TakeDamage, "player", "fwd_TakeDamage");
  91. 	RegisterHam(Ham_Think, "info_target", "fwd_Think");
  92.  
  93. 	register_logevent("hook_RoundStart", 2, "1=Round_Start");
  94. 	register_event("CurWeapon", "hook_CurWeapon", "be", "1=1");
  95. 	register_event("ResetHUD", "hook_ResetHUD", "be");
  96. 	register_clcmd("fullupdate", "hook_BlockCommand");
  97.  
  98. 	register_concmd("amx_shoopslay", "CmdShoopSlay", ADMIN_SLAY, "<nev vagy #userid vagy @all>");
  99.  
  100. 	g_iMaxplayers = get_maxplayers();
  101. }
  102.  
  103. public plugin_precache()
  104. {
  105. 	g_iExplosion = precache_model(EXPLOSION_SPRITE);
  106. 	g_iBeam = precache_model(BEAM_SPRITE);
  107. 	precache_model(SHOOP_MODEL);
  108. 	precache_sound(SHOOP_SOUND);
  109. }
  110.  
  111. public client_disconnect(iClient)
  112. 	g_bBeingShooped[iClient] = false;
  113.  
  114. public fwd_TakeDamage(iVictim, iInflictor, iAttacker, Float:flDamage, iDmgBits)
  115. {
  116. 	if(g_bBeingShooped[iVictim])
  117. 		return HAM_SUPERCEDE;
  118.  
  119. 	if(1 <= iAttacker <= g_iMaxplayers)
  120. 	{
  121. 		if(g_bBeingShooped[iAttacker])
  122. 			return HAM_SUPERCEDE;
  123. 	}
  124.  
  125. 	return HAM_IGNORED;
  126. }
  127.  
  128. public hook_RoundStart()
  129. {
  130. 	for(new i=1; i<=g_iMaxplayers; i++)
  131. 	{
  132. 		if(g_bBeingShooped[i])
  133. 			set_task(0.1, "task_ResetSpeed", i);
  134. 	}
  135. }
  136.  
  137. public task_ResetSpeed(iClient)
  138. 	engfunc(EngFunc_SetClientMaxspeed, iClient, 0.1);
  139.  
  140. public hook_CurWeapon(iClient)
  141. {
  142. 	if(g_bBeingShooped[iClient])
  143. 		engfunc(EngFunc_SetClientMaxspeed, iClient, 0.1);
  144. }
  145.  
  146. public fwd_ClientKill(iClient)
  147. {
  148. 	if(g_bBeingShooped[iClient])
  149. 		return FMRES_SUPERCEDE;
  150. 	return FMRES_IGNORED;
  151. }
  152.  
  153. public hook_ResetHUD(iClient)
  154. 	set_task(0.4, "task_Spawn", iClient);
  155.  
  156. public task_Spawn(iClient)
  157. 	pev(iClient, pev_origin, g_flSpawnOrigin[iClient]);
  158.  
  159. public hook_BlockCommand()
  160. 	return PLUGIN_HANDLED;
  161.  
  162. public CmdShoopSlay(iClient, iLevel, iCid)
  163. {
  164. 	if(!cmd_access(iClient, iLevel, iCid, 2))
  165. 		return FMRES_IGNORED;
  166.  
  167. 	new szArg[32];
  168.  
  169. 	read_argv(1, szArg, sizeof(szArg)-1);
  170.  
  171. 	if(equali(szArg, "@all"))
  172. 	{
  173. 		ShoopSlayAll(iClient);
  174. 		return FMRES_IGNORED;
  175. 	}
  176.  
  177. 	new iVictim = cmd_target(iClient, szArg, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_ALLOW_SELF | CMDTARGET_ONLY_ALIVE);
  178.  
  179. 	if(!iVictim)
  180. 		return FMRES_IGNORED;
  181.  
  182. 	if(g_bBeingShooped[iVictim])
  183. 	{
  184. 		console_print(iClient, "[HIBA] Mar folyamatban van a celpont likvidalasa.");
  185. 		return FMRES_IGNORED;
  186. 	}
  187.  
  188. 	ShoopSlay(iVictim);
  189.  
  190. 	new szAuthID[32], szName2[32], szAuthID2[32], szName[32];
  191. 	get_user_authid(iClient, szAuthID, sizeof(szAuthID)-1);
  192. 	get_user_name(iClient, szName, sizeof(szName)-1);
  193. 	get_user_authid(iVictim, szAuthID2, sizeof(szAuthID2)-1);
  194. 	get_user_name(iVictim, szName2, sizeof(szName2)-1);
  195.  
  196. 	log_amx("Cmd: ^"%s<%d><%s><>^" megutotte ^"%s<%d><%s><>^"", szName, get_user_userid(iClient), szAuthID, szName2, get_user_userid(iVictim), szAuthID2);
  197.  
  198. 	show_activity_key("ADMIN_SLAY_1", "ADMIN_SLAY_2", szName, szName2);
  199.  
  200. 	console_print(iClient, "[AMXX] %L", iClient, "CLIENT_SLAYED", szName2);
  201.  
  202. 	return FMRES_IGNORED;
  203. }
  204.  
  205. ShoopSlayAll(iClient)
  206. {
  207. 	new bool:bSlayed;
  208. 	for(new i=1; i<=g_iMaxplayers; i++)
  209. 	{
  210. 		if(g_bBeingShooped[i] || i == iClient || !is_user_alive(i) || access(i, ADMIN_IMMUNITY))
  211. 			continue;
  212.  
  213. 		ShoopSlay(i);
  214. 		bSlayed = true;
  215. 	}
  216.  
  217. 	if(bSlayed)
  218. 	{
  219. 		new szAuthID[32], szName[32];
  220. 		get_user_authid(iClient, szAuthID, sizeof(szAuthID)-1);
  221. 		get_user_name(iClient, szName, sizeof(szName)-1);
  222.  
  223. 		log_amx("Cmd: ^"%s<%d><%s><>^" megutotte ^"%s<><><>^"", szName, get_user_userid(iClient), szAuthID, "@all");
  224.  
  225. 		show_activity_key("ADMIN_SLAY_1", "ADMIN_SLAY_2", szName, "@all");
  226.  
  227. 		console_print(iClient, "[AMXX] %L", iClient, "CLIENT_SLAYED", "@all");
  228. 	}
  229. 	else
  230. 		console_print(iClient, "[HIBA] Ervenytelen jatekos.");
  231. }
  232.  
  233. ShoopSlay(iVictim)
  234. {
  235. 	// Freeze victim
  236. 	set_pev(iVictim, pev_movetype, MOVETYPE_NOCLIP);
  237. 	set_pev(iVictim, pev_solid, SOLID_NOT);
  238. 	set_pev(iVictim, pev_velocity, Float:{0.0,0.0,0.0});
  239. 	engfunc(EngFunc_SetClientMaxspeed, iVictim, 0.1);
  240.  
  241. 	static Float:flVictimOrigin[3];
  242. 	pev(iVictim, pev_origin, flVictimOrigin);
  243.  
  244. 	static Float:flShoopOrigin[3], bool:bShouldSpawn, bool:bMoveToSpawn;
  245. 	bShouldSpawn = false;
  246. 	bMoveToSpawn = false;
  247.  
  248. 	if(CanShoopSpawn(iVictim, flVictimOrigin, flShoopOrigin))
  249. 		bShouldSpawn = true;
  250. 	else
  251. 	{
  252. 		// See if Shoop can spawn near where the victim spawned, if so move victim
  253. 		if(CanShoopSpawn(iVictim, g_flSpawnOrigin[iVictim], flShoopOrigin))
  254. 		{
  255. 			bMoveToSpawn = true;
  256. 			bShouldSpawn = true;
  257. 		}
  258. 	}
  259.  
  260. 	static iShoop, Float:flAngles[3];
  261. 	if(bShouldSpawn)
  262. 	{
  263. 		// Spawn Shoop
  264. 		iShoop = SpawnShoop(iVictim, flShoopOrigin);
  265. 	}
  266.  
  267. 	if(iShoop)
  268. 	{
  269. 		if(bMoveToSpawn)
  270. 		{
  271. 			VectorCopy_Float(g_flSpawnOrigin[iVictim], flVictimOrigin);
  272. 			engfunc(EngFunc_SetOrigin, iVictim, flVictimOrigin);
  273. 		}
  274.  
  275. 		// Set shoops angles
  276. 		get_angles_to_origin(flShoopOrigin, flVictimOrigin, flAngles);
  277. 		if(flAngles[0] != 0.0)
  278. 			flAngles[1] += 180.0;
  279. 		set_pev(iShoop, pev_angles, flAngles);
  280.  
  281. 		// Make victim look at Shoop
  282. 		g_bBeingShooped[iVictim] = true;
  283.  
  284. 		get_angles_to_origin(flVictimOrigin, flShoopOrigin, flAngles);
  285.  
  286. 		if(flAngles[0] > 250)
  287. 			flAngles[0] = 89.0;
  288. 		else if(flAngles[0] > 70)
  289. 			flAngles[0] = -89.0;
  290.  
  291. 		VectorCopy_Float(flAngles, g_flAngles[iVictim]);
  292. 		set_pev(iVictim, pev_angles, flAngles);
  293. 		set_pev(iVictim, pev_fixangle, 1);
  294.  
  295. 		set_pev(iShoop, pev_nextthink, get_gametime() + 0.1);
  296. 	}
  297. 	else
  298. 	{
  299. 		// Slay player without using Shoop
  300. 		set_pdata_float(iVictim, POWERUP_GOD_OFFSET, 0.0, POWERUP_GOD_LINUX_DIFF); // Remove god in TFC when set with a power up
  301. 		set_pev(iVictim, pev_takedamage, DAMAGE_AIM);
  302. 		ExecuteHam(Ham_TakeDamage, iVictim, 0, 0, 9999.0, 0);
  303. 	}
  304. }
  305.  
  306. public fwd_Player_PreThink(iClient)
  307. {
  308. 	if(g_bBeingShooped[iClient])
  309. 	{
  310. 		set_pev(iClient, pev_angles, g_flAngles[iClient]);
  311. 		set_pev(iClient, pev_fixangle, 1);
  312. 	}
  313. }
  314.  
  315. public fwd_Think(iEnt)
  316. {
  317. 	if(!pev_valid(iEnt))
  318. 		return FMRES_IGNORED;
  319.  
  320. 	if(pev(iEnt, pev_iuser4) == SHOOPS_ID)
  321. 	{
  322. 		static iVictim;
  323. 		iVictim = pev(iEnt, pev_owner);
  324.  
  325. 		static Float:flShoopOrigin[3];
  326. 		pev(iEnt, pev_origin, flShoopOrigin);
  327.  
  328. 		if(!g_bBeingShooped[iVictim])
  329. 		{
  330. 			// Victim is invalid now, Remove Shoop
  331. 			ShoopTeleportEffect(flShoopOrigin);
  332. 			set_pev(iEnt, pev_flags, FL_KILLME);
  333. 			return FMRES_HANDLED;
  334. 		}
  335.  
  336. 		static iThinkNum;
  337. 		iThinkNum = pev(iEnt, pev_iuser3);
  338.  
  339. 		if(!iThinkNum)
  340. 		{
  341. 			// Shoops sound
  342. 			engfunc(EngFunc_EmitSound, iEnt, CHAN_BODY, SHOOP_SOUND, VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
  343. 			set_pev(iEnt, pev_iuser3, iThinkNum+1);
  344. 			set_pev(iEnt, pev_nextthink, get_gametime() + 2.6);
  345. 			return FMRES_HANDLED;
  346. 		}
  347.  
  348. 		if(iThinkNum == NUM_EXPLOSIONS)
  349. 		{
  350. 			// Remove Shoop on next think and slay player
  351. 			set_pdata_float(iVictim, POWERUP_GOD_OFFSET, 0.0, POWERUP_GOD_LINUX_DIFF); // Remove god in TFC when set with a power up
  352. 			set_pev(iVictim, pev_takedamage, DAMAGE_AIM);
  353. 			ExecuteHam(Ham_TakeDamage, iVictim, iEnt, iEnt, 9999.0, 0);
  354.  
  355. 			set_pev(iEnt, pev_iuser3, iThinkNum+1);
  356. 			set_pev(iEnt, pev_nextthink, get_gametime() + 0.5);
  357. 			return FMRES_HANDLED;
  358. 		}
  359. 		else if(iThinkNum > NUM_EXPLOSIONS)
  360. 		{
  361. 			// Remove Shoop
  362. 			ShoopTeleportEffect(flShoopOrigin);
  363. 			set_pev(iEnt, pev_flags, FL_KILLME);
  364. 			g_bBeingShooped[iVictim] = false;
  365. 			return FMRES_HANDLED;
  366. 		}
  367.  
  368. 		static Float:flVictimOrigin[3];
  369. 		pev(iVictim, pev_origin, flVictimOrigin);
  370.  
  371. 		if(iThinkNum == 1)
  372. 		{
  373. 			// Shoot Beam
  374. 			set_pev(iEnt, pev_sequence, 0);
  375. 			ShoopsBeam(flVictimOrigin, flShoopOrigin);
  376. 		}
  377.  
  378. 		// Explosion
  379. 		ShowExplosion(g_iExplosion, 10, 12, flVictimOrigin);
  380.  
  381. 		set_pev(iEnt, pev_iuser3, iThinkNum+1);
  382. 		set_pev(iEnt, pev_nextthink, get_gametime() + 0.1);
  383. 	}
  384.  
  385. 	return FMRES_HANDLED;
  386. }
  387.  
  388. ShoopTeleportEffect(const Float:flOrigin[3])
  389. {
  390. 	static iOrigin[3];
  391. 	iOrigin[0] = floatround(flOrigin[0]);
  392. 	iOrigin[1] = floatround(flOrigin[1]);
  393. 	iOrigin[2] = floatround(flOrigin[2]);
  394.  
  395. 	message_begin(MSG_PVS, SVC_TEMPENTITY, iOrigin);
  396. 	write_byte(TE_TELEPORT);
  397. 	write_coord(iOrigin[0]);
  398. 	write_coord(iOrigin[1]);
  399. 	write_coord(iOrigin[2]);
  400. 	message_end();
  401. }
  402.  
  403. SpawnShoop(iVictim, const Float:flShoopOrigin[3])
  404. {
  405. 	// Spawn Shoop
  406. 	new iShoop = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
  407. 	dllfunc(DLLFunc_Spawn, iShoop);
  408.  
  409. 	set_pev(iShoop, pev_movetype, MOVETYPE_FLY);
  410. 	set_pev(iShoop, pev_solid, SOLID_NOT);
  411.  
  412. 	engfunc(EngFunc_SetModel, iShoop, SHOOP_MODEL);
  413. 	engfunc(EngFunc_SetSize, iShoop, g_flShoopMins, g_flShoopMaxs);
  414. 	engfunc(EngFunc_SetOrigin, iShoop, flShoopOrigin);
  415.  
  416. 	set_pev(iShoop, pev_classname, "Shoop Da Whoop");
  417.  
  418. 	set_pev(iShoop, pev_sequence, 3);
  419. 	set_pev(iShoop, pev_framerate, 1.0);
  420.  
  421. 	set_pev(iShoop, pev_iuser4, SHOOPS_ID);
  422. 	set_pev(iShoop, pev_owner, iVictim);
  423.  
  424. 	ShoopTeleportEffect(flShoopOrigin);
  425.  
  426. 	return iShoop;
  427. }
  428.  
  429. CanShoopSpawn(iVictim, const Float:flVictimOrigin[3], Float:flShoopOrigin[3])
  430. {
  431. 	static iAxisSequence[] = {2,0,1,0,1,2};
  432. 	static iAxisSign[sizeof(iAxisSequence)] = {1,1,1,-1,-1,-1};
  433. 	static bool:bAxisMins[sizeof(iAxisSequence)] = {false,false,false,true,true,true};
  434. 	new iAxis;
  435.  
  436. 	for(new i=0; i<sizeof(iAxisSequence); i++)
  437. 	{
  438. 		iAxis = iAxisSequence[i]
  439.  
  440. 		VectorCopy_Float(flVictimOrigin, flShoopOrigin);
  441. 		flShoopOrigin[iAxis] += (DISTANCE_SHOOP + g_flShoopMaxs[iAxis] + 1) * iAxisSign[i]
  442. 		if(IsShoopsHullVacant(iVictim, flVictimOrigin, flShoopOrigin, iAxis, bAxisMins[i]))
  443. 			return true;
  444. 	}
  445.  
  446. 	return false;
  447. }
  448.  
  449. ShoopsBeam(const Float:flStartOrigin[3], const Float:flEndOrigin[3])
  450. {
  451. 	static iStartOrigin[3];
  452. 	iStartOrigin[0] = floatround(flStartOrigin[0]);
  453. 	iStartOrigin[1] = floatround(flStartOrigin[1]);
  454. 	iStartOrigin[2] = floatround(flStartOrigin[2]);
  455.  
  456. 	message_begin(MSG_PVS, SVC_TEMPENTITY, iStartOrigin);
  457. 	write_byte(TE_BEAMPOINTS);
  458. 	write_coord(iStartOrigin[0]);
  459. 	write_coord(iStartOrigin[1]);
  460. 	write_coord(iStartOrigin[2]);
  461. 	write_coord(floatround(flEndOrigin[0]));
  462. 	write_coord(floatround(flEndOrigin[1]));
  463. 	write_coord(floatround(flEndOrigin[2]));
  464. 	write_short(g_iBeam);
  465. 	write_byte(1); // starting frame
  466. 	write_byte(1); // frame rate in 0.1's
  467. 	write_byte(NUM_EXPLOSIONS); // life in 0.1's
  468. 	write_byte(210); // line width in 0.1's
  469. 	write_byte(1); // noise amplitude in 0.01's
  470. 	write_byte(12); // r
  471. 	write_byte(109); // g
  472. 	write_byte(190); // b
  473. 	write_byte(255); // brightness
  474. 	write_byte(50); // scroll speed
  475. 	message_end();
  476. }
  477.  
  478. IsShoopsHullVacant(iVictim, const Float:flVictimOrigin[3], Float:flShoopOrigin[3], iAxis, bool:bIsMins)
  479. {
  480. 	TraceLine_GetEndOrigin(flVictimOrigin, iVictim, flShoopOrigin);
  481.  
  482. 	new Float:flDistance;
  483. 	if(bIsMins)
  484. 		flShoopOrigin[iAxis] -= g_flShoopMins[iAxis];
  485. 	else
  486. 		flShoopOrigin[iAxis] -= g_flShoopMaxs[iAxis];
  487. 	flDistance = get_distance_f(flVictimOrigin, flShoopOrigin);
  488.  
  489. 	if(flDistance < DISTANCE_SHOOP)
  490. 		return false;
  491.  
  492. 	//if(!IsBBoxHullVacant(flShoopOrigin, g_flShoopMins, g_flShoopMaxs, iVictim))
  493. 	//	return false;
  494.  
  495. 	engfunc(EngFunc_TraceHull, flShoopOrigin, flShoopOrigin, 0, HULL_HEAD, iVictim, 0);
  496. 	if(!get_tr2(0, TR_InOpen))
  497. 		return false;
  498.  
  499. 	return true;
  500. }
  501.  
  502. stock get_angles_to_origin(const Float:flFromOrigin[3], const Float:flToOrigin[3], Float:flAngles[3])
  503. {
  504. 	flAngles[0] = flToOrigin[0] - flFromOrigin[0];
  505. 	flAngles[1] = flToOrigin[1] - flFromOrigin[1];
  506. 	flAngles[2] = flToOrigin[2] - flFromOrigin[2];
  507. 	engfunc(EngFunc_VecToAngles, flAngles, flAngles);
  508. }
  509.  
  510. stock IsBBoxHullVacant(const Float:flOrigin[3], const Float:flMins[3], const Float:flMaxs[3], iSkip)
  511. {
  512. 	new Float:flVerticesOrigins[8][3], i;
  513.  
  514. 	for(i=0; i<sizeof(flVerticesOrigins); i++)
  515. 	{
  516. 		flVerticesOrigins[i][0] = flOrigin[0];
  517. 		flVerticesOrigins[i][1] = flOrigin[1];
  518. 		flVerticesOrigins[i][2] = flOrigin[2];
  519. 	}
  520.  
  521. 	// Get the bottom vertices
  522. 	flVerticesOrigins[0][0] += flMins[0];
  523. 	flVerticesOrigins[0][1] += flMaxs[1];
  524. 	flVerticesOrigins[0][2] += flMins[2];
  525.  
  526. 	flVerticesOrigins[1][0] += flMaxs[0];
  527. 	flVerticesOrigins[1][1] += flMaxs[1];
  528. 	flVerticesOrigins[1][2] += flMins[2];
  529.  
  530. 	flVerticesOrigins[2][0] += flMaxs[0];
  531. 	flVerticesOrigins[2][1] += flMins[1];
  532. 	flVerticesOrigins[2][2] += flMins[2];
  533.  
  534. 	flVerticesOrigins[3][0] += flMins[0];
  535. 	flVerticesOrigins[3][1] += flMins[1];
  536. 	flVerticesOrigins[3][2] += flMins[2];
  537.  
  538. 	// Get the top vertices
  539. 	flVerticesOrigins[4][0] += flMins[0];
  540. 	flVerticesOrigins[4][1] += flMaxs[1];
  541. 	flVerticesOrigins[4][2] += flMaxs[2];
  542.  
  543. 	flVerticesOrigins[5][0] += flMaxs[0];
  544. 	flVerticesOrigins[5][1] += flMaxs[1];
  545. 	flVerticesOrigins[5][2] += flMaxs[2];
  546.  
  547. 	flVerticesOrigins[6][0] += flMaxs[0];
  548. 	flVerticesOrigins[6][1] += flMins[1];
  549. 	flVerticesOrigins[6][2] += flMaxs[2];
  550.  
  551. 	flVerticesOrigins[7][0] += flMins[0];
  552. 	flVerticesOrigins[7][1] += flMins[1];
  553. 	flVerticesOrigins[7][2] += flMaxs[2];
  554.  
  555. 	new Float:flFractionTotal, Float:flFraction;
  556. 	// Trace lines to make edges on the bottom face
  557. 	for(i=0; i<=3; i++)
  558. 	{
  559. 		if(i == 3)
  560. 			engfunc(EngFunc_TraceLine, flVerticesOrigins[i], flVerticesOrigins[0], 0, iSkip, 0);
  561. 		else
  562. 			engfunc(EngFunc_TraceLine, flVerticesOrigins[i], flVerticesOrigins[i+1], 0, iSkip, 0);
  563.  
  564. 		get_tr2(0, TR_flFraction, flFraction);
  565. 		flFractionTotal += flFraction;
  566. 	}
  567.  
  568. 	// Trace lines to make edges on the top face
  569. 	for(i=4; i<=7; i++)
  570. 	{
  571. 		if(i == 7)
  572. 			engfunc(EngFunc_TraceLine, flVerticesOrigins[i], flVerticesOrigins[4], 0, iSkip, 0);
  573. 		else
  574. 			engfunc(EngFunc_TraceLine, flVerticesOrigins[i], flVerticesOrigins[i+1], 0, iSkip, 0);
  575.  
  576. 		get_tr2(0, TR_flFraction, flFraction);
  577. 		flFractionTotal += flFraction;
  578. 	}
  579.  
  580. 	// Trace 4 lines to make the edges going from bottom vertices to top
  581. 	for(i=0; i<=3; i++)
  582. 	{
  583. 		engfunc(EngFunc_TraceLine, flVerticesOrigins[i], flVerticesOrigins[i+4], 0, iSkip, 0);
  584. 		get_tr2(0, TR_flFraction, flFraction);
  585. 		flFractionTotal += flFraction;
  586. 	}
  587.  
  588. 	if(flFractionTotal < 12)
  589. 		return false;
  590.  
  591. 	return true;
  592. }
  593.  
  594. stock VectorCopy_Float(const Float:flVecOriginal[3], Float:flVecCopy[3])
  595. {
  596. 	flVecCopy[0] = flVecOriginal[0];
  597. 	flVecCopy[1] = flVecOriginal[1];
  598. 	flVecCopy[2] = flVecOriginal[2];
  599. }
  600.  
  601. stock TraceLine_GetEndOrigin(const Float:flStartOrigin[3], iSkip, Float:flEndOrigin[3])
  602. {
  603. 	engfunc(EngFunc_TraceLine, flStartOrigin, flEndOrigin, 0, iSkip, 0);
  604. 	get_tr2(0, TR_vecEndPos, flEndOrigin);
  605. }
  606.  
  607. stock ShowExplosion(iSprite, iScale, iFrameRate, const Float:flOrigin[3])
  608. {
  609. 	static iOrigin[3];
  610. 	iOrigin[0] = floatround(flOrigin[0]);
  611. 	iOrigin[1] = floatround(flOrigin[1]);
  612. 	iOrigin[2] = floatround(flOrigin[2]);
  613.  
  614. 	message_begin(MSG_PVS, SVC_TEMPENTITY, iOrigin);
  615. 	write_byte(TE_EXPLOSION);
  616. 	write_coord(iOrigin[0]);
  617. 	write_coord(iOrigin[1]);
  618. 	write_coord(iOrigin[2]);
  619. 	write_short(iSprite);
  620. 	write_byte(iScale);
  621. 	write_byte(iFrameRate);
  622. 	write_byte(0);
  623. 	message_end();
  624. }