🚀flipper💫space👽

Augusto
/
🚀flipper💫space👽
on 6 Nov 2026
1
7
2
0
9946
game.m
function g = game()    % minihackContest.validate,    minihackContest.play
    g.init   = @create;
    g.update = @update;
    g.render = @render;
end

function st = create(ax) 
    wW = 400; wH = 700;
    xWall = -wW/2+[0   65  0   55  50  100 0   80  80 0 0 wW/2];
    yWall =  wH  *[.61 .58 .48 .30 .20 .25 .12 .08 0  0 1 1];
    sect = {[1 2],[2 3],[4 5],[5 6],[7 8],[8 9],[10 11],[11 12],[4 6]};

    st = struct(mode="chill",wH=wH,wW=wW,g=[0 -6],t=0,dump=0.8,...
                go      = struct(xy=[0 wH/2],O=90,R=80),...
                ball    = struct(xy=[0 wH/2],v=[0 0],acc=[0 0],tail=nan(15,2),R=8,apply=[]),...
                walls   = struct(X=xWall,Y=yWall,link=sect),...
                tail    = nan(9,2),...
                stars   = nan(2,5),...
                starCoord = nan(2,5),...
                e=[],...
                counter = struct(lose=15*1,hole=20*30,antiG=10*30,blip=10),...
                planet = struct(xy=[wW/2*[-.6;-.7;.4], wH*[.4;.85;.8]],R=[30;40;50]),...
                blip    = struct(v=-10,R=90,old={cell(1,4)}),...
                blackH  = struct(H=wH*0.45,R=wW*0.27,state="grow",intensity=85));

     set(ax,XLim=wW*[-1 1]/2,YLim=wH*[0 1],DataAspectRatio=[1 1 1],NextPl="add",Color='k');

   
   % GFX INIT
   set(ax,HitTest=0,PickableParts='none');
   
   % function gfx=blip()_______________________________________
    st.gfx.blip=quiver(ax,xWall([2 8 2 8]).*[1 1 -1 -1],yWall([2 8 2 8]), 50*cosd(-30)*[1 1 -1 -1],50*sind(-30)*[1 1 1 1],Col='r',ShowA=0,AutoScale=0,LineW=2);
   
   % function gfx=drawSpace()__________________________________
      k=35;
      plot(ax,randi([-wW wW]/2,1,k),randi(wH,1,k),'w.'); % stelle
      for i=-4:.3:4
         h=randi([3 5]);
         plot(ax,wW/3*i+randi(50,1,h),randi(300)+randi(50,1,h),'w:',LineW=.2);  % costellazioni
      end
      st.gfx.bck=text(ax,0,wH*0.7,"PRESS 'SPACE'"+newline+"TO PLAY IN SPACE",Horiz='center',Color='w',Fontn="Arial");
   
   % function gfxWa=Dwalls()___________________________________
      for i=1:numel(sect)
          s=sect{i};
          gfxW(i,1)=plot(ax, xWall(s),yWall(s),'w',LineW=2); %#ok
          gfxW(i,2)=plot(ax,-xWall(s),yWall(s),'w',LineW=2); %#ok
      end
      st.gfx.walls=gfxW;
  
   % function gfxBH=drawBlackHole()____________________________
        t=linspace(0,1,60);
        for i=1:4
            R = 0.6+0.4*rand;
            r = R*t*st.blackH.R;
            a = (1+rand/2)*pi;
            O = 2*pi/4*i;
            x=r.*cos(t*a+O); y=st.blackH.H+r.*sin(t*a+O);
            gfxBH(i)=plot(ax,[x NaN -x],[y NaN 2*st.blackH.H-y],Col=[1 1 1]*R,LineW=2,UserD=R); %#ok
        end
        st.gfx.blackH = gfxBH;
        st.gfx.stars = scatter(ax,nan,nan,'p');
   
    % function draw sacrifical stars______________________________
    for i=1:5
        st.gfx.stars=plot(ax,nan,nan,'p',Color='w');
    end
    
    % draw planets
    cols = ["w" "m" "c"]; pln=st.planet;
    for i=1:3
        R=pln.R(i); xy=pln.xy(i,:);
        st.gfx.planet(i) = fill(ax,xy(1)+cosd(t*360)*R,xy(2)+sind(t*360)*R,cols(i));
    end
    plot(ax,pln.xy(1,1)+randi([-20 20],1,5),pln.xy(1,2)+randi([-20 20],1,5),'o',Col=[.7 .7 .7]);  % i crateri della luna

    % DISEGNO LE ORBITE
    tt=@(w) w:-1:(-270+(90-w));
    MR=@(a) [cosd(a) -sind(a);sind(a) cosd(a)];
    orb=@(ro,A,B,w,R) MR(ro)*[A*cosd(tt(w));B*sind(tt(w))]*R;

    e1= orb(30,2,.7,65,pln.R(2));  % << MR(30)*[2*cosd(tt(65));.7*sind(tt(65))]*pln.R(2);
    plot(ax,pln.xy(2,1)+e1(1,:),pln.xy(2,2)+e1(2,:),'c');

    e2=orb(55,1.4,.8,60,pln.R(3)); % << MR(22)*[1.4*cosd(tt(60));.8*sind(tt(60))]*pln.R(3);
    e3=orb(-17,4,.6,76,pln.R(3));  % << MR(-17)*[4*cosd(tt(80));.6*sind(tt(80))]*pln.R(3);
    plot(ax,pln.xy(3,1)+e2(1,:),pln.xy(3,2)+e2(2,:),'m');
    plot(ax,pln.xy(3,1)+e3(1,:),pln.xy(3,2)+e3(2,:),'b');

    % arrow (go) for starting game, tail and ball
    st.gfx.go=quiver(ax, st.go.xy(1),st.go.xy(2),0,50,visible=1,LineW=1,Col='c',AutoScale=0,LineSt=':');
    st.gfx.tail=plot(ax,0,0,'-y',LineW=2);
    st.gfx.ball=plot(ax,st.ball.xy(1),st.ball.xy(2),'oy',MarkerFaceC='y',MarkerSize=10,LineW=2);
