source: scenarios/GerminationX/fungi/src/truffle/SkeletonEntity.hx @ 820

Revision 820, 4.4 KB checked in by dave, 10 years ago (diff)

added seeds and picking

Line 
1// t r u f f l e Copyright (C) 2010 FoAM vzw   \_\ __     /\
2//                                          /\    /_/    / / 
3// This program is free software: you can redistribute it and/or modify
4// it under the terms of the GNU Affero General Public License as
5// published by the Free Software Foundation, either version 3 of the
6// License, or (at your option) any later version.
7//
8// This program is distributed in the hope that it will be useful,
9// but WITHOUT ANY WARRANTY; without even the implied warranty of
10// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11// GNU Affero General Public License for more details.
12//
13// You should have received a copy of the GNU Affero General Public License
14// along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
16package truffle;
17
18import truffle.Truffle;
19import truffle.Graph;
20
21class SkeletonEntity extends truffle.Entity
22{
23    public var Root:Bone;
24        var g:Graph;
25    var bones:Array<Bone>;
26
27        public function new(world:World,pos:Vec3)
28        {
29                super(world,pos);
30        Root = null;
31        }
32
33    function GetClosest(pos:Vec2, bones:List<Bone>) : Bone
34    {
35        var dist=99999.0;
36        var closest:Bone=null;
37        for (b in bones)
38        {
39            var d=pos.Sub(b.Pos).Mag();
40            if (d>0.00001 && d<dist)
41            {
42                dist=d;
43                closest=b;
44            }
45        }
46        return closest;
47    }
48   
49    function FindTop(desc:Array<Dynamic>)
50    {
51        var highest=9999;
52        var top=0;
53        var c=0;
54        for (d in desc)
55        {
56            if (d.position.y<highest)
57            {
58                highest=d.position.y;
59                top=c;
60            }
61            c++;
62        }
63        return top;
64    }
65   
66    function BuildBones(desc:Array<Dynamic>)
67    {
68        var bones=new Array<Bone>();
69        for (d in desc)
70        {
71            var b=new Bone(new Vec2(-Std.parseInt(d.position.x),
72                                    -Std.parseInt(d.position.y)),
73                                    Resources.Get("test"));
74            b.LoadFromURL(d.name);
75            bones.push(b);
76        }
77        return bones;
78    }
79
80    function CalculateMST(bones:Array<Bone>,root:Int)
81    {
82        var g=new Graph(new List<Edge>());
83        var x=0;
84        var y=0;
85        for (xb in bones)
86        {
87            for (yb in bones)
88            {
89                g.AddEdge(new Edge(x,y,xb.Pos.Sub(yb.Pos).Mag()));
90                y++;
91            }
92            y=0;
93            x++;
94        }
95        return g.MST(root);
96    }
97
98    public function Build(world:World,desc:Array<Dynamic>)
99    {
100        bones=BuildBones(desc);
101        var top=FindTop(desc);
102        g=CalculateMST(bones,top);
103        Root=bones[top];
104        world.AddSprite(Root);
105        var relative = new Array<Vec2>();
106        for (i in 0...bones.length) relative.push(new Vec2(0,0));
107
108        for (edge in g.Edges)
109        {
110            bones[edge.From].AddChild(world,bones[edge.To]);
111            relative[edge.To]=bones[edge.From].Pos.Sub(bones[edge.To].Pos);
112        }
113
114        for (b in 0...bones.length)
115        {
116            bones[b].Pos=relative[b].Mul(0.5);
117        }
118    }
119
120    override function OnSortScene(order:Int) : Void
121    {
122        Root.SetDepth(order+10);
123        Root.Recurse(function(b:Bone,depth:Int)
124        {
125            b.SetDepth(order+1);
126        });       
127    }
128
129        override public function Update(frame:Int, world:World)
130        {
131        super.Update(frame,world);
132
133        //Root.SetRotate(25*Math.sin(frame*0.04));
134        //Draw(cast(world,truffle.World));
135
136        //UpdateDepth();
137
138        Root.Recurse(function(b:Bone,depth:Int)
139        {
140            b.SetRotate(15*Math.sin((10-depth)*0.58+frame*0.04));
141        }
142        );
143
144        Root.SetPos(new Vec2(Pos.x,Pos.y));
145        Root.Update(frame,null);
146        }
147 
148        public function Draw(world:World)
149        {
150        world.graphics.clear();
151                world.graphics.lineStyle(1, 0x00aa00, 1);       
152
153        for (e in g.Edges)
154        {
155            var start=bones[e.From].GetGlobalPos();
156            var end=bones[e.To].GetGlobalPos();
157            world.graphics.moveTo(start.x,start.y);
158            world.graphics.lineTo(end.x,end.y);
159            world.graphics.beginFill( 0x99ff33 , 1 );
160            // drawing circle
161            world.graphics.drawCircle( start.x , start.y , 4 );
162            world.graphics.drawCircle( end.x , end.y , 4 );
163        }
164    }
165
166    override public function GetRoot() : Dynamic
167    {
168        return Root;
169    }
170}
Note: See TracBrowser for help on using the repository browser.