flash on 2016-9-5

by mutantleg
♥0 | Line 237 | Modified 2016-09-05 01:20:31 | MIT License
play

ActionScript3 source code

/**
 * Copyright mutantleg ( http://wonderfl.net/user/mutantleg )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/yTr3
 */

package {
    import flash.text.TextField;
    import flash.events.Event;
    import flash.display.Sprite;
    public class FlashTest extends Sprite {
        public function FlashTest() {
         deb = new TextField();
          deb.width=320; deb.height=240;
          deb.mouseEnabled=false;
         addChild(deb);   
            
           // swapPos(myObj.vecVert[0], myObj.vecVert[1]); //b
            //swapPos(myObj.vecVert[3], myObj.vecVert[2]);
          //  swapPos(myObj.vecVert[1], myObj.vecVert[3]);
          //  swapPos(myObj.vecVert[0], myObj.vecVert[2]); 
            
         stage.addEventListener(Event.ENTER_FRAME, onEnter);    
        }//ctor

        public var myObj:xObj = new xObj();
        
        public var deb:TextField;


        public function getMag(ax:Number,ay:Number,az:Number):Number
        { return Math.sqrt(ax*ax+ay*ay+az*az); }
        
        public function onEnter(e:Event):void
        {
           graphics.clear();
           graphics.lineStyle(2, 0);
           
           drawBox2(0,0,0, 384,-16,384);

           graphics.lineStyle(2, 0xFF0000);

           graphics.lineStyle(2, 0);
           
            upVert(myObj.vecVert);
            upSpring(myObj.vecSpring);
           
           var ax:Number; var ay:Number; var az:Number;
           var bx:Number; var by:Number; var bz:Number;
           var dx:Number; var dy:Number; var dz:Number;
           
           ax = myObj.vecVert[1].cx - myObj.vecVert[0].cx;
           ay = myObj.vecVert[1].cy - myObj.vecVert[0].cy;
           az = myObj.vecVert[1].cz - myObj.vecVert[0].cz;

           bx = myObj.vecVert[2].cx - myObj.vecVert[0].cx;
           by = myObj.vecVert[2].cy - myObj.vecVert[0].cy;
           bz = myObj.vecVert[2].cz - myObj.vecVert[0].cz;
           
           dx = (ay * bz) - (az * by);
           dy = (az * bx) - (ax * bz);
           dz = (ax * by) - (ay * bx);
          
            var mag:Number;
            mag = getMag(dx,dy,dz);
            if (mag==0){mag=0.0001;}
            dx/=mag; dy/=mag; dz/=mag;          

            var dot:Number;
            dot = 0*dx + dy*1 + dz*0;
            deb.text = ""+dot;
            
            if (dot < 0)
            {
              myObj.vecVert[0].vy = 3;     
              myObj.vecVert[2].vy = 3;     
              myObj.vecVert[1].vy = -3;     
              myObj.vecVert[3].vy = -3;     
            }
            
         
             dx*=32; dy*=32; dz*=32;
          
           graphics.lineStyle(2,0xFF);
           drawLine(myObj.vecVert[0].cx,myObj.vecVert[0].cy,myObj.vecVert[0].cz,
           myObj.vecVert[0].cx+dx,myObj.vecVert[0].cy+dy,myObj.vecVert[0].cz+dz);
     
           ax = myObj.vecVert[0].cx + (myObj.vecVert[1].cx - myObj.vecVert[0].cx) * 0.5;
           ay = myObj.vecVert[0].cy + (myObj.vecVert[1].cy - myObj.vecVert[0].cy) * 0.5; 
           az = myObj.vecVert[0].cz + (myObj.vecVert[1].cz - myObj.vecVert[0].cz) * 0.5;
           bx = myObj.vecVert[3].cx + (myObj.vecVert[2].cx - myObj.vecVert[3].cx) * 0.5;
           by = myObj.vecVert[3].cy + (myObj.vecVert[2].cy - myObj.vecVert[3].cy) * 0.5; 
           bz = myObj.vecVert[3].cz + (myObj.vecVert[2].cz - myObj.vecVert[3].cz) * 0.5;
     
            drawBox3(ax,ay,az, 4,4,4);
            drawBox3(bx,by,bz, 4,4,4);
            drawLine(ax,ay,az, bx,by,bz);
            
            var ta:Number;
            var nx:Number; var nz:Number;
            ta = Math.atan2(az-bz, ax-bx);
            
             ang += 0.1;
             //ta += Math.sin(ang);
             ta+=0.4;
             
            nx = Math.cos(ta);
            nz = Math.sin(ta);
            drawLine(ax,ay,az, ax+nx*28,ay,az+nz*28);     
     
             nx*=0.1; nz*=0.1;
              myObj.vecVert[1].vx += nx;     
              myObj.vecVert[3].vx += nx;     
              myObj.vecVert[1].vz += nz;     
              myObj.vecVert[3].vz += nz;     
         
     
        }//onenter

        
        public var ang:Number =0;

        public function swapPos(a:xVert, b:xVert):void
        {
          var ax:Number;
          ax = a.cx; a.cx = b.cx; b.cx = ax;    
          ax = a.cy; a.cy = b.cy; b.cy = ax;    
          ax = a.cz; a.cz = b.cz; b.cz = ax;    
        }//swappos
       
        public function upVert(vec:Vector.<xVert>):void
        { 
          var a:xVert; var i:int; var num:int;
          num = vec.length;
          for(i=0;i<num;i+=1)
          {
            a = vec[i];
            a.vy-=0.2;
            a.vx*=0.99; a.vy*=0.99; a.vz*=0.99;

            if (a.cy+a.vy<a.rad && a.vy<0){ a.vy -= a.vy; }
            if (a.cx+a.vx<a.rad && a.vx<0){ a.vx -= a.vx; }
            if (a.cz+a.vz<a.rad && a.vz<0){ a.vz -= a.vz; }
            if (a.cx+a.vx>384 && a.vx>0){ a.vx -= a.vx; }
            if (a.cz+a.vz>384 && a.vz>0){ a.vz -= a.vz; }

            a.cx+=a.vx; a.cy+=a.vy; a.cz+=a.vz;
            drawBox3(a.cx,0,a.cz, a.rad,1,a.rad);
            drawBox3(a.cx,a.cy,a.cz, a.rad,a.rad,a.rad);
          }//nexti  
        }//upvert
 
        public function upSpring(vec:Vector.<xSpring>):void
        { var a:xSpring; var i:int; var num:int;
          num = vec.length;
          for(i=0;i<num;i+=1)
          { 
            a = vec[i]; 
            drawLine(a.va.cx, 0, a.va.cz,  a.vb.cx, 0, a.vb.cz);
            drawLine(a.va.cx, a.va.cy, a.va.cz,  a.vb.cx, a.vb.cy, a.vb.cz);
            spring(a.va, a.vb, a.rest, a.t);
          }//nexti
        }//uppsring       
        
        
        
        public var camx:Number = 0;   public var camy:Number = 0;  public var camz:Number = 0; 
        public var rendw:Number = 465 * 0.5;        public var rendh:Number = 465 * 0.5; 
        public function drawLine(ax:Number, ay:Number, az:Number,
        bx:Number, by:Number, bz:Number):void
        {
           var sx:Number; var sy:Number;     
           ax -= camx; ay -= camy; az -= camz;
           bx -= camx; by -= camy; bz -= camz;
            sx = ax - az + rendw;     sy = (ax * 0.5) + (az * 0.5) - ay;
            graphics.moveTo(sx,sy);
            sx = bx - bz + rendw;     sy = (bx * 0.5) + (bz * 0.5) - by;
            graphics.lineTo(sx, sy);
        }//drawline 

        public function drawBox3(ax:Number,ay:Number,az:Number,
        rx:Number,ry:Number,rz:Number):void
        { drawBox(ax-rx,ay-ry,az-rz,ax+rx,ay+ry,az+rz); }

        public function drawBox2(ax:Number,ay:Number,az:Number,
        aw:Number,ah:Number,ad:Number):void
        { drawBox(ax,ay,az, ax+aw,ay+ah,az+ad); }
        
           
        public function drawBox(ax:Number, ay:Number, az:Number,
          bx:Number, by:Number, bz:Number):void
        {
          drawLine(ax, ay, az,   bx, ay, az);
          drawLine(ax, by, az,   bx, by, az);
          drawLine(ax, ay, bz,   bx, ay, bz);
          drawLine(ax, by, bz,   bx, by, bz);
          
          drawLine(ax, ay, az,   ax, by, az);
          drawLine(bx, ay, az,   bx, by, az);
          drawLine(ax, ay, bz,   ax, by, bz);
          drawLine(bx, ay, bz,   bx, by, bz);
          
          drawLine(ax, ay, az,   ax, ay, bz);
          drawLine(bx, ay, az,   bx, ay, bz);
          drawLine(ax, by, az,   ax, by, bz);
          drawLine(bx, by, az,   bx, by, bz);
        }//drawbox

       public function goPos(a:xVert, ax:Number, ay:Number, az:Number, r:Number=32,t:Number=0.1):void
        {
          drawLine(ax,ay,az, a.cx, a.cy, a.cz);  
          var mag:Number; var dx:Number; var dy:Number; var dz:Number;
          var kx:Number; var ky:Number; var kz:Number;
          dx = ax-(a.cx+a.vx); dy= ay-(a.cy+a.vy); dz = az-(a.cz+a.vz);
          mag = Math.sqrt(dx*dx+ dy*dy + dz*dz);
          if (mag == 0) { mag =0.0001; }
          dx/=mag;   dy/=mag; dz/=mag;
          r = mag-r;
          kx = dx*r;  ky = dy*r;    kz = dz*r;
          a.vx += (kx-a.vx)*t;
          a.vy += (ky-a.vy)*t;
          a.vz += (kz-a.vz)*t;
        }//gopos
        
        
        public function spring(a:xVert, b:xVert, rest:Number, t:Number=0.5):void
        {
          var ax:Number;     var ay:Number;     var az:Number;
          var dx:Number;     var dy:Number;     var dz:Number;
          var nx:Number;     var ny:Number;     var nz:Number; 
          var dist:Number;   var mag:Number;
          var reld:Number;   var relvel:Number;      var rem:Number;      

           dx = ((a.cx + a.vx) - (b.cx + b.vx));     
           dy = ((a.cy+a.vy) - (b.cy+b.vy));
           dz = ((a.cz+a.vz) - (b.cz+b.vz));
            
            mag = Math.sqrt(dx * dx + dy * dy + dz*dz);
            if (mag == 0) {mag = Math.random(); a.cx += Math.random()-0.5; b.cy+=Math.random()-0.5;}
            //if (mag == 0) { mag = 0.001; }
            
            nx = dx / mag;     ny = dy / mag;     nz = dz/mag;
            ax = a.vx - b.vx;     ay = a.vy - b.vy;   az  = a.vz-b.vz;
    
            relvel = (ax*nx) +(ay*ny) + (az*nz);
            reld = mag - (rest+rest);
                 
            rem = relvel + reld;
            rem*=0.5;
                    
            if (rem > 130) { rem = 130; }
            else if (rem < -130) { rem = -130; }
      
            a.vx += (rem * (nx * -t));     
            a.vy += (rem * (ny * -t));
            a.vz += (rem * (nz * -t));
            b.vx += (rem * (nx * t));     
            b.vy += (rem * (ny * t)); 
            b.vz += (rem * (nz * t)); 

        }//spring  
        
              
    }//classend
}

