diff --git a/BUK-M2/BUK-M2-set.xml b/BUK-M2/BUK-M2-set.xml index f81aad3..92bb3c2 100644 --- a/BUK-M2/BUK-M2-set.xml +++ b/BUK-M2/BUK-M2-set.xml @@ -130,7 +130,57 @@ true - + + + + nasal + + + + + + enemies + + dialog-show + enemies + + + + + enemies + + dialog-show + priority + + + + + + nasal + + + + + + + nasal + + + @@ -245,6 +295,48 @@ false false + + 62 + 0.00 + 0.15 + radar + APN0506 + true + 31 + 360 + 170 + 24 + 11000 + 0 + 15 + 0 + 1576 + 145 + 900 + 0.20 + 1.312336 + 2 + 0.5 + 60 + 3000 + 0 + 1.6 + 200 + true + 5.5 + false + 24 + 0.92 + 3 + 1 + A + Bird away + true + false + 0 + 0 + 3 + @@ -294,6 +386,17 @@ 0 1 + + + + 0 + true + 1212 + /instrumentation/datalink/power + instrumentation/datalink/channel + 1 + + @@ -315,7 +418,11 @@ Aircraft/BUK-M2/Nasal/guided-missiles.nas + + Aircraft/BUK-M2/Nasal/datalink.nas + + Aircraft/BUK-M2/Nasal/fire-control-custom.nas Aircraft/BUK-M2/Nasal/fire-control.nas diff --git a/BUK-M2/Models/Armament/Weapons/M317/9M317.ac b/BUK-M2/Models/Armament/Weapons/M317/9M317.ac new file mode 100644 index 0000000..b3ca0b0 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/9M317.ac @@ -0,0 +1,1544 @@ +AC3Db +MATERIAL "DefaultWhite" rgb 1.0000 1.0000 1.0000 amb 0.2000 0.2000 0.2000 emis 0.0000 0.0000 0.0000 spec 0.5000 0.5000 0.5000 shi 10 trans 0.0000 +MATERIAL "BaseMat" rgb 0.8000 0.8000 0.8000 amb 1.0000 1.0000 1.0000 emis 0.0000 0.0000 0.0000 spec 0.5000 0.5000 0.5000 shi 12 trans 0.0000 +OBJECT world +name "Blender_export__s-200.ac" +kids 1 +OBJECT poly +name "missile1" +data 12 +Cylinder.014 +crease 35.0 +texture "BUK-M2.png" +texrep 1 1 +numvert 209 +1.68637 0.11991 -0.13685 +1.93720 0.11846 -0.13685 +1.78881 0.34799 -0.36552 +1.93705 0.34322 -0.36160 +1.78882 0.34897 -0.36453 +1.68638 0.12089 -0.13587 +1.93721 0.11945 -0.13587 +1.93705 0.34420 -0.36062 +1.68487 -0.14084 -0.12963 +1.93570 -0.14228 -0.12963 +1.78468 -0.37009 -0.35830 +1.93296 -0.36702 -0.35439 +1.78468 -0.36910 -0.35928 +1.68487 -0.13986 -0.13062 +1.93571 -0.14130 -0.13062 +1.93296 -0.36604 -0.35537 +1.68487 -0.13986 0.12943 +1.93571 -0.14130 0.12943 +1.78468 -0.36910 0.35810 +1.93296 -0.36604 0.35418 +1.78468 -0.37009 0.35712 +1.68487 -0.14084 0.12845 +1.93570 -0.14228 0.12845 +1.93296 -0.36702 0.35320 +1.68854 0.11989 0.13598 +1.93937 0.11844 0.13598 +1.79098 0.34797 0.36465 +1.93921 0.34320 0.36073 +1.79097 0.34699 0.36563 +1.68853 0.11890 0.13696 +1.93936 0.11746 0.13696 +1.93921 0.34222 0.36172 +-0.78236 0.13412 -0.13685 +0.54530 0.12648 -0.13685 +-0.43137 0.36077 -0.36552 +0.44626 0.35180 -0.36160 +-0.43136 0.36175 -0.36453 +-0.78236 0.13510 -0.13587 +0.54531 0.12746 -0.13587 +0.44626 0.35278 -0.36062 +-0.78386 -0.12663 -0.12963 +0.54380 -0.13427 -0.12963 +-0.43550 -0.35731 -0.35830 +0.44217 -0.35844 -0.35439 +-0.43550 -0.35633 -0.35928 +-0.78386 -0.12565 -0.13062 +0.54381 -0.13329 -0.13062 +0.44218 -0.35746 -0.35537 +-0.78386 -0.12565 0.12943 +0.54381 -0.13329 0.12943 +-0.43550 -0.35633 0.35810 +0.44218 -0.35746 0.35418 +-0.43550 -0.35731 0.35712 +-0.78386 -0.12663 0.12845 +0.54380 -0.13427 0.12845 +0.44217 -0.35844 0.35320 +-0.78019 0.13410 0.13598 +0.54747 0.12645 0.13598 +-0.42920 0.36075 0.36465 +0.44843 0.35178 0.36073 +-0.42921 0.35977 0.36563 +-0.78020 0.13311 0.13696 +0.54746 0.12547 0.13696 +0.44842 0.35080 0.36172 +1.94042 0.00093 -0.19017 +-0.93129 0.00093 -0.19017 +1.94042 0.07375 -0.17568 +-0.93129 0.07375 -0.17568 +1.94042 0.13549 -0.13443 +-0.93129 0.13549 -0.13443 +1.94042 0.17674 -0.07269 +-0.93129 0.17674 -0.07269 +1.94042 0.19122 0.00013 +-0.93129 0.19122 0.00013 +1.94042 0.17674 0.07295 +-0.93129 0.17674 0.07295 +1.94042 0.13549 0.13469 +-0.93129 0.13549 0.13469 +1.94042 0.07375 0.17594 +-0.93129 0.07375 0.17594 +1.94042 0.00093 0.19043 +-0.93129 0.00093 0.19043 +1.94042 -0.07190 0.17594 +-0.93129 -0.07190 0.17594 +1.94042 -0.13363 0.13469 +-0.93129 -0.13363 0.13469 +1.94042 -0.17488 0.07295 +-0.93129 -0.17488 0.07295 +1.94042 -0.18937 0.00013 +-0.93129 -0.18937 0.00013 +1.94042 -0.17488 -0.07269 +-0.93129 -0.17488 -0.07269 +1.94042 -0.13363 -0.13443 +-0.93129 -0.13363 -0.13443 +1.94042 -0.07190 -0.17568 +-0.93129 -0.07190 -0.17568 +-1.48171 0.00093 -0.15656 +-1.48171 0.06089 -0.14463 +-1.48171 0.11172 -0.11067 +-1.48171 0.14569 -0.05983 +-1.48171 0.15762 0.00013 +-1.48171 0.14569 0.06009 +-1.48171 0.11172 0.11093 +-1.48171 0.06089 0.14489 +-1.48171 0.00093 0.15682 +-1.48171 -0.05904 0.14489 +-1.48171 -0.10987 0.11093 +-1.48171 -0.14383 0.06009 +-1.48171 -0.15576 0.00013 +-1.48171 -0.14383 -0.05983 +-1.48171 -0.10987 -0.11067 +-1.48171 -0.05904 -0.14463 +-2.41768 0.00093 -0.15656 +-2.41768 0.06089 -0.14463 +-2.41768 0.11172 -0.11067 +-2.41768 0.14569 -0.05983 +-2.41768 0.15762 0.00013 +-2.41768 0.14569 0.06009 +-2.41768 0.11172 0.11093 +-2.41768 0.06089 0.14489 +-2.41768 0.00093 0.15682 +-2.41768 -0.05904 0.14489 +-2.41768 -0.10987 0.11093 +-2.41768 -0.14383 0.06009 +-2.41768 -0.15576 0.00013 +-2.41768 -0.14383 -0.05983 +-2.41768 -0.10987 -0.11067 +-2.41768 -0.05904 -0.14463 +-2.65559 0.00093 -0.13518 +-2.65559 0.05271 -0.12488 +-2.65559 0.09660 -0.09555 +-2.65559 0.12593 -0.05165 +-2.65559 0.13623 0.00013 +-2.65559 0.12593 0.05191 +-2.65559 0.09660 0.09581 +-2.65559 0.05271 0.12514 +-2.65559 0.00093 0.13544 +-2.65559 -0.05085 0.12514 +-2.65559 -0.09475 0.09581 +-2.65559 -0.12408 0.05191 +-2.65559 -0.13438 0.00013 +-2.65559 -0.12408 -0.05165 +-2.65559 -0.09475 -0.09555 +-2.65559 -0.05085 -0.12488 +-2.91627 0.00093 -0.08806 +-2.91627 0.03467 -0.08134 +-2.91627 0.06328 -0.06223 +-2.91627 0.08240 -0.03362 +-2.91627 0.08911 0.00013 +-2.91627 0.08240 0.03388 +-2.91627 0.06328 0.06249 +-2.91627 0.03467 0.08160 +-2.91627 0.00093 0.08832 +-2.91627 -0.03282 0.08160 +-2.91627 -0.06143 0.06249 +-2.91627 -0.08055 0.03388 +-2.91627 -0.08726 0.00013 +-2.91627 -0.08055 -0.03362 +-2.91627 -0.06143 -0.06223 +-2.91627 -0.03282 -0.08134 +-3.00698 0.00093 -0.05063 +-3.00698 0.02035 -0.04676 +-3.00698 0.03682 -0.03576 +-3.00698 0.04782 -0.01929 +-3.00698 0.05168 0.00013 +-3.00698 0.04782 0.01955 +-3.00698 0.03682 0.03602 +-3.00698 0.02035 0.04702 +-3.00698 0.00093 0.05089 +-3.00698 -0.01850 0.04702 +-3.00698 -0.03496 0.03602 +-3.00698 -0.04597 0.01955 +-3.00698 -0.04983 0.00013 +-3.00698 -0.04597 -0.01929 +-3.00698 -0.03496 -0.03576 +-3.00698 -0.01850 -0.04676 +-3.13379 0.00093 0.00013 +1.94042 0.00093 -0.14466 +1.94042 0.05634 -0.13364 +1.94042 0.10331 -0.10225 +1.94042 0.13469 -0.05528 +1.94042 0.14572 0.00013 +1.94042 0.13469 0.05554 +1.94042 0.10331 0.10251 +1.94042 0.05634 0.13390 +1.94042 0.00093 0.14492 +1.94042 -0.05448 0.13390 +1.94042 -0.10145 0.10251 +1.94042 -0.13284 0.05554 +1.94042 -0.14386 0.00013 +1.94042 -0.13284 -0.05528 +1.94042 -0.10145 -0.10225 +1.94042 -0.05448 -0.13364 +1.44438 0.00093 -0.14109 +1.44438 0.05497 -0.13034 +1.44438 0.10079 -0.09973 +1.44438 0.13140 -0.05391 +1.44438 0.14215 0.00013 +1.44438 0.13140 0.05417 +1.44438 0.10079 0.09999 +1.44438 0.05497 0.13061 +1.44438 0.00093 0.14136 +1.44438 -0.05312 0.13061 +1.44438 -0.09893 0.09999 +1.44438 -0.12955 0.05417 +1.44438 -0.14030 0.00013 +1.44438 -0.12955 -0.05391 +1.44438 -0.09893 -0.09973 +1.44438 -0.05312 -0.13034 +numsurf 189 +SURF 0X0 +mat 1 +refs 4 +0 0.821904 0.832671 +2 0.821904 0.832671 +3 0.821904 0.832671 +1 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +5 0.821904 0.832671 +6 0.821904 0.832671 +7 0.821904 0.832671 +4 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +3 0.821904 0.832671 +2 0.821904 0.832671 +4 0.821904 0.832671 +7 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +0 0.821904 0.832671 +1 0.821904 0.832671 +6 0.821904 0.832671 +5 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +1 0.821904 0.832671 +3 0.821904 0.832671 +7 0.821904 0.832671 +6 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +2 0.821904 0.832671 +0 0.821904 0.832671 +5 0.821904 0.832671 +4 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +8 0.821904 0.832671 +10 0.821904 0.832671 +11 0.821904 0.832671 +9 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +13 0.821904 0.832671 +14 0.821904 0.832671 +15 0.821904 0.832671 +12 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +11 0.821904 0.832671 +10 0.821904 0.832671 +12 0.821904 0.832671 +15 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +8 0.821904 0.832671 +9 0.821904 0.832671 +14 0.821904 0.832671 +13 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +9 0.821904 0.832671 +11 0.821904 0.832671 +15 0.821904 0.832671 +14 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +10 0.821904 0.832671 +8 0.821904 0.832671 +13 0.821904 0.832671 +12 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +16 0.933871 0.902116 +18 0.852384 0.903391 +19 0.853792 0.901094 +17 0.932835 0.899493 +SURF 0X0 +mat 1 +refs 4 +21 0.933506 0.899459 +22 0.932819 0.902115 +23 0.853643 0.903375 +20 0.851770 0.901094 +SURF 0X0 +mat 1 +refs 4 +19 0.000000 0.000000 +18 0.000000 0.000000 +20 0.000000 0.000000 +23 0.000000 0.000000 +SURF 0X0 +mat 1 +refs 4 +16 0.933871 0.902116 +17 0.932835 0.899493 +22 0.932819 0.902115 +21 0.933506 0.899459 +SURF 0X0 +mat 1 +refs 4 +17 0.932835 0.899493 +19 0.853792 0.901094 +23 0.853643 0.903375 +22 0.932819 0.902115 +SURF 0X0 +mat 1 +refs 4 +18 0.852384 0.903391 +16 0.933871 0.902116 +21 0.933506 0.899459 +20 0.851770 0.901094 +SURF 0X0 +mat 1 +refs 4 +24 0.821904 0.832671 +26 0.821904 0.832671 +27 0.821904 0.832671 +25 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +29 0.821904 0.832671 +30 0.821904 0.832671 +31 0.821904 0.832671 +28 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +27 0.821904 0.832671 +26 0.821904 0.832671 +28 0.821904 0.832671 +31 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +24 0.821904 0.832671 +25 0.821904 0.832671 +30 0.821904 0.832671 +29 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +25 0.821904 0.832671 +27 0.821904 0.832671 +31 0.821904 0.832671 +30 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +26 0.821904 0.832671 +24 0.821904 0.832671 +29 0.821904 0.832671 +28 0.821904 0.832671 +SURF 0X0 +mat 1 +refs 4 +32 0.970304 0.884794 +34 0.966778 0.958774 +35 0.957565 0.952593 +33 0.948163 0.869767 +SURF 0X0 +mat 1 +refs 4 +37 0.948163 0.890647 +38 0.965193 0.881300 +39 0.967358 0.953253 +36 0.961723 0.965834 +SURF 0X0 +mat 1 +refs 4 +35 0.957565 0.952593 +34 0.966778 0.958774 +36 0.961723 0.965834 +39 0.967358 0.953253 +SURF 0X0 +mat 1 +refs 4 +33 0.948163 0.869767 +35 0.957565 0.952593 +39 0.967358 0.953253 +38 0.965193 0.881300 +SURF 0X0 +mat 1 +refs 4 +34 0.966778 0.958774 +32 0.970304 0.884794 +37 0.948163 0.890647 +36 0.961723 0.965834 +SURF 0X0 +mat 1 +refs 4 +40 0.821929 0.832696 +42 0.890437 0.841267 +43 0.890434 0.865761 +41 0.823687 0.869718 +SURF 0X0 +mat 1 +refs 4 +45 0.959373 0.832696 +46 0.957608 0.869718 +47 0.890862 0.865748 +44 0.890864 0.841255 +SURF 0X0 +mat 1 +refs 4 +43 0.890434 0.865761 +42 0.890437 0.841267 +44 0.890864 0.841255 +47 0.890862 0.865748 +SURF 0X0 +mat 1 +refs 4 +41 0.000000 0.000000 +43 0.000000 0.000000 +47 0.000000 0.000000 +46 0.000000 0.000000 +SURF 0X0 +mat 1 +refs 4 +42 0.000000 0.000000 +40 0.000000 0.000000 +45 0.000000 0.000000 +44 0.000000 0.000000 +SURF 0X0 +mat 1 +refs 4 +48 0.834414 0.966811 +50 0.821929 0.886834 +51 0.830003 0.875049 +49 0.851721 0.946403 +SURF 0X0 +mat 1 +refs 4 +53 0.846865 0.951751 +54 0.829108 0.946403 +55 0.822882 0.869767 +52 0.832092 0.883696 +SURF 0X0 +mat 1 +refs 4 +51 0.830003 0.875049 +50 0.821929 0.886834 +52 0.832092 0.883696 +55 0.822882 0.869767 +SURF 0X0 +mat 1 +refs 4 +49 0.851721 0.946403 +51 0.830003 0.875049 +55 0.822882 0.869767 +54 0.829108 0.946403 +SURF 0X0 +mat 1 +refs 4 +50 0.821929 0.886834 +48 0.834414 0.966811 +53 0.846865 0.951751 +52 0.832092 0.883696 +SURF 0X0 +mat 1 +refs 4 +56 0.871957 0.876509 +58 0.948114 0.870404 +59 0.937390 0.879066 +57 0.867273 0.895362 +SURF 0X0 +mat 1 +refs 4 +61 0.871957 0.899411 +62 0.851770 0.881845 +63 0.934250 0.869767 +60 0.942580 0.877094 +SURF 0X0 +mat 1 +refs 4 +59 0.937390 0.879066 +58 0.948114 0.870404 +60 0.942580 0.877094 +63 0.934250 0.869767 +SURF 0X0 +mat 1 +refs 4 +57 0.867273 0.895362 +59 0.937390 0.879066 +63 0.934250 0.869767 +62 0.851770 0.881845 +SURF 0X0 +mat 1 +refs 4 +58 0.948114 0.870404 +56 0.871957 0.876509 +61 0.871957 0.899411 +60 0.942580 0.877094 +SURF 0X10 +mat 1 +refs 4 +64 0.118772 0.892513 +65 0.122949 0.914859 +67 0.113965 0.914818 +66 0.118684 0.892619 +SURF 0X10 +mat 1 +refs 4 +66 0.118684 0.892619 +67 0.113965 0.914818 +69 0.105668 0.911360 +68 0.118565 0.892681 +SURF 0X10 +mat 1 +refs 4 +68 0.118565 0.892681 +69 0.105668 0.911360 +71 0.099310 0.904987 +70 0.118433 0.892693 +SURF 0X10 +mat 1 +refs 4 +70 0.118433 0.892693 +71 0.099310 0.904987 +73 0.095863 0.896649 +72 0.118306 0.892652 +SURF 0X10 +mat 1 +refs 4 +72 0.118306 0.892652 +73 0.095863 0.896649 +75 0.095870 0.887601 +74 0.118205 0.892565 +SURF 0X10 +mat 1 +refs 4 +74 0.118205 0.892565 +75 0.095870 0.887601 +77 0.099347 0.879239 +76 0.118148 0.892446 +SURF 0X10 +mat 1 +refs 4 +76 0.118148 0.892446 +77 0.099347 0.879239 +79 0.105771 0.872850 +78 0.118139 0.892316 +SURF 0X10 +mat 1 +refs 4 +78 0.118139 0.892316 +79 0.105771 0.872850 +81 0.114157 0.869417 +80 0.118177 0.892192 +SURF 0X10 +mat 1 +refs 4 +80 0.118177 0.892192 +81 0.114157 0.869417 +83 0.123214 0.869465 +82 0.118258 0.892088 +SURF 0X10 +mat 1 +refs 4 +82 0.118258 0.892088 +83 0.123214 0.869465 +85 0.131554 0.872982 +84 0.118371 0.892033 +SURF 0X10 +mat 1 +refs 4 +84 0.118371 0.892033 +85 0.131554 0.872982 +87 0.137909 0.879429 +86 0.118498 0.892019 +SURF 0X10 +mat 1 +refs 4 +86 0.118498 0.892019 +87 0.137909 0.879429 +89 0.141307 0.887818 +88 0.118623 0.892055 +SURF 0X10 +mat 1 +refs 4 +88 0.118623 0.892055 +89 0.141307 0.887818 +91 0.141232 0.896859 +90 0.118726 0.892137 +SURF 0X10 +mat 1 +refs 4 +90 0.118726 0.892137 +91 0.141232 0.896859 +93 0.137705 0.905167 +92 0.118792 0.892250 +SURF 0X10 +mat 1 +refs 4 +73 0.631114 0.940940 +71 0.610103 0.961861 +99 0.594246 0.938582 +100 0.607492 0.925506 +SURF 0X10 +mat 1 +refs 4 +94 0.118810 0.892382 +95 0.131281 0.911480 +65 0.122949 0.914859 +64 0.118772 0.892513 +SURF 0X10 +mat 1 +refs 4 +92 0.118792 0.892250 +93 0.137705 0.905167 +95 0.131281 0.911480 +94 0.118810 0.892382 +SURF 0X10 +mat 1 +refs 4 +80 0.557004 0.956338 +82 0.529259 0.964757 +186 0.527331 0.947438 +185 0.548610 0.940371 +SURF 0X10 +mat 1 +refs 4 +83 0.582691 0.824220 +81 0.610090 0.835449 +104 0.594716 0.859076 +105 0.577592 0.851862 +SURF 0X10 +mat 1 +refs 4 +93 0.494496 0.913089 +91 0.494557 0.883872 +109 0.522005 0.888970 +110 0.521893 0.907463 +SURF 0X10 +mat 1 +refs 4 +69 0.582704 0.973074 +67 0.553154 0.972863 +97 0.558520 0.945324 +98 0.577036 0.945540 +SURF 0X10 +mat 1 +refs 4 +79 0.631110 0.856389 +77 0.642496 0.883820 +102 0.614841 0.889638 +103 0.607808 0.872343 +SURF 0X10 +mat 1 +refs 4 +89 0.505579 0.856823 +87 0.526096 0.835911 +107 0.542030 0.858845 +108 0.529032 0.871914 +SURF 0X10 +mat 1 +refs 4 +75 0.642496 0.913523 +73 0.631114 0.940940 +100 0.607492 0.925506 +101 0.614730 0.908313 +SURF 0X10 +mat 1 +refs 4 +85 0.553167 0.824410 +83 0.582691 0.824220 +105 0.577592 0.851862 +106 0.559081 0.851788 +SURF 0X10 +mat 1 +refs 4 +95 0.505465 0.940274 +93 0.494496 0.913089 +110 0.521893 0.907463 +111 0.528706 0.924679 +SURF 0X10 +mat 1 +refs 4 +71 0.610103 0.961861 +69 0.582704 0.973074 +98 0.577036 0.945540 +99 0.594246 0.938582 +SURF 0X10 +mat 1 +refs 4 +81 0.610090 0.835449 +79 0.631110 0.856389 +103 0.607808 0.872343 +104 0.594716 0.859076 +SURF 0X10 +mat 1 +refs 4 +67 0.553154 0.972863 +65 0.526024 0.961307 +96 0.541548 0.937986 +97 0.558520 0.945324 +SURF 0X10 +mat 1 +refs 4 +91 0.494557 0.883872 +89 0.505579 0.856823 +108 0.529032 0.871914 +109 0.522005 0.888970 +SURF 0X10 +mat 1 +refs 4 +77 0.642496 0.883820 +75 0.642496 0.913523 +101 0.614730 0.908313 +102 0.614841 0.889638 +SURF 0X10 +mat 1 +refs 4 +87 0.526096 0.835911 +85 0.553167 0.824410 +106 0.559081 0.851788 +107 0.542030 0.858845 +SURF 0X10 +mat 1 +refs 4 +65 0.526024 0.961307 +95 0.505465 0.940274 +111 0.528706 0.924679 +96 0.541548 0.937986 +SURF 0X10 +mat 1 +refs 4 +104 0.594716 0.859076 +103 0.607808 0.872343 +119 0.585283 0.887804 +120 0.579834 0.881894 +SURF 0X10 +mat 1 +refs 4 +97 0.558520 0.945324 +96 0.541548 0.937986 +112 0.556432 0.915461 +113 0.563513 0.918806 +SURF 0X10 +mat 1 +refs 4 +96 0.541548 0.937986 +111 0.528706 0.924679 +127 0.551247 0.909530 +112 0.556432 0.915461 +SURF 0X10 +mat 1 +refs 4 +105 0.577592 0.851862 +104 0.594716 0.859076 +120 0.579834 0.881894 +121 0.572591 0.878528 +SURF 0X10 +mat 1 +refs 4 +98 0.577036 0.945540 +97 0.558520 0.945324 +113 0.563513 0.918806 +114 0.571365 0.919088 +SURF 0X10 +mat 1 +refs 4 +106 0.559081 0.851788 +105 0.577592 0.851862 +121 0.572591 0.878528 +122 0.564740 0.878153 +SURF 0X10 +mat 1 +refs 4 +99 0.594246 0.938582 +98 0.577036 0.945540 +114 0.571365 0.919088 +115 0.578765 0.916270 +SURF 0X10 +mat 1 +refs 4 +107 0.542030 0.858845 +106 0.559081 0.851788 +122 0.564740 0.878153 +123 0.557440 0.880879 +SURF 0X10 +mat 1 +refs 4 +100 0.607492 0.925506 +99 0.594246 0.938582 +115 0.578765 0.916270 +116 0.584559 0.910775 +SURF 0X10 +mat 1 +refs 4 +108 0.529032 0.871914 +107 0.542030 0.858845 +123 0.557440 0.880879 +124 0.551831 0.886307 +SURF 0X10 +mat 1 +refs 4 +101 0.614730 0.908313 +100 0.607492 0.925506 +116 0.584559 0.910775 +117 0.587842 0.903435 +SURF 0X10 +mat 1 +refs 4 +109 0.522005 0.888970 +108 0.529032 0.871914 +124 0.551831 0.886307 +125 0.548852 0.893638 +SURF 0X10 +mat 1 +refs 4 +102 0.614841 0.889638 +101 0.614730 0.908313 +117 0.587842 0.903435 +118 0.588098 0.895368 +SURF 0X10 +mat 1 +refs 4 +110 0.521893 0.907463 +109 0.522005 0.888970 +125 0.548852 0.893638 +126 0.548855 0.901872 +SURF 0X10 +mat 1 +refs 4 +103 0.607808 0.872343 +102 0.614841 0.889638 +118 0.588098 0.895368 +119 0.585283 0.887804 +SURF 0X10 +mat 1 +refs 4 +111 0.528706 0.924679 +110 0.521893 0.907463 +126 0.548855 0.901872 +127 0.551247 0.909530 +SURF 0X10 +mat 1 +refs 4 +125 0.844466 0.970889 +124 0.818915 0.945418 +140 0.836660 0.933278 +141 0.856107 0.952964 +SURF 0X10 +mat 1 +refs 4 +118 0.915834 0.806205 +117 0.947419 0.820515 +133 0.935762 0.837177 +134 0.910910 0.826384 +SURF 0X10 +mat 1 +refs 4 +126 0.877665 0.984553 +125 0.844466 0.970889 +141 0.856107 0.952964 +142 0.881526 0.963624 +SURF 0X10 +mat 1 +refs 4 +119 0.880640 0.804784 +118 0.915834 0.806205 +134 0.910910 0.826384 +135 0.883715 0.825610 +SURF 0X10 +mat 1 +refs 4 +127 0.913428 0.984464 +126 0.877665 0.984553 +142 0.881526 0.963624 +143 0.908997 0.963725 +SURF 0X10 +mat 1 +refs 4 +120 0.847153 0.817006 +119 0.880640 0.804784 +135 0.883715 0.825610 +136 0.858075 0.835296 +SURF 0X10 +mat 1 +refs 4 +113 0.971392 0.945572 +112 0.946324 0.970744 +128 0.934339 0.953334 +129 0.953725 0.934102 +SURF 0X10 +mat 1 +refs 4 +112 0.946324 0.970744 +127 0.913428 0.984464 +143 0.908997 0.963725 +128 0.934339 0.953334 +SURF 0X10 +mat 1 +refs 4 +121 0.820570 0.841438 +120 0.847153 0.817006 +136 0.858075 0.835296 +137 0.837987 0.854251 +SURF 0X10 +mat 1 +refs 4 +114 0.984892 0.912854 +113 0.971392 0.945572 +129 0.953725 0.934102 +130 0.964270 0.909003 +SURF 0X10 +mat 1 +refs 4 +122 0.805281 0.874941 +121 0.820570 0.841438 +137 0.837987 0.854251 +138 0.826986 0.879718 +SURF 0X10 +mat 1 +refs 4 +115 0.984892 0.877623 +114 0.984892 0.912854 +130 0.964270 0.909003 +131 0.964465 0.881869 +SURF 0X10 +mat 1 +refs 4 +123 0.805020 0.911829 +122 0.805281 0.874941 +138 0.826986 0.879718 +139 0.826299 0.907496 +SURF 0X10 +mat 1 +refs 4 +116 0.971600 0.845250 +115 0.984892 0.877623 +131 0.964465 0.881869 +132 0.954412 0.856755 +SURF 0X10 +mat 1 +refs 4 +124 0.818915 0.945418 +123 0.805020 0.911829 +139 0.826299 0.907496 +140 0.836660 0.933278 +SURF 0X10 +mat 1 +refs 4 +117 0.947419 0.820515 +116 0.971600 0.845250 +132 0.954412 0.856755 +133 0.935762 0.837177 +SURF 0X10 +mat 1 +refs 4 +131 0.964465 0.881869 +130 0.964270 0.909003 +146 0.936371 0.903592 +147 0.936681 0.887457 +SURF 0X10 +mat 1 +refs 4 +139 0.826299 0.907496 +138 0.826986 0.879718 +154 0.855172 0.885457 +155 0.854754 0.901839 +SURF 0X10 +mat 1 +refs 4 +132 0.954412 0.856755 +131 0.964465 0.881869 +147 0.936681 0.887457 +148 0.930852 0.872440 +SURF 0X10 +mat 1 +refs 4 +140 0.836660 0.933278 +139 0.826299 0.907496 +155 0.854754 0.901839 +156 0.860664 0.917120 +SURF 0X10 +mat 1 +refs 4 +133 0.935762 0.837177 +132 0.954412 0.856755 +148 0.930852 0.872440 +149 0.919796 0.860764 +SURF 0X10 +mat 1 +refs 4 +141 0.856107 0.952964 +140 0.836660 0.933278 +156 0.860664 0.917120 +157 0.871986 0.928898 +SURF 0X10 +mat 1 +refs 4 +134 0.910910 0.826384 +133 0.935762 0.837177 +149 0.919796 0.860764 +150 0.905087 0.854191 +SURF 0X10 +mat 1 +refs 4 +142 0.881526 0.963624 +141 0.856107 0.952964 +157 0.871986 0.928898 +158 0.886934 0.935396 +SURF 0X10 +mat 1 +refs 4 +135 0.883715 0.825610 +134 0.910910 0.826384 +150 0.905087 0.854191 +151 0.888931 0.853686 +SURF 0X10 +mat 1 +refs 4 +143 0.908997 0.963725 +142 0.881526 0.963624 +158 0.886934 0.935396 +159 0.903196 0.935659 +SURF 0X10 +mat 1 +refs 4 +136 0.858075 0.835296 +135 0.883715 0.825610 +151 0.888931 0.853686 +152 0.873744 0.859396 +SURF 0X10 +mat 1 +refs 4 +129 0.953725 0.934102 +128 0.934339 0.953334 +144 0.918288 0.929687 +145 0.929927 0.918420 +SURF 0X10 +mat 1 +refs 4 +128 0.934339 0.953334 +143 0.908997 0.963725 +159 0.903196 0.935659 +144 0.918288 0.929687 +SURF 0X10 +mat 1 +refs 4 +137 0.837987 0.854251 +136 0.858075 0.835296 +152 0.873744 0.859396 +153 0.861860 0.870538 +SURF 0X10 +mat 1 +refs 4 +130 0.964270 0.909003 +129 0.953725 0.934102 +145 0.929927 0.918420 +146 0.936371 0.903592 +SURF 0X10 +mat 1 +refs 4 +138 0.826986 0.879718 +137 0.837987 0.854251 +153 0.861860 0.870538 +154 0.855172 0.885457 +SURF 0X10 +mat 1 +refs 4 +152 0.873744 0.859396 +151 0.888931 0.853686 +167 0.891866 0.871647 +168 0.883343 0.874911 +SURF 0X10 +mat 1 +refs 4 +145 0.929927 0.918420 +144 0.918288 0.929687 +160 0.908378 0.914412 +161 0.914957 0.908106 +SURF 0X10 +mat 1 +refs 4 +144 0.918288 0.929687 +159 0.903196 0.935659 +175 0.899879 0.917725 +160 0.908378 0.914412 +SURF 0X10 +mat 1 +refs 4 +153 0.861860 0.870538 +152 0.873744 0.859396 +168 0.883343 0.874911 +169 0.876713 0.881200 +SURF 0X10 +mat 1 +refs 4 +146 0.936371 0.903592 +145 0.929927 0.918420 +161 0.914957 0.908106 +162 0.918624 0.899774 +SURF 0X10 +mat 1 +refs 4 +154 0.855172 0.885457 +153 0.861860 0.870538 +169 0.876713 0.881200 +170 0.873007 0.889561 +SURF 0X10 +mat 1 +refs 4 +147 0.936681 0.887457 +146 0.936371 0.903592 +162 0.918624 0.899774 +163 0.918835 0.890681 +SURF 0X10 +mat 1 +refs 4 +155 0.854754 0.901839 +154 0.855172 0.885457 +170 0.873007 0.889561 +171 0.872814 0.898696 +SURF 0X10 +mat 1 +refs 4 +148 0.930852 0.872440 +147 0.936681 0.887457 +163 0.918835 0.890681 +164 0.915566 0.882194 +SURF 0X10 +mat 1 +refs 4 +156 0.860664 0.917120 +155 0.854754 0.901839 +171 0.872814 0.898696 +172 0.876077 0.907228 +SURF 0X10 +mat 1 +refs 4 +149 0.919796 0.860764 +148 0.930852 0.872440 +164 0.915566 0.882194 +165 0.909307 0.875581 +SURF 0X10 +mat 1 +refs 4 +157 0.871986 0.928898 +156 0.860664 0.917120 +172 0.876077 0.907228 +173 0.882385 0.913846 +SURF 0X10 +mat 1 +refs 4 +150 0.905087 0.854191 +149 0.919796 0.860764 +165 0.909307 0.875581 +166 0.900977 0.871888 +SURF 0X10 +mat 1 +refs 4 +158 0.886934 0.935396 +157 0.871986 0.928898 +173 0.882385 0.913846 +174 0.890749 0.917531 +SURF 0X10 +mat 1 +refs 4 +151 0.888931 0.853686 +150 0.905087 0.854191 +166 0.900977 0.871888 +167 0.891866 0.871647 +SURF 0X10 +mat 1 +refs 4 +159 0.903196 0.935659 +158 0.886934 0.935396 +174 0.890749 0.917531 +175 0.899879 0.917725 +SURF 0X10 +mat 1 +refs 3 +173 0.882385 0.913846 +172 0.876077 0.907228 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +166 0.900977 0.871888 +165 0.909307 0.875581 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +174 0.890749 0.917531 +173 0.882385 0.913846 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +167 0.891866 0.871647 +166 0.900977 0.871888 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +175 0.899879 0.917725 +174 0.890749 0.917531 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +168 0.883343 0.874911 +167 0.891866 0.871647 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +161 0.914957 0.908106 +160 0.908378 0.914412 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +160 0.908378 0.914412 +175 0.899879 0.917725 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +169 0.876713 0.881200 +168 0.883343 0.874911 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +162 0.918624 0.899774 +161 0.914957 0.908106 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +170 0.873007 0.889561 +169 0.876713 0.881200 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +163 0.918835 0.890681 +162 0.918624 0.899774 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +171 0.872814 0.898696 +170 0.873007 0.889561 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +164 0.915566 0.882194 +163 0.918835 0.890681 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +172 0.876077 0.907228 +171 0.872814 0.898696 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 3 +165 0.909307 0.875581 +164 0.915566 0.882194 +176 0.895843 0.894687 +SURF 0X10 +mat 1 +refs 4 +178 0.508345 0.832597 +179 0.531617 0.832049 +195 0.527933 0.854445 +194 0.513570 0.854580 +SURF 0X10 +mat 1 +refs 4 +90 0.444540 0.905280 +92 0.444540 0.875717 +191 0.462172 0.879540 +190 0.461999 0.902113 +SURF 0X10 +mat 1 +refs 4 +66 0.504635 0.814512 +68 0.535119 0.813735 +179 0.531617 0.832049 +178 0.508345 0.832597 +SURF 0X10 +mat 1 +refs 4 +76 0.595969 0.910089 +78 0.580631 0.937571 +184 0.566349 0.925486 +183 0.577494 0.904391 +SURF 0X10 +mat 1 +refs 4 +86 0.476043 0.951946 +88 0.455813 0.932066 +189 0.470402 0.922604 +188 0.485814 0.937934 +SURF 0X10 +mat 1 +refs 4 +72 0.586801 0.846962 +74 0.598866 0.877348 +182 0.579664 0.880031 +181 0.570507 0.857387 +SURF 0X10 +mat 1 +refs 4 +82 0.529259 0.964757 +84 0.501392 0.962780 +187 0.505687 0.946106 +186 0.527331 0.947438 +SURF 0X10 +mat 1 +refs 4 +92 0.444540 0.875717 +94 0.455890 0.848099 +192 0.470937 0.858380 +191 0.462172 0.879540 +SURF 0X10 +mat 1 +refs 4 +68 0.535119 0.813735 +70 0.564024 0.824859 +180 0.553491 0.840618 +179 0.531617 0.832049 +SURF 0X10 +mat 1 +refs 4 +78 0.580631 0.937571 +80 0.557004 0.956338 +185 0.548610 0.940371 +184 0.566349 0.925486 +SURF 0X10 +mat 1 +refs 4 +64 0.476929 0.826617 +66 0.504635 0.814512 +178 0.508345 0.832597 +177 0.487103 0.841885 +SURF 0X10 +mat 1 +refs 4 +88 0.455813 0.932066 +90 0.444540 0.905280 +190 0.461999 0.902113 +189 0.470402 0.922604 +SURF 0X10 +mat 1 +refs 4 +74 0.598866 0.877348 +76 0.595969 0.910089 +183 0.577494 0.904391 +182 0.579664 0.880031 +SURF 0X10 +mat 1 +refs 4 +84 0.501392 0.962780 +86 0.476043 0.951946 +188 0.485814 0.937934 +187 0.505687 0.946106 +SURF 0X10 +mat 1 +refs 4 +94 0.455890 0.848099 +64 0.476929 0.826617 +177 0.487103 0.841885 +192 0.470937 0.858380 +SURF 0X10 +mat 1 +refs 4 +70 0.564024 0.824859 +72 0.586801 0.846962 +181 0.570507 0.857387 +180 0.553491 0.840618 +SURF 0X10 +mat 1 +refs 16 +193 0.118607 0.892427 +194 0.118566 0.892478 +195 0.118512 0.892509 +196 0.118451 0.892514 +197 0.118393 0.892495 +198 0.118348 0.892454 +199 0.118320 0.892399 +200 0.118313 0.892336 +201 0.118330 0.892276 +202 0.118369 0.892226 +203 0.118422 0.892195 +204 0.118485 0.892191 +205 0.118545 0.892210 +206 0.118593 0.892250 +207 0.118623 0.892305 +208 0.118628 0.892367 +SURF 0X10 +mat 1 +refs 4 +186 0.527331 0.947438 +187 0.505687 0.946106 +203 0.510116 0.926511 +202 0.524154 0.926430 +SURF 0X10 +mat 1 +refs 4 +179 0.531617 0.832049 +180 0.553491 0.840618 +196 0.541036 0.859967 +195 0.527933 0.854445 +SURF 0X10 +mat 1 +refs 4 +187 0.505687 0.946106 +188 0.485814 0.937934 +204 0.497322 0.920795 +203 0.510116 0.926511 +SURF 0X10 +mat 1 +refs 4 +180 0.553491 0.840618 +181 0.570507 0.857387 +197 0.550735 0.870282 +196 0.541036 0.859967 +SURF 0X10 +mat 1 +refs 4 +188 0.485814 0.937934 +189 0.470402 0.922604 +205 0.487849 0.910880 +204 0.497322 0.920795 +SURF 0X10 +mat 1 +refs 4 +181 0.570507 0.857387 +182 0.579664 0.880031 +198 0.555392 0.883566 +197 0.550735 0.870282 +SURF 0X10 +mat 1 +refs 4 +189 0.470402 0.922604 +190 0.461999 0.902113 +206 0.483145 0.897950 +205 0.487849 0.910880 +SURF 0X10 +mat 1 +refs 4 +182 0.579664 0.880031 +183 0.577494 0.904391 +199 0.554716 0.898009 +198 0.555392 0.883566 +SURF 0X10 +mat 1 +refs 4 +190 0.461999 0.902113 +191 0.462172 0.879540 +207 0.483947 0.883850 +206 0.483145 0.897950 +SURF 0X10 +mat 1 +refs 4 +183 0.577494 0.904391 +184 0.566349 0.925486 +200 0.548410 0.911197 +199 0.554716 0.898009 +SURF 0X10 +mat 1 +refs 4 +191 0.462172 0.879540 +192 0.470937 0.858380 +208 0.489766 0.870508 +207 0.483947 0.883850 +SURF 0X10 +mat 1 +refs 4 +184 0.566349 0.925486 +185 0.548610 0.940371 +201 0.537564 0.921070 +200 0.548410 0.911197 +SURF 0X10 +mat 1 +refs 4 +177 0.487103 0.841885 +178 0.508345 0.832597 +194 0.513570 0.854580 +193 0.500179 0.860253 +SURF 0X10 +mat 1 +refs 4 +192 0.470937 0.858380 +177 0.487103 0.841885 +193 0.500179 0.860253 +208 0.489766 0.870508 +SURF 0X10 +mat 1 +refs 4 +185 0.548610 0.940371 +186 0.527331 0.947438 +202 0.524154 0.926430 +201 0.537564 0.921070 +kids 0 diff --git a/BUK-M2/Models/Armament/Weapons/M317/BUK-M2.png b/BUK-M2/Models/Armament/Weapons/M317/BUK-M2.png new file mode 100644 index 0000000..54caa8b Binary files /dev/null and b/BUK-M2/Models/Armament/Weapons/M317/BUK-M2.png differ diff --git a/BUK-M2/Models/Armament/Weapons/M317/explosion-0.xml b/BUK-M2/Models/Armament/Weapons/M317/explosion-0.xml new file mode 100644 index 0000000..fcb5b09 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/explosion-0.xml @@ -0,0 +1,176 @@ + + + + explosion + smoke.png + + true + false + + + payload/armament/m317/flags/explode-id-0 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 80 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 30 + 10 + + + + billboard + + + + + 1.0 + 1.0 + 0.4 + 1 + + + 2 + + + + + + 0.8 + 0.5 + 0.2 + 0.1 + + + 55 + + + + + 0.5 + + + 5 + 0.5 + + + + air + true + true + + + + + + + explosion-smoke + smoke.png + + false + false + + + payload/armament/m317/flags/explode-smoke-id-0 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 60 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 10 + + + + billboard + + + + + 0.3 + 0.3 + 0.25 + 0.5 + + + 10 + + + + + + 0.4 + 0.4 + 0.4 + 0.04 + + + 60 + + + + + 40 + + + 5 + 0.5 + + + + air + true + true + + + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/explosion-1.xml b/BUK-M2/Models/Armament/Weapons/M317/explosion-1.xml new file mode 100644 index 0000000..0296b93 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/explosion-1.xml @@ -0,0 +1,176 @@ + + + + explosion + smoke.png + + true + false + + + payload/armament/m317/flags/explode-id-1 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 80 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 30 + 10 + + + + billboard + + + + + 1.0 + 1.0 + 0.4 + 1 + + + 2 + + + + + + 0.8 + 0.5 + 0.2 + 0.1 + + + 55 + + + + + 0.5 + + + 5 + 0.5 + + + + air + true + true + + + + + + + explosion-smoke + smoke.png + + false + false + + + payload/armament/m317/flags/explode-smoke-id-1 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 60 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 10 + + + + billboard + + + + + 0.3 + 0.3 + 0.25 + 0.5 + + + 10 + + + + + + 0.4 + 0.4 + 0.4 + 0.04 + + + 60 + + + + + 40 + + + 5 + 0.5 + + + + air + true + true + + + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/explosion-2.xml b/BUK-M2/Models/Armament/Weapons/M317/explosion-2.xml new file mode 100644 index 0000000..d90a713 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/explosion-2.xml @@ -0,0 +1,176 @@ + + + + explosion + smoke.png + + true + false + + + payload/armament/m317/flags/explode-id-2 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 80 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 30 + 10 + + + + billboard + + + + + 1.0 + 1.0 + 0.4 + 1 + + + 2 + + + + + + 0.8 + 0.5 + 0.2 + 0.1 + + + 55 + + + + + 0.5 + + + 5 + 0.5 + + + + air + true + true + + + + + + + explosion-smoke + smoke.png + + false + false + + + payload/armament/m317/flags/explode-smoke-id-2 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 60 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 10 + + + + billboard + + + + + 0.3 + 0.3 + 0.25 + 0.5 + + + 10 + + + + + + 0.4 + 0.4 + 0.4 + 0.04 + + + 60 + + + + + 40 + + + 5 + 0.5 + + + + air + true + true + + + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/explosion-3.xml b/BUK-M2/Models/Armament/Weapons/M317/explosion-3.xml new file mode 100644 index 0000000..d6e5d10 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/explosion-3.xml @@ -0,0 +1,176 @@ + + + + explosion + smoke.png + + true + false + + + payload/armament/m317/flags/explode-id-3 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 80 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 30 + 10 + + + + billboard + + + + + 1.0 + 1.0 + 0.4 + 1 + + + 2 + + + + + + 0.8 + 0.5 + 0.2 + 0.1 + + + 55 + + + + + 0.5 + + + 5 + 0.5 + + + + air + true + true + + + + + + + explosion-smoke + smoke.png + + false + false + + + payload/armament/m317/flags/explode-smoke-id-3 + + + world + + + point + + + + -180 + 180 + -180 + 180 + + 500 + 60 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 10 + + + + billboard + + + + + 0.3 + 0.3 + 0.25 + 0.5 + + + 10 + + + + + + 0.4 + 0.4 + 0.4 + 0.04 + + + 60 + + + + + 40 + + + 5 + 0.5 + + + + air + true + true + + + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/m317-0.xml b/BUK-M2/Models/Armament/Weapons/M317/m317-0.xml new file mode 100644 index 0000000..93e4ff7 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/m317-0.xml @@ -0,0 +1,42 @@ + + + + + + + aim-120 + 9M317.ac + + + select + missile1 + + payload/armament/m317/flags/msl-id-0 + + + + + Aircraft/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-0.xml + + 1.83937 + 0 + 0 + + + + + explosion + Aircraft/BUK-M2/Models/Armament/Weapons/M317/explosion-0.xml + + 0 + 0 + 0 + + + + + missile1 + false + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/m317-1.xml b/BUK-M2/Models/Armament/Weapons/M317/m317-1.xml new file mode 100644 index 0000000..798788e --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/m317-1.xml @@ -0,0 +1,42 @@ + + + + + + + aim-120 + 9M317.ac + + + select + missile1 + + payload/armament/m317/flags/msl-id-1 + + + + + Aircraft/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-1.xml + + 1.83937 + 0 + 0 + + + + + explosion + Aircraft/BUK-M2/Models/Armament/Weapons/M317/explosion-1.xml + + 0 + 0 + 0 + + + + + missile1 + false + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/m317-2.xml b/BUK-M2/Models/Armament/Weapons/M317/m317-2.xml new file mode 100644 index 0000000..ec160b9 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/m317-2.xml @@ -0,0 +1,42 @@ + + + + + + + aim-120 + 9M317.ac + + + select + missile1 + + payload/armament/m317/flags/msl-id-2 + + + + + Aircraft/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-2.xml + + 1.83937 + 0 + 0 + + + + + explosion + Aircraft/BUK-M2/Models/Armament/Weapons/M317/explosion-2.xml + + 0 + 0 + 0 + + + + + missile1 + false + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/m317-3.xml b/BUK-M2/Models/Armament/Weapons/M317/m317-3.xml new file mode 100644 index 0000000..227977a --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/m317-3.xml @@ -0,0 +1,42 @@ + + + + + + + aim-120 + 9M317.ac + + + select + missile1 + + payload/armament/m317/flags/msl-id-3 + + + + + Aircraft/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-3.xml + + 1.83937 + 0 + 0 + + + + + explosion + Aircraft/BUK-M2/Models/Armament/Weapons/M317/explosion-3.xml + + 0 + 0 + 0 + + + + + missile1 + false + + + diff --git a/BUK-M2/Models/Armament/Weapons/M317/m317.xml b/BUK-M2/Models/Armament/Weapons/M317/m317.xml new file mode 100644 index 0000000..dcd94c8 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/m317.xml @@ -0,0 +1,7 @@ + + + + + 9M317.ac + + \ No newline at end of file diff --git a/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-0.xml b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-0.xml new file mode 100644 index 0000000..53ada28 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-0.xml @@ -0,0 +1,187 @@ + + + + smoke + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-0 + + + world + + + point + + + + 7 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 0 + + + + billboard + + + + + 0.25 + 0.25 + 0.25 + 1 + + + 1.0 + + + + + + 0.25 + 0.25 + 0.25 + 0.5 + + + 5 + + + + + 60 + + + 0.001 + 0.5 + + + + air + false + true + + + + + + exhaust + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-0 + + + world + + + point + + + + 0 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 100 + 0 + + + + billboard + + + + + 1.0 + 0.7 + 0.2 + 0.7 + + + 1.0 + + + + + + 0.9 + 0.6 + 0.2 + 0.1 + + + 1.5 + + + + + 0.15 + + + 0.001 + 0.5 + + + + air + false + false + + + + + \ No newline at end of file diff --git a/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-1.xml b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-1.xml new file mode 100644 index 0000000..172a3ae --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-1.xml @@ -0,0 +1,187 @@ + + + + smoke + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-1 + + + world + + + point + + + + 7 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 0 + + + + billboard + + + + + 0.25 + 0.25 + 0.25 + 1 + + + 1.0 + + + + + + 0.25 + 0.25 + 0.25 + 0.5 + + + 5 + + + + + 60 + + + 0.001 + 0.5 + + + + air + false + true + + + + + + exhaust + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-1 + + + world + + + point + + + + 0 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 100 + 0 + + + + billboard + + + + + 1.0 + 0.7 + 0.2 + 0.7 + + + 1.0 + + + + + + 0.9 + 0.6 + 0.2 + 0.1 + + + 1.5 + + + + + 0.15 + + + 0.001 + 0.5 + + + + air + false + false + + + + + \ No newline at end of file diff --git a/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-2.xml b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-2.xml new file mode 100644 index 0000000..1d550a3 --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-2.xml @@ -0,0 +1,187 @@ + + + + smoke + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-2 + + + world + + + point + + + + 7 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 0 + + + + billboard + + + + + 0.25 + 0.25 + 0.25 + 1 + + + 1.0 + + + + + + 0.25 + 0.25 + 0.25 + 0.5 + + + 5 + + + + + 60 + + + 0.001 + 0.5 + + + + air + false + true + + + + + + exhaust + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-2 + + + world + + + point + + + + 0 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 100 + 0 + + + + billboard + + + + + 1.0 + 0.7 + 0.2 + 0.7 + + + 1.0 + + + + + + 0.9 + 0.6 + 0.2 + 0.1 + + + 1.5 + + + + + 0.15 + + + 0.001 + 0.5 + + + + air + false + false + + + + + \ No newline at end of file diff --git a/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-3.xml b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-3.xml new file mode 100644 index 0000000..5ce082d --- /dev/null +++ b/BUK-M2/Models/Armament/Weapons/M317/motor-smoke-3.xml @@ -0,0 +1,187 @@ + + + + smoke + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-3 + + + world + + + point + + + + 7 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 50 + 0 + + + + billboard + + + + + 0.25 + 0.25 + 0.25 + 1 + + + 1.0 + + + + + + 0.25 + 0.25 + 0.25 + 0.5 + + + 5 + + + + + 60 + + + 0.001 + 0.5 + + + + air + false + true + + + + + + exhaust + smoke.png + + true + false + + + payload/armament/m317/flags/smoke-id-3 + + + world + + + point + + + + 0 + 0 + 0 + + + + -1.5 + 1.5 + -1.5 + 1.5 + + 0 + 0 + + + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + 100 + 0 + + + + billboard + + + + + 1.0 + 0.7 + 0.2 + 0.7 + + + 1.0 + + + + + + 0.9 + 0.6 + 0.2 + 0.1 + + + 1.5 + + + + + 0.15 + + + 0.001 + 0.5 + + + + air + false + false + + + + + \ No newline at end of file diff --git a/BUK-M2/Models/Armament/Weapons/M317/puff.png b/BUK-M2/Models/Armament/Weapons/M317/puff.png new file mode 100644 index 0000000..5ba85da Binary files /dev/null and b/BUK-M2/Models/Armament/Weapons/M317/puff.png differ diff --git a/BUK-M2/Models/Armament/Weapons/M317/smoke.png b/BUK-M2/Models/Armament/Weapons/M317/smoke.png new file mode 100644 index 0000000..658fed9 Binary files /dev/null and b/BUK-M2/Models/Armament/Weapons/M317/smoke.png differ diff --git a/BUK-M2/Nasal/damage.nas b/BUK-M2/Nasal/damage.nas index 44b753a..81e859c 100644 --- a/BUK-M2/Nasal/damage.nas +++ b/BUK-M2/Nasal/damage.nas @@ -27,8 +27,6 @@ var mlw_max=getprop("payload/d-config/mlw_max"); # var auto_flare_caller = getprop("payload/d-config/auto_flare_caller"); # If damage.nas should detect flare releases, or if function is called from somewhere in aircraft ############################################################################################################################ -var TRUE = 1; -var FALSE = 0; var hp = hp_max; setprop("sam/damage", math.max(0,100*hp/hp_max));#used in HUD @@ -164,7 +162,9 @@ var warheads = { "pilot": [93, 0.00,1,0],# ejected pilot "BETAB-500ShP": [94, 1160.00,1,0], "Flare": [95, 0.00,0,0], - "3M9": [96, 125.00,0,0],# 3M9 Missile used with 2K12/SA-6 + "3M9": [96, 125.00,0,0],# 3M9M3 Missile used with 2K12/SA-6 + "5V28V": [97, 478.00,0,0],# Missile used with S-200D/SA-5 + "AIM-9X": [98, 20.80,0,0], }; var AIR_RADAR = "air"; @@ -189,7 +189,8 @@ var radar_signatures = { "E-8R": AIR_RADAR, "EC-137D": AIR_RADAR, "Mig-28": AIR_RADAR, - "SA-6": AIR_RADAR,#Air radar tone chosen so that there is at least some lock tone until asset-specific is created + "SA-6": "gnd-06",#Air radar tone chosen so that there is at least some lock tone until asset-specific is created + "s-200": "gnd-05", "ZSU-23-4M": "gnd-23", "S-75": "gnd-02", "buk-m2": "gnd-11", @@ -203,7 +204,7 @@ var radar_signatures = { var id2warhead = []; var launched = {};# callsign: elapsed-sec var approached = {};# callsign: uniqueID -var heavy_smoke = [61,62,63,65,92,96]; +var heavy_smoke = [61,62,63,65,92,96,97]; var k = keys(warheads); @@ -241,6 +242,10 @@ for(var myid = 0;myid 450) { - printf("Missile Approach Warning from %03d degrees.", bearing); - damageLog.push(sprintf("Missile Approach Warning from %03d degrees from %s.", bearing, notification.Callsign)); - if (rwr_to_screen) screen.log.write(sprintf("Missile Approach Warning from %03d degrees.", bearing), 1,1,0);# temporary till someone models a RWR in RIO seat + if (radarOn) { + #printf("Missile Approach Warning from %03d degrees.", bearing); + damageLog.push(sprintf("Missile Approach Warning from %03d degrees from %s.", bearing, notification.Callsign)); + if (rwr_to_screen) screen.log.write(sprintf("Missile Approach Warning from %03d degrees.", bearing), 1,0.5,0);# temporary till someone models a RWR in RIO seat + } else { + #printf("Missile Approach Warning"); + damageLog.push(sprintf("Missile Approach Warning from %s.", notification.Callsign)); + if (rwr_to_screen) screen.log.write(sprintf("Missile Approach Warning (semi-active)."), 1,0.5,0);# temporary till someone models a RWR in RIO seat + } approached[notification.Callsign~notification.UniqueIdentity] = elapsed; - if (m28_auto) mig28.engagedBy(notification.Callsign); + if (m28_auto) mig28.engagedBy(notification.Callsign, 1); } return emesary.Transmitter.ReceiptStatus_OK; } @@ -415,7 +433,7 @@ var DamageRecipient = # debug.dump(notification); # # - if (tacview_supported and tacview.starttime and getprop("sim/multiplay/txhost") != "mpserver.opredflag.com") { + if (tacview_supported and tacview.starttime and (getprop("sim/multiplay/txhost") != "mpserver.opredflag.com" or m28_auto)) { var node = getCallsign(notification.RemoteCallsign); if (node != nil and notification.SecondaryKind > 20) { # its a warhead @@ -439,9 +457,10 @@ var DamageRecipient = var callsign = processCallsign(getprop("sim/multiplay/callsign")); if (notification.RemoteCallsign == callsign and getprop("payload/armament/msg") == 1) { #damage enabled and were getting hit - if (m28_auto) mig28.engagedBy(notification.Callsign); + if (notification.SecondaryKind < 0 and hitable_by_cannon) { # cannon hit + if (m28_auto) mig28.engagedBy(notification.Callsign, 0); var probability = id2shell[-1*notification.SecondaryKind-1][1]; var typ = id2shell[-1*notification.SecondaryKind-1][2]; var hit_count = notification.Distance; @@ -457,6 +476,7 @@ var DamageRecipient = } } elsif (notification.SecondaryKind > 20) { # its a warhead + if (m28_auto) mig28.engagedBy(notification.Callsign, 1); var dist = notification.Distance; var wh = id2warhead[notification.SecondaryKind - 21]; var type = wh[4];#test code @@ -549,21 +569,18 @@ var DamageRecipient = } if (notification.Kind == CREATE and getprop("payload/armament/enable-craters") == 1 and statics["obj_"~notification.UniqueIdentity] == nil) { if (notification.SecondaryKind == 0) {# TODO: make a hash with all the models - var crater_model = getprop("payload/armament/models") ~ "crater_small.xml"; - var static = geo.put_model(crater_model, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading); + var static = geo.put_model(crater_model0, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading); if (static != nil) { statics["obj_"~notification.UniqueIdentity] = [static, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading, notification.SecondaryKind]; #static is a PropertyNode inside /models } } elsif (notification.SecondaryKind == 1) { - var crater_model = getprop("payload/armament/models") ~ "crater_big.xml"; - var static = geo.put_model(crater_model, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading); + var static = geo.put_model(crater_model1, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading); if (static != nil) { statics["obj_"~notification.UniqueIdentity] = [static, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading, notification.SecondaryKind]; } } elsif (notification.SecondaryKind == 2) { - var crater_model = getprop("payload/armament/models") ~ "bomb_hit_smoke.xml"; - var static = geo.put_model(crater_model, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading); + var static = geo.put_model(crater_model2, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading); if (static != nil) { statics["obj_"~notification.UniqueIdentity] = [static, notification.Position.lat(), notification.Position.lon(), notification.Position.alt(), notification.Heading, notification.SecondaryKind]; } @@ -863,6 +880,7 @@ var flare_update_time = 0.4; var flare_duration = 8; var flare_terminal_speed = 50;#m/s var flares_max_process_per_loop = 4; +var flare_sequencer = -120; var flare_sorter = func(a, b) { if(a[0] < b[0]){ @@ -945,7 +963,9 @@ var flare_released = func { getprop("orientation/heading-deg"), FT2M*getprop("velocities/speed-down-fps"), FT2M*math.sqrt(getprop("velocities/speed-north-fps")*getprop("velocities/speed-north-fps")+getprop("velocities/speed-east-fps")*getprop("velocities/speed-east-fps")), - int(rand()*240)-120]; + flare_sequencer]; + flare_sequencer += 1; + if (flare_sequencer > 120) flare_sequencer = -120; append(flare_list, flare); var msg = notifications.ObjectInFlightNotification.new("ffly", flare[6], MOVE, 21+95); msg.Flags = 0; @@ -1233,7 +1253,7 @@ var processCallsigns = func () { var painted = 0; var paint_list = []; foreach (var player; players) { - if(player.getChild("valid") != nil and player.getChild("valid").getValue() == TRUE and player.getChild("callsign") != nil and player.getChild("callsign").getValue() != "" and player.getChild("callsign").getValue() != nil) { + if(player.getChild("valid") != nil and player.getChild("valid").getValue() == 1 and player.getChild("callsign") != nil and player.getChild("callsign").getValue() != "" and player.getChild("callsign").getValue() != nil) { var callsign = player.getChild("callsign").getValue(); callsign_struct[callsign] = player; var str6 = player.getNode("sim/multiplay/generic/string[6]"); @@ -1247,6 +1267,7 @@ var processCallsigns = func () { } if (getprop("sim/time/elapsed-sec")-MAW_elapsed > 1.1) { setprop("payload/armament/MAW-active", 0);# resets every 1.1 seconds without warning + setprop("payload/armament/MAW-semiactive", 0); } # spike handling: @@ -1293,16 +1314,16 @@ processCallsignsTimer.start(); var code_ct = func () { #ANTIC if (getprop("payload/armament/msg")) { - setprop("sim/rendering/redout/enabled", TRUE); + setprop("sim/rendering/redout/enabled", 1); #call(func{fgcommand('dialog-close', multiplayer.dialog.dialog.prop())},nil,var err= []);# props.Node.new({"dialog-name": "location-in-air"})); - call(func{multiplayer.dialog.del();},nil,var err= []); + if (!m28_auto) call(func{multiplayer.dialog.del();},nil,var err= []); if (!getprop("gear/gear[0]/wow")) { call(func{fgcommand('dialog-close', props.Node.new({"dialog-name": "WeightAndFuel"}))},nil,var err2 = []); call(func{fgcommand('dialog-close', props.Node.new({"dialog-name": "system-failures"}))},nil,var err2 = []); call(func{fgcommand('dialog-close', props.Node.new({"dialog-name": "instrument-failures"}))},nil,var err2 = []); } setprop("sim/freeze/fuel",0); - setprop("/sim/speed-up", 1); + if (!m28_auto) setprop("/sim/speed-up", 1); setprop("/gui/map/draw-traffic", 0); setprop("/sim/marker-pins/traffic", 0); setprop("/sim/gui/dialogs/map-canvas/draw-TFC", 0); @@ -1317,7 +1338,7 @@ code_ctTimer.simulatedTime = 1; -setprop("/sim/failure-manager/display-on-screen", FALSE); +setprop("/sim/failure-manager/display-on-screen", 0); code_ctTimer.start(); @@ -1337,6 +1358,22 @@ var re_init = func (node) { } stopLaunch(); damageLog.push("Aircraft was repaired due to re-init."); + + # Remove all 3D craters and re-place them. Due to re-init can remove some of them. + + foreach (var thekey ; keys(statics)) { + var sta = statics[thekey]; + if (sta[0] != nil) { + sta[0].remove(); + if (sta[5] == 0) {# TODO: make a hash with all the models + sta[0] = geo.put_model(crater_model0, sta[1], sta[2], sta[3], sta[4]); + } elsif (sta[5] == 1) { + sta[0] = geo.put_model(crater_model1, sta[1], sta[2], sta[3], sta[4]); + } elsif (sta[5] == 2) { + sta[0] = geo.put_model(crater_model2, sta[1], sta[2], sta[3], sta[4]); + } + } + } } #================================================================== @@ -1405,6 +1442,7 @@ setlistener("sim/signals/exit", writeDamageLog, 0, 0); #screen.property_display.add("payload/armament/MAW-bearing"); #screen.property_display.add("payload/armament/MAW-active"); +#screen.property_display.add("payload/armament/MAW-semiactive"); #screen.property_display.add("payload/armament/MLW-bearing"); #screen.property_display.add("payload/armament/MLW-count"); #screen.property_display.add("payload/armament/MLW-launcher"); @@ -1412,6 +1450,8 @@ setlistener("sim/signals/exit", writeDamageLog, 0, 0); #screen.property_display.add("payload/armament/spike-air"); #screen.property_display.add("payload/armament/spike-gnd-20"); #screen.property_display.add("payload/armament/spike-gnd-02"); +#screen.property_display.add("payload/armament/spike-gnd-05"); +#screen.property_display.add("payload/armament/spike-gnd-06"); #screen.property_display.add("payload/armament/spike-gnd-11"); #screen.property_display.add("payload/armament/spike-gnd-23"); #screen.property_display.add("payload/armament/spike-gnd-p2"); diff --git a/BUK-M2/Nasal/datalink.nas b/BUK-M2/Nasal/datalink.nas new file mode 100644 index 0000000..7b88482 --- /dev/null +++ b/BUK-M2/Nasal/datalink.nas @@ -0,0 +1,681 @@ +#### Datalink + +# Copyright 2020-2021 Colin Geniet. +# Licensed under the GNU General Public License 2.0 or any later version. + + +#### Usage + +### Generalities +# +# The datalink protocol consists of a core protocol which implements a notion +# of datalink channel, and extensions which allow transmitting actual data. + +### Core protocol usage: +# +# Define the following properties (must be defined at nasal loading time). +# * Mandatory +# /instrumentation/datalink/power_prop path to property indicating if datalink is on +# /instrumentation/datalink/channel_prop path to property containing datalink channel +# (the channel property can contain anything, and is transmitted/compared as a string). +# * Optional +# /instrumentation/datalink/receive_period = 1 receiving loop update rate +# +# Optional: Re-define the function +# datalink.can_transmit(callsign, mp_prop, mp_index) +# +# This function should return 'true' when the given aircraft is able to transmit over datalink to us. +# For instance, it can be used to check line of sight and maximum range. +# The default implementation always returns true (always able to transmit). +# Arguments are callsign, property node /ai/models/multiplayer[i], index of the former node. +# +# +# API: +# - get_data(callsign) +# Returns all datalink information about 'callsign' as an object, or nil if there is none. +# This object must not be modified. +# It contains the following methods: +# callsign(): The aircraft callsign (same as the argument of get_data()). +# index(): The aircraft index in /ai/models/multiplayer[i]. +# on_link(): Returns a bool indicating whether 'callsign' is connected to this aircraft through datalink. +# +# Extensions can define other methods in this object. +# +# - get_connected_callsigns() / get_connected_indices() +# Returns a vector containing all callsigns, resp. indices +# in /ai/models/multiplayer[i], of aircrafts connected on datalink. +# Both vectors use the same order, i.e. get_connected_callsigns()[i] +# and get_connected_indices()[i] correspond to the same aircraft. +# Furthermore this order is stable (the relative order of two aircrafts +# does not change as long as neither disconnects from multiplayer). +# +# - get_all_callsigns() +# Returns a vector containing all callsigns of aircraft with any associated data. +# There is no guarantee on the order of callsigns. +# +# - send_data(data, timeout=nil) +# Send data on the datalink. 'data' is a hash of the form +# { +# : , +# ... +# } +# If 'timeout' is set, clear_data() will be called after this delay. +# Data sent with send_data() is deleted at the next call of send_data(), or by clear_data(). +# +# - clear_data() +# Clear data transmitted by this aircraft. +# +# Important note: +# After a send_data(), and until the next send_data() or clear_data(), +# the datalink behaves as if you are continuously sending the same data. +# Thus, it is important to +# 1. either call send_data() regularly +# 2. or set the timeout argument of send_data() + +### Extensions + +### Aircraft contacts (extension name: "contacts") +# +# This extension allows to simulate an aircraft transmitting information about +# another aircraft (typically one tracked on radar). The position data is not +# actually transmitted (since everyone can access it from simulator internals). +# +## Receiving data +# This extension adds the following methods to the result of get_data("A"): +# tracked(): A bool indicating that some aircraft "B" connected on datalink +# is transmitting information about aircraft "A". +# iff(): One of IFF_UNKNOWN, IFF_HOSTILE, IFF_FRIENDLY, or nil if tracked() is false. +# Indicates the result of IFF interrogation of "A" by "B" +# IFF_UNKNOWN means that e.g. no IFF interrogation was performed. +# tracked_by(): The callsign of the transmitting aircraft ("A"), or nil if tracked() is false. +# tracked_by_index(): The index of the transmitting aircraft, or nil if tracked() is false. +# The index refers to property nodes /ai/models/multiplayer[i]. +# is_known(): Equivalent to (on_link() or tracked()). +# Indicates if the position of this aircraft is supposed to be known +# (i.e. whether or not it should be displayed on a HSD or whatever). +# is_friendly(): Equivalent to (on_link() or iff() == IFF_FRIENDLY). +# is_hostile(): Equivalent to (!on_link() and iff() == IFF_HOSTILE). +# +## Sending data +# usage: send_data({ contacts: , ...}, ...) +# where is a vector of hashes of the form { callsign: , [iff: ,] }. +# is the multiplayer callsign of the tracked aircraft. +# (optional) is one of IFF_UNKNOWN, IFF_HOSTILE, IFF_FRIENDLY + +### Datalink identifier (extension name: "identifier") +# +# This extension allows each aircraft on datalink to transmit a personal +# identifier, e.g. the number of the aircraft in a flight. +# +## Receiving data +# This extension adds the method identifier() to the result of get_data(), +# which returns the identifier, or nil if there is none). +# +## Sending data +# Set the identifier with send_data({"identifier": , ...}); +# The identifier must be a string. It must not contain '!'. + +### Coordinate transmission (extension name: "point") +# +# This extension allows each aircraft to broadcast a coordinate (geo.Coord object). +# +## Receiving data +# This extension adds the method point() to the result of get_data(), +# which results the transmitted geo.Coord object, or nil if there is none. +# +## Sending data +# Transmit a geo.Coord object with send_data({"point": , ...}); + + +#### Protocol: +# +# Data is transmitted on MP generic string[7], with the following format: +# (!)+ +# +# is a hash of the datalink channel. See hash_channel() and check_channel_hash(). +# Each block corresponds to data sent by an extension. +# It starts with a prefix uniquely defining the extension. +# The rest of the block can contain any character (including non-ascii) except '!'. +# +# Remark: '!' as separator is specifically chosen to allow encoding with emesary.Transfer. +# +# The current extension prefixes are the following: +# contacts: C +# identifier: I +# point: P + +#### Extensions API +# +# Creating a new extension is done with +# register_extension(name, prefix, object, encode, decode) +# name the extension name, used as key in the 'data' argument of send_data(). +# prefix the protocol prefix. +# class contact class parent. +# A class from which all contact objects will inherit. +# It must have an init() method, which is called whenever a contact is created. +# +# encode(data) extension encoding function. +# Must return the encoding of the extension data (i.e. when calling +# send_data({name: })) into a string, which may use any character except '!'. +# The extension prefix must not be part of the encoded string. +# +# decode(aircrafts_data, callsign, index, string) extension decoding function. +# 'aircrafts_data' is a hash from callsigns to contact objects (see below). +# 'callsign' is the callsign of the aircraft which transmitted this data. +# 'index' is the index of the aircraft which transmitted this data. +# 'string' is the data encoded by encode() and transmitted through datalink. + +# Each contact in 'data' inherits from the core 'Contact' class, and the extension 'class'. +# decode() is expected to modify 'aircrafts_data', by possibly editing +# existing contacts and adding new ones. It should be careful when +# overwriting existing data in these contacts, including its own: decode() +# will be called several time on the same 'aircrafts_data' (once for each +# transmitting aircraft). +# The modified 'aircrafts_data' hash must be returned. +# +# decode() may use the following helper functions: +# add_if_missing(aircrafts_data, callsign): +# Create a new contact object for 'callsign' and add it to 'aircrafts_data', +# unless an entry for 'callsign' already exists. Returns the modified hash. + + + +#### Version and changelog +# current: v1.1.0, minimum compatible: v1.0.0 +# +## v1.1.0: +# Allow external transmission restrictions +# Make transmitting contact IFF optional +# Ensure personal identifier has no '!' +# '\n' is redundant for printf() +# Fix separator character in documentation +# Fix error when sending unknown extension +# +## v1.0.1: +# Add is_known(), is_friendly(), is_hostile() helpers to extension "contacts". +# +## v1.0.0: Initial version +# - Core protocol for datalink channel. +# - Extensions "contacts", "identifier", and "point". + + + +### Parameters +# +# Remark: most parameters need to be the same on all aircrafts. + +# Index of multiplayer string used to transmit datalink info. +# Must be the same for all aircrafts. +var mp_string = 7; +var mp_path = "sim/multiplay/generic/string["~mp_string~"]"; + +var channel_hash_period = 600; + +var receive_period = getprop("/instrumentation/datalink/receive_period") or 1; + +# Should be overwitten to add transmission restrictions. +var can_transmit = func(contact, mp_prop, mp_index) { + return 1; +} + +### Properties + +var input = { + power: getprop("/instrumentation/datalink/power_prop"), + channel: getprop("/instrumentation/datalink/channel_prop"), + ident: getprop("/instrumentation/datalink/identifier_prop"), + mp: mp_path, + models: "/ai/models", + callsign: "/sim/multiplay/callsign", +}; + +foreach (var name; keys(input)) { + if (input[name] != nil) { + input[name] = props.globals.getNode(input[name], 1); + } +} + + + +#### Core protocol implementation + +### Channel hash (based on iff.nas) +# +# Channel is hashed with current time (rounded to 10min) and own callsign. + +var clean_callsign = func(callsign) { + return damage.processCallsign(callsign); +} + +var my_callsign = func { + return clean_callsign(input.callsign.getValue()); +} + +# Time, rounded to 'channel_hash_period'. This is used to hash channel. +var get_time = func { + return int(math.floor(systime() / channel_hash_period) * channel_hash_period); +} + +# Previous / next time (with channel_hash_period interval). +# This is used to give a bit of margin on the time check. +# (will work if system clocks are coordinated within 10min). +var get_prev_time = func { return get_time() - channel_hash_period; } +var get_next_time = func { return get_time() + channel_hash_period; } + +var parse_hexadecimal = func(str) { + var res = 0; + for (var i=0; i= 48 and c < 58) { + # digit + res += c - 48; + } elsif (c >= 65 and c < 71) { + # upper case letter + res += c - 55; + } elsif (c >= 97 and c < 103) { + # lower case letter + res += c - 87; + } + } + return res; +} + +var _hash_channel = func(time, callsign, channel) { + # 5 hex digits (2^20) fit in 3 chars for emesary int encoding. + var hash = parse_hexadecimal(left(md5(time ~ callsign ~ channel), 5)); + return emesary.TransferInt.encode(hash, 3); +} + +# Hash channel (when sending). +var encode_channel = func(channel) { + return _hash_channel(get_time(), my_callsign(), channel); +} + +# Check that the hash transmitted by aircraft 'callsign' is correct for 'channel'. +var check_channel = func(hash, callsign, channel) { + return hash == _hash_channel(get_time(), callsign, channel) + or hash == _hash_channel(get_prev_time(), callsign, channel) + or hash == _hash_channel(get_next_time(), callsign, channel); +} + +### Contact object +var Contact = { + new: func(callsign) { + var c = { + # contact_parents is the list of all classes from which contacts inherit (for extensions). + parents: contact_parents, + _callsign: callsign, + }; + # Initialize all inherited classes. + foreach (var class; contact_parents) { + call(class.init, [], c, nil, nil); + } + return c; + }, + init: func { me._on_link = 0; }, + + callsign: func { return me._callsign; }, + index: func { return callsign_to_index[me._callsign]; }, + on_link: func { return me._on_link; }, + set_on_link: func(b) { me._on_link = b; }, +}; + +### Extensions +var extensions = {}; +var extension_prefixes = {}; +var max_prefix_length = 0; +var contact_parents = [Contact]; + +var register_extension = func(name, prefix, class, encode, decode) { + if (contains(extensions, name)) { + printf("Datalink: double registration of extension '%s'. Skipping.", name); + return -1; + } + if (contains(extension_prefixes, prefix)) { + printf("Datalink: double registration of extension prefix '%s'. Skipping.", name); + return -1; + } + extensions[name] = { prefix: prefix, encode: encode, decode: decode, }; + extension_prefixes[prefix] = name; + max_prefix_length = math.max(max_prefix_length, size(prefix)); + append(contact_parents, class); + + return 0; +} + + +var data_separator = "!"; + + +### Transmission + +var clear_data = func { + send_data({}); +} + +var clear_timer = maketimer(1, clear_data); +clear_timer.singleShot = 1; + +# Send data through datalink. +# +# timeout: if set, sent data will be cleared after this time (other aircrafts +# won't receive it anymore). Useful if 'send_data' is not called often. +var send_data = func(data, timeout=nil) { + if (!input.power.getBoolValue()) { + last_data = {}; + input.mp.setValue(""); + return; + } + + # First encode channel + var str = encode_channel(input.channel.getValue()); + + # Then all extensions + last_data = data; + foreach(var ext; keys(data)) { + # Skip missing extensions with a warning + if (!contains(extensions, ext)) { + printf("Warning: unknown datalink extension %s in send_data().", ext); + continue; + } + str = str ~ data_separator ~ extensions[ext].prefix ~ extensions[ext].encode(data[ext]); + } + + input.mp.setValue(str); + + if (timeout != nil) { + clear_timer.restart(timeout); + } +} + +# Used internally to update the channel/identifier while keeping the same data. +# Does not touch timeout. +var last_data = {}; +var resend_data = func { + send_data(last_data); +} + +# Very slow timer to ensure the channel hash is updated regularly. +# Only relevant if you never call send_data(); +var hash_update_timer = maketimer(channel_hash_period/2, resend_data); +hash_update_timer.start(); + + +### Receiving + +# callsign to data hash +var aircrafts_data = {}; +# List of callsigns / indices connected on datalink (index is for /ai/models/multiplayer[i]). +var connected_callsigns = []; +var connected_indices = []; + +# Maintain callsign to multiplayer index hash +# (doesn't cost much since we already iterate over MP models). +var callsign_to_index = {}; + + +var get_data = func(callsign) { + return aircrafts_data[callsign]; +} + +var get_connected_callsigns = func { + return connected_callsigns; +} + +var get_connected_indices = func { + return connected_indices; +} + +var get_all_callsigns = func { + return keys(aircrafts_data); +} + +# Helper for modifying aircrafts_data. +var add_if_missing = func(aircrafts_data, callsign) { + if (!contains(aircrafts_data, callsign)) { + aircrafts_data[callsign] = Contact.new(callsign); + } + return aircrafts_data; +} + +var receive_loop = func { + var my_channel = input.channel.getValue(); + + aircrafts_data = {}; + connected_callsigns = []; + connected_indices = []; + + var mp_models = input.models.getChildren("multiplayer"); + foreach(var mp; mp_models) { + var idx = mp.getIndex(); + if (!mp.getValue("valid")) continue; + var callsign = mp.getValue("callsign"); + if (callsign == nil) continue; + + callsign_to_index[callsign] = idx; + + var data = mp.getValue(mp_path); + if (data == nil) continue; + + # Split channel part and data part + var tokens = split(data_separator, data); + + # Check channel + if (!check_channel(tokens[0], callsign, my_channel)) continue; + + # We check this _after_ the channel. Checking the channel is quite cheap, + # and we don't know how slow this function is, it might have a get_cart_ground_intersection() + if (!can_transmit(callsign, mp, idx)) continue; + + # Add to list of connected aircrafts. + append(connected_callsigns, callsign); + append(connected_indices, idx); + # Add to data + aircrafts_data = add_if_missing(aircrafts_data, callsign); + aircrafts_data[callsign].set_on_link(1); + + # Parse extensions data + for (var i=1; i size(tokens)) break; + var prefix = left(tokens[i], len); + if (contains(extension_prefixes, prefix)) { + extension = extension_prefixes[prefix]; + break; + } + } + # Unknown extension, skip + if (extension == nil) continue; + # Remove prefix + var data = substr(tokens[i], len); + # Decode + aircrafts_data = extensions[extension].decode(aircrafts_data, callsign, data); + } + } +} + +var receive_timer = maketimer(receive_period, receive_loop); + + +# Start / stop listener +setlistener(input.power, func (node) { + if (node.getBoolValue()) { + receive_timer.start(); + resend_data(); # Sets channel/identifier + } else { + receive_timer.stop(); + aircrafts_data = {}; + clear_data(); + } +}, 1, 0); + +# Listener to resend data so as to update the channel. +setlistener(input.channel, resend_data); + + + +#### Extensions + +## Identifier + +var ContactIdentifier = { + init: func { + me._identifier = nil; + }, + set_identifier: func(ident) { + me._identifier = ident; + }, + identifier: func { + return me._identifier; + }, +}; + +var encode_identifier = func(ident) { + # Force string conversion + ident = ""~ident; + + if (find("!", ident) >= 0) { + printf("Datalink: Identifier is not allowed to contain '!': %s.", ident); + return ""; + } else { + return ident; + } +} + +var decode_identifier = func(aircrafts_data, callsign, str) { + aircrafts_data = add_if_missing(aircrafts_data, callsign); + aircrafts_data[callsign].set_identifier(str); + return aircrafts_data; +} + +register_extension("identifier", "I", ContactIdentifier, encode_identifier, decode_identifier); + + + +## Contacts + +# IFF status transmitted over datalink. +var IFF_UNKNOWN = 0; # Unknown status +var IFF_HOSTILE = 1; # Considered hostile (no response to IFF). +var IFF_FRIENDLY = 2; # Friendly, because positive IFF identification. +# This is also the priority order for IFF reports in case of conflicts: +# e.g. a contact will be reported as friendly if anyone on datalink reports it as friendly. + +var ContactTracked = { + init: func { + me._tracked_by = nil; + me._iff = IFF_UNKNOWN; + }, + set_tracked_by: func(callsign) { + me._tracked_by = callsign; + }, + set_iff: func(iff) { + # Priority order on IFF values (friendly, then hostile, then no data). + me._iff = math.max(me._iff, iff); + }, + tracked: func { + return me._tracked_by != nil; + }, + tracked_by: func { + return me._tracked_by; + }, + tracked_by_index: func { + return (me._tracked_by != nil) ? callsign_to_index[me._tracked_by] : nil; + }, + iff: func { + return me._iff; + }, + is_known: func { + return me.on_link() or me.tracked(); + }, + is_friendly: func { + return me.on_link() or me.iff() == IFF_FRIENDLY; + }, + is_hostile: func { + return !me.on_link() and me.iff() == IFF_HOSTILE; + }, +}; + +# Contact encoding: callsign + bits +# callsign: the callsign encoded with emesary.TransferString +# bits: bitfield |xxxxxxff| (left is most significant) +# f: IFF, x: unused +# encoded with emesary.TransferByte +# Additional values may be appended for extensions. + +var encode_contact = func(contact) { + # Encode bitfield + var bits = contact["iff"] != nil ? contact.iff : IFF_UNKNOWN; + + return emesary.TransferString.encode(clean_callsign(contact.callsign)) + ~ emesary.TransferByte.encode(bits); +} + +var decode_contact = func(str) { + var res = {}; + var dv = emesary.TransferString.decode(str, 0); + res.callsign = dv.value; + dv = emesary.TransferByte.decode(str, dv.pos); + var bits = dv.value; + res.iff = math.mod(bits, 4); + return res; +} + +# Special character, won't be used by emesary encoding. +var contacts_separator = "#"; + +var encode_contacts = func(contacts) { + var str = ""; + foreach (var contact; contacts) { + str = str~encode_contact(contact)~contacts_separator; + } + return str; +} + +var decode_contacts = func(aircrafts_data, callsign, str) { + var contacts = split(contacts_separator, str); + foreach (var contact; contacts) { + if (contact == "") continue; + var res = decode_contact(contact); + aircrafts_data = add_if_missing(aircrafts_data, res.callsign); + aircrafts_data[res.callsign].set_iff(res.iff); + aircrafts_data[res.callsign].set_tracked_by(callsign); + } + return aircrafts_data; +} + +register_extension("contacts", "C", ContactTracked, encode_contacts, decode_contacts); + + + +## Coordinate + +var ContactPoint = { + init: func { + me._point = nil; + }, + set_point: func(point) { + me._point = point; + }, + point: func { + return me._point; + }, +}; + +var encode_point = func(coord) { + return emesary.TransferCoord.encode(coord); +} + +var decode_point = func(aircrafts_data, callsign, str) { + var coord = emesary.TransferCoord.decode(str, 0).value; + aircrafts_data = add_if_missing(aircrafts_data, callsign); + aircrafts_data[callsign].set_point(coord); + return aircrafts_data; +} + +register_extension("point", "P", ContactPoint, encode_point, decode_point); \ No newline at end of file diff --git a/BUK-M2/Nasal/fdm.nas b/BUK-M2/Nasal/fdm.nas index 1882ac3..71abce2 100644 --- a/BUK-M2/Nasal/fdm.nas +++ b/BUK-M2/Nasal/fdm.nas @@ -13,8 +13,10 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . -#io.include("Aircraft/ExpansionPack/Nasal/init.nas"); srand();# seed the random generator with systime + +#io.include("Aircraft/ExpansionPack/Nasal/init.nas"); + #with("updateloop"); # Number of iterations per second diff --git a/BUK-M2/Nasal/fire-control-custom.nas b/BUK-M2/Nasal/fire-control-custom.nas new file mode 100644 index 0000000..9151804 --- /dev/null +++ b/BUK-M2/Nasal/fire-control-custom.nas @@ -0,0 +1,62 @@ + +################### SAM INFO + +var setupTime = 300;#minimum 'launcher_tilt_time' secs no matter what, due to anim and stuff. +var reload_time = 900; +var launcher_final_tilt_deg = 24; +var launcher_start_tilt_deg = 24; +var launcher_tilt_time = 0; +var sam_align_to_target = 1; +var launcher_align_to_target = 0; +var align_speed_dps = 20; +var radar_elevation_above_terrain_m = 3; +var radar_lowest_pitch = 0.5;# 0.5 degs = roughly 925 feet at 20 nm, 25 feet at half a nm. # 0.35 = roughly 925 feet at 20 nm, 25 feet at half a nm. +var radar_off_time_min = 30;# When turning off to lure enemies into engagement zone, and to not make the SAM too easy to find, minimum turn off this duration. +var radar_off_time_max = 90;# Bigger missile_max_distance give crew incentive to keep this a bit longer +var radar_on_time = 45;# Minimum the time it would take to scan whole sky +var radar_on_after_detect_time = 180;# Crew is alert after spotting an aircraft, how long should they stay that way? +var can_detect_anti_rad = 0.35;# 0.5 very good, 0 not at all. + +#reaction tme for s-300p is 28 secs acording to http://www.astronautix.com/s/s-300p.html +# sounds a bit high, as its 4 secs for s-400 + +################### CIWS INFO + +var ciws_installed = 0; +var ciws_domain_nm = 1.50; #range where it can kill +var ciws_chance = 0.20; #chance to get a kill at 0nm distance +var ciws_burst_rounds = 60;#how many rounds in a burst +var ciws_shell = 15;#from lookup table in damage.nas +var ROUNDS_init = 30; +var ROUNDS = ROUNDS_init;#CIWS bursts remaining + +################### MISSILE INFO + +var NUM_MISSILES = 3; # total carried minus 1 +var missile_name = "M317"; +var missile_brevity = damage.id2warhead[getprop("payload/armament/"~string.lc(missile_name)~"/type-id")][4]; +var missile_max_distance = getprop("payload/armament/"~string.lc(missile_name)~"/max-fire-range-nm"); #max distance of target in nm when it will fire +var missile_min_distance = getprop("payload/armament/"~string.lc(missile_name)~"/min-fire-range-nm"); #minimum distance in nm when it will fire +var lockon_time = 12; #time in seconds it takes to lock on and get a firing solution on a target +var fire_minimum_interval = 7;# time since last track was initiated till a new can be initiated +var same_target_max_missiles = 1;# max number of missiles in air against same target + +var isInEngagementEnvelope = func (target_radial_airspeed, target_ground_distance, target_relative_altitude) { + # is the plane within the engagement envelope? + # the numbers after target_radial_airspeed are ( offset_of_engagement_envelope / speed_to_apply_that_offset ) + # larger offset means it wont fire until the plane is closer. + # for visualization: https://www.desmos.com/calculator/gw570fa9km + var vren = nil; + if ( target_radial_airspeed < 0 ) { + vren = 1 + target_radial_airspeed * ( 0.4 / 750 ); + } else { + vren = 1 + target_radial_airspeed * ( -0.25 / 750 ); + } + target_ground_distance = target_ground_distance * M2NM; + var engagement_altitude = ((1 + vren) * (-.008 * math.pow(target_ground_distance,2)) + 0.5 * target_ground_distance + 5) * 6076.12; + return target_relative_altitude <= engagement_altitude; +} + +var midflight = nil; + + diff --git a/BUK-M2/Nasal/fire-control.nas b/BUK-M2/Nasal/fire-control.nas new file mode 100644 index 0000000..f6e6674 --- /dev/null +++ b/BUK-M2/Nasal/fire-control.nas @@ -0,0 +1,646 @@ +################### GLOBALS + +var AIR = 0; +var MARINE = 1; +var SURFACE = 2; +var ORDNANCE = 3; + +var radar_update_time = 2; +var launch_update_time = 0.3; +var reloading = 0; +var missile_delay_time = 0;#time when last track was initiated +var missile_release_time = 0;#time when last missile was fired +var ciws_delay_time = 0;#time when CIWS was last fired +var launch_in_progress = 0;# if a firing solution is currently being calculated +var reload_starting = 0; +var ACTIVE_MISSILE = 0; +var semi_active_track = nil;# with multiple missiles flying in semi-active-radar mode, this can change rather fast. Which means pilots wont get a steady tone, but disrupted tones. (tradeoff) +var mutexLock = thread.newlock(); +var radarStatus = 0;# Current radar status. +var radarOnTimestamp = -500;# Last timestamp of when the radar was online +var radarOffTimestamp = -500;# Last timestamp of when the radar was offline +var radarOffDuration = radar_off_time_min; +var radarTrackTime = 0;# Last time stamp where any enemy aircraft has been spotted. + +########################################################################## +######################## Common SAM code ########################### +########################################################################## + +################### VARIOUS + +setprop("sim/multiplay/generic/float[7]", 0);# tracking radar vert rotation +setprop("sim/multiplay/generic/float[8]", 0);# tracking radar horiz rotation +setprop("sim/multiplay/generic/float[5]", 0);# launcher vert rotation +setprop("sim/multiplay/generic/float[6]", 0);# launcher horiz rotation +var start_time = systime(); + +var opfor_switch = "enemies/opfor-switch"; +setprop(opfor_switch,0); +var friend_switch = "enemies/friend-switch"; +setprop(friend_switch,0); + +################### IFF + +var target = { + new: func (callsign) { + var m = { parents: [target] }; + m.callsign = callsign; + m.in_air = 0; + m.tracking = 0; + m.missiles = []; + return m; + }, +}; + +var base = props.globals.getNode("/"); +base.getNode("instrumentation/transponder/id-code",1).setIntValue(-9999); +base.getNode("instrumentation/transponder/transmitted-id",1).setIntValue(-9999);# transponder off + +################################################################### + +var targetsV2 = nil; + +var buildTargetList = func { + # rather crappy code, but is not ran so often, so dont really matter. + if (getprop(opfor_switch) == 0 and getprop(friend_switch) == 0) { + for(var i = 1; i<=12;i+=1) { + # add new callsign to list + var sign = getprop("enemies/e"~i); + var tgt = lookup(sign); + if (tgt == nil) { + targetsV2.append(target.new(sign)); + print("added callsign: "~sign); + } + } + } + var removeList = []; + foreach(tgt ; targetsV2.vector) { + # schedule removed callsigns to be removed + if (getprop(opfor_switch) == 0 and getprop(friend_switch) == 0) { + if (tgt.callsign != getprop("enemies/e1") and tgt.callsign != getprop("enemies/e2") and tgt.callsign != getprop("enemies/e3") and tgt.callsign != getprop("enemies/e4") and tgt.callsign != getprop("enemies/e5") and tgt.callsign != getprop("enemies/e6") and tgt.callsign != getprop("enemies/e7") and tgt.callsign != getprop("enemies/e8") and tgt.callsign != getprop("enemies/e9") and tgt.callsign != getprop("enemies/e10") and tgt.callsign != getprop("enemies/e11") and tgt.callsign != getprop("enemies/e12")) { + append(removeList, tgt); + print("will remove callsign: "~tgt.callsign); + } + } + } + foreach(tgt ; removeList) { + # remove callsigns + call(func {targetsV2.remove(tgt);}, nil, var err = []); + } +}; + +var lookup = func (sign) { + + foreach (tgt ; targetsV2.vector) { + if (tgt.callsign == sign) { + return tgt; + } + } + if ( getprop(opfor_switch) == 1 and (left(sign, 5) != "OPFOR" and left(sign,5) != "opfor")) { + print("creating new target in: " ~ sign); + tgt = target.new(sign); + targetsV2.append(tgt); + return tgt; + } + if ( getprop(friend_switch) == 1 and ( left(sign, 5) == "OPFOR" or left(sign,5) == "opfor" )) { + print("creating new target in: " ~ sign); + tgt = target.new(sign); + targetsV2.append(tgt); + return tgt; + } + return nil; +} + + +var PRIO_NORM = 0; +var PRIO_HIGH = 1; +var PRIO_LOW = 2; +var PRIO_FAST = 3; +var PRIO_SLOW = 4; +var PRIO_CLOSE = 5; +var PRIO_FAR = 6; + + +################### MAIN LOOP + +var scan = func() { + setprop("sim/multiplay/visibility-range-nm", 250); + buildTargetList(); + + if ( getprop("/carrier/sunk") == 1 or getprop("/carrier/disabled") == 1) { + setprop("sim/multiplay/generic/string[6]", ""); + datalink.clear_data(); + return; + } + + if (isSetup() ) { + printf("Seconds till activation: %.1f", setupTime - (systime() - start_time)); + setprop("sam/timeleft", setupTime - (systime() - start_time)); + setprop("sam/missiles",(NUM_MISSILES+1-ACTIVE_MISSILE)); + setprop("sam/bursts", ROUNDS); + setprop("sam/info", "Preparing launch system"); + settimer(scan,radar_update_time); + if (launcher_tilt_time > 0) { + setprop("sim/multiplay/generic/float[5]", launcher_final_tilt_deg*math.max(0,(systime() - start_time)-(setupTime-launcher_tilt_time))/launcher_tilt_time);#raise the tubes in last 15 secs of activation + } else { + setprop("sim/multiplay/generic/float[5]", launcher_final_tilt_deg); + } + setprop("sim/multiplay/generic/float[6]", 0); + setprop("sim/multiplay/generic/float[7]", 0); + setprop("sim/multiplay/generic/float[8]", 0); + setprop("sim/multiplay/generic/string[6]", ""); + setprop("/sim/multiplay/generic/int[2]", 1); + datalink.clear_data(); + return; + } + setprop("sim/multiplay/generic/float[5]", launcher_final_tilt_deg); + #### ITERATE THROUGH MP LIST #### + if (radarStatus == 1) { + var my_pos = geo.aircraft_position(); + var radarAlt = my_pos.alt()+radar_elevation_above_terrain_m; + my_pos.set_alt(radarAlt); + var mvec = props.globals.getNode("/ai/models").getChildren("multiplayer"); + var tvec = props.globals.getNode("/ai/models").getChildren("tanker"); + var avec = props.globals.getNode("/ai/models").getChildren("aircraft"); + if (mvec!=nil and tvec != nil) { + mvec = mvec ~ tvec; + } + if (mvec!=nil and avec != nil) { + mvec = mvec ~ avec; + } + var prio_vector = [];#0:node,1:trigger,2:prio value + foreach(var mp; mvec){ + if (mp.getNode("valid") == nil or mp.getNode("valid").getValue() != 1) continue; + var prio = fire_control(mp, my_pos); + append(prio_vector, prio); + if (prio[3] == 1) { + radarTrackTime = systime();#this target is within envelope, we turn on radar. + } + } + prio_vector = sort(prio_vector, func (a,b) {if (a[2]>b[2]){return -1;} elsif (a[2] fire_minimum_interval ) ) { # + #### ... FOR THE MISSILE #### + #print("callsign " ~ cs ~ " found at " ~ dist_to_target); + missile_delay_time = systime(); + mp[0].getNode("unique",1).setValue(rand()); + armament.contact = radar_logic.Contact.new(mp[0], AIR); + launch_in_progress = 1; + missile_launch(mp[0], systime(), my_pos); + + } elsif ( ciws_installed and trigger == -1 and ROUNDS > 0 and ( systime() - ciws_delay_time > 1.0 ) and lu != nil) { + #### ... FOR THE CIWS #### + var contact = radar_logic.Contact.new(mp[0], AIR); + var cord = contact.get_Coord(); + var dist_nm = my_pos.direct_distance_to(cord)*M2NM; + var probabilityOfBurstKill = 0.50; + if (mp[0].getNode("velocities/true-airspeed-kt").getValue() > 50) { + probabilityOfBurstKill = extrapolate(dist_nm, 0, ciws_domain_nm, ciws_chance, 0); + } + var hits = math.max(0,int(extrapolate(rand(), 0, probabilityOfBurstKill, ciws_burst_rounds, 3)));#3 is a kill approx + var target_bearing = my_pos.course_to(cord); + setprop("sim/multiplay/generic/float[0]", -(target_bearing-getprop("orientation/heading-deg")));#CIWS horiz (inverted) + setprop("sim/multiplay/generic/float[1]", vector.Math.getPitch(my_pos, cord));#CIWS vert + setprop("sim/multiplay/generic/bool[0]",1);settimer(func {setprop("sim/multiplay/generic/bool[0]",0);}, 1);# for sound + if (hits > 0) { + var msg = notifications.ArmamentNotification.new("mhit", 4, -1*(ciws_shell+1)); + msg.RelativeAltitude = 0; + msg.Bearing = 0; + msg.Distance = hits; + msg.RemoteCallsign = mp[0].getNode("callsign").getValue(); + notifications.hitBridgedTransmitter.NotifyAll(msg); + damage.damageLog.push("CIWS fired | rounds remaining: " ~ ROUNDS ~ " | hit on: " ~ mp[0].getNode("callsign").getValue()); + } + print("CIWS fired | bursts remaining: " ~ ROUNDS ~ " | "~hits~" hits on: " ~ mp[0].getNode("callsign").getValue() ~ " @ "~ sprintf("%.1f",dist_nm) ~" nm"); + ciws_delay_time = systime(); + ROUNDS = ROUNDS - 1; + setprop("sam/bursts", ROUNDS); + if (ROUNDS == 0) { + print("Launcher out of shell ammo."); + settimer(autoreload, reload_time); + reloading = 1; + reload_starting = systime(); + } + } + if (lu != nil and lu.tracking) { + radarTrackTime = systime(); + } + } + } + + if (launcher_align_to_target and ACTIVE_MISSILE > NUM_MISSILES and systime()-missile_release_time > 2) { + # rotate launcher back to forward: + var tgt_dir = 0; + var cur_dir = getprop("sim/multiplay/generic/float[6]"); + var move_dir = geo.normdeg180(tgt_dir-cur_dir); + var max_dir = radar_update_time*align_speed_dps*0.25; + move_dir = math.clamp(move_dir, -max_dir, max_dir); + setprop("sim/multiplay/generic/float[6]", cur_dir+move_dir); + } + if (launch_in_progress == 0) { + if (reloading) { + setprop("sam/info", "Reloading"); + setprop("sam/timeleft", reload_time - (systime() - reload_starting)); + } else { + setprop("sam/info", "Search radar is "~(radarStatus==1?"ON":"OFF")); + setprop("sam/timeleft", 0); + } + clearSingleLock(); + thread.lock(mutexLock); + semi_active_track = nil; + thread.unlock(mutexLock); + } else { + setprop("sam/timeleft", 0); + } + if (getprop(getprop("payload/armament/MP-alt-ft")) == 0.0) { + # reset 'Follow view' to look at launcher + setprop(getprop("payload/armament/MP-lat"),getprop("position/latitude-deg")); + setprop(getprop("payload/armament/MP-lon"),getprop("position/longitude-deg")); + setprop(getprop("payload/armament/MP-alt-ft"),getprop("position/altitude-ft")); + } + setprop("sam/missiles",(NUM_MISSILES+1-ACTIVE_MISSILE)); + settimer(scan,radar_update_time); +} + +var isSetup = func { + return systime() - start_time < setupTime; +} + +var acquisitionRadarLoop = func { + if (isSetup() or reloading or getprop("/carrier/sunk") == 1 or getprop("/carrier/disabled") == 1) return; + var reason = ""; + var time = systime(); + if (time - radarTrackTime < radar_on_after_detect_time) { + radarStatus = 1; + reason = sprintf("Crew alert for %d seconds", radar_on_after_detect_time - (time - radarTrackTime)); + } elsif (radarStatus == 0 and time - radarOnTimestamp > radarOffDuration) { + radarStatus = 1; + reason = sprintf("Periodic check for %d seconds", radar_on_time); + } elsif (radarStatus == 1 and time - radarOffTimestamp > radar_on_time) { + radarStatus = 0; + radarOffDuration = rand()*(radar_off_time_max - radar_off_time_min)+radar_off_time_min; + reason = sprintf("Periodic pause for %d seconds", radarOffDuration); + } + + if (getprop("payload/armament/"~string.lc(missile_name)~"/guidance") == "tvm" and radarStatus == 0) { + foreach(var tgt ; targetsV2.vector) { + if (tgt.in_air > 0) { + radarTrackTime = time; + radarStatus = 1; + break; + } + } + } + setprop("/sim/multiplay/generic/int[2]", radarStatus != 1); + if (radarStatus == 1) radarOnTimestamp = time; + else radarOffTimestamp = time; + #print("Search radar is "~(radarStatus==1?"ON":"OFF")); + if (reason != "") print(reason); +} + +var radTimer = maketimer(0.5, acquisitionRadarLoop); +radTimer.start(); + +var clearSingleLock = func () { + thread.lock(mutexLock); + if (semi_active_track == nil) { + setprop("sim/multiplay/generic/string[6]", ""); + datalink.clear_data(); + } else { + setprop("sim/multiplay/generic/string[6]", left(md5(semi_active_track), 4)); + datalink.send_data({"contacts":[{"callsign":semi_active_track,"iff":0}]}); + } + thread.unlock(mutexLock); +} + +################## FIRE CONTROL +################## ALL AI LOGIC RELATED TO FIGURING OUT IF A TARGET SHOULD BE SHOT AT SHOULD GO HERE. + +var fire_control = func(mp, my_pos) { + # gather some data about the target + + if ( mp.getNode("valid").getValue() == 0 ) { return [mp,0,0,0]; } + + var ufo_pos = geo.Coord.new().set_latlon(mp.getNode("position/latitude-deg").getValue(),mp.getNode("position/longitude-deg").getValue(),(mp.getNode("position/altitude-ft").getValue() * FT2M)); + var target_distance = my_pos.direct_distance_to(ufo_pos); + var target_altitude = mp.getNode("position/altitude-ft").getValue(); + + # is this plane a friend or foe? + var lu = lookup(mp.getNode("callsign").getValue()); + if ( lu == nil ) { return [mp,0,0,0]; } + + var target_airspeed = mp.getNode("velocities/true-airspeed-kt").getValue(); + var target_ground_distance = my_pos.distance_to(ufo_pos); + var target_heading = mp.getNode("orientation/true-heading-deg").getValue(); + var relative_bearing = math.abs(geo.normdeg180(ufo_pos.course_to(my_pos) - target_heading)); + + var target_relative_altitude = target_altitude - my_pos.alt()*M2FT; + var target_radial_airspeed = math.abs(math.abs(((relative_bearing / 90 ) - 1) * target_airspeed));#200kt against us = 200kt, 200kt at angle of us = 0kt, 200kt away from us = 200kt + var target_relative_pitch = vector.Math.getPitch(my_pos, ufo_pos); + + + # can the radar see it? + var data_link_match = 0; +# foreach(var cx; gci.data_receive_callsigns) { +# if (cx[0] == callsign) { +# data_link_match = true; +# #print('tgt confirmed via datalink'); +# } +# } + + var visible = radar_logic.isNotBehindTerrain(mp); + + + if (ciws_installed and ROUNDS > 0 and target_distance*M2NM < ciws_domain_nm) { + #CIWS + var radarSeeTarget = 1; + if ( data_link_match == 0 ) { + if ( visible[0] == 0 ) {radarSeeTarget = 0 } + if ( target_relative_pitch < radar_lowest_pitch ) { radarSeeTarget = 0 } # + if ( target_distance*M2NM > 1.0 and visible[1] and math.abs(target_radial_airspeed) < 20 ) {radarSeeTarget = 0 } # i.e. notching with terrain behind + } + + if (radarSeeTarget and rand() > target_distance*M2NM / ciws_domain_nm) { + var score = 0; + var priority = getprop("priority"); + if (priority==PRIO_NORM) { + score = rand()-0.5; + } elsif (priority==PRIO_HIGH) { + score = target_altitude; + } elsif (priority==PRIO_LOW) { + score = -target_altitude; + } elsif (priority==PRIO_FAST) { + score = target_radial_airspeed; + } elsif (priority==PRIO_SLOW) { + score = -target_radial_airspeed; + } elsif (priority==PRIO_CLOSE) { + score = -target_distance; + } elsif (priority==PRIO_FAR) { + score = target_distance; + } + return [mp,-1,score,1]; + } + } + + if ( data_link_match == 0 ) { + if (target_airspeed < 60) {return [mp,0,0,0];} + if ( visible[0] == 0 ) { return [mp,0,0,0]; } + if ( target_relative_pitch < radar_lowest_pitch ) { return [mp,0,0,0]; } # + if ( visible[1] and math.abs(target_radial_airspeed) < 20 ) { return [mp,0,0,0]; } # i.e. notching, landed aircraft + } + + if ( target_distance * M2NM > missile_max_distance ) { return [mp,0,0,0]; } + if ( target_distance * M2NM < missile_min_distance ) { return [mp,0,0,0]; } + + + + + # is the plane within the engagement envelope? + # the numbers after target_radial_airspeed are ( offset_of_engagement_envelope / speed_to_apply_that_offset ) + # larger offset means it wont fire until the plane is closer. + # for visualization: https://www.desmos.com/calculator/gw570fa9km + + if (!isInEngagementEnvelope(target_radial_airspeed, target_ground_distance, target_relative_altitude) ) { return [mp,0,0,0]; } + + + + var the_dice = rand(); + + if ( the_dice > 0.20 ) { + var score = 0; + var priority = getprop("priority"); + if (priority==PRIO_NORM) { + score = rand()-0.5; + } elsif (priority==PRIO_HIGH) { + score = target_altitude; + } elsif (priority==PRIO_LOW) { + score = -target_altitude; + } elsif (priority==PRIO_FAST) { + score = target_radial_airspeed; + } elsif (priority==PRIO_SLOW) { + score = -target_radial_airspeed; + } elsif (priority==PRIO_CLOSE) { + score = -target_distance; + } elsif (priority==PRIO_FAR) { + score = target_distance; + } + return [mp,1,score,1]; + } else { + return [mp,0,0,1]; + } +} + +################### MISSILE CONTROL + + +### missile reload + +var reload = func(force = 1) { + #figure out how many to add + if (ACTIVE_MISSILE > NUM_MISSILES or force == 1) { + for ( var i = 0; i <= NUM_MISSILES; i = i + 1 ) { + + if (armament.AIM.new(i,missile_name,missile_brevity, midflight) != -1) { + #if statement just in case reload was called before all missiles were fired. Cause avoid calling search() on same missile twice. + armament.AIM.active[i].radarZ = radar_elevation_above_terrain_m; + armament.AIM.active[i].start(); + } + } + ACTIVE_MISSILE = 0;setprop("active", 0); + print("Launcher reloaded with "~(NUM_MISSILES+1)~" missiles."); + setprop("/sim/messages/copilot", "Launcher reloaded with "~(NUM_MISSILES+1)~" missiles."); + } + if (ROUNDS == 0 or force == 1) { + ROUNDS = ROUNDS_init; + print("Reloaded with "~(ROUNDS)~" bursts."); + } + setprop("sam/missiles",(NUM_MISSILES+1-ACTIVE_MISSILE)); + setprop("sam/bursts", ROUNDS); + reloading = 0; +} + +var autoreload = func() { + if ( getprop("/carrier/sunk") == 1 or getprop("/carrier/disabled") == 1) { + return; + } + if (reloading) { + reloading = 0; + if (ACTIVE_MISSILE > NUM_MISSILES or ROUNDS == 0) { + reload(0); + print("Auto reloading completed.") + } + } else { + print("Auto reloading cancelled due to manual reload.") + } +} + +### missile launch + +var missile_launch = func(mp, launchtime, my_pos) { + if ( getprop("/carrier/sunk") == 1 or getprop("/carrier/disabled") == 1) { + var lu = lookup(mp.getNode("callsign").getValue()); + if (lu != nil) { + lu.tracking = 0; + } + launch_in_progress = 0; + clearSingleLock(); + return; + } + var ufo_pos = geo.Coord.new().set_latlon(mp.getNode("position/latitude-deg").getValue(),mp.getNode("position/longitude-deg").getValue(),(mp.getNode("position/altitude-ft").getValue() * 0.3048)); + var target_bearing = my_pos.course_to(ufo_pos); + var target_pitch = vector.Math.getPitch(my_pos, ufo_pos); + var info = mp.getNode("callsign").getValue(); + var lu = lookup(mp.getNode("callsign").getValue()); + if (getprop("sam/timeleft") != 0) { + launch_in_progress = 0; + if (lu != nil) { + lu.tracking = 0; + } + return; + } elsif ( armament.AIM.active[ACTIVE_MISSILE].status == 1 and systime() - launchtime > lockon_time and radar_logic.isNotBehindTerrain(mp)[0] == 1 ) { + var theMissile = armament.AIM.active[ACTIVE_MISSILE]; + var brevity = theMissile.brevity; + #armament.defeatSpamFilter(brevity ~ " at: " ~ mp.getNode("callsign").getValue()); + damage.damageLog.push(brevity ~ " at: " ~ mp.getNode("callsign").getValue()); + if (launcher_align_to_target) { + setprop("sim/multiplay/generic/float[6]", target_bearing-getprop("orientation/heading-deg")); + theMissile.rail_head_deg = getprop("sim/multiplay/generic/float[6]"); + } + setprop("sim/multiplay/generic/float[7]", target_pitch); + setprop("sim/multiplay/generic/float[8]", target_bearing-getprop("orientation/heading-deg")); + if (sam_align_to_target) { + setprop("/orientation/heading-deg",target_bearing); + } + theMissile.release(); + missile_release_time = systime(); + ACTIVE_MISSILE = ACTIVE_MISSILE + 1;setprop("active", ACTIVE_MISSILE); + print("Fired "~missile_name~" #" ~ ACTIVE_MISSILE ~ " at: " ~ mp.getNode("callsign").getValue()); + setprop("/sim/messages/copilot", "Launch at "~mp.getNode("callsign").getValue()); + if (ACTIVE_MISSILE > NUM_MISSILES) { + setprop("/sim/messages/copilot", "Launcher out of ammo"); + print("Launcher out of missile ammo."); + settimer(autoreload, reload_time); + reloading = 1; + reload_starting = systime(); + } + if (lu != nil) { + append(lu.missiles, theMissile); + lu.in_air += 1; + lu.tracking = 0; + } + launch_in_progress = 0; + info = info~" (launched)"; + setprop("sam/info", info); + setprop("sam/missiles",(NUM_MISSILES+1-ACTIVE_MISSILE)); + clearSingleLock(); + return; + } elsif ((systime() - launchtime) > (lockon_time*1.5) or radar_logic.isNotBehindTerrain(mp)[0] == 0) { + # launch cancelled so it dont forever goes in this loop and dont allow for other firings. + if (lu != nil) { + lu.tracking = 0; + } + setprop("/sim/messages/copilot", "SAM Canceled launch at "~mp.getNode("callsign").getValue()); + launch_in_progress = 0; + info = info~" (cancelled)"; + setprop("sam/info", info); + setprop("sam/missiles",(NUM_MISSILES+1-ACTIVE_MISSILE)); + clearSingleLock(); + return; + } else { + info = sprintf("%s (tracking %d nm at %d ft)", info, armament.contact.get_range(), armament.contact.get_altitude()); + if (systime()-missile_release_time > 1.5) { + var tgt_dir = target_bearing-getprop("orientation/heading-deg"); + var max_dir = launch_update_time*align_speed_dps; + if (launcher_align_to_target) { + # now smoothly rotate launcher: + var cur_dir = getprop("sim/multiplay/generic/float[6]"); + var move_dir = geo.normdeg180(tgt_dir-cur_dir); + move_dir = math.clamp(move_dir, -max_dir, max_dir); + setprop("sim/multiplay/generic/float[6]", cur_dir+move_dir); + } + var cur_dir2 = getprop("sim/multiplay/generic/float[8]"); + var move_dir2 = geo.normdeg180(tgt_dir-cur_dir2); + move_dir2 = math.clamp(move_dir2, -max_dir, max_dir); + setprop("sim/multiplay/generic/float[8]", cur_dir2+move_dir2); + if (sam_align_to_target) { + var tgt_dir = target_bearing; + var cur_dir = getprop("orientation/heading-deg"); + var move_dir = geo.normdeg180(tgt_dir-cur_dir); + var max_dir = launch_update_time*align_speed_dps; + move_dir = math.clamp(move_dir, -max_dir, max_dir); + setprop("orientation/heading-deg", cur_dir+move_dir); + } + } + + setprop("sam/info", info); + if (mp.getNode("callsign") != nil and mp.getNode("callsign").getValue() != nil and mp.getNode("callsign").getValue() != "") { + if (getprop("payload/armament/"~string.lc(missile_name)~"/guidance") != "tvm") setprop("sim/multiplay/generic/string[6]", left(md5(mp.getNode("callsign").getValue()), 4)); + datalink.send_data({"contacts":[{"callsign":mp.getNode("callsign").getValue(),"iff":0}]}); + } else { + clearSingleLock(); + } + if (lu != nil) { + lu.tracking = 1; + radarTrackTime = systime(); + } + } + + settimer( func { missile_launch(mp, launchtime, my_pos); },launch_update_time); +} + +### missile set launched to false for target + +var missile_listener = func { + foreach(var tgt ; targetsV2.vector) { + var missilesNew = []; + foreach(var missile ; tgt.missiles) { + if (missile != nil) { + if (missile.deleted) { + tgt.in_air -= 1; + } else { + append(missilesNew, missile); + } + } + } + tgt.missiles = missilesNew; + } + settimer(missile_listener, 2.5); +} + +var extrapolate = func (x, x1, x2, y1, y2) { + return y1 + ((x - x1) / (x2 - x1)) * (y2 - y1); +} + +################### MISC + +var main_init_listener = setlistener("sim/signals/fdm-initialized", func { + print("fdm-initialized"); + targetsV2 = std.Vector.new();# OO vector (to make removing item easier) + reload(); + scan(); + aircraft.data.save(0.5);# save the target list every 30 seconds + removelistener(main_init_listener); + setlistener(opfor_switch, func { + targetsV2 = std.Vector.new();# OO vector (to make removing item easier) + }, 0, 0); + setlistener(friend_switch, func { + targetsV2 = std.Vector.new();# OO vector (to make removing item easier) + }, 0, 0); + missile_listener(); + setprop(getprop("payload/armament/MP-lat"),getprop("position/latitude-deg")); + setprop(getprop("payload/armament/MP-lon"),getprop("position/longitude-deg")); + setprop(getprop("payload/armament/MP-alt-ft"),getprop("position/altitude-ft")); + view.setViewByIndex(200);#follow view +}, 0, 0); + +setlistener("sim/signals/reinit", func { + print("reinit"); + start_time = systime(); +}); \ No newline at end of file diff --git a/BUK-M2/Nasal/guided-missiles.nas b/BUK-M2/Nasal/guided-missiles.nas new file mode 100644 index 0000000..98f3b94 --- /dev/null +++ b/BUK-M2/Nasal/guided-missiles.nas @@ -0,0 +1,5930 @@ +######################################################################################### +####### +####### Guided/Cruise missiles, rockets and dumb/glide/guided bombs code for Flightgear. +####### +####### License: GPL 2.0 +####### +####### Authors: +####### Alexis Bory, Fabien Barbier, Richard Harrison, Justin Nicholson, Nikolai V. Chr., Axel Paccalin, Colin Geniet +####### +####### The file vector.nas needs to be available in namespace 'vector'. +####### +####### In addition, some code is derived from work by: +####### David Culp, Vivian Meazza, M. Franz +####### +######################################################################################### + +# Some notes about making weapons: +# +# Firstly make sure you read the comments (line 300+) below for the properties. +# For laser/gps guided gravity bombs make sure to set the max G very low, like 0.5G, to simulate them slowly adjusting to hit the target. +# Remember for air to air missiles the speed quoted in literature is normally the speed above the launch platform. I usually fly at the typical max usage +# regime for that missile, so for example for AIM-7 it would be at 40000 ft, +# there I make sure it can reach approx the max relative speed. For older missiles the max speed quoted is sometimes absolute speed though, so beware. +# If it quotes aerodynamic speed then its the absolute speed. Speeds quoted in in unofficial sources can be any of them, +# but if its around mach 5 for A/A its a good bet its absolute, only very few A/A missiles are likely hypersonic. (among othe reasons due to heat or fuel limitations) +# If you cannot find fuel weight in literature, you probably wont go far off with a value that is 1/4 to 1/3 of total launch weight for a A/A missile. +# Stage durations is allowed to be 0, so can thrust values. If there is no second stage, instead of just setting stage 2 thrust to 0, +# set stage 2 duration to 0 also. For unpowered munitions, set all thrusts to 0. +# For very low sea skimming missiles, be sure to set terrain following to false, you cannot have it both ways. +# Since if it goes very low (below 100ft), it cannot navigate terrain reliable. +# The property terrain following only goes into effect, if a cruise altitude is set below 10000ft and not set to 0. +# Cruise missiles against ground targets will always terrain follow, no matter that property. +# If literature quotes a max distance for a weapon, its a good bet it is under the condition that the target +# is approaching the launch platform with high speed and does not evade, and also if the launch platform is an aircraft, +# that it also is approaching the target with high speed. In other words, high closing rate. For example the AIM-7, which can hit bombers out at 32 NM, +# will often have to be within 3 NM of an escaping target to hit it (source). Missiles typically have significantly less range against an evading +# or escaping target than what is commonly believed. I typically fly at 40000 ft at mach 2, approach a target flying head-on with same speed and altitude, +# to test max range. Its typically drag that I adjust for that. +# When you test missiles against aircraft, be sure to do it with a framerate of 25+, else they will not hit very good, especially high speed missiles like +# Amraam or Phoenix. Also notice they generally not hit so close against Scenario/AI objects compared to MP aircraft due to the way these are updated. +# Laser and semi-radar guided munitions need the target to be painted to keep lock. Notice gps guided munition that are all aspect will never lose lock, +# whether they can 'see' the target or not. Anti-radiation missiles will need the target to send radiation towards the missile. +# Set DEBUG_STATS and/or DEBUG_FLIGHT to true to check how the missile works during flight, when you are designing a weapon. +# +# +# Usage: +# +# To create a weapon call AIM.new(pylon, type, description, midFlightFunction). The pylon is an integer from 0 or higher. When its launched it will read the pylon position in +# controls/armament/station[pylon+1]/offsets, where the position properties must be x-m, y-m and z-m. The type is just a string, the description is a string +# that is exposed in its radar properties under AI/models during flight. The function is for changing target, guidance or guidance-law during flight. +# The mid flight function will be called often during flight with 1 parameter. The param is a hash like {time_s, dist_m, mach, weapon_position}, where the latter is a geo.Coord. +# It expects you to return a hash with any or none of these {guidance, guidanceLaw, target, remote_yaw, remote_pitch}. +# The model that is loaded and shown is located in the aircraft folder at the value of property payload/armament/models in a subfolder with same name as type. +# Inside the subfolder the xml file is called [lowercase type]-[pylon].xml +# To start making the missile try to get a lock, call start(), the missile will then keep trying to get a lock on 'contact'. +# 'contact' can be set to nil at any time or changed. To stop the search, just call stop(). To resume the search you again have call start(). +# To release the munition at a target call release(), normally do this after the missile has set its own status to MISSILE_LOCK. +# When using weapons without target, call releaseAtNothing() instead of release(), search() does not need to have been called beforehand. +# To then find out where it hit the ground check the impact report in AI/models. The impact report will contain warhead weight, but that will be zero if +# the weapon did not have time to arm before hitting ground. +# To drop the munition, without arming it nor igniting its engine, call eject(). +# Remote guidance requires the use of midFlightFunction (see below) to transmit guidance parameters, in the remote_yaw and remote_pitch fields of the output. +# +# +# Limitations: +# +# The weapons use a simplified flight model that does not have AoA or sideslip. Mass balance, rotational inertia, wind is also not implemented. They also do not roll due to aerodynmic effects. +# If you fire a weapon and have HoT enabled in flightgear, they likely will not hit very precise. +# The weapons are highly dependent on framerate, so low frame rate will make them hit imprecise. +# The drag curves are tailored for sizable munitions, so it does not work well will bullet or cannon sized munition, submodels are better suited for that. +# Inertial guidance does not account for drift and does not auto dead reckon the target if you want that you have to update the Target accordingly. +# +# +# Future features: +# +# ECM disturbance of getting radar lock. +# Lock on jam. (advanced feature) +# After FG gets HLA: stop using MP chat for hit messages. +# Allow firing only if certain conditions are met. Like not being inverted when firing ejected weapons. +# Sub munitions that have their own guidance/FDM. (advanced) +# GPS guided munitions could have waypoints added. +# Specify terminal manouvres and preferred impact aspect. +# Drag coeff reduction due to exhaust plume. This actually matters quite a bit. +# Proportional navigation should use vector math instead decomposition horizontal/vertical navigation. +# Bleeding speed due to high G turning should depend on drag-area, with AIM-120s as reference. (that would mean recalibrate all cruise-missiles so they don't crash) +# Max-g should be seperated into max structural G that it will never exceed, and max-g for certain mach. Should still depend also on altitude of course. This way it needs a certain speed to perform certain G. +# Real rocket thrust does not necesarily cutoff instantly. Make an optional fadeout. (use the aim-9 new variant paper page as guide) +# Support for seeker FOV that is smaller than FCS FOV. (ASRAAM) +# Introduce battery time. Beyond this time it wont steer. +# Anti-rad: So if the target source goes dark, it deploys a parachute and “loiters”. If it re-detects target, it releases the parachute and fires the second motor +# +# Please report bugs and features to Nikolai V. Chr. | ForumUser: Necolatis | Callsign: Leto + +var AcModel = props.globals.getNode("payload"); +var OurHdg = props.globals.getNode("orientation/heading-deg"); +var OurRoll = props.globals.getNode("orientation/roll-deg"); +var OurPitch = props.globals.getNode("orientation/pitch-deg"); +var OurAlpha = props.globals.getNode("orientation/alpha-deg"); +var OurBeta = props.globals.getNode("orientation/side-slip-deg"); +var ourAlt = props.globals.getNode("position/altitude-ft"); +var deltaSec = props.globals.getNode("sim/time/delta-sec"); +var speedUp = props.globals.getNode("sim/speed-up"); +var noseAir = props.globals.getNode("velocities/uBody-fps"); +var belowAir = props.globals.getNode("velocities/wBody-fps"); +var HudReticleDev = props.globals.getNode("payload/armament/hud/reticle-total-deviation", 1);#polar coords +var HudReticleDeg = props.globals.getNode("payload/armament/hud/reticle-total-angle", 1); +var update_loop_time = 0.000; + +var fox2_unique_id = -100; # each missile needs to have a unique numeric ID + +var SIM_TIME = 0; +var REAL_TIME = 1; + +# enables the AIM-9 aiming reticle (F-14) - doesn't require the radar to be in TWS +var use_fg_default_hud = getprop("payload/armament/use-fg-default-hud"); +if (use_fg_default_hud == nil) { + use_fg_default_hud = 0; +} + +var MISSILE_STANDBY = -1; +var MISSILE_STARTING = -0.5; +var MISSILE_SEARCH = 0; +var MISSILE_LOCK = 1; +var MISSILE_FLYING = 2; + +var AIR = 0; +var MARINE = 1; +var SURFACE = 2; +var ORDNANCE = 3; +var POINT = 4; + +var PATTERN_CIRCLE = 0; +var PATTERN_ROSETTE = 1; +var PATTERN_DOUBLE_D = 2; + +# set these to print stuff to console: +var DEBUG_STATS = 0;#most basic stuff +var DEBUG_FLIGHT = 0;#for creating missiles sometimes good to have this on to see how it flies. + +# set these to debug the code: +var DEBUG_STATS_DETAILS = 0; +var DEBUG_GUIDANCE = 0; +var DEBUG_GUIDANCE_DETAILS = 0; +var DEBUG_FLIGHT_DETAILS = 0; +var DEBUG_SEARCH = 0; +var DEBUG_CODE = 0; + +var g_fps = 9.80665 * M2FT; +var SLUGS2LBM = 32.1740485564; +var LBM2SLUGS = 1/SLUGS2LBM; +var slugs_to_lbm = SLUGS2LBM;# since various aircraft use this from outside missile, leaving it for backwards compat. + +var first_in_air = 0;# first missile is in the air, other missiles should not write to MP. +var first_in_air_max_sec = 30; + +var versionString = getprop("sim/version/flightgear"); +var version = split(".", versionString); +var major = num(version[0]); +var minor = num(version[1]); +var pica = num(version[2]); +var pickingMethod = 0; +if ((major == 2017 and minor == 2 and pica >= 1) or (major == 2017 and minor > 2) or major > 2017) { + pickingMethod = 1; +} +var offsetMethod = 0; +if ((major == 2017 and minor == 2 and pica >= 1) or (major == 2017 and minor > 2) or major > 2017) { + offsetMethod = 1; +} + +var wingedGuideFactor = 0.1; + +var spawn = func(c, context) return func {thread.newthread(func { + call(c, nil, context, context, var err = []); + if(size(err)) { + print("multi-threading error:"); + foreach(var i;err) { + print(i); + } + } +})}; + +# +# The radar will make sure to keep this variable updated. +# Whatever is targeted and ready to be fired upon, should be set here. (or set it directly on the missile using AIM.contacts[0]) +# +# The variable contactPoint is for now only used by F-16 target pod. +# +var contact = nil; +var contactPoint = nil; +# +# Contact should implement the following interface: +# +# get_type() - (AIR, MARINE, SURFACE or ORDNANCE) +# getUnique() - Used when comparing 2 targets to each other and determining if they are the same target. +# isValid() - If this target is valid +# getElevation() +# get_bearing() +# get_Callsign() +# get_range() +# get_Coord() +# get_altitude() +# get_Pitch() +# get_Speed() +# get_heading() +# get_uBody() +# get_vBody() +# get_wBody() +# getLastGroundTrackBlep() - Used for sample guidance +# getFlareNode() - Used for flares. +# getChaffNode() - Used for chaff. +# isPainted() - Tells if this target is still being radar tracked by the launch platform, only used in semi-radar guided missiles. +# isLaserPainted() - Tells if this target is still being tracked by the launch platform, only used by laser guided ordnance. +# isRadiating(coord) - Tell if anti-radiation missile is hit by radiation from target. coord is the weapon position. +# isCommandActive() +# isVirtual() - Tells if the target is just a position, and should not be considered for damage. +# get_closure_rate() - closure rate in kt + +var AIM = { + lowestETA: nil, + #done + new : func (p, type = "AIM-9L", sign = "Sidewinder", midFlightFunction = nil, nasalPosition = nil) { + if(AIM.active[p] != nil) { + #do not make new missile logic if one exist for this pylon. + return -1; + } elsif (AcModel.getNode("armament/"~string.lc(type)~"/") == nil) { + # missiletype does not exist + return -1; + } + var m = { parents : [AIM]}; + # Args: p = Pylon. + + m.mfFunction = midFlightFunction; + m.nasalPosition = nasalPosition; + + m.type_lc = string.lc(type); + m.type = type; + + m.deleted = 0; + + m.status = MISSILE_STANDBY; # -1 = stand-by, 0 = searching, 1 = locked, 2 = fired. + m.free = 0; # 0 = status fired with lock, 1 = status fired but having lost lock. + m.prop = AcModel.getNode("armament/"~m.type_lc~"/").getChild("msl", 0, 1); + m.SwSoundOnOff = AcModel.getNode("armament/"~m.type_lc~"/sound-on-off",1); + m.launchSoundProp = AcModel.getNode("armament/"~m.type_lc~"/sound-fire-on-off",1); + m.SwSoundVol = AcModel.getNode("armament/"~m.type_lc~"/sound-volume",1); + if (m.SwSoundOnOff.getValue() == nil) { + m.SwSoundOnOff.setBoolValue(0); + } + if (m.launchSoundProp.getValue() == nil) { + m.launchSoundProp.setBoolValue(0); + } + if (m.SwSoundVol.getValue() == nil) { + m.SwSoundVol.setDoubleValue(0); + } + m.tacview_support = getprop("payload/d-config/tacview_supported");# set to false, unless using an aircraft that has tacview + m.gnd_launch = getprop("payload/armament/gnd-launch");#true to be a SAM or ship + if (m.gnd_launch == nil) { + m.gnd_launch = 0; + } + if (m.tacview_support == nil) { + m.tacview_support = 0; + } + + m.ID = p; + m.stationName = AcModel.getNode("armament/station-name").getValue(); + if (m.nasalPosition == nil) { + m.pylon_prop = props.globals.getNode(AcModel.getNode("armament/pylon-stations").getValue()).getChild(m.stationName, p+AcModel.getNode("armament/pylon-offset").getValue()); + } + m.Tgt = nil; + m.callsign = "Unknown"; + m.direct_dist_m = nil; + m.speed_m = -1; + + fox2_unique_id += 1; + if (fox2_unique_id >100) fox2_unique_id = -100; + m.unique_id = fox2_unique_id; + m.nodeString = "payload/armament/"~m.type_lc~"/"; + + if (m.tacview_support) { + m.tacviewID = 11000 + int(math.floor(rand()*10000)); + } + + ############### + # Weapon specs: + ############### + + # name + m.typeLong = getprop(m.nodeString~"long-name"); # Longer name of the weapon + m.typeShort = getprop(m.nodeString~"short-name"); # Shorter name of the weapon + m.typeID = getprop(m.nodeString~"type-id"); # ID that match damage type + # detection and firing + m.max_fire_range_nm = getprop(m.nodeString~"max-fire-range-nm"); # max range that the FCS allows firing + m.min_fire_range_nm = getprop(m.nodeString~"min-fire-range-nm"); # it wont get solid lock before the target has this range + m.fcs_fov = getprop(m.nodeString~"FCS-field-deg") / 2; # fire control system total field of view diameter for when searching and getting lock before launch. + m.class = getprop(m.nodeString~"class"); # put in letters here that represent the types the missile can fire at. A=air, M=marine, G=ground, P=point + m.brevity = getprop(m.nodeString~"fire-msg"); # what the pilot will call out over the comm when he fires this weapon + m.coolable = getprop(m.nodeString~"coolable"); # If the seeker supports being cooled. (AIM-9L or later supports) + m.cool_time = getprop(m.nodeString~"cool-time"); # Time to cold the seeker from fully warm. + m.cool_duration = getprop(m.nodeString~"cool-duration"); # Typically 2.5 hours for cooling fluids. Much higher for electrical. + m.warm_detect_range_nm = getprop(m.nodeString~"warm-detect-range-nm"); # Current guidance mode detect range. (when warm) + m.cold_detect_range_nm = getprop(m.nodeString~"detect-range-nm"); # Current guidance mode default detect range. (when cold). This can differ from max-fire-range-nm in that some missiles can be fired at targets they cannot yet see. + m.beam_width_deg = getprop(m.nodeString~"seeker-beam-width-deg"); # Seeker detector instant field of view diameter + m.ready_time = getprop(m.nodeString~"ready-time"); # time to get ready after standby mode. + m.loal = getprop(m.nodeString~"lock-on-after-launch"); # bool. LOAL supported. For loal to work [optional] + m.canSwitch = getprop(m.nodeString~"auto-switch-target-allowed"); # bool. Can switch target at will if it loses lock [optional] + m.standbyFlight = getprop(m.nodeString~"prowl-flight"); # unguided/level/gyro-pitch/5/terrain-follow for LOAL and that stuff, when not locked onto stuff. + m.switchTime = getprop(m.nodeString~"switch-time-sec"); # auto switch of targets in flight: time to scan FoV. This should not be fast, some seconds or more. + m.noCommonTarget = getprop(m.nodeString~"no-common-target"); # bool. If true, target must be set directly on weapon and its not allowed to read 'contact' variable. + m.radarOrigin = getprop(m.nodeString~"FCS-at-origin"); # bool. If radar location is 0,0,0. If false use the 3 properties below also. + m.radarX = getprop(m.nodeString~"FCS-x"); # Where in the aircraft (model xml coords) the radar is located. + m.radarY = getprop(m.nodeString~"FCS-y"); # This is handy for SAMs with radar on a mast. + m.radarZ = getprop(m.nodeString~"FCS-z"); # In future I will add direction to it also, for now its center gimbal is along -x axis. + m.expand_min = getprop(m.nodeString~"expand-min-fire-range"); # Bool. Default false. If min fire range should expand with closing rate. Mainly use this for A/A missiles. + m.asc = getprop(m.nodeString~"attack-steering-cue-enabled");# Bool. ASC enabled. + # navigation, guiding and seekerhead + m.max_seeker_dev = getprop(m.nodeString~"seeker-field-deg") / 2; # missiles own seekers total FOV diameter. + m.guidance = getprop(m.nodeString~"guidance"); # heat/radar/semi-radar/tvm/laser/gps/gps-laser/vision/unguided/level/gyro-pitch/radiation/inertial/remote/remote-stable/command/sample + m.guidanceLaw = getprop(m.nodeString~"navigation"); # guidance-law: direct/direct-alt/OPN/PN/APN/PNxxyy/APNxxyy/LOS (use direct for pure pursuit, use PN for A/A missiles, use APN for modern SAM missiles PN for older, use PNxxyy/APNxxyy for surface to air where xx is degrees to aim above target, yy is seconds it will do that). GPN is APN for winged glidebombs. + m.guidanceLawHorizInit = getprop(m.nodeString~"navigation-init-pure-15"); # Bool. Guide in horizontal plane using pure pursuit until target with 15 deg of nose, before switching to + m.pro_constant = getprop(m.nodeString~"proportionality-constant"); # Constant for how sensitive proportional navigation is to target speed/acc. Normally between 3-6. [optional] + m.all_aspect = getprop(m.nodeString~"all-aspect"); # bool. set to false if missile only locks on reliably to rear of target aircraft + m.angular_speed = getprop(m.nodeString~"seeker-angular-speed-dps"); # only for heat/vision seeking missiles. Max angular speed that the target can move as seen from seeker, before seeker loses lock. + m.sun_lock = getprop(m.nodeString~"lock-on-sun-deg"); # only for heat seeking missiles. If it looks at sun within this angle, it will lose lock on target. + m.loft_alt = getprop(m.nodeString~"loft-altitude"); # if 0 then no snap up. Below 10000 then cruise altitude above ground. Above 10000 max altitude it will snap up to. + m.follow = getprop(m.nodeString~"terrain-follow"); # bool. used for anti-ship missiles that should be able to terrain follow instead of purely sea skimming. + m.reaquire = getprop(m.nodeString~"reaquire"); # bool. If weapon will try to reaquire lock after losing it. [optional] + m.maxPitch = getprop(m.nodeString~"max-pitch-deg"); # After propulsion burnout it will not be able to steer up more than this. Useful for guided bombs. [optional] + m.guidanceEnabled = getprop(m.nodeString~"guidance-enabled"); # Boolean. If guidance will activate when launched. [optional] + m.terminal_alt_factor = getprop(m.nodeString~"terminal-alt-factor"); # Float. Cruise alt multiplied by this factor determines how much is rise up in terminal. Default: 2 + m.terminal_rise_time = getprop(m.nodeString~"terminal-rise-time"); # Float. Seconds before reaching target that cruise missile will start to rise up. Default: 6 + m.terminal_dive_time = getprop(m.nodeString~"terminal-dive-time"); # Float. Seconds before reaching target that cruise missile will start to dive down. Default: 4 + m.rosette_radius = getprop(m.nodeString~"rosette-radius-deg"); # Float. Radius of uncaged rosette search pattern. If 0 then disabled. + m.seam_support = getprop(m.nodeString~"sw-expanded-acquisition-mode");# Bool. Default true. SEAM support. False for old heatseekers like AIM-9B/F/D/E and RB24. Supports then only static commandDir mode, uncage happens at firing. No radar slaving, no SEAM scan, no manual cage/uncage. + m.oldPattern = getprop(m.nodeString~"nutate-double-d-instead-of-circle"); # Bool. For old SEAM missiles like AIM-9G/H. (maybe J also, don't know). + m.seeker_filter = getprop(m.nodeString~"seeker-filter"); # Float: Ability to filter out background noise. Typically between 1 to 2 for IR. + # engine + m.force_lbf_1 = getprop(m.nodeString~"thrust-lbf-stage-1"); # stage 1 thrust [optional] + m.force_lbf_2 = getprop(m.nodeString~"thrust-lbf-stage-2"); # stage 2 thrust [optional] + m.force_lbf_3 = getprop(m.nodeString~"thrust-lbf-stage-3"); # stage 3 thrust [optional] + m.stage_1_duration = getprop(m.nodeString~"stage-1-duration-sec"); # stage 1 duration [optional] + m.stage_gap_duration = getprop(m.nodeString~"stage-gap-duration-sec"); # gap duration between stage 1 and 2 [optional] + m.stage_2_duration = getprop(m.nodeString~"stage-2-duration-sec"); # stage 2 duration [optional] + m.stage_3_duration = getprop(m.nodeString~"stage-3-duration-sec"); # stage 3 duration [optional] + m.stage_1_jet = getprop(m.nodeString~"stage-1-jet"); # Boolean. If stage 1 is a jet engine [optional] + m.stage_2_jet = getprop(m.nodeString~"stage-2-jet"); # Boolean. If stage 2 is a jet engine [optional] + m.stage_3_jet = getprop(m.nodeString~"stage-3-jet"); # Boolean. If stage 3 is a jet engine [optional] + m.jet_effectiveness = getprop(m.nodeString~"jet-effectiveness-10000ft"); # Effectiveness of the turnine at 10000 ft compared to sealevel [optional] + m.weight_fuel_lbm = getprop(m.nodeString~"weight-fuel-lbm"); # fuel weight [optional]. If this property is not present, it won't lose weight as the fuel is used. + m.vector_thrust = getprop(m.nodeString~"vector-thrust"); # Boolean. This will make less drag due to high G turns while engine is running. [optional] + m.engineEnabled = getprop(m.nodeString~"engine-enabled"); # Boolean. If engine will start at all. [optional] + # aerodynamic + m.weight_launch_lbm = getprop(m.nodeString~"weight-launch-lbs"); # total weight of armament, including fuel and warhead. + m.Cd_base = getprop(m.nodeString~"drag-coeff"); # drag coefficient + m.Cd_delta = getprop(m.nodeString~"delta-drag-coeff-deploy"); # drag coefficient added by deployment + m.ref_area_sqft = getprop(m.nodeString~"cross-section-sqft"); # normally is crosssection area of munition (without fins) + m.max_g = getprop(m.nodeString~"max-g"); # max G-force the missile can pull at sealevel (if vector thrust enabled, this will be auto reduced at engine burnout) + m.min_speed_for_guiding = getprop(m.nodeString~"min-speed-for-guiding-mach"); # minimum speed before the missile steers, before it reaches this speed it will fly ballistic. + m.intoBore = getprop(m.nodeString~"ignore-wind-at-release"); # Boolean. Default false. If true dropped weapons will ignore sideslip and AOA and start flying in aircraft bore direction. Will always be the case if ejector speed is non zero. + m.lateralSpeed = getprop(m.nodeString~"lateral-dps"); # Lateral speed in degrees per second. This is mostly for cosmetics. + # detonation + m.weight_whead_lbm = getprop(m.nodeString~"weight-warhead-lbs"); # warhead total mass. Includes scapnel, expanding rods etc etc. + m.arming_time = getprop(m.nodeString~"arming-time-sec"); # time for weapon to arm + m.selfdestruct_time = getprop(m.nodeString~"self-destruct-time-sec"); # time before selfdestruct + m.destruct_when_free = getprop(m.nodeString~"self-destruct-at-lock-lost"); # selfdestruct if lose target. Mostly for man-in-the-loop weapons like some old command guided. + m.reportDist = getprop(m.nodeString~"max-report-distance"); # Interpolation hit: max distance from target it report it exploded, not passed. Trig hit: Distance where it will trigger. + m.multiHit = getprop(m.nodeString~"hit-everything-nearby"); # bool. Only works well for slow moving targets. Needs you to pass contacts to release(). + m.inert = getprop(m.nodeString~"inert"); # bool. If the weapon is inert and will not detonate. [optional] + # avionics sounds + m.vol_search = getprop(m.nodeString~"vol-search"); # sound volume when searching + m.vol_track = getprop(m.nodeString~"vol-track"); # sound volume when having lock + # launching conditions + m.rail = getprop(m.nodeString~"rail"); # if the weapon is rail or tube fired set to true. If dropped 7ft before ignited set to false. + m.rail_dist_m = getprop(m.nodeString~"rail-length-m"); # length of tube/rail + m.rail_forward = getprop(m.nodeString~"rail-point-forward"); # true for rail, false for rail/tube with a pitch/heading-deviation + m.rail_pitch_deg = getprop(m.nodeString~"rail-pitch-deg"); # Only used when rail is not forward. 90 for vertical tube. Max 90, min -90. + m.rail_head_deg = getprop(m.nodeString~"rail-heading-deg"); # Only used when rail is not forward. 90 for vertical tube. + m.drop_time = getprop(m.nodeString~"drop-time"); # Time to fall before stage 1 thrust starts. + m.deploy_time = getprop(m.nodeString~"deploy-time"); # Time to deploy wings etc. Time starts when drop ends or rail passed. + m.no_pitch = getprop(m.nodeString~"pitch-animation-disabled"); # Bool. Default false. Set to true for ejection seats. + m.eject_speed = getprop(m.nodeString~"ejector-speed-fps"); # Ordnance ejected by pylon with this speed. Default = 0. Optional. Ignored if on rail. + m.guideWhileDrop = getprop(m.nodeString~"guide-before-ignition"); # Can guide before engine ignition if speed is high enough. + # counter-measures + m.chaffResistance = getprop(m.nodeString~"chaff-resistance"); # Float 0-1. Amount of resistance to chaff. Default 0.850. [optional] + m.flareResistance = getprop(m.nodeString~"flare-resistance"); # Float 0-1. Amount of resistance to flare. Default 0.850. [optional] + # data-link to launch platform + m.data = getprop(m.nodeString~"telemetry"); # Boolean. Data link back to aircraft when missile is flying. [optional] + m.dlz_enabled = getprop(m.nodeString~"DLZ"); # Supports dynamic launch zone info. For now only works with A/A. [optional] + m.dlz_opt_alt = getprop(m.nodeString~"DLZ-optimal-alt-feet"); # Minimum altitude required to hit the target at max range. + m.dlz_opt_mach = getprop(m.nodeString~"DLZ-optimal-closing-mach"); # Closing speed required to hit the target at max range at minimum altitude. + # detailed drag settings + m.Cd_plume = getprop(m.nodeString~"exhaust-plume-parasitic-drag-factor"); # Default 1. For AIM-120, Naval Postgraduate School paper suggest around 0.6. It will reduce drag during burn. + m.simple_drag = getprop(m.nodeString~"simplified-induced-drag"); # bool. Default true. If enabled, the properties below wont be used: + m.wing_aspect_ratio = getprop(m.nodeString~"wing-aspect-ratio"); # span^2/wing_area. Default to 8 + m.wing_eff = getprop(m.nodeString~"wing-efficiency-relative-to-an-elliptical-planform"); # Default to 0.85 + + + if (m.cold_detect_range_nm == nil) { + # backwards compatibility + m.cold_detect_range_nm = m.max_fire_range_nm; + } + m.detect_range_curr_nm = m.cold_detect_range_nm; + + if (m.max_seeker_dev == nil) { + m.max_seeker_dev = 15; + } + if (m.beam_width_deg == nil) { + m.beam_width_deg = 4; + } + m.beam_width_deg *= 0.5; + + if (m.eject_speed == nil) { + m.eject_speed = 0; + } + + if (m.rail_forward == 1) { + m.rail_pitch_deg = 0; + m.rail_head_deg = 0; + } + + if (m.asc == nil) { + m.asc = 0; + } + + if (m.wing_aspect_ratio == nil) { + m.wing_aspect_ratio = 8.0; + } + + if (m.wing_eff == nil) { + m.wing_eff = 0.85; + } + + if (m.expand_min == nil) { + m.expand_min = 0; + } + + if (m.rail_head_deg == nil) { + m.rail_head_deg = 0; + } + + if (m.radarOrigin == nil) { + m.radarOrigin = 1; + } + + if (m.all_aspect == nil) { + m.all_aspect = 1; + } + + if (m.guideWhileDrop == nil) { + m.guideWhileDrop = 0; + } + + if (m.seam_support == nil) { + m.seam_support = 1; + } + + if (m.rosette_radius == nil) { + m.rosette_radius = 7.5; + } + + if (m.oldPattern == nil) { + m.oldPattern = 0; + } + + if (m.seeker_filter == nil) { + m.seeker_filter = 0; + } + + if (m.ready_time == nil) { + m.ready_time = 0; + } + if (m.coolable == nil) { + m.coolable = 0; + } + if (m.intoBore == nil) { + m.intoBore = 0; + } + + if (m.lateralSpeed == nil) { + m.lateralSpeed = 0; + } + + if(m.maxPitch == nil) { + m.maxPitch = 90; + } + + if(m.loal == nil) { + m.loal = 0; + } + + if(m.Cd_delta == nil) { + m.Cd_delta = 0; + } + + if (m.Cd_plume == nil) { + m.Cd_plume = 1.0; + } + + if(m.canSwitch == nil) { + m.canSwitch = 0; + } + + if(m.terminal_alt_factor == nil) { + m.terminal_alt_factor = 2; + } + + if(m.terminal_rise_time == nil) { + m.terminal_rise_time = 6; + } + + if(m.terminal_dive_time == nil) { + m.terminal_dive_time = 4; + } + + if (m.weight_fuel_lbm == nil) { + m.weight_fuel_lbm = 0; + } + if (m.data == nil) { + m.data = 0; + } + if (m.stage_1_jet == nil) { + m.stage_1_jet = 0; + } + if (m.stage_2_jet == nil) { + m.stage_2_jet = 0; + } + if (m.stage_3_jet == nil) { + m.stage_3_jet = 0; + } + if (m.jet_effectiveness == nil) { + m.jet_effectiveness = 0.75; + } + if (m.vector_thrust == nil) { + m.vector_thrust = 0; + } + if (m.flareResistance == nil or !m.gnd_launch) { + m.flareResistance = 0.85; + } + if (m.chaffResistance == nil or !m.gnd_launch) { + m.chaffResistance = 0.85; + } + if (m.guidanceLaw == nil) { + m.guidanceLaw = "PN"; + } + if (m.guidanceLawHorizInit == nil) { + m.guidanceLawHorizInit = 0; + } + if (m.pro_constant == nil) { + m.pro_constant = 3; + } + if (m.force_lbf_1 == nil) { + m.force_lbf_1 = 0; + } + if (m.force_lbf_2 == nil) { + m.force_lbf_2 = 0; + } + if (m.force_lbf_3 == nil) { + m.force_lbf_3 = 0; + } + if(m.stage_gap_duration == nil) { + m.stage_gap_duration = 0; + } + if(m.stage_1_duration == nil) { + m.stage_1_duration = 0; + } + if(m.stage_2_duration == nil) { + m.stage_2_duration = 0; + } + if(m.stage_3_duration == nil) { + m.stage_3_duration = 0; + } + if (m.destruct_when_free == nil) { + m.destruct_when_free = 0; + } + if (m.reaquire == nil) { + if (m.guidance == "semi-radar" or m.guidance == "laser" or m.guidance == "heat" or m.guidance == "vision" or m.guidance == "tvm") { + m.reaquire = 1; + } else { + m.reaquire = 0; + } + } + if (m.rail == 1) { + # drop distance in time + m.drop_time = 0; + } elsif (m.drop_time == nil) { + m.drop_time = 0.5; + } + if (m.deploy_time == nil) { + m.deploy_time = 0.3; + } + if(m.typeLong == nil) { + m.typeLong = m.type; + } + if(m.typeShort == nil) { + m.typeShort = m.type; + } + if (m.standbyFlight == nil) { + m.standbyFlight = "unguided"; + } + if(m.switchTime == nil) { + m.switchTime = m.beam_width_deg*m.max_seeker_dev*0.05; + } + if(m.multiHit == nil) { + m.multiHit = 0; + } + if(m.inert == nil) { + m.inert = 0; + } + if(m.engineEnabled == nil) { + m.engineEnabled = 1; + } + if(m.guidanceEnabled == nil) { + m.guidanceEnabled = 1; + } + if (m.no_pitch == nil) { + m.no_pitch = 0; + } + if(m.simple_drag == nil) { + m.simple_drag = 1; + } + if(m.noCommonTarget == nil) { + m.noCommonTarget = 0; + } + + m.useModelCase = getprop("payload/armament/modelsUseCase"); + m.useModelUpperCase = getprop("payload/armament/modelsUpperCase"); + m.weapon_model_type = type; + if (m.useModelCase == 1) { + if (m.useModelUpperCase == 1) { + m.weapon_model_type = string.uc(type); + } else { + m.weapon_model_type = m.type_lc; + } + } + m.weapon_model = getprop("payload/armament/models")~m.weapon_model_type~"/"~m.type_lc~"-"; + m.weapon_model2 = getprop("payload/armament/models")~m.weapon_model_type~"/"~m.type_lc; + + # Find the next index for "models/model" and create property node. + # Find the next index for "ai/models/aim-9" and create property node. + # (M. Franz, see Nasal/tanker.nas) + var n = props.globals.getNode("models", 1); + var i = 0; + for (i = 0; 1==1; i += 1) { + if (n.getChild("model", i, 0) == nil) { + break; + } + } + m.model = n.getChild("model", i, 1); + + n = props.globals.getNode("ai/models", 1); + for (i = 0; 1==1; i += 1) { + if (n.getChild(m.type_lc, i, 0) == nil) { + break; + } + } + m.ai = n.getChild(m.type_lc, i, 1); + if(m.data == 1) { + m.ai.getNode("ETA", 1).setIntValue(-1); + m.ai.getNode("hit", 1).setIntValue(-1); + } + m.ai.getNode("valid", 1).setBoolValue(0); + m.ai.getNode("name", 1).setValue(type); + m.ai.getNode("sign", 1).setValue(sign); + m.ai.getNode("callsign", 1).setValue(sprintf("%s_%d", type, m.unique_id)); + m.ai.getNode("missile", 1).setBoolValue(1); + + + var id_model = m.weapon_model ~ m.ID ~ ".xml"; + m.model.getNode("path", 1).setValue(id_model); + m.model.getNode("enable-hot", 1).setBoolValue(0);# This is if people forget to set it in xml. + m.model.getNode("name", 1).setValue(m.typeLong);# this helps in debugging. + + + + # Create the AI position and orientation properties. + m.latN = m.ai.getNode("position/latitude-deg", 1); + m.lonN = m.ai.getNode("position/longitude-deg", 1); + m.altN = m.ai.getNode("position/altitude-ft", 1); + m.hdgN = m.ai.getNode("orientation/true-heading-deg", 1); + m.pitchN = m.ai.getNode("orientation/pitch-deg", 1); + m.rollN = m.ai.getNode("orientation/roll-deg", 1); + + m.mpLat = getprop("payload/armament/MP-lat");# properties to be used for showing missile over MP. + m.mpLon = getprop("payload/armament/MP-lon"); + m.mpAlt = getprop("payload/armament/MP-alt"); + m.mpAltft = getprop("payload/armament/MP-alt-ft");#used for anim of S-300 camera view: Follow + m.mpShow = 0; + if (m.mpLat != nil and m.mpLon != nil and m.mpAlt != nil and m.mpAltft != nil) { + m.mpLat = props.globals.getNode(m.mpLat, 0); + m.mpLon = props.globals.getNode(m.mpLon, 0); + m.mpAlt = props.globals.getNode(m.mpAlt, 0); + m.mpAltft = props.globals.getNode(m.mpAltft, 0); + if (m.mpLat != nil and m.mpLon != nil and m.mpAlt != nil and m.mpAltft != nil) { + m.mpShow = 1; + } + } + + + + m.target_air = find("A", m.class)==-1?0:1; + m.target_sea = find("M", m.class)==-1?0:1;#use M for marine, since S can be confused with surface. + m.target_gnd = find("G", m.class)==-1?0:1; + m.target_pnt = find("P", m.class)==-1?0:1; + + m.ac = nil; + + m.coord = geo.Coord.new().set_latlon(0, 0, 0); + m.t_coord = nil; + + + + # + # Seekerhead + # + m.caged = 1;# if gyro is caged + m.uncage_auto = 1;# will uncage when lock achieved (if SEAM supported) + m.command_dir_heading = 0;# where seeker is commanded in slave mode to look + m.command_dir_pitch = 0; + m.uncage_idle_heading = rand()*(2*m.max_seeker_dev)-m.max_seeker_dev; + m.uncage_idle_pitch = rand()*(2*m.max_seeker_dev)-m.max_seeker_dev; + m.contacts = [];# contacts that should be considered to lock onto. In slave it will only lock to the first. + m.warm = 1;# normalized warm/cold + m.ready_standby_time = 0;# time when started from standby + m.cooling = 0; + m.slave_to_radar = m.seam_support?1:0; + m.seeker_last_time = 0; + m.seeker_elev = 0; + m.seeker_head = 0; + m.seam_scan = 0; + m.cooling_last_time = 0; + m.cool_total_time = 0; + + # + # Emesary damage system + # + m.noti_time = 1.5;#2xsend freq of emesary notifications + m.last_noti = -2; + + # + # Aerodynamics and propulsion + # + m.density_alt_diff = 0; + m.max_g_current = m.max_g; + m.old_speed_horz_fps = nil; + m.old_speed_fps = 0; + m.g = 0; + m.limitGs = 0; + m.limitHalfGs = 0; + m.speed_down_fps = nil; + m.speed_east_fps = nil; + m.speed_north_fps = nil; + m.speed_horizontal_fps = nil; + m.alt_ft = nil; + m.pitch = nil; + m.hdg = nil; + m.thrust_lbf = 0; + m.myG = 0; + + # + # Simulation + # + m.last_dt = 0; + m.counter_last = -2; + m.counter = 0; + m.life_time = 0; + + # + # Fuse + # + m.crc_frames_look_back = 2; + m.crc_coord = []; + m.crc_t_coord = []; + m.crc_range = []; + setsize(m.crc_coord, m.crc_frames_look_back + 1); + setsize(m.crc_t_coord, m.crc_frames_look_back + 1); + setsize(m.crc_range, m.crc_frames_look_back + 1); + + # + # navigation and guidance + # + m.last_track_e = 0; + m.last_track_h = 0; + m.guiding = 1; + m.t_alt = 0; + m.dist_curr = 0; + m.dist_curr_direct = -1; + m.t_elev_deg = 0; + m.t_course = 0; + m.t_heading = nil; + m.t_pitch = nil; + m.t_speed_fps = nil; + m.dist_last = nil; + m.dist_direct_last = nil; + m.last_t_course = nil; + m.last_t_elev_deg = nil; + m.last_cruise_or_loft = 0; + m.last_t_norm_speed = nil; + m.last_t_elev_norm_speed = nil; + m.dive_token = 0; + m.raw_steer_signal_elev = 0; + m.raw_steer_signal_head = 0; + m.cruise_or_loft = 0; + m.curr_deviation_e = 0; + m.curr_deviation_h = 0; + m.track_signal_e = 0; + m.track_signal_h = 0; + m.remote_control_yaw = 0; + m.remote_control_pitch = 0; + m.prevTarget = nil; + m.prevGuidance = nil; + m.keepPitch = 0; + m.horz_closing_rate_fps = -1; + m.vert_closing_rate_fps = -1; + m.usingTGPPoint = 0; + m.rotate_token = 0; + m.CREv = 0; + m.CREh = 0; + m.CREv_old = 0; + m.CREh_old = 0; + m.CRE_old_dt = 0.05; + m.steer_for_free = 0; + + + + # + # Terrain following + # + m.nextGroundElevation = 0; # next Ground Elevation + m.nextGroundElevationMem = [-10000, -1]; + m.terrainStage = 0; + + # + # Rail + # + m.rail_passed = 0; + m.x = 0; + m.y = 0; + m.z = 0; + m.rail_pos = 0; + m.rail_speed_into_wind = 0; + m.rail_passed_time = nil; + m.deploy = 0; + + # + # stats + # + m.maxFPS = 0; + m.maxMach = 0; + m.maxMach1 = 0;#stage 1 + m.maxMach2 = 0;#stage 2 + m.maxMach3 = 0;#stage 3 + m.maxMach4 = 0;#stage 3 end + m.energyBleedKt = 0; + + # + # Counter-measure response + # + m.flareLast = 0; + m.flareTime = 0; + m.flareLock = 0; + m.chaffLast = 0; + m.chaffTime = 0; + m.chaffLock = 0; + m.chaffLockTime = -1000; + m.flarespeed_fps = nil; + + # + # Telemetry + # + m.first = 0; + + # + # these are used for limiting debugging spam + # + m.heatLostLock = 0; + m.semiLostLock = 0; + m.radLostLock = 0; + m.tooLowSpeed = 0; + m.tooLowSpeedPass = 0; + m.tooLowSpeedTime = -1; + m.lostLOS = 0; + + + # + # LOAL + # + m.newTargetAssigned = 0; + m.switchIndex = 0; + m.hasGuided = 0; + m.fovLost = 0; + m.maddog = 0; + m.nextFovCheck = m.switchTime; + m.observing = m.guidance; + + # + # Sound + # + m.SwSoundOnOff.setBoolValue(0); + m.SwSoundVol.setDoubleValue(m.vol_search); + m.pendingLaunchSound = -1; + m.explodeSound = 1; + + + + + m.standby();# these loops will run until released or deleted. + + #for multithreading + m.frameToggle = thread.newsem(); + m.myMath = {parents:[vector.Math],};#personal vector library, to avoid using a mutex on it. + + return AIM.active[m.ID] = m; + }, + + del: func { + # can be called at any time, before or during flight. + # + # stop semaphore counting up, and escape flight loop if its running. + # + # Note: Must never be called from the flight loop thread. + # + me.printCode("deleted weapon"); + if (me["frameLoop"] != nil) { + me.frameLoop.stop(); + me.frameLoop = nil; + } + me.deleted = 1; + thread.semup(me.frameToggle); + if (me.first) { + me.resetFirst(); + } + me.model.remove(); + me.ai.remove(); + if (me.status == MISSILE_FLYING) { + delete(AIM.flying, me.flyID); + if (me.tacview_support) { + if (tacview.starttime) { + thread.lock(tacview.mutexWrite); + tacview.write("#" ~ (systime() - tacview.starttime)~"\n"); + tacview.write("0,Event=Destroyed|"~me.tacviewID~"\n"); + tacview.write("-"~me.tacviewID~"\n"); + thread.unlock(tacview.mutexWrite); + } + } + if(getprop("payload/armament/msg")) { + thread.lock(mutexTimer); + #lat,lon,alt,rdar,typeID,typ,unique,thrustOn,callsign, heading, pitch, speed, is_deleted=0 + append(AIM.timerQueue, [AIM, AIM.notifyInFlight, [nil, -1, -1, 0, 0, me.typeID, "delete()", me.unique_id, 0,"", 0, 0, 0, 1], -1]); + thread.unlock(mutexTimer); + } + } else { + delete(AIM.active, me.ID); + } + AIM.setETA(nil); + me.SwSoundVol.setDoubleValue(0); + }, + + getCCRP: func (maxFallTime_sec, timeStep) { + # returns distance in meters to ideal release time. + # + # maxFallTime_sec: maximum allowed predicted falltime. Higher value will make method take more CPU time. + # timeStep: Fidelity of prediction. Lower value will increase CPU consumption. + # + # Assumptions: + # Ordnance do not have propulsion + # Ordnance has very limited steering + if (me.status != MISSILE_LOCK or me.Tgt == nil) { + return nil; + } + me.ccrp_agl = (getprop("position/altitude-ft")-me.Tgt.get_altitude())*FT2M; + #me.agl = getprop("position/altitude-agl-ft")*FT2M; + me.ccrp_alti = getprop("position/altitude-ft")*FT2M; + me.ccrp_roll = getprop("orientation/roll-deg"); + me.ccrp_vel = getprop("velocities/groundspeed-kt")*0.5144;#m/s + me.ccrp_dens = getprop("sim/flight-model") == "jsb"?getprop("fdm/jsbsim/atmosphere/density-altitude"):getprop("position/altitude-ft"); + me.ccrp_mach = getprop("velocities/mach"); + me.ccrp_speed_down_fps = getprop("velocities/speed-down-fps"); + me.ccrp_speed_east_fps = getprop("velocities/speed-east-fps"); + me.ccrp_speed_north_fps = getprop("velocities/speed-north-fps"); + if (me.eject_speed != 0 and !me.rail) { + # add ejector speed down from belly: + me.aircraft_vec = [me.ccrp_speed_north_fps,-me.ccrp_speed_east_fps,-me.ccrp_speed_down_fps]; + me.eject_vec = me.myMath.normalize(me.myMath.eulerToCartesian3Z(-OurHdg.getValue(),OurPitch.getValue(),OurRoll.getValue())); + me.eject_vec = me.myMath.product(-me.eject_speed, me.eject_vec); + me.init_rel_vec = me.myMath.plus(me.aircraft_vec, me.eject_vec); + me.ccrp_speed_down_fps = -me.init_rel_vec[2]; + me.ccrp_speed_east_fps = -me.init_rel_vec[1]; + me.ccrp_speed_north_fps = me.init_rel_vec[0]; + } + + me.ccrp_t = 0.0; + + me.ccrp_altC = me.ccrp_agl; + me.ccrp_vel_z = -me.ccrp_speed_down_fps*FT2M;#positive upwards + me.ccrp_fps_z = -me.ccrp_speed_down_fps; + me.ccrp_vel_x = math.sqrt(me.ccrp_speed_east_fps*me.ccrp_speed_east_fps+me.ccrp_speed_north_fps*me.ccrp_speed_north_fps)*FT2M; + me.ccrp_fps_x = me.ccrp_vel_x * M2FT; + + me.ccrp_rs = me.rho_sndspeed(me.ccrp_dens-(me.ccrp_agl/2)*M2FT); + me.ccrp_rho = me.ccrp_rs[0]; + me.ccrp_Cd = me.drag(me.ccrp_mach); + me.ccrp_mass = me.weight_launch_lbm * LBM2SLUGS; + me.ccrp_q = 0.5 * me.ccrp_rho * me.ccrp_fps_z * me.ccrp_fps_z; + me.ccrp_deacc = (me.ccrp_Cd * me.ccrp_q * me.ref_area_sqft) / me.ccrp_mass; + + while (me.ccrp_altC > 0 and me.ccrp_t <= maxFallTime_sec) { + me.ccrp_t += timeStep; + me.ccrp_acc = -9.81 + me.ccrp_deacc * FT2M; + me.ccrp_vel_z += me.ccrp_acc * timeStep; + me.ccrp_altC = me.ccrp_altC + me.ccrp_vel_z*timeStep+0.5*me.ccrp_acc*timeStep*timeStep; + } + #printf("predict fall time=%0.1f", me.t); + + if (me.ccrp_t >= maxFallTime_sec) { + return nil; + } + + me.ccrp_q = 0.5 * me.ccrp_rho * me.ccrp_fps_x * me.ccrp_fps_x; + me.ccrp_deacc = (me.ccrp_Cd * me.ccrp_q * me.ref_area_sqft) / me.ccrp_mass; + me.ccrp_acc = -me.ccrp_deacc * FT2M; + + me.ccrp_fps_x_final = me.ccrp_t*me.ccrp_acc+me.ccrp_fps_x;# calc final horz speed + me.ccrp_fps_x_average = (me.ccrp_fps_x-(me.ccrp_fps_x-me.ccrp_fps_x_final)*0.5); + me.ccrp_mach_average = me.ccrp_fps_x_average / me.ccrp_rs[1]; + + me.ccrp_Cd = me.drag(me.ccrp_mach_average); + me.ccrp_q = 0.5 * me.ccrp_rho * me.ccrp_fps_x_average * me.ccrp_fps_x_average; + me.ccrp_deacc = (me.ccrp_Cd * me.ccrp_q * me.ref_area_sqft) / me.ccrp_mass; + me.ccrp_acc = -me.ccrp_deacc * FT2M; + me.ccrp_dist = me.ccrp_vel_x*me.ccrp_t+0.5*me.ccrp_acc*me.ccrp_t*me.ccrp_t; + + me.ccrp_ac = geo.aircraft_position(); + me.ccrpPos = geo.Coord.new(me.ccrp_ac); + + # we calc heading from composite speeds, due to alpha and beta might influence direction bombs will fall: + me.ccrp_heading = geo.normdeg(math.atan2(me.ccrp_speed_east_fps,me.ccrp_speed_north_fps)*R2D); + me.ccrpPos.apply_course_distance(me.ccrp_heading, me.ccrp_dist); + + #printf("Will fall %0.1f NM ahead of aircraft.", me.dist*M2NM); + me.ccrp_elev = me.ccrp_alti-me.ccrp_agl;#faster + me.ccrpPos.set_alt(me.ccrp_elev); + + me.ccrp_distCCRP = me.ccrpPos.distance_to(me.Tgt.get_Coord()); + return me.ccrp_distCCRP; + }, + + getCCIPadv: func (maxFallTime_sec, timeStep) { + # for non flat areas. Lower falltime or higher timestep means using less CPU time. + # returns nil for higher than maxFallTime_sec. Else a vector with [Coord, hasTimeToArm]. + me.ccip_altC = getprop("position/altitude-ft")*FT2M; + me.ccip_dens = getprop("fdm/jsbsim/atmosphere/density-altitude"); + me.ccip_speed_down_fps = getprop("velocities/speed-down-fps"); + me.ccip_speed_east_fps = getprop("velocities/speed-east-fps"); + me.ccip_speed_north_fps = getprop("velocities/speed-north-fps"); + if (me.eject_speed != 0 and !me.rail) { + # add ejector speed down from belly: + me.aircraft_vec = [me.ccip_speed_north_fps,-me.ccip_speed_east_fps,-me.ccip_speed_down_fps]; + me.eject_vec = me.myMath.normalize(me.myMath.eulerToCartesian3Z(-OurHdg.getValue(),OurPitch.getValue(),OurRoll.getValue())); + me.eject_vec = me.myMath.product(-me.eject_speed, me.eject_vec); + me.init_rel_vec = me.myMath.plus(me.aircraft_vec, me.eject_vec); + me.ccip_speed_down_fps = -me.init_rel_vec[2]; + me.ccip_speed_east_fps = -me.init_rel_vec[1]; + me.ccip_speed_north_fps = me.init_rel_vec[0]; + } + + me.ccip_t = 0.0; + me.ccip_dt = timeStep; + me.ccip_fps_z = -me.ccip_speed_down_fps; + me.ccip_fps_x = math.sqrt(me.ccip_speed_east_fps*me.ccip_speed_east_fps+me.ccip_speed_north_fps*me.ccip_speed_north_fps); + me.ccip_bomb = me; + + me.ccip_rs = me.ccip_bomb.rho_sndspeed(getprop("sim/flight-model") == "jsb"?me.ccip_dens:me.ccip_altC*M2FT); + me.ccip_rho = me.ccip_rs[0]; + me.ccip_mass = me.ccip_bomb.weight_launch_lbm * LBM2SLUGS; + + me.ccipPos = geo.Coord.new(geo.aircraft_position()); + + # we calc heading from composite speeds, due to alpha and beta might influence direction bombs will fall: + if(me.ccip_fps_x == 0) return nil; + me.ccip_heading = geo.normdeg(math.atan2(me.ccip_speed_east_fps,me.ccip_speed_north_fps)*R2D); + #print(); + #printf("CCIP %.1f", me.ccip_heading); + me.ccip_pitch = math.atan2(me.ccip_fps_z, me.ccip_fps_x); + while (me.ccip_t <= maxFallTime_sec) { + me.ccip_t += me.ccip_dt; + me.ccip_bomb.deploy = me.clamp(me.extrapolate(me.ccip_t, me.drop_time, me.drop_time+me.deploy_time,0,1),0,1); + # Apply drag + me.ccip_fps = math.sqrt(me.ccip_fps_x*me.ccip_fps_x+me.ccip_fps_z*me.ccip_fps_z); + if (me.ccip_fps==0) return nil; + me.ccip_q = 0.5 * me.ccip_rho * me.ccip_fps * me.ccip_fps; + me.ccip_mach = me.ccip_fps / me.ccip_rs[1]; + me.ccip_Cd = me.ccip_bomb.drag(me.ccip_mach); + me.ccip_deacc = (me.ccip_Cd * me.ccip_q * me.ccip_bomb.ref_area_sqft) / me.ccip_mass; + me.ccip_fps -= me.ccip_deacc*me.ccip_dt; + + # new components and pitch + me.ccip_fps_z = me.ccip_fps*math.sin(me.ccip_pitch); + me.ccip_fps_x = me.ccip_fps*math.cos(me.ccip_pitch); + me.ccip_fps_z -= g_fps * me.ccip_dt; + me.ccip_pitch = math.atan2(me.ccip_fps_z, me.ccip_fps_x); + + # new position + me.ccip_altC = me.ccip_altC + me.ccip_fps_z*me.ccip_dt*FT2M; + me.ccip_dist = me.ccip_fps_x*me.ccip_dt*FT2M; + me.ccip_oldPos = geo.Coord.new(me.ccipPos); + me.ccipPos.apply_course_distance(me.ccip_heading, me.ccip_dist); + me.ccipPos.set_alt(me.ccip_altC); + + # test terrain + me.ccip_grnd = geo.elevation(me.ccipPos.lat(),me.ccipPos.lon()); + if (me.ccip_grnd != nil) { + if (me.ccip_grnd > me.ccip_altC) { + #return [me.ccipPos,me.arming_time 0 and me.ccip_t <= maxFallTime_sec) {#20 secs is max fall time + me.ccip_t += me.ccip_dt; + me.ccip_acc = -9.81 + me.ccip_deacc * FT2M; + me.ccip_vel_z += me.ccip_acc * me.ccip_dt; + me.ccip_altC = me.ccip_altC + me.ccip_vel_z*me.ccip_dt+0.5*me.ccip_acc*me.ccip_dt*me.ccip_dt; + } + #printf("predict fall time=%0.1f", t); + + if (me.ccip_t >= maxFallTime_sec) { + return nil; + } + #t -= 0.75 * math.cos(pitch*D2R); # fudge factor + + me.ccip_q = 0.5 * me.ccip_rho * me.ccip_fps_x * me.ccip_fps_x; + me.ccip_deacc = (me.ccip_Cd * me.ccip_q * me.ccip_bomb.ref_area_sqft) / me.ccip_mass; + me.ccip_acc = -me.ccip_deacc * FT2M; + + me.ccip_fps_x_final = me.ccip_t*me.ccip_acc+me.ccip_fps_x;# calc final horz speed + me.ccip_fps_x_average = (me.ccip_fps_x-(me.ccip_fps_x-me.ccip_fps_x_final)*0.5); + me.ccip_mach_average = me.ccip_fps_x_average / me.ccip_rs[1]; + + me.ccip_Cd = me.ccip_bomb.drag(me.ccip_mach_average); + me.ccip_q = 0.5 * me.ccip_rho * me.ccip_fps_x_average * me.ccip_fps_x_average; + me.ccip_deacc = (me.ccip_Cd * me.ccip_q * me.ccip_bomb.ref_area_sqft) / me.ccip_mass; + me.ccip_acc = -me.ccip_deacc * FT2M; + me.ccip_dist = me.ccip_vel_x*me.ccip_t+0.5*me.ccip_acc*me.ccip_t*me.ccip_t; + + me.ccip_ac = geo.aircraft_position(); + me.ccipPos = geo.Coord.new(me.ccip_ac); + + # we calc heading from composite speeds, due to alpha and beta might influence direction bombs will fall: + me.ccip_heading = geo.normdeg(math.atan2(me.ccip_speed_east_fps,me.ccip_speed_north_fps)*R2D); + me.ccipPos.apply_course_distance(me.ccip_heading, me.ccip_dist); + + me.ccip_elev = me.ccip_alti-me.ccip_agl;#faster + me.ccipPos.set_alt(me.ccip_elev); + return [me.ccipPos,me.arming_time me.maxBearing) { + me.horiz_intercept[1] = me.Tgt.get_bearing() + me.maxBearing; + } elsif (me.relativeBearing < -me.maxBearing) { + me.horiz_intercept[1] = me.Tgt.get_bearing() - me.maxBearing; + } + + return [me.horiz_intercept[1], math.clamp(me.loft_cue, 0, 45)]; # attack-bearing, loft-cue + }, + + get_intercept: func (bearingToRunner, dist_m, runnerHeading, runnerSpeed, chaserSpeed, chaserCoord, chaserHeading) { + # from Leto + # needs: bearingToRunner_deg, dist_m, runnerHeading_deg, runnerSpeed_mps, chaserSpeed_mps, chaserCoord + # dist_m > 0 and chaserSpeed > 0 + + if (dist_m < 500) { + return nil; + } + + me.trigAngle = 90-bearingToRunner; + me.RunnerPosition = [dist_m*math.cos(me.trigAngle*D2R), dist_m*math.sin(me.trigAngle*D2R),0]; + me.ChaserPosition = [0,0,0]; + + me.VectorFromRunner = vector.Math.minus(me.ChaserPosition, me.RunnerPosition); + me.runner_heading = 90-runnerHeading; + me.RunnerVelocity = [runnerSpeed*math.cos(me.runner_heading*D2R), runnerSpeed*math.sin(me.runner_heading*D2R),0]; + + me.a = chaserSpeed * chaserSpeed - runnerSpeed * runnerSpeed; + me.b = 2 * vector.Math.dotProduct(me.VectorFromRunner, me.RunnerVelocity); + me.c = -dist_m * dist_m; + + if ((me.b*me.b-4*me.a*me.c)<0) { + # intercept not possible + return nil; + } + + me.t1 = (-me.b+math.sqrt(me.b*me.b-4*me.a*me.c))/(2*me.a); + me.t2 = (-me.b-math.sqrt(me.b*me.b-4*me.a*me.c))/(2*me.a); + + if (me.t1 < 0 and me.t2 < 0) { + # intercept not possible + return nil; + } + + me.timeToIntercept = 0; + if (me.t1 > 0 and me.t2 > 0) { + me.timeToIntercept = math.min(me.t1, me.t2); + } else { + me.timeToIntercept = math.max(me.t1, me.t2); + } + me.InterceptPosition = vector.Math.plus(me.RunnerPosition, vector.Math.product(me.timeToIntercept, me.RunnerVelocity)); + + me.ChaserVelocity = vector.Math.product(1/me.timeToIntercept, vector.Math.minus(me.InterceptPosition, me.ChaserPosition)); + + me.interceptAngle = vector.Math.angleBetweenVectors([0,1,0], me.ChaserVelocity); + me.interceptHeading = geo.normdeg(me.ChaserVelocity[0]<0?-me.interceptAngle:me.interceptAngle); + + me.interceptDist = chaserSpeed*me.timeToIntercept; + + me.interceptCoord = geo.Coord.new(chaserCoord); + me.interceptCoord = me.interceptCoord.apply_course_distance(me.interceptHeading, me.interceptDist); + me.interceptRelativeBearing = geo.normdeg180(me.interceptHeading-chaserHeading); + + return [me.timeToIntercept, me.interceptHeading, me.interceptCoord, me.interceptDist, me.interceptRelativeBearing]; + }, + + setContacts: func (vect) { + # sets a vector of contacts the weapons will try to lock onto + # Before launch: for heatseekers in bore or unslaved mode + # do NOT call this after launch + # see also release(vect) + if (me.status == MISSILE_FLYING) return; + me.contacts = vect; + }, + + commandDir: func (heading_deg, pitch_deg) { + # commands are relative to aircraft bore + if (me.status == MISSILE_FLYING) return; + if (vector.Math.angleBetweenVectors(vector.Math.eulerToCartesian2(-heading_deg, pitch_deg), [1,0,0]) <= me.fcs_fov) { + me.command_dir_heading = heading_deg; + me.command_dir_pitch = pitch_deg; + me.slave_to_radar = 0; + } + me.printCode("Bore/dir command: heading %0.1f pitch %0.1f", heading_deg, pitch_deg); + }, + + commandRadar: func (idle_heading = 0, idle_elevation = 0) { + # command that radar is looking at a target, slave to that. + if (!me.seam_support or me.status == MISSILE_FLYING) return; + if (me.status != MISSILE_LOCK) { + me.command_dir_heading = idle_heading; + me.command_dir_pitch = idle_elevation; + } + me.slave_to_radar = 1; + me.printCode("Slave radar command. Idle: heading %0.1f pitch %0.1f", idle_heading, idle_elevation); + }, + + isRadarSlaved: func { + if (me.status == MISSILE_FLYING) return 0; + return me.slave_to_radar; + }, + + setSEAMscan: func (xfov) { + if (!me.seam_support or me.status == MISSILE_FLYING) return; + me.seam_scan = xfov; + }, + + isSEAMscan: func { + return me.seam_scan; + }, + + getWarm: func () { + return me.warm; + }, + + setCooling: func (cooling) { + if (me.status == MISSILE_FLYING) return; + if (me.cooling != cooling) { + me.printCode("Cooling commanded: "~cooling); + me.cooling = cooling; + me.cooling_last_time = 0; + #var time = getprop("sim/time/elapsed-sec"); + } + }, + + isCooling: func () { + return me.cooling; + }, + + start: func { + if (me.status == MISSILE_STANDBY) { + me.status = MISSILE_STARTING; + me.ready_standby_time = getprop("sim/time/elapsed-sec"); + if (me.ready_standby_time == 0) me.ready_standby_time = 0.001; + #printf("start #%3d %s", me.ID, me.type); + } + }, + + stop: func { + if (me.status != MISSILE_FLYING) { + me.status = MISSILE_STANDBY; + #printf("stop #%3d %s", me.ID, me.type); + } + }, + + isCaged: func () { + if (!me.seam_support) return me.status != MISSILE_FLYING; + return me.caged; + }, + + isAutoUncage: func () { + if (!me.seam_support) return 0; + return me.uncage_auto; + }, + + setAutoUncage: func (auto) { + if (!me.seam_support or me.status == MISSILE_FLYING) return; + me.uncage_auto = auto; + me.printCode("Cage auto: "~auto); + }, + + setCaged: func (cage) { + if (!me.seam_support or me.status == MISSILE_FLYING) return; + me.caged = cage; + me.printCode("Cage: "~cage); + }, + + getSeekerInfo: func { + if (me.status == MISSILE_FLYING or me.status == MISSILE_STANDBY) { + return nil; + } + return [me.seeker_head, me.seeker_elev]; + }, + + eject: func () { + if (me.stage_1_duration == 0 or me.force_lbf_1 == 0) { + me.pendingLaunchSound = 0; + } + me.stage_1_duration = 0; + me.force_lbf_1 = 0; + me.stage_2_duration = 0; + me.force_lbf_2 = 0; + me.stage_3_duration = 0; + me.force_lbf_3 = 0; + me.stage_gap_duration = 0; + me.drop_time = 10000; + me.inert = 1; + me.engineEnabled = 0; + me.guidanceEnabled = 0; + me.rail = 0; + me.releaseAtNothing(); + }, + + releaseAtNothing: func() { + me.Tgt = nil; + me.release(); + }, + + release: func(vect=nil) { + # Release missile/bomb from its pylon/rail/tube and send it away. + # + me.release = nil;# no calling this method twice + me.elapsed_last = systime(); + me.status = MISSILE_FLYING; + + if (vect!= nil) { + + # sets a vector of contacts the weapons will try to lock onto + # For LOAL weapons. + # see also setContacts() + me.contacts = vect; + } else { + me.contacts = []; + } + me.launchSoundProp.setBoolValue(0); + + if (me.engineEnabled and me.stage_1_duration > 0 and me.force_lbf_1 > 0 and me.drop_time < 1.75) { + me.pendingLaunchSound = me.drop_time; + } elsif (me.drop_time != 10000 and (!me.engineEnabled or me.stage_1_duration == 0 or me.force_lbf_1 == 0)) { + me.pendingLaunchSound = 0; + } + + me.flyID = rand(); + AIM.flying[me.flyID] = me; + delete(AIM.active, me.ID); + me.animation_flags_props(); + + # Get the A/C position and orientation values. + me.ac = geo.aircraft_position(); + me.ac_init = geo.Coord.new(me.ac); + var ac_roll = OurRoll.getValue();# positive is banking right + var ac_pitch = OurPitch.getValue(); + var ac_hdg = OurHdg.getValue(); + + me.msl_hdg = ac_hdg; + me.msl_pitch = ac_pitch; + + if (me.rail) { + if (!me.rail_forward) { + me.position_on_rail = 0; + #if (me.rail_pitch_deg == 90 and me.Tgt != nil) { + # This only really works for surface launchers which is not rolled + # me.rail_head_deg = me.Tgt.get_bearing()-OurHdg.getValue(); + #} + me.railvec = vector.Math.eulerToCartesian3X(-me.rail_head_deg, me.rail_pitch_deg,0); + me.veccy = vector.Math.rollPitchYawVector(ac_roll,ac_pitch,-ac_hdg,me.railvec); + me.carty = vector.Math.cartesianToEuler(me.veccy); + me.msl_pitch = me.carty[1]; + me.defaultHeading = me.Tgt != nil?me.Tgt.get_bearing():0;#90 deg tubes align to target heading, else north + me.msl_hdg = (me.carty[0]==nil or (ac_roll == 0 and me.rail_pitch_deg == 90))?me.defaultHeading:me.carty[0]; + } + } + + # Compute missile initial position relative to A/C center + if (me.nasalPosition == nil) { + me.x = me.pylon_prop.getNode("offsets/x-m").getValue(); + me.y = me.pylon_prop.getNode("offsets/y-m").getValue(); + me.z = me.pylon_prop.getNode("offsets/z-m").getValue(); + } else { + me.x = me.nasalPosition[0]; + me.y = me.nasalPosition[1]; + me.z = me.nasalPosition[2]; + } + var init_coord = nil; + if (me.rail) { + if (!me.rail_forward) { + me.railBegin = [-me.x, -me.y, me.z]; + me.railEnd = vector.Math.plus(me.railBegin, vector.Math.product(me.rail_dist_m, me.railvec)); + } + } + if (offsetMethod and (!me.rail or me.rail_forward)) { + var pos = aircraftToCart({x:-me.x, y:me.y, z: -me.z}); + init_coord = geo.Coord.new(); + init_coord.set_xyz(pos.x, pos.y, pos.z); + } else { + init_coord = me.getGPS(me.x, me.y, me.z, ac_pitch, ac_hdg); + } + + + # Set submodel initial position: + var mlat = init_coord.lat(); + var mlon = init_coord.lon(); + var malt = init_coord.alt() * M2FT; + + me.coord = geo.Coord.new(init_coord); + # Get target position. + if (me.Tgt != nil) { + if (me.Tgt == contactPoint) { + me.usingTGPPoint = 1; + } + me.t_coord = me.Tgt.get_Coord(); + me.maddog = 0; + me.newTargetAssigned = 1; + } else { + me.maddog = 1; + } + + me.model.getNode("latitude-deg-prop", 1).setValue(me.latN.getPath()); + me.model.getNode("longitude-deg-prop", 1).setValue(me.lonN.getPath()); + me.model.getNode("elevation-ft-prop", 1).setValue(me.altN.getPath()); + me.model.getNode("heading-deg-prop", 1).setValue(me.hdgN.getPath()); + me.model.getNode("pitch-deg-prop", 1).setValue(me.pitchN.getPath()); + me.model.getNode("roll-deg-prop", 1).setValue(me.rollN.getPath()); + var loadNode = me.model.getNode("load", 1); + loadNode.setBoolValue(1); + + # Get initial velocity vector (aircraft): + me.speed_down_fps = getprop("velocities/speed-down-fps"); + me.speed_east_fps = getprop("velocities/speed-east-fps"); + me.speed_north_fps = getprop("velocities/speed-north-fps"); + me.speed_horizontal_fps = math.sqrt(me.speed_east_fps*me.speed_east_fps + me.speed_north_fps*me.speed_north_fps); + if (me.rail) { + if (!me.rail_forward) { + # TODO: add side wind here too since rail can now have heading offset too. + me.u = noseAir.getValue(); + me.w = -belowAir.getValue(); + me.rail_speed_into_wind = me.u*math.cos(me.rail_pitch_deg*D2R)+me.w*math.sin(me.rail_pitch_deg*D2R); + } else { + # rail is pointing forward + me.rail_speed_into_wind = noseAir.getValue(); + #printf("Rail: ac_fps=%d uBody_fps=%d", math.sqrt(me.speed_down_fps*me.speed_down_fps+math.pow(math.sqrt(me.speed_east_fps*me.speed_east_fps+me.speed_north_fps*me.speed_north_fps),2)), me.rail_speed_into_wind); + } + } elsif (!me.intoBore and me.eject_speed == 0) { + # to prevent the missile to appear falling up, we need to sometimes pitch it into wind: + #var t_spd = math.sqrt(me.speed_down_fps*me.speed_down_fps + h_spd*h_spd); + var wind_pitch = math.atan2(-me.speed_down_fps, me.speed_horizontal_fps) * R2D; + if (wind_pitch < me.msl_pitch) { + # super hack, and might temporary as missile leaves launch platform look stupid: + me.msl_pitch = wind_pitch; + # this should really take place over a duration instead of instantanious. + } + if (me.speed_horizontal_fps != 0) { + # will turn weapon into wind + # (not sure this is a good idea..might lose lock immediatly if firing with a big AoA, + # but then on other hand why would you do that, unless in dogfight, and there you use aim9 anyway, + # which is always on rails, and dont have this issue) + # + # what if heavy cross wind and fires level. Then it can fly maybe 10 degs offbore, and will likely lose its lock. + # + msl_hdg = geo.normdeg(math.atan2(me.speed_east_fps,me.speed_north_fps)*R2D); + } + } elsif (me.eject_speed != 0) { + # add ejector speed down from belly: + if (me.force_lbf_1 > 0 and me.stage_1_duration > 0) { + # for missiles + # + # So we cheat a bit and pretend the aircraft groundspeed is in its nose direction instead of into airstream. + # We do this cause the missile has no alpha/beta and when firing in hard turn alpha can easy be 15+ degs, + # so the missile would otherwise be pointed much further from target that the pilot intends. + me.aircraft_vec = me.myMath.eulerToCartesian3X(-OurHdg.getValue(),OurPitch.getValue(),OurRoll.getValue()); + me.aircraft_vec = me.myMath.normalize(me.aircraft_vec); + me.aircraft_fps = math.sqrt(math.pow(math.sqrt(math.pow(me.speed_north_fps,2)+math.pow(me.speed_east_fps,2)),2)+math.pow(me.speed_down_fps,2)); + me.aircraft_vec = me.myMath.product(me.aircraft_fps, me.aircraft_vec); + } else { + # for bombs + me.aircraft_vec = [me.speed_north_fps,-me.speed_east_fps,-me.speed_down_fps]; + } + me.eject_vec = me.myMath.normalize(me.myMath.eulerToCartesian3Z(-OurHdg.getValue(),OurPitch.getValue(),OurRoll.getValue())); + me.eject_vec = me.myMath.product(-me.eject_speed, me.eject_vec); + me.init_rel_vec = me.myMath.plus(me.aircraft_vec, me.eject_vec); + me.speed_down_fps = -me.init_rel_vec[2]; + me.speed_east_fps = -me.init_rel_vec[1]; + me.speed_north_fps = me.init_rel_vec[0]; + me.msl_hdg = geo.normdeg(math.atan2(me.speed_east_fps,me.speed_north_fps)*R2D); + me.msl_pitch = math.atan2(-me.speed_down_fps, math.sqrt(me.speed_east_fps*me.speed_east_fps+me.speed_north_fps*me.speed_north_fps))*R2D; + } + + me.alt_ft = malt; + me.pitch = me.msl_pitch; + me.hdg = me.msl_hdg; + + me.latN.setDoubleValue(mlat); + me.lonN.setDoubleValue(mlon); + me.altN.setDoubleValue(malt); + me.hdgN.setDoubleValue(me.msl_hdg); + me.pitchN.setDoubleValue(me.msl_pitch); + me.rollN.setDoubleValue(0); + + me.keepPitch = me.pitch; + + if (getprop("sim/flight-model") == "jsb") { + # currently not supported in Yasim + me.density_alt_diff = getprop("fdm/jsbsim/atmosphere/density-altitude") - me.ac.alt()*M2FT; + } + + # setup lofting and cruising + me.snapUp = me.loft_alt > 10000; + + me.SwSoundVol.setDoubleValue(0); + #me.trackWeak = 1; + if (use_fg_default_hud) { + settimer(func { HudReticleDeg.setValue(0) }, 2); + interpolate(HudReticleDev, 0, 2); + } + + me.startMach = getprop("velocities/mach"); + me.startFPS = getprop("velocities/groundspeed-kt")*KT2FPS; + me.startAlt = getprop("position/altitude-ft"); + me.startDist = -1; + me.maxAlt = me.startAlt; + if (me.Tgt != nil) { + me.startDist = me.ac_init.direct_distance_to(me.Tgt.get_Coord()); + } + me.printStats("Launch %s at %s.", me.type, me.callsign); + + me.weight_current = me.weight_launch_lbm; + me.mass = me.weight_launch_lbm * LBM2SLUGS; + + # find the fuel consumption - lbm/sec + var impulse1 = me.force_lbf_1 * me.stage_1_duration; # lbf*s + var impulse2 = me.force_lbf_2 * me.stage_2_duration; # lbf*s + var impulse3 = me.force_lbf_3 * me.stage_3_duration; # lbf*s + me.impulseT = impulse1 + impulse2 + impulse3; # lbf*s + me.fuel_per_impulse = me.weight_fuel_lbm / me.impulseT;# lbm/(lbf*s) + me.fuel_per_sec_1 = me.stage_1_duration == 0?0:(me.fuel_per_impulse * impulse1) / me.stage_1_duration;# lbm/s + me.fuel_per_sec_2 = me.stage_2_duration == 0?0:(me.fuel_per_impulse * impulse2) / me.stage_2_duration;# lbm/s + me.fuel_per_sec_3 = me.stage_3_duration == 0?0:(me.fuel_per_impulse * impulse3) / me.stage_3_duration;# lbm/s + + me.printExtendedStats(); + + + # find the sun: + var sun_x = getprop("ephemeris/sun/local/x"); + var sun_y = getprop("ephemeris/sun/local/y");# unit vector pointing to sun in geocentric coords + var sun_z = getprop("ephemeris/sun/local/z"); + if (sun_x != nil) { + me.sun_enabled = 1; + me.sun = geo.Coord.new(); + me.sun.set_xyz(me.ac_init.x()+sun_x*2000000, me.ac_init.y()+sun_y*2000000, me.ac_init.z()+sun_z*2000000);#heat seeking missiles don't fly far, so setting it 2000Km away is fine. + me.sun.alt();# TODO: once fixed in FG this line is no longer needed. + } else { + # old FG versions does not supply location of sun. So this feature gets disabled. + me.sun_enabled = 0; + } + + me.lock_on_sun = 0; + + loadNode.remove(); + + # lets run the main flight loop in its own thread: + var frameTrigger = func { + thread.semup(me.frameToggle); + } + me.frameLoop = maketimer(0, frameTrigger); + me.frameLoop.simulatedTime = 1;# Prevents paused sim from triggering update + me.frameLoop.start(); + spawn(me.flight, me)(); +# me.ai.getNode("valid").setBoolValue(1); is now done at end of first flight update. + }, + + ################################################## DO NOT EXTERNALLY CALL ANYTHING BELOW THIS LINE ################################### + + printExtendedStats: func { + if (!DEBUG_STATS) return; + + var classes = ""; + var classesSep = ""; + if (me.target_air) { + classes = classes~"Airborne"; + classesSep = ", "; + } + if (me.target_gnd) { + classes = classes~classesSep~"Ground"; + classesSep = ", "; + } + if (me.target_sea) { + classes = classes~classesSep~"Ship"; + classesSep = ", "; + } + if (me.target_pnt) { + classes = classes~classesSep~"TGP point"; + } + var cooling = me.coolable?"YES":"NO"; + var rea = me.reaquire?"YES":"NO"; + var asp = ""; + if (me.guidance=="heat") { + if (!me.all_aspect) { + asp = "Rear aspect only."; + } else { + asp = "All aspect."; + } + } + var nav = ""; + var nav2 = ""; + if (me.guidanceLaw == "LOS") { + nav = "Line-of-sight"; + } elsif (me.guidanceLaw == "direct") { + nav = "Pure pursuit."; + } elsif (me.guidanceLaw == "direct-alt") { + nav = "Pure pursuit with altitude hold."; + } elsif (me.guidanceLaw == "OPN") { + nav = "Original Proportional navigation. Proportionality constant is "~me.pro_constant; + } elsif (me.guidanceLaw == "PN") { + nav = "Proportional navigation. Proportionality constant is "~me.pro_constant; + } elsif (me.guidanceLaw == "APN") { + nav = "Augmented proportional navigation. Proportionality constant is "~me.pro_constant; + } elsif (me.guidanceLaw == "GPN") { + nav = "Augmented proportional navigation. Proportionality constant is "~me.pro_constant~" for lateral and "~(wingedGuideFactor*me.pro_constant)~" for longitudal"; + } elsif (left(me.guidanceLaw,2) == "PN") { + nav = "Proportional navigation. Proportionality constant is "~me.pro_constant; + var xxyy = right(me.guidanceLaw,4); + var yy = right(xxyy,2); + var xx = left(xxyy,2); + nav2 = sprintf("Before PN it will aim %d degrees above target for %d seconds.",xx,yy); + } elsif (left(me.guidanceLaw,3) == "APN") { + nav = "Augmented proportional navigation. Proportionality constant is "~me.pro_constant; + var xxyy = right(me.guidanceLaw,4); + var yy = right(xxyy,2); + var xx = left(xxyy,2); + nav2 = sprintf("Before APN it will aim %d degrees above target for %d seconds.",xx,yy); + } + var stages = 0; + if (me.force_lbf_1 > 0 and me.stage_1_duration > 0 and me.force_lbf_2 > 0 and me.stage_2_duration > 0 and me.force_lbf_3 > 0 and me.stage_3_duration > 0) { + stages = 3; + } elsif (me.force_lbf_1 > 0 and me.stage_1_duration > 0 and me.force_lbf_2 > 0 and me.stage_2_duration > 0) { + stages = 2; + } elsif (me.force_lbf_1 > 0 and me.stage_1_duration > 0) { + stages = 1; + } + var vector = "No vectored thrust."; + if (me.vector_thrust) { + vector = "Vectored thrust."; + } + + + me.printStats("****************************************************"); + me.printStats("Stats for %s", me.typeLong); + me.printStats("Damage ID is %d, notification ID is %d, unique ID is %d", me.typeID, me.typeID+21,me.unique_id); + me.printStats("DETECTION AND FIRING:"); + me.printStats("Fire range %.1f-%.1f NM", me.min_fire_range_nm, me.max_fire_range_nm); + if (me.expand_min) { + me.printStats("Min fire range will expand with closing rate."); + } + me.printStats("Can be fired againts %s targets", classes); + me.printStats("Pilot will call out %s when firing.",me.brevity); + me.printStats("Launch platform detection field of view is +-%d degrees.",me.fcs_fov); + if (me.guidance =="heat") { + me.printStats("Seekerhead beam width is %.1f degrees radius.",me.beam_width_deg); + } + me.printStats("Weapons takes %.1f seconds to get ready.",me.ready_time); + me.printStats("Cooling supported: %s",cooling); + if (me.coolable) { + me.printStats("Time to cool %.1f seconds. Can be kept cool for %d seconds.",me.cool_time,me.cool_duration); + me.printStats("Max detect range when warm is %.1f NM, when cold %.1f NM.",me.warm_detect_range_nm, me.cold_detect_range_nm); + me.printStats("Current temperature is %d%%, which means seeker detection range of %.1f NM.", me.warm*100, me.detect_range_curr_nm); + } + if (me.maddog) { + me.printStats("Has currently no lock on anything."); + } + if (me.loal) { + me.printStats("Lock on after launch supported if fired without lock."); + } else { + me.printStats("Lock on after launch disabled."); + } + if (me.canSwitch and me.reaquire) { + me.printStats("Can switch target mid-flight by itself. Number of targets to choose from: "~size(me.contacts)); + } else { + me.printStats("Will not switch target mid-flight by itself."); + } + if (me.loal or (me.canSwitch and me.reaquire)) { + me.printStats("Takes %.1f seconds to scan FoV, while flying, for new target.", me.switchTime); + } + if (me.radarOrigin) { + me.printStats("Radar in launch vehicle is located inside vehicle at origin."); + } else { + me.printStats("Radar in launch vehicle is located inside vehicle coord system at position %.2f,%.2f,%.2f meters.", me.radarX, me.radarY, me.radarZ); + } + if (me.noCommonTarget) { + me.printStats("This weapon can not use armament.contact as target, it must be set explicit [setContacts(contacts) or release(contacts)] instead."); + } + me.printStats("NAVIGATION AND GUIDANCE:"); + if (!me.guidanceEnabled) { + me.printStats("All guidance has been disabled, the weapon will not guide."); + } else { + me.printStats("Weapon field of view is +-%d degrees.",me.max_seeker_dev); + me.printStats("Is %s guided. %s",me.guidance,asp); + if (me.loal or (me.canSwitch and me.reaquire)) { + me.printStats("When looking for target it is navigating by %s.", me.standbyFlight); + } + me.printStats("Guidance law: %s",nav); + if (nav2 != "") { + me.printStats(nav2); + } + me.printStats("Will attempt to reaquire target if its lost: %s",rea); + if (me.guidance=="heat" or me.guidance=="vision") { + me.printStats("Seeker is able to track targets moving in its FoV at %.1f degrees per second.",me.angular_speed); + } + if (me.guidance=="heat") { + me.printStats("Seeker will lock on sun if it is within %.1f degrees.",me.sun_lock); + } + if (me.loft_alt>10000) { + me.printStats("Weapon will max snap up to %d feet altitude.",me.loft_alt); + } elsif (me.loft_alt<10000 and me.loft_alt!=0) { + if (me.target_sea) { + if (me.follow) { + me.printStats("Weapon will follow terrain keeping %d AGL feet.",me.loft_alt); + } else { + me.printStats("Weapon will sea skim at %d AGL feet.",me.loft_alt); + } + } else { + me.printStats("Weapon will follow terrain keeping %d AGL feet.",me.loft_alt); + } + } else { + me.printStats("Weapon will not snap up, follow terrain or sea skim."); + } + + me.printStats("After propulsion ends, it will max steer up to %d degree pitch.",me.maxPitch); + if(me.Tgt == nil) { + me.printStats("Note: Ordnance was released with no lock or destination target."); + } elsif (me.Tgt["getVirtualType"] != nil) { + me.printStats("Note: Ordnance was released locked on this target type: %s", me.Tgt.getVirtualType()); + } + me.printStats("Seekerheads ability to filter out background noise is %.2f, where 0 is perfect and 3 is not so good.", me.seeker_filter); + me.printStats("Exhaust plume will reduce drag by %d percent.", (1-me.Cd_plume)*100); + if (me.rosette_radius > 0) { + me.printStats("When uncaged and not tracking, seekerhead will do rosette pattern, with %.1f deg radius.", me.rosette_radius); + } else { + me.printStats("When uncaged and not tracking, seekerhead will not do anything useful."); + } + if (me.seam_support) { + me.printStats("The missile support manual cage/uncage and radar slaving, and possibly auto-uncaging."); + if (me.oldPattern) { + me.printStats("If nutation is enabled, the seekerhead will do a double-D pattern."); + } else { + me.printStats("If nutation is enabled, the seekerhead will do a circle pattern."); + } + } else { + me.printStats("The missile does not support manual cage/uncage or radar slaving."); + } + } + if (stages > 0) { + me.printStats("PROPULSION:"); + me.printStats("Stage 1: %d lbf for %.1f seconds. Is %s engine.", me.force_lbf_1, me.stage_1_duration, me.stage_1_jet?"jet":"rocket"); + if (stages > 1) { + me.printStats("Stage 2: %d lbf for %.1f seconds. Is %s engine.", me.force_lbf_2, me.stage_2_duration, me.stage_2_jet?"jet":"rocket"); + if (me.stage_gap_duration > 0) { + me.printStats("Stage 1 to 2 time gap: %.1f seconds.", me.stage_gap_duration); + } + if (stages > 2) { + me.printStats("Stage 3: %d lbf for %.1f seconds. Is %s engine.", me.force_lbf_3, me.stage_3_duration, me.stage_3_jet?"jet":"rocket"); + } + } + me.printStats("%s",vector); + if (!me.weight_fuel_lbm) { + me.printStats("Fuel system not simulated."); + } else { + me.printStats("Total fuel %d lbm.",me.weight_fuel_lbm); + me.printStats("Specific Impulse is %.2f (lbf*s)/lbm. Total impulse: %.2f lbf*s.", 1/me.fuel_per_impulse, me.impulseT); + # see how much energy/fuel the missile have. For solid fuel rockets, it is normally 200-280. Lower for smokeless, higher for smoke. + if (me.weight_fuel_lbm > me.weight_launch_lbm) { + me.printStats("ERROR: More fuel mass than entire weapon, please correct."); + } else { + me.printStats("Fuel is %.1f%% of weapons mass.", 100*me.weight_fuel_lbm/me.weight_launch_lbm); + } + if (1/me.fuel_per_impulse > 400) { + me.printStats("WARNING: If this is rocket engine, it has way too much thrust."); + } elsif (1/me.fuel_per_impulse > 350) { + me.printStats("WARNING: If this is rocket engine, it most likely has too much thrust per fuel."); + } elsif (1/me.fuel_per_impulse > 280) { + me.printStats("If this is rocket engine, it has a very high thrust."); + } elsif (1/me.fuel_per_impulse > 250) { + me.printStats("If this is rocket engine, it is probably not smokeless."); + } elsif (1/me.fuel_per_impulse > 200) { + me.printStats("If this is rocket engine, it is probably smokeless."); + } else { + me.printStats("WARNING: If this is rocket engine, it probably has too little thrust."); + } + } + if (!me.engineEnabled) { + me.printStats("Engine is disabled and will not start/ignite."); + } + } + + me.printStats("AERODYNAMICS:"); + me.printStats("Full weight is %d lbm.", me.weight_launch_lbm); + me.printStats("Drag coefficient is %.2f. Reference area is %.2f square feet.", me.Cd_base,me.ref_area_sqft); + me.printStats("Total drag-area is %.3f. Use this number to compare with other weapons for drag estimation.",me.Cd_base*me.ref_area_sqft); + me.printStats("Maximum structural g-force is %.1f",me.max_g); + me.printStats("Minimum speed for steering is %.1f mach.",me.min_speed_for_guiding); + me.printStats("Weapon will roll clockwise with %.1f degrees per second.", me.lateralSpeed); + me.printStats("WARHEAD:"); + me.printStats("Warhead total weight is %.1f lbm.",me.weight_whead_lbm); + me.printStats("Arming time is %.1f seconds.",me.arming_time); + me.printStats("Will selfdestruct after %d seconds.",me.selfdestruct_time); + if (me.multiHit) { + me.printStats("When detonating, will hit everything nearby. Number of contacts to consider: %d", size(me.contacts)); + } else { + me.printStats("When detonating, will only hit single target."); + } + if (me.destruct_when_free) { + me.printStats("Will selfdestruct if loses lock."); + } + me.printStats("Will explode if target range is increasing and within %d meters of target.",me.reportDist); + if (me.inert) { + me.printStats("Warhead is inert though and will not detonate."); + } + if (me.simple_drag) { + me.printStats("Simplified induced drag will be used to determine speed bleed due to G's"); + } else { + me.printStats("To determine speed bleed due to G's wing aspect ratio is %.1f and wing effeciancy is %.2f.",me.wing_aspect_ratio,me.wing_eff); + } + me.printStats("LAUNCH CONDITIONS:"); + if (me.rail) { + me.printStats("Weapon is fired from rail/tube of length %.1f meters.",me.rail_dist_m); + if (me.rail_forward) { + me.printStats("Launch direction is forward."); + } else { + me.printStats("Launch direction is %d degrees upward.", me.rail_pitch_deg); + me.printStats(" and %d degrees right.", me.rail_head_deg); + } + } else { + me.printStats("Weapon is dropped from launcher. Dropping for %.1f seconds.",me.drop_time);#todo + me.printStats("After drop it takes %.1f seconds to deploy wings.",me.deploy_time);#todo + if (me.guideWhileDrop) { + me.printStats("In drop it will already start guiding if speed is high enough."); + } + } + if (me.intoBore or me.eject_speed != 0) { + me.printStats("Weapon will be unaffected by airstream when released."); + } else { + me.printStats("Weapon will be turn into airstream when released."); + } + if (!me.rail and me.eject_speed != 0) { + me.printStats("Weapon will be ejected at %.1f feet/sec.",me.eject_speed); + } + if (me.guidance == "heat" or me.guidance == "radar" or me.guidance == "semi-radar" or me.guidance == "tvm") { + me.printStats("COUNTER-MEASURES:"); + if (me.guidance == "radar" or me.guidance == "semi-radar" or me.guidance == "tvm") { + me.printStats("Resistance to chaff is %d%%.",me.chaffResistance*100); + } elsif (me.guidance == "heat") { + me.printStats("Resistance to flares is %d%%.",me.flareResistance*100); + } + } + me.printStats("MISC:"); + if (me.data) { + me.printStats("Will transmit telemetry data back to launch platform."); + } else { + me.printStats("Has no data connection to launch platform when launched."); + } + if (me.dlz_enabled) { + me.printStats("Dynamic launch zone support enabled."); + me.printStats("Missile will likely hit when fired at max range when closing speed is %.2f mach at %d feet.", me.dlz_opt_mach, me.dlz_opt_alt); + } else { + me.printStats("Dynamic launch zone support disabled."); + } + me.printStats("****************************************************"); + }, + + setNewTargetInFlight: func (tagt) { + if (tagt == "closest") { + tagt = nil; + me.closest = 1000000; + if (me.Tgt != nil) { + foreach(me.test_tgt ; me.contacts) { + me.test_dist = me.Tgt.get_Coord().distance_to(me.test_tgt.get_Coord()); + if (me.test_dist < me.closest and me.checkForClassInFlight(me.test_tgt)) { + me.closest = me.test_dist; + tagt = me.test_tgt; + } + } + } + } + me.Tgt = tagt; + me.callsign = tagt==nil?"Unknown":damage.processCallsign(me.Tgt.get_Callsign()); + me.printStatsDetails("Target set to %s", me.callsign); + me.newTargetAssigned = tagt==nil?0:1; + me.t_coord = tagt==nil?nil:me.Tgt.get_Coord(); + me.fovLost = 0; + me.lostLOS = tagt==nil?1:0;# to do prowl flight something needs to be lost. + me.radLostLock = 0; + me.semiLostLock = 0; + me.heatLostLock = 0; + me.hasGuided = 0; + }, + + flight: func { + + while(1==1) { + if(me.deleted) { + return; + } + thread.semdown(me.frameToggle); + if(me.deleted) { + return; + } + ############################################################################################################# + # + # + # + # MAIN FLIGHT LOOP + # + # + # + ############################################################################################################# + me.counter += 1;#main counter for which number of loop we are in. + + if (me.pendingLaunchSound > -1 and me.life_time >= me.pendingLaunchSound and me.counter >= 5) { + # For some reason, sound needs some time to see that the property is false, so we let counter go to 5 before we set it to true. + me.launchSoundProp.setBoolValue(1); + me.pendingLaunchSound = -1; + } + + me.elapsed = systime(); + + me.dt = (me.elapsed - me.elapsed_last)*speedUp.getValue(); + me.elapsed_last = me.elapsed; + + if(me.dt <= 0 or me.dt > 0.4) { + # Negative can happen if OS adjust clock while we are flying. + # Large dt can happen when pausing the sim or with heavy stuttering. + continue;# back to while() loop and wait for semaphore up. + } + + me.life_time += me.dt; + + me.handleMidFlightFunc(); + + if (me.hasGuided and me.maddog) { + me.maddog = 0; + me.printStats("Maddog stage over, guided at "~me.callsign); + } + + if (me.guidanceEnabled and !me.free and !me.newTargetAssigned and (me.canSwitch or (me.loal and me.maddog)) and size(me.contacts) > 0 and (me.dist_curr_direct==-1 or me.dist_curr_direct>me.reportDist)) { + # me.reaquire must also be enabled for me.canSwitch to work + + if (me.Tgt==nil or !me.hasGuided or (me.canSwitch and (me.fovLost or me.lostLOS or me.radLostLock or me.semiLostLock or me.heatLostLock)) and me.life_time > me.nextFovCheck) { + # test next contact + me.numberContacts = size(me.contacts); + me.switchIndex += 1; + if (me.switchIndex >= me.numberContacts) { + me.switchIndex = 0; + me.nextFovCheck = me.nextFovCheck+me.switchTime; + } + me.newTgt = me.contacts[me.switchIndex]; + if (!me.newLock(me.newTgt)) { + me.Tgt = nil; + me.callsign = "Unknown"; + me.newTargetAssigned = 0; + } else { + me.setNewTargetInFlight(me.newTgt); + } + } + } + + if (me.prevGuidance != me.guidance) { + me.keepPitch = me.pitch; + } + if (me.Tgt != nil and !me.Tgt.isValid()) {#TODO: verify that the following threaded code can handle invalid contact. As its read from property-tree, not mutex protected. + if (!(me.canSwitch and me.reaquire)) { + me.printStats(me.type~": Target went away, deleting missile."); + #me.sendMessage(me.type~" missed "~me.callsign~": Target logged off."); + thread.lock(mutexTimer); + append(AIM.timerQueue, [me,me.del,[],0]); + append(AIM.timerQueue, [me,me.log,[me.callsign~" logged off. Deleting "~me.typeLong],0]); + thread.unlock(mutexTimer); + AIM.setETA(nil); + return; + } else { + me.Tgt = nil; + me.callsign = "Unknown"; + me.newTargetAssigned = 0; + } + } elsif (me.Tgt != nil and me.Tgt.get_type() == POINT and me.guidance == "laser" and me.usingTGPPoint and contactPoint == nil) { + # if laser illuminated lock is lost on a targetpod target: + if (!(me.canSwitch and me.reaquire)) { + me.Tgt = nil; + me.guidance = "unguided"; + me.printStats("Guidance switched to %s",me.guidance); + } else { + me.Tgt = nil; + me.callsign = "Unknown"; + me.newTargetAssigned = 0; + } + } elsif (me.Tgt == nil and me.guidance == "laser" and me.usingTGPPoint and contactPoint != nil) { + # see if we can regain lock on new laser spot: + if (me.newLock(contactPoint)) { + me.setNewTargetInFlight(contactPoint); + me.printStats("Laser lock switched to %s",me.callsign); + } else { + me.printStats("Laser spot ignored, could not lock on %s",me.settings.target.get_Callsign()); + } + } + + if (!me.rail) { + me.deploy = me.clamp(me.extrapolate(me.life_time, me.drop_time, me.drop_time+me.deploy_time,0,1),0,1); + } elsif (me.rail_passed_time == nil and me.rail_passed) { + me.rail_passed_time = me.life_time; + me.deploy = 0; + } elsif (me.rail_passed_time != nil) { + me.deploy = me.clamp(me.extrapolate(me.life_time, me.rail_passed_time, me.rail_passed_time+me.deploy_time,0,1),0,1); + } + me.deploy_prop.setDoubleValue(me.deploy); + + me.thrust_lbf = me.thrust();# pounds force (lbf) + + + # Jmav remove the # from the line below for cruise missile adjustment: + #me.printAlways("guiding=%d time=%d: mach=%.3f alt=%d %s",me.guiding, me.life_time, me.speed_m, me.alt_ft, me.observing); + + + # Get total old speed, thats what we will use in next loop. + me.old_speed_horz_fps = math.sqrt((me.speed_east_fps*me.speed_east_fps)+(me.speed_north_fps*me.speed_north_fps)); + me.old_speed_fps = math.sqrt((me.old_speed_horz_fps*me.old_speed_horz_fps)+(me.speed_down_fps*me.speed_down_fps)); + + me.setRadarProperties(me.old_speed_fps); + + + + # Get air density and speed of sound (fps): + me.rs = me.rho_sndspeed(me.altN.getValue() + me.density_alt_diff); + me.rho = me.rs[0]; + me.sound_fps = me.rs[1]; + + me.max_g_current = me.maxG(me.rho, me.max_g); + + me.speed_m = me.old_speed_fps / me.sound_fps; + + if (me.old_speed_fps > me.maxFPS) { + me.maxFPS = me.old_speed_fps; + } + if (me.speed_m > me.maxMach) { + me.maxMach = me.speed_m; + } + if (me.speed_m > me.maxMach1 and me.life_time > me.drop_time and me.life_time <= (me.drop_time + me.stage_1_duration)) { + me.maxMach1 = me.speed_m; + } + if (me.speed_m > me.maxMach2 and me.life_time > (me.drop_time + me.stage_1_duration) and me.life_time <= (me.drop_time + me.stage_1_duration + me.stage_gap_duration+me.stage_2_duration)) { + me.maxMach2 = me.speed_m; + } + if (me.speed_m > me.maxMach3 and me.life_time > (me.drop_time + me.stage_1_duration + me.stage_gap_duration + me.stage_2_duration) and me.life_time <= (me.drop_time + me.stage_1_duration + me.stage_gap_duration+me.stage_2_duration+me.stage_3_duration)) { + me.maxMach3 = me.speed_m; + } + if (me.maxMach4 == 0 and me.life_time > (me.drop_time + me.stage_1_duration + me.stage_gap_duration+me.stage_2_duration+me.stage_3_duration)) { + me.maxMach4 = me.speed_m; + } + + me.Cd = me.drag(me.speed_m,me.myG); + + me.speed_change_fps = me.speedChange(me.thrust_lbf, me.rho, me.Cd); + + + if (me.last_dt != 0) { + me.speed_change_fps = me.speed_change_fps + me.energyBleed(me.g, me.altN.getValue() + me.density_alt_diff); + } + + + + ################### + #### Guidance.##### + ################### + + if(me.speed_m < me.min_speed_for_guiding) { + # No guidance at low speed. + # Still go through the guidance loop for sensor logic (need to check flares, LOS, etc. + # to detect loss of lock), but the steering commands will be ignored. + if (!me.tooLowSpeed) { + me.printStats(me.type~": Not guiding (too low speed)"); + } + me.tooLowSpeed = 1; + } else { + me.tooLowSpeed = 0; + } + + if (me.guidance == "remote" or me.guidance == "remote-stable") { + me.printGuide("Remote control"); + if (me.guidance == "remote-stable") { + me.remoteControlStabilized(); + } else { + me.remoteControl(); + } + AIM.setETA(nil); + me.prevETA = nil; + } elsif (me.Tgt != nil and me.t_coord !=nil and !me.free and me.guidance != "unguided" + and (!me.rail or me.rail_passed) and me.guidanceEnabled) { + # + # Here we figure out how to guide, navigate and steer. + # + if (me.guidance == "level") { + me.level(); + AIM.setETA(nil); + me.prevETA = nil; + } elsif (me.guidance == "gyro-pitch") { + me.pitchGyro(); + AIM.setETA(nil); + me.prevETA = nil; + } else { + me.guide(); + if (!me.guiding) { + AIM.setETA(nil); + me.prevETA = nil; + } + } + me.observing = me.guidance; + } elsif (me.guidance != "unguided" and (!me.rail or me.rail_passed) and me.guidanceEnabled and !me.free and me.t_coord == nil + and (me.newTargetAssigned or (me.canSwitch and (me.fovLost or me.lostLOS or me.radLostLock or me.semiLostLock or me.heatLostLock) or (me.loal and me.maddog)))) { + # check for too low speed not performed on purpuse, difference between flying straight on A/P and making manouvres. + if (me.observing != me.standbyFlight) { + me.keepPitch = me.pitch; + } + me.printGuide("Prowling"); + if (me.standbyFlight == "level") { + me.level(); + } elsif (me.standbyFlight == "5") { + me.level5(); + } elsif (me.standbyFlight == "gyro-pitch") { + me.pitchGyro(); + } elsif (me.standbyFlight == "terrain-follow") { + me.terrainFollow(); + } else { + me.track_signal_e = 0; + me.track_signal_h = 0; + } + me.observing = me.standbyFlight; + AIM.setETA(nil); + me.prevETA = nil; + } else { + me.observing = "unguided"; + me.track_signal_e = 0; + me.track_signal_h = 0; + me.printGuide("Unguided"); + #me.printGuideDetails(sprintf("not guiding %d %d %d %d %d",me.Tgt != nil,me.free == 0,me.guidance != "unguided",me.rail == 0,me.rail_passed)); + AIM.setETA(nil); + me.prevETA = nil; + } + + if(me.tooLowSpeed) { + # Guidance disabled due to low speed. + me.track_signal_e = 0; + me.track_signal_h = 0; + } elsif (me.observing != "unguided") { + me.limitG(); + if (me.track_signal_e > 0 and me.pitch+me.track_signal_e > me.maxPitch and me.thrust_lbf==0) {# super hack + me.printGuideDetails("Prevented to pitch up to %.2f degs.", me.pitch+me.track_signal_e); + me.adjst = 1-(me.pitch+me.track_signal_e - me.maxPitch)/45; + if (me.adjst < 0) me.adjst = 0; + me.track_signal_e *= me.adjst; + } + me.pitch += me.track_signal_e; + me.hdg += me.track_signal_h; + me.pitch = math.max(-90, math.min(90, me.pitch)); + me.hdg = geo.normdeg(me.hdg); + me.printGuideDetails("%04.1f deg pitch command done, new pitch: %04.1f deg", me.track_signal_e, me.pitch); + me.printGuideDetails("%05.1f deg heading command done, new heading: %05.1f", me.last_track_h, me.hdg); + } + + me.last_track_e = me.track_signal_e; + me.last_track_h = me.track_signal_h; + + me.new_speed_fps = me.speed_change_fps + me.old_speed_fps; + if (me.new_speed_fps < 0) { + # drag and bleed can theoretically make the speed less than 0, this will prevent that from happening. + me.new_speed_fps = 0.001; + } + + # Break speed change down total speed to North, East and Down components. + me.speed_down_fps = -math.sin(me.pitch * D2R) * me.new_speed_fps; + me.speed_horizontal_fps = math.cos(me.pitch * D2R) * me.new_speed_fps; + me.speed_north_fps = math.cos(me.hdg * D2R) * me.speed_horizontal_fps; + me.speed_east_fps = math.sin(me.hdg * D2R) * me.speed_horizontal_fps; + me.speed_down_fps += g_fps * me.dt; + + if (me.rail and !me.rail_passed) { + # missile still on rail, lets calculate its speed relative to the wind coming in from the aircraft nose. + me.rail_speed_into_wind = me.rail_speed_into_wind + me.speed_change_fps; + } else { + # gravity acc makes the weapon pitch down + me.pitch = math.atan2(-me.speed_down_fps, me.speed_horizontal_fps ) * R2D; + } + + + if (me.rail and !me.rail_passed) { + me.u = noseAir.getValue();# airstream from nose + #var v = getprop("velocities/vBody-fps");# airstream from side + me.w = -belowAir.getValue();# airstream from below + me.opposing_wind = me.u*math.cos(me.rail_pitch_deg*D2R)+me.w*math.sin(me.rail_pitch_deg*D2R); + + if (me.rail_forward) { + me.pitch = OurPitch.getValue(); + me.hdg = OurHdg.getValue(); + } else { + me.railvec = me.myMath.eulerToCartesian3X(-me.rail_head_deg, me.rail_pitch_deg,0); + me.veccy = me.myMath.rollPitchYawVector(OurRoll.getValue(),OurPitch.getValue(),-OurHdg.getValue(),me.railvec); + me.carty = me.myMath.cartesianToEuler(me.veccy); + me.defaultHeading = me.Tgt != nil?me.Tgt.get_bearing():0;#90 deg tubes align to target heading, else north + me.pitch = me.carty[1]; + me.hdg = me.carty[0]==nil?me.defaultHeading:me.carty[0]; + } + + me.speed_on_rail = math.max(me.rail_speed_into_wind - me.opposing_wind, 0); + + me.movement_on_rail = me.speed_on_rail * me.dt; + + me.rail_pos = me.rail_pos + me.movement_on_rail; + if (me.rail_forward) { + me.x = me.x - (me.movement_on_rail * FT2M);# negative cause positive is rear in body coordinates + } else { + me.position_on_rail += math.max(0, me.movement_on_rail * FT2M);# only can move forward on rail. + me.railPos = me.myMath.alongVector(me.railBegin, me.railEnd, me.rail_dist_m, me.position_on_rail); + } + } + + if (!me.rail or me.rail_passed) { + # missile not on rail, lets move it to next waypoint + if (me.observing != "level" or me.speed_m < me.min_speed_for_guiding) { + me.alt_ft = me.alt_ft - (me.speed_down_fps * me.dt); + } + me.dist_h_m = me.speed_horizontal_fps * me.dt * FT2M; + #me.coord.apply_course_distance(me.hdg, me.dist_h_m); + me.great = greatCircleMove(me.coord, me.hdg, me.dist_h_m*M2NM); + me.coord.set_latlon(me.great.lat, me.great.lon, me.alt_ft * FT2M); + #me.coord.set_alt(me.alt_ft * FT2M); + } else { + # missile on rail, lets move it on the rail + if (me.rail_forward) { + var init_coord = nil; + if (offsetMethod) { + me.geodPos = aircraftToCart({x:-me.x, y:me.y, z: -me.z}); + me.coord.set_xyz(me.geodPos.x, me.geodPos.y, me.geodPos.z); + } else { + me.coord = me.getGPS(me.x, me.y, me.z, OurPitch.getValue()); + } + } else { + me.coord = me.getGPS(-me.railPos[0], -me.railPos[1], me.railPos[2], OurPitch.getValue(), OurHdg.getValue()); + } + me.alt_ft = me.coord.alt() * M2FT; + # find its speed, for used in calc old speed + me.speed_down_fps = -math.sin(me.pitch * D2R) * me.rail_speed_into_wind; + me.speed_horizontal_fps = math.cos(me.pitch * D2R) * me.rail_speed_into_wind; + me.speed_north_fps = math.cos(me.hdg * D2R) * me.speed_horizontal_fps; + me.speed_east_fps = math.sin(me.hdg * D2R) * me.speed_horizontal_fps; + #printf("Rail: ms_after_fps=%d ac_fps=%d", math.sqrt(me.speed_down_fps*me.speed_down_fps+math.pow(math.sqrt(me.speed_east_fps*me.speed_east_fps+me.speed_north_fps*me.speed_north_fps),2)),math.sqrt(getprop("velocities/speed-down-fps")*getprop("velocities/speed-down-fps")+math.pow(math.sqrt(getprop("velocities/speed-east-fps")*getprop("velocities/speed-east-fps")+getprop("velocities/speed-north-fps")*getprop("velocities/speed-north-fps")),2))); + } + if (me.alt_ft > me.maxAlt) { + me.maxAlt = me.alt_ft; + } + # Get target position. + if (me.Tgt != nil and me.t_coord != nil) { + if (!me.flareLock and !me.chaffLock) { + if (me.guidance != "gps" and (me.guidance != "gps-laser" or me.is_laser_painted(me.Tgt))) {# gps never updated inflight, gps-laser only when laser is online + me.t_coord = geo.Coord.new(me.Tgt.get_Coord());#in case multiple missiles use same Tgt we cannot rely on coords being different, so we extra create new. + } + if (me.t_coord == nil or !me.t_coord.is_defined()) { + # just to protect the multithreaded code for invalid pos. + print("Missile target has undefined coord!"); + me.Tgt = nil; + } else { + me.t_coord.alt();# TODO: once fixed in FG this line is no longer needed. + } + } else { + # we are chasing a flare, lets update the flares position. + if (me.flareLock) { + me.flarespeed_fps = me.flarespeed_fps - (25 * me.dt);#flare deacc. 15 kt per second. + } else { + me.flarespeed_fps = me.flarespeed_fps - (50 * me.dt);#chaff deacc. 30 kt per second. + } + if (me.flarespeed_fps < 0) { + me.flarespeed_fps = 0; + } + me.flare_speed_down_fps = -math.sin(me.flare_pitch * D2R) * me.flarespeed_fps; + me.flare_speed_horizontal_fps = math.cos(me.flare_pitch * D2R) * me.flarespeed_fps; + me.flare_alt_ft = me.t_coord.alt()*M2FT - (me.flare_speed_down_fps * me.dt); + me.flare_dist_h_m = me.flare_speed_horizontal_fps * me.dt * FT2M; + #me.t_coord.apply_course_distance(me.flare_hdg, me.flare_dist_h_m); + me.great = greatCircleMove(me.t_coord, me.flare_hdg, me.flare_dist_h_m*M2NM); + me.t_coord.set_latlon(me.great.lat, me.great.lon, me.flare_alt_ft * FT2M); + #me.t_coord.set_alt(me.flare_alt_ft * FT2M); + } + } + + # performance logging: + # + #var q = 0.5 * rho * me.old_speed_fps * me.old_speed_fps; + #setprop("logging/missile/dist-nm", me.ac_init.distance_to(me.coord)*M2NM); + #setprop("logging/missile/alt-m", me.alt_ft * FT2M); + #setprop("logging/missile/speed-m", me.speed_m*1000); + #setprop("logging/missile/drag-lbf", Cd * q * me.ref_area_sqft); + #setprop("logging/missile/thrust-lbf", thrust_lbf); + + me.setFirst(); + + me.printFlight("Pitch %.2f degs.", me.pitch); + + me.latN.setDoubleValue(me.coord.lat()); + me.lonN.setDoubleValue(me.coord.lon()); + me.altN.setDoubleValue(me.alt_ft); + if (!me.no_pitch or (me.rail and !me.rail_passed)) { + me.pitchN.setDoubleValue(me.pitch); + } else { + # for ejection seat + me.uprighter = me.pitchN.getValue(); + if (me.uprighter<89.92) { + me.uprighter += (90-me.uprighter)*me.dt*0.1; + } elsif (me.uprighter>90.08) { + me.uprighter -= (me.uprighter-90)*me.dt*0.1; + } else { + me.uprighter = 90.0; + } + me.pitchN.setDoubleValue(me.uprighter); + } + me.hdgN.setDoubleValue(me.hdg); + me.rollN.setDoubleValue(me.rollN.getValue()+me.lateralSpeed*me.dt); + + # log missiles to unicsv for visualizing flightpath in Google Earth + # + #setprop("/logging/missile/latitude-deg", me.coord.lat()); + #setprop("/logging/missile/longitude-deg", me.coord.lon()); + #setprop("/logging/missile/altitude-ft", alt_ft); + #setprop("/logging/missile/t-latitude-deg", me.t_coord.lat()); + #setprop("/logging/missile/t-longitude-deg", me.t_coord.lon()); + #setprop("/logging/missile/t-altitude-ft", me.t_coord.alt()*M2FT); + #setprop("/logging/missile/altitude-ft", me.alt_ft); + #setprop("/logging/missile/heading-deg", me.hdg); + #setprop("/logging/missile/pitch-deg", me.pitch); + + + if (me.tacview_support) { + if (tacview.starttime and math.mod(me.counter, 3) == 0) { + me.nme = me.type=="es"?"Parachutist":me.type; + me.extra = me.type=="es"?"|0|0|0":""; + thread.lock(tacview.mutexWrite); + tacview.write("#" ~ (systime() - tacview.starttime)~"\n"); + tacview.write(me.tacviewID~",T="~me.coord.lon()~"|"~me.coord.lat()~"|"~(me.alt_ft*FT2M)~me.extra~",Name="~me.nme~",Parent="~tacview.myplaneID~"\n");#,Type=Weapon+Missile + thread.unlock(tacview.mutexWrite); + } + } + + ############################## + #### Proximity detection.##### + ############################## + if (!me.rail or me.rail_passed) { + if ( !me.free ) { + me.g = me.steering_speed_G(me.hdg, me.pitch, me.track_signal_e, me.track_signal_h, me.old_speed_fps, me.dt); + } else { + me.g = 0; + } + + me.exploded = me.proximity_detection(); + + # + # check stats while flying: + # + me.printFlight("Mach %04.2f , time %05.1f s , thrust %05.1f lbf , G-force %05.2f", me.speed_m, me.life_time, me.thrust_lbf, me.g); + me.printFlight("Alt %07.1f ft , direct distance to target %04.1f NM", me.alt_ft, (me.Tgt!=nil and me.direct_dist_m!=nil)?me.direct_dist_m*M2NM:-1); + + if (me.exploded) { + me.printStats("%s max absolute %.2f Mach. Max relative %.2f Mach. Max alt %6d ft. Terminal %.2f mach.", me.type, me.maxMach, me.maxMach-me.startMach, me.maxAlt, me.speed_m); + me.printStats("%s max relative %d ft/s.", me.type, me.maxFPS-me.startFPS); + me.printStats(" Absolute %.2f Mach in stage 1.", me.maxMach1); + if (me.force_lbf_2 > 0) me.printStats(" Absolute %.2f Mach in stage 2.", me.maxMach2); + if (me.force_lbf_3 > 0) me.printStats(" Absolute %.2f Mach in stage 3.", me.maxMach3); + if (me.maxMach4 > 0) me.printStats(" Absolute %.2f mach propulsion end.", me.maxMach4); + me.printStats("%d seconds from launch to end", me.life_time); + me.printStats(" Fired at %s from %.2f Mach, %5d ft at %3d NM distance. Flew %.1f NM.", me.callsign, me.startMach, me.startAlt, me.startDist * M2NM, me.ac_init.direct_distance_to(me.coord)*M2NM); + # We exploded, and start the sound propagation towards the plane + me.sndSpeed = me.sound_fps; + me.sndDistance = 0; + me.elapsed_last_snd = systime(); + if (me.explodeSound) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [me,me.sndPropagate,[],0]); + thread.unlock(mutexTimer); + } else { + thread.lock(mutexTimer); + append(AIM.timerQueue, [me,me.del,[],10]); + thread.unlock(mutexTimer); + } + AIM.setETA(nil); + return; + } + } + + if (me.Tgt == nil and me.rail and me.rail_pitch_deg==90 and !me.rail_passed) { + #for ejection seat to be oriented correct, wont be ran for missiles with target such as the frigate. + + # model of seat is loaded such that face is pointing in -Z FG coords. + + # Get the vector pointing up from aircraft + var a = me.myMath.eulerToCartesian3Z(-OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + #printf("HPR: %0.4f %0.4f %0.4f",OurHdg.getValue(),OurPitch.getValue(),OurRoll.getValue()); + #printf(" UP: %0.4f %0.4f %0.4f",a[0],a[1],a[2]); + + # get the pitch and heading of that vector + var euler = me.myMath.cartesianToEuler(a); + me.pitch = euler[1]; + me.pitchN.setDoubleValue(me.pitch); + if (euler[0]!=nil) { + me.hdg = euler[0]; + } else { + # straight up or down + me.hdg = OurHdg.getValue(); + } + me.hdgN.setDoubleValue(me.hdg); + + # get vector pointing out from aircraft nose + var nose = me.myMath.eulerToCartesian3X(-OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + + # get vector pointing perpendicular to seat travel direction (most upward possible) + var face = me.myMath.eulerToCartesian3Z(-me.hdg, me.pitch, 0); + + # convert to angle pointing out from face if pilot turns head without nodding and looks downward + face = me.myMath.product(-1,face); + + # get angle between face and aircraft-nose vectors + var turnFace = me.myMath.angleBetweenVectors(face,nose); + + if (me.myMath.angleBetweenVectors(nose,me.myMath.product(-1,me.myMath.eulerToCartesian3Z(-me.hdg, me.pitch, turnFace)))>me.myMath.angleBetweenVectors(nose,me.myMath.product(-1,me.myMath.eulerToCartesian3Z(-me.hdg, me.pitch, -turnFace)))) { + # if angle between aircraft nose and the face of pilot is greater than the roll of seat then the roll should be opposite + #print("looking1 "~me.myMath.cartesianToEuler(me.myMath.product(-1,me.myMath.eulerToCartesian3Z(-me.hdg, me.pitch, turnFace)))[0]); + turnFace *= -1; + #print("turned face"); + } else { + #turnFace *= -1; + } + + # roll the seat so pilot faces forward + me.rollN.setDoubleValue(turnFace); + #print("looking2 "~me.myMath.cartesianToEuler(me.myMath.product(-1,me.myMath.eulerToCartesian3Z(-me.hdg, me.pitch, turnFace)))[0]); + #printf("seat now at P:%d H:%d R:%d",me.pitch, me.hdg, turnFace); + } + if (!me.rail_passed and (!me.rail or me.rail_pos > me.rail_dist_m * M2FT)) { + me.rail_passed = 1; + me.printFlight("rail passed"); + } + + + # consume fuel + if (me.life_time > (me.drop_time + me.stage_1_duration + me.stage_gap_duration+me.stage_2_duration+me.stage_3_duration)) { + me.weight_current = me.weight_launch_lbm - me.weight_fuel_lbm; + } elsif (me.life_time > (me.drop_time + me.stage_1_duration+me.stage_gap_duration + me.stage_2_duration)) { + me.weight_current = me.weight_current - me.fuel_per_sec_3 * me.dt; + } elsif (me.life_time > (me.drop_time + me.stage_1_duration+me.stage_gap_duration)) { + me.weight_current = me.weight_current - me.fuel_per_sec_2 * me.dt; + } elsif (me.life_time > me.drop_time and me.life_time < (me.drop_time + me.stage_1_duration)) { + me.weight_current = me.weight_current - me.fuel_per_sec_1 * me.dt; + } + + me.mass = me.weight_current * LBM2SLUGS; + + # telemetry + me.sendTelemetry(); + + if (me.life_time - me.last_noti > me.noti_time and getprop("payload/armament/msg")) { + # notify in flight using Emesary. + me.last_noti = me.life_time; + thread.lock(mutexTimer); + var rdr = me.guidance=="radar"; + var semiRdr = (me.guidance=="semi-radar" and !me.semiLostLock) or (me.guidance=="command" and me.guiding);# Continous wave illuminator active on the target + append(AIM.timerQueue, [AIM, AIM.notifyInFlight, [me.latN.getValue(), me.lonN.getValue(), me.altN.getValue()*FT2M,rdr,semiRdr,me.typeID,me.type,me.unique_id,me.thrust_lbf>0,(me.free or me.lostLOS or me.tooLowSpeed or me.flareLock or me.chaffLock)?"":me.callsign, me.hdg, me.pitch, me.new_speed_fps, 0], -1]); + thread.unlock(mutexTimer); + } + + me.last_dt = me.dt; + + me.prevGuidance = me.guidance; + + if (me.counter > -1 and !me.ai.getNode("valid").getBoolValue()) { + # TODO: Why is this placed so late? Don't remember. + me.ai.getNode("valid").setBoolValue(1); + thread.lock(mutexTimer); + append(AIM.timerQueue, [me, me.setModelAdded, [], -1]); + thread.unlock(mutexTimer); + } + ############################################################################################################# + # + # + # + # MAIN FLIGHT LOOP END + # + # + # + ############################################################################################################# + } + }, + + handleMidFlightFunc: func { + if(me.mfFunction != nil) { + + me.settings = me.mfFunction({ time_s: me.life_time, + dist_m: me.dist_curr_direct, + dist_horz_m: me.dist_curr, + mach: me.speed_m, + speed_fps: me.old_speed_fps, + weapon_position: me.coord, + guidance: me.guidance, + guidanceLaw: me.guidanceLaw, + seeker_detect_range: me.detect_range_curr_nm, + seeker_fov: me.max_seeker_dev, + weapon_pitch: me.pitch, + weapon_heading: me.hdg, + callsign: me.callsign, + deviation_deg: me["fov_radial"], + hasTarget: me["Tgt"] != nil, + }); + if (me.settings["guidance"] != nil) { + me.guidance = me.settings.guidance; + me.printStats("Guidance switched to %s",me.guidance); + me.printExtendedStats(); + } + if (me.settings["guidanceLaw"] != nil) { + me.guidanceLaw = me.settings.guidanceLaw; + me.printStats("Guidance law switched to %s", me.guidanceLaw); + } + if (me.settings["altitude"] != nil) { + if (me.loft_alt != me.settings.altitude) me.printStats("Loft altitude switched to %d", me.settings.altitude); + me.loft_alt = me.settings.altitude; + } + if (me.settings["altitude_at"] != nil) { + # Altitude above target + me.settings.altitude_at+=me.Tgt.get_altitude(); + if (me.loft_alt != me.settings.altitude_at) me.printStats("Loft altitude switched to %d", me.settings.altitude_at); + me.loft_alt = me.settings.altitude_at; + } + if (me.settings["class"] != nil) { + me.class = me.settings.class; + me.target_air = find("A", me.class)==-1?0:1; + me.target_sea = find("M", me.class)==-1?0:1; + me.target_gnd = find("G", me.class)==-1?0:1; + me.target_pnt = find("P", me.class)==-1?0:1; + me.printStats("Class switched to %s", me.class); + } + if (me.settings["target"] != nil) { + if (me.settings.target == "nil") { + me.setNewTargetInFlight(nil); + me.printStats("Target removed"); + } elsif (me.settings.target == "closest") { + me.setNewTargetInFlight("closest"); + me.printStats("Seeker finding closest target to the GPS"); + } elsif (me.newLock(me.settings.target)) { + me.setNewTargetInFlight(me.settings.target); + me.printStats("Target switched to %s",me.callsign); + } else { + me.printStats("Target switch ignored, could not lock on %s",me.settings.target.get_Callsign()); + } + } + if (contains(me.settings, "remote_yaw")) { + me.remote_control_yaw = me.settings.remote_yaw; + } else { + me.remote_control_yaw = 0; + } + if (contains(me.settings, "remote_pitch")) { + me.remote_control_pitch = me.settings.remote_pitch; + } else { + me.remote_control_pitch = 0; + } + if (me.settings["abort_midflight_function"] != nil) { + me.mfFunction = nil; + } + } + }, + + sendTelemetry: func { + if (me.data) { + + me.eta = me.free or me.vert_closing_rate_fps == -1?-1:(me["t_go"]!=nil?me.t_go:(me.dist_curr*M2FT)/me.vert_closing_rate_fps); + if (me.eta < 0) me.eta = -1; + me.hit = 50;# in percent + if (me.life_time > me.drop_time+me.stage_1_duration + me.gnd_launch?(me.stage_2_duration + me.stage_gap_duration):0) { + # little less optimistic after reaching topspeed + if (me.selfdestruct_time-me.life_time < me.eta) { + # reduce alot if eta later than lifespan + me.hit -= 75; + } elsif (me.eta != -1 and (me.selfdestruct_time-me.life_time) != 0) { + # if its hitting late in life, then reduce + me.hit -= (me.eta / (me.selfdestruct_time-me.life_time)) * 25; + } + if (me.eta > 0) { + # penalty if eta is high + me.hit -= me.clamp(40*me.eta/(me.life_time*0.85), 0, 40); + } + if (me.eta < 0) { + # penalty if eta is incomputable + me.hit -= 75; + } + } + if (me.curr_deviation_h != nil and me.dist_curr > 50) { + # penalty for target being off-bore + me.hit -= math.abs(me.curr_deviation_h)/2.5; + } + if (me.guiding and me.t_speed_fps != nil and me.old_speed_fps > me.t_speed_fps and me.t_speed_fps != 0) { + # bonus for traveling faster than target + me.hit += me.clamp((me.old_speed_fps / me.t_speed_fps)*15,-25,50); + } + if (me.free or (me.gnd_launch and (me.chaffLock or me.flareLock))) { + # penalty for not longer guiding + me.hit -= 75; + } + me.hit = int(me.clamp(me.hit, 0, 90)); + me.ai.getNode("ETA").setIntValue(me.eta); + me.ai.getNode("hit").setIntValue(me.hit); + + if (me.gnd_launch) { + setprop("sam/impact"~me.ID,me.eta); + setprop("sam/hit"~me.ID,me.hit); + } + + if (me["prevETA"] != nil) { + if (me.prevETA < me.eta) { + # reset the lowest eta to allow it to increase. + AIM.setETA(nil); + } + AIM.setETA(me.eta, me["prevETA"]); + } + me.prevETA = me["eta"]; + } + }, + + getGPS: func(x, y, z, pitch, head=nil, roll=nil) { + # + # get Coord from body position. x,y,z must be in meters. + # derived from Vivian's code in AIModel/submodel.cxx. + # + me.ac = geo.aircraft_position(); + + if(x == 0 and y==0 and z==0) { + return geo.Coord.new(me.ac); + } + if (roll == nil) { + me.ac_roll = OurRoll.getValue(); + } else { + me.ac_roll = roll; + } + me.ac_pitch = pitch; + + if (head == nil) { + me.ac_hdg = OurHdg.getValue(); + } else { + me.ac_hdg = head; + } + + me.in = [0,0,0]; + me.trans = [[0,0,0],[0,0,0],[0,0,0]]; + me.out = [0,0,0]; + + me.in[0] = -x * M2FT; + me.in[1] = y * M2FT; + me.in[2] = z * M2FT; + # Pre-process trig functions: + me.cosRx = math.cos(-me.ac_roll * D2R); + me.sinRx = math.sin(-me.ac_roll * D2R); + me.cosRy = math.cos(-me.ac_pitch * D2R); + me.sinRy = math.sin(-me.ac_pitch * D2R); + me.cosRz = math.cos(me.ac_hdg * D2R); + me.sinRz = math.sin(me.ac_hdg * D2R); + # Set up the transform matrix: + me.trans[0][0] = me.cosRy * me.cosRz; + me.trans[0][1] = -1 * me.cosRx * me.sinRz + me.sinRx * me.sinRy * me.cosRz ; + me.trans[0][2] = me.sinRx * me.sinRz + me.cosRx * me.sinRy * me.cosRz; + me.trans[1][0] = me.cosRy * me.sinRz; + me.trans[1][1] = me.cosRx * me.cosRz + me.sinRx * me.sinRy * me.sinRz; + me.trans[1][2] = -1 * me.sinRx * me.cosRx + me.cosRx * me.sinRy * me.sinRz; + me.trans[2][0] = -1 * me.sinRy; + me.trans[2][1] = me.sinRx * me.cosRy; + me.trans[2][2] = me.cosRx * me.cosRy; + # Multiply the input and transform matrices: + me.out[0] = me.in[0] * me.trans[0][0] + me.in[1] * me.trans[0][1] + me.in[2] * me.trans[0][2]; + me.out[1] = me.in[0] * me.trans[1][0] + me.in[1] * me.trans[1][1] + me.in[2] * me.trans[1][2]; + me.out[2] = me.in[0] * me.trans[2][0] + me.in[1] * me.trans[2][1] + me.in[2] * me.trans[2][2]; + # Convert ft to degrees of latitude: + me.out[0] = me.out[0] / (366468.96 - 3717.12 * math.cos(me.ac.lat() * D2R)); + # Convert ft to degrees of longitude: + me.out[1] = me.out[1] / (365228.16 * math.cos(me.ac.lat() * D2R)); + # Set submodel initial position: + me.mlat = me.ac.lat() + me.out[0]; + me.mlon = me.ac.lon() + me.out[1]; + me.malt = (me.ac.alt() * M2FT) + me.out[2]; + + me.c = geo.Coord.new(); + me.c.set_latlon(me.mlat, me.mlon, me.malt * FT2M); + + return me.c; + }, + + drag: func (mach, N=nil) { + # Nikolai V. Chr.: Made the drag calc more in line with big missiles as opposed to small bullets. + # + # The old equations were based on curves for a conventional shell/bullet (no boat-tail), + # and derived from Davic Culps code in AIBallistic. + me.Cd0 = 0; + if (mach < 0.7) { + me.Cd0 = (0.0125 * mach + 0.20) * 5 * (me.Cd_base+me.Cd_delta*me.deploy); + } elsif (mach < 1.2 ) { + me.Cd0 = (0.3742 * math.pow(mach, 2) - 0.252 * mach + 0.0021 + 0.2 ) * 5 * (me.Cd_base+me.Cd_delta*me.deploy); + } else { + if (1) {# me.simple_drag + # https://www.desmos.com/calculator/77tfavmskq + me.Cd0 = (0.2965 * math.pow(mach, -1.1506) + 0.2) * 5 * (me.Cd_base+me.Cd_delta*me.deploy); + } else { + # https://www.desmos.com/calculator/nfu1cla7su + me.Cd0 = (0.2965 * math.pow(mach, -2.1506) + 0.073766412) * 8 * (me.Cd_base+me.Cd_delta*me.deploy); + } + } + + if (!me.simple_drag) { + if (me.vector_thrust and me.thrust_lbf>0) N=N*0.35; + if (mach < 1.1) { + me.Cdi = (me.Cd_base+me.Cd_delta*me.deploy)*N;# N = normal force in G + } else { + me.FN = N * me.mass * g_fps;# FN = normal force in LBF (me.mass is in slugs) + me.CN = 2*me.FN/(me.rho*me.old_speed_fps*me.old_speed_fps*me.ref_area_sqft);# Normal coefficient formula + me.CL = me.CN*math.cos(me.myG*1.5*D2R)-me.Cd0*math.sin(1.5*me.myG*D2R);# Lift coefficient formula (works best if G is kept under 60degs) + me.Cdi = (me.CL*me.CL)/(math.pi*me.wing_eff*me.wing_aspect_ratio);#Induced drag formula + } + #me.printFlightDetails("At M%04.2f %04.1fG %06dft, Cdi is %06.1f%% of Cd0.", mach, N, me.alt_ft, 100*me.Cdi/me.Cd0); + + me.Cd0 = me["thrust_lbf"] != nil and me.thrust_lbf>0?me.Cd0*me.Cd_plume:me.Cd0; + } else { + me.Cdi = 0;# Cdi is done in another method + me.Cd0 = me["thrust_lbf"] != nil and me.thrust_lbf>0?me.Cd0*me.Cd_plume:me.Cd0 + } + + return me.Cd0+me.Cdi; + }, + + maxG: func (rho, max_g_sealevel) { + # Nikolai V. Chr.: A function to determine max G-force depending on air density. + # + # density for 0ft and 50kft: + #print("0:"~rho_sndspeed(0)[0]); = 0.0023769 + #print("50k:"~rho_sndspeed(50000)[0]); = 0.00036159 + # + # Fact: An aim-9j can do 22G at sealevel, 13G at 50Kft + # 13G = 22G * 0.5909 + # + # extra/inter-polation: + # f(x) = y1 + ((x - x1) / (x2 - x1)) * (y2 - y1) + # calculate its performance at current air density: + if (me.vector_thrust and me.thrust_lbf==0) max_g_sealevel=max_g_sealevel*0.666; + return me.clamp(max_g_sealevel+((rho-0.0023769)/(0.00036159-0.0023769))*(max_g_sealevel*0.5909-max_g_sealevel),0.25,100); + }, + + extrapolate: func (x, x1, x2, y1, y2) { + return y1 + ((x - x1) / (x2 - x1)) * (y2 - y1); + }, + + thrust: func () { + # Determine the thrust at this moment. + # + # If dropped, then ignited after fall time of what is the equivalent of 7ft. + # If the rocket is 2 stage, then ignite the second stage when 1st has burned out. + # + me.thrust_lbf = 0;# pounds force (lbf) + if (me.engineEnabled) { + if (me.life_time > (me.drop_time + me.stage_1_duration + me.stage_gap_duration + me.stage_2_duration + me.stage_3_duration)) { + me.thrust_lbf = 0; + } elsif (me.life_time > me.stage_1_duration + me.stage_gap_duration + me.drop_time + me.stage_2_duration) { + me.thrust_lbf = me.getMilThrust(me.force_lbf_3, 3); + } elsif (me.life_time > me.stage_1_duration + me.stage_gap_duration + me.drop_time) { + me.thrust_lbf = me.getMilThrust(me.force_lbf_2, 2); + } elsif (me.life_time > me.drop_time and me.life_time < me.drop_time+me.stage_1_duration) { + me.thrust_lbf = me.getMilThrust(me.force_lbf_1, 1); + }else { + me.thrust_lbf = 0; + } + } + + #me.force_cutoff_s = 0;# seen charts of real (aim9m) that thrust dont stop instantly, but fades out. This term would say hwo long it takes to fade out. Need to rework fuel consumption first. Maybe in future. + #if (me.life_time > (me.drop_time + me.stage_1_duration + me.stage_2_duration-me.force_cutoff_s) and me.life_time < (me.drop_time + me.stage_1_duration + me.stage_2_duration)) { + # me.thrust_lbf = me.extrapolate(me.life_time - (me.drop_time + me.stage_1_duration + me.stage_2_duration - me.force_cutoff_s),0,me.force_cutoff_s,me.thrust_lbf,0); + #} + + if (me.thrust_lbf < 1) { + me.smoke_prop.setBoolValue(0); + } else { + me.smoke_prop.setBoolValue(1); + } + return me.thrust_lbf; + }, + + getMilThrust: func (staticSealevel, stage) { + if (stage == 1 and !me.stage_1_jet) return staticSealevel;# Its a rocket engine + if (stage == 2 and !me.stage_2_jet) return staticSealevel; + if (stage == 3 and !me.stage_3_jet) return staticSealevel; + + # Its a jet engine: + me.staticLevel = staticSealevel*math.pow(me.jet_effectiveness,me.alt_ft/10000);# for every 10000 ft reduce by 75% + if (me.speed_m > 0.5) { + me.lvl = me.staticLevel*me.extrapolate(me.speed_m, 0.5, 1.5, 0.9, 1.5); + } elsif (me.speed_m > 0.2) { + me.lvl = me.staticLevel*0.9; + } else { + me.lvl = me.staticLevel*me.extrapolate(me.speed_m, 0.0, 0.2, 1, 0.9); + } + return me.lvl; + }, + + speedChange: func (thrust_lbf, rho, Cd) { + # Calculate speed change from last update. + # + # Acceleration = thrust/mass - drag/mass; + + me.acc = thrust_lbf / me.mass; + me.q = 0.5 * rho * me.old_speed_fps * me.old_speed_fps;# dynamic pressure + me.drag_acc = (Cd * me.q * me.ref_area_sqft) / me.mass; + + # get total new speed change (minus gravity) + return me.acc*me.dt - me.drag_acc*me.dt; + }, + + energyBleed: func (gForce, altitude) { + if (!me.simple_drag) return 0; + if (me.steer_for_free) gForce = 0; + # Bleed of energy from pulling Gs. + # This is very inaccurate, but better than nothing. + # + # First we get the speedloss due to normal drag: + me.b300 = me.bleed32800at0g(); + me.b000 = me.bleed0at0g(); + # + # We then subtract the normal drag from the loss due to G and normal drag. + me.b325 = me.bleed32800at25g()-me.b300; + me.b025 = me.bleed0at25g()-me.b000; + me.b300 = 0; + me.b000 = 0; + # + # We now find what the speedloss will be at sealevel and 32800 ft. + me.speedLoss32800 = me.b300 + ((gForce-0)/(25-0))*(me.b325 - me.b300); + me.speedLoss0 = me.b000 + ((gForce-0)/(25-0))*(me.b025 - me.b000); + # + # We then inter/extra-polate that to the currect density-altitude. + me.speedLoss = me.speedLoss0 + ((altitude-0)/(32800-0))*(me.speedLoss32800-me.speedLoss0); + # + # For good measure the result is clamped to below zero. + me.speedLoss = math.min(me.speedLoss, 0); + me.energyBleedKt += me.speedLoss * FPS2KT; + me.speedLoss = me.speedLoss*(me.thrust_lbf>0 and me.vector_thrust?0.333:1);# vector thrust will only bleed 1/3 of the calculated loss. + me.steer_for_free = 0; + return me.speedLoss; + }, + + bleed32800at0g: func () { + me.loss_mps = 0 + ((me.last_dt - 0)/(15 - 0))*(-330 - 0); + return me.loss_mps*M2FT; + }, + + bleed32800at25g: func () { + me.loss_mps = 0 + ((me.last_dt - 0)/(3.5 - 0))*(-240 - 0); + return me.loss_mps*M2FT; + }, + + bleed0at0g: func () { + me.loss_mps = 0 + ((me.last_dt - 0)/(22 - 0))*(-950 - 0); + return me.loss_mps*M2FT; + }, + + bleed0at25g: func () { + me.loss_mps = 0 + ((me.last_dt - 0)/(7 - 0))*(-750 - 0); + return me.loss_mps*M2FT; + }, + + setFirst: func() { + if (me.smoke_prop.getValue() == 1 and me.life_time < first_in_air_max_sec) { + if (me.first or !first_in_air) { + # report position over MP for MP animation of smoke trail. + me.first = 1; + first_in_air = 1; + if (me.mpShow) { + me.mpLat.setDoubleValue(me.coord.lat()); + me.mpLon.setDoubleValue(me.coord.lon()); + me.mpAlt.setDoubleValue(me.coord.alt()); + me.mpAltft.setDoubleValue(me.coord.alt()*M2FT); + } + } + } elsif (me.first and (me.life_time >= first_in_air_max_sec or me.life_time > me.drop_time + me.stage_1_duration + me.stage_gap_duration + me.stage_2_duration)) { + # this weapon was reporting its position over MP, but now its fuel has used up. So allow for another to do that. + me.resetFirst(); + } + }, + + resetFirst: func() { + first_in_air = 0; + me.first = 0; + if (me.mpShow) { + me.mpLat.setDoubleValue(0.0); + me.mpLon.setDoubleValue(0.0); + me.mpAlt.setDoubleValue(0.0); + me.mpAltft.setDoubleValue(0.0); + } + }, + + limitG: func () { + # + # Here will be set the max angle of pitch and the max angle of heading to avoid G overload + # + me.myG = me.steering_speed_G(me.hdg, me.pitch, me.track_signal_e, me.track_signal_h, me.old_speed_fps, me.dt); + + me.max_g_current_observing = me.limitHalfGs?me.max_g_current*0.5:me.max_g_current; + + if(me.myG > me.max_g_current_observing) + { + me.MyCoef = me.overload_limiter(me.hdg, me.pitch, me.track_signal_e, me.track_signal_h, me.old_speed_fps, me.dt, me.max_g_current_observing); + + me.track_signal_h = me.MyCoef[0]; + me.track_signal_e = me.MyCoef[1]; + + me.myGnew = me.steering_speed_G(me.hdg, me.pitch, me.track_signal_e, me.track_signal_h, me.old_speed_fps, me.dt); + #me.printFlight(sprintf("G2 %.2f", myG)~sprintf(" - Coeff %.2f", MyCoef)); + if (!me.limitGs) { + me.printFlight("%s: Missile pulling approx max G: %06.3f/%06.3f (%06.3f)", me.type, me.myGnew, me.max_g_current, me.myG); + } + me.myG = me.myGnew; + } + if (me.limitGs and me.myG > me.max_g_current/2) { + # Save the horiz high performance maneuvering for later + me.track_signal_e = me.track_signal_e /2; + } + }, + + setRadarProperties: func (new_speed_fps) { + # + # Set missile radar properties for use in selection view, radar and HUD. + # + me.self = geo.aircraft_position(); + me.ai.getNode("radar/bearing-deg", 1).setDoubleValue(me.self.course_to(me.coord)); + me.ai.getNode("radar/elevation-deg", 1).setDoubleValue(me.getPitch(me.self, me.coord)); + me.ai.getNode("radar/range-nm", 1).setDoubleValue(me.self.distance_to(me.coord)*M2NM); + me.ai.getNode("velocities/true-airspeed-kt",1).setDoubleValue(new_speed_fps * FPS2KT); + me.ai.getNode("velocities/vertical-speed-fps",1).setDoubleValue(-me.speed_down_fps); + }, + + rear_aspect: func (munition_coord, test_contact) { + # + # If is heat-seeking rear-aspect-only missile, check if it has good view on engine(s) and can keep lock. + # + me.offset = me.aspectToExhaust(munition_coord, test_contact); + + if (me.offset < 45) { + # clear view of engine heat, keep the lock + me.rearAspect = 1; + } else { + # the greater angle away from clear engine view the greater chance of losing lock. + me.offset_away = me.offset - 45; + me.probability = me.offset_away/135; + me.probability = me.probability*2.5;# The higher the factor, the less chance to keep lock. + me.rearAspect = rand() > me.probability; + } + + me.printGuideDetails("Heatseeker deviation from full rear-aspect: "~sprintf("%05.1f", me.offset)~" deg, keep IR lock on engine: "~me.rearAspect); + + return me.rearAspect;# 1: keep lock, 0: lose lock + }, + + aspectToExhaust: func (munition_coord, test_contact) { + # return angle to viewing rear of target + me.vectorToEcho = me.myMath.eulerToCartesian2(-munition_coord.course_to(test_contact.get_Coord()), me.myMath.getPitch(munition_coord, test_contact.get_Coord())); + me.vectorEchoNose = me.myMath.eulerToCartesian3X(-test_contact.get_heading(), test_contact.get_Pitch(), test_contact.get_Roll()); + me.angleToRear = geo.normdeg180(me.myMath.angleBetweenVectors(me.vectorToEcho, me.vectorEchoNose)); + #me.printGuideDetails(sprintf("Angle to rear %d degs.", math.abs(me.angleToRear)); + return math.abs(me.angleToRear); + }, + + aspectToTop: func () { + # WIP: not used, and might never be + me.vectorEchoTop = me.myMath.eulerToCartesian3Z(-echoHeading, echoPitch, echoRoll); + me.view2D = me.myMath.projVectorOnPlane(me.vectorEchoTop, me.vectorToEcho); + me.angleToNose = geo.normdeg180(me.myMath.angleBetweenVectors(me.vectorEchoNose, me.view2D)+180); + me.angleToBelly = geo.normdeg180(me.myMath.angleBetweenVectors(me.vectorEchoTop, me.vectorToEcho)); + }, + + guide: func() { + # + # navigation and guidance + # + + me.raw_steer_signal_elev = 0; + me.raw_steer_signal_head = 0; + + me.guiding = 1; + + if (me.guidance == "sample") { + me.blep = me.Tgt.getLastGroundTrackBlep(); + if (me.blep == nil and me.newTargetAssigned) { + # TODO: Do not remember what this is for + me.t_coord_sampled = me.t_coord; + } elsif (me.blep == nil) { + me.free = 1; + me.guiding = 0; + } elsif (me.blep.getID() != me["blepID"]) { + thread.lock(me.blep.mutex); + me.blepID = me.blep.getID(); + thread.unlock(me.blep.mutex); + me.blepIDtime = me.life_time; + me.t_coord_sampled = me.t_coord; + } elsif (me["blepIDtime"] != nil) { + me.dtTrack = me.life_time - me.blepIDtime; + thread.lock(me.blep.mutex); + me.ecefVel = me.blep.getECEFVelocity(); + me.blep_coord = geo.Coord.new(me.blep.getCoord()); + thread.unlock(me.blep.mutex); + me.t_coord_sampled = geo.Coord.new(); + + # dead-reckon: + me.t_coord_sampled.set_xyz(me.blep_coord.x()+me.ecefVel[0]*me.dtTrack, me.blep_coord.y()+me.ecefVel[1]*me.dtTrack, me.blep_coord.z()+me.ecefVel[2]*me.dtTrack); + me.t_coord_sampled.set_alt(me.blep_coord.alt());# we don't dead-reackon alt due to curvature of earth + } else { + me.free = 1; + me.guiding = 0; + } + } else { + me.t_coord_sampled = me.t_coord; + } + if (me["t_coord_sampled"] == nil) { + # Without this, t_coord_sampled can possibly be undefined in maddog mode. + me.t_coord_sampled = me.t_coord; + } + + # Calculate current target elevation and azimut deviation. + me.t_alt = me.t_coord_sampled.alt()*M2FT; + #var t_alt_delta_m = (me.t_alt - me.alt_ft) * FT2M; + me.dist_curr = me.coord.distance_to(me.t_coord_sampled); + me.dist_curr_direct = me.coord.direct_distance_to(me.t_coord_sampled); + me.dist_curr_hypo = math.sqrt(me.dist_curr_direct*me.dist_curr_direct+math.pow(me.t_coord_sampled.alt()-me.coord.alt(),2)); + me.t_elev_deg = me.getPitch(me.coord, me.t_coord_sampled); + me.t_course = me.coord.course_to(me.t_coord_sampled); + me.curr_deviation_e = me.t_elev_deg - me.pitch; + me.curr_deviation_h = me.t_course - me.hdg; + + #var (t_course, me.dist_curr) = courseAndDistance(me.coord, me.t_coord); + #me.dist_curr = me.dist_curr * NM2M; + + me.curr_deviation_h = geo.normdeg180(me.curr_deviation_h); + + me.printFlightDetails("Elevation to target %05.2f degs, pitch deviation %05.2f degs, pitch %05.2f degs", me.t_elev_deg, me.curr_deviation_e, me.pitch); + me.printFlightDetails("Bearing to target %06.2f degs, heading deviation %06.2f degs, heading %06.2f degs", me.t_course, me.curr_deviation_h, me.hdg); + me.printFlightDetails("Altitude above launch platform = %07.1f ft", M2FT * (me.coord.alt()-me.ac.alt())); + me.printFlightDetails("Altitude. Target %07.1f. Missile %07.1f. Atan2 %04.1f degs", me.t_coord_sampled.alt()*M2FT, me.coord.alt()*M2FT, math.atan2( me.t_coord_sampled.alt()-me.coord.alt(), me.dist_curr ) * R2D); + + + + if (math.abs(me.curr_deviation_h) < 15) { + me.guidanceLawHorizInit = 0; + } + + me.checkForLOS(); + + me.checkForGuidance(); + + me.checkForSun(); + + me.checkForFlare(); + + me.checkForChaff(); + + me.canSeekerKeepUp(); + + me.cruiseAndLoft(); + + me.APN();# Proportional navigation + + #me.adjustToKeepLock(); + + me.track_signal_e = me.raw_steer_signal_elev * !me.free * me.guiding; + me.track_signal_h = me.raw_steer_signal_head * !me.free * me.guiding; + + me.printGuideDetails("%04.1f deg elevate command desired", me.track_signal_e); + me.printGuideDetails("%05.1f deg heading command desired", me.track_signal_h); + + # record some variables for next loop: + me.dist_last = me.dist_curr; + me.dist_direct_last = me.dist_curr_direct; + me.dist_last_hypo = me.dist_curr_hypo; + me.last_t_course = me.t_course; + me.last_t_elev_deg = me.t_elev_deg; + me.last_cruise_or_loft = me.cruise_or_loft; + + if (!(me.fovLost or me.lostLOS or me.radLostLock or me.semiLostLock or me.heatLostLock)) { + # me.tooLowSpeed not included in check on purpose + me.hasGuided = 1; + } + me.newTargetAssigned=0; + }, + + checkForFlare: func () { + # + # Check for being fooled by flare. + # + if (me.Tgt != nil and me.fovLost != 1 and me.guidance == "heat" and !me.flareLock and (me.life_time-me.flareTime) > 1) { + # the fov check is for loal missiles that should not lock onto flares from aircraft not in view. + # + # TODO: Use Richards Emissary for this. + # + me.flareNode = me.Tgt.getFlareNode(); + if (me.flareNode != nil) { + me.flareNumber = me.flareNode.getValue(); + if (me.flareNumber != nil and me.flareNumber != 0) { + if (me.flareNumber != me.flareLast) { + # target has released a new flare, lets check if it fools us + me.flareTime = me.life_time; + me.flareLast = me.flareNumber; + me.aspectDeg = me.aspectToExhaust(me.coord, me.Tgt) / 180; + me.flareLock = rand() < (1-me.flareResistance + ((1-me.flareResistance) * 0.5 * me.aspectDeg));# 50% extra chance to be fooled if front aspect + if (me.flareLock) { + # fooled by the flare + me.printStats(me.type~": Missile locked on flare from "~me.callsign); + me.flarespeed_fps = me.Tgt.get_Speed()*KT2FPS; + me.flare_hdg = me.Tgt.get_heading(); + me.flare_pitch = me.Tgt.get_Pitch(); + } else { + me.printStats(me.type~": Missile ignored flare from "~me.callsign); + } + } + } + } + } + }, + + checkForChaff: func () { + # + # Check for being fooled by chaff. + # + if (me.Tgt != nil and me.fovLost != 1 and (me.guidance == "radar" or me.guidance == "semi-radar" or me.guidance == "command" or me.guidance == "tvm") and !me.chaffLock and (me.life_time-me.chaffTime) > 1) { + # + # TODO: Use Richards Emissary for this. + # + me.chaffNode = me.Tgt.getChaffNode();#error + if (me.chaffNode != nil) { + me.chaffNumber = me.chaffNode.getValue(); + if (me.chaffNumber != nil and me.chaffNumber != 0) { + if (me.chaffNumber != me.chaffLast) {# problem here is MP interpolates to new values. Hence the timer. + # target has released a new chaff, lets check if it blinds us + me.chaffLast = me.chaffNumber; + me.chaffTime = me.life_time; + me.aspectDeg = me.aspectToExhaust(me.coord, me.Tgt) / 180;# 0 = viewing engine, 1 = front + me.redux = me.guidance == "semi-radar" or me.guidance == "command" or me.guidance == "tvm"?(me.gnd_launch?0.5:0.75):1; + me.chaffChance = (1-me.chaffResistance)*me.redux; + me.chaffLock = rand() < (me.chaffChance - (me.chaffChance * 0.5 * me.aspectDeg));# 50% less chance to be fooled if front aspect + + if (me.chaffLock) { + me.printStats(me.type~": Missile locked on chaff from "~me.callsign); + me.flarespeed_fps = me.Tgt.get_Speed()*KT2FPS; + me.flare_hdg = me.Tgt.get_heading(); + me.flare_pitch = me.Tgt.get_Pitch(); + me.chaffLockTime = me.life_time; + } else { + me.printStats(me.type~": Missile ignored chaff from "~me.callsign); + } + } + } + } + } + }, + + checkForSun: func () { + if (me.fovLost != 1 and me.guidance == "heat" and me.sun_enabled and getprop("/rendering/scene/diffuse/red") > 0.6) { + # test for heat seeker locked on to sun + me.sun_dev_e = me.getPitch(me.coord, me.sun) - me.pitch; + me.sun_dev_h = me.coord.course_to(me.sun) - me.hdg; + me.sun_dev_h = geo.normdeg180(me.sun_dev_h); + # now we check if the sun is behind the target, which is the direction the gyro seeker is pointed at: + me.sun_dev = math.sqrt((me.sun_dev_e-me.curr_deviation_e)*(me.sun_dev_e-me.curr_deviation_e)+(me.sun_dev_h-me.curr_deviation_h)*(me.sun_dev_h-me.curr_deviation_h)); + if (me.sun_dev < me.sun_lock) { + me.printStats(me.type~": Locked onto sun, lost target. "); + me.lock_on_sun = 1; + me.free = 1; + } + } + }, + + checkForLOS: func () { + if (pickingMethod and me.guidance != "gps" and me.guidance != "gps-laser" and me.guidance != "unguided" and me.guidance != "inertial" and me.guidance != "sample") { + me.xyz = {"x":me.coord.x(), "y":me.coord.y(), "z":me.coord.z()}; + me.directionLOS = {"x":me.t_coord.x()-me.coord.x(), "y":me.t_coord.y()-me.coord.y(), "z":me.t_coord.z()-me.coord.z()}; + + # Check for terrain between own weapon and target: + me.terrainGeod = get_cart_ground_intersection(me.xyz, me.directionLOS); + if (me.terrainGeod == nil) { + me.lostLOS = 0; + return; + } else { + me.terrain = geo.Coord.new(); + me.terrain.set_latlon(me.terrainGeod.lat, me.terrainGeod.lon, me.terrainGeod.elevation); + me.maxDist = me.coord.direct_distance_to(me.t_coord)-1;#-1 is to avoid z-fighting distance + me.terrainDist = me.coord.direct_distance_to(me.terrain); + if (me.terrainDist >= me.maxDist) { + me.lostLOS = 0; + return; + } + } + if (me.reaquire) { + if (!me.lostLOS) { + me.printStats(me.type~": Not guiding (lost line of sight, trying to reaquire)"); + } + me.lostLOS = 1; + me.guiding = 0; + return; + } else { + if (!me.lostLOS) { + me.printStats(me.type~": Gave up (lost line of sight)"); + } + me.lostLOS = 1; + me.free = 1; + return; + } + } + me.lostLOS = 0; + }, + + checkForGuidance: func () { + if(me.tooLowSpeed) { + me.guiding = 0; + } elsif ((me.guidance == "semi-radar" and !me.is_painted(me.Tgt)) or (me.guidance =="laser" and !me.is_laser_painted(me.Tgt)) ) { + # if its semi-radar guided and the target is no longer painted + me.guiding = 0; + if (me.reaquire) { + if (!me.semiLostLock) { + me.printStats(me.type~": Not guiding (lost radar reflection, trying to reaquire)"); + } + me.semiLostLock = 1; + } else { + me.printStats(me.type~": Not guiding (lost radar reflection, gave up)"); + me.free = 1; + } + } elsif ((me.guidance == "command" or me.guidance == "tvm") and (me.Tgt == nil or !me.Tgt.isCommandActive())) { + # if its command or TVM guided and the control no longer sends commands + me.guiding = 0; + me.printStats(me.type~": Not guiding (no commands from controller)"); + } elsif (me.guidance == "radiation" and !me.is_radiating_me(me.Tgt)) { + # if its radiation guided and the target is not illuminating us with radiation + me.guiding = 0; + if (me.reaquire) { + if (!me.radLostLock) { + me.printStats(me.type~": Not guiding (lost radiation, trying to reaquire)"); + } + me.radLostLock = 1; + } else { + me.printStats(me.type~": Not guiding (lost radiation, gave up)"); + me.free = 1; + } + } elsif (me.guidance != "gps" and me.guidance != "gps-laser" and me.guidance != "inertial" and me.guidance != "sample" and (me.dist_curr_direct*M2NM > me.detect_range_curr_nm or !me.FOV_check(me.hdg, me.pitch, me.curr_deviation_h, me.curr_deviation_e, me.max_seeker_dev, me.myMath))) { + # target is not in missile seeker view anymore + + if (!me.fovLost and me.detect_range_curr_nm != 0) { + me.normFOV = me.FOV_check_norm(me.hdg, me.pitch, me.curr_deviation_h, me.curr_deviation_e, me.max_seeker_dev, me.myMath); + me.printStats(me.type~": "~me.callsign~" is not in seeker view. (%d%% in view, %d%% in range)", me.normFOV*100, 100*me.dist_curr_direct*M2NM / me.detect_range_curr_nm);#~me.viewLost); + } elsif (!me.fovLost) { + me.normFOV = me.FOV_check_norm(me.hdg, me.pitch, me.curr_deviation_h, me.curr_deviation_e, me.max_seeker_dev, me.myMath); + me.printStats(me.type~": "~me.callsign~" is not in seeker view. (%d%% in view)", me.normFOV*100);#~me.viewLost); + } + if (!me.reaquire) { + me.free = 1; + } else { + me.fovLost = 1; + me.guiding = 0; + } + } elsif (!me.all_aspect and !me.rear_aspect(me.coord, me.Tgt)) { + me.guiding = 0; + if (!me.heatLostLock) { + me.printStats(me.type~": Missile lost heat lock, attempting to reaquire.."); + } + me.heatLostLock = 1; + } elsif (me.life_time < me.drop_time and !me.guideWhileDrop) { + me.guiding = 0; + } elsif (me.semiLostLock) { + me.printStats(me.type~": Reaquired reflection."); + me.semiLostLock = 0; + } elsif (me.radLostLock) { + me.printStats(me.type~": Reaquired radiation."); + me.radLostLock = 0; + } elsif (me.heatLostLock) { + me.printStats(me.type~": Regained heat lock."); + me.heatLostLock = 0; + } elsif (me.tooLowSpeed) { + me.printStats(me.type~": Gained speed and started guiding."); + me.tooLowSpeed = 0; + } elsif (me.fovLost) { + me.printStats(me.type~": Regained view of target."); + me.fovLost = 0; + } elsif (me.loal and me.maddog) { + me.printStats(me.type~": "~me.callsign~" is potential target. ("~me.Tgt.get_type()~","~me.class~")"); + } + if (me.speed_m >= me.min_speed_for_guiding) { + me.tooLowSpeedPass = 1; + if (me.tooLowSpeedTime == -1) { + me.tooLowSpeedTime = me.life_time; + me.normFOV = me.FOV_check_norm(me.hdg, me.pitch, me.curr_deviation_h, me.curr_deviation_e, me.max_seeker_dev, me.myMath); + me.printStats(me.type~": Passed minimum speed for guiding after %.1f seconds. Target %d%% inside view.", me.life_time, me.normFOV*100); + } + } + if (me.chaffLock and (me.guidance == "command" or me.guidance == "semi-radar" or me.guidance == "tvm") and (me.life_time - me.chaffLockTime) > (me.gnd_launch?4:6)) { + me.chaffLock = 0; + me.printStats(me.type~": Chaff dissipated, regained track."); + } + }, + + adjustToKeepLock: func { + if (me.guidance != "gps" and me.guidance != "gps-laser" and me.guidance != "inertial" and me.guidance != "sample") { + if (!me.FOV_check(me.hdg, me.pitch, me.curr_deviation_h+me.raw_steer_signal_head, me.curr_deviation_e+me.raw_steer_signal_elev, me.max_seeker_dev, me.myMath) and me.fov_radial != 0) { + # the commanded steer order will make the missile lose its lock, to prevent that we reduce the steering just enough so lock wont be lost. + me.factorKeep = me.max_seeker_dev/me.fov_radial; + me.raw_steer_signal_elev = (me.curr_deviation_e+me.raw_steer_signal_elev)*me.factorKeep-me.curr_deviation_e; + me.raw_steer_signal_head = (me.curr_deviation_h+me.raw_steer_signal_head)*me.factorKeep-me.curr_deviation_h; + } + } + }, + + canSeekerKeepUp: func () { + me.globalVectorToTarget = me.myMath.eulerToCartesian3X(-me.t_course, me.t_elev_deg, 0); + me.localVectorTarget = me.myMath.yawPitchVector(me.hdg, -me.pitch, me.globalVectorToTarget); + if (me.counter == me.counter_last+1 and !me.newTargetAssigned and me["localVectorSeeker"] != nil and (me.guidance == "heat" or me.guidance == "vision") and me.prevGuidance == me.guidance and me.prevTarget == me.Tgt) { + # calculate if the seeker can keep up with the angular change of the target + # + # missile own movement is subtracted from this change due to seeker being on gyroscope + # + if (!me.caged) { + # Gyro is stabilized + me.localVectorSeeker = me.myMath.yawPitchVector(me.last_track_h, -me.last_track_e, me.localVectorSeeker); + } + me.angleSeekerToTarget = me.myMath.angleBetweenVectors(me.localVectorSeeker, me.localVectorTarget); + me.deviation_per_sec = me.angleSeekerToTarget/me.dt; + + if (me.deviation_per_sec > me.angular_speed) { + if (me.angleSeekerToTarget < me.beam_width_deg) { + me.max_seekertrack = me.angular_speed * me.dt; + me.localVectorSeeker = me.myMath.rotateVectorTowardsVector(me.localVectorSeeker, me.localVectorTarget, me.max_seekertrack); + me.printStatsDetails("%s: %4.1f deg/s too fast angular change for seeker head. %5.2fnm to target. Target still in beam though: %4.2f/%4.2f degs.", me.type, me.deviation_per_sec, me.dist_curr_direct*M2NM, me.angleSeekerToTarget-me.max_seekertrack, me.beam_width_deg); + } else { + # lost lock due to angular speed limit could not keep target in beam + me.printStats("%s: %4.1f deg/s too fast angular change for seeker head to keep target in beam. %5.2fnm to target.", me.type, me.deviation_per_sec, me.dist_curr_direct*M2NM); + me.free = 1; + } + } else { + me.localVectorSeeker = me.localVectorTarget; + me.printStatsDetails("%s: %4.1f deg/s fine angular change for seeker head. %5.2fnm to target.", me.type, me.deviation_per_sec, me.dist_curr_direct*M2NM); + } + } else { + me.localVectorSeeker = me.localVectorTarget; + } + me.prevTarget = me.Tgt; + me.counter_last = me.counter;# since we use dt as time passed since last we were in this function, we need to be sure only 1 loop has passed. + }, + + cruiseAndLoft: func () { + # + # cruise, loft, cruise-missile + # + if (!me.guiding) { + return; + } + me.loft_angle = 15;# notice Shinobi used 26.5651 degs, but Raider1 found a source saying 10-20 degs. + me.cruise_or_loft = 0;# If true then this method handles the vertical component of guiding. + me.time_before_snap_up = me.drop_time * 3; + me.limitGs = 0; + me.limitHalfGs = 0; + + if (me.loft_alt != 0 and me.guidanceLaw == "direct-alt") { + me.t_alt_delta_ft = me.loft_alt - me.alt_ft; + if(me.t_alt_delta_ft < 0) { + me.printGuide("Moving down %5d ft M%.3f %.2fNM %d",-me.t_alt_delta_ft, me.speed_m, me.dist_curr*M2NM,me.alt_ft); + me.slope = me.clamp(me.t_alt_delta_ft / 300, -30, 0);# the lower the desired alt is, the steeper the slope, but not steeper than 30 + me.raw_steer_signal_elev = -me.pitch + me.clamp(math.atan2(me.t_alt_delta_ft, me.old_speed_fps * 15) * R2D, me.slope, 0); + } elsif (me.speed_m > 0.6) { + me.printGuide("Moving up %5d ft M%.3f %.2fNM %d", me.t_alt_delta_ft, me.speed_m, me.dist_curr*M2NM,me.alt_ft); + me.raw_steer_signal_elev = -me.pitch + math.atan2(me.t_alt_delta_ft, me.old_speed_fps * 75) * R2D; + } else { + #me.raw_steer_signal_elev = 0; + me.printGuide(" no move M%.3f %.2fNM %d", me.speed_m, me.dist_curr*M2NM,me.alt_ft); + me.attitudePN = (math.atan2(-(me.speed_down_fps+g_fps * me.dt), me.speed_horizontal_fps ) - math.atan2(-me.speed_down_fps, me.speed_horizontal_fps )) * R2D; + me.gravComp = - me.attitudePN; + #printf("Gravity compensation %0.2f degs", me.gravComp); + me.raw_steer_signal_elev = me.gravComp; + me.steer_for_free = 1;#due to having wings + } + me.cruise_or_loft = 1; + me.limitHalfGs = 1; + } elsif(me.loft_alt != 0 and !me.snapUp) { + # this is for Air to ground/sea cruise-missile (SCALP, Sea-Eagle, Taurus, Tomahawk, RB-15...) + + var code = 1;# 0 = old, 1 = new, 2 = angle + + if (code == 2) {# angle code + me.terrainStage += 1;# only 1 terrain check in each stage. + if (me.terrainStage > 5) { + me.terrainStage = 0; + } + if (me.terrainStage == 0) { + # down + me.terrainUnder = geo.elevation(me.coord.lat(),me.coord.lon()); + } elsif (me.terrainStage == 1) { + # level + me.geoPlus = me.nextGeoloc(me.coord.lat(), me.coord.lon(), me.hdg, me.old_speed_fps, 5, me.coord.alt()); + + xyz = {"x":me.coord.x(), "y":me.coord.y(), "z":me.coord.z()}; + dir = {"x":me.geoPlus.x()-me.coord.x(), "y":me.geoPlus.y()-me.coord.y(), "z":me.geoPlus.z()-me.coord.z()}; + me.groundIntersectResult = get_cart_ground_intersection(xyz, dir); + if(me.groundIntersectResult == nil) { + me.terrainLevel = 1000000; + } else { + GroundIntersectCoord.set_latlon(me.groundIntersectResult.lat, me.groundIntersectResult.lon, me.groundIntersectResult.elevation); + me.terrainLevel = me.coord.direct_distance_to(me.groundIntersectCoord); + } + } elsif (me.terrainStage == 2) { + # negative angle + me.geoPlus = me.nextGeoloc(me.coord.lat(), me.coord.lon(), me.hdg, me.old_speed_fps, 5, me.coord.alt()); + + xyz = {"x":me.coord.x(), "y":me.coord.y(), "z":me.coord.z()}; + dir = {"x":me.geoPlus.x()-me.coord.x(), "y":me.geoPlus.y()-me.coord.y(), "z":me.geoPlus.z()-me.coord.z()}; + me.groundIntersectResult = get_cart_ground_intersection(xyz, dir); + if(me.groundIntersectResult == nil) { + me.terrainLevel = 1000000; + } else { + GroundIntersectCoord.set_latlon(me.groundIntersectResult.lat, me.groundIntersectResult.lon, me.groundIntersectResult.elevation); + me.terrainLevel = me.coord.direct_distance_to(me.groundIntersectCoord); + } + } + + } elsif (code == 1) {# Shinobi's new code + #Variable declaration + var No_terrain = 0; + var distance_Target = 0; + var xyz = nil; + var dir = nil; + var GroundIntersectCoord = geo.Coord.new(); + var howmany = 0; + var altitude_step = 30; + + # Do terrain following for air/ground missile (but not anti-ship), or if explicitly set with me.follow + if (me.follow or (me.Tgt != nil and (me.Tgt.get_type() == SURFACE or me.Tgt.get_type() == POINT))) { + # detect terrain for use in terrain following + me.nextGroundElevationMem[1] -= 1; + #First we need origin coordinates we transorfm it in xyz + xyz = {"x":me.coord.x(), "y":me.coord.y(), "z":me.coord.z()}; + + #Then we need the coordinate of the future point at let say 20 dt + me.geoPlus4 = me.nextGeoloc(me.coord.lat(), me.coord.lon(), me.hdg, me.old_speed_fps, 5); + me.geoAlt = geo.elevation(me.geoPlus4.lat(),me.geoPlus4.lon()); + if (me.geoAlt != nil) { + me.geoPlus4.set_alt(me.geoAlt); + } + + #Loop + while(No_terrain != 1){ + howmany = howmany + 1; + #We finalize the vector + dir = {"x":me.geoPlus4.x()-me.coord.x(), "y":me.geoPlus4.y()-me.coord.y(), "z":me.geoPlus4.z()-me.coord.z()}; + #We measure distance to be sure that the ground intersection is closer than geoPlus4 + distance_Target = me.coord.direct_distance_to(me.geoPlus4); + # Check for terrain between own aircraft and other: + GroundIntersectResult = get_cart_ground_intersection(xyz, dir); + if(GroundIntersectResult == nil){ + No_terrain = 1; + #Checking if the distance to the intersection is before or after geoPlus4 + }else{ + GroundIntersectCoord.set_latlon(GroundIntersectResult.lat, GroundIntersectResult.lon, GroundIntersectResult.elevation); + # Factor 0.95 to account for error in the two distance computations. + # Otherwise falso positive obstacle detection occurs. + if(me.coord.direct_distance_to(GroundIntersectCoord) > 0.95 * distance_Target){ + No_terrain = 1; + }else{ + #Raising geoPlus4 altitude by 100 meters + me.geoPlus4.set_alt(me.geoPlus4.alt()+altitude_step); + #print("Alt too low :" ~ me.geoPlus4.alt() ~ "; Raising alt by 30 meters (100 feet)"); + } + } + + } + me.printGuideDetails("There was : " ~ howmany ~ " iteration of the ground loop"); + me.nextGroundElevation = me.geoPlus4.alt(); + + me.Daground = me.nextGroundElevation * M2FT; + } else { + me.Daground = 0;# zero for sealevel in case target is ship. Don't shoot A/S missiles over terrain. :) + } + + me.loft_alt_curr = me.loft_alt; + if (me.Tgt != nil and me.dist_curr < me.old_speed_fps * me.terminal_rise_time * FT2M and me.dist_curr > me.old_speed_fps * me.terminal_dive_time * FT2M) { + # the missile lofts a bit at the end to avoid PN to slam it into ground before target is reached. + # end here is between 2.5-4 seconds + me.loft_alt_curr = me.loft_alt*me.terminal_alt_factor; + } + if (me.Tgt == nil or me.dist_curr > me.old_speed_fps * me.terminal_dive_time * FT2M) {# need to give the missile time to do final navigation + # Here we do the actual steering over terrain + me.t_alt_delta_ft = (me.loft_alt_curr + me.Daground - me.alt_ft); + me.printGuideDetails("var t_alt_delta_m : "~me.t_alt_delta_ft*FT2M); + if(me.loft_alt_curr + me.Daground > me.alt_ft) { + me.printGuideDetails("Moving up"); + me.raw_steer_signal_elev = -me.pitch + math.atan2(me.t_alt_delta_ft, me.old_speed_fps * me.dt * 5) * R2D; + } else { + me.printGuideDetails("Moving down"); + me.slope = me.clamp(me.t_alt_delta_ft / 300, -7.5, 0);# the lower the desired alt is, the steeper the slope, but not steeper than 7.5 + me.raw_steer_signal_elev = -me.pitch + me.clamp(math.atan2(me.t_alt_delta_ft, me.old_speed_fps * me.dt * 5) * R2D, me.slope, 0); + } + me.cruise_or_loft = 1; + } + if (me.cruise_or_loft) { + me.printGuideDetails(" pitch "~me.pitch~" + me.raw_steer_signal_elev "~me.raw_steer_signal_elev); + } + } else {#Older code + # detect terrain for use in terrain following + me.nextGroundElevationMem[1] -= 1; + me.geoPlus2 = me.nextGeoloc(me.coord.lat(), me.coord.lon(), me.hdg, me.old_speed_fps, me.dt*5); + me.geoPlus3 = me.nextGeoloc(me.coord.lat(), me.coord.lon(), me.hdg, me.old_speed_fps, me.dt*10); + me.geoPlus4 = me.nextGeoloc(me.coord.lat(), me.coord.lon(), me.hdg, me.old_speed_fps, me.dt*20); + me.e1 = geo.elevation(me.coord.lat(), me.coord.lon());# This is done, to make sure is does not decline before it has passed obstacle. + me.e2 = geo.elevation(me.geoPlus2.lat(), me.geoPlus2.lon());# This is the main one. + me.e3 = geo.elevation(me.geoPlus3.lat(), me.geoPlus3.lon());# This is an extra, just in case there is an high cliff it needs longer time to climb. + me.e4 = geo.elevation(me.geoPlus4.lat(), me.geoPlus4.lon()); + if (me.e1 != nil) { + me.nextGroundElevation = me.e1; + } else { + me.printFlight(me.type~": nil terrain, blame terrasync! Cruise-missile keeping altitude."); + } + if (me.e2 != nil and me.e2 > me.nextGroundElevation) { + me.nextGroundElevation = me.e2; + if (me.e2 > me.nextGroundElevationMem[0] or me.nextGroundElevationMem[1] < 0) { + me.nextGroundElevationMem[0] = me.e2; + me.nextGroundElevationMem[1] = 5; + } + } + if (me.nextGroundElevationMem[0] > me.nextGroundElevation) { + me.nextGroundElevation = me.nextGroundElevationMem[0]; + } + if (me.e3 != nil and me.e3 > me.nextGroundElevation) { + me.nextGroundElevation = me.e3; + } + if (me.e4 != nil and me.e4 > me.nextGroundElevation) { + me.nextGroundElevation = me.e4; + } + + me.Daground = 0;# zero for sealevel in case target is ship. Don't shoot A/S missiles over terrain. :) + if(me.Tgt.get_type() == SURFACE or me.follow) { + me.Daground = me.nextGroundElevation * M2FT; + } + me.loft_alt_curr = me.loft_alt; + if (me.dist_curr < me.old_speed_fps * me.terminal_rise_time * FT2M and me.dist_curr > me.old_speed_fps * me.terminal_dive_time * FT2M) { + # the missile lofts a bit at the end to avoid APN to slam it into ground before target is reached. + # end here is between 2.5-4 seconds + me.loft_alt_curr = me.loft_alt*me.terminal_alt_factor; + } + if (me.dist_curr > me.old_speed_fps * me.terminal_dive_time * FT2M) {# need to give the missile time to do final navigation + # it's 1 or 2 seconds for this kinds of missiles... + me.t_alt_delta_ft = (me.loft_alt_curr + me.Daground - me.alt_ft); + me.printGuideDetails("var t_alt_delta_m : "~me.t_alt_delta_ft*FT2M); + if(me.loft_alt_curr + me.Daground > me.alt_ft) { + # 200 is for a very short reaction to terrain + me.printGuideDetails("Moving up"); + me.raw_steer_signal_elev = -me.pitch + math.atan2(me.t_alt_delta_ft, me.old_speed_fps * me.dt * 5) * R2D; + } else { + # that means a dive angle of 22.5° (a bit less + # coz me.alt is in feet) (I let this alt in feet on purpose (more this figure is low, more the future pitch is high) + me.printGuideDetails("Moving down"); + me.slope = me.clamp(me.t_alt_delta_ft / 300, -7.5, 0);# the lower the desired alt is, the steeper the slope. + me.raw_steer_signal_elev = -me.pitch + me.clamp(math.atan2(me.t_alt_delta_ft, me.old_speed_fps * me.dt * 5) * R2D, me.slope, 0); + } + me.cruise_or_loft = 1; + } + if (me.cruise_or_loft) { + me.printGuideDetails(" pitch "~me.pitch~" + me.raw_steer_signal_elev "~me.raw_steer_signal_elev); + } + } + #} elsif (me.rail == 1 and me.rail_forward == 0 and me.rotate_token == 0) { + # tube launched missile turns towards target + + # me.raw_steer_signal_elev = me.curr_deviation_e; + # me.printGuideDetails("Turning, desire "~me.t_elev_deg~" degs pitch."); + # me.cruise_or_loft = 1; + # me.limitGs = 1; + # if (math.abs(me.curr_deviation_e) < 20) { + # me.rotate_token = 1; + # me.printGuide("Is last turn, snap-up/PN takes it from here..") + # } + } elsif (me.snapUp and me.t_elev_deg > me.clamp(-50/me.speed_m,-30,-5) and me.dist_curr * M2NM > me.speed_m * 6 + and me.t_elev_deg < me.loft_angle #and me.t_elev_deg > -7.5 + and !me.dive_token) { + # lofting: due to target is more than 10 miles out and we havent reached + # our desired cruising alt, and the elevation to target is less than lofting angle. + # The -7.5 limit, is so the seeker don't lose track of target when lofting. + if (me.life_time < me.time_before_snap_up and me.coord.alt() * M2FT < me.loft_alt) { + me.printGuide("preparing for lofting"); + me.cruise_or_loft = 1; + } elsif (me.coord.alt() * M2FT < me.loft_alt) { + me.raw_steer_signal_elev = -me.pitch + me.loft_angle; + me.limitGs = 1; + me.printGuide("Lofting %04.1f degs, dev is %04.1f", me.loft_angle, me.raw_steer_signal_elev); + } else { + me.dive_token = 1; + me.printGuide("Stopped lofting"); + } + me.cruise_or_loft = 1; + } elsif (me.snapUp and me.coord.alt() > me.t_coord.alt() and me.last_cruise_or_loft + and me.t_elev_deg > me.clamp(-50/me.speed_m,-30,-5) and me.dist_curr * M2NM > me.speed_m * 5.5) { + # cruising: keeping altitude since target is below and more than -45 degs down + + me.ratio = (g_fps * me.dt)/me.old_speed_fps; + me.attitude = 0; + + if (me.ratio < 1 and me.ratio > -1) { + me.attitude = math.asin(me.ratio)*R2D; + } + + me.raw_steer_signal_elev = -me.pitch + me.attitude; + me.printGuideDetails("Cruising, desire "~me.attitude~" degs pitch."); + me.cruise_or_loft = 1; + me.limitGs = 1; + me.dive_token = 1; + } elsif (me.last_cruise_or_loft and math.abs(me.curr_deviation_e) > 25 and me.life_time > me.time_before_snap_up) { + # after cruising, point the missile in the general direction of the target, before PN starts guiding. + me.printGuide("Rotating toward target"); + me.raw_steer_signal_elev = me.curr_deviation_e; + me.cruise_or_loft = 1; + #me.limitGs = 1; + + # TODO: this needs to be worked on. + } + }, + + level: func () { + me.attitudePN = math.atan2(-(me.speed_down_fps+g_fps * me.dt), me.speed_horizontal_fps ) * R2D; + me.gravComp = me.pitch - me.attitudePN; + #printf("Gravity compensation %0.2f degs", me.gravComp); + me.track_signal_e = me.gravComp * !me.free; + me.track_signal_h = 0; + me.printGuide("Trying to keep current %04.1f deg pitch.", me.pitch); + }, + + level5: func () { + me.track_signal_e = (5-me.pitch) * !me.free; + me.track_signal_h = 0; + me.printGuide("Gyro keeping %04.1f deg pitch. Current is %04.1f deg.", 5, me.pitch); + }, + + pitchGyro: func () { + me.track_signal_e = (me.keepPitch-me.pitch) * !me.free; + me.track_signal_h = 0; + me.printGuide("Gyro keeping %04.1f deg pitch. Current is %04.1f deg.", me.keepPitch, me.pitch); + }, + + # Terrain following as standby guidance mode. + terrainFollow: func () { + me.cruiseAndLoft(); + me.track_signal_e = me.raw_steer_signal_elev * !me.free; + me.track_signal_h = me.raw_steer_signal_head * !me.free; + }, + + remoteControl: func () { + me.track_signal_e = me.remote_control_pitch * me.dt * !me.free; + me.track_signal_h = me.remote_control_yaw * me.dt * !me.free; + me.printGuide("Remote input: %04.1f deg/s pitch, %04.1f deg/s yaw.", + me.remote_control_pitch, me.remote_control_yaw); + }, + + remoteControlStabilized: func () { + me.keepPitch += me.remote_control_pitch * me.dt; + me.track_signal_e = (me.keepPitch - me.pitch) * !me.free; + me.track_signal_h = me.remote_control_yaw * me.dt * !me.free; + me.printGuide("Remote input: %04.1f deg/s pitch, %04.1f deg/s yaw.", + me.remote_control_pitch, me.remote_control_yaw); + }, + + APN: func () { + # + # guidance laws + # + if (me.guiding and !me.free and me.dist_last != nil and me.last_dt != 0 and me.newTargetAssigned==0) { + # augmented proportional navigation for heading # + ################################################# + + if (me.guidanceLaw == "direct" or (me.guidanceLaw == "LOS" and me.life_time < 4)) { + # pure pursuit + me.raw_steer_signal_head = me.curr_deviation_h; + if (!me.cruise_or_loft) { + me.raw_steer_signal_elev = me.curr_deviation_e; + me.attitudePN = (math.atan2(-(me.speed_down_fps+g_fps * me.dt), me.speed_horizontal_fps ) - math.atan2(-me.speed_down_fps, me.speed_horizontal_fps )) * R2D; + me.gravComp = - me.attitudePN; + #printf("Gravity compensation %0.2f degs", me.gravComp); + me.raw_steer_signal_elev += me.gravComp; + } + return; + } elsif (find("OPN", me.guidanceLaw)!=-1) { + me.apn = -1; + me.gpn = 1; + } elsif (find("APN", me.guidanceLaw)!=-1) { + me.apn = 1; + me.gpn = 1; + } elsif (find("GPN", me.guidanceLaw)!=-1) { + me.apn = 1; + me.gpn = wingedGuideFactor; + } else { + me.apn = 0; + me.gpn = 1; + } + + if (me["noise"]==nil or me["last"] == nil) { + me.noise = 1; + me.last = 0; + me.next = 0.10; + me.seed = rand()*me.seeker_filter; + } + if (me.life_time > 6) { + me.noise = 1; + } elsif (me.seeker_filter > 0 and me.guidance != "gps" and me.guidance != "gps-laser" and me.life_time-me.last > me.next) { + # PN noise. + me.sign = me.seed>0.85?(rand()>0.75?-1:1):1; + me.opnNoiseReduct = me.apn == -1?0.5:1; + me.noise = (1+me.seeker_filter*me.opnNoiseReduct)*rand(); + me.noise = me.sign*(me.noise + 1); # the noise factor + me.last = me.life_time; + me.next = me.seeker_filter*0.15*rand();# duration for this noise factor, till a new is computed. + } + + me.horz_closing_rate_fps = ((me.dist_last - me.dist_curr)*M2FT)/me.dt+me.horz_closing_rate_fps;#clamped due to cruise missiles that can fly slower than target. + me.horz_closing_rate_fps *= 0.5;# average over 2 frames + me.printGuideDetails("Horz closing rate: %05d ft/sec", me.horz_closing_rate_fps); + me.vert_closing_rate_fps = ((me.dist_direct_last - me.dist_curr_direct)*M2FT)/me.dt+me.vert_closing_rate_fps; + me.vert_closing_rate_fps *= 0.5; + me.printGuideDetails("Vert closing rate: %05d ft/sec", me.vert_closing_rate_fps); + # Note: Since PN will steer opposite at negative closing rate, we will later use only the absolute magnitudes. + # This is especially important before we really gain speed against a receding fast target. + + me.course_deviation = geo.normdeg180(me.t_course-me.last_t_course); + + me.line_of_sight_rate_rps = (D2R*me.course_deviation)/me.dt;#positive clockwise + + me.printGuideDetails("LOS rate: %06.4f rad/s", me.line_of_sight_rate_rps); + + me.t_velocity = me.myMath.getCartesianVelocity(-me.Tgt.get_heading(), me.Tgt.get_Pitch(), me.Tgt.get_Roll(), me.Tgt.get_uBody(), me.Tgt.get_vBody(), me.Tgt.get_wBody()); + + if ((!me.flareLock and !me.chaffLock) or me.t_heading == nil) { + me.euler = me.myMath.cartesianToEuler(me.t_velocity); + if (me.euler[0] != nil) { + me.t_heading = me.euler[0]; + } else { + me.t_heading = me.Tgt.get_heading(); + } + me.t_pitch = me.euler[1]; + me.t_speed_fps = me.myMath.magnitudeVector(me.t_velocity);#groundspeed + } elsif (me.flarespeed_fps != nil) { + me.t_speed_fps = me.flarespeed_fps;#true airspeed + } + + me.t_horz_speed_fps = math.sqrt(me.t_velocity[0]*me.t_velocity[0]+me.t_velocity[1]*me.t_velocity[1]); + me.t_LOS_norm_head_deg = me.t_course + 90;#when looking at target this direction will be 90 deg right of target + me.t_LOS_norm_speed_fps = math.cos((me.t_LOS_norm_head_deg - me.t_heading)*D2R)*me.t_horz_speed_fps; + + if (me.last_t_norm_speed == nil) { + me.last_t_norm_speed = me.t_LOS_norm_speed_fps; + } + + me.t_LOS_norm_acc_fps2 = (me.t_LOS_norm_speed_fps - me.last_t_norm_speed)/me.dt; + + me.last_t_norm_speed = me.t_LOS_norm_speed_fps; + + # time to go calc + me.t_away_norm_speed_fps = math.cos((me.t_course - me.t_heading)*D2R)*me.t_horz_speed_fps; + me.t_speed_vert_fps = me.t_velocity[2]; + me.m_speed_vert_fps = math.sin(me.pitch*D2R)*me.old_speed_horz_fps; + me.t_pos_z = (me.t_coord.alt()-me.coord.alt())*M2FT; + me.Vt = [me.t_away_norm_speed_fps,me.t_LOS_norm_speed_fps,me.t_speed_vert_fps]; + me.Vm = [me.old_speed_horz_fps,0,me.m_speed_vert_fps]; + me.Pm = [0,0,0]; + me.Pt = [me.dist_curr*M2FT,0,me.t_pos_z]; + me.V_tm = me.myMath.minus(me.Vt,me.Vm); + me.R_tm = me.myMath.minus(me.Pm,me.Pt); + me.t_go = me.myMath.dotProduct(me.R_tm,me.R_tm)/me.myMath.dotProduct(me.R_tm, me.V_tm); + #printf("time_to_go %.1f, closing %d",me.t_go,me.vert_closing_rate_fps); + + + + # Horizontal homing: + if (me.guidanceLaw == "LOS") { + + me.K1 = 2.5; + me.K2 = 10.0; + + me.R_m = me.ac_init.distance_to(me.coord)*M2FT; + me.course_to_missile = me.ac_init.course_to(me.coord); + me.course_to_target = me.ac_init.course_to(me.t_coord); + me.CREh_old_old = me.CREh_old; + me.CREh_old = me.CREh; + # cross range error: + me.CREh = me.R_m*math.sin(me.clamp(geo.normdeg180(me.course_to_target - me.course_to_missile),-89,89)*D2R); + me.CREh_dot = (me.CREh - me.CREh_old_old)/(me.dt+me.CRE_old_dt); + me.acc_lateral_fps2 = me.K1*me.CREh_dot + me.K2*me.CREh; + me.toBody = math.cos(geo.normdeg180(me.hdg-me.course_to_target)*D2R); + if (me.toBody==0) me.toBody=0.0001; + me.acc_lateral_fps2 /= me.toBody; + me.velocity_vector_length_fps = me.clamp(me.old_speed_horz_fps, 0.0001, 1000000); + me.commanded_lateral_vector_length_fps = me.acc_lateral_fps2*me.dt; + me.raw_steer_signal_head = R2D*me.commanded_lateral_vector_length_fps/me.velocity_vector_length_fps; + #me.raw_steer_signal_head = me.curr_deviation_h; + } elsif (me.apn == 1) { + # APN (constant best at 5, but the higher value the more sensitive to noise) + # Augmented proportional navigation. Takes target acc. into account. Invented for SAMs. + me.toBody = math.cos(me.curr_deviation_h*D2R);#convert perpendicular LOS acc. to perpendicular body acc. + if (me.toBody==0) me.toBody=0.00001; + # acceleration perpendicular to instantaneous line of sight in feet/sec^2: + me.acc_lateral_fps2 = me.pro_constant*me.line_of_sight_rate_rps*math.abs(me.horz_closing_rate_fps)+me.t_LOS_norm_acc_fps2*me.noise;# in some litterature the second pro_constant is replaced by t_go, but that will make the missile overcompensate. + me.acc_lateral_fps2 /= me.toBody; + #printf("vert acc = %.2f + %.2f G", me.pro_constant*me.line_of_sight_rate_up_rps*me.vert_closing_rate_fps/g_fps, (me.apn*me.pro_constant*me.t_LOS_elev_norm_acc/2)/g_fps); + me.velocity_vector_length_fps = me.clamp(me.old_speed_horz_fps, 0.0001, 1000000); + me.commanded_lateral_vector_length_fps = me.acc_lateral_fps2*me.dt; + me.raw_steer_signal_head = R2D*me.commanded_lateral_vector_length_fps/me.velocity_vector_length_fps; + } elsif (me.apn == 0) { + # PN (constant best at 3) + # Generalized Proportional navigation. + me.toBody = math.cos(me.curr_deviation_h*D2R);#convert perpendicular LOS acc. to perpendicular body acc. + if (me.toBody==0) me.toBody=0.00001; + me.acc_lateral_fps2 = me.pro_constant*me.line_of_sight_rate_rps*math.abs(me.horz_closing_rate_fps)*me.noise; + me.acc_lateral_fps2 /= me.toBody; + me.velocity_vector_length_fps = me.clamp(me.old_speed_horz_fps, 0.0001, 1000000); + me.commanded_lateral_vector_length_fps = me.acc_lateral_fps2*me.dt; + me.raw_steer_signal_head = R2D*me.commanded_lateral_vector_length_fps/me.velocity_vector_length_fps; + } else { + # PN [invented during WWII by Luke Chia‐Liu Yuan] + # Original Proportional navigation. + # Rearranging the equations gives Pure proportional navigation, which show that this law + # does not take missile alpha into account, and is therefore not very good in real life. + me.radians_lateral_per_sec = me.pro_constant*me.line_of_sight_rate_rps*me.noise; + me.raw_steer_signal_head = me.dt*me.radians_lateral_per_sec*R2D; + } + #printf("horz acc = %.1f + %.1f", proportionality_constant*line_of_sight_rate_rps*horz_closing_rate_fps, proportionality_constant*t_LOS_norm_acc/2); + + if (me.guidanceLawHorizInit) { + # pure horiz pursuit + me.raw_steer_signal_head = me.curr_deviation_h; + } + + # now translate that sideways acc to an angle: + + + + #printf("Proportional lead: %0.1f deg horz", -(me.curr_deviation_h-me.raw_steer_signal_head)); + + #me.print(sprintf("LOS-rate=%.2f rad/s - closing-rate=%.1f ft/s",line_of_sight_rate_rps,horz_closing_rate_fps)); + #me.print(sprintf("commanded-perpendicular-acceleration=%.1f ft/s^2", acc_lateral_fps2)); + #printf("horz leading by %.1f deg, commanding %.1f deg", me.curr_deviation_h, me.raw_steer_signal_head); + + if (!me.cruise_or_loft) { + me.fixed_aim = nil; + me.fixed_aim_time = nil; + if (find("PN",me.guidanceLaw) != -1 and size(me.guidanceLaw) > 3) { + me.extra = right(me.guidanceLaw, 4); + me.fixed_aim = num(left(me.extra, 2)); + me.fixed_aim_time = num(right(me.extra, 2)); + } + if (me.fixed_aim != nil and me.life_time < me.fixed_aim_time) { + me.raw_steer_signal_elev = me.curr_deviation_e+me.fixed_aim; + me.attitudePN = (math.atan2(-(me.speed_down_fps+g_fps * me.dt), me.speed_horizontal_fps ) - math.atan2(-me.speed_down_fps, me.speed_horizontal_fps )) * R2D; + me.gravComp = - me.attitudePN; + #printf("Gravity compensation %0.2f degs", me.gravComp); + me.raw_steer_signal_elev += me.gravComp; + } else { + # proportional navigation for elevation # + ######################################### + #me.print(me.guidanceLaw~" in fully control"); + + me.line_of_sight_rate_up_rps = (D2R*(me.t_elev_deg-me.last_t_elev_deg))/me.dt; + + # calculate target acc as normal to LOS line: (up acc is positive) + me.t_approach_bearing = me.t_course + 180; + + + # used to do this with trigonometry, but vector math is simpler to understand: (they give same result though) + me.t_LOS_elev_norm_speed = me.scalarProj(me.t_heading,me.t_pitch,me.t_speed_fps,me.t_approach_bearing,me.t_elev_deg*-1 +90); + + if (me.last_t_elev_norm_speed == nil) { + me.last_t_elev_norm_speed = me.t_LOS_elev_norm_speed; + } + + + me.t_LOS_elev_norm_acc = (me.t_LOS_elev_norm_speed - me.last_t_elev_norm_speed)/me.dt; + me.last_t_elev_norm_speed = me.t_LOS_elev_norm_speed; + #printf("Target acc. perpendicular to LOS (positive up): %.1f G.", me.t_LOS_elev_norm_acc/g_fps); + + # Vertical homing: + if (me.guidanceLaw == "LOS") { + me.R_m = me.ac_init.direct_distance_to(me.coord)*M2FT; + me.pitch_to_missile = me.myMath.getPitch(me.ac_init,me.coord); + me.pitch_to_target = me.myMath.getPitch(me.ac_init,me.t_coord); + me.CREv_old_old = me.CREv_old; + me.CREv_old = me.CREv; + # Cross range error + me.CREv = me.R_m*math.sin((me.pitch_to_target - me.pitch_to_missile)*D2R); + me.CREv_dot = (me.CREv - me.CREv_old_old)/(me.dt+me.CRE_old_dt); + me.acc_upwards_fps2 = me.K1*me.CREv_dot + me.K2*me.CREv; + # Convert perpendicular LOS acc. to perpendicular body acc. + me.toBody = math.cos((me.pitch - me.pitch_to_target)*D2R); + if (me.toBody==0) me.toBody=0.00001; + me.acc_upwards_fps2 /= me.toBody; + # Apply the acc. + me.velocity_vector_length_fps = me.clamp(me.old_speed_fps, 0.0001, 1000000); + me.commanded_upwards_vector_length_fps = me.acc_upwards_fps2*me.dt; + me.raw_steer_signal_elev = R2D*me.commanded_upwards_vector_length_fps/me.velocity_vector_length_fps; + } elsif (me.apn == 1) { + # APN (constant best at 5, but the higher value the more sensitive to noise) + # Augmented proportional navigation. Takes target acc. into account. Invented for SAMs. + me.toBody = math.cos(me.curr_deviation_e*D2R);#convert perpendicular LOS acc. to perpendicular body acc. + if (me.toBody==0) me.toBody=0.00001; + me.acc_upwards_fps2 = me.gpn*me.pro_constant*me.line_of_sight_rate_up_rps*math.abs(me.vert_closing_rate_fps)+me.t_LOS_elev_norm_acc*me.noise; + me.acc_upwards_fps2 /= me.toBody; + #printf("vert acc = %.2f + %.2f G", me.pro_constant*me.line_of_sight_rate_up_rps*me.vert_closing_rate_fps/g_fps, (me.apn*me.pro_constant*me.t_LOS_elev_norm_acc/2)/g_fps); + me.velocity_vector_length_fps = me.clamp(me.old_speed_fps, 0.0001, 1000000); + me.commanded_upwards_vector_length_fps = me.acc_upwards_fps2*me.dt; + me.raw_steer_signal_elev = R2D*me.commanded_upwards_vector_length_fps/me.velocity_vector_length_fps; + } elsif (me.apn == 0) { + # PN (constant best at 3) + # Generalized Proportional Navigation. + me.toBody = math.cos(me.curr_deviation_e*D2R);#convert perpendicular LOS acc. to perpendicular body acc. + if (me.toBody==0) me.toBody=0.00001; + me.acc_upwards_fps2 = me.pro_constant*me.line_of_sight_rate_up_rps*math.abs(me.vert_closing_rate_fps)*me.noise; + me.acc_upwards_fps2 /= me.toBody; + me.velocity_vector_length_fps = me.clamp(me.old_speed_fps, 0.0001, 1000000); + me.commanded_upwards_vector_length_fps = me.acc_upwards_fps2*me.dt; + me.raw_steer_signal_elev = R2D*me.commanded_upwards_vector_length_fps/me.velocity_vector_length_fps; + } elsif (me.apn == -1) { + # PN [invented during WWII by Luke Chia‐Liu Yuan] + # Original Proportional navigation. + # Rearranging the equations gives Pure proportional navigation, which show that this law + # does not take missile alpha into account, and is therefore not very good in real life. + me.radians_up_per_sec = me.pro_constant*me.line_of_sight_rate_up_rps*me.noise; + me.raw_steer_signal_elev = me.dt*me.radians_up_per_sec*R2D; + } + + # now compensate for the predicted gravity drop of attitude: + me.attitudePN = (math.atan2(-(me.speed_down_fps+g_fps * me.dt), me.speed_horizontal_fps ) - math.atan2(-me.speed_down_fps, me.speed_horizontal_fps )) * R2D; + me.gravComp = -me.attitudePN; + #printf("Gravity compensation %0.2f degs", me.gravComp); + me.raw_steer_signal_elev += me.gravComp; + + #printf("Proportional lead: %0.1f deg elev", -(me.curr_deviation_e-me.raw_steer_signal_elev)); + } + } + me.CRE_old_dt = me.dt; + } + }, + + scalarProj: func (head, pitch, magn, projHead, projPitch) { + head = head*D2R; + pitch = pitch*D2R; + projHead = projHead*D2R; + projPitch = projPitch*D2R; + + # Convert the 2 polar vectors to cartesian: + + # velocity vector of target + me.ax = magn * math.cos(pitch) * math.cos(-head);#north + me.ay = magn * math.cos(pitch) * math.sin(-head);#west + me.az = magn * math.sin(pitch); #up + + # vector pointing from target perpendicular to LOS + me.bx = 1 * math.cos(projPitch) * math.cos(-projHead);# north + me.by = 1 * math.cos(projPitch) * math.sin(-projHead);# west + me.bz = 1 * math.sin(projPitch); # up + + # the dot product is the scalar projection. And represent the target velocity perpendicular to LOS + me.result = (me.ax * me.bx + me.ay * me.by + me.az * me.bz)/1; + return me.result; + }, + + map: func (value, leftMin, leftMax, rightMin, rightMax) { + # Figure out how 'wide' each range is + var leftSpan = leftMax - leftMin; + var rightSpan = rightMax - rightMin; + + # Convert the left range into a 0-1 range (float) + var valueScaled = (value - leftMin) / leftSpan; + + # Convert the 0-1 range into a value in the right range. + return rightMin + (valueScaled * rightSpan); + }, + + proximity_detection: func { + + ####Ground interaction + me.ground = geo.elevation(me.coord.lat(), me.coord.lon()) or 0; + me.terrainImpact = 0; + if(me.ground > me.coord.alt()) { + me.event = "exploded"; + if(me.life_time < me.arming_time) { + me.event = "landed disarmed"; + #thread.lock(mutexTimer); + #append(AIM.timerQueue, [me,me.log,[me.typeLong~" landed disarmed."],0]); + #thread.unlock(mutexTimer); + } + if (me.Tgt != nil and me.direct_dist_m == nil) { + # maddog might go here + me.Tgt = nil; + #me.direct_dist_m = me.coord.direct_distance_to(me.Tgt.get_Coord()); + } + if ((me.Tgt != nil and me.direct_dist_m != nil) or me.Tgt == nil) { + me.terrainImpact = 1; + #me.explode("Hit terrain.", me.coord, me.direct_dist_m, me.event); + #return 1; + } + } + + if (me.Tgt != nil and me.t_coord != nil and me.guidance != "inertial") { + # Maintain an array of the coordinates of the missile and the tgt in the last 3 frames. + # (use xyz coord to avoid the strange behaviour of comparing geo coordinates). + for (var i=me.crc_frames_look_back; i >= 0; i-=1){ + me.crc_coord[i] = (i != 0) ? me.crc_coord[i-1] : me.coord.xyz(); + me.crc_t_coord[i] = (i != 0) ? me.crc_t_coord[i-1] : me.t_coord.xyz(); + me.crc_range[i] = (i != 0) ? me.crc_range[i-1] : me.myMath.magnitudeVector( + me.myMath.minus(me.crc_coord[0], + me.crc_t_coord[0])); + } + + if (me.crc_coord[1] == nil or me.crc_t_coord[1] == nil or me.crc_range[1] == nil) { + if (me.terrainImpact) { + me.coord.set_alt(me.ground); + me.explode("Hit terrain.", me.coord, me.direct_dist_m, me.event); + return 1; + } + return 0; # Wait for the buffer to fill at least once. + } + + if (me.life_time > me.arming_time) { + # Distance to target increase. + if (me.crc_range[0] > me.crc_range[1] and me.crc_range[0] < 250) { + # Compute the closest approach. + me.subframeClosestRangeCoord(); # Provides `me.crc_closestRange` and `me.crc_missileCoord`. + + me.explode("Passed target.", me.crc_missileCoord, me.crc_closestRange); + return 1; + } + if (me.life_time > me.selfdestruct_time or (me.destruct_when_free and me.free)) { + me.explode("Selfdestructed.", me.coord); + return 1; + } + } + me.direct_dist_m = me.crc_range[0]; + } elsif (me.life_time > me.selfdestruct_time) { + me.Tgt = nil; # make sure we dont in inertial mode with target go in and start checking distances. + me.explode("Selfdestructed.", me.coord); + return 1; + } + if (me.terrainImpact) { + me.coord.set_alt(me.ground); + me.explode("Hit terrain.", me.coord, me.direct_dist_m, me.event); + return 1; + } + return 0; + }, + + #! brief: Recursive function to compute the closest range in the past mfd frames. + #! param fei: The frame to compute first (0: current frame, 1: previous frame, ...). + #! param mfd: The maximum amount of frames available if needed. + #! input me.crc_coord: The coordinates of the missile in the last frames. + #! input me.crc_t_coord: The coordinates of the target in the last frames. + #! output me.crc_missileCoord: The coordinates of the missile when it was the closest to the target in the mfd+1 last frames. + #! output me.crc_closestRange: The range of the missile when it was the closest to the target in the mfd+1 last frames. + subframeClosestRangeCoord : func(fei=0, mfd=nil) { + # Handle default depth parameter (set it as me.crc_frames_look_back if default is needed). + if (mfd == nil) + mfd = me.crc_frames_look_back; + + # Prevent illegal parameter. + if(mfd < 1) + die("Argument exception: The mfd (Max Frames Depth) cannot be less than one."); + if(fei < 0) + die("Argument exception: The fei (Frames End Index) cannot be negative."); + + # Ensure the availability of the frame-end data. + if(me.crc_coord[fei] == nil or me.crc_t_coord[fei] == nil) + die("No coordinates available for the end of the frame."); + + # Indices for the coordinates at frame start (fsi) and frame end (fei); + var fsi = fei + 1; + + # Buffers used for unprocessed result, set to the frame-end values in case of unavailable frame-start data; + var missileCoord = me.crc_coord[fei]; + var targetCoord = me.crc_t_coord[fei]; + + # Check for availability of the frame-start data + if(me.crc_coord[fsi] != nil and me.crc_t_coord[fsi] != nil){ + # Get the origin coordinates and speed of the missile and it's target for the current frame. + # The units are in m for distances and frames for time. + var misCoord = me.crc_coord[fsi]; + var misSpeed = me.myMath.minus(me.crc_coord[fei], misCoord); + var tgtCoord = me.crc_t_coord[fsi]; + var tgtSpeed = me.myMath.minus(me.crc_t_coord[fei], tgtCoord); + + # Compute when the closest distance happened in time. + var t = call(func me.myMath.particleShortestDistTime(misCoord, misSpeed, tgtCoord, tgtSpeed), nil, var err = []); + # If an error is thrown, this is probably due to a null differential speed. + if (size(err)){ + t = 1; + print(err[0]); + } + + # If the time factor (in frames) is superior than 1, this mean that the missile is still closing. + if (t > 1) + t = 1; # Set it to 1 to prevent extrapolation (but it should still get closer). + # If it is negative, the closest range happened at one of the previous frame: + else if (t < 0) + if (mfd > 1) # If we can recursively compute the previous frame: + return me.subframeClosestRangeCoord(fei+1, mfd-1); # Return it's result instead, and stop here. + else + t = 0; # Set it to 0 to prevent extrapolation. + + # Compute (interpolate) the position of the missile and it's target when their range is the closest. + missileCoord = me.myMath.plus(misCoord, me.myMath.product(t, misSpeed)); + targetCoord = me.myMath.plus(tgtCoord, me.myMath.product(t, tgtSpeed)); + } + + # Return the minimum distance between the missile and the tgt, and the position of the missile at that time. + me.crc_closestRange = me.myMath.magnitudeVector(me.myMath.minus(targetCoord, missileCoord)); + me.crc_missileCoord = geo.Coord.new(); + me.crc_missileCoord.set_xyz(missileCoord[0], missileCoord[1], missileCoord[2]); + me.crc_missileCoord.alt();# TODO: once fixed in FG this line is no longer needed. + }, + + log: func (str) { + damage.damageLog.push(str); + }, + + notifyInFlight: func (lat,lon,alt,rdar,semiRdr,typeID,typ,unique,thrustOn,callsign, heading, pitch, speed, is_deleted=0) { + ## thrustON cannot be named 'thrust' as FG for some reason will then think its a function (probably fixed by the way call() now is used) + var msg = notifications.ArmamentInFlightNotification.new("mfly", unique, is_deleted?damage.DESTROY:damage.MOVE, 21+typeID); + if (lat != nil) { + msg.Position.set_latlon(lat,lon,alt); + } else { + msg.Position.set_latlon(0,0,0); + } + msg.Flags = rdar;#bit #0 + if (thrustOn) { + msg.Flags = bits.set(msg.Flags, 1);#bit #1 + } + if (semiRdr) { + msg.Flags = bits.set(msg.Flags, 2);#bit #2 + } + msg.IsDistinct = !is_deleted; + msg.RemoteCallsign = callsign; + msg.UniqueIndex = ""~typeID~unique; + msg.Pitch = pitch; + msg.Heading = heading; + msg.u_fps = speed; + #msg.isValid(); + notifications.geoBridgedTransmitter.NotifyAll(msg); +#print("fox2.nas: transmit in flight"); +#f14.debugRecipient.Receive(msg); + }, + + notifyCrater: func (lat,lon,alt,big,heading,static) { + var uni = int(rand()*15000000); + var msg = notifications.StaticNotification.new("stat", uni, 1, big); + + msg.Position.set_latlon(lat,lon,alt); + msg.IsDistinct = 0; + msg.Heading = heading; + notifications.hitBridgedTransmitter.NotifyAll(msg); +#print("fox2.nas: transmit crater"); +#f14.debugRecipient.Receive(msg); + damage.statics["obj_"~uni] = [static, lat,lon,alt, heading,big]; + }, + + notifyHit: func (RelativeAltitude, Distance, callsign, Bearing, reason, typeID, type, self) { + var msg = notifications.ArmamentNotification.new("mhit", 4, 21+typeID); + msg.RelativeAltitude = RelativeAltitude; + msg.Bearing = Bearing; + msg.Distance = Distance; + msg.RemoteCallsign = callsign; # RJHTODO: maybe handle flares / chaff + if (self) { + msg.Callsign = callsign; + msg.FromIncomingBridge = 1; + damage.damage_recipient.Receive(msg); + } + notifications.hitBridgedTransmitter.NotifyAll(msg); + me.log(sprintf("You hit %s with %s at %.1f meters.",callsign, type, Distance)); +#print("fox2.nas: transmit hit to ",callsign," reason:",reason); +#f14.debugRecipient.Receive(msg); + }, + + explode: func (reason, coordinates, range = nil, event = "exploded") { + var hitGround = 0; + if (reason == "Hit terrain.") { + hitGround = 1; + } + if (me.lock_on_sun) { + reason = "Locked onto sun."; + } elsif (me.flareLock) { + reason = "Locked onto flare."; + } elsif (me.chaffLock) { + reason = "Locked onto chaff."; + } + + me.coord = coordinates; # Set the current missile coordinates at the explosion point. + + if(getprop("payload/armament/msg")) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.notifyInFlight, [me.coord.lat(), me.coord.lon(), me.coord.alt(),0,0,me.typeID,me.type,me.unique_id,0,"", me.hdg, me.pitch, 0, 0], -1]); + thread.unlock(mutexTimer); + } + + var wh_mass = (event == "exploded" and !me.inert) ? me.weight_whead_lbm : 0; #will report 0 mass if did not have time to arm + + thread.lock(mutexTimer); + append(AIM.timerQueue, [me,impact_report,[coordinates, wh_mass, "munition", me.type, me.new_speed_fps*FT2M],0]); + thread.unlock(mutexTimer); + + if (!me.inert) { + var phrase = nil; + var hitPrimaryTarget = 0; + if (me.Tgt != nil and !me.Tgt.isVirtual()) { + var tgtLabel = me.callsign; + if(me.flareLock) + tgtLabel ~= "'s flare"; + elsif (me.chaffLock) + tgtLabel ~= "'s chaff"; + if (range != nil and range < me.reportDist) { + phrase = sprintf(me.type ~ " " ~ event ~ ": %.1f meters from: " ~ tgtLabel, range); + if (!me.flareLock and !me.chaffLock) { + hitPrimaryTarget = 1; + } + } else { + phrase = me.type ~ " missed " ~ me.callsign ~ ": " ~ reason; + } + } elsif (me.Tgt == nil) { + phrase = sprintf(me.type ~ " " ~ event); + } + if (phrase != nil) { + me.printStats("%s time %.1f", phrase, me.life_time); + if(getprop("payload/armament/msg") and hitPrimaryTarget and wh_mass > 0){ + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.notifyHit, [coordinates.alt() - me.t_coord.alt(),range,me.callsign,coordinates.course_to(me.t_coord),reason,me.typeID, me.typeLong, 0], -1]); + thread.unlock(mutexTimer); + } else { + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.log, [phrase], 0]); + thread.unlock(mutexTimer); + } + } + if (me.multiHit and !me.multiExplosion(coordinates, event, wh_mass) and me.Tgt != nil and me.Tgt.isVirtual()) { + phrase = sprintf(me.type~" "~event); + me.printStats("%s Reason: %s time %.1f", phrase, reason, me.life_time); + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.log, [phrase], 0]); + thread.unlock(mutexTimer); + } + } + + me.ai.getNode("valid", 1).setBoolValue(0); + thread.lock(mutexTimer); + append(AIM.timerQueue, [me, me.setModelRemoved, [], -1]); + thread.unlock(mutexTimer); + if (event == "exploded" and !me.inert and wh_mass > 0) { + me.animate_explosion(hitGround); + me.explodeSound = 1; + } else { + me.animate_dud(); + me.explodeSound = 0; + } + me.Tgt = nil; + }, + + multiExplosion: func (explode_coord, event, wh_mass) { + # hit everything that is nearby except for target itself. + me.sendout = 0; + foreach (me.testMe;me.contacts) { + if (!me.testMe.isValid() or me.testMe.isVirtual() or me.testMe.get_type() == ORDNANCE) { + continue; + } + var min_distance = me.testMe.get_Coord().direct_distance_to(explode_coord); + + if (min_distance < me.reportDist and (me.Tgt == nil or me.testMe.getUnique() != me.Tgt.getUnique())) { + var phrase = sprintf("%s %s: %.1f meters from: %s", me.type,event, min_distance, me.testMe.get_Callsign()); + me.printStats(phrase); + + if(getprop("payload/armament/msg") and wh_mass > 0){ + var cs = damage.processCallsign(me.testMe.get_Callsign()); + var cc = me.testMe.get_Coord(); + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.notifyHit, [explode_coord.alt() - cc.alt(),min_distance,cs,explode_coord.course_to(cc),"mhit1",me.typeID, me.typeLong,0], -1]); + thread.unlock(mutexTimer); + } elsif (wh_mass > 0) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.log, [phrase], 0]); + thread.unlock(mutexTimer); + } + + me.sendout = 1; + } + } + # Now check for hitting ourselves: + var min_distance = geo.aircraft_position().direct_distance_to(explode_coord); + if (min_distance < me.reportDist) { + # hitting oneself :) + var cs = damage.processCallsign(getprop("sim/multiplay/callsign")); + var phrase = sprintf("%s %s: %.1f meters from: %s", me.type,event, min_distance, cs);# if we mention ourself then we need to explicit add ourself as author. + me.printStats(phrase); + if (wh_mass > 0) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.notifyHit, [explode_coord.alt() - geo.aircraft_position().alt(),min_distance,cs,explode_coord.course_to(geo.aircraft_position()),"mhit2",me.typeID, me.typeLong, 1], -1]); + thread.unlock(mutexTimer); + } + me.sendout = 1; + } + return me.sendout; + }, + + sendMessage: func (str) { + if (getprop("payload/armament/msg")) { + defeatSpamFilter(str); + } else { + setprop("/sim/messages/atc", str); + } + }, + + interpolate: func (start, end, fraction) { + #if (!start.is_defined()) print("start undefined:"); found the bug so these prints not needed anymore + #if (!end.is_defined()) print("end undefined:"); + me.xx = (start.x()*(1-fraction) + +end.x()*fraction); + me.yy = (start.y()*(1-fraction)+end.y()*fraction); + me.zz = (start.z()*(1-fraction)+end.z()*fraction); + + me.cc = geo.Coord.new(); + me.cc.set_xyz(me.xx,me.yy,me.zz); + + return me.cc; + }, + + getPitch: func (coord1, coord2) { + #pitch from coord1 to coord2 in degrees (takes curvature of earth into effect.) + return me.myMath.getPitch(coord1, coord2); + }, + + getPitch2: func (coord1, coord2) { + #pitch from coord1 to coord2 in degrees (assumes earth is flat) + me.flat_dist = coord1.distance_to(coord2); + me.flat_alt = coord2.alt()-coord1.alt(); + return math.atan2(me.flat_alt, me.flat_dist)*R2D; + }, + + ################################################################### + # non-multi-threaded loops for before flying. autostarted. + ################################################################### + + getContact: func { + if (me.noCommonTarget) { + return nil; + } + if (me.target_pnt and contactPoint != nil) { + return contactPoint; + } else { + return contact; + } + }, + + standby: func { + # looping in standby mode + if (deltaSec.getValue()==0) { + settimer(func me.standby(), 0.5); + } + if(me.seam_support and me.uncage_auto) { + me.caged = 1; + } + if (me.deleted or me.status == MISSILE_FLYING) return; + if (me.status == MISSILE_STARTING) { + me.printCode("Starting up missile"); + me.startup(); + return; + } + me.coolingSyst(); + me.reset_seeker(); + #print(me.type~" standby "~me.ID); + + settimer(func me.standby(), deltaSec.getValue()==0?0.5:0.25); + }, + + startup: func { + # looping in starting mode + #print("startup"); + if (deltaSec.getValue()==0) { + settimer(func me.startup(), 0.5); + } + if(me.seam_support and me.uncage_auto) { + me.caged = 1; + } + if (me.status != MISSILE_STARTING) { + me.standby(); + return; + } + if (me.ready_standby_time != 0 and getprop("sim/time/elapsed-sec") > (me.ready_standby_time+me.ready_time)) { + me.status = MISSILE_SEARCH; + me.search(); + return; + } + #print("Starting up"); + me.coolingSyst(); + me.reset_seeker(); + settimer(func me.startup(), deltaSec.getValue()==0?0.5:0.25); + }, + + coolingSyst: func { + if (me.coolable and me.status != MISSILE_FLYING) { + me.cool_elapsed = getprop("sim/time/elapsed-sec"); + if (me.cooling_last_time != 0) { + me.cool_delta_time = me.cool_elapsed - me.cooling_last_time; + if (me.cooling) { + me.cool_total_time += me.cool_delta_time; + if (me.cool_total_time > me.cool_duration) { + me.cooling = 0; + } else { + me.cool_curr_time = me.cool_delta_time+me.extrapolate(me.warm, 1, 0, 0, me.cool_time); + me.warm = me.clamp(me.extrapolate(me.cool_curr_time, 0, me.cool_time, 1, 0),0,1); + } + } + if (!me.cooling) { + me.cool_curr_time = me.cool_delta_time+me.extrapolate(me.warm, 0, 1, 0, me.cool_time*3);#takes longer to warm than to cool down + me.warm = me.clamp(me.extrapolate(me.cool_curr_time, 0, me.cool_time*3, 0, 1),0,1); + } + } + me.cooling_last_time = me.cool_elapsed; + me.detect_range_curr_nm = me.extrapolate(me.warm, 0, 1, me.cold_detect_range_nm, me.warm_detect_range_nm); + me.detect_range_curr_nm *= me.seam_scan?0.65:1;#GR1F-16CJ-34-1-1 page 1-402 + } else { + me.detect_range_curr_nm = (me.seam_scan?0.65:1)*me.max_fire_range_nm;#GR1F-16CJ-34-1-1 page 1-402 + } + }, + + checkForLock: func { + # call this only before firing + if (!(me.tagt.get_type() == AIR and me.tagt.get_Speed()<15) and ((me.guidance != "semi-radar" or me.is_painted(me.tagt)) and (me.guidance !="laser" or me.is_laser_painted(me.tagt))) + and (me.guidance != "radiation" or me.is_radiating_aircraft(me.tagt)) + and me.rng < me.max_fire_range_nm and me.rng > me.getCurrentMinFireRange(me.tagt) and me.FOV_check(OurHdg.getValue(),OurPitch.getValue(),me.total_horiz, me.total_elev, me.slave_to_radar or contactPoint==me.tagt?(me.guidance == "heat" or me.guidance == "vision"?math.min(me.max_seeker_dev, me.fcs_fov):me.fcs_fov):me.max_seeker_dev, vector.Math) + and (me.rng < me.detect_range_curr_nm or (me.guidance != "radar" and me.guidance != "semi-radar" and me.guidance != "tvm" and me.guidance != "sample" and me.guidance != "heat" and me.guidance != "vision" and me.guidance != "radiation")) + and (me.guidance != "heat" or (me.all_aspect or me.rear_aspect(geo.aircraft_position(), me.tagt))) + and me.checkForView()) { + return 1; + } + #me.printSearch("Lock did fail %d %d %d %d %d %d %d %d %d", + # !(me.tagt.get_type() == AIR and me.tagt.get_Speed()<15), + # ((me.guidance != "semi-radar" or me.is_painted(me.tagt) == 1) and (me.guidance !="laser" or me.is_laser_painted(me.tagt) == 1)), + # (me.guidance != "radiation" or me.is_radiating_aircraft(me.tagt) == 1), + # me.rng < me.max_fire_range_nm, + # me.rng > me.min_fire_range_nm, + # me.FOV_check(OurHdg.getValue(),OurPitch.getValue(),me.total_horiz, me.total_elev, me.slave_to_radar?math.min(me.max_seeker_dev, me.fcs_fov):me.max_seeker_dev, vector.Math), + # (me.rng < me.detect_range_curr_nm or (me.guidance != "radar" and me.guidance != "semi-radar" and me.guidance != "heat" and me.guidance != "vision" and me.guidance != "heat" and me.guidance != "radiation")), + # (me.guidance != "heat" or (me.all_aspect == 1 or me.rear_aspect(geo.aircraft_position(), me.tagt) == 1)), + # me.checkForView()); + return 0; + }, + + checkForView: func { + if (me.guidance != "gps-laser" and me.guidance != "gps" and me.guidance != "inertial" and me.guidance != "sample") { + me.launchCoord = geo.aircraft_position(); + if (!me.radarOrigin) { + me.geodPos = aircraftToCart({x:-me.radarX, y:me.radarY, z: -me.radarZ}); + me.launchCoord.set_xyz(me.geodPos.x, me.geodPos.y, me.geodPos.z); + } + + me.potentialCoord = me.tagt.get_Coord(); + me.xyz = {"x":me.launchCoord.x(), "y":me.launchCoord.y(), "z":me.launchCoord.z()}; + me.directionLOS = {"x":me.potentialCoord.x()-me.launchCoord.x(), "y":me.potentialCoord.y()-me.launchCoord.y(), "z":me.potentialCoord.z()-me.launchCoord.z()}; + + # Check for terrain between own weapon and target: + me.terrainGeod = get_cart_ground_intersection(me.xyz, me.directionLOS); + if (me.terrainGeod == nil) { + return 1; + } else { + me.terrain = geo.Coord.new(); + me.terrain.set_latlon(me.terrainGeod.lat, me.terrainGeod.lon, me.terrainGeod.elevation); + me.maxDist = me.launchCoord.direct_distance_to(me.potentialCoord)-1;#-1 is to avoid z-fighting distance + me.terrainDist = me.launchCoord.direct_distance_to(me.terrain); + if (me.terrainDist >= me.maxDist) { + return 1; + } + } + return 0; + } + return 1; + }, + + checkForViewInFlight: func (tagt) { + if (me.guidance != "gps-laser" and me.guidance != "gps" and me.guidance != "inertial" and me.guidance != "sample") { + me.launchCoord = me.coord; + me.potentialCoord = tagt.get_Coord(); + me.xyz = {"x":me.launchCoord.x(), "y":me.launchCoord.y(), "z":me.launchCoord.z()}; + me.directionLOS = {"x":me.potentialCoord.x()-me.launchCoord.x(), "y":me.potentialCoord.y()-me.launchCoord.y(), "z":me.potentialCoord.z()-me.launchCoord.z()}; + + # Check for terrain between own weapon and target: + me.terrainGeod = get_cart_ground_intersection(me.xyz, me.directionLOS); + if (me.terrainGeod == nil) { + return 1; + } else { + me.terrain = geo.Coord.new(); + me.terrain.set_latlon(me.terrainGeod.lat, me.terrainGeod.lon, me.terrainGeod.elevation); + me.maxDist = me.launchCoord.direct_distance_to(me.potentialCoord)-1;#-1 is to avoid z-fighting distance + me.terrainDist = me.launchCoord.direct_distance_to(me.terrain); + if (me.terrainDist >= me.maxDist) { + return 1; + } + } + return 0; + } + return 1; + }, + + checkForClassInFlight: func (newtgt) { + # call this only after firing + if(newtgt != nil and newtgt.isValid() and + ( (newtgt.get_type() == SURFACE and me.target_gnd) + or (newtgt.get_type() == AIR and me.target_air) + or (newtgt.get_type() == POINT and me.target_pnt) + or (newtgt.get_type() == MARINE and me.target_sea))) { + return 1; + } + #if(me.slaveContact != nil) printf("class failed %d %d %d",me.slaveContact.isValid() == 1,me.slaveContact.get_type() == AIR,me.target_air == 1); + return 0; + }, + + checkForClass: func { + # call this only before firing + if(me.slaveContact != nil and me.slaveContact.isValid() and + ( (me.slaveContact.get_type() == SURFACE and me.target_gnd) + or (me.slaveContact.get_type() == AIR and me.target_air) + or (me.slaveContact.get_type() == POINT and me.target_pnt) + or (me.slaveContact.get_type() == MARINE and me.target_sea))) { + return 1; + } + #if(me.slaveContact != nil) printf("class failed %d %d %d",me.slaveContact.isValid() == 1,me.slaveContact.get_type() == AIR,me.target_air == 1); + return 0; + }, + + newLock: func (tagt) { + # for switching to new lock during flight. + #reorder to gain performance + me.newlockgained = 0; + if (!tagt.isValid()) { + me.printStatsDetails("Test: invalid contact. Rejected."); + return 0; + } + me.printStatsDetails("Test starting on %s:",tagt.get_Callsign()); + me.newCoord = tagt.get_Coord(); + if (me.coord.direct_distance_to(me.newCoord)*M2NM > me.detect_range_curr_nm) { + me.printStatsDetails("Test: contact out of range. Rejected."); + return 0; + } + me.newlockgained = me.checkForClassInFlight(tagt); + if (!me.newlockgained) {me.printStatsDetails("Test: invalid type: %d. Rejected.",tagt.get_type());return 0;} + if (me.guidance == "laser") { + me.newlockgained = me.is_laser_painted(tagt); + if (!me.newlockgained){me.printStatsDetails("Test: no laser lock. Rejected.");return 0;} + } elsif (me.guidance == "semi-radar") { + me.newlockgained = me.is_painted(tagt); + if (!me.newlockgained) {me.printStatsDetails("Test: no radar paint. Rejected.");return 0;} + } elsif (me.guidance == "radiation") { + me.newlockgained = me.is_radiating_me(tagt); + if (!me.newlockgained) {me.printStatsDetails("Test: not radiating me. Rejected.");return 0;} + } elsif (me.guidance == "heat") { + me.newlockgained = me.all_aspect or me.rear_aspect(me.coord, tagt); + if (!me.newlockgained) {me.printStatsDetails("Test: no view of heat source. Rejected.");return 0;} + } + if (me.guidance != "gps-laser" and me.guidance != "gps" and me.guidance != "inertial" and me.guidance != "sample") { + me.new_elev_deg = me.getPitch(me.coord, me.newCoord); + me.new_course = me.coord.course_to(me.newCoord); + me.new_deviation_e = me.new_elev_deg - me.pitch; + me.new_deviation_h = me.new_course - me.hdg; + me.newlockgained = me.FOV_check(me.hdg, me.pitch, me.new_deviation_h, me.new_deviation_e, me.max_seeker_dev, me.myMath); + if (!me.newlockgained) {me.printStatsDetails("Test: not in FoV. Rejected.");return 0;} + } + me.newlockgained = me.checkForViewInFlight(tagt); + if (!me.newlockgained) {me.printStatsDetails("Test: terrain obscurre contact. Rejected.");return 0;} + else me.printStatsDetails("Test: contact approved."); + return me.newlockgained; + }, + + checkForClassInFlight: func (tact) { + # call this only after firing + if(tact != nil and tact.isValid() and + ( (tact.get_type() == SURFACE and me.target_gnd) + or (tact.get_type() == AIR and me.target_air) + or (tact.get_type() == POINT and me.target_pnt) + or (tact.get_type() == MARINE and me.target_sea))) { + return 1; + } + return 0; + }, + + search: func { + # looping in search mode + if (deltaSec.getValue()==0) { + settimer(func me.search(), 0.5); + } + if (me.deleted) { + return; + } elsif ( me.status == MISSILE_FLYING ) { + me.SwSoundVol.setDoubleValue(0); + me.SwSoundOnOff.setBoolValue(0); + return; + } elsif ( me.status == MISSILE_STANDBY or me.status == MISSILE_STARTING) { + # Stand by. + me.SwSoundVol.setDoubleValue(0); + me.SwSoundOnOff.setBoolValue(0); + #me.trackWeak = 1; + me.standby(); + return; + } elsif ( me.status == MISSILE_LOCK) { + # Locked. + me.printSearch("in search loop, but locked!"); + me.return_to_search(); + return; + } + + + + me.printSearch("searching"); + # search. + if(me.seam_support and me.uncage_auto) { + me.caged = 1; + } + me.coolingSyst(); + if (!me.caged) { + me.slaveContacts = nil; + if (size(me.contacts) == 0) { + me.slaveContacts = [me.getContact()]; + } else { + me.slaveContacts = me.contacts; + } + if (me.rosette_radius != 0 and me.guidance == "heat") { + # Only here for backwards compat. Uncaged and untracking it will not do a pattern, it will be horizon stabilized (TODO). + me.nutateSeeker(PATTERN_ROSETTE, me.command_dir_heading, me.command_dir_pitch, me.rosette_radius); + } else { + me.seeker_head_target = me.uncage_idle_heading+(rand()-0.5); + me.seeker_elev_target = me.uncage_idle_pitch+(rand()-0.5); + me.moveSeeker(); + } + foreach(me.slaveContact ; me.slaveContacts) { + if (me.checkForClass()) { + me.tagt = me.slaveContact; + me.rng = me.tagt.get_range(); + me.total_elev = deviation_normdeg(OurPitch.getValue(), me.tagt.getElevation()); # deg. + me.total_horiz = deviation_normdeg(OurHdg.getValue(), me.tagt.get_bearing()); # deg. + # Check if in range and in the seeker FOV. + if (me.checkForLock()) { + me.printSearch("uncaged-search ready for lock"); + + me.convertGlobalToSeekerViewDirection(me.tagt.get_bearing(), me.tagt.getElevation(), OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + me.testSeeker(); + if (me.inBeam) { + me.printSearch("uncaged-search found a lock (%s %s)", me.tagt["getVirtualType"] != nil?me.tagt.getVirtualType():"orig", contactPoint!=nil); + me.goToLock(); + return; + } + } + } + } + me.Tgt = nil; + me.SwSoundVol.setDoubleValue(me.vol_search); + me.SwSoundOnOff.setBoolValue(1); + settimer(func me.search(), 0.05);# this mode needs to be a bit faster. + return; + } elsif (me.slave_to_radar) { + me.slaveContact = nil; + if (size(me.contacts) == 0) { + me.slaveContact = me.getContact(); + } else { + me.slaveContact = me.contacts[0]; + } + if (me.checkForClass()) { + me.printSearch("search found suitable contact"); + me.tagt = me.slaveContact; + me.rng = me.tagt.get_range(); + me.total_elev = deviation_normdeg(OurPitch.getValue(), me.tagt.getElevation()); # deg. + me.total_horiz = deviation_normdeg(OurHdg.getValue(), me.tagt.get_bearing()); # deg. + # Check if in range and in the seeker FOV. + if (me.checkForLock()) { + me.printSearch("rdr-slave-search ready for lock"); + me.convertGlobalToSeekerViewDirection(me.tagt.get_bearing(), me.tagt.getElevation(), OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + if (me.seam_scan and me.guidance == "heat") { + me.nutateSeeker(me.oldPattern?PATTERN_DOUBLE_D:PATTERN_CIRCLE, me.seeker_head_target, me.seeker_elev_target); + } else { + me.moveSeeker(); + } + me.testSeeker(); + if (me.inBeam) { + me.printSearch("rdr-slave-search found a lock (%s %s)", me.tagt["getVirtualType"] != nil?me.tagt.getVirtualType():"orig", contactPoint!=nil); + me.goToLock(); + return; + } + } else { + # Radar locked, seekerhead nutates around a locked direction. + me.convertGlobalToSeekerViewDirection(me.tagt.get_bearing(), me.tagt.getElevation(), OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + if (me.seam_scan and me.guidance == "heat") { + me.nutateSeeker(me.oldPattern?PATTERN_DOUBLE_D:PATTERN_CIRCLE, me.seeker_head_target, me.seeker_elev_target); + } else { + me.moveSeeker(); + } + if (DEBUG_SEARCH) { + # air target has speed + # fox1 is painted + # in range (max) + # in range (min) + # FOV + # in range (detect) + # Line of sight + me.printSearch("Lock failed %d %d %d %d %d %d %d", + !(me.tagt.get_type() == AIR and me.tagt.get_Speed()<15), + (me.guidance != "semi-radar" or me.is_painted(me.tagt)), + me.rng < me.max_fire_range_nm, + me.rng > me.getCurrentMinFireRange(me.tagt), + me.FOV_check(OurHdg.getValue(),OurPitch.getValue(),me.total_horiz, me.total_elev, me.fcs_fov, vector.Math), + me.rng < me.detect_range_curr_nm, + me.checkForView()); + } + } + } else { + # Radar slaved, no valid designation, seekerhead jitters around a idle direction. + me.seeker_elev_target = me.command_dir_pitch+(rand()-0.5)*(me.seam_scan and me.guidance == "heat"); + me.seeker_head_target = me.command_dir_heading+(rand()-0.5)*(me.seam_scan and me.guidance == "heat"); + me.moveSeeker(); + if (DEBUG_SEARCH and me.slaveContact != nil) { + var tpe = me.slaveContact.get_type(); + if (tpe==AIR) tpe="A"; + elsif (tpe==SURFACE) tpe="G"; + elsif (tpe==MARINE) tpe="M"; + elsif (tpe==POINT) tpe="P"; + else tpe ="?"; + me.printSearch("Class check failed: %s (weapon: %s)", tpe, me.class); + } + } + } elsif (!me.slave_to_radar) { + me.slaveContacts = nil; + if (size(me.contacts) == 0) { + me.slaveContacts = [me.getContact()]; + } else { + me.slaveContacts = me.contacts; + } + if (!me.seam_scan or me.guidance != "heat") { + me.seeker_elev_target = me.command_dir_pitch; + me.seeker_head_target = me.command_dir_heading; + me.moveSeeker(); + } else { + me.nutateSeeker(me.oldPattern?PATTERN_DOUBLE_D:PATTERN_CIRCLE, me.command_dir_heading, me.command_dir_pitch); + } + foreach(me.slaveContact ; me.slaveContacts) { + if (me.checkForClass()) { + me.tagt = me.slaveContact; + me.rng = me.tagt.get_range(); + + # Check if in range and in the seeker FOV. + me.total_elev = deviation_normdeg(OurPitch.getValue(), me.tagt.getElevation()); # deg. + me.total_horiz = deviation_normdeg(OurHdg.getValue(), me.tagt.get_bearing()); # deg. + if (me.checkForLock()) { + me.printSearch("bore/dir-search ready for lock"); + me.convertGlobalToSeekerViewDirection(me.tagt.get_bearing(), me.tagt.getElevation(), OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + me.testSeeker(); + if (me.inBeam) { + me.printSearch("dir-search found a lock (%s %s)",me.tagt["getVirtualType"] != nil?me.tagt.getVirtualType():"orig", contactPoint!=nil); + me.goToLock(); + return; + } + } + } + } + } + me.Tgt = nil; + me.SwSoundVol.setDoubleValue(me.vol_search); + me.SwSoundOnOff.setBoolValue(1); + settimer(func me.search(), 0.05); + }, + + goToLock: func { + me.status = MISSILE_LOCK; + me.SwSoundOnOff.setBoolValue(1); + me.SwSoundVol.setDoubleValue(me.vol_track); + + me.Tgt = me.tagt; + + me.callsign = damage.processCallsign(me.Tgt.get_Callsign()); + + settimer(func me.update_lock(), 0.1); + }, + + convertGlobalToSeekerViewDirection: func (bearing, elevation, heading, pitch, roll) { + me.target_x = math.cos(bearing*D2R)*math.cos(elevation*D2R); + me.target_y = -math.sin(bearing*D2R)*math.cos(elevation*D2R); + me.target_z = math.sin(elevation*D2R); + me.target_vector = [me.target_x,me.target_y,me.target_z]; + me.rollLaunchvehicle = vector.Math.rollMatrix(-roll); + me.pitchLaunchvehicle = vector.Math.pitchMatrix(-pitch); + me.yawLaunchvehicle = vector.Math.yawMatrix(heading); + me.rotation = vector.Math.multiplyMatrices(me.rollLaunchvehicle, vector.Math.multiplyMatrices(me.pitchLaunchvehicle, me.yawLaunchvehicle)); + me.target_vector_from_seekers_view = vector.Math.multiplyMatrixWithVector(me.rotation, me.target_vector); + me.angles = vector.Math.cartesianToEuler(me.target_vector_from_seekers_view); + + me.seeker_head_target = me.angles[0]==nil?0:geo.normdeg180(me.angles[0]); + me.seeker_elev_target = me.angles[1]; + }, + + nutateSeeker: func (pattern, heading, pitch, radius = nil) { + me.pattern_elapsed = systime(); + + if (radius == nil and pattern == PATTERN_DOUBLE_D) radius = me.beam_width_deg; + elsif (radius == nil and pattern == PATTERN_CIRCLE) radius = me.beam_width_deg*0.40; + elsif (radius == nil and pattern == PATTERN_ROSETTE) radius = me.beam_width_deg*2.00; + + me.target_x = math.cos(heading*D2R)*math.cos(pitch*D2R); + me.target_y = -math.sin(heading*D2R)*math.cos(pitch*D2R); + me.target_z = math.sin(pitch*D2R); + + me.seeker_reset = [1,0,0]; + + me.meridian_factor = math.abs(pitch)>85?1:math.cos(pitch*D2R); + + if (math.sqrt(math.pow((me.seeker_head-heading)*me.meridian_factor,2)+math.pow(me.seeker_elev-pitch,2))>radius*1.2) { + me.seeker_head_target = heading; + me.seeker_elev_target = pitch; + me.moveSeeker(); + } elsif (vector.Math.angleBetweenVectors(me.seeker_reset, [me.target_x,me.target_y,me.target_z]) < (me.slave_to_radar?math.min(me.max_seeker_dev, me.fcs_fov):me.max_seeker_dev)) { + # TODO: check for seeker FOV of pattern also instead of just center of pattern. + # TODO: use proper high elevation math here too instead of feeble meridian factor. + if (pattern == PATTERN_ROSETTE) { + # rosette nutation + me.freq1 = me.angular_speed*0.23/radius; + me.freq2 = me.f1*0.4; + me.seeker_head = 0.5*radius*(math.cos(me.freq1*math.pi*2*me.pattern_elapsed)+math.cos(me.freq2*math.pi*2*me.pattern_elapsed))/me.meridian_factor+heading; + me.seeker_elev = 0.5*radius*(math.sin(me.freq1*math.pi*2*me.pattern_elapsed)-math.sin(me.freq2*math.pi*2*me.pattern_elapsed))+pitch; + } elsif (pattern == PATTERN_CIRCLE) { + # Standard nutation (CCW) + me.freq = math.min(me.angular_speed/(2*math.pi*radius), 1.0);# source for 1 hz: NAVAIR 01 245FDB-1T + me.seeker_head = radius*math.cos(me.freq*math.pi*2*me.pattern_elapsed)/me.meridian_factor+heading; + me.seeker_elev =-radius*math.sin(me.freq*math.pi*2*me.pattern_elapsed)+pitch; + } elsif (pattern == PATTERN_DOUBLE_D) { + # Is used by older AIM-9G/AIM-9H. 4 hz. 2.5 deg radius. + me.freq = 4.0; + me.doubleDmod = math.mod(me.pattern_elapsed,4); + if (me.doubleDmod >= 0 and me.doubleDmod < 1) { + me.seeker_head = radius*math.cos(math.pi*me.doubleDmod)/me.meridian_factor+heading; + me.seeker_elev =-radius*math.sin(math.pi*me.doubleDmod)+pitch; + } elsif (me.doubleDmod >= 1 and me.doubleDmod < 2) { + me.seeker_head = (2*radius*(me.doubleDmod-1)-radius)/me.meridian_factor+heading; + me.seeker_elev = pitch; + } elsif (me.doubleDmod >= 2 and me.doubleDmod < 3) { + me.seeker_head = radius*math.cos(math.pi*(me.doubleDmod-2))/me.meridian_factor+heading; + me.seeker_elev = radius*math.sin(math.pi*(me.doubleDmod-2))+pitch; + } elsif (me.doubleDmod >= 3) { + me.seeker_head = (2*radius*(me.doubleDmod-3)-radius)/me.meridian_factor+heading; + me.seeker_elev = pitch; + } + } + } + me.computeSeekerPos(); + }, + + moveSeeker: func { + # Build unit vector components for seeker and target location in aircraft frame: + me.target_x = math.cos(me.seeker_head_target*D2R)*math.cos(me.seeker_elev_target*D2R); + me.target_y = -math.sin(me.seeker_head_target*D2R)*math.cos(me.seeker_elev_target*D2R); + me.target_z = math.sin(me.seeker_elev_target*D2R); + + me.seeker_reset = [1,0,0]; + + if (me.guidance != "heat" and me.guidance != "vision") { + me.new_seeker_deviation = vector.Math.angleBetweenVectors(me.seeker_reset, [me.target_x,me.target_y,me.target_z]); + if (me.new_seeker_deviation < (me.slave_to_radar?me.fcs_fov:me.max_seeker_dev)) { + me.seeker_elev = me.seeker_elev_target; + me.seeker_head = me.seeker_head_target; + } + me.computeSeekerPos(); + return; + } + me.seeker_elapsed = systime(); + if (me.seeker_last_time != 0) { + me.seeker_time = me.seeker_elapsed - me.seeker_last_time; + me.seeker_max_move = me.seeker_time*me.angular_speed; + + # Build unit vector components for seeker and target location in aircraft frame: + me.seeker_x = math.cos(me.seeker_head*D2R)*math.cos(me.seeker_elev*D2R); + me.seeker_y = -math.sin(me.seeker_head*D2R)*math.cos(me.seeker_elev*D2R); + me.seeker_z = math.sin(me.seeker_elev*D2R); + + me.ideal_seeker_deviation = vector.Math.angleBetweenVectors([me.seeker_x,me.seeker_y,me.seeker_z],[me.target_x,me.target_y,me.target_z]); + me.ideal_total_seeker_deviation = vector.Math.angleBetweenVectors(me.seeker_reset, [me.target_x,me.target_y,me.target_z]); + + if (me.ideal_seeker_deviation > me.seeker_max_move) { + me.new_seeker_vector = vector.Math.rotateVectorTowardsVector([me.seeker_x,me.seeker_y,me.seeker_z],[me.target_x,me.target_y,me.target_z],me.seeker_max_move); + me.new_seeker_deviation = vector.Math.angleBetweenVectors(me.seeker_reset, me.new_seeker_vector); + + if (me.new_seeker_deviation < me.max_seeker_dev) { + me.new_seeker_pos = vector.Math.cartesianToEuler(me.new_seeker_vector); + me.seeker_head = me.new_seeker_pos[0]==nil?0:geo.normdeg180(me.new_seeker_pos[0]); + me.seeker_elev = me.new_seeker_pos[1]; + } + } elsif (me.ideal_total_seeker_deviation < me.max_seeker_dev) { + me.seeker_elev = me.seeker_elev_target; + me.seeker_head = me.seeker_head_target; + } + } + me.seeker_last_time = me.seeker_elapsed; + me.computeSeekerPos(); + }, + + testSeeker: func { + me.inBeam = 0; + + # Build unit vector components for seeker and target location in aircraft frame: + me.target_x = math.cos(me.seeker_head_target*D2R)*math.cos(me.seeker_elev_target*D2R); + me.target_y = -math.sin(me.seeker_head_target*D2R)*math.cos(me.seeker_elev_target*D2R); + me.target_z = math.sin(me.seeker_elev_target*D2R); + + me.seeker_x = math.cos(me.seeker_head*D2R)*math.cos(me.seeker_elev*D2R); + me.seeker_y = -math.sin(me.seeker_head*D2R)*math.cos(me.seeker_elev*D2R); + me.seeker_z = math.sin(me.seeker_elev*D2R); + + + # we measure the geodesic angle between where seeker is pointing and where the target is. + me.target_deviation = vector.Math.angleBetweenVectors([me.target_x,me.target_y,me.target_z],[me.seeker_x,me.seeker_y,me.seeker_z]); + + if (me.target_deviation < me.beam_width_deg) { + me.inBeam = 1; + #me.printSearch("in beam"); + } + }, + + computeSeekerPos: func { + # Compute HUD diamond position. + if ( use_fg_default_hud) { + var h_rad = (90 - me.seeker_head) * D2R; + var e_rad = (90 - me.seeker_elev) * D2R; + var devs = develev_to_devroll(h_rad, e_rad); + var combined_dev_deg = devs[0]; + var combined_dev_length = devs[1]; + var clamped = devs[2]; + if ( clamped and me.status == MISSILE_LOCK) { + SW_reticle_Blinker.blink(); + } else { + SW_reticle_Blinker.cont(); + } + HudReticleDeg.setDoubleValue(combined_dev_deg); + HudReticleDev.setDoubleValue(combined_dev_length); + } + }, + + update_lock: func() { + # + # Missile locked on target + # + if (deltaSec.getValue()==0) { + settimer(func me.update_lock(), 0.5); + } + if (me.status == MISSILE_FLYING) { + return; + } + if (me.Tgt == nil) { + me.printSearch("search commanded 1"); + me.return_to_search(); + return; + } + if (me.status == MISSILE_SEARCH) { + # Status = searching. + me.printSearch("search commanded 2"); + me.return_to_search(); + return; + } elsif ( me.status == MISSILE_STANDBY or me.status == MISSILE_STARTING) { + # Status = stand-by. + me.reset_seeker(); + me.SwSoundOnOff.setBoolValue(0); + me.SwSoundVol.setDoubleValue(0); + #me.trackWeak = 1; + me.standby(); + return; + } elsif (!me.Tgt.isValid()) { + # Lost of lock due to target disapearing: + # return to search mode. + me.printSearch("invalid"); + me.return_to_search(); + return; + } elsif (me.deleted) { + return; + } elsif (me.slave_to_radar and me.caged and me.getContact() != me.Tgt and !me.noCommonTarget) { + me.printSearch("target switch (%s to %s)", me.Tgt["getVirtualType"] != nil?me.Tgt.getVirtualType():"orig", me.getContact()==nil?"nil":(me.getContact()["getVirtualType"] != nil?me.getContact().getVirtualType():"orig")); + me.return_to_search(); + return; + } + me.printSearch("lock (caged:%d slave:%d point:%s same:%d noCommon:%d)",me.caged,me.slave_to_radar,contactPoint!=nil,me.getContact() == me.Tgt,me.noCommonTarget); + # Time interval since lock time or last track loop. + #if (me.status == MISSILE_LOCK) { + # Status = locked. Get target position relative to our aircraft. + + #} + + #me.time = props.globals.getNode("/sim/time/elapsed-sec", 1).getValue(); + + if(me.seam_support and me.uncage_auto) { + me.caged = 0; + } + me.coolingSyst(); + me.computeSeekerPos(); + if (me.status != MISSILE_STANDBY ) {#TODO: should this also check for starting up? + me.in_view = me.check_t_in_fov(); + + if (!me.in_view) { + me.printSearch("out of view"); + me.return_to_search(); + return; + } + + if (!me.caged or me.slave_to_radar) { + me.convertGlobalToSeekerViewDirection(me.Tgt.get_bearing(), me.Tgt.getElevation(), OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + # Notice: seeker_xxxx_target is used both for denoting where seeker should move towards and where the target is. In this case its both: + me.moveSeeker(); + } elsif (!me.slave_to_radar) { + if (me.seam_scan and me.guidance == "heat") { + me.nutateSeeker(PATTERN_CIRCLE, me.command_dir_heading, me.command_dir_pitch); + } else { + me.seeker_elev_target = me.command_dir_pitch; + me.seeker_head_target = me.command_dir_heading; + # Notice: seeker_xxxx_target is used both for denoting where seeker should move towards and where the target is. In this case its the former: + me.moveSeeker(); + } + } + + # Notice: seeker_xxxx_target is used both for denoting where seeker should move towards and where the target is. In this case its the latter: + me.convertGlobalToSeekerViewDirection(me.Tgt.get_bearing(), me.Tgt.getElevation(), OurHdg.getValue(), OurPitch.getValue(), OurRoll.getValue()); + me.testSeeker(); + if (!me.inBeam or (me.guidance == "semi-radar" and !me.is_painted(me.Tgt))) { + me.printSearch("out of beam or no beam for fox 1"); + me.status = MISSILE_SEARCH; + me.Tgt = nil; + me.SwSoundOnOff.setBoolValue(1); + me.SwSoundVol.setDoubleValue(me.vol_search); + settimer(func me.search(), 0.1); + return; + } + + me.dist = geo.aircraft_position().direct_distance_to(me.Tgt.get_Coord()); + + me.SwSoundOnOff.setBoolValue(1); + me.SwSoundVol.setDoubleValue(me.vol_track); + + if (!me.noCommonTarget and me.slave_to_radar) { + me.slaveContact = nil; + if (size(me.contacts) == 0) { + me.slaveContact = me.getContact(); + } else { + me.slaveContact = me.contacts[0]; + } + if (me.slaveContact == nil or me.slaveContact != me.Tgt or (me.slaveContact.getUnique() != nil and me.Tgt.getUnique() != nil and me.slaveContact.getUnique() != me.Tgt.getUnique())) { + me.printSearch("Radar/TGP system lock updated, dropping this lock.."); + me.return_to_search(); + return; + } + } + + settimer(func me.update_lock(), deltaSec.getValue()==0?0.5:0.1); + return; + } + me.standby(); + return; + }, + + return_to_search: func { + me.status = MISSILE_SEARCH; + me.Tgt = nil; + me.SwSoundOnOff.setBoolValue(1); + me.SwSoundVol.setDoubleValue(me.vol_search); + #me.trackWeak = 1; + me.reset_seeker(); + settimer(func me.search(), 0.1); + }, + + ################################################################### + # end loops for before flying. + ################################################################### + + FOV_check: func (meHeading, mePitch, deviation_hori, deviation_elev, fov_radius, vect) { + # we measure the geodesic angle between current attitude and the attitude to target. We pass vector math since this method is called both during multi-threading and not. + me.meVector = vect.eulerToCartesian3X(-meHeading, mePitch, 0); + me.itVector = vect.eulerToCartesian3X(-(meHeading+deviation_hori), mePitch+deviation_elev, 0); + me.fov_radial = vect.angleBetweenVectors(me.meVector, me.itVector); + #me.fov_radial = math.sqrt(math.pow(deviation_hori,2)+math.pow(deviation_elev,2)); + if (me.fov_radial <= fov_radius) { + return 1; + } + # out of FOV + #if (me.status==MISSILE_FLYING) printf("1: %.1f out of %.1f, deviation %.1f, %.1f", me.fov_radial, fov_radius, deviation_hori, deviation_elev); + return 0; + }, + + FOV_check_norm: func (meHeading, mePitch, deviation_hori, deviation_elev, fov_radius,vect) { + # we measure the geodesic angle between current attitude and the attitude to target. + me.meVector = vect.eulerToCartesian3X(-meHeading, mePitch, 0); + me.itVector = vect.eulerToCartesian3X(-(meHeading+deviation_hori), mePitch+deviation_elev, 0); + me.fov_radial = vect.angleBetweenVectors(me.meVector, me.itVector); + #me.fov_radial = math.sqrt(math.pow(deviation_hori,2)+math.pow(deviation_elev,2)); + if (fov_radius == 0) return -1; + #if (me.status==MISSILE_FLYING) printf("2: %.1f out of %.1f, deviation %.1f, %.1f", me.fov_radial, fov_radius, deviation_hori, deviation_elev); + return me.fov_radial/fov_radius; + }, + + check_t_in_fov: func { + # called only before firing + me.total_elev = deviation_normdeg(OurPitch.getValue(), me.Tgt.getElevation()); # deg. + me.total_horiz = deviation_normdeg(OurHdg.getValue(), me.Tgt.get_bearing()); # deg. + # Check if in range and in the seeker FOV. + if (me.FOV_check(OurHdg.getValue(),OurPitch.getValue(),me.total_horiz, me.total_elev, me.slave_to_radar?(me.guidance == "heat" or me.guidance == "vision"?math.min(me.max_seeker_dev, me.fcs_fov):me.fcs_fov):me.max_seeker_dev, vector.Math) and me.Tgt.get_range() < me.max_fire_range_nm and me.Tgt.get_range() > me.getCurrentMinFireRange(me.Tgt) + and (me.Tgt.get_range() < me.detect_range_curr_nm or (me.guidance != "radar" and me.guidance != "semi-radar" and me.guidance != "tvm" and me.guidance != "sample" and me.guidance != "heat" and me.guidance != "vision" and me.guidance != "heat" and me.guidance != "radiation"))) { + return 1; + } + # Target out of FOV or range while still not launched, return to search loop. + return 0; + }, + + is_painted: func (target) { + if(target != nil) { + me.hasPaint = target.isPainted(); + if(me.hasPaint != nil and me.hasPaint) { + return 1; + } + } + return 0; + }, + + is_laser_painted: func (target) { + if(target != nil) { + me.hasPaint = target.isLaserPainted(); + if(me.hasPaint != nil and me.hasPaint) { + return 1; + } + } + return 0; + }, + + is_radiating_me: func (target) { + if(target != nil) { + me.seeMe = target.isRadiating(me.coord); + if (me.seeMe != nil and me.seeMe) { + return 1; + } + } + return 0; + }, + + is_radiating_aircraft: func (target) { + if(target != nil) { + me.seeMe = target.isRadiating(geo.aircraft_position()); + if (me.seeMe != nil and me.seeMe) { + return 1; + } + } + return 0; + }, + + reset_seeker: func { + #me.printSearch("Reset seeker"); + me.seeker_elev_target = 0; + me.seeker_head_target = 0; + me.moveSeeker(); + }, + + clamp_min_max: func (v, mm) { + if ( v < -mm ) { + v = -mm; + } elsif ( v > mm ) { + v = mm; + } + return(v); + }, + + clamp: func(v, min, max) { v < min ? min : v > max ? max : v }, + + animation_flags_props: func { + # Create animation flags properties. + var path_base = "payload/armament/"~me.type_lc~"/flags/"; + + var msl_path = path_base~"msl-id-" ~ me.ID; + me.msl_prop = props.globals.initNode( msl_path, 1, "BOOL", 1); + me.msl_prop.setBoolValue(1);# this is cause it might already exist, and so need to force value + + var smoke_path = path_base~"smoke-id-" ~ me.ID; + me.smoke_prop = props.globals.initNode( smoke_path, 0, "BOOL", 1); + + var explode_path = path_base~"explode-id-" ~ me.ID; + me.explode_prop = props.globals.initNode( explode_path, 0, "BOOL", 1); + + var explode_smoke_path = path_base~"explode-smoke-id-" ~ me.ID; + me.explode_smoke_prop = props.globals.initNode( explode_smoke_path, 0, "BOOL", 1); + + var explode_water_path = path_base~"explode-water-id-" ~ me.ID; + me.explode_water_prop = props.globals.initNode( explode_water_path, 0, "BOOL", 1); + + var explode_angle_path = path_base~"explode-angle"; + me.explode_angle_prop = props.globals.initNode( explode_angle_path, 0.0, "DOUBLE", 1); + + var explode_sound_path = "payload/armament/flags/explode-sound-on-" ~ me.ID;; + me.explode_sound_prop = props.globals.initNode( explode_sound_path, 0, "BOOL", 1); + + var explode_sound_vol_path = "payload/armament/flags/explode-sound-vol-" ~ me.ID;; + me.explode_sound_vol_prop = props.globals.initNode( explode_sound_vol_path, 0, "DOUBLE", 1); + + var deploy_path = path_base~"deploy-id-" ~ me.ID; + me.deploy_prop = props.globals.initNode(deploy_path, 0, "DOUBLE", 1); + }, + + animate_explosion: func (hitGround) { + # + # a last position update to where the explosion happened: + # + me.latN.setDoubleValue(me.coord.lat()); + me.lonN.setDoubleValue(me.coord.lon()); + me.altN.setDoubleValue(me.coord.alt()*M2FT); + me.pitchN.setDoubleValue(0);# this will make explosions from cluster bombs (like M90) align to ground 'sorta'. + me.rollN.setDoubleValue(0);# this will make explosions from cluster bombs (like M90) align to ground 'sorta'. + me.msl_prop.setBoolValue(0); + me.smoke_prop.setBoolValue(0); + var info = geodinfo(me.coord.lat(), me.coord.lon()); + + if (hitGround) { + if (info == nil) { + me.explode_water_prop.setBoolValue(0); + } elsif (info[1] == nil) { + #print ("Building hit!"); + } elsif (!info[1].solid) { + me.explode_water_prop.setBoolValue(1); + } else { + me.explode_water_prop.setBoolValue(0); + } + } else { + me.explode_water_prop.setBoolValue(0); + } + + #print (me.typeShort); + + me.explode_prop.setBoolValue(1); + me.explode_angle_prop.setDoubleValue((rand() - 0.5) * 50); + thread.lock(mutexTimer); + append(AIM.timerQueue, [me, func me.explode_prop.setBoolValue(0), [], 0.5]); + append(AIM.timerQueue, [me, func me.explode_smoke_prop.setBoolValue(1), [], 0.5]); + append(AIM.timerQueue, [me, func {me.explode_smoke_prop.setBoolValue(0);if (me.first and size(keys(AIM.flying))>1) {me.resetFirst();}}, [], 3]); + thread.unlock(mutexTimer); + if (info == nil or !hitGround or getprop("payload/armament/enable-craters") == nil or !getprop("payload/armament/enable-craters")) {return;}; + thread.lock(mutexTimer); + append(AIM.timerQueue, [me, func { + if (info[1] == nil) { + #print ("Building hit..smoking"); + var static = geo.put_model(getprop("payload/armament/models") ~ "bomb_hit_smoke.xml", me.coord.lat(), me.coord.lon()); + if(getprop("payload/armament/msg") and info[0] != nil) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.notifyCrater, [me.coord.lat(), me.coord.lon(), info[0], 2, 0, static], 0]); + thread.unlock(mutexTimer); + } + } else if ((info[1] != nil) and info[1].solid) { + var crater_model = ""; + var siz = -1; + if (me.weight_whead_lbm < 850 and (me.target_sea or me.target_gnd)) { + crater_model = getprop("payload/armament/models") ~ "crater_small.xml"; + siz = 0; + #print("small crater"); + } elsif (me.target_sea or me.target_gnd) { + #print("big crater"); + siz = 1; + crater_model = getprop("payload/armament/models") ~ "crater_big.xml"; + } + + if (crater_model != "" and me.weight_whead_lbm > 150) { + var static = geo.put_model(crater_model, me.coord.lat(), me.coord.lon()); + #print("put crater"); + if(getprop("payload/armament/msg") and info[0] != nil) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [AIM, AIM.notifyCrater, [me.coord.lat(), me.coord.lon(),info[0],siz, 0, static], 0]); + thread.unlock(mutexTimer); + } + } + } + }, [], 0.5]); + thread.unlock(mutexTimer); + }, + + animate_dud: func { + # + # a last position update to where the impact happened: + # + me.latN.setDoubleValue(me.coord.lat()); + me.lonN.setDoubleValue(me.coord.lon()); + me.altN.setDoubleValue(me.coord.alt()*M2FT); + #me.pitchN.setDoubleValue(0); uncomment this to let it lie flat on ground, instead of sticking its nose in it. + me.smoke_prop.setBoolValue(0); + }, + + sndPropagate: func { + var dt = deltaSec.getValue(); + if (dt == 0) { + #FG is likely paused + settimer(func me.sndPropagate(), 0.01); + return; + } + #dt = update_loop_time; + var elapsed = systime(); + if (me.elapsed_last_snd != 0) { + dt = (elapsed - me.elapsed_last_snd) * speedUp.getValue(); + } + me.elapsed_last_snd = elapsed; + + me.ac = geo.aircraft_position(); + var distance = me.coord.direct_distance_to(me.ac); + + me.sndDistance = me.sndDistance + (me.sndSpeed * dt) * FT2M; + if(me.sndDistance > distance) { + var volume = math.pow(math.e,(-.00025*(distance-1000))); + me.printStats(me.type~": Explosion heard "~distance~"m vol:"~volume); + me.explode_sound_vol_prop.setDoubleValue(volume); + me.explode_sound_prop.setBoolValue(1); + settimer( func me.explode_sound_prop.setBoolValue(0), 3); + settimer( func me.del(), 4); + return; + } elsif (me.sndDistance > 5000) { + settimer(func { me.del(); }, 4 ); + return;#TODO: I added this return recently, but not sure why it wasn't there.. + } else { + settimer(func me.sndPropagate(), 0.05); + return; + } + }, + + steering_speed_G_old: func(meHeading, mePitch,steering_e_deg, steering_h_deg, s_fps, dt) { + # Get G number from steering (e, h) in deg, speed in ft/s. + me.meVector = me.myMath.eulerToCartesian3X(-meHeading, mePitch, 0); + me.itVector = me.myMath.eulerToCartesian3X(-(meHeading+steering_h_deg), mePitch+steering_e_deg, 0); + me.steer_deg = me.myMath.angleBetweenVectors(me.meVector, me.itVector); + + # next speed vector + me.vector_next_x = math.cos(me.steer_deg*D2R)*s_fps; + me.vector_next_y = math.sin(me.steer_deg*D2R)*s_fps; + + # present speed vector + me.vector_now_x = s_fps; + me.vector_now_y = 0; + + # Delta velocity: subtract the vectors from each other and get the magnitude + me.dv = me.myMath.minus([me.vector_now_x,me.vector_now_y,0],[me.vector_next_x,me.vector_next_y,0]); + me.dv = me.myMath.magnitudeVector(me.dv); + + # calculate g-force + # dv/dt=a + me.g = (me.dv/dt) / g_fps; + + return me.g; + }, + + steering_speed_G: func(meHeading, mePitch, steering_e_deg, steering_h_deg, s_fps, dt) { + # Get G number from steering (e, h) in deg, speed in ft/s. + me.meVector = me.myMath.eulerToCartesian3X(-meHeading, mePitch, 0); + me.meVectorN= me.myMath.normalize(me.meVector); + me.meVector = me.myMath.product(s_fps, me.meVectorN);#velocity vector now + me.itVector = me.myMath.eulerToCartesian3X(-(meHeading+steering_h_deg), mePitch+steering_e_deg, 0); + me.itVector = me.myMath.normalize(me.itVector); + me.itVector = me.myMath.product(s_fps, me.itVector);#velocity vector if doing that steering + + # Delta lateral velocity + me.dv = me.myMath.minus(me.itVector, me.meVector); + me.dv = me.myMath.projVectorOnPlane(me.meVectorN, me.dv); + me.dv = me.myMath.magnitudeVector(me.dv); + + # calculate g-force + # dv/dt=a + me.g = (me.dv/dt) / g_fps; + + return me.g; + }, + + overload_limiter: func(meHeading, mePitch, steering_e_deg, steering_h_deg, s_fps, dt, gMax) { + # The missile desires to rotate a certain amount + # This function will limit that steering to prevent it from exceeding the max G it should be able to do at this air density + + if (gMax == 0 or (steering_e_deg == 0 and steering_h_deg == 0)) { + return [0,0]; + } + + # Get G number from steering (e, h) in deg, speed in ft/s. + me.meVector = me.myMath.eulerToCartesian3X(-meHeading, mePitch, 0); + me.meVectorN= me.myMath.normalize(me.meVector); + me.meVector = me.myMath.product(s_fps, me.meVectorN);#velocity vector now + me.itVector = me.myMath.eulerToCartesian3X(-(meHeading+steering_h_deg), mePitch+steering_e_deg, 0); + me.itVectorN= me.myMath.normalize(me.itVector); + me.itVector = me.myMath.product(s_fps, me.itVectorN);#velocity vector if doing that steering + + # Delta lateral velocity + me.dvAcc = me.myMath.minus(me.itVector, me.meVector); + me.dv = me.myMath.projVectorOnPlane(me.meVectorN, me.dvAcc); + me.dv = me.myMath.magnitudeVector(me.dv); + + # calculate g-force + # dv/dt=a + me.g_load = (me.dv/dt) / g_fps; + + me.exceed_g = gMax/me.g_load; + + if (me.exceed_g >= 1) { + return [steering_h_deg, steering_e_deg]; + } + + # Now do something that works okay for small desired steerings, but fails for big steerings. Hence the 0.9 factor. + me.dvAcc9 = me.myMath.product(me.exceed_g*0.9, me.dvAcc); + me.itVector = me.myMath.plus(me.dvAcc9, me.meVector); + + me.euler = me.myMath.cartesianToEuler(me.itVector); + + if (me.euler[0] == nil) { + me.euler[0] = meHeading; + } + + return [geo.normdeg180(me.euler[0]-meHeading), me.euler[1]-mePitch]; + }, + + max_G_Rotation_old: func(steering_e_deg, steering_h_deg, s_fps, dt, gMax) { + # The missile desires to rotate a certain amount + # This function will limit that steering to prevent it from exceeding the max G it should be able to do at this air density + me.guess = 1; + me.coef = 1; + me.lastgoodguess = 1; + + for(var i=1;i<25;i+=1){ + me.coef = me.coef/2; + me.new_g = me.steering_speed_G(me.hdg, me.pitch, steering_e_deg*me.guess, steering_h_deg*me.guess, s_fps, dt); + if (me.new_g < gMax) { + me.lastgoodguess = me.guess; + me.guess = me.guess + me.coef; + } else { + me.guess = me.guess - me.coef; + } + } + return me.lastgoodguess; + }, + + nextGeoloc: func(lat, lon, heading, speed, dt, alt=100) { + # lng & lat & heading, in degree, speed in fps + # this function should send back the futures lng lat + me.distanceN = speed * dt * FT2M; # should be a distance in meters + #me.print("distance ", distance); + # much simpler than trigo + me.NextGeo = geo.Coord.new().set_latlon(lat, lon, alt); + me.NextGeo.apply_course_distance(heading, me.distanceN); + return me.NextGeo; + }, + + rho_sndspeed: func(altitude) { + # Calculate density of air: rho + # at altitude (ft), using standard atmosphere, + # standard temperature T and pressure p. + + me.T = 0; + me.p = 0; + if (altitude < 36152) { + # curve fits for the troposphere + me.T = 59 - 0.00356 * altitude; + me.p = 2116 * math.pow( ((me.T + 459.7) / 518.6) , 5.256); + } elsif ( 36152 < altitude and altitude < 82345 ) { + # lower stratosphere + me.T = -70; + me.p = 473.1 * math.pow( math.e , 1.73 - (0.000048 * altitude) ); + } else { + # upper stratosphere + me.T = -205.05 + (0.00164 * altitude); + me.p = 51.97 * math.pow( ((me.T + 459.7) / 389.98) , -11.388); + } + + me.rho = me.p / (1718 * (me.T + 459.7)); + + # calculate the speed of sound at altitude + # a = sqrt ( g * R * (T + 459.7)) + # where: + # snd_speed in feet/s, + # g = specific heat ratio, which is usually equal to 1.4 + # R = specific gas constant, which equals 1716 ft-lb/slug/R + + me.snd_speed = math.sqrt( 1.4 * 1716 * (me.T + 459.7)); + return [me.rho, me.snd_speed]; + + }, + + printFlight: func { + if (DEBUG_FLIGHT) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printFlightDetails: func { + if (DEBUG_FLIGHT_DETAILS) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printStats: func { + if (DEBUG_STATS) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printStatsDetails: func { + if (DEBUG_STATS_DETAILS) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printGuide: func { + if (DEBUG_GUIDANCE) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printGuideDetails: func { + if (DEBUG_GUIDANCE_DETAILS) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printCode: func { + if (DEBUG_CODE) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printSearch: func { + if (DEBUG_SEARCH) { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + } + }, + + printAlways: func { + thread.lock(mutexTimer); + append(AIM.timerQueue, [nil, printff, arg, -1]); + thread.unlock(mutexTimer); + }, + + timerLoop: func { + thread.lock(mutexTimer); + AIM.tq = AIM.timerQueue; + AIM.timerQueue = []; + thread.unlock(mutexTimer); + foreach(var cmd; AIM.tq) { + AIM.timerCall(cmd); + } + }, + + timerCall: func (cmd) { + if (cmd != nil) { + if (cmd[3] == -1) { + call(cmd[1], cmd[2], cmd[0], nil, var err = []); + debug.printerror(err); + } else { + var code = "timer_"~rand(); + var tr = maketimer(cmd[3], cmd[0], func {call(cmd[1], cmd[2], cmd[0], nil, var err = []);debug.printerror(err);delete(AIM.timers, code);}); + tr.singleShot = 1; + tr.start(); + AIM.timers[code] = tr; + } + } + }, + + pop_front: func (vector) { + if (size(vector)==0) return [nil, vector]; + var new_vector = []; + var first = 1; + foreach (i;vector) { + if (first) continue; + append(new_vector, i); + } + return [vector[0],new_vector]; + }, + + timers: {}, + + timerQueue: [], + + active: {}, + flying: {}, + + setETA: func (eta, prev = -1) { + # Class method + thread.lock(mutexETA); + if (eta == -1 and prev == AIM.lowestETA) { + AIM.lowestETA = nil; + } elsif (eta == nil) { + AIM.lowestETA = nil; + } elsif (AIM.lowestETA == nil or eta < AIM.lowestETA and eta < 1800) { + AIM.lowestETA = eta; + } + thread.unlock(mutexETA); + }, + getETA: func { + # Class method + var retur = 0; + thread.lock(mutexETA); + retur = AIM.lowestETA; + thread.unlock(mutexETA); + return retur; + }, + + setModelAdded: func { + setprop("ai/models/model-added", me.ai.getPath()); + }, + + setModelRemoved: func { + setprop("ai/models/model-removed", me.ai.getPath()); + }, +}; +var backtrace = func(desc = nil, dump_vars = 1, skip_level = 0, levels = 3) { + var d = (desc == nil) ? "" : " '" ~ desc ~ "'"; + print(""); + print(_title("### backtrace" ~ d ~ " ###")); + skip_level += 1; + for (var i = skip_level; i virtual HUD screen. + var h_dev = eye_hud_m / ( math.sin(dev_rad) / math.cos(dev_rad) ); + var v_dev = eye_hud_m / ( math.sin(elev_rad) / math.cos(elev_rad) ); + # Angle between HUD center/top <-> HUD center/symbol position. + # -90° left, 0° up, 90° right, +/- 180° down. + var dev_deg = math.atan2( h_dev, v_dev ) * R2D; + # Correction with own a/c roll. + var combined_dev_deg = dev_deg; + # Lenght HUD center <-> symbol pos on the HUD: + var combined_dev_length = math.sqrt((h_dev*h_dev)+(v_dev*v_dev)); + # clamp and squeeze the top of the display area so the symbol follow the egg shaped HUD limits. + var abs_combined_dev_deg = math.abs( combined_dev_deg ); + var clamp = hud_radius_m; + if ( abs_combined_dev_deg >= 0 and abs_combined_dev_deg < 90 ) { + var coef = ( 90 - abs_combined_dev_deg ) * 0.00075; + if ( coef > 0.050 ) { coef = 0.050 } + clamp -= coef; + } + if ( combined_dev_length > clamp ) { + combined_dev_length = clamp; + clamped = 1; + } + var v = [combined_dev_deg, combined_dev_length, clamped]; + return(v); +} + +#was in radar +var deviation_normdeg = func(our_heading, target_bearing) { + var dev_norm = geo.normdeg180(target_bearing-our_heading); + return dev_norm; +} + +# +# this code make sure messages don't trigger the MP spam filter: + +var spams = 0; +var spamList = []; +var mutexMsg = thread.newlock(); +var mutexTimer = thread.newlock(); +var mutexETA = thread.newlock(); + +var defeatSpamFilter = func (str) { + thread.lock(mutexMsg); + spams += 1; + if (spams == 15) { + spams = 1; + } + str = str~":"; + for (var i = 1; i <= spams; i+=1) { + str = str~"."; + } + var myCallsign = getprop("sim/multiplay/callsign"); + if (myCallsign != nil and find(myCallsign, str) != -1) { + str = myCallsign~": "~str; + } + var newList = [str]; + for (var i = 0; i < size(spamList); i += 1) { + append(newList, spamList[i]); + } + spamList = newList; + thread.unlock(mutexMsg); +} + +var spamLoop = func { + thread.lock(mutexMsg); + var spam = pop(spamList); + thread.unlock(mutexMsg); + if (spam != nil) { + setprop("/sim/multiplay/chat", spam); + } + settimer(spamLoop, 1.20); +} + +var printff = func{ + var str = call(sprintf, arg,nil,nil,var err = []);#call to printf directly sometimes crashes FG + debug.printerror(err); + print(str); +} + +spamLoop(); +var timerLooper = maketimer(0, AIM, AIM.timerLoop); +timerLooper.start(); diff --git a/BUK-M2/Nasal/radar-logic.nas b/BUK-M2/Nasal/radar-logic.nas new file mode 100644 index 0000000..6b92c8b --- /dev/null +++ b/BUK-M2/Nasal/radar-logic.nas @@ -0,0 +1,427 @@ +var clamp = func(v, min, max) { v < min ? min : v > max ? max : v } +var encode3bits = func(first, second, third) { + var integer = first; + integer = integer + 2 * second; + integer = integer + 4 * third; + return integer; +} +var versionString = getprop("sim/version/flightgear"); +var version = split(".", versionString); +var major = num(version[0]); +var minor = num(version[1]); +var pica = num(version[2]); +var pickingMethod = 0; +if ((major == 2017 and minor == 2 and pica >= 1) or (major == 2017 and minor > 2) or major > 2017) { + pickingMethod = 1; +} + +var AIR = 0; +var MARINE = 1; +var SURFACE = 2; +var ORDNANCE = 3; + +var Contact = { + # For now only used in guided missiles, to make it compatible with Mirage 2000-5. + new: func(c, class) { + var obj = { parents : [Contact]}; +#debug.benchmark("radar process1", func { + obj.rdrProp = c.getNode("radar"); + obj.oriProp = c.getNode("orientation"); + obj.velProp = c.getNode("velocities"); + obj.posProp = c.getNode("position"); + obj.heading = obj.oriProp.getNode("true-heading-deg"); +#}); +#debug.benchmark("radar process2", func { + obj.alt = obj.posProp.getNode("altitude-ft"); + obj.lat = obj.posProp.getNode("latitude-deg"); + obj.lon = obj.posProp.getNode("longitude-deg"); +#}); +#debug.benchmark("radar process3", func { + #As it is a geo.Coord object, we have to update lat/lon/alt ->and alt is in meters + obj.coord = geo.Coord.new(); + obj.coord.set_latlon(obj.lat.getValue(), obj.lon.getValue(), obj.alt.getValue() * FT2M); +#}); +#debug.benchmark("radar process4", func { + obj.pitch = obj.oriProp.getNode("pitch-deg"); + obj.roll = obj.oriProp.getNode("roll-deg"); + obj.speed = obj.velProp.getNode("true-airspeed-kt"); + obj.vSpeed = obj.velProp.getNode("vertical-speed-fps"); + obj.callsign = c.getNode("callsign", 1); + obj.shorter = c.getNode("model-shorter"); + obj.orig_callsign = obj.callsign.getValue(); + obj.name = c.getNode("name"); + obj.sign = c.getNode("sign",1); + obj.valid = c.getNode("valid"); + obj.painted = c.getNode("painted"); + obj.unique = c.getNode("unique"); + obj.validTree = 0; +#}); +#debug.benchmark("radar process5", func { + #obj.transponderID = c.getNode("instrumentation/transponder/transmitted-id"); +#}); +#debug.benchmark("radar process6", func { + obj.acType = c.getNode("sim/model/ac-type"); + obj.type = c.getName(); + obj.index = c.getIndex(); + obj.string = "ai/models/" ~ obj.type ~ "[" ~ obj.index ~ "]"; + obj.shortString = obj.type ~ "[" ~ obj.index ~ "]"; +#}); +#debug.benchmark("radar process7", func { + obj.range = obj.rdrProp.getNode("range-nm"); + obj.bearing = obj.rdrProp.getNode("bearing-deg"); + obj.elevation = obj.rdrProp.getNode("elevation-deg"); + obj.ubody = obj.rdrProp.getNode("velocities/uBody-fps"); + obj.vbody = obj.rdrProp.getNode("velocities/vBody-fps"); + obj.wbody = obj.rdrProp.getNode("velocities/wBody-fps"); +#}); + obj.deviation = nil; + + obj.node = c; + obj.class = class; + + obj.polar = [0,0]; + obj.cartesian = [0,0]; + + return obj; + }, + + get_uBody: func { + var body = nil; + if (me.ubody != nil) { + body = me.ubody.getValue(); + } + if(body == nil) { + body = me.get_Speed()*KT2FPS; + } + return body; + }, + + get_vBody: func { + var body = nil; + if (me.ubody != nil) { + body = me.vbody.getValue(); + } + if(body == nil) { + body = 0; + } + return body; + }, + + get_wBody: func { + var body = nil; + if (me.ubody != nil) { + body = me.wbody.getValue(); + } + if(body == nil) { + body = 0; + } + return body; + }, + + isValid: func () { + var valid = me.valid.getValue(); + if (valid == nil) { + valid = 0; + } + if (me.callsign.getValue() != me.orig_callsign) { + valid = 0; + } + return valid; + }, + + isPainted: func () { + if (getprop("/carrier/sunk") == 1) { + return 0; + } + return isNotBehindTerrain(me.node)[0]; + }, + + isCommandActive: func { + if (getprop("/carrier/sunk") == 1) { + return 0; + } + return isNotBehindTerrain(me.node)[0]; + }, + + getUnique: func () { + if (me.unique == nil) { + me.unique = me.node.getNode("unique"); + } + if (me.unique == nil) { + return nil; + } + var u = me.unique.getValue(); + return u; + }, + + getElevation: func() { + var e = 0; + e = me.elevation.getValue(); + if(e == nil or e == 0) { + # AI/MP has no radar properties + var self = geo.aircraft_position(); + self.set_alt(self.alt()+fire_control.radar_elevation_above_terrain_m); + me.get_Coord(); + var angleInv = clamp(self.distance_to(me.coord)/self.direct_distance_to(me.coord), -1, 1); + e = (self.alt()>me.coord.alt()?-1:1)*math.acos(angleInv)*R2D; + } + return e; + }, + + getNode: func () { + return me.node; + }, + + getFlareNode: func () { + return me.node.getNode("rotors/main/blade[3]/flap-deg"); + }, + + getChaffNode: func () { + return me.node.getNode("rotors/main/blade[3]/position-deg"); + }, + + setPolar: func(dist, angle) { + me.polar = [dist,angle]; + }, + + setCartesian: func(x, y) { + me.cartesian = [x,y]; + }, + + remove: func(){ + if(me.validTree != 0){ + me.validTree.setValue(0); + } + }, + + get_Coord: func(){ + me.coord.set_latlon(me.lat.getValue(), me.lon.getValue(), me.alt.getValue() * FT2M); + var TgTCoord = geo.Coord.new(me.coord); + return TgTCoord; + }, + + get_Callsign: func(){ + var n = me.callsign.getValue(); + if(n != "" and n != nil) { + return n; + } + if (me.name == nil) { + me.name = me.getNode().getNode("name"); + } + if (me.name == nil) { + n = ""; + } else { + n = me.name.getValue(); + } + if(n != "" and n != nil) { + return n; + } + n = me.sign.getValue(); + if(n != "" and n != nil) { + return n; + } + return "UFO"; + }, + + get_model: func(){ + var n = ""; + if (me.shorter == nil) { + me.shorter = me.node.getNode("model-shorter"); + } + if (me.shorter != nil) { + n = me.shorter.getValue(); + } + if(n != "" and n != nil) { + return n; + } + n = me.sign.getValue(); + if(n != "" and n != nil) { + return n; + } + if (me.name == nil) { + me.name = me.getNode().getNode("name"); + } + if (me.name == nil) { + n = ""; + } else { + n = me.name.getValue(); + } + if(n != "" and n != nil) { + return n; + } + return me.get_Callsign(); + }, + + get_Speed: func(){ + # return true airspeed + var n = me.speed.getValue(); + return n; + }, + + get_Longitude: func(){ + var n = me.lon.getValue(); + return n; + }, + + get_Latitude: func(){ + var n = me.lat.getValue(); + return n; + }, + + get_Pitch: func(){ + var n = me.pitch.getValue(); + return n; + }, + + isVirtual: func(){ + return 0; + }, + + get_Roll: func(){ + var n = me.roll.getValue(); + return n; + }, + + get_heading : func(){ + var n = me.heading.getValue(); + if(n == nil) + { + n = 0; + } + return n; + }, + + get_bearing: func(){ + var n = 0; + n = me.bearing.getValue(); + if(n == nil or n == 0) { + # AI/MP has no radar properties + n = me.get_bearing_from_Coord(geo.aircraft_position()); + } + return n; + }, + + get_bearing_from_Coord: func(MyAircraftCoord){ + me.get_Coord(); + var myBearing = 0; + if(me.coord.is_defined()) { + myBearing = MyAircraftCoord.course_to(me.coord); + } + return myBearing; + }, + + get_reciprocal_bearing: func(){ + return geo.normdeg(me.get_bearing() + 180); + }, + + get_deviation: func(true_heading_ref, coord){ + me.deviation = - deviation_normdeg(true_heading_ref, me.get_bearing_from_Coord(coord)); + return me.deviation; + }, + + get_altitude: func(){ + #Return Alt in feet + return me.alt.getValue(); + }, + + get_Elevation_from_Coord: func(MyAircraftCoord) { + me.get_Coord(); + var value = (me.coord.alt() - MyAircraftCoord.alt()) / me.coord.direct_distance_to(MyAircraftCoord); + if (math.abs(value) > 1) { + # warning this else will fail if logged in as observer and see aircraft on other side of globe + return 0; + } + var myPitch = math.asin(value) * R2D; + return myPitch; + }, + + get_total_elevation_from_Coord: func(own_pitch, MyAircraftCoord){ + var myTotalElevation = - deviation_normdeg(own_pitch, me.get_Elevation_from_Coord(MyAircraftCoord)); + return myTotalElevation; + }, + + get_total_elevation: func(own_pitch) { + me.deviation = - deviation_normdeg(own_pitch, me.getElevation()); + return me.deviation; + }, + + get_range: func() { + var r = 0; + if(me.range == nil or me.range.getValue() == nil or me.range.getValue() == 0) { + # AI/MP has no radar properties + me.get_Coord(); + r = me.coord.direct_distance_to(geo.aircraft_position()) * M2NM; + } else { + r = me.range.getValue(); + } + return r; + }, + + get_range_from_Coord: func(MyAircraftCoord) { + var myCoord = me.get_Coord(); + var myDistance = 0; + if(myCoord.is_defined()) { + myDistance = MyAircraftCoord.direct_distance_to(myCoord) * M2NM; + } + return myDistance; + }, + + get_type: func () { + return me.class; + }, + + get_cartesian: func() { + return me.cartesian; + }, + + get_polar: func() { + return me.polar; + }, +}; + +var isNotBehindTerrain = func( mp ) { + var pos = mp.getNode("position"); + var alt = pos.getNode("altitude-ft").getValue(); + var lat = pos.getNode("latitude-deg").getValue(); + var lon = pos.getNode("longitude-deg").getValue(); + if(alt == nil or lat == nil or lon == nil) { + return [0,0]; # invisible and not in front of terrain + } + var aircraftPos = geo.Coord.new().set_latlon(lat, lon, alt*FT2M); + + var myPos = geo.aircraft_position(); + + myPos.set_alt(myPos.alt()+fire_control.radar_elevation_above_terrain_m); + + var target_distance = myPos.direct_distance_to(aircraftPos); + + call(func { + if (target_distance*0.001 > 3.57*(math.sqrt(myPos.alt())+math.sqrt(alt*FT2M))) { + # behind earth curvature + #print("behind earth curvature"); + return [0,0]; # invisible and not in front of terrain + } + },nil,nil,var err =[]); + + var xyz = {"x":myPos.x(), "y":myPos.y(), "z":myPos.z()}; + var dir = {"x":aircraftPos.x()-myPos.x(), "y":aircraftPos.y()-myPos.y(), "z":aircraftPos.z()-myPos.z()}; + + # Check for terrain between own aircraft and other: + v = get_cart_ground_intersection(xyz, dir); + if (v == nil) { + return [1,0]; # visible and not in front of terrain + #printf("No terrain, planes has clear view of each other"); + } else { + var terrain = geo.Coord.new(); + terrain.set_latlon(v.lat, v.lon, v.elevation); + var maxDist = myPos.direct_distance_to(aircraftPos); + var terrainDist = myPos.direct_distance_to(terrain); + if (terrainDist < maxDist-1) { + #printf("terrain found between me and aircraft %.1f meter away.", terrainDist); + return [0,0]; # visible and not in front of terrain + } else { + #print("The planes has clear view of each other"); + return [1,1]; # visible and in front of terrain + } + } +} \ No newline at end of file diff --git a/BUK-M2/Sounds/launch.wav b/BUK-M2/Sounds/launch.wav new file mode 100644 index 0000000..0b3c83b Binary files /dev/null and b/BUK-M2/Sounds/launch.wav differ diff --git a/BUK-M2/Sounds/sound.xml b/BUK-M2/Sounds/sound.xml new file mode 100644 index 0000000..31c9e6c --- /dev/null +++ b/BUK-M2/Sounds/sound.xml @@ -0,0 +1,25 @@ + + + + + + missile + Aircraft/BUK-M2/Sounds/launch.wav + once + + payload/armament/m317/sound-fire-on-off + + 50 + 15000 + + 0.01 + 0.01 + 0.01 + + + 1 + 1 + + + + diff --git a/BUK-M2/gui/dialogs/enemies.xml b/BUK-M2/gui/dialogs/enemies.xml new file mode 100644 index 0000000..67f39af --- /dev/null +++ b/BUK-M2/gui/dialogs/enemies.xml @@ -0,0 +1,348 @@ + + + enemies + false + vbox + true + true + 250 + 550 + + + hbox + 1 + + + + + + 1 + + + + + + + 25 + + + + 250 + 25 + + enemies/e1 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e2 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e3 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e4 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e5 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e6 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e7 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e8 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e9 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e10 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e11 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 250 + 25 + + enemies/e12 + true + left + + dialog-apply + + + 1 + 0.5 + 0.5 + + + + enemies/opfor-switch + + + enemies/friend-switch + + + + + 12 + 12 + /enemies/opfor-switch + + + dialog-apply + + + + 12 + 12 + /enemies/friend-switch + + + dialog-apply + + + \ No newline at end of file diff --git a/BUK-M2/gui/dialogs/prio.xml b/BUK-M2/gui/dialogs/prio.xml new file mode 100644 index 0000000..cabac21 --- /dev/null +++ b/BUK-M2/gui/dialogs/prio.xml @@ -0,0 +1,166 @@ + + + priority + false + vbox + true + false + 150 + 250 + + + 1 + hbox + + + + 1 + + + + table + + + right + 0 + 0 + + + 0 + 1 + priority0 + true + + nasal + + + + + + right + 1 + 0 + + + 1 + 1 + priority1 + true + + nasal + + + + + + right + 2 + 0 + + + 2 + 1 + priority2 + true + + nasal + + + + + + right + 3 + 0 + + + 3 + 1 + priority3 + true + + nasal + + + + + + right + 4 + 0 + + + 4 + 1 + priority4 + true + + nasal + + + + + + right + 5 + 0 + + + 5 + 1 + priority5 + true + + nasal + + + + + + right + 6 + 0 + + + 6 + 1 + priority6 + true + + nasal + + + + + 7 + 0 + 75 + 25 + + instrumentation/datalink/channel + true + right + + dialog-apply + + + 0.75 + 0.75 + 1.0 + + + + \ No newline at end of file