end

function st = update(st, dt, pr)
    dt=dt*4;
    T=st.t+dt;
    st.t = T;
    
    st.n=[]; st.e=[];

    b=st.ball;  hole=st.blackH;
    st.tail = [st.tail(2:end,:); b.xy];
    st.go.O=90+T*25;
    st.go.R=70+sind(T/50)*30;
    if st.mode=="chill"
        % b.xy=[0 st.wH/2];
        if pr
            st.mode="play";
            st.gfx.bck.Visible=0;
            st.gfx.go.Visible=0;
            st.ball.v=[st.gfx.go.UData st.gfx.go.VData];
        end
        return   
    end
    
    vv=[-10 40];
    st.counter.blip=max(st.counter.blip-1,0);

    if pr
        st.blip.v = vv(2); st.counter.blip=10;
    else
        if st.counter.blip
            st.blip.v = vv(2);
        else
            st.blip.v = max(st.blip.v-5,vv(1));
        end
    end

    if st.mode=="play" %____________________
        
        b.xy=b.xy+b.v*dt;      % aggiornamento pallina
        if ~isempty(b.apply)
             b.xy=b.apply(1:2); b.v=b.apply(3:4); b.apply=[];
        end
        b.v=b.v+(b.acc+st.g)*dt;
        if norm(b.v)>130
            b.v=b.v/norm(b.v)*130;  % stabilizzare la velocità
        end
        b.next=b.xy+b.v*dt;
        
        U = st.gfx.blip;     % < computo dei flippers

        for h=1:numel(U.XData)
            obj=struct(XData=U.XData(h)+[0 U.UData(h)],YData=U.YData(h)+[0 U.VData(h)]);
            
            mem=st.blip.old{h};
            mem=[obj; mem]; %#ok
            if numel(mem)>5
                mem(end)=[];
            end
            st.blip.old{h}=mem;

            for f=1:numel(mem)
                [q,XY,V]=bounce(b.xy,b.next,mem(f),1.3+rand*.2,b.R+2);
                if q % << servirebbe un meccanismo per dare la priorità al segmento di primo impatto
                    b.apply=[XY V'/dt];
                    break
                end
            end
        end
        
        if isempty(b.apply)  % < se ho già preso un flipper, non computo i muri.
            for ww=numel(st.gfx.walls):-1:1  % < computo dei muri
                [q,XY,V]=bounce(b.xy,b.next,st.gfx.walls(ww),st.dump+(1+rand)*any(ww==[9 18]),b.R+2);
                if q
                    b.apply=[XY V'/dt];
                    break
                end
            end
        end

        for i=1:numel(st.planet.R)  % < computo dei pianeti
            [q,XY,V]=land(b.next,st.planet.xy(i,:),st.planet.R(i),2,b.R);
            if q
                b.apply=[XY V/dt];
            end
        end

        Hint=hole.intensity;  % < computo black Hole
        b.acc=[0 0];
        if norm(b.xy-[0 hole.H])<hole.R   % is the ball inside?
            Hint = min(100,Hint+0.5);
            if Hint==100
               hole.state="nova";
            elseif Hint>20
               hole.state="dark";
            else
               hole.state="grow"; 
            end
            hole.intensity = Hint;
        end

        switch hole.state     % black hole effects (even if out of range)
            case "dark"  
              angls = st.stars(1,:);
              radii = st.stars(2,:);
              radii = max(0,radii-randi(10,1,5));
              rep=radii<15;

              angls(rep)=randi(500,1,nnz(rep));    % < angolo
              radii(rep)=randi(hole.R+[0 40],1,nnz(rep)); % < raggio
              st.stars=[angls; radii];
              st.coords = [0; hole.H]+radii.*[cosd(angls);sind(angls)];
              st.starAlfa  = min(1,radii/hole.R);
            case "nova"
                dd = b.xy-[0 hole.H];
                G=hole.R*1.5;
                b.acc = -40*(dd/norm(dd)^3)*G^2;
                st.counter.hole=max(0,st.counter.hole-1);
                if st.counter.hole==0
                    hole.state="grow"; hole.intensity=0;
                end
            otherwise
                st.counter.hole=20;
        end
        st.blackH=hole;
        
    end    % ___________________
    

    if b.xy(2)<0
        st.mode = "reset";
        b.v=[0 0];
    end
    if st.mode=="reset"
        st.counter.lose = st.counter.lose-1;
        if st.counter.lose<0
         st.mode="chill";
         st.counter.lose=15;
         b.xy=[0 st.wH/2];
        end
    end
    st.ball = b;
end

function [h,P,V]=land(XY,pXY,pR,k,R)
    d = XY-pXY; P=[]; V=[];
    h = norm(d)<(pR+R);
    if h
       P=pXY+d/norm(d)*(pR+R);
       V=d*k+randi(5,1,2);
    end
end


function [h,P,V,n,e,t] = bounce(xy,XY,O,k,R)
         x1=xy(1);y1=xy(2); 
         x2=XY(1);y2=XY(2);
         x3=O.XData(1);
         x4=O.XData(end);
         y3=O.YData(1);
         y4=O.YData(end);
        
        h = 0; P = [];  V=[]; e=[];
        
        v = [x2-x1; y2-y1];
        w = [x4-x3; y4-y3];
        w = w/norm(w);
        
        n = [-w(2); w(1)];
        if dot(v,n) > 0
            n = -n; 
        end
        
        B = [x3;y3] + R*n;
        D = [x4;y4] + R*n - B;
        
        den = v(1)*D(2) - v(2)*D(1);
        
        if abs(den)<1e-6
            return
        end
        
        d = B - xy';
        
        t = (d(1)*D(2) - d(2)*D(1))/den;
        u = (d(1)*v(2) - d(2)*v(1))/den;
        
        h = t>=0 & t<=1 & u>=0 & u<=1;
        
        if ~h
            return
        end
        e = -dot(v,n);
        P = (xy' + t*v).';               % centro al contatto
        V = k*(v - 2*dot(v,n)*n);        % velocità riflessa
    end



    function render(~,st)
    
    rgb = hsv2rgb([rem(st.t/5,1) 0.5 1]); 
    set(st.gfx.tail,XData=st.tail(:,1),YData=st.tail(:,2),Color='y');
    set([st.gfx.blip st.gfx.walls(end,:)],Color=rgb);
    if st.mode=="chill"
        ga=st.gfx.go; ar=st.go;
        set(ga,UData=ar.R*cosd(ar.O),VData=ar.R*sind(ar.O),Visible=1);
    end
    
        b=st.ball;
        set(st.gfx.ball,XData=b.xy(1),YData=b.xy(2),Color=rgb);

    if any(st.mode==["play" "reset"])
        for i=1:numel(st.gfx.blackH)
            set(st.gfx.blackH(i),Color=st.gfx.blackH(i).UserData*[1 1 1]*(st.blackH.intensity)/100)
        end
        switch st.blackH.state
            case "dark"
            set(st.gfx.stars,Visible=1,XData=st.coords(1,:),YData=st.coords(2,:));
            case "nova"
            set(st.gfx.stars,Visible=0);
        end
    end

    % DIAGNOSTICA DEGLI URTI
    % if ~isempty(st.e) 
    %      quiver(st.gfx.ball.Parent, st.ball.xy(1),st.ball.xy(2),st.n(1)*st.e,st.n(2)*st.e,Color=rgb); 
    % end

    o=st.blip.v; r=st.blip.R;
    set(st.gfx.blip,UData=cosd(o).*[r r -r -r],VData=sind(o)*[r r r r]);
end

% minihackContest.validate,    minihackContest.play
Play Game
Preview

Play Game opens this in MATLAB Drive. Click Run this app there to play.