请选择 进入手机版 | 继续访问电脑版
设为首页收藏本站

ESFKAMI

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz

ESFX

ESF: Xenoverse

ESF123

ESF1.2.3

EVM2.1

EVM2.1

ECXSSJ

ECX: TeamSSJ

ECX2.2

ECX RC2

ECX2.3

ECX RC3

查看: 337|回复: 0

[Library]Math.inc

[复制链接]

208

主题

213

帖子

1045

积分

ESFKAMI

Rank: 8Rank: 8

积分
1045
发表于 2017-7-13 16:28:32 | 显示全部楼层 |阅读模式

  1. /* CHR Engine - v1.1b
  2. *
  3. * by GHW_Chronic
  4. *   12/2006 - 07/2009
  5. *
  6. * This file is provided as is (no warranties).
  7. *
  8. */

  9. #if defined chr_engine_included
  10.   #endinput
  11. #endif
  12. #define chr_engine_included


  13. #include <amxmodx>
  14. #include <fakemeta>



  15. /*
  16. *
  17. *  Determines velocity (new_velocity) that
  18. *  you would set an entity to in order for
  19. *  it to go at "speed" from "origin1" to
  20. *  "origin2".
  21. *
  22. */

  23. stock get_speed_vector(const Float:origin1[3],const Float:origin2[3],Float:speed, Float:new_velocity[3])
  24. {
  25.         new_velocity[0] = origin2[0] - origin1[0]
  26.         new_velocity[1] = origin2[1] - origin1[1]
  27.         new_velocity[2] = origin2[2] - origin1[2]
  28.         new Float:num = floatsqroot(speed*speed / (new_velocity[0]*new_velocity[0] + new_velocity[1]*new_velocity[1] + new_velocity[2]*new_velocity[2]))
  29.         new_velocity[0] *= num
  30.         new_velocity[1] *= num
  31.         new_velocity[2] *= num

  32.         return 1;
  33. }



  34. /*
  35. *
  36. *  Determines velocity (new_velocity) that
  37. *  you would set "ent1" to in order for it
  38. *  to go at "speed" from "ent1"'s origin
  39. *  to "ent2"'s origin.
  40. *
  41. */

  42. stock get_speed_vector2(ent1, ent2, Float:speed, Float:new_velocity[3])
  43. {
  44.         if(!pev_valid(ent1) || !pev_valid(ent2))
  45.                 return 0;

  46.         static Float:origin1[3]
  47.         pev(ent1,pev_origin,origin1)
  48.         static Float:origin2[3]
  49.         pev(ent2,pev_origin,origin2)

  50.         new_velocity[0] = origin2[0] - origin1[0]
  51.         new_velocity[1] = origin2[1] - origin1[1]
  52.         new_velocity[2] = origin2[2] - origin1[2]
  53.         new Float:num = floatsqroot(speed*speed / (new_velocity[0]*new_velocity[0] + new_velocity[1]*new_velocity[1] + new_velocity[2]*new_velocity[2]))
  54.         new_velocity[0] *= num
  55.         new_velocity[1] *= num
  56.         new_velocity[2] *= num

  57.         return 1;
  58. }



  59. /*
  60. *
  61. *  Determines location ("origin") of an entity
  62. *  with supplied offset to its original angles.
  63. *
  64. *  Example: You want the location of 30 units
  65. *  to the left of a model but the model is
  66. *  turned at an angle so you cannot simply add
  67. *  the offset to the origin. Then you would use
  68. *  this.
  69. *
  70. */

  71. stock get_offset_origin(ent,const Float:offset[3],Float:origin[3])
  72. {
  73.         if(!pev_valid(ent))
  74.                 return 0;

  75.         new Float:angle[3]
  76.         pev(ent,pev_origin,origin)
  77.         pev(ent,pev_angles,angle)

  78.         origin[0] += floatcos(angle[1],degrees) * offset[0]
  79.         origin[1] += floatsin(angle[1],degrees) * offset[0]

  80.         origin[2] += floatsin(angle[0],degrees) * offset[0]
  81.         origin[0] += floatcos(angle[0],degrees) * offset[0]

  82.         origin[1] += floatcos(angle[1],degrees) * offset[1]
  83.         origin[0] -= floatsin(angle[1],degrees) * offset[1]

  84.         origin[2] += floatsin(angle[2],degrees) * offset[1]
  85.         origin[1] += floatcos(angle[2],degrees) * offset[1]

  86.         origin[2] += floatcos(angle[2],degrees) * offset[2]
  87.         origin[1] -= floatsin(angle[2],degrees) * offset[2]

  88.         origin[2] += floatcos(angle[0],degrees) * offset[2]
  89.         origin[0] -= floatsin(angle[0],degrees) * offset[2]

  90.         origin[0] -= offset[0]
  91.         origin[1] -= offset[1]
  92.         origin[2] -= offset[2]

  93.         return 1;
  94. }



  95. /*
  96. *
  97. *  Determines location ("origin") of a monster
  98. *  or player entity with supplied offset to its
  99. *  original angles.
  100. *
  101. *  Example: You want the location of 30 units
  102. *  to the left of a model but the model is
  103. *  turned at an angle so you cannot simply add
  104. *  the offset to the origin. Then you would use
  105. *  this.
  106. *
  107. *  Works same as above but only for players and
  108. *  monsters.
  109. *
  110. */

  111. stock get_offset_origin_body(ent,const Float:offset[3],Float:origin[3])
  112. {
  113.         if(!pev_valid(ent))
  114.                 return 0;

  115.         new Float:angle[3]
  116.         pev(ent,pev_angles,angle)

  117.         pev(ent,pev_origin,origin)

  118.         origin[0] += floatcos(angle[1],degrees) * offset[0]
  119.         origin[1] += floatsin(angle[1],degrees) * offset[0]

  120.         origin[1] += floatcos(angle[1],degrees) * offset[1]
  121.         origin[0] += floatsin(angle[1],degrees) * offset[1]

  122.         return 1;
  123. }



  124. /*
  125. *
  126. *  Determines if a player is crouching or not.
  127. *  Return 1 if crouching and 0 if not.
  128. *
  129. *  Set ignoreplayer to 1 if you are using on
  130. *  a HL monster that can crouch.
  131. *
  132. */

  133. stock is_user_crouching(ent,ignoreplayer=0)
  134. {
  135.         if(!is_user_alive(ent) && !ignoreplayer)
  136.                 return 0;

  137.         new Float:minsize[3]
  138.         pev(ent,pev_mins,minsize)

  139.         if(minsize[2]==-18.0)
  140.                 return 1;

  141.         return 0;
  142. }



  143. /*
  144. *
  145. *  Returns indexes of players in order according
  146. *  to how close they are to "origin". Indexes are
  147. *  stored in "players[32]" and the number of
  148. *  indexes returned is stored in num[0]. team[] is
  149. *  used only if flag 'e' is passed.
  150. *
  151. *  Flags:
  152. *  "a" - Don't return dead players
  153. *  "b" - Don't return alive players
  154. *  "c" - Skip bots
  155. *  "d" - Skip real players
  156. *  "e" - Match with passed team
  157. *  "h" - Skip HLTV
  158. *  "i" - Is in Viewcone
  159. *  "j" - Is Visible
  160. *
  161. *  If flag 'i' is passed, you must specify into
  162. *  variable "index" who's viewcone to check if
  163. *  the returned players are in.
  164. *
  165. */

  166. stock get_players_distance(const Float:origin2[3],players[32], &num,const flags[]="",index=0,const team[]="")
  167. {
  168.         new bool:flag1, bool:flag2
  169.         if(containi(flags,"j")!=-1) flag2 = true
  170.         if(containi(flags,"i")!=-1)
  171.         {
  172.                 if(!pev_valid(index))
  173.                         return 0;
  174.                 flag1 = true
  175.         }

  176.         static Float:origin[3]
  177.         origin[0] = origin2[0]
  178.         origin[1] = origin2[1]
  179.         origin[2] = origin2[2]

  180.         static players2[32]
  181.         new num2
  182.         arrayset(players2,0,32)
  183.         get_players(players2,num2,flags,team)
  184.         static Float:origin3[3]
  185.         static Float:distance[32]
  186.         for(new i=0;i<32;i++) distance=0.0
  187.         num = num2

  188.         static Float:hit[3]
  189.         new bool:continuea=true
  190.         for(new i=0;i<num2;i++)
  191.         {
  192.                 pev(players2,pev_origin,origin3)
  193.                 if(flag2)
  194.                 {
  195.                         engfunc(EngFunc_TraceLine,origin2,origin3,1,index,0)
  196.                         get_tr2(0,TR_vecEndPos,hit)
  197.                         if(hit[0]==origin3[0] && hit[1]==origin3[1] && hit[2]==origin3[2])
  198.                         {
  199.                                 distance = vector_distance(origin,origin3)
  200.                         }
  201.                         else
  202.                         {
  203.                                 continuea=false
  204.                                 distance = 9999999.1337
  205.                                 num--
  206.                         }
  207.                 }
  208.                 if(flag1 && continuea)
  209.                 {
  210.                         static Float:angles[3], Float:diff[3], Float:reciprocalsq, Float:norm[3], Float:dot, Float:fov
  211.                         pev(index, pev_angles, angles)
  212.                         engfunc(EngFunc_MakeVectors, angles)
  213.                         global_get(glb_v_forward, angles)
  214.                         angles[2] = 0.0

  215.                         pev(index, pev_origin, origin)
  216.                         diff[0] = origin3[0] - origin[0]
  217.                         diff[1] = origin3[1] - origin[1]
  218.                         diff[2] = origin3[2] - origin[2]
  219.                         //diff[2]=0.0// - for 2D viewcone

  220.                         reciprocalsq = 1.0 / floatsqroot(diff[0]*diff[0] + diff[1]*diff[1] + diff[2]*diff[2])
  221.                         norm[0] = diff[0] * reciprocalsq
  222.                         norm[1] = diff[1] * reciprocalsq
  223.                         norm[2] = diff[2] * reciprocalsq

  224.                         dot = norm[0]*angles[0] + norm[1]*angles[1] + norm[2]*angles[2]
  225.                         pev(index, pev_fov, fov)
  226.                         if(dot >= floatcos(fov * 3.1415926535 / 360.0))
  227.                         {
  228.                                 distance = vector_distance(origin,origin3)
  229.                         }
  230.                         else
  231.                         {
  232.                                 continuea=false
  233.                                 distance = 9999999.1337
  234.                                 num--
  235.                         }
  236.                 }
  237.                 if(continuea)
  238.                 {
  239.                         distance = vector_distance(origin,origin3)
  240.                 }
  241.         }
  242.         static distance_cnt[32]
  243.         arrayset(distance_cnt,0,32)
  244.         for(new i=0;i<num2;i++)
  245.         {
  246.                 if(distance!=9999999.1337)
  247.                 {
  248.                         for(new i2=0;i2<num;i2++)
  249.                         {
  250.                                 if(distance[i2]<distance) distance_cnt++
  251.                         }
  252.                         players[distance_cnt]=players2
  253.                 }
  254.         }
  255.         return 1;
  256. }



  257. /*
  258. *
  259. *  Forces "ent" to aim at "origin"
  260. *
  261. *  Set bone to a positive value to
  262. *  detect a specific bone the function
  263. *  should aim from.
  264. *
  265. */

  266. stock entity_set_aim(ent,const Float:origin2[3],bone=0)
  267. {
  268.         if(!pev_valid(ent))
  269.                 return 0;

  270.         static Float:origin[3]
  271.         origin[0] = origin2[0]
  272.         origin[1] = origin2[1]
  273.         origin[2] = origin2[2]

  274.         static Float:ent_origin[3], Float:angles[3]

  275.         if(bone)
  276.                 engfunc(EngFunc_GetBonePosition,ent,bone,ent_origin,angles)
  277.         else
  278.                 pev(ent,pev_origin,ent_origin)

  279.         origin[0] -= ent_origin[0]
  280.         origin[1] -= ent_origin[1]
  281.         origin[2] -= ent_origin[2]

  282.         static Float:v_length
  283.         v_length = vector_length(origin)

  284.         static Float:aim_vector[3]
  285.         aim_vector[0] = origin[0] / v_length
  286.         aim_vector[1] = origin[1] / v_length
  287.         aim_vector[2] = origin[2] / v_length

  288.         static Float:new_angles[3]
  289.         vector_to_angle(aim_vector,new_angles)

  290.         new_angles[0] *= -1

  291.         if(new_angles[1]>180.0) new_angles[1] -= 360
  292.         if(new_angles[1]<-180.0) new_angles[1] += 360
  293.         if(new_angles[1]==180.0 || new_angles[1]==-180.0) new_angles[1]=-179.999999

  294.         set_pev(ent,pev_angles,new_angles)
  295.         set_pev(ent,pev_fixangle,1)

  296.         return 1;
  297. }



  298. /*
  299. *
  300. *  If "origin" is in ent's viewcone, the location
  301. *  of it using the hudmessage grid will be placed
  302. *  into hudpos[2].
  303. *
  304. *  Returns 0 if "origin" is not on ent's hud.
  305. *
  306. *  ent must be a player (index 1-32).
  307. *
  308. */

  309. stock get_hudmessage_locs(ent,const Float:origin[3],Float:hudpos[2])
  310. {
  311.         if(!is_user_connected(ent))
  312.                 return 0;

  313.         static Float:origin2[3]
  314.         origin2[0] = origin[0]
  315.         origin2[1] = origin[1]
  316.         origin2[2] = origin[2]

  317.         static Float:ent_origin[3]

  318.         pev(ent,pev_origin,ent_origin)

  319.         static Float:ent_angles[3]

  320.         pev(ent,pev_v_angle,ent_angles)

  321.         origin2[0] -= ent_origin[0]
  322.         origin2[1] -= ent_origin[1]
  323.         origin2[2] -= ent_origin[2]

  324.         new Float:v_length
  325.         v_length = vector_length(origin2)

  326.         static Float:aim_vector[3]
  327.         aim_vector[0] = origin2[0] / v_length
  328.         aim_vector[1] = origin2[1] / v_length
  329.         aim_vector[2] = origin2[2] / v_length

  330.         static Float:new_angles[3]
  331.         vector_to_angle(aim_vector,new_angles)

  332.         new_angles[0] *= -1

  333.         if(new_angles[1]>180.0) new_angles[1] -= 360.0
  334.         if(new_angles[1]<-180.0) new_angles[1] += 360.0
  335.         if(new_angles[1]==180.0 || new_angles[1]==-180.0) new_angles[1]=-179.999999

  336.         if(new_angles[0]>180.0) new_angles[0] -= 360.0
  337.         if(new_angles[0]<-180.0) new_angles[0] += 360.0
  338.         if(new_angles[0]==90.0) new_angles[0]=89.999999
  339.         else if(new_angles[0]==-90.0) new_angles[0]=-89.999999

  340.         new Float:fov
  341.         pev(ent,pev_fov,fov)

  342.         if(!fov)
  343.                 fov = 90.0

  344.         if(floatabs(ent_angles[0] - new_angles[0]) <= fov/2 && floatabs((180.0 - floatabs(ent_angles[1])) - (180.0 - floatabs(new_angles[1]))) <= fov/2)
  345.         {
  346.                 hudpos[1] = 1 - ( ( (ent_angles[0] - new_angles[0]) + fov/2 ) / fov )
  347.                 hudpos[0] = ( (ent_angles[1] - new_angles[1]) + fov/2 ) / fov
  348.         }
  349.         else
  350.                 return 0;

  351.         return 1;
  352. }



  353. /*
  354. *
  355. *  Sets ent's speed in the direction specified
  356. *  by the mode variable
  357. *
  358. *  Modes:
  359. *   0 = In direction ent is currently moving
  360. *        but not including the z axis
  361. *   1 = In direction ent is currently moving
  362. *   2 = In direction ent is currently looking
  363. *   3 = In direction ent is currently looking
  364. *        but not including the z axis
  365. *   4 = In direction of origin[3]
  366. *
  367. *
  368. *  Use a negative speed to go in the opposite
  369. *  direction of the specified mode.
  370. *
  371. */

  372. stock set_speed(ent,Float:speed,mode=0,const Float:origin[3]={0.0,0.0,0.0})
  373. {
  374.         if(!pev_valid(ent))
  375.                 return 0;

  376.         switch(mode)
  377.         {
  378.                 case 0:
  379.                 {
  380.                         static Float:cur_velo[3]

  381.                         pev(ent,pev_velocity,cur_velo)

  382.                         new Float:y
  383.                         y = cur_velo[0]*cur_velo[0] + cur_velo[1]*cur_velo[1]

  384.                         new Float:x
  385.                         if(y) x = floatsqroot(speed*speed / y)

  386.                         cur_velo[0] *= x
  387.                         cur_velo[1] *= x

  388.                         if(speed<0.0)
  389.                         {
  390.                                 cur_velo[0] *= -1
  391.                                 cur_velo[1] *= -1
  392.                         }

  393.                         set_pev(ent,pev_velocity,cur_velo)
  394.                 }
  395.                 case 1:
  396.                 {
  397.                         static Float:cur_velo[3]

  398.                         pev(ent,pev_velocity,cur_velo)

  399.                         new Float:y
  400.                         y = cur_velo[0]*cur_velo[0] + cur_velo[1]*cur_velo[1] + cur_velo[2]*cur_velo[2]

  401.                         new Float:x
  402.                         if(y) x = floatsqroot(speed*speed / y)

  403.                         cur_velo[0] *= x
  404.                         cur_velo[1] *= x
  405.                         cur_velo[2] *= x

  406.                         if(speed<0.0)
  407.                         {
  408.                                 cur_velo[0] *= -1
  409.                                 cur_velo[1] *= -1
  410.                                 cur_velo[2] *= -1
  411.                         }

  412.                         set_pev(ent,pev_velocity,cur_velo)
  413.                 }
  414.                 case 2:
  415.                 {
  416.                         static Float:vangle[3]
  417.                         if(ent<=get_maxplayers()) pev(ent,pev_v_angle,vangle)
  418.                         else pev(ent,pev_angles,vangle)

  419.                         static Float:new_velo[3]

  420.                         angle_vector(vangle,1,new_velo)

  421.                         new Float:y
  422.                         y = new_velo[0]*new_velo[0] + new_velo[1]*new_velo[1] + new_velo[2]*new_velo[2]

  423.                         new Float:x
  424.                         if(y) x = floatsqroot(speed*speed / y)

  425.                         new_velo[0] *= x
  426.                         new_velo[1] *= x
  427.                         new_velo[2] *= x

  428.                         if(speed<0.0)
  429.                         {
  430.                                 new_velo[0] *= -1
  431.                                 new_velo[1] *= -1
  432.                                 new_velo[2] *= -1
  433.                         }

  434.                         set_pev(ent,pev_velocity,new_velo)
  435.                 }
  436.                 case 3:
  437.                 {
  438.                         static Float:vangle[3]
  439.                         if(ent<=get_maxplayers()) pev(ent,pev_v_angle,vangle)
  440.                         else pev(ent,pev_angles,vangle)

  441.                         static Float:new_velo[3]

  442.                         pev(ent,pev_velocity,new_velo)

  443.                         angle_vector(vangle,1,new_velo)

  444.                         new Float:y
  445.                         y = new_velo[0]*new_velo[0] + new_velo[1]*new_velo[1]

  446.                         new Float:x
  447.                         if(y) x = floatsqroot(speed*speed / y)

  448.                         new_velo[0] *= x
  449.                         new_velo[1] *= x

  450.                         if(speed<0.0)
  451.                         {
  452.                                 new_velo[0] *= -1
  453.                                 new_velo[1] *= -1
  454.                         }

  455.                         set_pev(ent,pev_velocity,new_velo)
  456.                 }
  457.                 case 4:
  458.                 {
  459.                         static Float:origin1[3]
  460.                         pev(ent,pev_origin,origin1)

  461.                         static Float:new_velo[3]

  462.                         new_velo[0] = origin[0] - origin1[0]
  463.                         new_velo[1] = origin[1] - origin1[1]
  464.                         new_velo[2] = origin[2] - origin1[2]

  465.                         new Float:y
  466.                         y = new_velo[0]*new_velo[0] + new_velo[1]*new_velo[1] + new_velo[2]*new_velo[2]

  467.                         new Float:x
  468.                         if(y) x = floatsqroot(speed*speed / y)

  469.                         new_velo[0] *= x
  470.                         new_velo[1] *= x
  471.                         new_velo[2] *= x

  472.                         if(speed<0.0)
  473.                         {
  474.                                 new_velo[0] *= -1
  475.                                 new_velo[1] *= -1
  476.                                 new_velo[2] *= -1
  477.                         }

  478.                         set_pev(ent,pev_velocity,new_velo)
  479.                 }
  480.                 default: return 0;
  481.         }
  482.         return 1;
  483. }



  484. /*
  485. *
  486. *  Determines if 2 floats are within "difference"
  487. *  between eachother.
  488. *
  489. *  Example: 2.0 is within 5.0 "difference" of 7.0
  490. *
  491. */

  492. stock is_within_difference(Float:number1,Float:number2,Float:difference)
  493. {
  494.         if(floatabs(number2 - number1) <= difference)
  495.                 return 1;

  496.         return 0;
  497. }



  498. /*
  499. *
  500. *  Determines if point[2] is inside of polygon[20][2].
  501. *  Returns 1 if it is and 0 if it isn't.
  502. *
  503. *  Any polygon of any shape can be put into the polygon
  504. *  array. MAX_SIDES define has to be changed for more
  505. *  than 20 sides.
  506. *
  507. *  numsides if the number of sides put into polygon[20][2].
  508. *
  509. *  Example Usage:
  510. *
  511. *  new Float:square[MAX_SIDES][2], Float:point[2]
  512. *  point[0] = 0.0
  513. *  point[1] = 0.0
  514. *
  515. *  //4 sides are made up between the 4 points.
  516. *  //The sides make up a square if you connect
  517. *  //the points.
  518. *  square[0][0] = 10.0
  519. *  square[0][1] = 10.0
  520. *  square[1][0] = 10.0
  521. *  square[1][1] = -10.0
  522. *  square[2][0] = -10.0
  523. *  square[2][1] = -10.0
  524. *  square[3][0] = -10.0
  525. *  square[3][1] = 10.0
  526. *
  527. *  //will return 1 because (0,0) is
  528. *  //inside the polygon made by the array.
  529. *  is_inside(point,square,4)
  530. *
  531. */

  532. #define MAX_SIDES        20

  533. stock is_inside(const Float:point[2],const Float:polygon[MAX_SIDES][2],numsides)
  534. {
  535.         if(numsides>MAX_SIDES || numsides<3)
  536.                 return 0;

  537.         new num, Float:slope1, Float:slope2, Float:x, Float:y, i2

  538.         if(point[0]==100.0)
  539.                 slope2 = (point[1] - 100.0) / 0.000001
  540.         else
  541.                 slope2 = (point[1] - 100.0) / (point[0] - 100.00)

  542.         for(new i=0;i<numsides;i++)
  543.         {
  544.                 i2 = i+1
  545.                 if(i2==numsides) i2=0

  546.                 if(polygon[0]==polygon[i2][0]) polygon[i2][0] += 0.1

  547.                 slope1 = (polygon[1] - polygon[i2][1]) / (polygon[0] - polygon[i2][0])

  548.                 if(slope1!=slope2)
  549.                 {
  550.                         x=(polygon[1] + slope2*point[0] - point[1] - slope1*polygon[0]) / (slope2 - slope1)
  551.                         y = slope2*(x - point[0]) + point[1]
  552.                         if(
  553.                         !(y>polygon[1] && y>polygon[i2][1]) &&
  554.                         !(y<polygon[1] && y<polygon[i2][1]) &&
  555.                         !(x>polygon[0] && x>polygon[i2][0]) &&
  556.                         !(x<polygon[0] && x<polygon[i2][0]) &&
  557.                         !(x==polygon[0] && y==polygon[1]) &&
  558.                         (x>point[0])
  559.                         )
  560.                         {
  561.                                 num++
  562.                         }
  563.                 }
  564.         }

  565.         new Float:num2 = float(num) / 2.0

  566.         if(num2==float(floatround(num2))) return 0;

  567.         return 1;
  568. }



  569. /*
  570. *
  571. *  Returns the distance origin[3] is at its closest
  572. *  location to the line drawn from start[3] to end[3]
  573. *
  574. *  &is_visible is filled with 1 if origin[3] is visible
  575. *  by the line at its nearest point, 0 if it is not
  576. *
  577. */

  578. stock Float:distance_from_line(Float:start[3],Float:end[3],Float:origin[3],&is_visible)
  579. {
  580.         new Float:deltas[3]
  581.         deltas[0] = (start[1] - end[1]) / (start[0] - end[0])
  582.         deltas[1] = (start[2] - end[2]) / (start[1] - end[1])
  583.         deltas[2] = (start[1] - end[1]) / (start[2] - end[2])

  584.         static Float:origin2[3]
  585.         origin2[2] = origin[2]
  586.         origin2[1] = (deltas[2] * (origin2[2] - start[2])) + start[1]
  587.         origin2[0] = ((deltas[0] * start[0]) + origin2[1] - start[1]) / deltas[0]

  588.         static Float:hit[3]
  589.         engfunc(EngFunc_TraceLine,origin,origin2,1,0,0)
  590.         get_tr2(0,TR_vecEndPos,hit)
  591.         if(hit[0]==origin2[0] && hit[1]==origin2[1] && hit[2]==origin2[2])
  592.                 is_visible = 1
  593.         else
  594.                 is_visible = 0
  595.                

  596.         return get_distance_f(origin,origin2)
  597. }
复制代码
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|ESFKAMI    

GMT+8, 2018-2-26 08:58 , Processed in 0.303180 second(s), 22 queries .

Powered by Discuz! X3

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表