internal class xObj
{
 public var vecVert:Vector.<xVert> = new Vector.<xVert>(0, false);
 public var vecSpring:Vector.<xSpring> = new Vector.<xSpring>(0, false);    
 
 public function xObj()
 {
    vecVert.push(new xVert(230, 32, 230) );   
    vecVert.push(new xVert(230+32, 32, 230) );   
    vecVert.push(new xVert(230, 32, 230+64) );   
    vecVert.push(new xVert(230+32, 32, 230+64) );   

       var i:int; var k:int;
       for (i=0;i<4;i+=1)
       { for (k=i+1;k<4;k+=1)
         {   addSpring(vecVert[i], vecVert[k]); }
       }//nexti
 }//ctor

 public function getMag(ax:Number,ay:Number,az:Number):Number
  { return Math.sqrt(ax*ax+ay*ay+az*az); }
  
 public function addSpring(a:xVert, b:xVert):void
 {
   var sp:xSpring;
   sp = new xSpring();
   sp.va = a; sp.vb = b;
   sp.rest = getMag(a.cx-b.cx, a.cy-b.cy, a.cz-b.cz);  
   vecSpring.push(sp);
 }//addspring
 
 
}//xobj

internal class xVert
{
  public var rad:Number = 4;  
  public var cx:Number = 0;  public var cy:Number = 0;  public var cz:Number = 0;
  public var vx:Number = 0;  public var vy:Number = 0;  public var vz:Number = 0;      
  public function xVert(ax:Number,ay:Number, az:Number) { cx=ax; cy=ay; cz=az;}      
}//xvert

internal class xSpring
{
  public var va:xVert = null;
  public var vb:xVert = null;
  public var rest:Number = 32;
  public var t:Number = 0.5;
}//xspring