API tools faq
paste
Guest User

Untitled

a guest
May 21st, 2013
45
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 40.39 KB | None | 0 0
raw download clone embed print report
  1. #include <amxmodx>
  2. #include <engine>
  3. #include <fakemeta>
  4. #include <fakemeta_util>
  5. #include <hamsandwich>
  6.  
  7. #define PLUGIN "Mad Machine"
  8. #define VERSION "1.0"
  9. #define AUTHOR "Dias"
  10.  
  11. #define MM_MODEL "models/mad_machine/mad_machine.mdl"
  12. #define MM_CLASSNAME "mad_machine"
  13.  
  14. #define MM_HEALTH 10000.0
  15. #define MM_MOVESPEED 150.0
  16. #define MM_ATTACK_RANGE 300.0
  17. #define HEALTH_OFFSET 10000.0
  18.  
  19. // Start Origin
  20. #define STARTORIGIN_X 0.0
  21. #define STARTORIGIN_Y 0.0
  22. #define STARTORIGIN_Z 100.0
  23.  
  24. // Attack 1
  25. #define ATTACK1_RADIUS 300.0
  26. #define ATTACK1_DAMAGE random_float(7.5, 12.5)
  27.  
  28. // Attack 2
  29. #define ATTACK2_RADIUS 300.0
  30. #define ATTACK2_DAMAGE random_float(10.0, 17.0)
  31.  
  32. // Laser
  33. #define LASER_LIGHTDOT_SPR "sprites/3dmflared.spr"
  34. #define LASER_DAMAGE random_float(10.0, 15.0)
  35.  
  36. // Flame
  37. #define FLAME_SPR "sprites/mm_fire.spr"
  38. #define FLAME_DAMAGE random_float(25.0, 50.0)
  39.  
  40. #define FIRE_CLASSNAME "fire"
  41. #define FIRE_SPEED 1000.0
  42.  
  43. // Task
  44. #define TASK_ATTACK 1962+100
  45. #define TASK_ATTACK_LASER 1962+200
  46. #define TASK_ATTACK_LASERING 1962+300
  47. #define TASK_ATTACK_LASERFLAME 1962+600
  48. #define TASK_ATTACK_FLAME 1962+400
  49. #define TASK_ATTACK_FLAMING 1962+500
  50.  
  51. //CountDown
  52. #define TASK_COUNTDOWN 1962+1000
  53.  
  54. enum
  55. {
  56. MM_ANIM_DUMMY = 0,
  57. MM_ANIM_IDLE,
  58. MM_ANIM_WALK,
  59. MM_ANIM_RUN,
  60. MM_ANIM_ATTACK1,
  61. MM_ANIM_ATTACK2,
  62. MM_ANIM_ATTACK_FLAME,
  63. MM_ANIM_ATTACK_LASER,
  64. MM_ANIM_JUMP_START,
  65. MM_ANIM_JUMP_LOOP,
  66. MM_ANIM_JUMP_END,
  67. MM_ANIM_SCENE01,
  68. MM_ANIM_DEATH
  69. }
  70.  
  71. enum
  72. {
  73. MM_STATE_IDLE = 0,
  74. MM_STATE_SEARCHING_ENEMY,
  75. MM_STATE_CHASE_ENEMY,
  76. MM_STATE_ATTACK_NORMAL,
  77. MM_STATE_ATTACK_FLAME,
  78. MM_STATE_ATTACK_LASER,
  79. MM_STATE_JUMP_START,
  80. MM_STATE_JUMP_LOOP,
  81. MM_STATE_JUMP_END,
  82. MM_STATE_SCENE01,
  83. MM_STATE_DEATH
  84. }
  85.  
  86. #define MAX_SOUND 10
  87. new const MM_Sound[MAX_SOUND][] =
  88. {
  89. "mad_machine/mm_walk.wav",
  90. "mad_machine/mm_attack1.wav",
  91. "mad_machine/mm_attack2.wav",
  92. "mad_machine/mm_attack_flame.wav",
  93. "mad_machine/mm_attack_flame1.wav",
  94. "mad_machine/mm_lazer.wav",
  95. "mad_machine/mm_attack_jump1.wav",
  96. "mad_machine/mm_attack_jump3.wav",
  97. "mad_machine/mm_scene03.wav",
  98. "mad_machine/mm_death.wav"
  99. }
  100.  
  101. enum
  102. {
  103. MM_SOUND_WALK = 0,
  104. MM_SOUND_ATTACK1,
  105. MM_SOUND_ATTACK2,
  106. MM_SOUND_ATTACK_FLAME,
  107. MM_SOUND_FLAMING,
  108. MM_SOUND_ATTACK_LASER,
  109. MM_SOUND_JUMP_BEGIN,
  110. MM_SOUND_JUMP_END,
  111. MM_SOUND_SCENE03,
  112. MM_SOUND_DEATH
  113. }
  114.  
  115.  
  116. const pev_state = pev_iuser1
  117. const pev_time = pev_fuser1
  118. const pev_time2 = pev_fuser2
  119.  
  120. new g_MM_Ent, g_LC_Ent, g_Reg_Ham, LASER_LIGHTDOT_SPRID
  121. new g_Msg_ScreenShake, g_MaxPlayers
  122. new CountDown
  123.  
  124. new BeamSpr_Id, m_iBlood[2]
  125. new Float:StartOrigin[3]
  126.  
  127. #define FIGHT_MUSIC "cso_angra/bg/Scenario_Normal.mp3"
  128.  
  129. public plugin_init()
  130. {
  131. register_plugin(PLUGIN, VERSION, AUTHOR)
  132.  
  133. register_think(MM_CLASSNAME, "fw_MM_Think")
  134. register_think("AutoRemove", "fw_AM_Think")
  135. register_think("LaserControl", "fw_LC_Think")
  136. register_think("FlameControl", "fw_FC_Think")
  137.  
  138. register_think(FIRE_CLASSNAME, "fw_Fire_Think")
  139. register_touch(FIRE_CLASSNAME, "*", "fw_Fire_Touch")
  140.  
  141. g_Msg_ScreenShake = get_user_msgid("ScreenShake")
  142. g_MaxPlayers = get_maxplayers()
  143.  
  144. register_clcmd("say /get", "get_origin")
  145. register_clcmd("say /mm", "Create_MadMachine")
  146. }
  147.  
  148. public plugin_precache()
  149. {
  150. engfunc(EngFunc_PrecacheModel, MM_MODEL)
  151.  
  152. for(new i = 0; i < sizeof(MM_Sound); i++)
  153. engfunc(EngFunc_PrecacheSound, MM_Sound[i])
  154.  
  155. BeamSpr_Id = engfunc(EngFunc_PrecacheModel, "sprites/laserbeam.spr")
  156.  
  157. m_iBlood[0] = precache_model("sprites/blood.spr")
  158. m_iBlood[1] = precache_model("sprites/bloodspray.spr")
  159.  
  160. LASER_LIGHTDOT_SPRID = engfunc(EngFunc_PrecacheModel, LASER_LIGHTDOT_SPR)
  161. engfunc(EngFunc_PrecacheModel, FLAME_SPR)
  162. }
  163.  
  164. public get_origin(id)
  165. {
  166. static Float:Origin[3]
  167. pev(id, pev_origin, StartOrigin)
  168. Origin = StartOrigin
  169.  
  170. client_print(id, print_console, "%f %f %f", Origin[0], Origin[1], Origin[2])
  171. }
  172.  
  173. public Create_MadMachine(id)
  174. {
  175. new CountDown = 10
  176. set_task( 1.0, "StartMachine", TASK_COUNTDOWN, _, _, "a", CountDown + 1 );
  177. }
  178.  
  179. public StartMachine()
  180. {
  181. CountDown--
  182. if(CountDown > 0)
  183. {
  184. set_hudmessage(0, 0, 0, -1.0, 0.24, 0, 6.0, 1.0)
  185. show_hudmessage(0, "Game Starts In^n%i", CountDown)
  186.  
  187. new szTime[20];
  188. num_to_word(CountDown, szTime, charsmax(szTime));
  189.  
  190. client_cmd(0, "spk ^"vox/%s.wav^"", szTime);
  191. }
  192.  
  193. else
  194. {
  195. set_hudmessage(0, 0, 0, -1.0, 0.24, 0, 6.0, 12.0)
  196. show_hudmessage(0, "Time Is Over!!")
  197.  
  198. if(pev_valid(g_MM_Ent))
  199. engfunc(EngFunc_RemoveEntity, g_MM_Ent)
  200.  
  201. static MM; MM = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
  202. if(!pev_valid(MM)) return
  203.  
  204. g_MM_Ent = MM
  205.  
  206. // Set Origin & Angles
  207. StartOrigin[0] = STARTORIGIN_X; StartOrigin[1] = STARTORIGIN_Y; StartOrigin[2] = STARTORIGIN_Z
  208. set_pev(MM, pev_origin, StartOrigin)
  209.  
  210. // Set Config
  211. set_pev(MM, pev_classname, MM_CLASSNAME)
  212. engfunc(EngFunc_SetModel, MM, MM_MODEL)
  213.  
  214. set_pev(MM, pev_gamestate, 1)
  215. set_pev(MM, pev_solid, SOLID_BBOX)
  216. set_pev(MM, pev_movetype, MOVETYPE_NONE)
  217.  
  218. // Set Size
  219. new Float:maxs[3] = {72.0, 72.0, 172.0}
  220. new Float:mins[3] = {-72.0, -72.0, 22.0}
  221. engfunc(EngFunc_SetSize, MM, mins, maxs)
  222.  
  223. // Set Life
  224. set_pev(MM, pev_takedamage, DAMAGE_YES)
  225. set_pev(MM, pev_health, HEALTH_OFFSET + MM_HEALTH)
  226.  
  227. // Set Config 2
  228. set_entity_anim(MM, MM_ANIM_IDLE, 1.0, 1)
  229. set_pev(MM, pev_state, MM_STATE_IDLE)
  230.  
  231. set_pev(MM, pev_nextthink, get_gametime() + 3.0)
  232. engfunc(EngFunc_DropToFloor, MM)
  233.  
  234. if(!g_Reg_Ham)
  235. {
  236. g_Reg_Ham = 1
  237. RegisterHamFromEntity(Ham_TraceAttack, MM, "fw_MM_TraceAttack")
  238. }
  239.  
  240. PlaySound(0, FIGHT_MUSIC)
  241.  
  242. remove_task(TASK_COUNTDOWN)
  243. }
  244. }
  245.  
  246. public MM_Death(ent)
  247. {
  248. if(!pev_valid(ent))
  249. return
  250.  
  251. remove_task(ent+TASK_ATTACK)
  252. remove_task(ent+TASK_ATTACK_LASER)
  253. remove_task(ent+TASK_ATTACK_LASERING)
  254. remove_task(ent+TASK_ATTACK_LASERFLAME)
  255. remove_task(ent+TASK_ATTACK_FLAME)
  256. remove_task(ent+TASK_ATTACK_FLAMING)
  257.  
  258. Remove_LaserControl()
  259.  
  260. set_pev(ent, pev_state, MM_STATE_DEATH)
  261.  
  262. set_pev(ent, pev_solid, SOLID_NOT)
  263. set_pev(ent, pev_movetype, MOVETYPE_NONE)
  264.  
  265. set_task(0.1, "MM_Death2", ent)
  266. }
  267.  
  268. public MM_Death2(ent)
  269. {
  270. set_task(1.5, "MM_Death_Sound", ent)
  271. set_entity_anim(ent, MM_ANIM_DEATH, 1.0, 1)
  272. }
  273.  
  274. public MM_Death_Sound(ent)
  275. {
  276. EmitSound(ent, MM_Sound[MM_SOUND_DEATH], CHAN_BODY)
  277. }
  278.  
  279. public fw_MM_Think(ent)
  280. {
  281. if(!pev_valid(ent))
  282. return
  283. if(pev(ent, pev_state) == MM_STATE_DEATH)
  284. return
  285. if((pev(ent, pev_health) - HEALTH_OFFSET) <= 0.0)
  286. {
  287. MM_Death(ent)
  288. return
  289. }
  290.  
  291. // Set Next Think
  292. set_pev(ent, pev_nextthink, get_gametime() + 0.01)
  293.  
  294. if(get_gametime() - 7.0 > pev(ent, pev_fuser4))
  295. {
  296. static RandomNum; RandomNum = random_num(0, 1)
  297.  
  298. if(RandomNum == 1)
  299. MM_Attack_Laser(ent)
  300. else
  301. MM_Attack_Flame(ent)
  302.  
  303. set_pev(ent, pev_fuser4, get_gametime())
  304. }
  305.  
  306. switch(pev(ent, pev_state))
  307. {
  308. case MM_STATE_IDLE:
  309. {
  310. if(get_gametime() - 12.0 > pev(ent, pev_time))
  311. {
  312. set_entity_anim(ent, MM_ANIM_IDLE, 1.0, 1)
  313. set_pev(ent, pev_time, get_gametime())
  314. }
  315. if(get_gametime() - 1.0 > pev(ent, pev_time2))
  316. {
  317. set_pev(ent, pev_state, MM_STATE_SEARCHING_ENEMY)
  318. set_pev(ent, pev_time2, get_gametime())
  319. }
  320. }
  321. case MM_STATE_SEARCHING_ENEMY:
  322. {
  323. static Victim;
  324. Victim = FindClosetEnemy(ent, 1)
  325.  
  326. if(is_user_alive(Victim))
  327. {
  328. set_pev(ent, pev_enemy, Victim)
  329. Random_AttackMethod(ent)
  330. } else {
  331. set_pev(ent, pev_enemy, 0)
  332. set_pev(ent, pev_state, MM_STATE_IDLE)
  333. }
  334. }
  335. case MM_STATE_CHASE_ENEMY:
  336. {
  337. static Enemy; Enemy = pev(ent, pev_enemy)
  338. static Float:EnemyOrigin[3]
  339. pev(Enemy, pev_origin, EnemyOrigin)
  340.  
  341. if(is_user_alive(Enemy))
  342. {
  343. if(entity_range(Enemy, ent) <= floatround(MM_ATTACK_RANGE))
  344. {
  345. set_pev(ent, pev_state, MM_STATE_ATTACK_NORMAL)
  346. set_entity_anim(ent, MM_ANIM_IDLE, 1.0, 1)
  347. MM_Aim_To(ent, EnemyOrigin)
  348.  
  349. if(random_num(0, 1) == 1)
  350. set_task(0.1, "MM_StartAttack1", ent+TASK_ATTACK)
  351. else
  352. set_task(0.1, "MM_StartAttack2", ent+TASK_ATTACK)
  353. } else {
  354. if(pev(ent, pev_movetype) == MOVETYPE_PUSHSTEP)
  355. {
  356. static Float:OriginAhead[3]
  357. get_position(ent, 300.0, 0.0, 0.0, OriginAhead)
  358.  
  359. MM_Aim_To(ent, EnemyOrigin)
  360. hook_ent2(ent, OriginAhead, MM_MOVESPEED)
  361.  
  362. set_entity_anim(ent, MM_ANIM_RUN, 1.0, 0)
  363. if(get_gametime() - 1.0 > pev(ent, pev_time))
  364. {
  365. EmitSound(ent, MM_Sound[MM_SOUND_WALK], CHAN_ITEM)
  366. set_pev(ent, pev_time, get_gametime())
  367. }
  368. } else {
  369. set_pev(ent, pev_movetype, MOVETYPE_PUSHSTEP)
  370. }
  371. }
  372. } else {
  373. set_pev(ent, pev_state, MM_STATE_SEARCHING_ENEMY)
  374. }
  375. }
  376. }
  377. }
  378.  
  379. public fw_AM_Think(ent)
  380. {
  381. if(!pev_valid(ent))
  382. return
  383.  
  384. engfunc(EngFunc_RemoveEntity, ent)
  385. }
  386.  
  387. public fw_MM_TraceAttack(Ent, Attacker, Float:Damage, Float:Dir[3], ptr, DamageType)
  388. {
  389. if(!is_valid_ent(Ent))
  390. return
  391.  
  392. static Classname[32]
  393. pev(Ent, pev_classname, Classname, charsmax(Classname))
  394.  
  395. if(!equal(Classname, MM_CLASSNAME))
  396. return
  397.  
  398. static Float:EndPos[3]
  399. get_tr2(ptr, TR_vecEndPos, EndPos)
  400.  
  401. create_blood(EndPos)
  402. if(is_user_alive(Attacker)) client_print(Attacker, print_center, "Mad Machine's Health: %i", floatround(pev(Ent, pev_health) - HEALTH_OFFSET))
  403. }
  404.  
  405. public Random_AttackMethod(ent)
  406. {
  407. static RandomNum; RandomNum = random_num(1, 99)
  408.  
  409. if(RandomNum >= 0 && RandomNum <= 60)
  410. set_pev(ent, pev_state, MM_STATE_CHASE_ENEMY)
  411. else if(RandomNum >= 61 && RandomNum <= 80)
  412. MM_Attack_Laser(ent)
  413. else if(RandomNum >= 81 && RandomNum <= 100)
  414. MM_Attack_Flame(ent)
  415. else
  416. Random_AttackMethod(ent)
  417. }
  418.  
  419. public MM_StartAttack1(ent)
  420. {
  421. ent -= TASK_ATTACK
  422. if(!pev_valid(ent))
  423. return
  424.  
  425. set_pev(ent, pev_movetype, MOVETYPE_NONE)
  426. set_pev(ent, pev_velocity, {0.0, 0.0, 0.0})
  427.  
  428. set_task(0.1, "MM_StartAttack1_2", ent+TASK_ATTACK)
  429. }
  430.  
  431. public MM_StartAttack2(ent)
  432. {
  433. ent -= TASK_ATTACK
  434. if(!pev_valid(ent))
  435. return
  436.  
  437. set_pev(ent, pev_movetype, MOVETYPE_NONE)
  438. set_pev(ent, pev_velocity, {0.0, 0.0, 0.0})
  439.  
  440. set_task(0.1, "MM_StartAttack2_2", ent+TASK_ATTACK)
  441. }
  442.  
  443. public MM_StartAttack1_2(ent)
  444. {
  445. ent -= TASK_ATTACK
  446. if(!pev_valid(ent))
  447. return
  448.  
  449. set_entity_anim(ent, MM_ANIM_ATTACK1, 1.0, 1)
  450. set_task(0.5, "Attack1_Sound", ent)
  451.  
  452. set_task(1.3, "MM_CheckAttack1", ent+TASK_ATTACK)
  453. set_task(3.3, "MM_DoneAttack", ent+TASK_ATTACK)
  454. }
  455.  
  456. public Attack1_Sound(ent)
  457. {
  458. EmitSound(ent, MM_Sound[MM_SOUND_ATTACK1], CHAN_BODY)
  459. }
  460.  
  461. public MM_StartAttack2_2(ent)
  462. {
  463. ent -= TASK_ATTACK
  464. if(!pev_valid(ent))
  465. return
  466.  
  467. set_entity_anim(ent, MM_ANIM_ATTACK2, 1.0, 1)
  468. EmitSound(ent, MM_Sound[MM_SOUND_ATTACK2], CHAN_BODY)
  469.  
  470. set_task(1.0, "MM_Attack2_Effect", ent+TASK_ATTACK)
  471. set_task(1.0, "MM_CheckAttack2", ent+TASK_ATTACK)
  472. set_task(3.3, "MM_DoneAttack", ent+TASK_ATTACK)
  473. }
  474.  
  475. public MM_Attack2_Effect(ent)
  476. {
  477. ent -= TASK_ATTACK
  478. if(!pev_valid(ent))
  479. return
  480.  
  481. // Not Found
  482. }
  483.  
  484. public MM_CheckAttack1(ent)
  485. {
  486. ent -= TASK_ATTACK
  487. if(!pev_valid(ent))
  488. return
  489.  
  490. static Float:CheckPosition[3], Float:VicOrigin[3]
  491. get_position(ent, 200.0, 80.0, 0.0, CheckPosition)
  492.  
  493. for(new i = 0; i < g_MaxPlayers; i++)
  494. {
  495. if(!is_user_alive(i))
  496. continue
  497.  
  498. pev(i, pev_origin, VicOrigin)
  499. if(get_distance_f(VicOrigin, CheckPosition) > ATTACK1_RADIUS)
  500. continue
  501.  
  502. ExecuteHamB(Ham_TakeDamage, i, 0, i, ATTACK1_DAMAGE, DMG_BLAST)
  503.  
  504. static Float:Velocity[3]
  505. Velocity[0] = random_float(100.0, 200.0)
  506. Velocity[1] = random_float(100.0, 200.0)
  507. Velocity[2] = random_float(100.0, 400.0)
  508. set_pev(i, pev_velocity, Velocity)
  509.  
  510. Make_PlayerShake(i)
  511. }
  512. }
  513.  
  514. public MM_CheckAttack2(ent)
  515. {
  516. ent -= TASK_ATTACK
  517. if(!pev_valid(ent))
  518. return
  519.  
  520. static Float:CheckPosition[3], Float:VicOrigin[3]
  521. pev(ent, pev_origin, CheckPosition)
  522.  
  523. for(new i = 0; i < g_MaxPlayers; i++)
  524. {
  525. if(!is_user_alive(i))
  526. continue
  527.  
  528. pev(i, pev_origin, VicOrigin)
  529. if(get_distance_f(VicOrigin, CheckPosition) > ATTACK2_RADIUS)
  530. continue
  531.  
  532. ExecuteHamB(Ham_TakeDamage, i, 0, i, ATTACK2_DAMAGE, DMG_BLAST)
  533. Make_PlayerShake(i)
  534. }
  535. }
  536.  
  537. public MM_DoneAttack(ent)
  538. {
  539. ent -= TASK_ATTACK
  540. if(!pev_valid(ent))
  541. return
  542.  
  543. set_pev(ent, pev_movetype, MOVETYPE_PUSHSTEP)
  544. set_pev(ent, pev_state, MM_STATE_CHASE_ENEMY)
  545. }
  546.  
  547. public MM_Attack_Laser(ent)
  548. {
  549. if((pev(ent, pev_state) == MM_STATE_CHASE_ENEMY || pev(ent, pev_state) == MM_STATE_IDLE)/* && is_user_alive(pev(ent, pev_enemy))*/)
  550. {
  551. set_pev(ent, pev_state, MM_STATE_ATTACK_LASER)
  552. set_pev(ent, pev_movetype, MOVETYPE_NONE)
  553. set_pev(ent, pev_velocity, {0.0, 0.0, 0.0})
  554.  
  555. set_task(0.1, "MM_Start_Attack_Laser", ent+TASK_ATTACK_LASER)
  556. }
  557. }
  558.  
  559. public MM_Start_Attack_Laser(ent)
  560. {
  561. ent -= TASK_ATTACK_LASER
  562. if(!pev_valid(ent))
  563. return
  564.  
  565. set_entity_anim(ent, MM_ANIM_ATTACK_LASER, 1.0, 1)
  566. EmitSound(ent, MM_Sound[MM_SOUND_ATTACK_FLAME], CHAN_BODY)
  567. set_task(1.35, "MM_StartLaser", ent+TASK_ATTACK_LASER)
  568. set_task(8.6, "MM_Done_Attack_Laser_AND_Flame", ent+TASK_ATTACK_LASERFLAME)
  569. }
  570.  
  571. public MM_StartLaser(ent)
  572. {
  573. ent -= TASK_ATTACK_LASER
  574. if(!pev_valid(ent))
  575. return
  576.  
  577. PlaySound(0, MM_Sound[MM_SOUND_ATTACK_LASER])
  578. Create_LaserControl(ent)
  579. set_task(3.3, "Stop_Laser", ent+TASK_ATTACK_LASER)
  580. }
  581.  
  582. public Create_LaserControl(ent)
  583. {
  584. static Ent; Ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
  585. if(!pev_valid(Ent))
  586. return
  587.  
  588. g_LC_Ent = Ent
  589.  
  590. static Float:Vector[3]
  591.  
  592. pev(ent, pev_origin, Vector); set_pev(Ent, pev_origin, Vector)
  593. pev(ent, pev_angles, Vector); set_pev(Ent, pev_angles, Vector)
  594.  
  595. // Set Config
  596. set_pev(Ent, pev_classname, "LaserControl")
  597. engfunc(EngFunc_SetModel, Ent, MM_MODEL)
  598.  
  599. set_pev(Ent, pev_gamestate, 1)
  600. set_pev(Ent, pev_solid, SOLID_NOT)
  601. set_pev(Ent, pev_movetype, MOVETYPE_NONE)
  602.  
  603. set_pev(Ent, pev_iuser1, 1)
  604. set_pev(Ent, pev_fuser1, Vector[1])
  605.  
  606. // Set Size
  607. new Float:maxs[3] = {72.0, 72.0, 172.0}
  608. new Float:mins[3] = {-72.0, -72.0, 22.0}
  609. engfunc(EngFunc_SetSize, Ent, mins, maxs)
  610.  
  611. fm_set_rendering(Ent, kRenderFxNone, 0, 0, 0, kRenderTransAlpha, 0)
  612.  
  613. engfunc(EngFunc_DropToFloor, Ent)
  614. set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
  615.  
  616. set_task(0.01, "Create_Laser2", Ent+TASK_ATTACK_LASERING)
  617. set_task(1.35, "Rotate_Right", Ent+TASK_ATTACK_LASERFLAME)
  618. }
  619.  
  620. public Rotate_Right(ent)
  621. {
  622. ent -= TASK_ATTACK_LASERFLAME
  623. if(!pev_valid(ent))
  624. return
  625.  
  626. set_pev(ent, pev_iuser1, 2)
  627. }
  628.  
  629. public Remove_LaserControl()
  630. {
  631. remove_task(g_LC_Ent+TASK_ATTACK_FLAMING)
  632. remove_task(g_LC_Ent+TASK_ATTACK_LASERING)
  633.  
  634. if(pev_valid(g_LC_Ent)) engfunc(EngFunc_RemoveEntity, g_LC_Ent)
  635. }
  636.  
  637. public Create_Laser(ent)
  638. {
  639. ent -= TASK_ATTACK_LASERING
  640. if(!pev_valid(ent))
  641. return
  642.  
  643. static Float:Origin[3], Float:TargetOrigin[3]
  644. if(pev(ent, pev_iuser1) == 1)
  645. get_position(ent, 130.0, 100.0, 50.0, Origin)
  646. else
  647. get_position(ent, 120.0, 100.0, 50.0, Origin)
  648.  
  649. get_position(ent, 2000.0, 100.0, 0.0, TargetOrigin)
  650.  
  651. static Trace_Result; Trace_Result = 0
  652. engfunc(EngFunc_TraceLine, Origin, TargetOrigin, DONT_IGNORE_MONSTERS, g_MM_Ent, Trace_Result)
  653.  
  654. static Float:EndPos[3]
  655. get_tr2(Trace_Result, TR_vecEndPos, EndPos)
  656.  
  657. EndPos[2] /= 1.5
  658.  
  659. message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
  660. write_byte(TE_BEAMPOINTS)
  661. engfunc(EngFunc_WriteCoord, Origin[0])
  662. engfunc(EngFunc_WriteCoord, Origin[1])
  663. engfunc(EngFunc_WriteCoord, Origin[2])
  664. engfunc(EngFunc_WriteCoord, EndPos[0])
  665. engfunc(EngFunc_WriteCoord, EndPos[1])
  666. engfunc(EngFunc_WriteCoord, EndPos[2])
  667. write_short(BeamSpr_Id) // sprite index
  668. write_byte(1) // starting frame
  669. write_byte(1) // frame rate in 0.1's
  670. write_byte(5) // life in 0.1's
  671. write_byte(70) // line width in 0.1's
  672. write_byte(0) // noise amplitude in 0.01's
  673. write_byte(255) // Red
  674. write_byte(0) // Green
  675. write_byte(0) // Blue
  676. write_byte(255) // brightness
  677. write_byte(0) // scroll speed in 0.1's
  678. message_end()
  679.  
  680. message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
  681. write_byte(TE_BEAMPOINTS)
  682. engfunc(EngFunc_WriteCoord, Origin[0])
  683. engfunc(EngFunc_WriteCoord, Origin[1])
  684. engfunc(EngFunc_WriteCoord, Origin[2])
  685. engfunc(EngFunc_WriteCoord, EndPos[0])
  686. engfunc(EngFunc_WriteCoord, EndPos[1])
  687. engfunc(EngFunc_WriteCoord, EndPos[2])
  688. write_short(BeamSpr_Id) // sprite index
  689. write_byte(1) // starting frame
  690. write_byte(1) // frame rate in 0.1's
  691. write_byte(5) // life in 0.1's
  692. write_byte(20) // line width in 0.1's
  693. write_byte(0) // noise amplitude in 0.01's
  694. write_byte(255) // Red
  695. write_byte(255) // Green
  696. write_byte(85) // Blue
  697. write_byte(255) // brightness
  698. write_byte(0) // scroll speed in 0.1's
  699. message_end()
  700.  
  701. engfunc(EngFunc_TraceLine, Origin, EndPos, DONT_IGNORE_MONSTERS, g_MM_Ent, Trace_Result)
  702.  
  703. static pHit; pHit = get_tr2(Trace_Result, TR_pHit)
  704. if(pev_valid(pHit)) ExecuteHamB(Ham_TakeDamage, pHit, 0, pHit, LASER_DAMAGE, DMG_BLAST)
  705. }
  706.  
  707. public Create_Laser2(ent)
  708. {
  709. ent -= TASK_ATTACK_LASERING
  710. if(!pev_valid(ent))
  711. return
  712.  
  713. static Float:Origin[3]
  714. if(pev(ent, pev_iuser1) == 1)
  715. get_position(ent, 130.0, 100.0, 50.0, Origin)
  716. else
  717. get_position(ent, 120.0, 100.0, 50.0, Origin)
  718.  
  719. message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
  720. write_byte(TE_SPRITE)
  721. engfunc(EngFunc_WriteCoord, Origin[0])
  722. engfunc(EngFunc_WriteCoord, Origin[1])
  723. engfunc(EngFunc_WriteCoord, Origin[2])
  724. write_short(LASER_LIGHTDOT_SPRID)
  725. write_byte(30)
  726. write_byte(255)
  727. message_end()
  728.  
  729. set_task(0.1, "Create_Laser2", ent+TASK_ATTACK_LASERING)
  730. }
  731.  
  732. public Stop_Laser(ent)
  733. {
  734. ent -= TASK_ATTACK_LASER
  735. if(!pev_valid(ent))
  736. return
  737.  
  738. remove_task(ent+TASK_ATTACK_LASERING)
  739. Remove_LaserControl()
  740. }
  741.  
  742. public fw_LC_Think(ent)
  743. {
  744. if(!pev_valid(ent))
  745. return
  746.  
  747. set_pev(ent, pev_nextthink, get_gametime() + 0.025)
  748.  
  749. static Float:Vector[3]
  750. pev(ent, pev_angles, Vector)
  751.  
  752. if(pev(ent, pev_iuser1) == 1) // Rotating to the Right
  753. {
  754. Vector[1] -= 1.125
  755. set_pev(ent, pev_angles, Vector)
  756. } else if(pev(ent, pev_iuser1) == 2) { // Rotating to the Left
  757. Vector[1] += 1.5
  758. set_pev(ent, pev_angles, Vector)
  759. }
  760.  
  761. if(get_gametime() - 0.1 > pev(ent, pev_fuser4))
  762. {
  763. Create_Laser(ent+TASK_ATTACK_LASERING)
  764. set_pev(ent, pev_fuser4, get_gametime())
  765. }
  766. }
  767.  
  768. public MM_Attack_Flame(ent)
  769. {
  770. if((pev(ent, pev_state) == MM_STATE_CHASE_ENEMY || pev(ent, pev_state) == MM_STATE_IDLE)/* && is_user_alive(pev(ent, pev_enemy))*/)
  771. {
  772. set_pev(ent, pev_state, MM_STATE_ATTACK_FLAME)
  773. set_pev(ent, pev_movetype, MOVETYPE_NONE)
  774. set_pev(ent, pev_velocity, {0.0, 0.0, 0.0})
  775.  
  776. set_task(0.1, "MM_Start_Attack_Flame", ent+TASK_ATTACK_FLAME)
  777. }
  778. }
  779.  
  780. public MM_Start_Attack_Flame(ent)
  781. {
  782. ent -= TASK_ATTACK_FLAME
  783. if(!pev_valid(ent))
  784. return
  785.  
  786. EmitSound(ent, MM_Sound[MM_SOUND_ATTACK_FLAME], CHAN_BODY)
  787.  
  788. set_entity_anim(ent, MM_ANIM_ATTACK_FLAME, 1.0, 1)
  789. set_task(1.35, "MM_StartFlame", ent+TASK_ATTACK_FLAME)
  790. set_task(8.6, "MM_Done_Attack_Laser_AND_Flame", ent+TASK_ATTACK_LASERFLAME)
  791. }
  792.  
  793. public MM_StartFlame(ent)
  794. {
  795. ent -= TASK_ATTACK_FLAME
  796. if(!pev_valid(ent))
  797. return
  798.  
  799. PlaySound(0, MM_Sound[MM_SOUND_FLAMING])
  800. Create_FlameControl(ent)
  801. set_task(3.3, "Stop_Flame", ent+TASK_ATTACK_FLAME)
  802. }
  803.  
  804. public Create_Flame(ent)
  805. {
  806. ent -= TASK_ATTACK_FLAMING
  807. if(!pev_valid(ent))
  808. return
  809.  
  810. static Float:Origin[3], Float:TargetOrigin[3]
  811. if(pev(ent, pev_iuser1) == 1)
  812. get_position(ent, 130.0, -100.0, 50.0, Origin)
  813. else
  814. get_position(ent, 120.0, -100.0, 50.0, Origin)
  815.  
  816. get_position(ent, 2000.0, -100.0, 25.0, TargetOrigin)
  817. create_fire(ent, Origin, TargetOrigin, FIRE_SPEED)
  818. }
  819.  
  820. public Create_FlameControl(ent)
  821. {
  822. static Ent; Ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
  823. if(!pev_valid(Ent))
  824. return
  825.  
  826. g_LC_Ent = Ent
  827.  
  828. static Float:Vector[3]
  829.  
  830. pev(ent, pev_origin, Vector); set_pev(Ent, pev_origin, Vector)
  831. pev(ent, pev_angles, Vector); set_pev(Ent, pev_angles, Vector)
  832.  
  833. // Set Config
  834. set_pev(Ent, pev_classname, "FlameControl")
  835. engfunc(EngFunc_SetModel, Ent, MM_MODEL)
  836.  
  837. set_pev(Ent, pev_gamestate, 1)
  838. set_pev(Ent, pev_solid, SOLID_NOT)
  839. set_pev(Ent, pev_movetype, MOVETYPE_NONE)
  840.  
  841. set_pev(Ent, pev_iuser1, 1)
  842. set_pev(Ent, pev_fuser1, Vector[1])
  843.  
  844. // Set Size
  845. new Float:maxs[3] = {72.0, 72.0, 172.0}
  846. new Float:mins[3] = {-72.0, -72.0, 22.0}
  847. engfunc(EngFunc_SetSize, Ent, mins, maxs)
  848.  
  849. fm_set_rendering(Ent, kRenderFxNone, 0, 0, 0, kRenderTransAlpha, 0)
  850.  
  851. engfunc(EngFunc_DropToFloor, Ent)
  852. set_pev(Ent, pev_nextthink, get_gametime() + 0.1)
  853.  
  854. set_task(0.1, "Create_Flame", Ent+TASK_ATTACK_FLAMING, _, _, "b")
  855. set_task(1.35, "Rotate_Right", Ent+TASK_ATTACK_LASERFLAME)
  856. }
  857.  
  858. public fw_FC_Think(ent)
  859. {
  860. if(!pev_valid(ent))
  861. return
  862.  
  863. set_pev(ent, pev_nextthink, get_gametime() + 0.025)
  864.  
  865. static Float:Vector[3]
  866. pev(ent, pev_angles, Vector)
  867.  
  868. if(pev(ent, pev_iuser1) == 1) // Rotating to the Right
  869. {
  870. Vector[1] -= 1.125
  871. set_pev(ent, pev_angles, Vector)
  872. } else if(pev(ent, pev_iuser1) == 2) { // Rotating to the Left
  873. Vector[1] += 1.5
  874. set_pev(ent, pev_angles, Vector)
  875. }
  876. }
  877.  
  878. public create_fire(id, Float:Origin[3], Float:TargetOrigin[3], Float:Speed)
  879. {
  880. new iEnt = create_entity("env_sprite")
  881. static Float:vfAngle[3], Float:MyOrigin[3], Float:Velocity[3]
  882.  
  883. pev(id, pev_angles, vfAngle)
  884. pev(id, pev_origin, MyOrigin)
  885.  
  886. vfAngle[2] = float(random(18) * 20)
  887.  
  888. // set info for ent
  889. set_pev(iEnt, pev_movetype, MOVETYPE_FLY)
  890. set_pev(iEnt, pev_rendermode, kRenderTransAdd)
  891. set_pev(iEnt, pev_renderamt, 250.0)
  892. set_pev(iEnt, pev_fuser1, get_gametime() + 2.5) // time remove
  893. set_pev(iEnt, pev_scale, 1.0)
  894. set_pev(iEnt, pev_nextthink, get_gametime() + 0.05)
  895.  
  896. set_pev(iEnt, pev_classname, FIRE_CLASSNAME)
  897. engfunc(EngFunc_SetModel, iEnt, FLAME_SPR)
  898. set_pev(iEnt, pev_mins, Float:{-10.0, -10.0, -10.0})
  899. set_pev(iEnt, pev_maxs, Float:{10.0, 10.0, 10.0})
  900. set_pev(iEnt, pev_origin, Origin)
  901. set_pev(iEnt, pev_gravity, 0.01)
  902. set_pev(iEnt, pev_angles, vfAngle)
  903. set_pev(iEnt, pev_solid, SOLID_TRIGGER)
  904. set_pev(iEnt, pev_owner, id)
  905. set_pev(iEnt, pev_frame, 0.0)
  906.  
  907. get_speed_vector(Origin, TargetOrigin, Speed, Velocity)
  908. set_pev(iEnt, pev_velocity, Velocity)
  909. }
  910.  
  911. public fw_Fire_Think(iEnt)
  912. {
  913. if(!pev_valid(iEnt))
  914. return
  915.  
  916. new Float:fFrame, Float:fNextThink, Float:fScale
  917. pev(iEnt, pev_frame, fFrame)
  918. pev(iEnt, pev_scale, fScale)
  919.  
  920. // effect exp
  921. new iMoveType = pev(iEnt, pev_movetype)
  922. if (iMoveType == MOVETYPE_NONE)
  923. {
  924. fNextThink = 0.0015
  925. fFrame += 0.5
  926.  
  927. if (fFrame > 21.0)
  928. {
  929. engfunc(EngFunc_RemoveEntity, iEnt)
  930. return
  931. }
  932. }
  933.  
  934. // effect normal
  935. else
  936. {
  937. fNextThink = 0.045
  938.  
  939. fFrame += 0.5
  940. fScale += 0.01
  941.  
  942. fFrame = floatmin(21.0, fFrame)
  943. fScale = floatmin(5.0, fFrame)
  944. }
  945.  
  946. set_pev(iEnt, pev_frame, fFrame)
  947. set_pev(iEnt, pev_scale, fScale)
  948. set_pev(iEnt, pev_nextthink, halflife_time() + fNextThink)
  949.  
  950. // time remove
  951. new Float:fTimeRemove
  952. pev(iEnt, pev_fuser1, fTimeRemove)
  953. if (get_gametime() >= fTimeRemove)
  954. {
  955. engfunc(EngFunc_RemoveEntity, iEnt)
  956. return;
  957. }
  958. }
  959.  
  960. public fw_Fire_Touch(ent, id)
  961. {
  962. if(!pev_valid(ent))
  963. return
  964.  
  965. if(pev_valid(id))
  966. {
  967. static Classname[32]
  968. pev(id, pev_classname, Classname, sizeof(Classname))
  969.  
  970. if(equal(Classname, FIRE_CLASSNAME)) return
  971. else if(equal(Classname, "player")) {
  972. if(is_user_alive(id)) ExecuteHamB(Ham_TakeDamage, id, 0, id, FLAME_DAMAGE, DMG_BURN)
  973. }
  974. }
  975.  
  976. set_pev(ent, pev_movetype, MOVETYPE_NONE)
  977. set_pev(ent, pev_solid, SOLID_NOT)
  978. }
  979.  
  980. public Stop_Flame(ent)
  981. {
  982. ent -= TASK_ATTACK_FLAME
  983. if(!pev_valid(ent))
  984. return
  985.  
  986. remove_task(ent+TASK_ATTACK_FLAMING)
  987. Remove_LaserControl()
  988. }
  989.  
  990. public MM_Done_Attack_Laser_AND_Flame(ent)
  991. {
  992. ent -= TASK_ATTACK_LASERFLAME
  993. if(!pev_valid(ent))
  994. return
  995.  
  996. remove_task(ent+TASK_ATTACK_LASER)
  997. remove_task(ent+TASK_ATTACK_LASER)
  998. remove_task(ent+TASK_ATTACK_LASERING)
  999. remove_task(ent+TASK_ATTACK_LASERFLAME)
  1000. remove_task(ent+TASK_ATTACK_FLAME)
  1001. remove_task(ent+TASK_ATTACK_FLAMING)
  1002.  
  1003. Remove_LaserControl()
  1004.  
  1005. set_pev(ent, pev_movetype, MOVETYPE_NONE)
  1006. set_pev(ent, pev_velocity, {0.0, 0.0, 0.0})
  1007.  
  1008. set_task(0.1, "Reset_Idle", ent)
  1009. }
  1010.  
  1011. public Reset_Idle(ent)
  1012. {
  1013. set_entity_anim(ent, MM_ANIM_IDLE, 1.0, 1)
  1014. set_pev(ent, pev_state, MM_STATE_SEARCHING_ENEMY)
  1015. }
  1016.  
  1017. public MM_Aim_To(ent, Float:Origin[3])
  1018. {
  1019. if(!pev_valid(ent))
  1020. return
  1021.  
  1022. static Float:Vec[3], Float:Angles[3]
  1023. pev(ent, pev_origin, Vec)
  1024.  
  1025. Vec[0] = Origin[0] - Vec[0]
  1026. Vec[1] = Origin[1] - Vec[1]
  1027. Vec[2] = Origin[2] - Vec[2]
  1028. engfunc(EngFunc_VecToAngles, Vec, Angles)
  1029. Angles[0] = Angles[2] = 0.0
  1030.  
  1031. set_pev(ent, pev_angles, Angles)
  1032. }
  1033.  
  1034. stock EmitSound(ent, const SoundFile[], Channel)
  1035. {
  1036. if(!pev_valid(ent))
  1037. return
  1038.  
  1039. emit_sound(ent, Channel, SoundFile, 1.0, ATTN_NORM, 0, PITCH_NORM)
  1040. }
  1041.  
  1042. stock set_entity_anim(ent, anim, Float:framerate, resetframe)
  1043. {
  1044. if(!pev_valid(ent))
  1045. return
  1046.  
  1047. if(!resetframe)
  1048. {
  1049. if(pev(ent, pev_sequence) != anim)
  1050. {
  1051. set_pev(ent, pev_animtime, get_gametime())
  1052. set_pev(ent, pev_framerate, framerate)
  1053. set_pev(ent, pev_sequence, anim)
  1054. }
  1055. } else {
  1056. set_pev(ent, pev_animtime, get_gametime())
  1057. set_pev(ent, pev_framerate, framerate)
  1058. set_pev(ent, pev_sequence, anim)
  1059. }
  1060. }
  1061.  
  1062. public FindClosetEnemy(ent, can_see)
  1063. {
  1064. new Float:maxdistance = 4980.0
  1065. new indexid = 0
  1066. new Float:current_dis = maxdistance
  1067.  
  1068. for(new i = 1 ;i <= g_MaxPlayers; i++)
  1069. {
  1070. if(can_see)
  1071. {
  1072. if(is_user_alive(i) && can_see_fm(ent, i) && entity_range(ent, i) < current_dis)
  1073. {
  1074. current_dis = entity_range(ent, i)
  1075. indexid = i
  1076. }
  1077. } else {
  1078. if(is_user_alive(i) && entity_range(ent, i) < current_dis)
  1079. {
  1080. current_dis = entity_range(ent, i)
  1081. indexid = i
  1082. }
  1083. }
  1084. }
  1085.  
  1086. return indexid
  1087. }
  1088.  
  1089. public bool:can_see_fm(entindex1, entindex2)
  1090. {
  1091. if (!entindex1 || !entindex2)
  1092. return false
  1093.  
  1094. if (pev_valid(entindex1) && pev_valid(entindex1))
  1095. {
  1096. new flags = pev(entindex1, pev_flags)
  1097. if (flags & EF_NODRAW || flags & FL_NOTARGET)
  1098. {
  1099. return false
  1100. }
  1101.  
  1102. new Float:lookerOrig[3]
  1103. new Float:targetBaseOrig[3]
  1104. new Float:targetOrig[3]
  1105. new Float:temp[3]
  1106.  
  1107. pev(entindex1, pev_origin, lookerOrig)
  1108. pev(entindex1, pev_view_ofs, temp)
  1109. lookerOrig[0] += temp[0]
  1110. lookerOrig[1] += temp[1]
  1111. lookerOrig[2] += temp[2]
  1112.  
  1113. pev(entindex2, pev_origin, targetBaseOrig)
  1114. pev(entindex2, pev_view_ofs, temp)
  1115. targetOrig[0] = targetBaseOrig [0] + temp[0]
  1116. targetOrig[1] = targetBaseOrig [1] + temp[1]
  1117. targetOrig[2] = targetBaseOrig [2] + temp[2]
  1118.  
  1119. engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) // checks the had of seen player
  1120. if (get_tr2(0, TraceResult:TR_InOpen) && get_tr2(0, TraceResult:TR_InWater))
  1121. {
  1122. return false
  1123. }
  1124. else
  1125. {
  1126. new Float:flFraction
  1127. get_tr2(0, TraceResult:TR_flFraction, flFraction)
  1128. if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
  1129. {
  1130. return true
  1131. }
  1132. else
  1133. {
  1134. targetOrig[0] = targetBaseOrig [0]
  1135. targetOrig[1] = targetBaseOrig [1]
  1136. targetOrig[2] = targetBaseOrig [2]
  1137. engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) // checks the body of seen player
  1138. get_tr2(0, TraceResult:TR_flFraction, flFraction)
  1139. if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
  1140. {
  1141. return true
  1142. }
  1143. else
  1144. {
  1145. targetOrig[0] = targetBaseOrig [0]
  1146. targetOrig[1] = targetBaseOrig [1]
  1147. targetOrig[2] = targetBaseOrig [2] - 17.0
  1148. engfunc(EngFunc_TraceLine, lookerOrig, targetOrig, 0, entindex1, 0) // checks the legs of seen player
  1149. get_tr2(0, TraceResult:TR_flFraction, flFraction)
  1150. if (flFraction == 1.0 || (get_tr2(0, TraceResult:TR_pHit) == entindex2))
  1151. {
  1152. return true
  1153. }
  1154. }
  1155. }
  1156. }
  1157. }
  1158. return false
  1159. }
  1160.  
  1161. public Make_PlayerShake(id)
  1162. {
  1163. if(!id)
  1164. {
  1165. message_begin(MSG_BROADCAST, g_Msg_ScreenShake)
  1166. write_short(8<<12)
  1167. write_short(5<<12)
  1168. write_short(4<<12)
  1169. message_end()
  1170. } else {
  1171. if(!is_user_connected(id))
  1172. return
  1173.  
  1174. message_begin(MSG_BROADCAST, g_Msg_ScreenShake, _, id)
  1175. write_short(8<<12)
  1176. write_short(5<<12)
  1177. write_short(4<<12)
  1178. message_end()
  1179. }
  1180. }
  1181.  
  1182. stock get_position(ent, Float:forw, Float:right, Float:up, Float:vStart[])
  1183. {
  1184. if(!pev_valid(ent))
  1185. return
  1186.  
  1187. static Float:vOrigin[3], Float:vAngle[3], Float:vForward[3], Float:vRight[3], Float:vUp[3]
  1188.  
  1189. pev(ent, pev_origin, vOrigin)
  1190. pev(ent, pev_view_ofs,vUp) //for player
  1191. xs_vec_add(vOrigin,vUp,vOrigin)
  1192. pev(ent, pev_angles, vAngle) // if normal entity ,use pev_angles
  1193.  
  1194. vAngle[0] = 0.0
  1195.  
  1196. angle_vector(vAngle,ANGLEVECTOR_FORWARD,vForward) //or use EngFunc_AngleVectors
  1197. angle_vector(vAngle,ANGLEVECTOR_RIGHT,vRight)
  1198. angle_vector(vAngle,ANGLEVECTOR_UP,vUp)
  1199.  
  1200. vStart[0] = vOrigin[0] + vForward[0] * forw + vRight[0] * right + vUp[0] * up
  1201. vStart[1] = vOrigin[1] + vForward[1] * forw + vRight[1] * right + vUp[1] * up
  1202. vStart[2] = vOrigin[2] + vForward[2] * forw + vRight[2] * right + vUp[2] * up
  1203. }
  1204.  
  1205. stock hook_ent2(ent, Float:VicOrigin[3], Float:speed)
  1206. {
  1207. if(!pev_valid(ent))
  1208. return
  1209.  
  1210. static Float:fl_Velocity[3], Float:EntOrigin[3], Float:distance_f, Float:fl_Time
  1211.  
  1212. pev(ent, pev_origin, EntOrigin)
  1213.  
  1214. distance_f = get_distance_f(EntOrigin, VicOrigin)
  1215. fl_Time = distance_f / speed
  1216.  
  1217. fl_Velocity[0] = (VicOrigin[0] - EntOrigin[0]) / fl_Time
  1218. fl_Velocity[1] = (VicOrigin[1] - EntOrigin[1]) / fl_Time
  1219. fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time
  1220.  
  1221. set_pev(ent, pev_velocity, fl_Velocity)
  1222. }
  1223.  
  1224. stock create_blood(const Float:origin[3])
  1225. {
  1226. // Show some blood :)
  1227. message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
  1228. write_byte(TE_BLOODSPRITE)
  1229. engfunc(EngFunc_WriteCoord, origin[0])
  1230. engfunc(EngFunc_WriteCoord, origin[1])
  1231. engfunc(EngFunc_WriteCoord, origin[2])
  1232. write_short(m_iBlood[1])
  1233. write_short(m_iBlood[0])
  1234. write_byte(75)
  1235. write_byte(5)
  1236. message_end()
  1237. }
  1238.  
  1239. stock PlaySound(id, const sound[])
  1240. {
  1241. if (equal(sound[strlen(sound)-4], ".mp3"))
  1242. client_cmd(id, "mp3 play ^"sound/%s^"", sound)
  1243. else
  1244. client_cmd(id, "spk ^"%s^"", sound)
  1245. }
  1246.  
  1247. stock get_speed_vector(const Float:origin1[3],const Float:origin2[3],Float:speed, Float:new_velocity[3])
  1248. {
  1249. new_velocity[0] = origin2[0] - origin1[0]
  1250. new_velocity[1] = origin2[1] - origin1[1]
  1251. new_velocity[2] = origin2[2] - origin1[2]
  1252. new Float:num = floatsqroot(speed*speed / (new_velocity[0]*new_velocity[0] + new_velocity[1]*new_velocity[1] + new_velocity[2]*new_velocity[2]))
  1253. new_velocity[0] *= num
  1254. new_velocity[1] *= num
  1255. new_velocity[2] *= num
  1256.  
  1257. return 1;
  1258. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!