Variables:
Distance 500;
Speed 200;
OffsetX 10
OffsetY 15
DragAngleX 45
DragAngleY 24
ReflectTime 3


Values
0 - 4 predictivity
2 speed_distance_ratio
1.11 postoffset
0.7 ReflectDistance
0.51 dragangle

complexity variables Ranges
0 - 4 predictivity
0 - 2 speed_distance_ratio
0 - 2 postoffset
0 - 1 reflectdistance
0 - 1 flickangle








Result Complexity:
speed_distance_ratio*(postoffset+reflectdistance+dragangle +predictivity(0to4))
v1: 5.64 = 2*(1.11+0.7+0.51+4)+1
v2: 3.32 = (2 * (1.11 + 0.7 + 0.51 + 4)/2)+1

4 = 1.0;


v2 dupe: 3.53 = (2.0*1 * (2.0*0.59 + 0.72 + 0.63+4)/2)+1

v3 dupe: 7.41 = 1+ 2.0*1 * (2.0*0.59 + 0.72 + 1.5*0.63)


speed_distance_ratio = 1

Multiplyer variables Ranges
1 - 2 predictivity
0 - 2 speed_distance_ratio
0 - 2 postoffset
0 - 2 reflectdistance
0 - 2 flickangle






Result Multiplyer:
reflectdistance*postoffset*dragangle*
v1: 2.679285 = 1.33*1.275*1.58

v2: 5.3371428571429 = (((2*1.58)+(4*1.33)+(8*1.275)  /7 ) 

v3: 3.5606367346939 = (((2*1.58)+(4*1.33)+(8*1.275))  /7 *predictivity(1to2) 
v3 best so far

v4: 3.6647142857143  = ( 4*1.275*(8*1.33+6*1.58)) /28.0



v3 dupe: 10.471428571429 = (( 2*(0.5+0.72*1.5)+4*(0.5+0.59*1.5)+8*(0.5+0.63*1.5))  /7 ) 1-15 on predcitv =1 *predictivity(1to2)


v4 dupe: 7.074187 = (( 2*(0.5+0.72*1.5)*4*(0.5+0.59*1.5)*8*(0.5+0.63*1.5))  /8 ) 1-15 on predcitv =1 *predictivity(1to2)


v5 dupe: 9.861792 = (0.5+0.72)*(0.5+0.59)*(0.25+0.63) *16 ; 9.861792 = ((9.861792-1)*8.0)+1    1-22 on predcitv =1 *predictivity(1to2)

_________

v6 dupe: 12.39505856 = (0.5+0.72)*(0.3333+0.59)*(0.25+0.63) *24 ; 12.39505856 = ((12.39505856-1)*8.0)+1


v66 dupe: 8.0201515004 = (0.75+0.72)*(0.5+0.59)*(0.25+0.63) *10.6667 ; 8.0201515004 = ((8.0201515004-1)*8.0)+1

delay < offset < drag (6 10 12) (6 12 12) (6 8 12) v66(4 8 12)
delay*offset < delay*drag < drag*offset (60 | 72 | 120)  (72 | 72 | 144)  (56 | 72 | 96) (32 | 48 | 96) 
all: drag*offset*delay (___) (___) (576) (384) 
//to make delay influence bigger on multiplying, smaller on alone

considered flicks n tricks in order of their complexity to make (v66):
eye-on-rocket deflect ~2
direkt to direkt ~5
aim up (upspike) ~4
aim behind (backfire) ~6
random flick (360 flick) ~5 (bf trigger: /2 drag /2 offset) | ~10 (bf trigger: /2 offset)
vertical direkt hit (wave) ~9
horizontal direkt flick (sidespike) ~14
both axis direkt flick ~19
fake direkt (dirket to backfire) ~13 (bf trigger: /2 drag /2 offset) | ~21 (bf trigger: /2 offset)
fake backfire (direkt from rocket behind) ~23
backfire wave-direkt ~24
CQC instant wave direkt ~32

non considered tricks:
bounce to behind
360 flick
distance feet shot

(4+1)*(2+1)*(1+1) /8

4*2*(8*2+6*2) )/14

anti panda direkt spin:
//1+(0.0*2.0);

flickdirektRatio = 0.7817;

todo (multiplier)
reflect distance makes too little affect on big drag angles

old better formula (2*2)+(4*2)+(8*2) -6 )*0.75 (ranges 1-22)
(2*2)+(4*2)+(8*2)  /32 )   )-2.125 (ranges 1-10) (+predictivity *1.5)
___________
(2*2)+(4*2)+(8*2))  /7  (ranges 1-16) (+predictivity *1.5)
4postoffset*8dragangle*2delay (v1-v3)
offset*delay < dragangle*delay < dragangle*offset (6 10 12)
drag < delay < offset
???????????????????????
4dragangle*(8offset+6delay)

