Gap Functions

let GAP_IN = 999901; let GAP_OUT = 999902; let GAP_HOLD = 999903; let GAP_VOID = 999904;

function CreateGapA1(x,y,opening,width,angle,dur,  type, outgap)    {

    let gap = ObjPrim_Create(OBJ_SPRITE_2D);
    Obj_SetValue(gap,"Type",type);

    //let x0 = rotate(x-width/2,angle); let x1 = rotate(x+width/2,angle);
    //let y0 = rotate(y-width/2,angle); let y1 = rotate(y+width/2,angle);
    //Obj_SetValue(gap,"Endpoints",[x0,y0,x1,y1]);

    let midx = x; let midy = y;
    let endpoints = rotate(x-width/2,y-opening/2,x-width/2,y,angle) ~ rotate(x,y+opening/2+1,x,y,angle);
    let x0=endpoints[0]; let y0=endpoints[1]; let x1=endpoints[2]; let y1=endpoints[3];
    Obj_SetValue(gap,"Endpoints",[x0,y0,x1,y1]);

    //DebugWarnShot(x0,y0);DebugWarnShot(x1,y1);

    //since outgaps don't need a reference to another gap, use the parameter for delay instead
    //this way an ingap can be created "before" the corresponding outgap if desired
    let del = tern(type==GAP_OUT, outgap, 0);
    RenderGap(gap,x,y, width/44,opening/114, angle, dur, del);

    if(type==GAP_IN){ TInGap(gap,outgap); }

    return gap;

    task RenderGap(gap,Xpos,Ypos,xscale,yscale,angle,duration,delay){
        wait(delay);

        let Yangle = 90;

        SE_Play(se_gap,120);
        ObjPrim_SetTexture(gap, CSD~"../img/gap.png");
        ObjSprite2D_SetSourceRect(gap,0, 0, 44, 114);
        ObjRender_SetScaleXYZ(gap,xscale,yscale,1);
        Obj_SetRenderPriorityI(gap,30);
        ObjSprite2D_SetDestCenter(gap);
        ObjRender_SetBlendType(gap,BLEND_ALPHA);
        ObjRender_SetPosition(gap,Xpos,Ypos,0);
        ObjRender_SetAngleXYZ(gap,0,Yangle,angle);
        loop(15){
            Yangle-=6;
            ObjRender_SetAngleXYZ(gap,0,Yangle,angle);
            yield;
        }
        //wait(duration);
        let glowdel = 15;
        loop(floor(duration/glowdel)){
            RenderGapOutline(gap,Xpos,Ypos,xscale,yscale,angle,40,128,type);
            wait(glowdel);
        }
        wait(remainder(duration,glowdel));
        loop(15){
            Yangle+=6;
            ObjRender_SetAngleXYZ(gap,0,Yangle,angle);
            yield;
        }
        Obj_Delete(gap);
    }
    task RenderGapOutline(gap,Xpos,Ypos,xscale0,yscale0,angle,duration,alpha0,type){
        let glow = ObjPrim_Create(OBJ_SPRITE_2D);
        ObjPrim_SetTexture(glow, CSD~"../img/gap_outline.png");
        ObjSprite2D_SetSourceRect(glow,0, 0, 44, 114);
        Obj_SetRenderPriorityI(glow,30);
        ObjSprite2D_SetDestCenter(glow);
        ObjRender_SetBlendType(glow,BLEND_ADD_ARGB);
        ObjRender_SetPosition(glow,Xpos,Ypos,0);
        ObjRender_SetAngleXYZ(glow,0,0,angle);

        //let alpha0=255;
        let dA = -alpha0/duration;
        let xscale = xscale0; let yscale = yscale0;
        let xscaleincr = 0.01*xscale0; //xscale / (xscale+yscale)/2;
        let yscaleincr = 0.01*yscale0; //yscale / (xscale+yscale)/2;
        if(type==GAP_IN){
            xscale = xscale + xscaleincr*duration;
            yscale = yscale + yscaleincr*duration;
            xscaleincr*=-1; yscaleincr*=-1;
            alpha0 = 0; dA*=-1;
        }
        ObjRender_SetScaleXYZ(glow,xscale,yscale,1);

        alternative(type)
        case(GAP_IN){  ObjRender_SetColor(glow,128,128,255); }
        case(GAP_OUT){ ObjRender_SetColor(glow,255,130,128); }

        ascent(i in 0..duration) {
            ObjRender_SetAlpha(glow,alpha0+dA*i);
            ObjRender_SetScaleXYZ(glow,xscale+xscaleincr*i,yscale+yscaleincr*i,1);
            yield;
        }
        Obj_Delete(glow);
    }



    task TInGap(gap,outgap) {

        let intersectwidth = max(width-20,15); //max(width/3,15)
        let shots;
        let x; let y; let t; let k; let a;

        while(!Obj_IsDeleted(gap)){


            shots = GetShotIdInCircleA2(midx,midy,opening/2,TARGET_ALL);
            ascent(i in 0..length(shots)){
                if(Obj_GetValueD(shots[i],"CanGap",true) && IsIntersected_Line_Circle(x0,y1,x1,y0,intersectwidth, ObjMove_GetX(shots[i]),ObjMove_GetY(shots[i]),1)) {

                    x=ObjMove_GetX(shots[i]); y=ObjMove_GetY(shots[i]);

                    t = (((x0-x)^2 + (y0-y)^2)^0.5)/opening;
                    k = GetDistanceToLine(x0,y1,x1,y0, x,y)/width;
                    a = ObjMove_GetAngle(shots[i]) - angle;

                    if( k < intersectwidth*sin(1.579*114*t)/width) {
                        GapWarp(shots[i],t,k,a,outgap);
                    }
                    //WriteLog("GAP:     " ~ ToString(GetDistanceToLine(x0,y0,x1,y1, x,y)) ~ " < " ~ ToString( intersectwidth*sin(1.579*114*t)) ~ "   " ~ ToString(GetDistanceToLine(x0,y0,x1,y1, x,y) < intersectwidth*sin(1.579*114*t)) );

                    //Obj_SetValue(outgap,"Inbox", Obj_GetValue(outgap,"Inbox") ~ [[shots[i],t/opening]])
                }
            }
            yield;
        }

    }




    function GapWarp(shot,t,k,a,outgap) {

        //pseudocode for "holding" shots and moving them to the gap after a delay
        //if(hold){setx(-1000);wait;}set(pos,angle);

    //  let midx = ObjRender_GetX(outgap); let midy = ObjRender_GetY(outgap);
        let opening = ObjRender_GetScaleY(outgap)*114;
        let width   = ObjRender_GetScaleX(outgap)*44;
        let angle = ObjRender_GetAngleZ(outgap);
        let endpoints = Obj_GetValueD(outgap,"Endpoints",[0,0,0,0]);
    //  let x0=endpoints[0]; let y0=endpoints[1]; let x1=endpoints[2]; let y1=endpoints[3];
        let outpos = rotate( width*k,opening*t, 0,0, angle);
    //  if(Obj_IsDeleted(shot)){WriteLog("GAP: Tried to warp deleted shot! ~~~~~~~~~~~~~~~~~~~~~~~~~~~");return;}
        Obj_SetValue(shot,"CanGap",false);
        ObjMove_SetAngle(shot,angle+a);
        ObjMove_SetPosition(shot,endpoints[0]+outpos[0],endpoints[3]-outpos[1]);

    //  DebugWarnShot(midx+outpos[0],midy+outpos[1]);

        //WriteLog("GAP:    Warped shot to " ~ IntToString(midx+outpos[0]) ~ ", " ~ IntToString(midy+outpos[1]) ~ ", gap " ~ IntToString(midx) ~ ", " ~ IntToString(midy)  );



    }




}