From 14579fb90ea12a09afcd5759a9649fd435cb2fda Mon Sep 17 00:00:00 2001 From: Nou Date: Tue, 14 Apr 2015 00:41:19 -0700 Subject: [PATCH] Explosive reflection, enabled on all frag rounds. --- addons/frag/CfgAmmo.hpp | 3 + addons/frag/CfgAmmoReflections.hpp | 2523 +++++++++++++++++ addons/frag/XEH_pre_Init.sqf | 4 + addons/frag/functions/fnc_doExplosions.sqf | 26 + addons/frag/functions/fnc_doReflections.sqf | 22 + addons/frag/functions/fnc_findReflections.sqf | 130 + addons/frag/functions/fnc_frago.sqf | 6 +- 7 files changed, 2712 insertions(+), 2 deletions(-) create mode 100644 addons/frag/CfgAmmoReflections.hpp create mode 100644 addons/frag/functions/fnc_doExplosions.sqf create mode 100644 addons/frag/functions/fnc_doReflections.sqf create mode 100644 addons/frag/functions/fnc_findReflections.sqf diff --git a/addons/frag/CfgAmmo.hpp b/addons/frag/CfgAmmo.hpp index 8ad76e6ae8..8d965e8d2e 100644 --- a/addons/frag/CfgAmmo.hpp +++ b/addons/frag/CfgAmmo.hpp @@ -8,6 +8,9 @@ class CfgAmmo { //class ace_arty_105mm_m1_m782_delay: ace_arty_105mm_m1_m782_prox { // ACE_FRAG_SKIP = 1; //}; + + #include "CfgAmmoReflections.hpp" + class Bo_GBU12_LGB; class Nou_GBU12 : Bo_GBU12_LGB { ACE_FRAG_CLASSES[] = {"ACE_frag_large", "ACE_frag_large", "ACE_frag_large_HD", "ACE_frag_large", "ACE_frag_huge", "ACE_frag_huge_HD", "ACE_frag_huge"}; diff --git a/addons/frag/CfgAmmoReflections.hpp b/addons/frag/CfgAmmoReflections.hpp new file mode 100644 index 0000000000..8e481a9cd0 --- /dev/null +++ b/addons/frag/CfgAmmoReflections.hpp @@ -0,0 +1,2523 @@ +//CfgAmmoReflections.hpp + +#define ACE_EXPLOSION_REFLECTION(range, hit) class ace_explosion_reflection_##range##_##hit : ace_explosion_reflection_base { indirectHitRange = range; indirectHit = hit; dangerRadiusHit = range*3; suppressionRadiusHit = range*2; }; +class Sh_120mm_HE; +class ace_explosion_reflection_base : Sh_120mm_HE { + CraterWaterEffects = ""; + CraterEffects = ""; + effectsMissile = ""; + ExplosionEffects = ""; + effectFlare = ""; + class HitEffects { + hitWater = ""; + }; + multiSoundHit[] = {}; + explosionTime = 0.0001; + explosive = 1; + soundFakeFall[] = {}; + typicalSpeed = 0; + model = "\A3\Weapons_F\empty.p3d"; + craterShape = "\A3\weapons_f\empty.p3d"; +}; + +ACE_EXPLOSION_REFLECTION(2,10); +ACE_EXPLOSION_REFLECTION(2,20); +ACE_EXPLOSION_REFLECTION(2,30); +ACE_EXPLOSION_REFLECTION(2,40); +ACE_EXPLOSION_REFLECTION(2,50); +ACE_EXPLOSION_REFLECTION(2,60); +ACE_EXPLOSION_REFLECTION(2,70); +ACE_EXPLOSION_REFLECTION(2,80); +ACE_EXPLOSION_REFLECTION(2,90); +ACE_EXPLOSION_REFLECTION(2,100); +ACE_EXPLOSION_REFLECTION(2,110); +ACE_EXPLOSION_REFLECTION(2,120); +ACE_EXPLOSION_REFLECTION(2,130); +ACE_EXPLOSION_REFLECTION(2,140); +ACE_EXPLOSION_REFLECTION(2,150); +ACE_EXPLOSION_REFLECTION(2,160); +ACE_EXPLOSION_REFLECTION(2,170); +ACE_EXPLOSION_REFLECTION(2,180); +ACE_EXPLOSION_REFLECTION(2,190); +ACE_EXPLOSION_REFLECTION(2,200); +ACE_EXPLOSION_REFLECTION(2,210); +ACE_EXPLOSION_REFLECTION(2,220); +ACE_EXPLOSION_REFLECTION(2,230); +ACE_EXPLOSION_REFLECTION(2,240); +ACE_EXPLOSION_REFLECTION(2,250); +ACE_EXPLOSION_REFLECTION(2,260); +ACE_EXPLOSION_REFLECTION(2,270); +ACE_EXPLOSION_REFLECTION(2,280); +ACE_EXPLOSION_REFLECTION(2,290); +ACE_EXPLOSION_REFLECTION(2,300); +ACE_EXPLOSION_REFLECTION(2,310); +ACE_EXPLOSION_REFLECTION(2,320); +ACE_EXPLOSION_REFLECTION(2,330); +ACE_EXPLOSION_REFLECTION(2,340); +ACE_EXPLOSION_REFLECTION(2,350); +ACE_EXPLOSION_REFLECTION(2,360); +ACE_EXPLOSION_REFLECTION(2,370); +ACE_EXPLOSION_REFLECTION(2,380); +ACE_EXPLOSION_REFLECTION(2,390); +ACE_EXPLOSION_REFLECTION(2,400); +ACE_EXPLOSION_REFLECTION(2,410); +ACE_EXPLOSION_REFLECTION(2,420); +ACE_EXPLOSION_REFLECTION(2,430); +ACE_EXPLOSION_REFLECTION(2,440); +ACE_EXPLOSION_REFLECTION(2,450); +ACE_EXPLOSION_REFLECTION(2,460); +ACE_EXPLOSION_REFLECTION(2,470); +ACE_EXPLOSION_REFLECTION(2,480); +ACE_EXPLOSION_REFLECTION(2,490); +ACE_EXPLOSION_REFLECTION(2,500); +ACE_EXPLOSION_REFLECTION(4,10); +ACE_EXPLOSION_REFLECTION(4,20); +ACE_EXPLOSION_REFLECTION(4,30); +ACE_EXPLOSION_REFLECTION(4,40); +ACE_EXPLOSION_REFLECTION(4,50); +ACE_EXPLOSION_REFLECTION(4,60); +ACE_EXPLOSION_REFLECTION(4,70); +ACE_EXPLOSION_REFLECTION(4,80); +ACE_EXPLOSION_REFLECTION(4,90); +ACE_EXPLOSION_REFLECTION(4,100); +ACE_EXPLOSION_REFLECTION(4,110); +ACE_EXPLOSION_REFLECTION(4,120); +ACE_EXPLOSION_REFLECTION(4,130); +ACE_EXPLOSION_REFLECTION(4,140); +ACE_EXPLOSION_REFLECTION(4,150); +ACE_EXPLOSION_REFLECTION(4,160); +ACE_EXPLOSION_REFLECTION(4,170); +ACE_EXPLOSION_REFLECTION(4,180); +ACE_EXPLOSION_REFLECTION(4,190); +ACE_EXPLOSION_REFLECTION(4,200); +ACE_EXPLOSION_REFLECTION(4,210); +ACE_EXPLOSION_REFLECTION(4,220); +ACE_EXPLOSION_REFLECTION(4,230); +ACE_EXPLOSION_REFLECTION(4,240); +ACE_EXPLOSION_REFLECTION(4,250); +ACE_EXPLOSION_REFLECTION(4,260); +ACE_EXPLOSION_REFLECTION(4,270); +ACE_EXPLOSION_REFLECTION(4,280); +ACE_EXPLOSION_REFLECTION(4,290); +ACE_EXPLOSION_REFLECTION(4,300); +ACE_EXPLOSION_REFLECTION(4,310); +ACE_EXPLOSION_REFLECTION(4,320); +ACE_EXPLOSION_REFLECTION(4,330); +ACE_EXPLOSION_REFLECTION(4,340); +ACE_EXPLOSION_REFLECTION(4,350); +ACE_EXPLOSION_REFLECTION(4,360); +ACE_EXPLOSION_REFLECTION(4,370); +ACE_EXPLOSION_REFLECTION(4,380); +ACE_EXPLOSION_REFLECTION(4,390); +ACE_EXPLOSION_REFLECTION(4,400); +ACE_EXPLOSION_REFLECTION(4,410); +ACE_EXPLOSION_REFLECTION(4,420); +ACE_EXPLOSION_REFLECTION(4,430); +ACE_EXPLOSION_REFLECTION(4,440); +ACE_EXPLOSION_REFLECTION(4,450); +ACE_EXPLOSION_REFLECTION(4,460); +ACE_EXPLOSION_REFLECTION(4,470); +ACE_EXPLOSION_REFLECTION(4,480); +ACE_EXPLOSION_REFLECTION(4,490); +ACE_EXPLOSION_REFLECTION(4,500); +ACE_EXPLOSION_REFLECTION(6,10); +ACE_EXPLOSION_REFLECTION(6,20); +ACE_EXPLOSION_REFLECTION(6,30); +ACE_EXPLOSION_REFLECTION(6,40); +ACE_EXPLOSION_REFLECTION(6,50); +ACE_EXPLOSION_REFLECTION(6,60); +ACE_EXPLOSION_REFLECTION(6,70); +ACE_EXPLOSION_REFLECTION(6,80); +ACE_EXPLOSION_REFLECTION(6,90); +ACE_EXPLOSION_REFLECTION(6,100); +ACE_EXPLOSION_REFLECTION(6,110); +ACE_EXPLOSION_REFLECTION(6,120); +ACE_EXPLOSION_REFLECTION(6,130); +ACE_EXPLOSION_REFLECTION(6,140); +ACE_EXPLOSION_REFLECTION(6,150); +ACE_EXPLOSION_REFLECTION(6,160); +ACE_EXPLOSION_REFLECTION(6,170); +ACE_EXPLOSION_REFLECTION(6,180); +ACE_EXPLOSION_REFLECTION(6,190); +ACE_EXPLOSION_REFLECTION(6,200); +ACE_EXPLOSION_REFLECTION(6,210); +ACE_EXPLOSION_REFLECTION(6,220); +ACE_EXPLOSION_REFLECTION(6,230); +ACE_EXPLOSION_REFLECTION(6,240); +ACE_EXPLOSION_REFLECTION(6,250); +ACE_EXPLOSION_REFLECTION(6,260); +ACE_EXPLOSION_REFLECTION(6,270); +ACE_EXPLOSION_REFLECTION(6,280); +ACE_EXPLOSION_REFLECTION(6,290); +ACE_EXPLOSION_REFLECTION(6,300); +ACE_EXPLOSION_REFLECTION(6,310); +ACE_EXPLOSION_REFLECTION(6,320); +ACE_EXPLOSION_REFLECTION(6,330); +ACE_EXPLOSION_REFLECTION(6,340); +ACE_EXPLOSION_REFLECTION(6,350); +ACE_EXPLOSION_REFLECTION(6,360); +ACE_EXPLOSION_REFLECTION(6,370); +ACE_EXPLOSION_REFLECTION(6,380); +ACE_EXPLOSION_REFLECTION(6,390); +ACE_EXPLOSION_REFLECTION(6,400); +ACE_EXPLOSION_REFLECTION(6,410); +ACE_EXPLOSION_REFLECTION(6,420); +ACE_EXPLOSION_REFLECTION(6,430); +ACE_EXPLOSION_REFLECTION(6,440); +ACE_EXPLOSION_REFLECTION(6,450); +ACE_EXPLOSION_REFLECTION(6,460); +ACE_EXPLOSION_REFLECTION(6,470); +ACE_EXPLOSION_REFLECTION(6,480); +ACE_EXPLOSION_REFLECTION(6,490); +ACE_EXPLOSION_REFLECTION(6,500); +ACE_EXPLOSION_REFLECTION(8,10); +ACE_EXPLOSION_REFLECTION(8,20); +ACE_EXPLOSION_REFLECTION(8,30); +ACE_EXPLOSION_REFLECTION(8,40); +ACE_EXPLOSION_REFLECTION(8,50); +ACE_EXPLOSION_REFLECTION(8,60); +ACE_EXPLOSION_REFLECTION(8,70); +ACE_EXPLOSION_REFLECTION(8,80); +ACE_EXPLOSION_REFLECTION(8,90); +ACE_EXPLOSION_REFLECTION(8,100); +ACE_EXPLOSION_REFLECTION(8,110); +ACE_EXPLOSION_REFLECTION(8,120); +ACE_EXPLOSION_REFLECTION(8,130); +ACE_EXPLOSION_REFLECTION(8,140); +ACE_EXPLOSION_REFLECTION(8,150); +ACE_EXPLOSION_REFLECTION(8,160); +ACE_EXPLOSION_REFLECTION(8,170); +ACE_EXPLOSION_REFLECTION(8,180); +ACE_EXPLOSION_REFLECTION(8,190); +ACE_EXPLOSION_REFLECTION(8,200); +ACE_EXPLOSION_REFLECTION(8,210); +ACE_EXPLOSION_REFLECTION(8,220); +ACE_EXPLOSION_REFLECTION(8,230); +ACE_EXPLOSION_REFLECTION(8,240); +ACE_EXPLOSION_REFLECTION(8,250); +ACE_EXPLOSION_REFLECTION(8,260); +ACE_EXPLOSION_REFLECTION(8,270); +ACE_EXPLOSION_REFLECTION(8,280); +ACE_EXPLOSION_REFLECTION(8,290); +ACE_EXPLOSION_REFLECTION(8,300); +ACE_EXPLOSION_REFLECTION(8,310); +ACE_EXPLOSION_REFLECTION(8,320); +ACE_EXPLOSION_REFLECTION(8,330); +ACE_EXPLOSION_REFLECTION(8,340); +ACE_EXPLOSION_REFLECTION(8,350); +ACE_EXPLOSION_REFLECTION(8,360); +ACE_EXPLOSION_REFLECTION(8,370); +ACE_EXPLOSION_REFLECTION(8,380); +ACE_EXPLOSION_REFLECTION(8,390); +ACE_EXPLOSION_REFLECTION(8,400); +ACE_EXPLOSION_REFLECTION(8,410); +ACE_EXPLOSION_REFLECTION(8,420); +ACE_EXPLOSION_REFLECTION(8,430); +ACE_EXPLOSION_REFLECTION(8,440); +ACE_EXPLOSION_REFLECTION(8,450); +ACE_EXPLOSION_REFLECTION(8,460); +ACE_EXPLOSION_REFLECTION(8,470); +ACE_EXPLOSION_REFLECTION(8,480); +ACE_EXPLOSION_REFLECTION(8,490); +ACE_EXPLOSION_REFLECTION(8,500); +ACE_EXPLOSION_REFLECTION(10,10); +ACE_EXPLOSION_REFLECTION(10,20); +ACE_EXPLOSION_REFLECTION(10,30); +ACE_EXPLOSION_REFLECTION(10,40); +ACE_EXPLOSION_REFLECTION(10,50); +ACE_EXPLOSION_REFLECTION(10,60); +ACE_EXPLOSION_REFLECTION(10,70); +ACE_EXPLOSION_REFLECTION(10,80); +ACE_EXPLOSION_REFLECTION(10,90); +ACE_EXPLOSION_REFLECTION(10,100); +ACE_EXPLOSION_REFLECTION(10,110); +ACE_EXPLOSION_REFLECTION(10,120); +ACE_EXPLOSION_REFLECTION(10,130); +ACE_EXPLOSION_REFLECTION(10,140); +ACE_EXPLOSION_REFLECTION(10,150); +ACE_EXPLOSION_REFLECTION(10,160); +ACE_EXPLOSION_REFLECTION(10,170); +ACE_EXPLOSION_REFLECTION(10,180); +ACE_EXPLOSION_REFLECTION(10,190); +ACE_EXPLOSION_REFLECTION(10,200); +ACE_EXPLOSION_REFLECTION(10,210); +ACE_EXPLOSION_REFLECTION(10,220); +ACE_EXPLOSION_REFLECTION(10,230); +ACE_EXPLOSION_REFLECTION(10,240); +ACE_EXPLOSION_REFLECTION(10,250); +ACE_EXPLOSION_REFLECTION(10,260); +ACE_EXPLOSION_REFLECTION(10,270); +ACE_EXPLOSION_REFLECTION(10,280); +ACE_EXPLOSION_REFLECTION(10,290); +ACE_EXPLOSION_REFLECTION(10,300); +ACE_EXPLOSION_REFLECTION(10,310); +ACE_EXPLOSION_REFLECTION(10,320); +ACE_EXPLOSION_REFLECTION(10,330); +ACE_EXPLOSION_REFLECTION(10,340); +ACE_EXPLOSION_REFLECTION(10,350); +ACE_EXPLOSION_REFLECTION(10,360); +ACE_EXPLOSION_REFLECTION(10,370); +ACE_EXPLOSION_REFLECTION(10,380); +ACE_EXPLOSION_REFLECTION(10,390); +ACE_EXPLOSION_REFLECTION(10,400); +ACE_EXPLOSION_REFLECTION(10,410); +ACE_EXPLOSION_REFLECTION(10,420); +ACE_EXPLOSION_REFLECTION(10,430); +ACE_EXPLOSION_REFLECTION(10,440); +ACE_EXPLOSION_REFLECTION(10,450); +ACE_EXPLOSION_REFLECTION(10,460); +ACE_EXPLOSION_REFLECTION(10,470); +ACE_EXPLOSION_REFLECTION(10,480); +ACE_EXPLOSION_REFLECTION(10,490); +ACE_EXPLOSION_REFLECTION(10,500); +ACE_EXPLOSION_REFLECTION(12,10); +ACE_EXPLOSION_REFLECTION(12,20); +ACE_EXPLOSION_REFLECTION(12,30); +ACE_EXPLOSION_REFLECTION(12,40); +ACE_EXPLOSION_REFLECTION(12,50); +ACE_EXPLOSION_REFLECTION(12,60); +ACE_EXPLOSION_REFLECTION(12,70); +ACE_EXPLOSION_REFLECTION(12,80); +ACE_EXPLOSION_REFLECTION(12,90); +ACE_EXPLOSION_REFLECTION(12,100); +ACE_EXPLOSION_REFLECTION(12,110); +ACE_EXPLOSION_REFLECTION(12,120); +ACE_EXPLOSION_REFLECTION(12,130); +ACE_EXPLOSION_REFLECTION(12,140); +ACE_EXPLOSION_REFLECTION(12,150); +ACE_EXPLOSION_REFLECTION(12,160); +ACE_EXPLOSION_REFLECTION(12,170); +ACE_EXPLOSION_REFLECTION(12,180); +ACE_EXPLOSION_REFLECTION(12,190); +ACE_EXPLOSION_REFLECTION(12,200); +ACE_EXPLOSION_REFLECTION(12,210); +ACE_EXPLOSION_REFLECTION(12,220); +ACE_EXPLOSION_REFLECTION(12,230); +ACE_EXPLOSION_REFLECTION(12,240); +ACE_EXPLOSION_REFLECTION(12,250); +ACE_EXPLOSION_REFLECTION(12,260); +ACE_EXPLOSION_REFLECTION(12,270); +ACE_EXPLOSION_REFLECTION(12,280); +ACE_EXPLOSION_REFLECTION(12,290); +ACE_EXPLOSION_REFLECTION(12,300); +ACE_EXPLOSION_REFLECTION(12,310); +ACE_EXPLOSION_REFLECTION(12,320); +ACE_EXPLOSION_REFLECTION(12,330); +ACE_EXPLOSION_REFLECTION(12,340); +ACE_EXPLOSION_REFLECTION(12,350); +ACE_EXPLOSION_REFLECTION(12,360); +ACE_EXPLOSION_REFLECTION(12,370); +ACE_EXPLOSION_REFLECTION(12,380); +ACE_EXPLOSION_REFLECTION(12,390); +ACE_EXPLOSION_REFLECTION(12,400); +ACE_EXPLOSION_REFLECTION(12,410); +ACE_EXPLOSION_REFLECTION(12,420); +ACE_EXPLOSION_REFLECTION(12,430); +ACE_EXPLOSION_REFLECTION(12,440); +ACE_EXPLOSION_REFLECTION(12,450); +ACE_EXPLOSION_REFLECTION(12,460); +ACE_EXPLOSION_REFLECTION(12,470); +ACE_EXPLOSION_REFLECTION(12,480); +ACE_EXPLOSION_REFLECTION(12,490); +ACE_EXPLOSION_REFLECTION(12,500); +ACE_EXPLOSION_REFLECTION(14,10); +ACE_EXPLOSION_REFLECTION(14,20); +ACE_EXPLOSION_REFLECTION(14,30); +ACE_EXPLOSION_REFLECTION(14,40); +ACE_EXPLOSION_REFLECTION(14,50); +ACE_EXPLOSION_REFLECTION(14,60); +ACE_EXPLOSION_REFLECTION(14,70); +ACE_EXPLOSION_REFLECTION(14,80); +ACE_EXPLOSION_REFLECTION(14,90); +ACE_EXPLOSION_REFLECTION(14,100); +ACE_EXPLOSION_REFLECTION(14,110); +ACE_EXPLOSION_REFLECTION(14,120); +ACE_EXPLOSION_REFLECTION(14,130); +ACE_EXPLOSION_REFLECTION(14,140); +ACE_EXPLOSION_REFLECTION(14,150); +ACE_EXPLOSION_REFLECTION(14,160); +ACE_EXPLOSION_REFLECTION(14,170); +ACE_EXPLOSION_REFLECTION(14,180); +ACE_EXPLOSION_REFLECTION(14,190); +ACE_EXPLOSION_REFLECTION(14,200); +ACE_EXPLOSION_REFLECTION(14,210); +ACE_EXPLOSION_REFLECTION(14,220); +ACE_EXPLOSION_REFLECTION(14,230); +ACE_EXPLOSION_REFLECTION(14,240); +ACE_EXPLOSION_REFLECTION(14,250); +ACE_EXPLOSION_REFLECTION(14,260); +ACE_EXPLOSION_REFLECTION(14,270); +ACE_EXPLOSION_REFLECTION(14,280); +ACE_EXPLOSION_REFLECTION(14,290); +ACE_EXPLOSION_REFLECTION(14,300); +ACE_EXPLOSION_REFLECTION(14,310); +ACE_EXPLOSION_REFLECTION(14,320); +ACE_EXPLOSION_REFLECTION(14,330); +ACE_EXPLOSION_REFLECTION(14,340); +ACE_EXPLOSION_REFLECTION(14,350); +ACE_EXPLOSION_REFLECTION(14,360); +ACE_EXPLOSION_REFLECTION(14,370); +ACE_EXPLOSION_REFLECTION(14,380); +ACE_EXPLOSION_REFLECTION(14,390); +ACE_EXPLOSION_REFLECTION(14,400); +ACE_EXPLOSION_REFLECTION(14,410); +ACE_EXPLOSION_REFLECTION(14,420); +ACE_EXPLOSION_REFLECTION(14,430); +ACE_EXPLOSION_REFLECTION(14,440); +ACE_EXPLOSION_REFLECTION(14,450); +ACE_EXPLOSION_REFLECTION(14,460); +ACE_EXPLOSION_REFLECTION(14,470); +ACE_EXPLOSION_REFLECTION(14,480); +ACE_EXPLOSION_REFLECTION(14,490); +ACE_EXPLOSION_REFLECTION(14,500); +ACE_EXPLOSION_REFLECTION(16,10); +ACE_EXPLOSION_REFLECTION(16,20); +ACE_EXPLOSION_REFLECTION(16,30); +ACE_EXPLOSION_REFLECTION(16,40); +ACE_EXPLOSION_REFLECTION(16,50); +ACE_EXPLOSION_REFLECTION(16,60); +ACE_EXPLOSION_REFLECTION(16,70); +ACE_EXPLOSION_REFLECTION(16,80); +ACE_EXPLOSION_REFLECTION(16,90); +ACE_EXPLOSION_REFLECTION(16,100); +ACE_EXPLOSION_REFLECTION(16,110); +ACE_EXPLOSION_REFLECTION(16,120); +ACE_EXPLOSION_REFLECTION(16,130); +ACE_EXPLOSION_REFLECTION(16,140); +ACE_EXPLOSION_REFLECTION(16,150); +ACE_EXPLOSION_REFLECTION(16,160); +ACE_EXPLOSION_REFLECTION(16,170); +ACE_EXPLOSION_REFLECTION(16,180); +ACE_EXPLOSION_REFLECTION(16,190); +ACE_EXPLOSION_REFLECTION(16,200); +ACE_EXPLOSION_REFLECTION(16,210); +ACE_EXPLOSION_REFLECTION(16,220); +ACE_EXPLOSION_REFLECTION(16,230); +ACE_EXPLOSION_REFLECTION(16,240); +ACE_EXPLOSION_REFLECTION(16,250); +ACE_EXPLOSION_REFLECTION(16,260); +ACE_EXPLOSION_REFLECTION(16,270); +ACE_EXPLOSION_REFLECTION(16,280); +ACE_EXPLOSION_REFLECTION(16,290); +ACE_EXPLOSION_REFLECTION(16,300); +ACE_EXPLOSION_REFLECTION(16,310); +ACE_EXPLOSION_REFLECTION(16,320); +ACE_EXPLOSION_REFLECTION(16,330); +ACE_EXPLOSION_REFLECTION(16,340); +ACE_EXPLOSION_REFLECTION(16,350); +ACE_EXPLOSION_REFLECTION(16,360); +ACE_EXPLOSION_REFLECTION(16,370); +ACE_EXPLOSION_REFLECTION(16,380); +ACE_EXPLOSION_REFLECTION(16,390); +ACE_EXPLOSION_REFLECTION(16,400); +ACE_EXPLOSION_REFLECTION(16,410); +ACE_EXPLOSION_REFLECTION(16,420); +ACE_EXPLOSION_REFLECTION(16,430); +ACE_EXPLOSION_REFLECTION(16,440); +ACE_EXPLOSION_REFLECTION(16,450); +ACE_EXPLOSION_REFLECTION(16,460); +ACE_EXPLOSION_REFLECTION(16,470); +ACE_EXPLOSION_REFLECTION(16,480); +ACE_EXPLOSION_REFLECTION(16,490); +ACE_EXPLOSION_REFLECTION(16,500); +ACE_EXPLOSION_REFLECTION(18,10); +ACE_EXPLOSION_REFLECTION(18,20); +ACE_EXPLOSION_REFLECTION(18,30); +ACE_EXPLOSION_REFLECTION(18,40); +ACE_EXPLOSION_REFLECTION(18,50); +ACE_EXPLOSION_REFLECTION(18,60); +ACE_EXPLOSION_REFLECTION(18,70); +ACE_EXPLOSION_REFLECTION(18,80); +ACE_EXPLOSION_REFLECTION(18,90); +ACE_EXPLOSION_REFLECTION(18,100); +ACE_EXPLOSION_REFLECTION(18,110); +ACE_EXPLOSION_REFLECTION(18,120); +ACE_EXPLOSION_REFLECTION(18,130); +ACE_EXPLOSION_REFLECTION(18,140); +ACE_EXPLOSION_REFLECTION(18,150); +ACE_EXPLOSION_REFLECTION(18,160); +ACE_EXPLOSION_REFLECTION(18,170); +ACE_EXPLOSION_REFLECTION(18,180); +ACE_EXPLOSION_REFLECTION(18,190); +ACE_EXPLOSION_REFLECTION(18,200); +ACE_EXPLOSION_REFLECTION(18,210); +ACE_EXPLOSION_REFLECTION(18,220); +ACE_EXPLOSION_REFLECTION(18,230); +ACE_EXPLOSION_REFLECTION(18,240); +ACE_EXPLOSION_REFLECTION(18,250); +ACE_EXPLOSION_REFLECTION(18,260); +ACE_EXPLOSION_REFLECTION(18,270); +ACE_EXPLOSION_REFLECTION(18,280); +ACE_EXPLOSION_REFLECTION(18,290); +ACE_EXPLOSION_REFLECTION(18,300); +ACE_EXPLOSION_REFLECTION(18,310); +ACE_EXPLOSION_REFLECTION(18,320); +ACE_EXPLOSION_REFLECTION(18,330); +ACE_EXPLOSION_REFLECTION(18,340); +ACE_EXPLOSION_REFLECTION(18,350); +ACE_EXPLOSION_REFLECTION(18,360); +ACE_EXPLOSION_REFLECTION(18,370); +ACE_EXPLOSION_REFLECTION(18,380); +ACE_EXPLOSION_REFLECTION(18,390); +ACE_EXPLOSION_REFLECTION(18,400); +ACE_EXPLOSION_REFLECTION(18,410); +ACE_EXPLOSION_REFLECTION(18,420); +ACE_EXPLOSION_REFLECTION(18,430); +ACE_EXPLOSION_REFLECTION(18,440); +ACE_EXPLOSION_REFLECTION(18,450); +ACE_EXPLOSION_REFLECTION(18,460); +ACE_EXPLOSION_REFLECTION(18,470); +ACE_EXPLOSION_REFLECTION(18,480); +ACE_EXPLOSION_REFLECTION(18,490); +ACE_EXPLOSION_REFLECTION(18,500); +ACE_EXPLOSION_REFLECTION(20,10); +ACE_EXPLOSION_REFLECTION(20,20); +ACE_EXPLOSION_REFLECTION(20,30); +ACE_EXPLOSION_REFLECTION(20,40); +ACE_EXPLOSION_REFLECTION(20,50); +ACE_EXPLOSION_REFLECTION(20,60); +ACE_EXPLOSION_REFLECTION(20,70); +ACE_EXPLOSION_REFLECTION(20,80); +ACE_EXPLOSION_REFLECTION(20,90); +ACE_EXPLOSION_REFLECTION(20,100); +ACE_EXPLOSION_REFLECTION(20,110); +ACE_EXPLOSION_REFLECTION(20,120); +ACE_EXPLOSION_REFLECTION(20,130); +ACE_EXPLOSION_REFLECTION(20,140); +ACE_EXPLOSION_REFLECTION(20,150); +ACE_EXPLOSION_REFLECTION(20,160); +ACE_EXPLOSION_REFLECTION(20,170); +ACE_EXPLOSION_REFLECTION(20,180); +ACE_EXPLOSION_REFLECTION(20,190); +ACE_EXPLOSION_REFLECTION(20,200); +ACE_EXPLOSION_REFLECTION(20,210); +ACE_EXPLOSION_REFLECTION(20,220); +ACE_EXPLOSION_REFLECTION(20,230); +ACE_EXPLOSION_REFLECTION(20,240); +ACE_EXPLOSION_REFLECTION(20,250); +ACE_EXPLOSION_REFLECTION(20,260); +ACE_EXPLOSION_REFLECTION(20,270); +ACE_EXPLOSION_REFLECTION(20,280); +ACE_EXPLOSION_REFLECTION(20,290); +ACE_EXPLOSION_REFLECTION(20,300); +ACE_EXPLOSION_REFLECTION(20,310); +ACE_EXPLOSION_REFLECTION(20,320); +ACE_EXPLOSION_REFLECTION(20,330); +ACE_EXPLOSION_REFLECTION(20,340); +ACE_EXPLOSION_REFLECTION(20,350); +ACE_EXPLOSION_REFLECTION(20,360); +ACE_EXPLOSION_REFLECTION(20,370); +ACE_EXPLOSION_REFLECTION(20,380); +ACE_EXPLOSION_REFLECTION(20,390); +ACE_EXPLOSION_REFLECTION(20,400); +ACE_EXPLOSION_REFLECTION(20,410); +ACE_EXPLOSION_REFLECTION(20,420); +ACE_EXPLOSION_REFLECTION(20,430); +ACE_EXPLOSION_REFLECTION(20,440); +ACE_EXPLOSION_REFLECTION(20,450); +ACE_EXPLOSION_REFLECTION(20,460); +ACE_EXPLOSION_REFLECTION(20,470); +ACE_EXPLOSION_REFLECTION(20,480); +ACE_EXPLOSION_REFLECTION(20,490); +ACE_EXPLOSION_REFLECTION(20,500); +ACE_EXPLOSION_REFLECTION(22,10); +ACE_EXPLOSION_REFLECTION(22,20); +ACE_EXPLOSION_REFLECTION(22,30); +ACE_EXPLOSION_REFLECTION(22,40); +ACE_EXPLOSION_REFLECTION(22,50); +ACE_EXPLOSION_REFLECTION(22,60); +ACE_EXPLOSION_REFLECTION(22,70); +ACE_EXPLOSION_REFLECTION(22,80); +ACE_EXPLOSION_REFLECTION(22,90); +ACE_EXPLOSION_REFLECTION(22,100); +ACE_EXPLOSION_REFLECTION(22,110); +ACE_EXPLOSION_REFLECTION(22,120); +ACE_EXPLOSION_REFLECTION(22,130); +ACE_EXPLOSION_REFLECTION(22,140); +ACE_EXPLOSION_REFLECTION(22,150); +ACE_EXPLOSION_REFLECTION(22,160); +ACE_EXPLOSION_REFLECTION(22,170); +ACE_EXPLOSION_REFLECTION(22,180); +ACE_EXPLOSION_REFLECTION(22,190); +ACE_EXPLOSION_REFLECTION(22,200); +ACE_EXPLOSION_REFLECTION(22,210); +ACE_EXPLOSION_REFLECTION(22,220); +ACE_EXPLOSION_REFLECTION(22,230); +ACE_EXPLOSION_REFLECTION(22,240); +ACE_EXPLOSION_REFLECTION(22,250); +ACE_EXPLOSION_REFLECTION(22,260); +ACE_EXPLOSION_REFLECTION(22,270); +ACE_EXPLOSION_REFLECTION(22,280); +ACE_EXPLOSION_REFLECTION(22,290); +ACE_EXPLOSION_REFLECTION(22,300); +ACE_EXPLOSION_REFLECTION(22,310); +ACE_EXPLOSION_REFLECTION(22,320); +ACE_EXPLOSION_REFLECTION(22,330); +ACE_EXPLOSION_REFLECTION(22,340); +ACE_EXPLOSION_REFLECTION(22,350); +ACE_EXPLOSION_REFLECTION(22,360); +ACE_EXPLOSION_REFLECTION(22,370); +ACE_EXPLOSION_REFLECTION(22,380); +ACE_EXPLOSION_REFLECTION(22,390); +ACE_EXPLOSION_REFLECTION(22,400); +ACE_EXPLOSION_REFLECTION(22,410); +ACE_EXPLOSION_REFLECTION(22,420); +ACE_EXPLOSION_REFLECTION(22,430); +ACE_EXPLOSION_REFLECTION(22,440); +ACE_EXPLOSION_REFLECTION(22,450); +ACE_EXPLOSION_REFLECTION(22,460); +ACE_EXPLOSION_REFLECTION(22,470); +ACE_EXPLOSION_REFLECTION(22,480); +ACE_EXPLOSION_REFLECTION(22,490); +ACE_EXPLOSION_REFLECTION(22,500); +ACE_EXPLOSION_REFLECTION(24,10); +ACE_EXPLOSION_REFLECTION(24,20); +ACE_EXPLOSION_REFLECTION(24,30); +ACE_EXPLOSION_REFLECTION(24,40); +ACE_EXPLOSION_REFLECTION(24,50); +ACE_EXPLOSION_REFLECTION(24,60); +ACE_EXPLOSION_REFLECTION(24,70); +ACE_EXPLOSION_REFLECTION(24,80); +ACE_EXPLOSION_REFLECTION(24,90); +ACE_EXPLOSION_REFLECTION(24,100); +ACE_EXPLOSION_REFLECTION(24,110); +ACE_EXPLOSION_REFLECTION(24,120); +ACE_EXPLOSION_REFLECTION(24,130); +ACE_EXPLOSION_REFLECTION(24,140); +ACE_EXPLOSION_REFLECTION(24,150); +ACE_EXPLOSION_REFLECTION(24,160); +ACE_EXPLOSION_REFLECTION(24,170); +ACE_EXPLOSION_REFLECTION(24,180); +ACE_EXPLOSION_REFLECTION(24,190); +ACE_EXPLOSION_REFLECTION(24,200); +ACE_EXPLOSION_REFLECTION(24,210); +ACE_EXPLOSION_REFLECTION(24,220); +ACE_EXPLOSION_REFLECTION(24,230); +ACE_EXPLOSION_REFLECTION(24,240); +ACE_EXPLOSION_REFLECTION(24,250); +ACE_EXPLOSION_REFLECTION(24,260); +ACE_EXPLOSION_REFLECTION(24,270); +ACE_EXPLOSION_REFLECTION(24,280); +ACE_EXPLOSION_REFLECTION(24,290); +ACE_EXPLOSION_REFLECTION(24,300); +ACE_EXPLOSION_REFLECTION(24,310); +ACE_EXPLOSION_REFLECTION(24,320); +ACE_EXPLOSION_REFLECTION(24,330); +ACE_EXPLOSION_REFLECTION(24,340); +ACE_EXPLOSION_REFLECTION(24,350); +ACE_EXPLOSION_REFLECTION(24,360); +ACE_EXPLOSION_REFLECTION(24,370); +ACE_EXPLOSION_REFLECTION(24,380); +ACE_EXPLOSION_REFLECTION(24,390); +ACE_EXPLOSION_REFLECTION(24,400); +ACE_EXPLOSION_REFLECTION(24,410); +ACE_EXPLOSION_REFLECTION(24,420); +ACE_EXPLOSION_REFLECTION(24,430); +ACE_EXPLOSION_REFLECTION(24,440); +ACE_EXPLOSION_REFLECTION(24,450); +ACE_EXPLOSION_REFLECTION(24,460); +ACE_EXPLOSION_REFLECTION(24,470); +ACE_EXPLOSION_REFLECTION(24,480); +ACE_EXPLOSION_REFLECTION(24,490); +ACE_EXPLOSION_REFLECTION(24,500); +ACE_EXPLOSION_REFLECTION(26,10); +ACE_EXPLOSION_REFLECTION(26,20); +ACE_EXPLOSION_REFLECTION(26,30); +ACE_EXPLOSION_REFLECTION(26,40); +ACE_EXPLOSION_REFLECTION(26,50); +ACE_EXPLOSION_REFLECTION(26,60); +ACE_EXPLOSION_REFLECTION(26,70); +ACE_EXPLOSION_REFLECTION(26,80); +ACE_EXPLOSION_REFLECTION(26,90); +ACE_EXPLOSION_REFLECTION(26,100); +ACE_EXPLOSION_REFLECTION(26,110); +ACE_EXPLOSION_REFLECTION(26,120); +ACE_EXPLOSION_REFLECTION(26,130); +ACE_EXPLOSION_REFLECTION(26,140); +ACE_EXPLOSION_REFLECTION(26,150); +ACE_EXPLOSION_REFLECTION(26,160); +ACE_EXPLOSION_REFLECTION(26,170); +ACE_EXPLOSION_REFLECTION(26,180); +ACE_EXPLOSION_REFLECTION(26,190); +ACE_EXPLOSION_REFLECTION(26,200); +ACE_EXPLOSION_REFLECTION(26,210); +ACE_EXPLOSION_REFLECTION(26,220); +ACE_EXPLOSION_REFLECTION(26,230); +ACE_EXPLOSION_REFLECTION(26,240); +ACE_EXPLOSION_REFLECTION(26,250); +ACE_EXPLOSION_REFLECTION(26,260); +ACE_EXPLOSION_REFLECTION(26,270); +ACE_EXPLOSION_REFLECTION(26,280); +ACE_EXPLOSION_REFLECTION(26,290); +ACE_EXPLOSION_REFLECTION(26,300); +ACE_EXPLOSION_REFLECTION(26,310); +ACE_EXPLOSION_REFLECTION(26,320); +ACE_EXPLOSION_REFLECTION(26,330); +ACE_EXPLOSION_REFLECTION(26,340); +ACE_EXPLOSION_REFLECTION(26,350); +ACE_EXPLOSION_REFLECTION(26,360); +ACE_EXPLOSION_REFLECTION(26,370); +ACE_EXPLOSION_REFLECTION(26,380); +ACE_EXPLOSION_REFLECTION(26,390); +ACE_EXPLOSION_REFLECTION(26,400); +ACE_EXPLOSION_REFLECTION(26,410); +ACE_EXPLOSION_REFLECTION(26,420); +ACE_EXPLOSION_REFLECTION(26,430); +ACE_EXPLOSION_REFLECTION(26,440); +ACE_EXPLOSION_REFLECTION(26,450); +ACE_EXPLOSION_REFLECTION(26,460); +ACE_EXPLOSION_REFLECTION(26,470); +ACE_EXPLOSION_REFLECTION(26,480); +ACE_EXPLOSION_REFLECTION(26,490); +ACE_EXPLOSION_REFLECTION(26,500); +ACE_EXPLOSION_REFLECTION(28,10); +ACE_EXPLOSION_REFLECTION(28,20); +ACE_EXPLOSION_REFLECTION(28,30); +ACE_EXPLOSION_REFLECTION(28,40); +ACE_EXPLOSION_REFLECTION(28,50); +ACE_EXPLOSION_REFLECTION(28,60); +ACE_EXPLOSION_REFLECTION(28,70); +ACE_EXPLOSION_REFLECTION(28,80); +ACE_EXPLOSION_REFLECTION(28,90); +ACE_EXPLOSION_REFLECTION(28,100); +ACE_EXPLOSION_REFLECTION(28,110); +ACE_EXPLOSION_REFLECTION(28,120); +ACE_EXPLOSION_REFLECTION(28,130); +ACE_EXPLOSION_REFLECTION(28,140); +ACE_EXPLOSION_REFLECTION(28,150); +ACE_EXPLOSION_REFLECTION(28,160); +ACE_EXPLOSION_REFLECTION(28,170); +ACE_EXPLOSION_REFLECTION(28,180); +ACE_EXPLOSION_REFLECTION(28,190); +ACE_EXPLOSION_REFLECTION(28,200); +ACE_EXPLOSION_REFLECTION(28,210); +ACE_EXPLOSION_REFLECTION(28,220); +ACE_EXPLOSION_REFLECTION(28,230); +ACE_EXPLOSION_REFLECTION(28,240); +ACE_EXPLOSION_REFLECTION(28,250); +ACE_EXPLOSION_REFLECTION(28,260); +ACE_EXPLOSION_REFLECTION(28,270); +ACE_EXPLOSION_REFLECTION(28,280); +ACE_EXPLOSION_REFLECTION(28,290); +ACE_EXPLOSION_REFLECTION(28,300); +ACE_EXPLOSION_REFLECTION(28,310); +ACE_EXPLOSION_REFLECTION(28,320); +ACE_EXPLOSION_REFLECTION(28,330); +ACE_EXPLOSION_REFLECTION(28,340); +ACE_EXPLOSION_REFLECTION(28,350); +ACE_EXPLOSION_REFLECTION(28,360); +ACE_EXPLOSION_REFLECTION(28,370); +ACE_EXPLOSION_REFLECTION(28,380); +ACE_EXPLOSION_REFLECTION(28,390); +ACE_EXPLOSION_REFLECTION(28,400); +ACE_EXPLOSION_REFLECTION(28,410); +ACE_EXPLOSION_REFLECTION(28,420); +ACE_EXPLOSION_REFLECTION(28,430); +ACE_EXPLOSION_REFLECTION(28,440); +ACE_EXPLOSION_REFLECTION(28,450); +ACE_EXPLOSION_REFLECTION(28,460); +ACE_EXPLOSION_REFLECTION(28,470); +ACE_EXPLOSION_REFLECTION(28,480); +ACE_EXPLOSION_REFLECTION(28,490); +ACE_EXPLOSION_REFLECTION(28,500); +ACE_EXPLOSION_REFLECTION(30,10); +ACE_EXPLOSION_REFLECTION(30,20); +ACE_EXPLOSION_REFLECTION(30,30); +ACE_EXPLOSION_REFLECTION(30,40); +ACE_EXPLOSION_REFLECTION(30,50); +ACE_EXPLOSION_REFLECTION(30,60); +ACE_EXPLOSION_REFLECTION(30,70); +ACE_EXPLOSION_REFLECTION(30,80); +ACE_EXPLOSION_REFLECTION(30,90); +ACE_EXPLOSION_REFLECTION(30,100); +ACE_EXPLOSION_REFLECTION(30,110); +ACE_EXPLOSION_REFLECTION(30,120); +ACE_EXPLOSION_REFLECTION(30,130); +ACE_EXPLOSION_REFLECTION(30,140); +ACE_EXPLOSION_REFLECTION(30,150); +ACE_EXPLOSION_REFLECTION(30,160); +ACE_EXPLOSION_REFLECTION(30,170); +ACE_EXPLOSION_REFLECTION(30,180); +ACE_EXPLOSION_REFLECTION(30,190); +ACE_EXPLOSION_REFLECTION(30,200); +ACE_EXPLOSION_REFLECTION(30,210); +ACE_EXPLOSION_REFLECTION(30,220); +ACE_EXPLOSION_REFLECTION(30,230); +ACE_EXPLOSION_REFLECTION(30,240); +ACE_EXPLOSION_REFLECTION(30,250); +ACE_EXPLOSION_REFLECTION(30,260); +ACE_EXPLOSION_REFLECTION(30,270); +ACE_EXPLOSION_REFLECTION(30,280); +ACE_EXPLOSION_REFLECTION(30,290); +ACE_EXPLOSION_REFLECTION(30,300); +ACE_EXPLOSION_REFLECTION(30,310); +ACE_EXPLOSION_REFLECTION(30,320); +ACE_EXPLOSION_REFLECTION(30,330); +ACE_EXPLOSION_REFLECTION(30,340); +ACE_EXPLOSION_REFLECTION(30,350); +ACE_EXPLOSION_REFLECTION(30,360); +ACE_EXPLOSION_REFLECTION(30,370); +ACE_EXPLOSION_REFLECTION(30,380); +ACE_EXPLOSION_REFLECTION(30,390); +ACE_EXPLOSION_REFLECTION(30,400); +ACE_EXPLOSION_REFLECTION(30,410); +ACE_EXPLOSION_REFLECTION(30,420); +ACE_EXPLOSION_REFLECTION(30,430); +ACE_EXPLOSION_REFLECTION(30,440); +ACE_EXPLOSION_REFLECTION(30,450); +ACE_EXPLOSION_REFLECTION(30,460); +ACE_EXPLOSION_REFLECTION(30,470); +ACE_EXPLOSION_REFLECTION(30,480); +ACE_EXPLOSION_REFLECTION(30,490); +ACE_EXPLOSION_REFLECTION(30,500); +ACE_EXPLOSION_REFLECTION(32,10); +ACE_EXPLOSION_REFLECTION(32,20); +ACE_EXPLOSION_REFLECTION(32,30); +ACE_EXPLOSION_REFLECTION(32,40); +ACE_EXPLOSION_REFLECTION(32,50); +ACE_EXPLOSION_REFLECTION(32,60); +ACE_EXPLOSION_REFLECTION(32,70); +ACE_EXPLOSION_REFLECTION(32,80); +ACE_EXPLOSION_REFLECTION(32,90); +ACE_EXPLOSION_REFLECTION(32,100); +ACE_EXPLOSION_REFLECTION(32,110); +ACE_EXPLOSION_REFLECTION(32,120); +ACE_EXPLOSION_REFLECTION(32,130); +ACE_EXPLOSION_REFLECTION(32,140); +ACE_EXPLOSION_REFLECTION(32,150); +ACE_EXPLOSION_REFLECTION(32,160); +ACE_EXPLOSION_REFLECTION(32,170); +ACE_EXPLOSION_REFLECTION(32,180); +ACE_EXPLOSION_REFLECTION(32,190); +ACE_EXPLOSION_REFLECTION(32,200); +ACE_EXPLOSION_REFLECTION(32,210); +ACE_EXPLOSION_REFLECTION(32,220); +ACE_EXPLOSION_REFLECTION(32,230); +ACE_EXPLOSION_REFLECTION(32,240); +ACE_EXPLOSION_REFLECTION(32,250); +ACE_EXPLOSION_REFLECTION(32,260); +ACE_EXPLOSION_REFLECTION(32,270); +ACE_EXPLOSION_REFLECTION(32,280); +ACE_EXPLOSION_REFLECTION(32,290); +ACE_EXPLOSION_REFLECTION(32,300); +ACE_EXPLOSION_REFLECTION(32,310); +ACE_EXPLOSION_REFLECTION(32,320); +ACE_EXPLOSION_REFLECTION(32,330); +ACE_EXPLOSION_REFLECTION(32,340); +ACE_EXPLOSION_REFLECTION(32,350); +ACE_EXPLOSION_REFLECTION(32,360); +ACE_EXPLOSION_REFLECTION(32,370); +ACE_EXPLOSION_REFLECTION(32,380); +ACE_EXPLOSION_REFLECTION(32,390); +ACE_EXPLOSION_REFLECTION(32,400); +ACE_EXPLOSION_REFLECTION(32,410); +ACE_EXPLOSION_REFLECTION(32,420); +ACE_EXPLOSION_REFLECTION(32,430); +ACE_EXPLOSION_REFLECTION(32,440); +ACE_EXPLOSION_REFLECTION(32,450); +ACE_EXPLOSION_REFLECTION(32,460); +ACE_EXPLOSION_REFLECTION(32,470); +ACE_EXPLOSION_REFLECTION(32,480); +ACE_EXPLOSION_REFLECTION(32,490); +ACE_EXPLOSION_REFLECTION(32,500); +ACE_EXPLOSION_REFLECTION(34,10); +ACE_EXPLOSION_REFLECTION(34,20); +ACE_EXPLOSION_REFLECTION(34,30); +ACE_EXPLOSION_REFLECTION(34,40); +ACE_EXPLOSION_REFLECTION(34,50); +ACE_EXPLOSION_REFLECTION(34,60); +ACE_EXPLOSION_REFLECTION(34,70); +ACE_EXPLOSION_REFLECTION(34,80); +ACE_EXPLOSION_REFLECTION(34,90); +ACE_EXPLOSION_REFLECTION(34,100); +ACE_EXPLOSION_REFLECTION(34,110); +ACE_EXPLOSION_REFLECTION(34,120); +ACE_EXPLOSION_REFLECTION(34,130); +ACE_EXPLOSION_REFLECTION(34,140); +ACE_EXPLOSION_REFLECTION(34,150); +ACE_EXPLOSION_REFLECTION(34,160); +ACE_EXPLOSION_REFLECTION(34,170); +ACE_EXPLOSION_REFLECTION(34,180); +ACE_EXPLOSION_REFLECTION(34,190); +ACE_EXPLOSION_REFLECTION(34,200); +ACE_EXPLOSION_REFLECTION(34,210); +ACE_EXPLOSION_REFLECTION(34,220); +ACE_EXPLOSION_REFLECTION(34,230); +ACE_EXPLOSION_REFLECTION(34,240); +ACE_EXPLOSION_REFLECTION(34,250); +ACE_EXPLOSION_REFLECTION(34,260); +ACE_EXPLOSION_REFLECTION(34,270); +ACE_EXPLOSION_REFLECTION(34,280); +ACE_EXPLOSION_REFLECTION(34,290); +ACE_EXPLOSION_REFLECTION(34,300); +ACE_EXPLOSION_REFLECTION(34,310); +ACE_EXPLOSION_REFLECTION(34,320); +ACE_EXPLOSION_REFLECTION(34,330); +ACE_EXPLOSION_REFLECTION(34,340); +ACE_EXPLOSION_REFLECTION(34,350); +ACE_EXPLOSION_REFLECTION(34,360); +ACE_EXPLOSION_REFLECTION(34,370); +ACE_EXPLOSION_REFLECTION(34,380); +ACE_EXPLOSION_REFLECTION(34,390); +ACE_EXPLOSION_REFLECTION(34,400); +ACE_EXPLOSION_REFLECTION(34,410); +ACE_EXPLOSION_REFLECTION(34,420); +ACE_EXPLOSION_REFLECTION(34,430); +ACE_EXPLOSION_REFLECTION(34,440); +ACE_EXPLOSION_REFLECTION(34,450); +ACE_EXPLOSION_REFLECTION(34,460); +ACE_EXPLOSION_REFLECTION(34,470); +ACE_EXPLOSION_REFLECTION(34,480); +ACE_EXPLOSION_REFLECTION(34,490); +ACE_EXPLOSION_REFLECTION(34,500); +ACE_EXPLOSION_REFLECTION(36,10); +ACE_EXPLOSION_REFLECTION(36,20); +ACE_EXPLOSION_REFLECTION(36,30); +ACE_EXPLOSION_REFLECTION(36,40); +ACE_EXPLOSION_REFLECTION(36,50); +ACE_EXPLOSION_REFLECTION(36,60); +ACE_EXPLOSION_REFLECTION(36,70); +ACE_EXPLOSION_REFLECTION(36,80); +ACE_EXPLOSION_REFLECTION(36,90); +ACE_EXPLOSION_REFLECTION(36,100); +ACE_EXPLOSION_REFLECTION(36,110); +ACE_EXPLOSION_REFLECTION(36,120); +ACE_EXPLOSION_REFLECTION(36,130); +ACE_EXPLOSION_REFLECTION(36,140); +ACE_EXPLOSION_REFLECTION(36,150); +ACE_EXPLOSION_REFLECTION(36,160); +ACE_EXPLOSION_REFLECTION(36,170); +ACE_EXPLOSION_REFLECTION(36,180); +ACE_EXPLOSION_REFLECTION(36,190); +ACE_EXPLOSION_REFLECTION(36,200); +ACE_EXPLOSION_REFLECTION(36,210); +ACE_EXPLOSION_REFLECTION(36,220); +ACE_EXPLOSION_REFLECTION(36,230); +ACE_EXPLOSION_REFLECTION(36,240); +ACE_EXPLOSION_REFLECTION(36,250); +ACE_EXPLOSION_REFLECTION(36,260); +ACE_EXPLOSION_REFLECTION(36,270); +ACE_EXPLOSION_REFLECTION(36,280); +ACE_EXPLOSION_REFLECTION(36,290); +ACE_EXPLOSION_REFLECTION(36,300); +ACE_EXPLOSION_REFLECTION(36,310); +ACE_EXPLOSION_REFLECTION(36,320); +ACE_EXPLOSION_REFLECTION(36,330); +ACE_EXPLOSION_REFLECTION(36,340); +ACE_EXPLOSION_REFLECTION(36,350); +ACE_EXPLOSION_REFLECTION(36,360); +ACE_EXPLOSION_REFLECTION(36,370); +ACE_EXPLOSION_REFLECTION(36,380); +ACE_EXPLOSION_REFLECTION(36,390); +ACE_EXPLOSION_REFLECTION(36,400); +ACE_EXPLOSION_REFLECTION(36,410); +ACE_EXPLOSION_REFLECTION(36,420); +ACE_EXPLOSION_REFLECTION(36,430); +ACE_EXPLOSION_REFLECTION(36,440); +ACE_EXPLOSION_REFLECTION(36,450); +ACE_EXPLOSION_REFLECTION(36,460); +ACE_EXPLOSION_REFLECTION(36,470); +ACE_EXPLOSION_REFLECTION(36,480); +ACE_EXPLOSION_REFLECTION(36,490); +ACE_EXPLOSION_REFLECTION(36,500); +ACE_EXPLOSION_REFLECTION(38,10); +ACE_EXPLOSION_REFLECTION(38,20); +ACE_EXPLOSION_REFLECTION(38,30); +ACE_EXPLOSION_REFLECTION(38,40); +ACE_EXPLOSION_REFLECTION(38,50); +ACE_EXPLOSION_REFLECTION(38,60); +ACE_EXPLOSION_REFLECTION(38,70); +ACE_EXPLOSION_REFLECTION(38,80); +ACE_EXPLOSION_REFLECTION(38,90); +ACE_EXPLOSION_REFLECTION(38,100); +ACE_EXPLOSION_REFLECTION(38,110); +ACE_EXPLOSION_REFLECTION(38,120); +ACE_EXPLOSION_REFLECTION(38,130); +ACE_EXPLOSION_REFLECTION(38,140); +ACE_EXPLOSION_REFLECTION(38,150); +ACE_EXPLOSION_REFLECTION(38,160); +ACE_EXPLOSION_REFLECTION(38,170); +ACE_EXPLOSION_REFLECTION(38,180); +ACE_EXPLOSION_REFLECTION(38,190); +ACE_EXPLOSION_REFLECTION(38,200); +ACE_EXPLOSION_REFLECTION(38,210); +ACE_EXPLOSION_REFLECTION(38,220); +ACE_EXPLOSION_REFLECTION(38,230); +ACE_EXPLOSION_REFLECTION(38,240); +ACE_EXPLOSION_REFLECTION(38,250); +ACE_EXPLOSION_REFLECTION(38,260); +ACE_EXPLOSION_REFLECTION(38,270); +ACE_EXPLOSION_REFLECTION(38,280); +ACE_EXPLOSION_REFLECTION(38,290); +ACE_EXPLOSION_REFLECTION(38,300); +ACE_EXPLOSION_REFLECTION(38,310); +ACE_EXPLOSION_REFLECTION(38,320); +ACE_EXPLOSION_REFLECTION(38,330); +ACE_EXPLOSION_REFLECTION(38,340); +ACE_EXPLOSION_REFLECTION(38,350); +ACE_EXPLOSION_REFLECTION(38,360); +ACE_EXPLOSION_REFLECTION(38,370); +ACE_EXPLOSION_REFLECTION(38,380); +ACE_EXPLOSION_REFLECTION(38,390); +ACE_EXPLOSION_REFLECTION(38,400); +ACE_EXPLOSION_REFLECTION(38,410); +ACE_EXPLOSION_REFLECTION(38,420); +ACE_EXPLOSION_REFLECTION(38,430); +ACE_EXPLOSION_REFLECTION(38,440); +ACE_EXPLOSION_REFLECTION(38,450); +ACE_EXPLOSION_REFLECTION(38,460); +ACE_EXPLOSION_REFLECTION(38,470); +ACE_EXPLOSION_REFLECTION(38,480); +ACE_EXPLOSION_REFLECTION(38,490); +ACE_EXPLOSION_REFLECTION(38,500); +ACE_EXPLOSION_REFLECTION(40,10); +ACE_EXPLOSION_REFLECTION(40,20); +ACE_EXPLOSION_REFLECTION(40,30); +ACE_EXPLOSION_REFLECTION(40,40); +ACE_EXPLOSION_REFLECTION(40,50); +ACE_EXPLOSION_REFLECTION(40,60); +ACE_EXPLOSION_REFLECTION(40,70); +ACE_EXPLOSION_REFLECTION(40,80); +ACE_EXPLOSION_REFLECTION(40,90); +ACE_EXPLOSION_REFLECTION(40,100); +ACE_EXPLOSION_REFLECTION(40,110); +ACE_EXPLOSION_REFLECTION(40,120); +ACE_EXPLOSION_REFLECTION(40,130); +ACE_EXPLOSION_REFLECTION(40,140); +ACE_EXPLOSION_REFLECTION(40,150); +ACE_EXPLOSION_REFLECTION(40,160); +ACE_EXPLOSION_REFLECTION(40,170); +ACE_EXPLOSION_REFLECTION(40,180); +ACE_EXPLOSION_REFLECTION(40,190); +ACE_EXPLOSION_REFLECTION(40,200); +ACE_EXPLOSION_REFLECTION(40,210); +ACE_EXPLOSION_REFLECTION(40,220); +ACE_EXPLOSION_REFLECTION(40,230); +ACE_EXPLOSION_REFLECTION(40,240); +ACE_EXPLOSION_REFLECTION(40,250); +ACE_EXPLOSION_REFLECTION(40,260); +ACE_EXPLOSION_REFLECTION(40,270); +ACE_EXPLOSION_REFLECTION(40,280); +ACE_EXPLOSION_REFLECTION(40,290); +ACE_EXPLOSION_REFLECTION(40,300); +ACE_EXPLOSION_REFLECTION(40,310); +ACE_EXPLOSION_REFLECTION(40,320); +ACE_EXPLOSION_REFLECTION(40,330); +ACE_EXPLOSION_REFLECTION(40,340); +ACE_EXPLOSION_REFLECTION(40,350); +ACE_EXPLOSION_REFLECTION(40,360); +ACE_EXPLOSION_REFLECTION(40,370); +ACE_EXPLOSION_REFLECTION(40,380); +ACE_EXPLOSION_REFLECTION(40,390); +ACE_EXPLOSION_REFLECTION(40,400); +ACE_EXPLOSION_REFLECTION(40,410); +ACE_EXPLOSION_REFLECTION(40,420); +ACE_EXPLOSION_REFLECTION(40,430); +ACE_EXPLOSION_REFLECTION(40,440); +ACE_EXPLOSION_REFLECTION(40,450); +ACE_EXPLOSION_REFLECTION(40,460); +ACE_EXPLOSION_REFLECTION(40,470); +ACE_EXPLOSION_REFLECTION(40,480); +ACE_EXPLOSION_REFLECTION(40,490); +ACE_EXPLOSION_REFLECTION(40,500); +ACE_EXPLOSION_REFLECTION(42,10); +ACE_EXPLOSION_REFLECTION(42,20); +ACE_EXPLOSION_REFLECTION(42,30); +ACE_EXPLOSION_REFLECTION(42,40); +ACE_EXPLOSION_REFLECTION(42,50); +ACE_EXPLOSION_REFLECTION(42,60); +ACE_EXPLOSION_REFLECTION(42,70); +ACE_EXPLOSION_REFLECTION(42,80); +ACE_EXPLOSION_REFLECTION(42,90); +ACE_EXPLOSION_REFLECTION(42,100); +ACE_EXPLOSION_REFLECTION(42,110); +ACE_EXPLOSION_REFLECTION(42,120); +ACE_EXPLOSION_REFLECTION(42,130); +ACE_EXPLOSION_REFLECTION(42,140); +ACE_EXPLOSION_REFLECTION(42,150); +ACE_EXPLOSION_REFLECTION(42,160); +ACE_EXPLOSION_REFLECTION(42,170); +ACE_EXPLOSION_REFLECTION(42,180); +ACE_EXPLOSION_REFLECTION(42,190); +ACE_EXPLOSION_REFLECTION(42,200); +ACE_EXPLOSION_REFLECTION(42,210); +ACE_EXPLOSION_REFLECTION(42,220); +ACE_EXPLOSION_REFLECTION(42,230); +ACE_EXPLOSION_REFLECTION(42,240); +ACE_EXPLOSION_REFLECTION(42,250); +ACE_EXPLOSION_REFLECTION(42,260); +ACE_EXPLOSION_REFLECTION(42,270); +ACE_EXPLOSION_REFLECTION(42,280); +ACE_EXPLOSION_REFLECTION(42,290); +ACE_EXPLOSION_REFLECTION(42,300); +ACE_EXPLOSION_REFLECTION(42,310); +ACE_EXPLOSION_REFLECTION(42,320); +ACE_EXPLOSION_REFLECTION(42,330); +ACE_EXPLOSION_REFLECTION(42,340); +ACE_EXPLOSION_REFLECTION(42,350); +ACE_EXPLOSION_REFLECTION(42,360); +ACE_EXPLOSION_REFLECTION(42,370); +ACE_EXPLOSION_REFLECTION(42,380); +ACE_EXPLOSION_REFLECTION(42,390); +ACE_EXPLOSION_REFLECTION(42,400); +ACE_EXPLOSION_REFLECTION(42,410); +ACE_EXPLOSION_REFLECTION(42,420); +ACE_EXPLOSION_REFLECTION(42,430); +ACE_EXPLOSION_REFLECTION(42,440); +ACE_EXPLOSION_REFLECTION(42,450); +ACE_EXPLOSION_REFLECTION(42,460); +ACE_EXPLOSION_REFLECTION(42,470); +ACE_EXPLOSION_REFLECTION(42,480); +ACE_EXPLOSION_REFLECTION(42,490); +ACE_EXPLOSION_REFLECTION(42,500); +ACE_EXPLOSION_REFLECTION(44,10); +ACE_EXPLOSION_REFLECTION(44,20); +ACE_EXPLOSION_REFLECTION(44,30); +ACE_EXPLOSION_REFLECTION(44,40); +ACE_EXPLOSION_REFLECTION(44,50); +ACE_EXPLOSION_REFLECTION(44,60); +ACE_EXPLOSION_REFLECTION(44,70); +ACE_EXPLOSION_REFLECTION(44,80); +ACE_EXPLOSION_REFLECTION(44,90); +ACE_EXPLOSION_REFLECTION(44,100); +ACE_EXPLOSION_REFLECTION(44,110); +ACE_EXPLOSION_REFLECTION(44,120); +ACE_EXPLOSION_REFLECTION(44,130); +ACE_EXPLOSION_REFLECTION(44,140); +ACE_EXPLOSION_REFLECTION(44,150); +ACE_EXPLOSION_REFLECTION(44,160); +ACE_EXPLOSION_REFLECTION(44,170); +ACE_EXPLOSION_REFLECTION(44,180); +ACE_EXPLOSION_REFLECTION(44,190); +ACE_EXPLOSION_REFLECTION(44,200); +ACE_EXPLOSION_REFLECTION(44,210); +ACE_EXPLOSION_REFLECTION(44,220); +ACE_EXPLOSION_REFLECTION(44,230); +ACE_EXPLOSION_REFLECTION(44,240); +ACE_EXPLOSION_REFLECTION(44,250); +ACE_EXPLOSION_REFLECTION(44,260); +ACE_EXPLOSION_REFLECTION(44,270); +ACE_EXPLOSION_REFLECTION(44,280); +ACE_EXPLOSION_REFLECTION(44,290); +ACE_EXPLOSION_REFLECTION(44,300); +ACE_EXPLOSION_REFLECTION(44,310); +ACE_EXPLOSION_REFLECTION(44,320); +ACE_EXPLOSION_REFLECTION(44,330); +ACE_EXPLOSION_REFLECTION(44,340); +ACE_EXPLOSION_REFLECTION(44,350); +ACE_EXPLOSION_REFLECTION(44,360); +ACE_EXPLOSION_REFLECTION(44,370); +ACE_EXPLOSION_REFLECTION(44,380); +ACE_EXPLOSION_REFLECTION(44,390); +ACE_EXPLOSION_REFLECTION(44,400); +ACE_EXPLOSION_REFLECTION(44,410); +ACE_EXPLOSION_REFLECTION(44,420); +ACE_EXPLOSION_REFLECTION(44,430); +ACE_EXPLOSION_REFLECTION(44,440); +ACE_EXPLOSION_REFLECTION(44,450); +ACE_EXPLOSION_REFLECTION(44,460); +ACE_EXPLOSION_REFLECTION(44,470); +ACE_EXPLOSION_REFLECTION(44,480); +ACE_EXPLOSION_REFLECTION(44,490); +ACE_EXPLOSION_REFLECTION(44,500); +ACE_EXPLOSION_REFLECTION(46,10); +ACE_EXPLOSION_REFLECTION(46,20); +ACE_EXPLOSION_REFLECTION(46,30); +ACE_EXPLOSION_REFLECTION(46,40); +ACE_EXPLOSION_REFLECTION(46,50); +ACE_EXPLOSION_REFLECTION(46,60); +ACE_EXPLOSION_REFLECTION(46,70); +ACE_EXPLOSION_REFLECTION(46,80); +ACE_EXPLOSION_REFLECTION(46,90); +ACE_EXPLOSION_REFLECTION(46,100); +ACE_EXPLOSION_REFLECTION(46,110); +ACE_EXPLOSION_REFLECTION(46,120); +ACE_EXPLOSION_REFLECTION(46,130); +ACE_EXPLOSION_REFLECTION(46,140); +ACE_EXPLOSION_REFLECTION(46,150); +ACE_EXPLOSION_REFLECTION(46,160); +ACE_EXPLOSION_REFLECTION(46,170); +ACE_EXPLOSION_REFLECTION(46,180); +ACE_EXPLOSION_REFLECTION(46,190); +ACE_EXPLOSION_REFLECTION(46,200); +ACE_EXPLOSION_REFLECTION(46,210); +ACE_EXPLOSION_REFLECTION(46,220); +ACE_EXPLOSION_REFLECTION(46,230); +ACE_EXPLOSION_REFLECTION(46,240); +ACE_EXPLOSION_REFLECTION(46,250); +ACE_EXPLOSION_REFLECTION(46,260); +ACE_EXPLOSION_REFLECTION(46,270); +ACE_EXPLOSION_REFLECTION(46,280); +ACE_EXPLOSION_REFLECTION(46,290); +ACE_EXPLOSION_REFLECTION(46,300); +ACE_EXPLOSION_REFLECTION(46,310); +ACE_EXPLOSION_REFLECTION(46,320); +ACE_EXPLOSION_REFLECTION(46,330); +ACE_EXPLOSION_REFLECTION(46,340); +ACE_EXPLOSION_REFLECTION(46,350); +ACE_EXPLOSION_REFLECTION(46,360); +ACE_EXPLOSION_REFLECTION(46,370); +ACE_EXPLOSION_REFLECTION(46,380); +ACE_EXPLOSION_REFLECTION(46,390); +ACE_EXPLOSION_REFLECTION(46,400); +ACE_EXPLOSION_REFLECTION(46,410); +ACE_EXPLOSION_REFLECTION(46,420); +ACE_EXPLOSION_REFLECTION(46,430); +ACE_EXPLOSION_REFLECTION(46,440); +ACE_EXPLOSION_REFLECTION(46,450); +ACE_EXPLOSION_REFLECTION(46,460); +ACE_EXPLOSION_REFLECTION(46,470); +ACE_EXPLOSION_REFLECTION(46,480); +ACE_EXPLOSION_REFLECTION(46,490); +ACE_EXPLOSION_REFLECTION(46,500); +ACE_EXPLOSION_REFLECTION(48,10); +ACE_EXPLOSION_REFLECTION(48,20); +ACE_EXPLOSION_REFLECTION(48,30); +ACE_EXPLOSION_REFLECTION(48,40); +ACE_EXPLOSION_REFLECTION(48,50); +ACE_EXPLOSION_REFLECTION(48,60); +ACE_EXPLOSION_REFLECTION(48,70); +ACE_EXPLOSION_REFLECTION(48,80); +ACE_EXPLOSION_REFLECTION(48,90); +ACE_EXPLOSION_REFLECTION(48,100); +ACE_EXPLOSION_REFLECTION(48,110); +ACE_EXPLOSION_REFLECTION(48,120); +ACE_EXPLOSION_REFLECTION(48,130); +ACE_EXPLOSION_REFLECTION(48,140); +ACE_EXPLOSION_REFLECTION(48,150); +ACE_EXPLOSION_REFLECTION(48,160); +ACE_EXPLOSION_REFLECTION(48,170); +ACE_EXPLOSION_REFLECTION(48,180); +ACE_EXPLOSION_REFLECTION(48,190); +ACE_EXPLOSION_REFLECTION(48,200); +ACE_EXPLOSION_REFLECTION(48,210); +ACE_EXPLOSION_REFLECTION(48,220); +ACE_EXPLOSION_REFLECTION(48,230); +ACE_EXPLOSION_REFLECTION(48,240); +ACE_EXPLOSION_REFLECTION(48,250); +ACE_EXPLOSION_REFLECTION(48,260); +ACE_EXPLOSION_REFLECTION(48,270); +ACE_EXPLOSION_REFLECTION(48,280); +ACE_EXPLOSION_REFLECTION(48,290); +ACE_EXPLOSION_REFLECTION(48,300); +ACE_EXPLOSION_REFLECTION(48,310); +ACE_EXPLOSION_REFLECTION(48,320); +ACE_EXPLOSION_REFLECTION(48,330); +ACE_EXPLOSION_REFLECTION(48,340); +ACE_EXPLOSION_REFLECTION(48,350); +ACE_EXPLOSION_REFLECTION(48,360); +ACE_EXPLOSION_REFLECTION(48,370); +ACE_EXPLOSION_REFLECTION(48,380); +ACE_EXPLOSION_REFLECTION(48,390); +ACE_EXPLOSION_REFLECTION(48,400); +ACE_EXPLOSION_REFLECTION(48,410); +ACE_EXPLOSION_REFLECTION(48,420); +ACE_EXPLOSION_REFLECTION(48,430); +ACE_EXPLOSION_REFLECTION(48,440); +ACE_EXPLOSION_REFLECTION(48,450); +ACE_EXPLOSION_REFLECTION(48,460); +ACE_EXPLOSION_REFLECTION(48,470); +ACE_EXPLOSION_REFLECTION(48,480); +ACE_EXPLOSION_REFLECTION(48,490); +ACE_EXPLOSION_REFLECTION(48,500); +ACE_EXPLOSION_REFLECTION(50,10); +ACE_EXPLOSION_REFLECTION(50,20); +ACE_EXPLOSION_REFLECTION(50,30); +ACE_EXPLOSION_REFLECTION(50,40); +ACE_EXPLOSION_REFLECTION(50,50); +ACE_EXPLOSION_REFLECTION(50,60); +ACE_EXPLOSION_REFLECTION(50,70); +ACE_EXPLOSION_REFLECTION(50,80); +ACE_EXPLOSION_REFLECTION(50,90); +ACE_EXPLOSION_REFLECTION(50,100); +ACE_EXPLOSION_REFLECTION(50,110); +ACE_EXPLOSION_REFLECTION(50,120); +ACE_EXPLOSION_REFLECTION(50,130); +ACE_EXPLOSION_REFLECTION(50,140); +ACE_EXPLOSION_REFLECTION(50,150); +ACE_EXPLOSION_REFLECTION(50,160); +ACE_EXPLOSION_REFLECTION(50,170); +ACE_EXPLOSION_REFLECTION(50,180); +ACE_EXPLOSION_REFLECTION(50,190); +ACE_EXPLOSION_REFLECTION(50,200); +ACE_EXPLOSION_REFLECTION(50,210); +ACE_EXPLOSION_REFLECTION(50,220); +ACE_EXPLOSION_REFLECTION(50,230); +ACE_EXPLOSION_REFLECTION(50,240); +ACE_EXPLOSION_REFLECTION(50,250); +ACE_EXPLOSION_REFLECTION(50,260); +ACE_EXPLOSION_REFLECTION(50,270); +ACE_EXPLOSION_REFLECTION(50,280); +ACE_EXPLOSION_REFLECTION(50,290); +ACE_EXPLOSION_REFLECTION(50,300); +ACE_EXPLOSION_REFLECTION(50,310); +ACE_EXPLOSION_REFLECTION(50,320); +ACE_EXPLOSION_REFLECTION(50,330); +ACE_EXPLOSION_REFLECTION(50,340); +ACE_EXPLOSION_REFLECTION(50,350); +ACE_EXPLOSION_REFLECTION(50,360); +ACE_EXPLOSION_REFLECTION(50,370); +ACE_EXPLOSION_REFLECTION(50,380); +ACE_EXPLOSION_REFLECTION(50,390); +ACE_EXPLOSION_REFLECTION(50,400); +ACE_EXPLOSION_REFLECTION(50,410); +ACE_EXPLOSION_REFLECTION(50,420); +ACE_EXPLOSION_REFLECTION(50,430); +ACE_EXPLOSION_REFLECTION(50,440); +ACE_EXPLOSION_REFLECTION(50,450); +ACE_EXPLOSION_REFLECTION(50,460); +ACE_EXPLOSION_REFLECTION(50,470); +ACE_EXPLOSION_REFLECTION(50,480); +ACE_EXPLOSION_REFLECTION(50,490); +ACE_EXPLOSION_REFLECTION(50,500); +ACE_EXPLOSION_REFLECTION(52,10); +ACE_EXPLOSION_REFLECTION(52,20); +ACE_EXPLOSION_REFLECTION(52,30); +ACE_EXPLOSION_REFLECTION(52,40); +ACE_EXPLOSION_REFLECTION(52,50); +ACE_EXPLOSION_REFLECTION(52,60); +ACE_EXPLOSION_REFLECTION(52,70); +ACE_EXPLOSION_REFLECTION(52,80); +ACE_EXPLOSION_REFLECTION(52,90); +ACE_EXPLOSION_REFLECTION(52,100); +ACE_EXPLOSION_REFLECTION(52,110); +ACE_EXPLOSION_REFLECTION(52,120); +ACE_EXPLOSION_REFLECTION(52,130); +ACE_EXPLOSION_REFLECTION(52,140); +ACE_EXPLOSION_REFLECTION(52,150); +ACE_EXPLOSION_REFLECTION(52,160); +ACE_EXPLOSION_REFLECTION(52,170); +ACE_EXPLOSION_REFLECTION(52,180); +ACE_EXPLOSION_REFLECTION(52,190); +ACE_EXPLOSION_REFLECTION(52,200); +ACE_EXPLOSION_REFLECTION(52,210); +ACE_EXPLOSION_REFLECTION(52,220); +ACE_EXPLOSION_REFLECTION(52,230); +ACE_EXPLOSION_REFLECTION(52,240); +ACE_EXPLOSION_REFLECTION(52,250); +ACE_EXPLOSION_REFLECTION(52,260); +ACE_EXPLOSION_REFLECTION(52,270); +ACE_EXPLOSION_REFLECTION(52,280); +ACE_EXPLOSION_REFLECTION(52,290); +ACE_EXPLOSION_REFLECTION(52,300); +ACE_EXPLOSION_REFLECTION(52,310); +ACE_EXPLOSION_REFLECTION(52,320); +ACE_EXPLOSION_REFLECTION(52,330); +ACE_EXPLOSION_REFLECTION(52,340); +ACE_EXPLOSION_REFLECTION(52,350); +ACE_EXPLOSION_REFLECTION(52,360); +ACE_EXPLOSION_REFLECTION(52,370); +ACE_EXPLOSION_REFLECTION(52,380); +ACE_EXPLOSION_REFLECTION(52,390); +ACE_EXPLOSION_REFLECTION(52,400); +ACE_EXPLOSION_REFLECTION(52,410); +ACE_EXPLOSION_REFLECTION(52,420); +ACE_EXPLOSION_REFLECTION(52,430); +ACE_EXPLOSION_REFLECTION(52,440); +ACE_EXPLOSION_REFLECTION(52,450); +ACE_EXPLOSION_REFLECTION(52,460); +ACE_EXPLOSION_REFLECTION(52,470); +ACE_EXPLOSION_REFLECTION(52,480); +ACE_EXPLOSION_REFLECTION(52,490); +ACE_EXPLOSION_REFLECTION(52,500); +ACE_EXPLOSION_REFLECTION(54,10); +ACE_EXPLOSION_REFLECTION(54,20); +ACE_EXPLOSION_REFLECTION(54,30); +ACE_EXPLOSION_REFLECTION(54,40); +ACE_EXPLOSION_REFLECTION(54,50); +ACE_EXPLOSION_REFLECTION(54,60); +ACE_EXPLOSION_REFLECTION(54,70); +ACE_EXPLOSION_REFLECTION(54,80); +ACE_EXPLOSION_REFLECTION(54,90); +ACE_EXPLOSION_REFLECTION(54,100); +ACE_EXPLOSION_REFLECTION(54,110); +ACE_EXPLOSION_REFLECTION(54,120); +ACE_EXPLOSION_REFLECTION(54,130); +ACE_EXPLOSION_REFLECTION(54,140); +ACE_EXPLOSION_REFLECTION(54,150); +ACE_EXPLOSION_REFLECTION(54,160); +ACE_EXPLOSION_REFLECTION(54,170); +ACE_EXPLOSION_REFLECTION(54,180); +ACE_EXPLOSION_REFLECTION(54,190); +ACE_EXPLOSION_REFLECTION(54,200); +ACE_EXPLOSION_REFLECTION(54,210); +ACE_EXPLOSION_REFLECTION(54,220); +ACE_EXPLOSION_REFLECTION(54,230); +ACE_EXPLOSION_REFLECTION(54,240); +ACE_EXPLOSION_REFLECTION(54,250); +ACE_EXPLOSION_REFLECTION(54,260); +ACE_EXPLOSION_REFLECTION(54,270); +ACE_EXPLOSION_REFLECTION(54,280); +ACE_EXPLOSION_REFLECTION(54,290); +ACE_EXPLOSION_REFLECTION(54,300); +ACE_EXPLOSION_REFLECTION(54,310); +ACE_EXPLOSION_REFLECTION(54,320); +ACE_EXPLOSION_REFLECTION(54,330); +ACE_EXPLOSION_REFLECTION(54,340); +ACE_EXPLOSION_REFLECTION(54,350); +ACE_EXPLOSION_REFLECTION(54,360); +ACE_EXPLOSION_REFLECTION(54,370); +ACE_EXPLOSION_REFLECTION(54,380); +ACE_EXPLOSION_REFLECTION(54,390); +ACE_EXPLOSION_REFLECTION(54,400); +ACE_EXPLOSION_REFLECTION(54,410); +ACE_EXPLOSION_REFLECTION(54,420); +ACE_EXPLOSION_REFLECTION(54,430); +ACE_EXPLOSION_REFLECTION(54,440); +ACE_EXPLOSION_REFLECTION(54,450); +ACE_EXPLOSION_REFLECTION(54,460); +ACE_EXPLOSION_REFLECTION(54,470); +ACE_EXPLOSION_REFLECTION(54,480); +ACE_EXPLOSION_REFLECTION(54,490); +ACE_EXPLOSION_REFLECTION(54,500); +ACE_EXPLOSION_REFLECTION(56,10); +ACE_EXPLOSION_REFLECTION(56,20); +ACE_EXPLOSION_REFLECTION(56,30); +ACE_EXPLOSION_REFLECTION(56,40); +ACE_EXPLOSION_REFLECTION(56,50); +ACE_EXPLOSION_REFLECTION(56,60); +ACE_EXPLOSION_REFLECTION(56,70); +ACE_EXPLOSION_REFLECTION(56,80); +ACE_EXPLOSION_REFLECTION(56,90); +ACE_EXPLOSION_REFLECTION(56,100); +ACE_EXPLOSION_REFLECTION(56,110); +ACE_EXPLOSION_REFLECTION(56,120); +ACE_EXPLOSION_REFLECTION(56,130); +ACE_EXPLOSION_REFLECTION(56,140); +ACE_EXPLOSION_REFLECTION(56,150); +ACE_EXPLOSION_REFLECTION(56,160); +ACE_EXPLOSION_REFLECTION(56,170); +ACE_EXPLOSION_REFLECTION(56,180); +ACE_EXPLOSION_REFLECTION(56,190); +ACE_EXPLOSION_REFLECTION(56,200); +ACE_EXPLOSION_REFLECTION(56,210); +ACE_EXPLOSION_REFLECTION(56,220); +ACE_EXPLOSION_REFLECTION(56,230); +ACE_EXPLOSION_REFLECTION(56,240); +ACE_EXPLOSION_REFLECTION(56,250); +ACE_EXPLOSION_REFLECTION(56,260); +ACE_EXPLOSION_REFLECTION(56,270); +ACE_EXPLOSION_REFLECTION(56,280); +ACE_EXPLOSION_REFLECTION(56,290); +ACE_EXPLOSION_REFLECTION(56,300); +ACE_EXPLOSION_REFLECTION(56,310); +ACE_EXPLOSION_REFLECTION(56,320); +ACE_EXPLOSION_REFLECTION(56,330); +ACE_EXPLOSION_REFLECTION(56,340); +ACE_EXPLOSION_REFLECTION(56,350); +ACE_EXPLOSION_REFLECTION(56,360); +ACE_EXPLOSION_REFLECTION(56,370); +ACE_EXPLOSION_REFLECTION(56,380); +ACE_EXPLOSION_REFLECTION(56,390); +ACE_EXPLOSION_REFLECTION(56,400); +ACE_EXPLOSION_REFLECTION(56,410); +ACE_EXPLOSION_REFLECTION(56,420); +ACE_EXPLOSION_REFLECTION(56,430); +ACE_EXPLOSION_REFLECTION(56,440); +ACE_EXPLOSION_REFLECTION(56,450); +ACE_EXPLOSION_REFLECTION(56,460); +ACE_EXPLOSION_REFLECTION(56,470); +ACE_EXPLOSION_REFLECTION(56,480); +ACE_EXPLOSION_REFLECTION(56,490); +ACE_EXPLOSION_REFLECTION(56,500); +ACE_EXPLOSION_REFLECTION(58,10); +ACE_EXPLOSION_REFLECTION(58,20); +ACE_EXPLOSION_REFLECTION(58,30); +ACE_EXPLOSION_REFLECTION(58,40); +ACE_EXPLOSION_REFLECTION(58,50); +ACE_EXPLOSION_REFLECTION(58,60); +ACE_EXPLOSION_REFLECTION(58,70); +ACE_EXPLOSION_REFLECTION(58,80); +ACE_EXPLOSION_REFLECTION(58,90); +ACE_EXPLOSION_REFLECTION(58,100); +ACE_EXPLOSION_REFLECTION(58,110); +ACE_EXPLOSION_REFLECTION(58,120); +ACE_EXPLOSION_REFLECTION(58,130); +ACE_EXPLOSION_REFLECTION(58,140); +ACE_EXPLOSION_REFLECTION(58,150); +ACE_EXPLOSION_REFLECTION(58,160); +ACE_EXPLOSION_REFLECTION(58,170); +ACE_EXPLOSION_REFLECTION(58,180); +ACE_EXPLOSION_REFLECTION(58,190); +ACE_EXPLOSION_REFLECTION(58,200); +ACE_EXPLOSION_REFLECTION(58,210); +ACE_EXPLOSION_REFLECTION(58,220); +ACE_EXPLOSION_REFLECTION(58,230); +ACE_EXPLOSION_REFLECTION(58,240); +ACE_EXPLOSION_REFLECTION(58,250); +ACE_EXPLOSION_REFLECTION(58,260); +ACE_EXPLOSION_REFLECTION(58,270); +ACE_EXPLOSION_REFLECTION(58,280); +ACE_EXPLOSION_REFLECTION(58,290); +ACE_EXPLOSION_REFLECTION(58,300); +ACE_EXPLOSION_REFLECTION(58,310); +ACE_EXPLOSION_REFLECTION(58,320); +ACE_EXPLOSION_REFLECTION(58,330); +ACE_EXPLOSION_REFLECTION(58,340); +ACE_EXPLOSION_REFLECTION(58,350); +ACE_EXPLOSION_REFLECTION(58,360); +ACE_EXPLOSION_REFLECTION(58,370); +ACE_EXPLOSION_REFLECTION(58,380); +ACE_EXPLOSION_REFLECTION(58,390); +ACE_EXPLOSION_REFLECTION(58,400); +ACE_EXPLOSION_REFLECTION(58,410); +ACE_EXPLOSION_REFLECTION(58,420); +ACE_EXPLOSION_REFLECTION(58,430); +ACE_EXPLOSION_REFLECTION(58,440); +ACE_EXPLOSION_REFLECTION(58,450); +ACE_EXPLOSION_REFLECTION(58,460); +ACE_EXPLOSION_REFLECTION(58,470); +ACE_EXPLOSION_REFLECTION(58,480); +ACE_EXPLOSION_REFLECTION(58,490); +ACE_EXPLOSION_REFLECTION(58,500); +ACE_EXPLOSION_REFLECTION(60,10); +ACE_EXPLOSION_REFLECTION(60,20); +ACE_EXPLOSION_REFLECTION(60,30); +ACE_EXPLOSION_REFLECTION(60,40); +ACE_EXPLOSION_REFLECTION(60,50); +ACE_EXPLOSION_REFLECTION(60,60); +ACE_EXPLOSION_REFLECTION(60,70); +ACE_EXPLOSION_REFLECTION(60,80); +ACE_EXPLOSION_REFLECTION(60,90); +ACE_EXPLOSION_REFLECTION(60,100); +ACE_EXPLOSION_REFLECTION(60,110); +ACE_EXPLOSION_REFLECTION(60,120); +ACE_EXPLOSION_REFLECTION(60,130); +ACE_EXPLOSION_REFLECTION(60,140); +ACE_EXPLOSION_REFLECTION(60,150); +ACE_EXPLOSION_REFLECTION(60,160); +ACE_EXPLOSION_REFLECTION(60,170); +ACE_EXPLOSION_REFLECTION(60,180); +ACE_EXPLOSION_REFLECTION(60,190); +ACE_EXPLOSION_REFLECTION(60,200); +ACE_EXPLOSION_REFLECTION(60,210); +ACE_EXPLOSION_REFLECTION(60,220); +ACE_EXPLOSION_REFLECTION(60,230); +ACE_EXPLOSION_REFLECTION(60,240); +ACE_EXPLOSION_REFLECTION(60,250); +ACE_EXPLOSION_REFLECTION(60,260); +ACE_EXPLOSION_REFLECTION(60,270); +ACE_EXPLOSION_REFLECTION(60,280); +ACE_EXPLOSION_REFLECTION(60,290); +ACE_EXPLOSION_REFLECTION(60,300); +ACE_EXPLOSION_REFLECTION(60,310); +ACE_EXPLOSION_REFLECTION(60,320); +ACE_EXPLOSION_REFLECTION(60,330); +ACE_EXPLOSION_REFLECTION(60,340); +ACE_EXPLOSION_REFLECTION(60,350); +ACE_EXPLOSION_REFLECTION(60,360); +ACE_EXPLOSION_REFLECTION(60,370); +ACE_EXPLOSION_REFLECTION(60,380); +ACE_EXPLOSION_REFLECTION(60,390); +ACE_EXPLOSION_REFLECTION(60,400); +ACE_EXPLOSION_REFLECTION(60,410); +ACE_EXPLOSION_REFLECTION(60,420); +ACE_EXPLOSION_REFLECTION(60,430); +ACE_EXPLOSION_REFLECTION(60,440); +ACE_EXPLOSION_REFLECTION(60,450); +ACE_EXPLOSION_REFLECTION(60,460); +ACE_EXPLOSION_REFLECTION(60,470); +ACE_EXPLOSION_REFLECTION(60,480); +ACE_EXPLOSION_REFLECTION(60,490); +ACE_EXPLOSION_REFLECTION(60,500); +ACE_EXPLOSION_REFLECTION(62,10); +ACE_EXPLOSION_REFLECTION(62,20); +ACE_EXPLOSION_REFLECTION(62,30); +ACE_EXPLOSION_REFLECTION(62,40); +ACE_EXPLOSION_REFLECTION(62,50); +ACE_EXPLOSION_REFLECTION(62,60); +ACE_EXPLOSION_REFLECTION(62,70); +ACE_EXPLOSION_REFLECTION(62,80); +ACE_EXPLOSION_REFLECTION(62,90); +ACE_EXPLOSION_REFLECTION(62,100); +ACE_EXPLOSION_REFLECTION(62,110); +ACE_EXPLOSION_REFLECTION(62,120); +ACE_EXPLOSION_REFLECTION(62,130); +ACE_EXPLOSION_REFLECTION(62,140); +ACE_EXPLOSION_REFLECTION(62,150); +ACE_EXPLOSION_REFLECTION(62,160); +ACE_EXPLOSION_REFLECTION(62,170); +ACE_EXPLOSION_REFLECTION(62,180); +ACE_EXPLOSION_REFLECTION(62,190); +ACE_EXPLOSION_REFLECTION(62,200); +ACE_EXPLOSION_REFLECTION(62,210); +ACE_EXPLOSION_REFLECTION(62,220); +ACE_EXPLOSION_REFLECTION(62,230); +ACE_EXPLOSION_REFLECTION(62,240); +ACE_EXPLOSION_REFLECTION(62,250); +ACE_EXPLOSION_REFLECTION(62,260); +ACE_EXPLOSION_REFLECTION(62,270); +ACE_EXPLOSION_REFLECTION(62,280); +ACE_EXPLOSION_REFLECTION(62,290); +ACE_EXPLOSION_REFLECTION(62,300); +ACE_EXPLOSION_REFLECTION(62,310); +ACE_EXPLOSION_REFLECTION(62,320); +ACE_EXPLOSION_REFLECTION(62,330); +ACE_EXPLOSION_REFLECTION(62,340); +ACE_EXPLOSION_REFLECTION(62,350); +ACE_EXPLOSION_REFLECTION(62,360); +ACE_EXPLOSION_REFLECTION(62,370); +ACE_EXPLOSION_REFLECTION(62,380); +ACE_EXPLOSION_REFLECTION(62,390); +ACE_EXPLOSION_REFLECTION(62,400); +ACE_EXPLOSION_REFLECTION(62,410); +ACE_EXPLOSION_REFLECTION(62,420); +ACE_EXPLOSION_REFLECTION(62,430); +ACE_EXPLOSION_REFLECTION(62,440); +ACE_EXPLOSION_REFLECTION(62,450); +ACE_EXPLOSION_REFLECTION(62,460); +ACE_EXPLOSION_REFLECTION(62,470); +ACE_EXPLOSION_REFLECTION(62,480); +ACE_EXPLOSION_REFLECTION(62,490); +ACE_EXPLOSION_REFLECTION(62,500); +ACE_EXPLOSION_REFLECTION(64,10); +ACE_EXPLOSION_REFLECTION(64,20); +ACE_EXPLOSION_REFLECTION(64,30); +ACE_EXPLOSION_REFLECTION(64,40); +ACE_EXPLOSION_REFLECTION(64,50); +ACE_EXPLOSION_REFLECTION(64,60); +ACE_EXPLOSION_REFLECTION(64,70); +ACE_EXPLOSION_REFLECTION(64,80); +ACE_EXPLOSION_REFLECTION(64,90); +ACE_EXPLOSION_REFLECTION(64,100); +ACE_EXPLOSION_REFLECTION(64,110); +ACE_EXPLOSION_REFLECTION(64,120); +ACE_EXPLOSION_REFLECTION(64,130); +ACE_EXPLOSION_REFLECTION(64,140); +ACE_EXPLOSION_REFLECTION(64,150); +ACE_EXPLOSION_REFLECTION(64,160); +ACE_EXPLOSION_REFLECTION(64,170); +ACE_EXPLOSION_REFLECTION(64,180); +ACE_EXPLOSION_REFLECTION(64,190); +ACE_EXPLOSION_REFLECTION(64,200); +ACE_EXPLOSION_REFLECTION(64,210); +ACE_EXPLOSION_REFLECTION(64,220); +ACE_EXPLOSION_REFLECTION(64,230); +ACE_EXPLOSION_REFLECTION(64,240); +ACE_EXPLOSION_REFLECTION(64,250); +ACE_EXPLOSION_REFLECTION(64,260); +ACE_EXPLOSION_REFLECTION(64,270); +ACE_EXPLOSION_REFLECTION(64,280); +ACE_EXPLOSION_REFLECTION(64,290); +ACE_EXPLOSION_REFLECTION(64,300); +ACE_EXPLOSION_REFLECTION(64,310); +ACE_EXPLOSION_REFLECTION(64,320); +ACE_EXPLOSION_REFLECTION(64,330); +ACE_EXPLOSION_REFLECTION(64,340); +ACE_EXPLOSION_REFLECTION(64,350); +ACE_EXPLOSION_REFLECTION(64,360); +ACE_EXPLOSION_REFLECTION(64,370); +ACE_EXPLOSION_REFLECTION(64,380); +ACE_EXPLOSION_REFLECTION(64,390); +ACE_EXPLOSION_REFLECTION(64,400); +ACE_EXPLOSION_REFLECTION(64,410); +ACE_EXPLOSION_REFLECTION(64,420); +ACE_EXPLOSION_REFLECTION(64,430); +ACE_EXPLOSION_REFLECTION(64,440); +ACE_EXPLOSION_REFLECTION(64,450); +ACE_EXPLOSION_REFLECTION(64,460); +ACE_EXPLOSION_REFLECTION(64,470); +ACE_EXPLOSION_REFLECTION(64,480); +ACE_EXPLOSION_REFLECTION(64,490); +ACE_EXPLOSION_REFLECTION(64,500); +ACE_EXPLOSION_REFLECTION(66,10); +ACE_EXPLOSION_REFLECTION(66,20); +ACE_EXPLOSION_REFLECTION(66,30); +ACE_EXPLOSION_REFLECTION(66,40); +ACE_EXPLOSION_REFLECTION(66,50); +ACE_EXPLOSION_REFLECTION(66,60); +ACE_EXPLOSION_REFLECTION(66,70); +ACE_EXPLOSION_REFLECTION(66,80); +ACE_EXPLOSION_REFLECTION(66,90); +ACE_EXPLOSION_REFLECTION(66,100); +ACE_EXPLOSION_REFLECTION(66,110); +ACE_EXPLOSION_REFLECTION(66,120); +ACE_EXPLOSION_REFLECTION(66,130); +ACE_EXPLOSION_REFLECTION(66,140); +ACE_EXPLOSION_REFLECTION(66,150); +ACE_EXPLOSION_REFLECTION(66,160); +ACE_EXPLOSION_REFLECTION(66,170); +ACE_EXPLOSION_REFLECTION(66,180); +ACE_EXPLOSION_REFLECTION(66,190); +ACE_EXPLOSION_REFLECTION(66,200); +ACE_EXPLOSION_REFLECTION(66,210); +ACE_EXPLOSION_REFLECTION(66,220); +ACE_EXPLOSION_REFLECTION(66,230); +ACE_EXPLOSION_REFLECTION(66,240); +ACE_EXPLOSION_REFLECTION(66,250); +ACE_EXPLOSION_REFLECTION(66,260); +ACE_EXPLOSION_REFLECTION(66,270); +ACE_EXPLOSION_REFLECTION(66,280); +ACE_EXPLOSION_REFLECTION(66,290); +ACE_EXPLOSION_REFLECTION(66,300); +ACE_EXPLOSION_REFLECTION(66,310); +ACE_EXPLOSION_REFLECTION(66,320); +ACE_EXPLOSION_REFLECTION(66,330); +ACE_EXPLOSION_REFLECTION(66,340); +ACE_EXPLOSION_REFLECTION(66,350); +ACE_EXPLOSION_REFLECTION(66,360); +ACE_EXPLOSION_REFLECTION(66,370); +ACE_EXPLOSION_REFLECTION(66,380); +ACE_EXPLOSION_REFLECTION(66,390); +ACE_EXPLOSION_REFLECTION(66,400); +ACE_EXPLOSION_REFLECTION(66,410); +ACE_EXPLOSION_REFLECTION(66,420); +ACE_EXPLOSION_REFLECTION(66,430); +ACE_EXPLOSION_REFLECTION(66,440); +ACE_EXPLOSION_REFLECTION(66,450); +ACE_EXPLOSION_REFLECTION(66,460); +ACE_EXPLOSION_REFLECTION(66,470); +ACE_EXPLOSION_REFLECTION(66,480); +ACE_EXPLOSION_REFLECTION(66,490); +ACE_EXPLOSION_REFLECTION(66,500); +ACE_EXPLOSION_REFLECTION(68,10); +ACE_EXPLOSION_REFLECTION(68,20); +ACE_EXPLOSION_REFLECTION(68,30); +ACE_EXPLOSION_REFLECTION(68,40); +ACE_EXPLOSION_REFLECTION(68,50); +ACE_EXPLOSION_REFLECTION(68,60); +ACE_EXPLOSION_REFLECTION(68,70); +ACE_EXPLOSION_REFLECTION(68,80); +ACE_EXPLOSION_REFLECTION(68,90); +ACE_EXPLOSION_REFLECTION(68,100); +ACE_EXPLOSION_REFLECTION(68,110); +ACE_EXPLOSION_REFLECTION(68,120); +ACE_EXPLOSION_REFLECTION(68,130); +ACE_EXPLOSION_REFLECTION(68,140); +ACE_EXPLOSION_REFLECTION(68,150); +ACE_EXPLOSION_REFLECTION(68,160); +ACE_EXPLOSION_REFLECTION(68,170); +ACE_EXPLOSION_REFLECTION(68,180); +ACE_EXPLOSION_REFLECTION(68,190); +ACE_EXPLOSION_REFLECTION(68,200); +ACE_EXPLOSION_REFLECTION(68,210); +ACE_EXPLOSION_REFLECTION(68,220); +ACE_EXPLOSION_REFLECTION(68,230); +ACE_EXPLOSION_REFLECTION(68,240); +ACE_EXPLOSION_REFLECTION(68,250); +ACE_EXPLOSION_REFLECTION(68,260); +ACE_EXPLOSION_REFLECTION(68,270); +ACE_EXPLOSION_REFLECTION(68,280); +ACE_EXPLOSION_REFLECTION(68,290); +ACE_EXPLOSION_REFLECTION(68,300); +ACE_EXPLOSION_REFLECTION(68,310); +ACE_EXPLOSION_REFLECTION(68,320); +ACE_EXPLOSION_REFLECTION(68,330); +ACE_EXPLOSION_REFLECTION(68,340); +ACE_EXPLOSION_REFLECTION(68,350); +ACE_EXPLOSION_REFLECTION(68,360); +ACE_EXPLOSION_REFLECTION(68,370); +ACE_EXPLOSION_REFLECTION(68,380); +ACE_EXPLOSION_REFLECTION(68,390); +ACE_EXPLOSION_REFLECTION(68,400); +ACE_EXPLOSION_REFLECTION(68,410); +ACE_EXPLOSION_REFLECTION(68,420); +ACE_EXPLOSION_REFLECTION(68,430); +ACE_EXPLOSION_REFLECTION(68,440); +ACE_EXPLOSION_REFLECTION(68,450); +ACE_EXPLOSION_REFLECTION(68,460); +ACE_EXPLOSION_REFLECTION(68,470); +ACE_EXPLOSION_REFLECTION(68,480); +ACE_EXPLOSION_REFLECTION(68,490); +ACE_EXPLOSION_REFLECTION(68,500); +ACE_EXPLOSION_REFLECTION(70,10); +ACE_EXPLOSION_REFLECTION(70,20); +ACE_EXPLOSION_REFLECTION(70,30); +ACE_EXPLOSION_REFLECTION(70,40); +ACE_EXPLOSION_REFLECTION(70,50); +ACE_EXPLOSION_REFLECTION(70,60); +ACE_EXPLOSION_REFLECTION(70,70); +ACE_EXPLOSION_REFLECTION(70,80); +ACE_EXPLOSION_REFLECTION(70,90); +ACE_EXPLOSION_REFLECTION(70,100); +ACE_EXPLOSION_REFLECTION(70,110); +ACE_EXPLOSION_REFLECTION(70,120); +ACE_EXPLOSION_REFLECTION(70,130); +ACE_EXPLOSION_REFLECTION(70,140); +ACE_EXPLOSION_REFLECTION(70,150); +ACE_EXPLOSION_REFLECTION(70,160); +ACE_EXPLOSION_REFLECTION(70,170); +ACE_EXPLOSION_REFLECTION(70,180); +ACE_EXPLOSION_REFLECTION(70,190); +ACE_EXPLOSION_REFLECTION(70,200); +ACE_EXPLOSION_REFLECTION(70,210); +ACE_EXPLOSION_REFLECTION(70,220); +ACE_EXPLOSION_REFLECTION(70,230); +ACE_EXPLOSION_REFLECTION(70,240); +ACE_EXPLOSION_REFLECTION(70,250); +ACE_EXPLOSION_REFLECTION(70,260); +ACE_EXPLOSION_REFLECTION(70,270); +ACE_EXPLOSION_REFLECTION(70,280); +ACE_EXPLOSION_REFLECTION(70,290); +ACE_EXPLOSION_REFLECTION(70,300); +ACE_EXPLOSION_REFLECTION(70,310); +ACE_EXPLOSION_REFLECTION(70,320); +ACE_EXPLOSION_REFLECTION(70,330); +ACE_EXPLOSION_REFLECTION(70,340); +ACE_EXPLOSION_REFLECTION(70,350); +ACE_EXPLOSION_REFLECTION(70,360); +ACE_EXPLOSION_REFLECTION(70,370); +ACE_EXPLOSION_REFLECTION(70,380); +ACE_EXPLOSION_REFLECTION(70,390); +ACE_EXPLOSION_REFLECTION(70,400); +ACE_EXPLOSION_REFLECTION(70,410); +ACE_EXPLOSION_REFLECTION(70,420); +ACE_EXPLOSION_REFLECTION(70,430); +ACE_EXPLOSION_REFLECTION(70,440); +ACE_EXPLOSION_REFLECTION(70,450); +ACE_EXPLOSION_REFLECTION(70,460); +ACE_EXPLOSION_REFLECTION(70,470); +ACE_EXPLOSION_REFLECTION(70,480); +ACE_EXPLOSION_REFLECTION(70,490); +ACE_EXPLOSION_REFLECTION(70,500); +ACE_EXPLOSION_REFLECTION(72,10); +ACE_EXPLOSION_REFLECTION(72,20); +ACE_EXPLOSION_REFLECTION(72,30); +ACE_EXPLOSION_REFLECTION(72,40); +ACE_EXPLOSION_REFLECTION(72,50); +ACE_EXPLOSION_REFLECTION(72,60); +ACE_EXPLOSION_REFLECTION(72,70); +ACE_EXPLOSION_REFLECTION(72,80); +ACE_EXPLOSION_REFLECTION(72,90); +ACE_EXPLOSION_REFLECTION(72,100); +ACE_EXPLOSION_REFLECTION(72,110); +ACE_EXPLOSION_REFLECTION(72,120); +ACE_EXPLOSION_REFLECTION(72,130); +ACE_EXPLOSION_REFLECTION(72,140); +ACE_EXPLOSION_REFLECTION(72,150); +ACE_EXPLOSION_REFLECTION(72,160); +ACE_EXPLOSION_REFLECTION(72,170); +ACE_EXPLOSION_REFLECTION(72,180); +ACE_EXPLOSION_REFLECTION(72,190); +ACE_EXPLOSION_REFLECTION(72,200); +ACE_EXPLOSION_REFLECTION(72,210); +ACE_EXPLOSION_REFLECTION(72,220); +ACE_EXPLOSION_REFLECTION(72,230); +ACE_EXPLOSION_REFLECTION(72,240); +ACE_EXPLOSION_REFLECTION(72,250); +ACE_EXPLOSION_REFLECTION(72,260); +ACE_EXPLOSION_REFLECTION(72,270); +ACE_EXPLOSION_REFLECTION(72,280); +ACE_EXPLOSION_REFLECTION(72,290); +ACE_EXPLOSION_REFLECTION(72,300); +ACE_EXPLOSION_REFLECTION(72,310); +ACE_EXPLOSION_REFLECTION(72,320); +ACE_EXPLOSION_REFLECTION(72,330); +ACE_EXPLOSION_REFLECTION(72,340); +ACE_EXPLOSION_REFLECTION(72,350); +ACE_EXPLOSION_REFLECTION(72,360); +ACE_EXPLOSION_REFLECTION(72,370); +ACE_EXPLOSION_REFLECTION(72,380); +ACE_EXPLOSION_REFLECTION(72,390); +ACE_EXPLOSION_REFLECTION(72,400); +ACE_EXPLOSION_REFLECTION(72,410); +ACE_EXPLOSION_REFLECTION(72,420); +ACE_EXPLOSION_REFLECTION(72,430); +ACE_EXPLOSION_REFLECTION(72,440); +ACE_EXPLOSION_REFLECTION(72,450); +ACE_EXPLOSION_REFLECTION(72,460); +ACE_EXPLOSION_REFLECTION(72,470); +ACE_EXPLOSION_REFLECTION(72,480); +ACE_EXPLOSION_REFLECTION(72,490); +ACE_EXPLOSION_REFLECTION(72,500); +ACE_EXPLOSION_REFLECTION(74,10); +ACE_EXPLOSION_REFLECTION(74,20); +ACE_EXPLOSION_REFLECTION(74,30); +ACE_EXPLOSION_REFLECTION(74,40); +ACE_EXPLOSION_REFLECTION(74,50); +ACE_EXPLOSION_REFLECTION(74,60); +ACE_EXPLOSION_REFLECTION(74,70); +ACE_EXPLOSION_REFLECTION(74,80); +ACE_EXPLOSION_REFLECTION(74,90); +ACE_EXPLOSION_REFLECTION(74,100); +ACE_EXPLOSION_REFLECTION(74,110); +ACE_EXPLOSION_REFLECTION(74,120); +ACE_EXPLOSION_REFLECTION(74,130); +ACE_EXPLOSION_REFLECTION(74,140); +ACE_EXPLOSION_REFLECTION(74,150); +ACE_EXPLOSION_REFLECTION(74,160); +ACE_EXPLOSION_REFLECTION(74,170); +ACE_EXPLOSION_REFLECTION(74,180); +ACE_EXPLOSION_REFLECTION(74,190); +ACE_EXPLOSION_REFLECTION(74,200); +ACE_EXPLOSION_REFLECTION(74,210); +ACE_EXPLOSION_REFLECTION(74,220); +ACE_EXPLOSION_REFLECTION(74,230); +ACE_EXPLOSION_REFLECTION(74,240); +ACE_EXPLOSION_REFLECTION(74,250); +ACE_EXPLOSION_REFLECTION(74,260); +ACE_EXPLOSION_REFLECTION(74,270); +ACE_EXPLOSION_REFLECTION(74,280); +ACE_EXPLOSION_REFLECTION(74,290); +ACE_EXPLOSION_REFLECTION(74,300); +ACE_EXPLOSION_REFLECTION(74,310); +ACE_EXPLOSION_REFLECTION(74,320); +ACE_EXPLOSION_REFLECTION(74,330); +ACE_EXPLOSION_REFLECTION(74,340); +ACE_EXPLOSION_REFLECTION(74,350); +ACE_EXPLOSION_REFLECTION(74,360); +ACE_EXPLOSION_REFLECTION(74,370); +ACE_EXPLOSION_REFLECTION(74,380); +ACE_EXPLOSION_REFLECTION(74,390); +ACE_EXPLOSION_REFLECTION(74,400); +ACE_EXPLOSION_REFLECTION(74,410); +ACE_EXPLOSION_REFLECTION(74,420); +ACE_EXPLOSION_REFLECTION(74,430); +ACE_EXPLOSION_REFLECTION(74,440); +ACE_EXPLOSION_REFLECTION(74,450); +ACE_EXPLOSION_REFLECTION(74,460); +ACE_EXPLOSION_REFLECTION(74,470); +ACE_EXPLOSION_REFLECTION(74,480); +ACE_EXPLOSION_REFLECTION(74,490); +ACE_EXPLOSION_REFLECTION(74,500); +ACE_EXPLOSION_REFLECTION(76,10); +ACE_EXPLOSION_REFLECTION(76,20); +ACE_EXPLOSION_REFLECTION(76,30); +ACE_EXPLOSION_REFLECTION(76,40); +ACE_EXPLOSION_REFLECTION(76,50); +ACE_EXPLOSION_REFLECTION(76,60); +ACE_EXPLOSION_REFLECTION(76,70); +ACE_EXPLOSION_REFLECTION(76,80); +ACE_EXPLOSION_REFLECTION(76,90); +ACE_EXPLOSION_REFLECTION(76,100); +ACE_EXPLOSION_REFLECTION(76,110); +ACE_EXPLOSION_REFLECTION(76,120); +ACE_EXPLOSION_REFLECTION(76,130); +ACE_EXPLOSION_REFLECTION(76,140); +ACE_EXPLOSION_REFLECTION(76,150); +ACE_EXPLOSION_REFLECTION(76,160); +ACE_EXPLOSION_REFLECTION(76,170); +ACE_EXPLOSION_REFLECTION(76,180); +ACE_EXPLOSION_REFLECTION(76,190); +ACE_EXPLOSION_REFLECTION(76,200); +ACE_EXPLOSION_REFLECTION(76,210); +ACE_EXPLOSION_REFLECTION(76,220); +ACE_EXPLOSION_REFLECTION(76,230); +ACE_EXPLOSION_REFLECTION(76,240); +ACE_EXPLOSION_REFLECTION(76,250); +ACE_EXPLOSION_REFLECTION(76,260); +ACE_EXPLOSION_REFLECTION(76,270); +ACE_EXPLOSION_REFLECTION(76,280); +ACE_EXPLOSION_REFLECTION(76,290); +ACE_EXPLOSION_REFLECTION(76,300); +ACE_EXPLOSION_REFLECTION(76,310); +ACE_EXPLOSION_REFLECTION(76,320); +ACE_EXPLOSION_REFLECTION(76,330); +ACE_EXPLOSION_REFLECTION(76,340); +ACE_EXPLOSION_REFLECTION(76,350); +ACE_EXPLOSION_REFLECTION(76,360); +ACE_EXPLOSION_REFLECTION(76,370); +ACE_EXPLOSION_REFLECTION(76,380); +ACE_EXPLOSION_REFLECTION(76,390); +ACE_EXPLOSION_REFLECTION(76,400); +ACE_EXPLOSION_REFLECTION(76,410); +ACE_EXPLOSION_REFLECTION(76,420); +ACE_EXPLOSION_REFLECTION(76,430); +ACE_EXPLOSION_REFLECTION(76,440); +ACE_EXPLOSION_REFLECTION(76,450); +ACE_EXPLOSION_REFLECTION(76,460); +ACE_EXPLOSION_REFLECTION(76,470); +ACE_EXPLOSION_REFLECTION(76,480); +ACE_EXPLOSION_REFLECTION(76,490); +ACE_EXPLOSION_REFLECTION(76,500); +ACE_EXPLOSION_REFLECTION(78,10); +ACE_EXPLOSION_REFLECTION(78,20); +ACE_EXPLOSION_REFLECTION(78,30); +ACE_EXPLOSION_REFLECTION(78,40); +ACE_EXPLOSION_REFLECTION(78,50); +ACE_EXPLOSION_REFLECTION(78,60); +ACE_EXPLOSION_REFLECTION(78,70); +ACE_EXPLOSION_REFLECTION(78,80); +ACE_EXPLOSION_REFLECTION(78,90); +ACE_EXPLOSION_REFLECTION(78,100); +ACE_EXPLOSION_REFLECTION(78,110); +ACE_EXPLOSION_REFLECTION(78,120); +ACE_EXPLOSION_REFLECTION(78,130); +ACE_EXPLOSION_REFLECTION(78,140); +ACE_EXPLOSION_REFLECTION(78,150); +ACE_EXPLOSION_REFLECTION(78,160); +ACE_EXPLOSION_REFLECTION(78,170); +ACE_EXPLOSION_REFLECTION(78,180); +ACE_EXPLOSION_REFLECTION(78,190); +ACE_EXPLOSION_REFLECTION(78,200); +ACE_EXPLOSION_REFLECTION(78,210); +ACE_EXPLOSION_REFLECTION(78,220); +ACE_EXPLOSION_REFLECTION(78,230); +ACE_EXPLOSION_REFLECTION(78,240); +ACE_EXPLOSION_REFLECTION(78,250); +ACE_EXPLOSION_REFLECTION(78,260); +ACE_EXPLOSION_REFLECTION(78,270); +ACE_EXPLOSION_REFLECTION(78,280); +ACE_EXPLOSION_REFLECTION(78,290); +ACE_EXPLOSION_REFLECTION(78,300); +ACE_EXPLOSION_REFLECTION(78,310); +ACE_EXPLOSION_REFLECTION(78,320); +ACE_EXPLOSION_REFLECTION(78,330); +ACE_EXPLOSION_REFLECTION(78,340); +ACE_EXPLOSION_REFLECTION(78,350); +ACE_EXPLOSION_REFLECTION(78,360); +ACE_EXPLOSION_REFLECTION(78,370); +ACE_EXPLOSION_REFLECTION(78,380); +ACE_EXPLOSION_REFLECTION(78,390); +ACE_EXPLOSION_REFLECTION(78,400); +ACE_EXPLOSION_REFLECTION(78,410); +ACE_EXPLOSION_REFLECTION(78,420); +ACE_EXPLOSION_REFLECTION(78,430); +ACE_EXPLOSION_REFLECTION(78,440); +ACE_EXPLOSION_REFLECTION(78,450); +ACE_EXPLOSION_REFLECTION(78,460); +ACE_EXPLOSION_REFLECTION(78,470); +ACE_EXPLOSION_REFLECTION(78,480); +ACE_EXPLOSION_REFLECTION(78,490); +ACE_EXPLOSION_REFLECTION(78,500); +ACE_EXPLOSION_REFLECTION(80,10); +ACE_EXPLOSION_REFLECTION(80,20); +ACE_EXPLOSION_REFLECTION(80,30); +ACE_EXPLOSION_REFLECTION(80,40); +ACE_EXPLOSION_REFLECTION(80,50); +ACE_EXPLOSION_REFLECTION(80,60); +ACE_EXPLOSION_REFLECTION(80,70); +ACE_EXPLOSION_REFLECTION(80,80); +ACE_EXPLOSION_REFLECTION(80,90); +ACE_EXPLOSION_REFLECTION(80,100); +ACE_EXPLOSION_REFLECTION(80,110); +ACE_EXPLOSION_REFLECTION(80,120); +ACE_EXPLOSION_REFLECTION(80,130); +ACE_EXPLOSION_REFLECTION(80,140); +ACE_EXPLOSION_REFLECTION(80,150); +ACE_EXPLOSION_REFLECTION(80,160); +ACE_EXPLOSION_REFLECTION(80,170); +ACE_EXPLOSION_REFLECTION(80,180); +ACE_EXPLOSION_REFLECTION(80,190); +ACE_EXPLOSION_REFLECTION(80,200); +ACE_EXPLOSION_REFLECTION(80,210); +ACE_EXPLOSION_REFLECTION(80,220); +ACE_EXPLOSION_REFLECTION(80,230); +ACE_EXPLOSION_REFLECTION(80,240); +ACE_EXPLOSION_REFLECTION(80,250); +ACE_EXPLOSION_REFLECTION(80,260); +ACE_EXPLOSION_REFLECTION(80,270); +ACE_EXPLOSION_REFLECTION(80,280); +ACE_EXPLOSION_REFLECTION(80,290); +ACE_EXPLOSION_REFLECTION(80,300); +ACE_EXPLOSION_REFLECTION(80,310); +ACE_EXPLOSION_REFLECTION(80,320); +ACE_EXPLOSION_REFLECTION(80,330); +ACE_EXPLOSION_REFLECTION(80,340); +ACE_EXPLOSION_REFLECTION(80,350); +ACE_EXPLOSION_REFLECTION(80,360); +ACE_EXPLOSION_REFLECTION(80,370); +ACE_EXPLOSION_REFLECTION(80,380); +ACE_EXPLOSION_REFLECTION(80,390); +ACE_EXPLOSION_REFLECTION(80,400); +ACE_EXPLOSION_REFLECTION(80,410); +ACE_EXPLOSION_REFLECTION(80,420); +ACE_EXPLOSION_REFLECTION(80,430); +ACE_EXPLOSION_REFLECTION(80,440); +ACE_EXPLOSION_REFLECTION(80,450); +ACE_EXPLOSION_REFLECTION(80,460); +ACE_EXPLOSION_REFLECTION(80,470); +ACE_EXPLOSION_REFLECTION(80,480); +ACE_EXPLOSION_REFLECTION(80,490); +ACE_EXPLOSION_REFLECTION(80,500); +ACE_EXPLOSION_REFLECTION(82,10); +ACE_EXPLOSION_REFLECTION(82,20); +ACE_EXPLOSION_REFLECTION(82,30); +ACE_EXPLOSION_REFLECTION(82,40); +ACE_EXPLOSION_REFLECTION(82,50); +ACE_EXPLOSION_REFLECTION(82,60); +ACE_EXPLOSION_REFLECTION(82,70); +ACE_EXPLOSION_REFLECTION(82,80); +ACE_EXPLOSION_REFLECTION(82,90); +ACE_EXPLOSION_REFLECTION(82,100); +ACE_EXPLOSION_REFLECTION(82,110); +ACE_EXPLOSION_REFLECTION(82,120); +ACE_EXPLOSION_REFLECTION(82,130); +ACE_EXPLOSION_REFLECTION(82,140); +ACE_EXPLOSION_REFLECTION(82,150); +ACE_EXPLOSION_REFLECTION(82,160); +ACE_EXPLOSION_REFLECTION(82,170); +ACE_EXPLOSION_REFLECTION(82,180); +ACE_EXPLOSION_REFLECTION(82,190); +ACE_EXPLOSION_REFLECTION(82,200); +ACE_EXPLOSION_REFLECTION(82,210); +ACE_EXPLOSION_REFLECTION(82,220); +ACE_EXPLOSION_REFLECTION(82,230); +ACE_EXPLOSION_REFLECTION(82,240); +ACE_EXPLOSION_REFLECTION(82,250); +ACE_EXPLOSION_REFLECTION(82,260); +ACE_EXPLOSION_REFLECTION(82,270); +ACE_EXPLOSION_REFLECTION(82,280); +ACE_EXPLOSION_REFLECTION(82,290); +ACE_EXPLOSION_REFLECTION(82,300); +ACE_EXPLOSION_REFLECTION(82,310); +ACE_EXPLOSION_REFLECTION(82,320); +ACE_EXPLOSION_REFLECTION(82,330); +ACE_EXPLOSION_REFLECTION(82,340); +ACE_EXPLOSION_REFLECTION(82,350); +ACE_EXPLOSION_REFLECTION(82,360); +ACE_EXPLOSION_REFLECTION(82,370); +ACE_EXPLOSION_REFLECTION(82,380); +ACE_EXPLOSION_REFLECTION(82,390); +ACE_EXPLOSION_REFLECTION(82,400); +ACE_EXPLOSION_REFLECTION(82,410); +ACE_EXPLOSION_REFLECTION(82,420); +ACE_EXPLOSION_REFLECTION(82,430); +ACE_EXPLOSION_REFLECTION(82,440); +ACE_EXPLOSION_REFLECTION(82,450); +ACE_EXPLOSION_REFLECTION(82,460); +ACE_EXPLOSION_REFLECTION(82,470); +ACE_EXPLOSION_REFLECTION(82,480); +ACE_EXPLOSION_REFLECTION(82,490); +ACE_EXPLOSION_REFLECTION(82,500); +ACE_EXPLOSION_REFLECTION(84,10); +ACE_EXPLOSION_REFLECTION(84,20); +ACE_EXPLOSION_REFLECTION(84,30); +ACE_EXPLOSION_REFLECTION(84,40); +ACE_EXPLOSION_REFLECTION(84,50); +ACE_EXPLOSION_REFLECTION(84,60); +ACE_EXPLOSION_REFLECTION(84,70); +ACE_EXPLOSION_REFLECTION(84,80); +ACE_EXPLOSION_REFLECTION(84,90); +ACE_EXPLOSION_REFLECTION(84,100); +ACE_EXPLOSION_REFLECTION(84,110); +ACE_EXPLOSION_REFLECTION(84,120); +ACE_EXPLOSION_REFLECTION(84,130); +ACE_EXPLOSION_REFLECTION(84,140); +ACE_EXPLOSION_REFLECTION(84,150); +ACE_EXPLOSION_REFLECTION(84,160); +ACE_EXPLOSION_REFLECTION(84,170); +ACE_EXPLOSION_REFLECTION(84,180); +ACE_EXPLOSION_REFLECTION(84,190); +ACE_EXPLOSION_REFLECTION(84,200); +ACE_EXPLOSION_REFLECTION(84,210); +ACE_EXPLOSION_REFLECTION(84,220); +ACE_EXPLOSION_REFLECTION(84,230); +ACE_EXPLOSION_REFLECTION(84,240); +ACE_EXPLOSION_REFLECTION(84,250); +ACE_EXPLOSION_REFLECTION(84,260); +ACE_EXPLOSION_REFLECTION(84,270); +ACE_EXPLOSION_REFLECTION(84,280); +ACE_EXPLOSION_REFLECTION(84,290); +ACE_EXPLOSION_REFLECTION(84,300); +ACE_EXPLOSION_REFLECTION(84,310); +ACE_EXPLOSION_REFLECTION(84,320); +ACE_EXPLOSION_REFLECTION(84,330); +ACE_EXPLOSION_REFLECTION(84,340); +ACE_EXPLOSION_REFLECTION(84,350); +ACE_EXPLOSION_REFLECTION(84,360); +ACE_EXPLOSION_REFLECTION(84,370); +ACE_EXPLOSION_REFLECTION(84,380); +ACE_EXPLOSION_REFLECTION(84,390); +ACE_EXPLOSION_REFLECTION(84,400); +ACE_EXPLOSION_REFLECTION(84,410); +ACE_EXPLOSION_REFLECTION(84,420); +ACE_EXPLOSION_REFLECTION(84,430); +ACE_EXPLOSION_REFLECTION(84,440); +ACE_EXPLOSION_REFLECTION(84,450); +ACE_EXPLOSION_REFLECTION(84,460); +ACE_EXPLOSION_REFLECTION(84,470); +ACE_EXPLOSION_REFLECTION(84,480); +ACE_EXPLOSION_REFLECTION(84,490); +ACE_EXPLOSION_REFLECTION(84,500); +ACE_EXPLOSION_REFLECTION(86,10); +ACE_EXPLOSION_REFLECTION(86,20); +ACE_EXPLOSION_REFLECTION(86,30); +ACE_EXPLOSION_REFLECTION(86,40); +ACE_EXPLOSION_REFLECTION(86,50); +ACE_EXPLOSION_REFLECTION(86,60); +ACE_EXPLOSION_REFLECTION(86,70); +ACE_EXPLOSION_REFLECTION(86,80); +ACE_EXPLOSION_REFLECTION(86,90); +ACE_EXPLOSION_REFLECTION(86,100); +ACE_EXPLOSION_REFLECTION(86,110); +ACE_EXPLOSION_REFLECTION(86,120); +ACE_EXPLOSION_REFLECTION(86,130); +ACE_EXPLOSION_REFLECTION(86,140); +ACE_EXPLOSION_REFLECTION(86,150); +ACE_EXPLOSION_REFLECTION(86,160); +ACE_EXPLOSION_REFLECTION(86,170); +ACE_EXPLOSION_REFLECTION(86,180); +ACE_EXPLOSION_REFLECTION(86,190); +ACE_EXPLOSION_REFLECTION(86,200); +ACE_EXPLOSION_REFLECTION(86,210); +ACE_EXPLOSION_REFLECTION(86,220); +ACE_EXPLOSION_REFLECTION(86,230); +ACE_EXPLOSION_REFLECTION(86,240); +ACE_EXPLOSION_REFLECTION(86,250); +ACE_EXPLOSION_REFLECTION(86,260); +ACE_EXPLOSION_REFLECTION(86,270); +ACE_EXPLOSION_REFLECTION(86,280); +ACE_EXPLOSION_REFLECTION(86,290); +ACE_EXPLOSION_REFLECTION(86,300); +ACE_EXPLOSION_REFLECTION(86,310); +ACE_EXPLOSION_REFLECTION(86,320); +ACE_EXPLOSION_REFLECTION(86,330); +ACE_EXPLOSION_REFLECTION(86,340); +ACE_EXPLOSION_REFLECTION(86,350); +ACE_EXPLOSION_REFLECTION(86,360); +ACE_EXPLOSION_REFLECTION(86,370); +ACE_EXPLOSION_REFLECTION(86,380); +ACE_EXPLOSION_REFLECTION(86,390); +ACE_EXPLOSION_REFLECTION(86,400); +ACE_EXPLOSION_REFLECTION(86,410); +ACE_EXPLOSION_REFLECTION(86,420); +ACE_EXPLOSION_REFLECTION(86,430); +ACE_EXPLOSION_REFLECTION(86,440); +ACE_EXPLOSION_REFLECTION(86,450); +ACE_EXPLOSION_REFLECTION(86,460); +ACE_EXPLOSION_REFLECTION(86,470); +ACE_EXPLOSION_REFLECTION(86,480); +ACE_EXPLOSION_REFLECTION(86,490); +ACE_EXPLOSION_REFLECTION(86,500); +ACE_EXPLOSION_REFLECTION(88,10); +ACE_EXPLOSION_REFLECTION(88,20); +ACE_EXPLOSION_REFLECTION(88,30); +ACE_EXPLOSION_REFLECTION(88,40); +ACE_EXPLOSION_REFLECTION(88,50); +ACE_EXPLOSION_REFLECTION(88,60); +ACE_EXPLOSION_REFLECTION(88,70); +ACE_EXPLOSION_REFLECTION(88,80); +ACE_EXPLOSION_REFLECTION(88,90); +ACE_EXPLOSION_REFLECTION(88,100); +ACE_EXPLOSION_REFLECTION(88,110); +ACE_EXPLOSION_REFLECTION(88,120); +ACE_EXPLOSION_REFLECTION(88,130); +ACE_EXPLOSION_REFLECTION(88,140); +ACE_EXPLOSION_REFLECTION(88,150); +ACE_EXPLOSION_REFLECTION(88,160); +ACE_EXPLOSION_REFLECTION(88,170); +ACE_EXPLOSION_REFLECTION(88,180); +ACE_EXPLOSION_REFLECTION(88,190); +ACE_EXPLOSION_REFLECTION(88,200); +ACE_EXPLOSION_REFLECTION(88,210); +ACE_EXPLOSION_REFLECTION(88,220); +ACE_EXPLOSION_REFLECTION(88,230); +ACE_EXPLOSION_REFLECTION(88,240); +ACE_EXPLOSION_REFLECTION(88,250); +ACE_EXPLOSION_REFLECTION(88,260); +ACE_EXPLOSION_REFLECTION(88,270); +ACE_EXPLOSION_REFLECTION(88,280); +ACE_EXPLOSION_REFLECTION(88,290); +ACE_EXPLOSION_REFLECTION(88,300); +ACE_EXPLOSION_REFLECTION(88,310); +ACE_EXPLOSION_REFLECTION(88,320); +ACE_EXPLOSION_REFLECTION(88,330); +ACE_EXPLOSION_REFLECTION(88,340); +ACE_EXPLOSION_REFLECTION(88,350); +ACE_EXPLOSION_REFLECTION(88,360); +ACE_EXPLOSION_REFLECTION(88,370); +ACE_EXPLOSION_REFLECTION(88,380); +ACE_EXPLOSION_REFLECTION(88,390); +ACE_EXPLOSION_REFLECTION(88,400); +ACE_EXPLOSION_REFLECTION(88,410); +ACE_EXPLOSION_REFLECTION(88,420); +ACE_EXPLOSION_REFLECTION(88,430); +ACE_EXPLOSION_REFLECTION(88,440); +ACE_EXPLOSION_REFLECTION(88,450); +ACE_EXPLOSION_REFLECTION(88,460); +ACE_EXPLOSION_REFLECTION(88,470); +ACE_EXPLOSION_REFLECTION(88,480); +ACE_EXPLOSION_REFLECTION(88,490); +ACE_EXPLOSION_REFLECTION(88,500); +ACE_EXPLOSION_REFLECTION(90,10); +ACE_EXPLOSION_REFLECTION(90,20); +ACE_EXPLOSION_REFLECTION(90,30); +ACE_EXPLOSION_REFLECTION(90,40); +ACE_EXPLOSION_REFLECTION(90,50); +ACE_EXPLOSION_REFLECTION(90,60); +ACE_EXPLOSION_REFLECTION(90,70); +ACE_EXPLOSION_REFLECTION(90,80); +ACE_EXPLOSION_REFLECTION(90,90); +ACE_EXPLOSION_REFLECTION(90,100); +ACE_EXPLOSION_REFLECTION(90,110); +ACE_EXPLOSION_REFLECTION(90,120); +ACE_EXPLOSION_REFLECTION(90,130); +ACE_EXPLOSION_REFLECTION(90,140); +ACE_EXPLOSION_REFLECTION(90,150); +ACE_EXPLOSION_REFLECTION(90,160); +ACE_EXPLOSION_REFLECTION(90,170); +ACE_EXPLOSION_REFLECTION(90,180); +ACE_EXPLOSION_REFLECTION(90,190); +ACE_EXPLOSION_REFLECTION(90,200); +ACE_EXPLOSION_REFLECTION(90,210); +ACE_EXPLOSION_REFLECTION(90,220); +ACE_EXPLOSION_REFLECTION(90,230); +ACE_EXPLOSION_REFLECTION(90,240); +ACE_EXPLOSION_REFLECTION(90,250); +ACE_EXPLOSION_REFLECTION(90,260); +ACE_EXPLOSION_REFLECTION(90,270); +ACE_EXPLOSION_REFLECTION(90,280); +ACE_EXPLOSION_REFLECTION(90,290); +ACE_EXPLOSION_REFLECTION(90,300); +ACE_EXPLOSION_REFLECTION(90,310); +ACE_EXPLOSION_REFLECTION(90,320); +ACE_EXPLOSION_REFLECTION(90,330); +ACE_EXPLOSION_REFLECTION(90,340); +ACE_EXPLOSION_REFLECTION(90,350); +ACE_EXPLOSION_REFLECTION(90,360); +ACE_EXPLOSION_REFLECTION(90,370); +ACE_EXPLOSION_REFLECTION(90,380); +ACE_EXPLOSION_REFLECTION(90,390); +ACE_EXPLOSION_REFLECTION(90,400); +ACE_EXPLOSION_REFLECTION(90,410); +ACE_EXPLOSION_REFLECTION(90,420); +ACE_EXPLOSION_REFLECTION(90,430); +ACE_EXPLOSION_REFLECTION(90,440); +ACE_EXPLOSION_REFLECTION(90,450); +ACE_EXPLOSION_REFLECTION(90,460); +ACE_EXPLOSION_REFLECTION(90,470); +ACE_EXPLOSION_REFLECTION(90,480); +ACE_EXPLOSION_REFLECTION(90,490); +ACE_EXPLOSION_REFLECTION(90,500); +ACE_EXPLOSION_REFLECTION(92,10); +ACE_EXPLOSION_REFLECTION(92,20); +ACE_EXPLOSION_REFLECTION(92,30); +ACE_EXPLOSION_REFLECTION(92,40); +ACE_EXPLOSION_REFLECTION(92,50); +ACE_EXPLOSION_REFLECTION(92,60); +ACE_EXPLOSION_REFLECTION(92,70); +ACE_EXPLOSION_REFLECTION(92,80); +ACE_EXPLOSION_REFLECTION(92,90); +ACE_EXPLOSION_REFLECTION(92,100); +ACE_EXPLOSION_REFLECTION(92,110); +ACE_EXPLOSION_REFLECTION(92,120); +ACE_EXPLOSION_REFLECTION(92,130); +ACE_EXPLOSION_REFLECTION(92,140); +ACE_EXPLOSION_REFLECTION(92,150); +ACE_EXPLOSION_REFLECTION(92,160); +ACE_EXPLOSION_REFLECTION(92,170); +ACE_EXPLOSION_REFLECTION(92,180); +ACE_EXPLOSION_REFLECTION(92,190); +ACE_EXPLOSION_REFLECTION(92,200); +ACE_EXPLOSION_REFLECTION(92,210); +ACE_EXPLOSION_REFLECTION(92,220); +ACE_EXPLOSION_REFLECTION(92,230); +ACE_EXPLOSION_REFLECTION(92,240); +ACE_EXPLOSION_REFLECTION(92,250); +ACE_EXPLOSION_REFLECTION(92,260); +ACE_EXPLOSION_REFLECTION(92,270); +ACE_EXPLOSION_REFLECTION(92,280); +ACE_EXPLOSION_REFLECTION(92,290); +ACE_EXPLOSION_REFLECTION(92,300); +ACE_EXPLOSION_REFLECTION(92,310); +ACE_EXPLOSION_REFLECTION(92,320); +ACE_EXPLOSION_REFLECTION(92,330); +ACE_EXPLOSION_REFLECTION(92,340); +ACE_EXPLOSION_REFLECTION(92,350); +ACE_EXPLOSION_REFLECTION(92,360); +ACE_EXPLOSION_REFLECTION(92,370); +ACE_EXPLOSION_REFLECTION(92,380); +ACE_EXPLOSION_REFLECTION(92,390); +ACE_EXPLOSION_REFLECTION(92,400); +ACE_EXPLOSION_REFLECTION(92,410); +ACE_EXPLOSION_REFLECTION(92,420); +ACE_EXPLOSION_REFLECTION(92,430); +ACE_EXPLOSION_REFLECTION(92,440); +ACE_EXPLOSION_REFLECTION(92,450); +ACE_EXPLOSION_REFLECTION(92,460); +ACE_EXPLOSION_REFLECTION(92,470); +ACE_EXPLOSION_REFLECTION(92,480); +ACE_EXPLOSION_REFLECTION(92,490); +ACE_EXPLOSION_REFLECTION(92,500); +ACE_EXPLOSION_REFLECTION(94,10); +ACE_EXPLOSION_REFLECTION(94,20); +ACE_EXPLOSION_REFLECTION(94,30); +ACE_EXPLOSION_REFLECTION(94,40); +ACE_EXPLOSION_REFLECTION(94,50); +ACE_EXPLOSION_REFLECTION(94,60); +ACE_EXPLOSION_REFLECTION(94,70); +ACE_EXPLOSION_REFLECTION(94,80); +ACE_EXPLOSION_REFLECTION(94,90); +ACE_EXPLOSION_REFLECTION(94,100); +ACE_EXPLOSION_REFLECTION(94,110); +ACE_EXPLOSION_REFLECTION(94,120); +ACE_EXPLOSION_REFLECTION(94,130); +ACE_EXPLOSION_REFLECTION(94,140); +ACE_EXPLOSION_REFLECTION(94,150); +ACE_EXPLOSION_REFLECTION(94,160); +ACE_EXPLOSION_REFLECTION(94,170); +ACE_EXPLOSION_REFLECTION(94,180); +ACE_EXPLOSION_REFLECTION(94,190); +ACE_EXPLOSION_REFLECTION(94,200); +ACE_EXPLOSION_REFLECTION(94,210); +ACE_EXPLOSION_REFLECTION(94,220); +ACE_EXPLOSION_REFLECTION(94,230); +ACE_EXPLOSION_REFLECTION(94,240); +ACE_EXPLOSION_REFLECTION(94,250); +ACE_EXPLOSION_REFLECTION(94,260); +ACE_EXPLOSION_REFLECTION(94,270); +ACE_EXPLOSION_REFLECTION(94,280); +ACE_EXPLOSION_REFLECTION(94,290); +ACE_EXPLOSION_REFLECTION(94,300); +ACE_EXPLOSION_REFLECTION(94,310); +ACE_EXPLOSION_REFLECTION(94,320); +ACE_EXPLOSION_REFLECTION(94,330); +ACE_EXPLOSION_REFLECTION(94,340); +ACE_EXPLOSION_REFLECTION(94,350); +ACE_EXPLOSION_REFLECTION(94,360); +ACE_EXPLOSION_REFLECTION(94,370); +ACE_EXPLOSION_REFLECTION(94,380); +ACE_EXPLOSION_REFLECTION(94,390); +ACE_EXPLOSION_REFLECTION(94,400); +ACE_EXPLOSION_REFLECTION(94,410); +ACE_EXPLOSION_REFLECTION(94,420); +ACE_EXPLOSION_REFLECTION(94,430); +ACE_EXPLOSION_REFLECTION(94,440); +ACE_EXPLOSION_REFLECTION(94,450); +ACE_EXPLOSION_REFLECTION(94,460); +ACE_EXPLOSION_REFLECTION(94,470); +ACE_EXPLOSION_REFLECTION(94,480); +ACE_EXPLOSION_REFLECTION(94,490); +ACE_EXPLOSION_REFLECTION(94,500); +ACE_EXPLOSION_REFLECTION(96,10); +ACE_EXPLOSION_REFLECTION(96,20); +ACE_EXPLOSION_REFLECTION(96,30); +ACE_EXPLOSION_REFLECTION(96,40); +ACE_EXPLOSION_REFLECTION(96,50); +ACE_EXPLOSION_REFLECTION(96,60); +ACE_EXPLOSION_REFLECTION(96,70); +ACE_EXPLOSION_REFLECTION(96,80); +ACE_EXPLOSION_REFLECTION(96,90); +ACE_EXPLOSION_REFLECTION(96,100); +ACE_EXPLOSION_REFLECTION(96,110); +ACE_EXPLOSION_REFLECTION(96,120); +ACE_EXPLOSION_REFLECTION(96,130); +ACE_EXPLOSION_REFLECTION(96,140); +ACE_EXPLOSION_REFLECTION(96,150); +ACE_EXPLOSION_REFLECTION(96,160); +ACE_EXPLOSION_REFLECTION(96,170); +ACE_EXPLOSION_REFLECTION(96,180); +ACE_EXPLOSION_REFLECTION(96,190); +ACE_EXPLOSION_REFLECTION(96,200); +ACE_EXPLOSION_REFLECTION(96,210); +ACE_EXPLOSION_REFLECTION(96,220); +ACE_EXPLOSION_REFLECTION(96,230); +ACE_EXPLOSION_REFLECTION(96,240); +ACE_EXPLOSION_REFLECTION(96,250); +ACE_EXPLOSION_REFLECTION(96,260); +ACE_EXPLOSION_REFLECTION(96,270); +ACE_EXPLOSION_REFLECTION(96,280); +ACE_EXPLOSION_REFLECTION(96,290); +ACE_EXPLOSION_REFLECTION(96,300); +ACE_EXPLOSION_REFLECTION(96,310); +ACE_EXPLOSION_REFLECTION(96,320); +ACE_EXPLOSION_REFLECTION(96,330); +ACE_EXPLOSION_REFLECTION(96,340); +ACE_EXPLOSION_REFLECTION(96,350); +ACE_EXPLOSION_REFLECTION(96,360); +ACE_EXPLOSION_REFLECTION(96,370); +ACE_EXPLOSION_REFLECTION(96,380); +ACE_EXPLOSION_REFLECTION(96,390); +ACE_EXPLOSION_REFLECTION(96,400); +ACE_EXPLOSION_REFLECTION(96,410); +ACE_EXPLOSION_REFLECTION(96,420); +ACE_EXPLOSION_REFLECTION(96,430); +ACE_EXPLOSION_REFLECTION(96,440); +ACE_EXPLOSION_REFLECTION(96,450); +ACE_EXPLOSION_REFLECTION(96,460); +ACE_EXPLOSION_REFLECTION(96,470); +ACE_EXPLOSION_REFLECTION(96,480); +ACE_EXPLOSION_REFLECTION(96,490); +ACE_EXPLOSION_REFLECTION(96,500); +ACE_EXPLOSION_REFLECTION(98,10); +ACE_EXPLOSION_REFLECTION(98,20); +ACE_EXPLOSION_REFLECTION(98,30); +ACE_EXPLOSION_REFLECTION(98,40); +ACE_EXPLOSION_REFLECTION(98,50); +ACE_EXPLOSION_REFLECTION(98,60); +ACE_EXPLOSION_REFLECTION(98,70); +ACE_EXPLOSION_REFLECTION(98,80); +ACE_EXPLOSION_REFLECTION(98,90); +ACE_EXPLOSION_REFLECTION(98,100); +ACE_EXPLOSION_REFLECTION(98,110); +ACE_EXPLOSION_REFLECTION(98,120); +ACE_EXPLOSION_REFLECTION(98,130); +ACE_EXPLOSION_REFLECTION(98,140); +ACE_EXPLOSION_REFLECTION(98,150); +ACE_EXPLOSION_REFLECTION(98,160); +ACE_EXPLOSION_REFLECTION(98,170); +ACE_EXPLOSION_REFLECTION(98,180); +ACE_EXPLOSION_REFLECTION(98,190); +ACE_EXPLOSION_REFLECTION(98,200); +ACE_EXPLOSION_REFLECTION(98,210); +ACE_EXPLOSION_REFLECTION(98,220); +ACE_EXPLOSION_REFLECTION(98,230); +ACE_EXPLOSION_REFLECTION(98,240); +ACE_EXPLOSION_REFLECTION(98,250); +ACE_EXPLOSION_REFLECTION(98,260); +ACE_EXPLOSION_REFLECTION(98,270); +ACE_EXPLOSION_REFLECTION(98,280); +ACE_EXPLOSION_REFLECTION(98,290); +ACE_EXPLOSION_REFLECTION(98,300); +ACE_EXPLOSION_REFLECTION(98,310); +ACE_EXPLOSION_REFLECTION(98,320); +ACE_EXPLOSION_REFLECTION(98,330); +ACE_EXPLOSION_REFLECTION(98,340); +ACE_EXPLOSION_REFLECTION(98,350); +ACE_EXPLOSION_REFLECTION(98,360); +ACE_EXPLOSION_REFLECTION(98,370); +ACE_EXPLOSION_REFLECTION(98,380); +ACE_EXPLOSION_REFLECTION(98,390); +ACE_EXPLOSION_REFLECTION(98,400); +ACE_EXPLOSION_REFLECTION(98,410); +ACE_EXPLOSION_REFLECTION(98,420); +ACE_EXPLOSION_REFLECTION(98,430); +ACE_EXPLOSION_REFLECTION(98,440); +ACE_EXPLOSION_REFLECTION(98,450); +ACE_EXPLOSION_REFLECTION(98,460); +ACE_EXPLOSION_REFLECTION(98,470); +ACE_EXPLOSION_REFLECTION(98,480); +ACE_EXPLOSION_REFLECTION(98,490); +ACE_EXPLOSION_REFLECTION(98,500); +ACE_EXPLOSION_REFLECTION(100,10); +ACE_EXPLOSION_REFLECTION(100,20); +ACE_EXPLOSION_REFLECTION(100,30); +ACE_EXPLOSION_REFLECTION(100,40); +ACE_EXPLOSION_REFLECTION(100,50); +ACE_EXPLOSION_REFLECTION(100,60); +ACE_EXPLOSION_REFLECTION(100,70); +ACE_EXPLOSION_REFLECTION(100,80); +ACE_EXPLOSION_REFLECTION(100,90); +ACE_EXPLOSION_REFLECTION(100,100); +ACE_EXPLOSION_REFLECTION(100,110); +ACE_EXPLOSION_REFLECTION(100,120); +ACE_EXPLOSION_REFLECTION(100,130); +ACE_EXPLOSION_REFLECTION(100,140); +ACE_EXPLOSION_REFLECTION(100,150); +ACE_EXPLOSION_REFLECTION(100,160); +ACE_EXPLOSION_REFLECTION(100,170); +ACE_EXPLOSION_REFLECTION(100,180); +ACE_EXPLOSION_REFLECTION(100,190); +ACE_EXPLOSION_REFLECTION(100,200); +ACE_EXPLOSION_REFLECTION(100,210); +ACE_EXPLOSION_REFLECTION(100,220); +ACE_EXPLOSION_REFLECTION(100,230); +ACE_EXPLOSION_REFLECTION(100,240); +ACE_EXPLOSION_REFLECTION(100,250); +ACE_EXPLOSION_REFLECTION(100,260); +ACE_EXPLOSION_REFLECTION(100,270); +ACE_EXPLOSION_REFLECTION(100,280); +ACE_EXPLOSION_REFLECTION(100,290); +ACE_EXPLOSION_REFLECTION(100,300); +ACE_EXPLOSION_REFLECTION(100,310); +ACE_EXPLOSION_REFLECTION(100,320); +ACE_EXPLOSION_REFLECTION(100,330); +ACE_EXPLOSION_REFLECTION(100,340); +ACE_EXPLOSION_REFLECTION(100,350); +ACE_EXPLOSION_REFLECTION(100,360); +ACE_EXPLOSION_REFLECTION(100,370); +ACE_EXPLOSION_REFLECTION(100,380); +ACE_EXPLOSION_REFLECTION(100,390); +ACE_EXPLOSION_REFLECTION(100,400); +ACE_EXPLOSION_REFLECTION(100,410); +ACE_EXPLOSION_REFLECTION(100,420); +ACE_EXPLOSION_REFLECTION(100,430); +ACE_EXPLOSION_REFLECTION(100,440); +ACE_EXPLOSION_REFLECTION(100,450); +ACE_EXPLOSION_REFLECTION(100,460); +ACE_EXPLOSION_REFLECTION(100,470); +ACE_EXPLOSION_REFLECTION(100,480); +ACE_EXPLOSION_REFLECTION(100,490); +ACE_EXPLOSION_REFLECTION(100,500); + diff --git a/addons/frag/XEH_pre_Init.sqf b/addons/frag/XEH_pre_Init.sqf index 5b3aa36b18..4ec70bbc3d 100644 --- a/addons/frag/XEH_pre_Init.sqf +++ b/addons/frag/XEH_pre_Init.sqf @@ -9,6 +9,10 @@ PREP(trackFragRound); PREP(spallTrack); PREP(doSpall); PREP(vectorDiffFast); +PREP(findReflections); +PREP(doExplosions); +PREP(doReflections); + GVAR(trackedObjects) = []; GVAR(blackList) = []; diff --git a/addons/frag/functions/fnc_doExplosions.sqf b/addons/frag/functions/fnc_doExplosions.sqf new file mode 100644 index 0000000000..f2c20c2f1e --- /dev/null +++ b/addons/frag/functions/fnc_doExplosions.sqf @@ -0,0 +1,26 @@ +//fnc_doExplosions.sqf +#include "script_component.hpp" + +private ["_params", "_explosions", "_index", "_i", "_exp", "_refExp", "_bpos", "_hit", "_distance", "_indirectHitRange", "_depth"]; +_params = _this select 0; +_explosions = _params select 0; +_index = _params select 1; +for "_i" from _index to ((_index+1) min (count _explosions)) do { + _exp = _explosions select _i; + _refExp = _exp select 0; + _bpos = _exp select 1; + _hit = _exp select 2; + _distance = _exp select 3; + _indirectHitRange = _exp select 4; + _depth = _exp select 5; + _refExp createVehicle (ASLtoATL _bpos); + // if(_hit >= 150 && _distance > _indirectHitRange) then { + // [_bpos, _refExp, _depth] call FUNC(doReflections); + // }; +}; +_index = _index + 1; +if(_index >= (count _explosions)) then { + [(_this select 1)] call cba_fnc_removePerFrameHandler; +} else { + _params set[1, _index]; +}; diff --git a/addons/frag/functions/fnc_doReflections.sqf b/addons/frag/functions/fnc_doReflections.sqf new file mode 100644 index 0000000000..844ccb4c9b --- /dev/null +++ b/addons/frag/functions/fnc_doReflections.sqf @@ -0,0 +1,22 @@ +//fnc_doReflections.sqf +#include "script_component.hpp" + +private ["_pos", "_ammo", "_depth", "_hit", "_range", "_hitFactor", "_indirectHitRange", "_indirectHit", "_testParams"]; + +_pos = _this select 0; +_ammo = _this select 1; +_depth = 1; +if(count _this > 2) then { + _depth = _this select 2; +}; +// TEST_ICONS pushBack [_pos, format["EXP!", _hit, _range, _hitFactor]]; +if(_depth <= 2) then { + _indirectHitRange = getNumber(configFile >> "CfgAmmo" >> _ammo >> "indirectHitRange"); + _indirectHit = getNumber(configFile >> "CfgAmmo" >> _ammo >> "indirectHit"); + + + + + _testParams = [_pos, [_indirectHitRange, _indirectHit], [], [], -4, _depth, 0]; + [DFUNC(findReflections), 0.005, _testParams] call cba_fnc_addPerFrameHandler; +}; diff --git a/addons/frag/functions/fnc_findReflections.sqf b/addons/frag/functions/fnc_findReflections.sqf new file mode 100644 index 0000000000..75c4ee2ae6 --- /dev/null +++ b/addons/frag/functions/fnc_findReflections.sqf @@ -0,0 +1,130 @@ +//fnc_findReflections.sqf +#include "script_component.hpp" + +private ["_split", "_radi", "_params", "_pos", "_explosiveInfo", "_los", "_nlos", "_zIndex", "_depth", "_indirectHitRange", + "_indirectHit", "_distanceCount", "_lastPos", "_test", "_vec", "_testPos", "_buckets", "_excludes", "_bucketIndex", "_bucketPos", + "_bucketList", "_c", "_index", "_blist", "_avgX", "_avgY", "_avgZ", "_bpos", "_distance", "_hitFactor", "_hit", "_range", "_refExp", + "_rand", "_i", "_x", "_res", "_forEachIndex", "_explosions", "_can", "_dirvec"]; + + +_params = _this select 0; +_pos = _params select 0; +_explosiveInfo = _params select 1; +_los = _params select 2; +_nlos = _params select 3; +_zIndex = _params select 4; +_depth = _params select 5; +_rand = _params select 6; + +_split = 15; +_radi = (360/_split*_depth); + +// player sideChat format["p: %1", _explosiveInfo]; +_indirectHitRange = _explosiveInfo select 0; +_indirectHit = _explosiveInfo select 1; +_distanceCount = (floor _indirectHitRange*4) min 100; + +if(_zIndex < 5) then { + _lastPos = _pos; + _zAng = _zIndex*20+2; + if(_zAng > 80) then { + _radi = 1; + _zAng = 90; + }; + for "_i" from 0 to _radi do { + _test = true; + _vec = [1, ((_i*_split)+_rand) mod 360, _zAng] call cba_fnc_polar2vect; + for "_x" from 1 to _distanceCount do { + _testPos = _pos vectorAdd (_vec vectorMultiply _x); + // drop ["\a3\data_f\Cl_basic","","Billboard",1,15,ASLtoATL _testPos,[0,0,0],1,1.275,1.0,0.0,[1],[[1,0,0,1]],[0],0.0,2.0,"","",""]; + _res = lineIntersectsWith [_pos, _testPos]; + if(count _res > 0) exitWith { + _test = false; + _nlos pushBack _lastPos; + // { + // _x addEventHandler ["HandleDamage", { diag_log text format["this: %1", _this]; }]; + // } forEach _res; + // drop ["\a3\data_f\Cl_basic","","Billboard",1,15,ASLtoATL _testPos,[0,0,0],1,1.275,1.0,0.0,[1],[[1,0,0,1]],[0],0.0,2.0,"","",""]; + // TEST_PAIRS pushBack [_pos, _lastPos, [1,0,0,1]]; + + }; + // if(terrainIntersectASL [_pos, _testPos]) exitWith {}; + _lastPos = _testPos; + }; + }; + _params set[4, _zIndex+1]; +} else { + _depth = _depth + 1; + _buckets = []; + _excludes = []; + _bucketIndex = 0; + _bucketPos = nil; + _bucketList = nil; + _c = 0; + while { count(_nlos) != count(_excludes) && _c < (count _nlos) } do { + scopeName "mainSearch"; + { + if(!(_forEachIndex in _excludes)) then { + _index = _buckets pushBack [_x, [_x]]; + _excludes pushBack _forEachIndex; + _bucketPos = _x; + _bucketList = (_buckets select _index) select 1; + breakTo "mainSearch"; + }; + } forEach _nlos; + { + if(!(_forEachIndex in _excludes)) then { + _testPos = _x; + if(_testPos vectorDistanceSqr _bucketPos <= 30) then { + _bucketList pushBack _x; + _excludes pushBack _forEachIndex; + }; + }; + } forEach _nlos; + _c = _c + 1; + }; + + // player sideChat format["c: %1", count _buckets]; + _explosions = []; + { + _blist = _x select 1; + _avgX = 0; + _avgY = 0; + _avgZ = 0; + + { + _avgX = _avgX + (_x select 0); + _avgY = _avgY + (_x select 1); + _avgZ = _avgZ + (_x select 2); + } forEach _blist; + _c = count _blist; + _bpos = [_avgX/_c, _avgY/_c, _avgZ/_c]; + + _distance = _pos vectorDistance _bpos; + _hitFactor = 1-(((_distance/(_indirectHitRange*4)) min 1) max 0); + // _hitFactor = 1/(_distance^2); + _hit = _indirectHit*_hitFactor; + _hit = (floor (_hit/4)) min 500; + _hit = _hit - (_hit%10); + _range = (floor (_indirectHitRange-(_distance/4))) min 100; + _range = _range - (_range%2); + + if(_hit >= 10 && _range > 0) then { + // TEST_ICONS pushBack [_bpos, format["h: %1, r: %2, hf: %3 d: %4 ihr: %5", _hit, _range, _hitFactor, _distance, _indirectHitRange*4]]; + // TEST_PAIRS pushBack [_pos, _bpos, [1,0,0,1]]; + _refExp = format["ace_explosion_reflection_%1_%2", _range, _hit]; + // _refExp createVehicle (ASLtoATL _bpos); + // drop ["\a3\data_f\Cl_basic","","Billboard",1,15,ASLtoATL _bpos,[0,0,0],1,1.275,1.0,0.0,[1],[[1,0,0,1]],[0],0.0,2.0,"","",""]; + + _explosions pushBack [_refExp, _bpos, _hit, _distance, _indirectHitRange/4, _depth]; + + }; + if(count _explosions > (_radi*2)/_depth) exitWith {}; + } forEach _buckets; + // _can = "Land_Bricks_V4_F" createVehicle (ASLtoATL _pos); + // _dirvec = _pos vectorFromTo ((ATLtoASL (player modelToWorldVisual (player selectionPosition "Spine3")))); + // _dirvec = _dirvec vectorMultiply 100; + // _can setVelocity _dirvec; + [DFUNC(doExplosions), 0, [_explosions, 0]] call cba_fnc_addPerFrameHandler; + [(_this select 1)] call cba_fnc_removePerFrameHandler; +}; diff --git a/addons/frag/functions/fnc_frago.sqf b/addons/frag/functions/fnc_frago.sqf index 1b737dc70d..8c97baa209 100644 --- a/addons/frag/functions/fnc_frago.sqf +++ b/addons/frag/functions/fnc_frago.sqf @@ -111,8 +111,9 @@ _fragArcs set[360, 0]; player sideChat format["_fragRange: %1", _fragRange]; player sideChat format["_objects: %1", _objects]; #endif -_doRandom = false; +_doRandom = true; if(_isArmed && (count _objects) > 0) then { + [_lastPos, _shellType] call FUNC(doReflections); { //if(random(1) > 0.5) then { _target = _x; @@ -189,7 +190,7 @@ if(_isArmed && (count _objects) > 0) then { if(_fragCount > MAX_FRAG_COUNT) exitWith {}; } forEach _objects; if(_fragCount > MAX_FRAG_COUNT) exitWith {}; - _randomCount = (ceil((MAX_FRAG_COUNT-_fragCount)*0.1)) max 0; + _randomCount = ((ceil((MAX_FRAG_COUNT-_fragCount)*0.1)) max 0)+20; _sectorSize = 360 / (_randomCount max 1); // _doRandom = false; if(_doRandom) then { @@ -222,6 +223,7 @@ if(_isArmed && (count _objects) > 0) then { _fragCount = _fragCount + 1; }; }; + }; // #ifdef DEBUG_MODE_FULL // player sideChat format["total frags: %1", GVAR(TOTALFRAGS)];