1-56 )-1)/14)+1

2postoffset*8dragangle*4delay (v4)
offset*delay < drag*offset < dragangle*delay (6 10 12)
offset < delay < drag

8.0201515004*8.0201515004 (4->16) possible variation 8.0201515004*(8.0201515004/2)*2(predictivity)

multiplyer variables Ranges
4.0 - 16.0 dragangle
2.0 - 8.0 postoffset
1.0 - 4.0 reflectdelay

flags:
is rocket stolen or redirekted (prev owner != reflector) -> x2 complexity
has rocket bounced (hit floor while flying triggered, while being closer to owner and not spinned) -> x1.5 complexity
revrted flick (from bottom) ->  (vertickal drag angle limit from 90 to 30)
is backfire (closer offset form behind) -> affects predictivity only



importance to complexity: (bottom to top)
speed_distance_ratio*reflectdistance < speed_distance_ratio*dragangle < speedratio*postoffset
postoffset*reflectdistance  < postoffset*dragangle
reflectdistance*dragangle
speed_distance_ratio
postoffset
dragangle
reflectdistance


most dangerous:
close long-distanced long-drag to direkt:
4+2+1+1

least dangerous:
far distance spinned random direktion simple reflect:
0+0+0+0

panda move
4+2+0+0

tests

complexity:
predictivity, real distance, offset distance, reflect Distance, flick distance //add real distance
real_distance4*(predictivity8 + offsetdistance2 + reflectDistance1 + flickDistance1) //add real distance Add distance/speed ratio
13.62 = 1*(4+0.59+0.72+1);


//difference 0 to 16 (predictivity included)




Predictivity
2*2*2
1*1*1
v1
4postoffset*8dragangle*2delay
offset*delay < dragangle*delay < dragangle*offset (6 10 12)
drag < delay < offset
(4*2)*(8*2)+(2*2) )/34 (1 - 3.88)

v2
4postoffset*8dragangle*6delay
offset*delay < dragangle*delay < dragangle*offset (6 10 12)
drag < delay < offset
(6*1)*(4*1)+(8*1) )/32 (1 - 3.5)

v3
4*offset 3*backfire 2*hitdelay preOffset
(offset+backfire+hitdelay+preOffset) /4 (equal, ranges 1-2)
////
(hitdelay*dragangle -> hitdelay*backfire) < (dragangle*direkt -> direkt) < (spin*direkt -> dragangle*direkt) < (dragangle*direkt -> dragangle*backfire)
(0.59*4)+(*3)+(0.72*2)+(0.63) )/10   (1 to 2)

v4
COmplexity:
PreOffset+isBackfire+hitdelay+drag+postOffset )*0.8 to make range 0-4
Multiplyer
(2.0 + ((4.0 - CurCompl) / (0.0 - 4)))

_______________________
predicttivneness

test:
1 more factor - add aimFramesOffset(1-6), pos (left up, right up, left down, right down) Xaxis=0-90 Yaxis = 0-90
Xaxis -  limited to -90 to 90  - (1.0 + ((90.0 - 90) / (-90.0 - 90)))*2 //0 to 1

//predictPreOffset values (rocketSentOnLeftShoulder)
//or make post offset + - (direction cahnge in angles - rocket hit angle - post offset angle differences)

 = ...

//inputs are from 0.0-1.0 arrays of prev values: post offsets, backfire flags, reflect distances, drag angles, pre offsets
 
predictPostOffset = 0.8
 
