ソースコード

物理演算にはAPEパッケージを使用しています。

Gariben.as (メインクラス)

package {
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import org.cove.ape.APEngine;
    import org.cove.ape.Group;
    import org.cove.ape.Vector;
    
    [SWF(width='550',height='400',backgroundColor='0x0',frameRate='40')]

    public class Gariben extends Sprite{
        //APE objects
        private var wall:Wall;
        private var obj:SphereSpring;
    
        //for drag
        public var base:Sprite;
        private var flgMouse:Boolean;
        
        //img
        private var character:Character;
        
        public function Gariben(){
            //for APE
            APEInit();
            
            addEventListener(Event.ENTER_FRAME, run);
        
            createBase();
            base.addEventListener(MouseEvent.MOUSE_DOWN, pick);
            stage.addEventListener(MouseEvent.MOUSE_UP, place);
            
            character = new Character();
            base.addChild(character);
        }
        
        private function createBase():void{
            base = new Sprite();
            base.x = obj.cAry[0].px;
            base.y = obj.cAry[0].py;
            addChild(base);
        }
        
        private function pick(e:MouseEvent):void{
            flgMouse = true;
            e.target.startDrag();
        }
        
        private function place(e:MouseEvent):void{
            flgMouse = false;
            //e.target.stopDrag();
            base.stopDrag();
        }
        
        private function chase():void{
            //tune the rotating angle
            var dx:Number = obj.cAry[1].px - obj.cAry[0].px;
            var dy:Number = obj.cAry[1].py - obj.cAry[0].py;
            var ang:Number = Math.atan2(dy,dx);
            base.rotation = 180*ang/Math.PI;
            
            base.x = obj.cAry[0].px;
            base.y = obj.cAry[0].py;
            
            //why needed?
            character.x = 0;
            character.y = 0;
            
            if (flgMouse){
                obj.cAry[0].px = stage.mouseX;
                obj.cAry[0].py = stage.mouseY;
            }
        }
        
        private function APEInit():void{
            var stageWidth:Number = stage.stageWidth;
            var stageHeight:Number = stage.stageHeight;
            var wallThickness:Number = 100;
            
            APEngine.init(0.25);
            APEngine.container = this;
            APEngine.addMasslessForce(new Vector(0,5));
            
            wall= new Wall(stageWidth,stage.stageHeight,wallThickness);
            APEngine.addGroup(wall);
            
            obj= new SphereSpring(stageWidth/2,stageHeight/2);
            APEngine.addGroup(obj);
            
            //"wall" collides with "obj"
            wall.addCollidableList(new Array(obj));
        }
        
        private function run(e:Event):void{
            chase();
            APEngine.step();
            APEngine.paint();
        }
    }
}

SphereSpring.as (ネット状のオブジェクト全体)

package{
    import flash.display.Sprite;
    import org.cove.ape.CircleParticle;
    import org.cove.ape.SpringConstraint;
    import org.cove.ape.Group;
    
    public class SphereSpring extends Group{
            private static const N_TOTAL:int = 10;
            private static const RADIUS:int = 100;
            
            //must be accessible from the main class
            public var cAry:Array;
        
        public function SphereSpring(xPos:Number, yPos:Number){
            
            cAry = new Array();
            
            //center object (optional)
            var c0:CircleParticle = new CircleParticle(xPos,yPos,0);
            addParticle(c0);
            cAry.push(c0);
            
            for (var i:int=0; i<N_TOTAL; i++){
                var t:Number = 2*Math.PI*i/N_TOTAL;
                var x:Number = xPos + RADIUS*Math.cos(t);
                var y:Number = yPos + RADIUS*Math.sin(t);
                //var c:CircleParticle = new CircleParticle(x,y,0);
                var c:CircleParticle = new CircleParticle(x,y,0,false,1,0.3,0.1);
                c.setStyle(0, 0xFFFFFF, 1, 0xFFFFFF);
                addParticle(c);
                cAry.push(c);
            }
            
            for (i=0; i<cAry.length; i++){
                for (var j:int=0; j<cAry.length; j++){
                    if (j!=i){
                        var s:SpringConstraint = new SpringConstraint(cAry[i],cAry[j],0.2);
                        s.setStyle(0, 0x666666, 1, 0xFFFFFF);
                        addConstraint(s);
                    }
                }
            }
        }
    }
}

Wall.as (壁)

package{
    import org.cove.ape.RectangleParticle;
    import org.cove.ape.Group;
    
    public class Wall extends Group{
        
        private var rL:RectangleParticle;
        private var rR:RectangleParticle;
        private var rT:RectangleParticle;
        private var rB:RectangleParticle;
        
        public function Wall(stageWidth:Number,stageHeight:Number,wallThickness:Number){
            rL = new RectangleParticle(-wallThickness/2,stageHeight/2,stageHeight,wallThickness,Math.PI/2,true);
            addParticle(rL);
            rR = new RectangleParticle(stageWidth+wallThickness/2,stageHeight/2,stageHeight,wallThickness,Math.PI/2,true);
            addParticle(rR);
            rT = new RectangleParticle(stageWidth/2,-wallThickness/2,stageWidth,wallThickness,0,true);
            addParticle(rT);
            rB = new RectangleParticle(stageWidth/2,stageHeight+wallThickness/2,stageWidth,wallThickness,0,true);
            addParticle(rB);
        }
    }
}

Character.as (キャラクターアニメーション)

package{
    import flash.utils.setInterval;
    import flash.display.Sprite;
    import flash.display.Bitmap;
    
    public class Character extends Sprite{
        [Embed(source="gari1.gif")]
        private var IMG1:Class;
        [Embed(source="gari2.gif")]
        private var IMG2:Class;
        
        private var img1:Bitmap;
        private var img2:Bitmap;
        private var flgIMG:Boolean;
        
        public function Character(){
            img1 = new IMG1();
            img2 = new IMG2();
            img1.x = -img1.bitmapData.width/2;
            img1.y = -img1.bitmapData.height/2;
            img2.x = -img2.bitmapData.width/2;
            img2.y = -img2.bitmapData.height/2;
            
            addChildAt(img1,0);
            setInterval(changeIMG,500);
        }
        
        private function changeIMG():void{
            
            if(flgIMG){
                addChildAt(img1,0);
                flgIMG = false;
            }
            else{
                addChildAt(img2,0);
                flgIMG = true;
            }
            if (numChildren > 1){
                removeChildAt(1);
            }
        }
    }
}