API tools faq
paste
Advertisement
Guest User

Standalone Jet HUD

a guest
Oct 22nd, 2018
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 11.63 KB | None | 0 0
raw download clone embed print report
  1. @name Standalone Jet HUD
  2. @inputs [Active]:number [Chair Base]:entity [EGP]:wirelink
  3. @outputs [Ops Us]:number [Angles]:angle
  4. @persist [SimplifiedMode RadarAngle RadarDistance MaxFoes PrevFoes N GroundAlt HUDHeading HUDKnots HUDAlt HUDMach HUDAlpha HUDGForce]:number
  5. @persist [Velocity AnglesX Altitude GForce IsTracking]:number [Angles]:angle
  6. @persist [Color]:vector4 [Driver]:entity [Chairs Foes Filter LaddersL LaddersR FoeDisplays FoeTrackers]:array
  7.  
  8. #Ops = floor(ops())
  9. #Us  = floor(cpuUsage() * 1000000)
  10.  
  11. if (first() | dupefinished())
  12. {
  13.     SimplifiedMode = 0      #Set this to 1 in case your computer starts dying. Disables the elevation ladder.
  14.     RadarDistance  = 15000
  15.     RadarAngle     = 20
  16.    
  17.     Color   = vec4(20, 200, 20, 255)
  18.     MaxFoes = 6
  19.    
  20.     #--------------------------
  21.    
  22.     findIncludePlayerProps(owner())
  23.     findInSphere(Base:pos(), 1000)
  24.     Filter = findToArray()
  25.     findClearWhiteList()
  26.     findExcludeEntities(Filter)
  27.     findIncludeClass("prop_vehicle_prisoner_pod")
  28.    
  29.     rangerPersist(1)
  30.     rangerFilter(Filter)
  31.    
  32.     R = rangerOffset(Base:pos(), Base:toWorld(vec(0, 0, -999999)))
  33.     GroundAlt = R:position()[3]
  34.    
  35.     #1 = Base aimer holo
  36.     #2 = Elevation ladder holo
  37.     #(3 - 8) = Homing targets
  38.     for (I = 1, 2 + MaxFoes) { holoCreate(I, vec(), vec()) }
  39.    
  40.     holoPos(1, Base:toWorld(vec(5000, 0, 0)))
  41.     holoParent(1, Base)
  42.    
  43.     holoPos(2, Base:toWorld(vec()))
  44.     holoAng(2, Base:toWorld(ang()))
  45.     holoParent(2, Base)
  46.    
  47.     function trackingSound()
  48.     {
  49.         if (IsTracking & !Foes:count())
  50.         {
  51.             IsTracking = 0
  52.             soundStop(1)
  53.         }
  54.         elseif (!IsTracking & Foes:count())
  55.         {
  56.             IsTracking = 1
  57.             Chair:soundPlay(1, 0, "acf_extra/airfx/radar_track.wav")
  58.         }
  59.     }
  60.    
  61.     function drawMarkers()
  62.     {
  63.         local Count = Foes:count()
  64.        
  65.         if (!Count & !PrevFoes) { return }
  66.         elseif (Count != PrevFoes)
  67.         {
  68.             local Cond  = Count > PrevFoes
  69.             local From  = Cond ? PrevFoes : Count
  70.             local To    = Cond ? Count : PrevFoes
  71.             local Alpha = 255 * Cond
  72.            
  73.             for (I = From, To)
  74.             {
  75.                 local ID = FoeDisplays[I, number]
  76.                
  77.                 EGP:egpAlpha(ID, Alpha)
  78.             }
  79.         }
  80.        
  81.         foreach (K:number, V:entity = Foes)
  82.         {
  83.             local ID = FoeTrackers[K, number]
  84.            
  85.             EGP:egpParent(ID, V)
  86.            
  87.             if (K == MaxFoes) { break }
  88.         }
  89.     }
  90.    
  91.     function getPilotedChairs()
  92.     {
  93.         PrevFoes = Foes:count()
  94.         Foes = array()
  95.        
  96.         if (Chairs:count())
  97.         {
  98.             local N = 0
  99.             foreach (K, V:entity = Chairs)
  100.             {
  101.                 if (V:driver()) { N++ Foes[N, entity] = V }
  102.             }
  103.         }
  104.        
  105.         drawMarkers()
  106.         trackingSound()
  107.     }
  108.    
  109.     function coneRadarFind()
  110.     {
  111.         if (!Active | !findCanQuery()) { return }
  112.        
  113.         local Position = Base:pos()
  114.        
  115.         findInCone(Position, Base:forward(), RadarDistance, RadarAngle)
  116.         findSortByDistance(Position)
  117.         Chairs = findToArray()
  118.            
  119.         getPilotedChairs()
  120.        
  121.         timer("Radar", 1000)
  122.     }
  123.    
  124.     function updateLadderDegrees()
  125.     {
  126.         if (SimplifiedMode) { return }
  127.        
  128.         for (I = 1, 4)
  129.         {
  130.             local Left   = LaddersL[I, number]
  131.             local Right  = LaddersR[I, number]
  132.             local Angle  = AnglesX + 5 * (I - 2)
  133.             local Number = ""+Angle
  134.            
  135.             if (Angle == 0) { Number = "" }
  136.             elseif (Angle > 90) { Number = ""+(90*2-Angle) }
  137.             elseif (Angle < -90) { Number = ""+(-90*2-Angle) }
  138.            
  139.             EGP:egpSetText(Left, Number)
  140.             EGP:egpSetText(Right, Number)
  141.         }
  142.     }
  143.    
  144.     function number getWingSweepAngle(Mach, MinMach, MaxMach)
  145.     {
  146.         return Mach <= MinMach ? 20 : Mach >= MaxMach ? 68 : 20 + 80 * Mach
  147.     }
  148. }
  149. elseif (changed(Active) & Active)
  150. {
  151.     timer("Radar", 1000)
  152.    
  153.     soundPurge()
  154.    
  155.     Driver = Chair:driver()
  156.     Res    = egpScrSize(Driver) / 2
  157.     X      = Res[1]
  158.     Y      = Res[2]
  159.     Scale  = X / 960
  160.     Size   = max(1,2*Scale)
  161.    
  162.     PrevFoes = N = 0
  163.    
  164.     #The actual shape for the HUD and its borders
  165.     Screen = array(vec2(350, 350) * Scale,
  166.                    vec2(350, -250) * Scale,
  167.                    vec2(150, -350) * Scale,
  168.                    vec2(-150, -350) * Scale,
  169.                    vec2(-350, -250) * Scale,
  170.                    vec2(-350, 350) * Scale)
  171.  
  172.     #Display for the closest target on the list
  173.     Marker1 = array(vec2(20, 0) * Scale,
  174.                     vec2(0, 20) * Scale,
  175.                     vec2(0, -20) * Scale,
  176.                     vec2(20, 0) * Scale,
  177.                     vec2(-20, 0) * Scale,
  178.                     vec2(0, -20) * Scale,
  179.                     vec2(0, 20) * Scale,
  180.                     vec2(-20, 0) * Scale)
  181.                    
  182.     #Display for the rest of the targets on the list
  183.     Marker = array(vec2(20, 0) * Scale,
  184.                    vec2(0, 20) * Scale,
  185.                    vec2(-20, 0) * Scale,
  186.                    vec2(0, -20) * Scale)
  187.    
  188.     BoxLeft = array(vec2(260, 15) * Scale,
  189.                     vec2(170, 15) * Scale,
  190.                     vec2(150, 0) * Scale,
  191.                     vec2(170, -15) * Scale,
  192.                     vec2(260, -15) * Scale)
  193.    
  194.     BoxRight = array(vec2(-260, 15) * Scale,
  195.                      vec2(-170, 15) * Scale,
  196.                      vec2(-150, 0) * Scale,
  197.                      vec2(-170, -15) * Scale,
  198.                      vec2(-260, -15) * Scale)
  199.    
  200.     EGP:egpClear()
  201.    
  202.     N++ BaseAim = N
  203.     EGP:egp3DTracker(N, vec())
  204.     EGP:egpParent(N, holoEntity(1))
  205.    
  206.     #Creating homing target displays
  207.     for (I = 1, MaxFoes)
  208.     {
  209.         N++ FoeTrackers[I, number] = N
  210.         EGP:egp3DTracker(N, vec())
  211.         EGP:egpParent(N, holoEntity(2 + I))
  212.        
  213.         local Shape = I == 1 ? Marker1 : Marker
  214.        
  215.         N++ FoeDisplays[I, number] = N
  216.         EGP:egpPolyOutline(N, Shape)
  217.         EGP:egpParent(N, N - 1)
  218.     }
  219.    
  220.     N++ HUDDark = N
  221.     EGP:egpPoly(N, Screen)
  222.     EGP:egpParent(N, BaseAim)
  223.     EGP:egpOrder(N, 0)
  224.    
  225.     N++
  226.     EGP:egpPolyOutline(N, Screen)
  227.     EGP:egpParent(N, BaseAim)
  228.    
  229.     N++
  230.     EGP:egpCircleOutline(N, vec2(), vec2(5) * Scale)
  231.     EGP:egpParent(N, BaseAim)
  232.    
  233.     N++
  234.     EGP:egpLine(N, vec2(5, 0) * Scale, vec2(25, 0) * Scale)
  235.     EGP:egpParent(N, BaseAim)
  236.    
  237.     N++
  238.     EGP:egpLine(N, vec2(-5, 0) * Scale, vec2(-25 , 0) * Scale)
  239.     EGP:egpParent(N, BaseAim)
  240.    
  241.     N++
  242.     EGP:egpLine(N, vec2(0, -5) * Scale, vec2(0, -20) * Scale)
  243.     EGP:egpParent(N, BaseAim)
  244.    
  245.     N++
  246.     EGP:egpBoxOutline(N, vec2(0, -250) * Scale, vec2(75, 30) * Scale)
  247.     EGP:egpParent(N, BaseAim)
  248.    
  249.     N++
  250.     EGP:egpPolyOutline(N, BoxLeft)
  251.     EGP:egpParent(N, BaseAim)
  252.    
  253.     N++
  254.     EGP:egpPolyOutline(N, BoxRight)
  255.     EGP:egpParent(N, BaseAim)
  256.    
  257.     N++ HUDHeading = N
  258.     EGP:egpText(N, "XXX", vec2(0, -250) * Scale)
  259.     EGP:egpAlign(N, 1, 1)
  260.     EGP:egpParent(N, BaseAim)
  261.    
  262.     N++ HUDAlt = N
  263.     EGP:egpText(N, "XXXX", vec2(180, 15) * Scale)
  264.     EGP:egpAlign(N, 0, 2)
  265.     EGP:egpParent(N, BaseAim)
  266.    
  267.     N++ HUDKnots = N
  268.     EGP:egpText(N, "XXXX", vec2(-180, 15) * Scale)
  269.     EGP:egpAlign(N, 2, 2)
  270.     EGP:egpParent(N, BaseAim)
  271.    
  272.     N++
  273.     EGP:egpText(N, "a", vec2(-240, 140) * Scale)
  274.     EGP:egpAlign(N, 1, 2)
  275.     EGP:egpParent(N, BaseAim)
  276.    
  277.     N++ HUDAlpha = N
  278.     EGP:egpText(N, "XXXX", vec2(-175, 140) * Scale)
  279.     EGP:egpAlign(N, 2, 2)
  280.     EGP:egpParent(N, BaseAim)
  281.    
  282.     N++
  283.     EGP:egpText(N, "M", vec2(-240, 160) * Scale)
  284.     EGP:egpAlign(N, 1, 2)
  285.     EGP:egpParent(N, BaseAim)
  286.    
  287.     N++ HUDMach = N
  288.     EGP:egpText(N, "XXXX", vec2(-175, 160) * Scale)
  289.     EGP:egpAlign(N, 2, 2)
  290.     EGP:egpParent(N, BaseAim)
  291.    
  292.     N++
  293.     EGP:egpText(N, "G", vec2(-240, 180) * Scale)
  294.     EGP:egpAlign(N, 1, 2)
  295.     EGP:egpParent(N, BaseAim)
  296.    
  297.     N++ HUDGForce = N
  298.     EGP:egpText(N, "XXXX", vec2(-175, 180) * Scale)
  299.     EGP:egpAlign(N, 2, 2)
  300.     EGP:egpParent(N, BaseAim)
  301.    
  302.     if (!SimplifiedMode)
  303.     {
  304.         #Creating elevation ladder lines
  305.         for (I = 1, 4)
  306.         {
  307.             local Angle = -10 + 5 * I
  308.             local PosX  = 5000 * cos(Angle)
  309.             local PosZ  = 5000 * sin(Angle)
  310.            
  311.             N++ Tracker = N
  312.             EGP:egp3DTracker(N, vec(PosX, 0, PosZ))
  313.             EGP:egpParent(N, holoEntity(2))
  314.            
  315.             N++
  316.             EGP:egpLine(N, vec2(30, 0) * Scale, vec2(110, 0) * Scale)
  317.             EGP:egpParent(N, Tracker)
  318.        
  319.             N++
  320.             EGP:egpLine(N, vec2(-30, 0) * Scale, vec2(-110, 0) * Scale)
  321.             EGP:egpParent(N, Tracker)
  322.            
  323.             N++ LaddersL[I, number] = N
  324.             EGP:egpText(N, "XX", vec2(-120, 0) * Scale)
  325.             EGP:egpAlign(N, 2, 1)
  326.             EGP:egpParent(N, Tracker)
  327.            
  328.             N++ LaddersR[I, number] = N
  329.             EGP:egpText(N, "XX", vec2(120, 0) * Scale)
  330.             EGP:egpAlign(N, 0, 1)
  331.             EGP:egpParent(N, Tracker)
  332.         }
  333.     }
  334.    
  335.     for (I = 1, N)
  336.     {
  337.         EGP:egpColor(I, Color)
  338.         EGP:egpSize(I, Size)
  339.     }
  340.    
  341.     EGP:egpColor(HUDDark, vec4(30, 30, 30, 200))
  342.     EGP:egpSize(HUDHeading, 30 * Scale)
  343.     EGP:egpSize(HUDKnots, 30 * Scale)
  344.     EGP:egpSize(HUDAlt, 30 * Scale)
  345.     EGP:egpSize(HUDAlpha, 20 * Scale)
  346.     EGP:egpSize(HUDAlpha - 1, 20 * Scale)
  347.     EGP:egpSize(HUDMach, 20 * Scale)
  348.     EGP:egpSize(HUDMach - 1, 20 * Scale)
  349.     EGP:egpSize(HUDGForce, 20 * Scale)
  350.     EGP:egpSize(HUDGForce - 1, 20 * Scale)
  351.    
  352.     foreach (K:number, V:number = FoeDisplays)
  353.     {
  354.         EGP:egpAlpha(V, 0)
  355.     }
  356.    
  357.     foreach (K:number, V:number = LaddersL:add(LaddersR))
  358.     {
  359.         EGP:egpSize(V, 20 * Scale)
  360.     }
  361. }
  362. elseif (clkName())
  363. {
  364.     switch (clkName())
  365.     {
  366.         case "Radar", coneRadarFind()
  367.         case "interval",
  368.             if (!Active) { break }
  369.  
  370.             interval(150)
  371.  
  372.             Velocity = floor(Base:vel():length() * 4) #Multiplied by 4 because of the 1:4 scale.
  373.             Angles   = floor(-Base:angles(), 1)
  374.             AnglesX  = floor(Angles[1] / 5) * 5
  375.             Altitude = floor((Base:pos()[3] - GroundAlt) * 0.333) #Multiplied by 0.333 instead of 0.083 because of the 1:4 scale
  376.             GForce   = floor(1 + $Velocity * 0.0173, 2) #Delta Vel(in/s) / Interval in seconds(s) * 0.0026
  377.            
  378.             if (changed(Velocity))
  379.             {
  380.                 local Knots = floor(toUnit("knots", Velocity))
  381.                 local Mach  = floor(toUnit("mach", Velocity), 2)
  382.                                      
  383.                 EGP:egpSetText(HUDKnots, "" + Knots)
  384.                 EGP:egpSetText(HUDMach, "" + Mach)
  385.             }
  386.             if (changed(Angles))
  387.             {
  388.                 local Heading = 180 + floor(Angles[2])
  389.                
  390.                 EGP:egpAngle(BaseAim, Angles[3])
  391.                 EGP:egpSetText(HUDHeading, "" + Heading)
  392.                 EGP:egpSetText(HUDAlpha, "" + Angles[1])
  393.                
  394.                 holoAng(2, -ang(AnglesX, Angles[2], 0))
  395.             }
  396.             if (changed(AnglesX)) { updateLadderDegrees() }
  397.             if (changed(Altitude)) { EGP:egpSetText(HUDAlt, "" + Altitude) }
  398.             if (changed(GForce)) { EGP:egpSetText(HUDGForce, "" + GForce) }
  399.         break
  400.     }
  401. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!