predictPreOffset = 0.6
 
predictDragAngle = 0.55
 
predictReflectDelay = 0.5
 
predictReflectDelay = 0.25



2.16 = (0.8+0.6+0.55+0.5+0.25)*0.8;

FinalHitScrore = Speed*Multiplier*Complexity*finalPredictivity )/80-2ez 160? 360-2tough
PredictReflectDelay -> fly time range

___________
loses:
->
LDS:
(5)+(35)+(24)+(25)+(50) 1hit = new val

PTS:
1hit = 0.0-1.0 range
EdgeFirst = 0.0-1.0;
EdgeLast = 1.0-EdgeFirst;
6 cell

(25*0.8)+(5)+(35)+(24)+(25)+(50*0.2) ~max 139 

OnRocketDeflect(iIndex, deflector)
{
    //
    if (CurClientRocketPTS > PTSCell[0])
    PrintToChat(Rocket PTS, %f, CurClientRocketPTS[client]);
}

OnRocketDestroyed(iIndex)
{
    CheckCellsAhead(client, iIndex);
}

GainCurrentCell
{
    PTSCell[0] = CurClientRocketPTS[client];
}

CheckCellsAhead(client, iIndex)
{
    ~(5*0.7)+(35)+(24)+(25)+(50)+(12[35]*0.3)
    
    if (PTSCell[0] < CurClientRocketPTS[iIndex][client])
    {
        //make a recursion instead
        
        if (PTSCell[5] < PTSCell[0])
        {
            if (PTSCell[4] PTSCell[0])
    {
        RegroupCells(5, PTSCell[0]);
        PTSCell[0] = CurClientRocketPTS[client];
    }
    else
    RegroupCells(5, CurClientRocketPTS[client]);
}


// ~(5*0.7)+(35)+(24)+(25)+(50)+(12[35]*0.3)
RegroupCells(Index, value)
{
    if (Index > 0) //all but first
    {
        if (PTSCell[Index] < value)
        {
            RegroupCells(Index-1, PTSCell[Index]);
            PTSCell[Index] = value;
        }
        else
        RegroupCells(Index-1, value);
    }
}

OnHitClient

calculate CurHitLoseCoeff;
1-Predictivity*complexity
ranges 0-1

//deduct from first
if (EdgeFirst(~0.2) < CurHitLoseCoeff(~0.9)) 
{
    CheckUserMaxPTS(client);
    EdgeFirst = (EdgeFirst-CurHitLoseCoeff)*-1.0;
    EdgeLast = 1.0-EdgeFirst;
    DropLastPTSCell(client);
    CreateNewPTSCell(client);
    PTSCell[5]~last *= EdgeLast;
    PTSCell[0]~first *= FirstAhead[client] (~0);
    ~(5*0.7)+(35)+(24)+(25)+(50)+(12*0.3) ~max 146
    CheckUserMaxPTS(client);
    PrintToCHat (Streak PTS, chechmaxpts);
}

//deduct from last
if (EdgeLast(~0.2) < CurHitLoseCoeff(~0.9)) 
{
    CheckUserMaxPTS(client);
    EdgeLast = (EdgeLast-CurHitLoseCoeff)*-1.0;
    EdgeFirst = 1.0-EdgeLast;
    DropLastPTSCell(client);
    CreateNewPTSCell(client);
    PTSCell[5]~last *= EdgeLast;
    PTSCell[0]~first *= EdgeFirst;
    ~(5*0.7)+(35)+(24)+(25)+(50)+(12*0.3) ~max 146
    CheckUserMaxPTS(client);
    PrintToCHat (Streak PTS, chechmaxpts);
}

CheckUserCurrentMaxPTS
{
    PTSSessionMAX = 0.0;
    if (PTSCell[0] > PTSCell[5])
    PTSSessionMAX = PTSCell[0]+PTSCell[1]+PTSCell[2]+PTSCell[3]+PTSCell[4]
    else
    PTSSessionMAX = PTSCell[1]+PTSCell[2]+PTSCell[3]+PTSCell[4]+PTSCell[5]
    
    return PTSSessionMAX
    //on count Cur Values check full 5 on each side, pick highest
}