1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.replica.replicaisland;
18
19import java.util.Comparator;
20
21import com.replica.replicaisland.AnimationComponent.PlayerAnimations;
22import com.replica.replicaisland.CollisionParameters.HitType;
23import com.replica.replicaisland.EnemyAnimationComponent.EnemyAnimations;
24import com.replica.replicaisland.GameObject.ActionType;
25import com.replica.replicaisland.GameObject.Team;
26import com.replica.replicaisland.GenericAnimationComponent.Animation;
27
28/** A class for generating game objects at runtime.
29 * This should really be replaced with something that is data-driven, but it is hard to do data
30 * parsing quickly at runtime.  For the moment this class is full of large functions that just
31 * patch pointers between objects, but in the future those functions should either be
32 * a) generated from data at compile time, or b) described by data at runtime.
33 */
34public class GameObjectFactory extends BaseObject {
35    private final static int MAX_GAME_OBJECTS = 384;
36    private final static ComponentPoolComparator sComponentPoolComparator = new ComponentPoolComparator();
37    private FixedSizeArray<FixedSizeArray<BaseObject>> mStaticData;
38    private FixedSizeArray<GameComponentPool> mComponentPools;
39    private GameComponentPool mPoolSearchDummy;
40    private GameObjectPool mGameObjectPool;
41
42    private float mTightActivationRadius;
43    private float mNormalActivationRadius;
44    private float mWideActivationRadius;
45    private float mAlwaysActive;
46
47    private final static String sRedButtonChannel = "RED BUTTON";
48    private final static String sBlueButtonChannel = "BLUE BUTTON";
49    private final static String sGreenButtonChannel = "GREEN BUTTON";
50    private final static String sSurprisedNPCChannel = "SURPRISED";
51
52
53    // A list of game objects that can be spawned at runtime.  Note that the indicies of these
54    // objects must match the order of the object tileset in the level editor in order for the
55    // level content to make sense.
56    public enum GameObjectType {
57        INVALID(-1),
58
59        PLAYER (0),
60
61        // Collectables
62        COIN (1),
63        RUBY (2),
64        DIARY (3),
65
66        // Characters
67        WANDA (10),
68        KYLE (11),
69        KYLE_DEAD (12),
70        ANDOU_DEAD (13),
71        KABOCHA (26),
72        ROKUDOU_TERMINAL (27),
73        KABOCHA_TERMINAL (28),
74        EVIL_KABOCHA (29),
75        ROKUDOU (30),
76
77        // AI
78        BROBOT (16),
79        SNAILBOMB (17),
80        SHADOWSLIME (18),
81        MUDMAN (19),
82        SKELETON (20),
83        KARAGUIN (21),
84        PINK_NAMAZU (22),
85        TURRET (23),
86        TURRET_LEFT (24),
87        BAT (6),
88        STING(7),
89        ONION(8),
90
91        // Objects
92        DOOR_RED (32),
93        DOOR_BLUE (33),
94        DOOR_GREEN (34),
95        BUTTON_RED (35),
96        BUTTON_BLUE (36),
97        BUTTON_GREEN (37),
98        CANNON (38),
99        BROBOT_SPAWNER (39),
100        BROBOT_SPAWNER_LEFT (40),
101        BREAKABLE_BLOCK(41),
102        THE_SOURCE(42),
103        HINT_SIGN(43),
104
105        // Effects
106        DUST(48),
107        EXPLOSION_SMALL(49),
108        EXPLOSION_LARGE(50),
109        EXPLOSION_GIANT(51),
110
111
112        // Special Spawnable
113        DOOR_RED_NONBLOCKING (52),
114        DOOR_BLUE_NONBLOCKING (53),
115        DOOR_GREEN_NONBLOCKING (54),
116
117        GHOST_NPC(55),
118
119        CAMERA_BIAS(56),
120
121        FRAMERATE_WATCHER(57),
122        INFINITE_SPAWNER(58),
123        CRUSHER_ANDOU(59),
124
125
126        // Projectiles
127        ENERGY_BALL(68),
128        CANNON_BALL(65),
129        TURRET_BULLET(66),
130        BROBOT_BULLET(67),
131        BREAKABLE_BLOCK_PIECE(68),
132        BREAKABLE_BLOCK_PIECE_SPAWNER(69),
133        WANDA_SHOT(70),
134
135        // Special Objects -- Not spawnable normally
136        SMOKE_BIG(-1),
137        SMOKE_SMALL(-1),
138
139        CRUSH_FLASH(-1),
140        FLASH(-1),
141
142        PLAYER_JETS(-1),
143        PLAYER_SPARKS(-1),
144        PLAYER_GLOW(-1),
145        ENEMY_SPARKS(-1),
146        GHOST(-1),
147        SMOKE_POOF(-1),
148        GEM_EFFECT(-1),
149        GEM_EFFECT_SPAWNER(-1),
150
151
152        // End
153        OBJECT_COUNT(-1);
154
155        private final int mIndex;
156        GameObjectType(int index) {
157            this.mIndex = index;
158        }
159
160        public int index() {
161            return mIndex;
162        }
163
164        // TODO: Is there any better way to do this?
165        public static GameObjectType indexToType(int index) {
166            final GameObjectType[] valuesArray = values();
167            GameObjectType foundType = INVALID;
168            for (int x = 0; x < valuesArray.length; x++) {
169                GameObjectType type = valuesArray[x];
170                if (type.mIndex == index) {
171                    foundType = type;
172                    break;
173                }
174            }
175            return foundType;
176        }
177
178    }
179
180    public GameObjectFactory() {
181        super();
182
183        mGameObjectPool = new GameObjectPool(MAX_GAME_OBJECTS);
184
185        final int objectTypeCount = GameObjectType.OBJECT_COUNT.ordinal();
186        mStaticData = new FixedSizeArray<FixedSizeArray<BaseObject>>(objectTypeCount);
187
188        for (int x = 0; x < objectTypeCount; x++) {
189            mStaticData.add(null);
190        }
191
192        final ContextParameters context = sSystemRegistry.contextParameters;
193        final float halfHeight2 = (context.gameHeight * 0.5f) * (context.gameHeight * 0.5f);
194        final float halfWidth2 = (context.gameWidth * 0.5f) * (context.gameWidth * 0.5f);
195        final float screenSizeRadius = (float)Math.sqrt(halfHeight2 + halfWidth2);
196        mTightActivationRadius = screenSizeRadius + 128.0f;
197        mNormalActivationRadius = screenSizeRadius * 1.25f;
198        mWideActivationRadius = screenSizeRadius * 2.0f;
199        mAlwaysActive = -1.0f;
200
201        // TODO: I wish there was a way to do this automatically, but the ClassLoader doesn't seem
202        // to provide access to the currently loaded class list.  There's some discussion of walking
203        // the actual class file objects and using forName() to instantiate them, but that sounds
204        // really heavy-weight.  For now I'll rely on (sucky) manual enumeration.
205        class ComponentClass {
206            public Class<?> type;
207            public int poolSize;
208            public ComponentClass(Class<?> classType, int size) {
209                type = classType;
210                poolSize = size;
211            }
212        }
213        ComponentClass[] componentTypes = {
214                new ComponentClass(AnimationComponent.class, 1),
215                new ComponentClass(AttackAtDistanceComponent.class, 16),
216                new ComponentClass(BackgroundCollisionComponent.class, 192),
217                new ComponentClass(ButtonAnimationComponent.class, 32),
218                new ComponentClass(CameraBiasComponent.class, 8),
219                new ComponentClass(ChangeComponentsComponent.class, 256),
220                new ComponentClass(CrusherAndouComponent.class, 1),
221                new ComponentClass(DoorAnimationComponent.class, 256),  //!
222                new ComponentClass(DynamicCollisionComponent.class, 256),
223                new ComponentClass(EnemyAnimationComponent.class, 256),
224                new ComponentClass(FadeDrawableComponent.class, 32),
225                new ComponentClass(FixedAnimationComponent.class, 8),
226                new ComponentClass(FrameRateWatcherComponent.class, 1),
227                new ComponentClass(GenericAnimationComponent.class, 32),
228                new ComponentClass(GhostComponent.class, 256),
229                new ComponentClass(GravityComponent.class, 128),
230                new ComponentClass(HitPlayerComponent.class, 256),
231                new ComponentClass(HitReactionComponent.class, 256),
232                new ComponentClass(InventoryComponent.class, 128),
233                new ComponentClass(LauncherComponent.class, 16),
234                new ComponentClass(LaunchProjectileComponent.class, 128),
235                new ComponentClass(LifetimeComponent.class, 384),
236                new ComponentClass(MotionBlurComponent.class, 1),
237                new ComponentClass(MovementComponent.class, 128),
238                new ComponentClass(NPCAnimationComponent.class, 8),
239                new ComponentClass(NPCComponent.class, 8),
240                new ComponentClass(OrbitalMagnetComponent.class, 1),
241                new ComponentClass(PatrolComponent.class, 256),
242                new ComponentClass(PhysicsComponent.class, 8),
243                new ComponentClass(PlayerComponent.class, 1),
244                new ComponentClass(PlaySingleSoundComponent.class, 128),
245                new ComponentClass(PopOutComponent.class, 32),
246                new ComponentClass(RenderComponent.class, 384),
247                new ComponentClass(ScrollerComponent.class, 8),
248                new ComponentClass(SelectDialogComponent.class, 8),
249                new ComponentClass(SimpleCollisionComponent.class, 32),
250                new ComponentClass(SimplePhysicsComponent.class, 256),
251                new ComponentClass(SleeperComponent.class, 32),
252                new ComponentClass(SolidSurfaceComponent.class, 16),
253                new ComponentClass(SpriteComponent.class, 384),
254                new ComponentClass(TheSourceComponent.class, 1),
255
256        };
257
258        mComponentPools = new FixedSizeArray<GameComponentPool>(componentTypes.length, sComponentPoolComparator);
259        for (int x = 0; x < componentTypes.length; x++) {
260            ComponentClass component = componentTypes[x];
261            mComponentPools.add(new GameComponentPool(component.type, component.poolSize));
262        }
263        mComponentPools.sort(true);
264
265        mPoolSearchDummy = new GameComponentPool(Object.class, 1);
266
267    }
268
269    @Override
270    public void reset() {
271
272    }
273
274    protected GameComponentPool getComponentPool(Class<?> componentType) {
275        GameComponentPool pool = null;
276        mPoolSearchDummy.objectClass = componentType;
277        final int index = mComponentPools.find(mPoolSearchDummy, false);
278        if (index != -1) {
279            pool = mComponentPools.get(index);
280        }
281        return pool;
282    }
283
284    protected GameComponent allocateComponent(Class<?> componentType) {
285        GameComponentPool pool = getComponentPool(componentType);
286        assert pool != null;
287        GameComponent component = null;
288        if (pool != null) {
289            component = pool.allocate();
290        }
291        return component;
292    }
293
294    protected void releaseComponent(GameComponent component) {
295        GameComponentPool pool = getComponentPool(component.getClass());
296        assert pool != null;
297        if (pool != null) {
298            component.reset();
299            component.shared = false;
300            pool.release(component);
301        }
302    }
303
304    protected boolean componentAvailable(Class<?> componentType, int count) {
305    	boolean canAllocate = false;
306        GameComponentPool pool = getComponentPool(componentType);
307        assert pool != null;
308        if (pool != null) {
309        	canAllocate = pool.getAllocatedCount() + count < pool.getSize();
310        }
311        return canAllocate;
312    }
313
314    public void preloadEffects() {
315        // These textures appear in every level, so they are long-term.
316        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
317        textureLibrary.allocateTexture(R.drawable.dust01);
318        textureLibrary.allocateTexture(R.drawable.dust02);
319        textureLibrary.allocateTexture(R.drawable.dust03);
320        textureLibrary.allocateTexture(R.drawable.dust04);
321        textureLibrary.allocateTexture(R.drawable.dust05);
322
323        textureLibrary.allocateTexture(R.drawable.effect_energyball01);
324        textureLibrary.allocateTexture(R.drawable.effect_energyball02);
325        textureLibrary.allocateTexture(R.drawable.effect_energyball03);
326        textureLibrary.allocateTexture(R.drawable.effect_energyball04);
327
328        textureLibrary.allocateTexture(R.drawable.effect_explosion_small01);
329        textureLibrary.allocateTexture(R.drawable.effect_explosion_small02);
330        textureLibrary.allocateTexture(R.drawable.effect_explosion_small03);
331        textureLibrary.allocateTexture(R.drawable.effect_explosion_small04);
332        textureLibrary.allocateTexture(R.drawable.effect_explosion_small05);
333        textureLibrary.allocateTexture(R.drawable.effect_explosion_small06);
334        textureLibrary.allocateTexture(R.drawable.effect_explosion_small07);
335
336        textureLibrary.allocateTexture(R.drawable.effect_explosion_big01);
337        textureLibrary.allocateTexture(R.drawable.effect_explosion_big02);
338        textureLibrary.allocateTexture(R.drawable.effect_explosion_big03);
339        textureLibrary.allocateTexture(R.drawable.effect_explosion_big04);
340        textureLibrary.allocateTexture(R.drawable.effect_explosion_big05);
341        textureLibrary.allocateTexture(R.drawable.effect_explosion_big06);
342        textureLibrary.allocateTexture(R.drawable.effect_explosion_big07);
343        textureLibrary.allocateTexture(R.drawable.effect_explosion_big08);
344        textureLibrary.allocateTexture(R.drawable.effect_explosion_big09);
345
346        textureLibrary.allocateTexture(R.drawable.effect_smoke_big01);
347        textureLibrary.allocateTexture(R.drawable.effect_smoke_big02);
348        textureLibrary.allocateTexture(R.drawable.effect_smoke_big03);
349        textureLibrary.allocateTexture(R.drawable.effect_smoke_big04);
350        textureLibrary.allocateTexture(R.drawable.effect_smoke_big05);
351
352        textureLibrary.allocateTexture(R.drawable.effect_smoke_small01);
353        textureLibrary.allocateTexture(R.drawable.effect_smoke_small02);
354        textureLibrary.allocateTexture(R.drawable.effect_smoke_small03);
355        textureLibrary.allocateTexture(R.drawable.effect_smoke_small04);
356        textureLibrary.allocateTexture(R.drawable.effect_smoke_small05);
357
358        textureLibrary.allocateTexture(R.drawable.effect_crush_back01);
359        textureLibrary.allocateTexture(R.drawable.effect_crush_back02);
360        textureLibrary.allocateTexture(R.drawable.effect_crush_back03);
361        textureLibrary.allocateTexture(R.drawable.effect_crush_front01);
362        textureLibrary.allocateTexture(R.drawable.effect_crush_front02);
363        textureLibrary.allocateTexture(R.drawable.effect_crush_front03);
364        textureLibrary.allocateTexture(R.drawable.effect_crush_front04);
365        textureLibrary.allocateTexture(R.drawable.effect_crush_front05);
366        textureLibrary.allocateTexture(R.drawable.effect_crush_front06);
367        textureLibrary.allocateTexture(R.drawable.effect_crush_front07);
368    }
369
370    public void destroy(GameObject object) {
371        object.commitUpdates();
372        final int componentCount = object.getCount();
373        for (int x = 0; x < componentCount; x++) {
374            GameComponent component = (GameComponent)object.get(x);
375            if (!component.shared) {
376                releaseComponent(component);
377            }
378        }
379        object.removeAll();
380        object.commitUpdates();
381        mGameObjectPool.release(object);
382    }
383
384    public GameObject spawn(GameObjectType type, float x, float y, boolean horzFlip) {
385        GameObject newObject = null;
386        switch(type) {
387            case PLAYER:
388                newObject = spawnPlayer(x, y);
389                break;
390            case COIN:
391                newObject = spawnCoin(x, y);
392                break;
393            case RUBY:
394                newObject = spawnRuby(x, y);
395                break;
396            case DIARY:
397                newObject = spawnDiary(x, y);
398                break;
399            case WANDA:
400                newObject = spawnEnemyWanda(x, y, true);
401                break;
402            case KYLE:
403                newObject = spawnEnemyKyle(x, y, true);
404                break;
405            case KYLE_DEAD:
406                newObject = spawnEnemyKyleDead(x, y);
407                break;
408            case ANDOU_DEAD:
409                newObject = spawnEnemyAndouDead(x, y);
410                break;
411            case KABOCHA:
412                newObject = spawnEnemyKabocha(x, y, true);
413                break;
414            case ROKUDOU_TERMINAL:
415                newObject = spawnRokudouTerminal(x, y);
416                break;
417            case KABOCHA_TERMINAL:
418                newObject = spawnKabochaTerminal(x, y);
419                break;
420            case EVIL_KABOCHA:
421                newObject = spawnEnemyEvilKabocha(x, y, true);
422                break;
423            case ROKUDOU:
424                newObject = spawnEnemyRokudou(x, y, true);
425                break;
426            case BROBOT:
427                newObject = spawnEnemyBrobot(x, y, horzFlip);
428                break;
429            case SNAILBOMB:
430                newObject = spawnEnemySnailBomb(x, y, horzFlip);
431                break;
432            case SHADOWSLIME:
433                newObject = spawnEnemyShadowSlime(x, y, horzFlip);
434                break;
435            case MUDMAN:
436                newObject = spawnEnemyMudman(x, y, horzFlip);
437                break;
438            case SKELETON:
439                newObject = spawnEnemySkeleton(x, y, horzFlip);
440                break;
441            case KARAGUIN:
442                newObject = spawnEnemyKaraguin(x, y, horzFlip);
443                break;
444            case PINK_NAMAZU:
445                newObject = spawnEnemyPinkNamazu(x, y, horzFlip);
446                break;
447            case BAT:
448                newObject = spawnEnemyBat(x, y, horzFlip);
449                break;
450            case STING:
451                newObject = spawnEnemySting(x, y, horzFlip);
452                break;
453            case ONION:
454                newObject = spawnEnemyOnion(x, y, horzFlip);
455                break;
456            case TURRET:
457            case TURRET_LEFT:
458                newObject = spawnObjectTurret(x, y, (type == GameObjectType.TURRET_LEFT));
459                break;
460            case DOOR_RED:
461            case DOOR_RED_NONBLOCKING:
462                newObject = spawnObjectDoor(x, y, GameObjectType.DOOR_RED, (type == GameObjectType.DOOR_RED));
463                break;
464            case DOOR_BLUE:
465            case DOOR_BLUE_NONBLOCKING:
466                newObject = spawnObjectDoor(x, y, GameObjectType.DOOR_BLUE, (type == GameObjectType.DOOR_BLUE));
467                break;
468            case DOOR_GREEN:
469            case DOOR_GREEN_NONBLOCKING:
470                newObject = spawnObjectDoor(x, y, GameObjectType.DOOR_GREEN, (type == GameObjectType.DOOR_GREEN));
471                break;
472            case BUTTON_RED:
473                newObject = spawnObjectButton(x, y, GameObjectType.BUTTON_RED);
474                break;
475            case BUTTON_BLUE:
476                newObject = spawnObjectButton(x, y, GameObjectType.BUTTON_BLUE);
477                break;
478            case BUTTON_GREEN:
479                newObject = spawnObjectButton(x, y, GameObjectType.BUTTON_GREEN);
480                break;
481            case CANNON:
482                newObject = spawnObjectCannon(x, y);
483                break;
484            case BROBOT_SPAWNER:
485            case BROBOT_SPAWNER_LEFT:
486                newObject = spawnObjectBrobotSpawner(x, y, (type == GameObjectType.BROBOT_SPAWNER_LEFT));
487                break;
488            case BREAKABLE_BLOCK:
489                newObject = spawnObjectBreakableBlock(x, y);
490                break;
491            case THE_SOURCE:
492            	newObject = spawnObjectTheSource(x, y);
493            	break;
494            case HINT_SIGN:
495            	newObject = spawnObjectSign(x, y);
496            	break;
497            case DUST:
498                newObject = spawnDust(x, y, horzFlip);
499                break;
500            case EXPLOSION_SMALL:
501                newObject = spawnEffectExplosionSmall(x, y);
502                break;
503            case EXPLOSION_LARGE:
504                newObject = spawnEffectExplosionLarge(x, y);
505                break;
506            case EXPLOSION_GIANT:
507                newObject = spawnEffectExplosionGiant(x, y);
508                break;
509            case GHOST_NPC:
510            	newObject = spawnGhostNPC(x, y);
511            	break;
512            case CAMERA_BIAS:
513            	newObject = spawnCameraBias(x, y);
514            	break;
515            case FRAMERATE_WATCHER:
516            	newObject = spawnFrameRateWatcher(x, y);
517            	break;
518            case INFINITE_SPAWNER:
519            	newObject = spawnObjectInfiniteSpawner(x, y);
520            	break;
521            case CRUSHER_ANDOU:
522            	newObject = spawnObjectCrusherAndou(x,y);
523            	break;
524            case SMOKE_BIG:
525                newObject = spawnEffectSmokeBig(x, y);
526                break;
527            case SMOKE_SMALL:
528                newObject = spawnEffectSmokeSmall(x, y);
529                break;
530            case CRUSH_FLASH:
531                newObject = spawnEffectCrushFlash(x, y);
532                break;
533            case FLASH:
534                newObject = spawnEffectFlash(x, y);
535                break;
536
537            case ENERGY_BALL:
538                newObject = spawnEnergyBall(x, y, horzFlip);
539                break;
540            case CANNON_BALL:
541                newObject = spawnCannonBall(x, y, horzFlip);
542                break;
543            case TURRET_BULLET:
544                newObject = spawnTurretBullet(x, y, horzFlip);
545                break;
546            case BROBOT_BULLET:
547                newObject = spawnBrobotBullet(x, y, horzFlip);
548                break;
549            case BREAKABLE_BLOCK_PIECE:
550                newObject = spawnBreakableBlockPiece(x, y);
551                break;
552            case BREAKABLE_BLOCK_PIECE_SPAWNER:
553                newObject = spawnBreakableBlockPieceSpawner(x, y);
554                break;
555            case WANDA_SHOT:
556                newObject = spawnWandaShot(x, y, horzFlip);
557                break;
558            case SMOKE_POOF:
559            	newObject = spawnSmokePoof(x, y);
560            	break;
561            case GEM_EFFECT:
562            	newObject = spawnGemEffect(x, y);
563            	break;
564            case GEM_EFFECT_SPAWNER:
565            	newObject = spawnGemEffectSpawner(x, y);
566            	break;
567        }
568
569        return newObject;
570    }
571
572
573
574	public void spawnFromWorld(TiledWorld world, int tileWidth, int tileHeight) {
575        // Walk the world and spawn objects based on tile indexes.
576        final float worldHeight = world.getHeight() * tileHeight;
577        GameObjectManager manager = sSystemRegistry.gameObjectManager;
578        if (manager != null) {
579            for (int y = 0; y < world.getHeight(); y++) {
580                for (int x = 0; x < world.getWidth(); x++) {
581                    int index = world.getTile(x, y);
582                    if (index != -1) {
583                        GameObjectType type = GameObjectType.indexToType(index);
584                        if (type != GameObjectType.INVALID) {
585                            final float worldX = x * tileWidth;
586                            final float worldY = worldHeight - ((y + 1) * tileHeight);
587                            GameObject object = spawn(type, worldX, worldY, false);
588                            if (object != null) {
589                                if (object.height < tileHeight) {
590                                    // make sure small objects are vertically centered in their
591                                    // tile.
592                                    object.getPosition().y += (tileHeight - object.height) / 2.0f;
593                                }
594                                if (object.width < tileWidth) {
595                                    object.getPosition().x += (tileWidth - object.width) / 2.0f;
596                                } else if (object.width > tileWidth) {
597                                    object.getPosition().x -= (object.width - tileWidth) / 2.0f;
598                                }
599                                manager.add(object);
600                                if (type == GameObjectType.PLAYER) {
601                                    manager.setPlayer(object);
602                                }
603                            }
604                        }
605                    }
606                }
607            }
608        }
609    }
610
611
612    private FixedSizeArray<BaseObject> getStaticData(GameObjectType type) {
613        return mStaticData.get(type.ordinal());
614    }
615
616    private void setStaticData(GameObjectType type, FixedSizeArray<BaseObject> data) {
617        int index = type.ordinal();
618        assert mStaticData.get(index) == null;
619
620        final int staticDataCount = data.getCount();
621
622        for (int x = 0; x < staticDataCount; x++) {
623            BaseObject entry = data.get(x);
624            if (entry instanceof GameComponent) {
625                ((GameComponent) entry).shared = true;
626            }
627        }
628
629        mStaticData.set(index, data);
630    }
631
632    private void addStaticData(GameObjectType type, GameObject object, SpriteComponent sprite) {
633        FixedSizeArray<BaseObject> staticData = getStaticData(type);
634        assert staticData != null;
635
636        if (staticData != null) {
637            final int staticDataCount = staticData.getCount();
638
639            for (int x = 0; x < staticDataCount; x++) {
640                BaseObject entry = staticData.get(x);
641                if (entry instanceof GameComponent && object != null) {
642                    object.add((GameComponent)entry);
643                } else if (entry instanceof SpriteAnimation && sprite != null) {
644                    sprite.addAnimation((SpriteAnimation)entry);
645                }
646            }
647        }
648    }
649
650    public void clearStaticData() {
651        final int typeCount = mStaticData.getCount();
652        for (int x = 0; x < typeCount; x++) {
653            FixedSizeArray<BaseObject> staticData = mStaticData.get(x);
654            if (staticData != null) {
655                final int count = staticData.getCount();
656                for (int y = 0; y < count; y++) {
657                    BaseObject entry = staticData.get(y);
658                    if (entry != null) {
659                        if (entry instanceof GameComponent) {
660                            releaseComponent((GameComponent)entry);
661                        }
662                    }
663                }
664                staticData.clear();
665                mStaticData.set(x, null);
666            }
667        }
668    }
669
670    public void sanityCheckPools() {
671        final int outstandingObjects = mGameObjectPool.getAllocatedCount();
672        if (outstandingObjects != 0) {
673            DebugLog.d("Sanity Check", "Outstanding game object allocations! ("
674                    + outstandingObjects + ")");
675            assert false;
676        }
677
678        final int componentPoolCount = mComponentPools.getCount();
679        for (int x = 0; x < componentPoolCount; x++) {
680            final int outstandingComponents = mComponentPools.get(x).getAllocatedCount();
681
682            if (outstandingComponents != 0) {
683                DebugLog.d("Sanity Check", "Outstanding "
684                        + mComponentPools.get(x).objectClass.getSimpleName()
685                        + " allocations! (" + outstandingComponents + ")");
686                //assert false;
687            }
688        }
689    }
690
691    public GameObject spawnPlayer(float positionX, float positionY) {
692        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
693
694        GameObject object = mGameObjectPool.allocate();
695        object.getPosition().set(positionX, positionY);
696        object.activationRadius = mAlwaysActive;
697        object.width = 64;
698        object.height = 64;
699
700        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.PLAYER);
701
702        if (staticData == null) {
703            final int staticObjectCount = 13;
704            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
705
706            GameComponent gravity = allocateComponent(GravityComponent.class);
707            GameComponent movement = allocateComponent(MovementComponent.class);
708            PhysicsComponent physics = (PhysicsComponent)allocateComponent(PhysicsComponent.class);
709
710            physics.setMass(9.1f);   // ~90kg w/ earth gravity
711            physics.setDynamicFrictionCoeffecient(0.2f);
712            physics.setStaticFrictionCoeffecient(0.01f);
713
714            // Animation Data
715            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
716                new FixedSizeArray<CollisionVolume>(1);
717            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 32));
718
719            FixedSizeArray<CollisionVolume> pressAndCollectVolume =
720                new FixedSizeArray<CollisionVolume>(2);
721            AABoxCollisionVolume collectionVolume = new AABoxCollisionVolume(16, 0, 32, 48);
722            collectionVolume.setHitType(HitType.COLLECT);
723            pressAndCollectVolume.add(collectionVolume);
724            AABoxCollisionVolume pressCollisionVolume = new AABoxCollisionVolume(16, 0, 32, 16);
725            pressCollisionVolume.setHitType(HitType.DEPRESS);
726            pressAndCollectVolume.add(pressCollisionVolume);
727
728            SpriteAnimation idle = new SpriteAnimation(PlayerAnimations.IDLE.ordinal(), 1);
729            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stand),
730                    1.0f, pressAndCollectVolume, basicVulnerabilityVolume));
731
732            SpriteAnimation angle = new SpriteAnimation(PlayerAnimations.MOVE.ordinal(), 1);
733            angle.addFrame(
734                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_diag01),
735                            0.0416f, pressAndCollectVolume, basicVulnerabilityVolume));
736
737            SpriteAnimation extremeAngle = new SpriteAnimation(
738                    PlayerAnimations.MOVE_FAST.ordinal(), 1);
739            extremeAngle.addFrame(
740                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_diagmore01),
741                            0.0416f, pressAndCollectVolume, basicVulnerabilityVolume));
742
743            SpriteAnimation up = new SpriteAnimation(PlayerAnimations.BOOST_UP.ordinal(), 2);
744            up.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_flyup02),
745                    Utils.framesToTime(24, 1), pressAndCollectVolume, basicVulnerabilityVolume));
746            up.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_flyup03),
747                    Utils.framesToTime(24, 1), pressAndCollectVolume, basicVulnerabilityVolume));
748            up.setLoop(true);
749
750            SpriteAnimation boostAngle = new SpriteAnimation(PlayerAnimations.BOOST_MOVE.ordinal(), 2);
751            boostAngle.addFrame(
752                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_diag02),
753                            Utils.framesToTime(24, 1), pressAndCollectVolume, basicVulnerabilityVolume));
754            boostAngle.addFrame(
755                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_diag03),
756                            Utils.framesToTime(24, 1), pressAndCollectVolume, basicVulnerabilityVolume));
757            boostAngle.setLoop(true);
758
759            SpriteAnimation boostExtremeAngle = new SpriteAnimation(
760                    PlayerAnimations.BOOST_MOVE_FAST.ordinal(), 2);
761            boostExtremeAngle.addFrame(
762                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_diagmore02),
763                            Utils.framesToTime(24, 1), pressAndCollectVolume, basicVulnerabilityVolume));
764            boostExtremeAngle.addFrame(
765                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_diagmore03),
766                            Utils.framesToTime(24, 1), pressAndCollectVolume, basicVulnerabilityVolume));
767            boostExtremeAngle.setLoop(true);
768
769            FixedSizeArray<CollisionVolume> stompAttackVolume =
770                new FixedSizeArray<CollisionVolume>(3);
771            stompAttackVolume.add(new AABoxCollisionVolume(16, -5.0f, 32, 37, HitType.HIT));
772            stompAttackVolume.add(pressCollisionVolume);
773            stompAttackVolume.add(collectionVolume);
774
775            SpriteAnimation stomp = new SpriteAnimation(PlayerAnimations.STOMP.ordinal(), 4);
776            stomp.addFrame(
777                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp01),
778                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
779            stomp.addFrame(
780                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp02),
781                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
782            stomp.addFrame(
783                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp03),
784                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
785            stomp.addFrame(
786                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp04),
787                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
788
789            SpriteAnimation hitReactAnim = new SpriteAnimation(PlayerAnimations.HIT_REACT.ordinal(), 1);
790            hitReactAnim.addFrame(
791                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_hit),
792                            0.1f, pressAndCollectVolume, null));
793
794            SpriteAnimation deathAnim = new SpriteAnimation(PlayerAnimations.DEATH.ordinal(), 16);
795            AnimationFrame death1 =
796                new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_die01),
797                        Utils.framesToTime(24, 1), null, null);
798            AnimationFrame death2 =
799                new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_die02),
800                        Utils.framesToTime(24, 1), null, null);
801            deathAnim.addFrame(death1);
802            deathAnim.addFrame(death2);
803            deathAnim.addFrame(death1);
804            deathAnim.addFrame(death2);
805            deathAnim.addFrame(
806                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode01),
807                            Utils.framesToTime(24, 1), null, null));
808            deathAnim.addFrame(
809                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode02),
810                            Utils.framesToTime(24, 1), null, null));
811            deathAnim.addFrame(
812                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode03),
813                            Utils.framesToTime(24, 1), null, null));
814            deathAnim.addFrame(
815                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode04),
816                            Utils.framesToTime(24, 1), null, null));
817            deathAnim.addFrame(
818                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode05),
819                            Utils.framesToTime(24, 2), null, null));
820            deathAnim.addFrame(
821                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode06),
822                            Utils.framesToTime(24, 2), null, null));
823            deathAnim.addFrame(
824                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode07),
825                            Utils.framesToTime(24, 2), null, null));
826            deathAnim.addFrame(
827                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode08),
828                            Utils.framesToTime(24, 2), null, null));
829            deathAnim.addFrame(
830                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode09),
831                            Utils.framesToTime(24, 2), null, null));
832            deathAnim.addFrame(
833                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode10),
834                            Utils.framesToTime(24, 2), null, null));
835            deathAnim.addFrame(
836                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode11),
837                            Utils.framesToTime(24, 2), null, null));
838            deathAnim.addFrame(
839                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode12),
840                            Utils.framesToTime(24, 2), null, null));
841
842
843            SpriteAnimation frozenAnim = new SpriteAnimation(PlayerAnimations.FROZEN.ordinal(), 1);
844            // Frozen has no frames!
845
846
847            // Save static data
848            staticData.add(gravity);
849            staticData.add(movement);
850            staticData.add(physics);
851
852
853            staticData.add(idle);
854            staticData.add(angle);
855            staticData.add(extremeAngle);
856            staticData.add(up);
857            staticData.add(boostAngle);
858            staticData.add(boostExtremeAngle);
859            staticData.add(stomp);
860            staticData.add(hitReactAnim);
861            staticData.add(deathAnim);
862            staticData.add(frozenAnim);
863
864            setStaticData(GameObjectType.PLAYER, staticData);
865        }
866
867
868        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
869        render.setPriority(SortConstants.PLAYER);
870        BackgroundCollisionComponent bgcollision
871            = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
872        bgcollision.setSize(32, 48);
873        bgcollision.setOffset(16, 0);
874        PlayerComponent player = (PlayerComponent)allocateComponent(PlayerComponent.class);
875        AnimationComponent animation =
876            (AnimationComponent)allocateComponent(AnimationComponent.class);
877
878        animation.setPlayer(player);
879        SoundSystem sound = sSystemRegistry.soundSystem;
880        if (sound != null) {
881            animation.setLandThump(sound.load(R.raw.thump));
882            animation.setRocketSound(sound.load(R.raw.rockets));
883            animation.setRubySounds(sound.load(R.raw.gem1), sound.load(R.raw.gem2), sound.load(R.raw.gem3));
884            animation.setExplosionSound(sound.load(R.raw.sound_explode));
885        }
886
887
888        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
889        sprite.setSize((int)object.width, (int)object.height);
890        sprite.setRenderComponent(render);
891        animation.setSprite(sprite);
892
893
894
895        DynamicCollisionComponent dynamicCollision
896            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
897        sprite.setCollisionComponent(dynamicCollision);
898
899        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
900        hitReact.setBounceOnHit(true);
901        hitReact.setPauseOnAttack(true);
902        hitReact.setInvincibleTime(3.0f);
903        hitReact.setSpawnOnDealHit(HitType.HIT, GameObjectType.CRUSH_FLASH, false, true);
904
905        if (sound != null) {
906            hitReact.setTakeHitSound(HitType.HIT, sound.load(R.raw.deep_clang));
907        }
908
909        dynamicCollision.setHitReactionComponent(hitReact);
910
911        player.setHitReactionComponent(hitReact);
912
913        InventoryComponent inventory = (InventoryComponent)allocateComponent(InventoryComponent.class);
914
915        player.setInventory(inventory);
916        animation.setInventory(inventory);
917
918        ChangeComponentsComponent damageSwap = (ChangeComponentsComponent)allocateComponent(ChangeComponentsComponent.class);
919        animation.setDamageSwap(damageSwap);
920
921        LaunchProjectileComponent smokeGun
922            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
923        smokeGun.setDelayBetweenShots(0.25f);
924        smokeGun.setObjectTypeToSpawn(GameObjectType.SMOKE_BIG);
925        smokeGun.setOffsetX(32);
926        smokeGun.setOffsetY(15);
927        smokeGun.setVelocityX(-150.0f);
928        smokeGun.setVelocityY(100.0f);
929        smokeGun.setThetaError(0.1f);
930
931        LaunchProjectileComponent smokeGun2
932            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
933        smokeGun2.setDelayBetweenShots(0.35f);
934        smokeGun2.setObjectTypeToSpawn(GameObjectType.SMOKE_SMALL);
935        smokeGun2.setOffsetX(16);
936        smokeGun2.setOffsetY(15);
937        smokeGun2.setVelocityX(-150.0f);
938        smokeGun2.setVelocityY(150.0f);
939        smokeGun2.setThetaError(0.1f);
940
941        damageSwap.addSwapInComponent(smokeGun);
942        damageSwap.addSwapInComponent(smokeGun2);
943        damageSwap.setPingPongBehavior(true);
944
945        ChangeComponentsComponent invincibleSwap = (ChangeComponentsComponent)allocateComponent(ChangeComponentsComponent.class);
946        invincibleSwap.setPingPongBehavior(true);
947        player.setInvincibleSwap(invincibleSwap);
948
949        object.life = PlayerComponent.getDifficultyConstants().getMaxPlayerLife();
950        object.team = Team.PLAYER;
951
952        // Very very basic DDA.  Make the game easier if we've died on this level too much.
953        LevelSystem level = sSystemRegistry.levelSystem;
954        if (level != null) {
955        	player.adjustDifficulty(object, level.getAttemptsCount());
956        }
957
958
959        object.add(player);
960        object.add(inventory);
961        object.add(bgcollision);
962        object.add(render);
963        object.add(animation);
964        object.add(sprite);
965        object.add(dynamicCollision);
966        object.add(hitReact);
967        object.add(damageSwap);
968        object.add(invincibleSwap);
969
970        addStaticData(GameObjectType.PLAYER, object, sprite);
971
972
973
974        sprite.playAnimation(PlayerAnimations.IDLE.ordinal());
975
976
977        // Jets
978        {
979            FixedSizeArray<BaseObject> jetStaticData = getStaticData(GameObjectType.PLAYER_JETS);
980            if (jetStaticData == null) {
981                jetStaticData = new FixedSizeArray<BaseObject>(1);
982
983                SpriteAnimation jetAnim = new SpriteAnimation(0, 2);
984                jetAnim.addFrame(
985                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.jetfire01),
986                                Utils.framesToTime(24, 1)));
987                jetAnim.addFrame(
988                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.jetfire02),
989                                Utils.framesToTime(24, 1)));
990                jetAnim.setLoop(true);
991
992                jetStaticData.add(jetAnim);
993
994                setStaticData(GameObjectType.PLAYER_JETS, jetStaticData);
995            }
996
997            RenderComponent jetRender = (RenderComponent)allocateComponent(RenderComponent.class);
998            jetRender.setPriority(SortConstants.PLAYER - 1);
999            jetRender.setDrawOffset(0.0f, -16.0f);
1000            SpriteComponent jetSprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1001            jetSprite.setSize(64, 64);
1002            jetSprite.setRenderComponent(jetRender);
1003
1004            object.add(jetRender);
1005            object.add(jetSprite);
1006
1007            addStaticData(GameObjectType.PLAYER_JETS, object, jetSprite);
1008
1009            jetSprite.playAnimation(0);
1010
1011            animation.setJetSprite(jetSprite);
1012        }
1013        // Sparks
1014        {
1015            FixedSizeArray<BaseObject> sparksStaticData = getStaticData(GameObjectType.PLAYER_SPARKS);
1016
1017            if (sparksStaticData == null) {
1018                sparksStaticData = new FixedSizeArray<BaseObject>(1);
1019
1020                SpriteAnimation sparksAnim = new SpriteAnimation(0, 3);
1021                sparksAnim.addFrame(
1022                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.spark01),
1023                                Utils.framesToTime(24, 1)));
1024                sparksAnim.addFrame(
1025                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.spark02),
1026                                Utils.framesToTime(24, 1)));
1027                sparksAnim.addFrame(
1028                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.spark03),
1029                                Utils.framesToTime(24, 1)));
1030                sparksAnim.setLoop(true);
1031
1032                sparksStaticData.add(sparksAnim);
1033
1034                setStaticData(GameObjectType.PLAYER_SPARKS, sparksStaticData);
1035            }
1036
1037            RenderComponent sparksRender = (RenderComponent)allocateComponent(RenderComponent.class);
1038            sparksRender.setPriority(SortConstants.PLAYER + 1);
1039            SpriteComponent sparksSprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1040            sparksSprite.setSize(64, 64);
1041            sparksSprite.setRenderComponent(sparksRender);
1042
1043            object.add(sparksRender);
1044            object.add(sparksSprite);
1045
1046            addStaticData(GameObjectType.PLAYER_SPARKS, object, sparksSprite);
1047
1048            sparksSprite.playAnimation(0);
1049
1050            animation.setSparksSprite(sparksSprite);
1051        }
1052
1053        // Glow
1054        {
1055            FixedSizeArray<BaseObject> glowStaticData = getStaticData(GameObjectType.PLAYER_GLOW);
1056            if (glowStaticData == null) {
1057                glowStaticData = new FixedSizeArray<BaseObject>(1);
1058
1059                FixedSizeArray<CollisionVolume> glowAttackVolume =
1060                    new FixedSizeArray<CollisionVolume>(1);
1061                glowAttackVolume.add(new SphereCollisionVolume(40, 40, 40, HitType.HIT));
1062
1063                SpriteAnimation glowAnim = new SpriteAnimation(0, 3);
1064                glowAnim.addFrame(
1065                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.effect_glow01),
1066                                Utils.framesToTime(24, 1), glowAttackVolume, null));
1067                glowAnim.addFrame(
1068                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.effect_glow02),
1069                                Utils.framesToTime(24, 1), glowAttackVolume, null));
1070                glowAnim.addFrame(
1071                        new AnimationFrame(textureLibrary.allocateTexture(R.drawable.effect_glow03),
1072                                Utils.framesToTime(24, 1), glowAttackVolume, null));
1073                glowAnim.setLoop(true);
1074
1075                glowStaticData.add(glowAnim);
1076
1077                setStaticData(GameObjectType.PLAYER_GLOW, glowStaticData);
1078            }
1079
1080            RenderComponent glowRender = (RenderComponent)allocateComponent(RenderComponent.class);
1081            glowRender.setPriority(SortConstants.PLAYER + 1);
1082            glowRender.setDrawOffset(0, -5.0f);
1083            SpriteComponent glowSprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1084            glowSprite.setSize(64, 64);
1085            glowSprite.setRenderComponent(glowRender);
1086
1087            DynamicCollisionComponent glowCollision
1088                = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
1089            glowSprite.setCollisionComponent(glowCollision);
1090
1091            FadeDrawableComponent glowFade = (FadeDrawableComponent)allocateComponent(FadeDrawableComponent.class);
1092            final float glowDuration = PlayerComponent.getDifficultyConstants().getGlowDuration();
1093            glowFade.setupFade(1.0f, 0.0f, 0.15f,
1094            		FadeDrawableComponent.LOOP_TYPE_PING_PONG,
1095            		FadeDrawableComponent.FADE_EASE,
1096            		glowDuration - 4.0f);	// 4 seconds before the glow ends, start flashing
1097            glowFade.setPhaseDuration(glowDuration);
1098            glowFade.setRenderComponent(glowRender);
1099
1100            // HACK
1101            player.setInvincibleFader(glowFade);
1102
1103            invincibleSwap.addSwapInComponent(glowRender);
1104            invincibleSwap.addSwapInComponent(glowSprite);
1105            invincibleSwap.addSwapInComponent(glowCollision);
1106            invincibleSwap.addSwapInComponent(glowFade);
1107
1108            addStaticData(GameObjectType.PLAYER_GLOW, object, glowSprite);
1109
1110            glowSprite.playAnimation(0);
1111
1112        }
1113
1114        CameraSystem camera = sSystemRegistry.cameraSystem;
1115        if (camera != null) {
1116            camera.setTarget(object);
1117        }
1118
1119        return object;
1120    }
1121
1122
1123    // Sparks are used by more than one enemy type, so the setup for them is abstracted.
1124    private void setupEnemySparks() {
1125        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.ENEMY_SPARKS);
1126        if (staticData == null) {
1127            staticData = new FixedSizeArray<BaseObject>(1);
1128            TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
1129
1130            SpriteAnimation sparksAnim = new SpriteAnimation(0, 13);
1131            AnimationFrame frame1 =
1132                new AnimationFrame(textureLibrary.allocateTexture(R.drawable.spark01),
1133                        Utils.framesToTime(24, 1));
1134            AnimationFrame frame2 =
1135                new AnimationFrame(textureLibrary.allocateTexture(R.drawable.spark02),
1136                        Utils.framesToTime(24, 1));
1137            AnimationFrame frame3 =
1138                new AnimationFrame(textureLibrary.allocateTexture(R.drawable.spark03),
1139                        Utils.framesToTime(24, 1));
1140            sparksAnim.addFrame(frame1);
1141            sparksAnim.addFrame(frame2);
1142            sparksAnim.addFrame(frame3);
1143            sparksAnim.addFrame(frame1);
1144            sparksAnim.addFrame(frame2);
1145            sparksAnim.addFrame(frame3);
1146            sparksAnim.addFrame(frame1);
1147            sparksAnim.addFrame(frame2);
1148            sparksAnim.addFrame(frame3);
1149            sparksAnim.addFrame(frame1);
1150            sparksAnim.addFrame(frame2);
1151            sparksAnim.addFrame(frame3);
1152            sparksAnim.addFrame(new AnimationFrame(null, 3.0f));
1153            sparksAnim.setLoop(true);
1154
1155            staticData.add(sparksAnim);
1156            setStaticData(GameObjectType.ENEMY_SPARKS, staticData);
1157        }
1158
1159    }
1160
1161    public GameObject spawnEnemyBrobot(float positionX, float positionY, boolean flipHorizontal) {
1162        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
1163
1164
1165        GameObject object = mGameObjectPool.allocate();
1166        object.getPosition().set(positionX, positionY);
1167        object.activationRadius = mNormalActivationRadius;
1168        object.width = 64;
1169        object.height = 64;
1170
1171        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.BROBOT);
1172        if (staticData == null) {
1173            final int staticObjectCount = 5;
1174            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
1175
1176            GameComponent gravity = allocateComponent(GravityComponent.class);
1177            GameComponent movement = allocateComponent(MovementComponent.class);
1178            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
1179            physics.setBounciness(0.4f);
1180
1181
1182            // Animations
1183            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
1184                new FixedSizeArray<CollisionVolume>(1);
1185            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 32));
1186
1187            FixedSizeArray<CollisionVolume> basicAttackVolume =
1188                new FixedSizeArray<CollisionVolume>(2);
1189            basicAttackVolume.add(new SphereCollisionVolume(16, 32, 32, HitType.HIT));
1190            basicAttackVolume.add(new AABoxCollisionVolume(16, 0, 32, 16, HitType.DEPRESS));
1191
1192            SpriteAnimation idle = new SpriteAnimation(EnemyAnimations.IDLE.ordinal(), 4);
1193            idle.addFrame(new AnimationFrame(
1194                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_idle01),
1195                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume));
1196            idle.addFrame(new AnimationFrame(
1197                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_idle02),
1198                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
1199            idle.addFrame(new AnimationFrame(
1200                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_idle03),
1201                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume));
1202            idle.addFrame(new AnimationFrame(
1203                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_idle02),
1204                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume));
1205
1206            idle.setLoop(true);
1207
1208            SpriteAnimation walk = new SpriteAnimation(EnemyAnimations.MOVE.ordinal(), 3);
1209            walk.addFrame(new AnimationFrame(
1210                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk01),
1211                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
1212            walk.addFrame(new AnimationFrame(
1213                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk02),
1214                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
1215            walk.addFrame(new AnimationFrame(
1216                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk03),
1217                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
1218            walk.setLoop(true);
1219
1220            staticData.add(gravity);
1221            staticData.add(movement);
1222            staticData.add(physics);
1223            staticData.add(idle);
1224            staticData.add(walk);
1225
1226            setStaticData(GameObjectType.BROBOT, staticData);
1227
1228        }
1229        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
1230        render.setPriority(SortConstants.GENERAL_ENEMY);
1231        BackgroundCollisionComponent bgcollision
1232            = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
1233        bgcollision.setSize(32, 48);
1234        bgcollision.setOffset(16, 0);
1235
1236        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1237        sprite.setSize((int)object.width, (int)object.height);
1238        sprite.setRenderComponent(render);
1239
1240        EnemyAnimationComponent animation
1241            = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
1242        animation.setSprite(sprite);
1243
1244        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
1245        patrol.setMovementSpeed(50.0f, 1000.0f);
1246
1247        DynamicCollisionComponent collision
1248            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
1249        sprite.setCollisionComponent(collision);
1250
1251        HitReactionComponent hitReact
1252            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
1253        collision.setHitReactionComponent(hitReact);
1254
1255
1256        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
1257        lifetime.setObjectToSpawnOnDeath(GameObjectType.EXPLOSION_GIANT);
1258        lifetime.setVulnerableToDeathTiles(true);
1259        lifetime.setIncrementEventCounter(EventRecorder.COUNTER_ROBOTS_DESTROYED);
1260
1261        GhostComponent ghost = (GhostComponent)allocateComponent(GhostComponent.class);
1262        ghost.setMovementSpeed(500.0f);
1263        ghost.setAcceleration(1000.0f);
1264        ghost.setJumpImpulse(300.0f);
1265        ghost.setKillOnRelease(true);
1266        ghost.setDelayOnRelease(1.5f);
1267
1268        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
1269        if (sound != null) {
1270        	ghost.setAmbientSound(sound.load(R.raw.sound_possession));
1271        }
1272
1273        ChangeComponentsComponent ghostSwap
1274            = (ChangeComponentsComponent)allocateComponent(ChangeComponentsComponent.class);
1275        ghostSwap.addSwapInComponent(ghost);
1276        ghostSwap.addSwapOutComponent(patrol);
1277
1278        SimplePhysicsComponent ghostPhysics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
1279        ghostPhysics.setBounciness(0.0f);
1280
1281        object.add(render);
1282        object.add(sprite);
1283
1284        object.add(bgcollision);
1285        object.add(animation);
1286        object.add(patrol);
1287        object.add(collision);
1288        object.add(hitReact);
1289        object.add(lifetime);
1290        object.add(ghostSwap);
1291
1292        object.team = Team.ENEMY;
1293
1294        if (flipHorizontal) {
1295            object.facingDirection.x = -1.0f;
1296        }
1297
1298        addStaticData(GameObjectType.BROBOT, object, sprite);
1299
1300        object.commitUpdates();
1301
1302        SimplePhysicsComponent normalPhysics = object.findByClass(SimplePhysicsComponent.class);
1303        if (normalPhysics != null) {
1304            ghostSwap.addSwapOutComponent(normalPhysics);
1305        }
1306
1307        ghostSwap.addSwapInComponent(ghostPhysics);
1308
1309        sprite.playAnimation(0);
1310
1311        // Sparks
1312        setupEnemySparks();
1313
1314        RenderComponent sparksRender = (RenderComponent)allocateComponent(RenderComponent.class);
1315        sparksRender.setPriority(render.getPriority() + 1);
1316        SpriteComponent sparksSprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1317        sparksSprite.setSize(64, 64);
1318        sparksSprite.setRenderComponent(sparksRender);
1319
1320        addStaticData(GameObjectType.ENEMY_SPARKS, object, sparksSprite);
1321
1322        sparksSprite.playAnimation(0);
1323
1324        ghostSwap.addSwapInComponent(sparksSprite);
1325        ghostSwap.addSwapInComponent(sparksRender);
1326
1327
1328        hitReact.setPossessionComponent(ghostSwap);
1329
1330        return object;
1331    }
1332
1333    public GameObject spawnEnemySnailBomb(float positionX, float positionY, boolean flipHorizontal) {
1334
1335        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
1336
1337
1338        // Make sure related textures are loaded.
1339        textureLibrary.allocateTexture(R.drawable.snail_bomb);
1340
1341        GameObject object = mGameObjectPool.allocate();
1342        object.getPosition().set(positionX, positionY);
1343        object.activationRadius = mNormalActivationRadius;
1344        object.width = 64;
1345        object.height = 64;
1346
1347        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.SNAILBOMB);
1348        if (staticData == null) {
1349            final int staticObjectCount = 6;
1350            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
1351
1352            GameComponent gravity = allocateComponent(GravityComponent.class);
1353            GameComponent movement = allocateComponent(MovementComponent.class);
1354            GameComponent physics = allocateComponent(SimplePhysicsComponent.class);
1355
1356            // Animations
1357            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
1358                new FixedSizeArray<CollisionVolume>(1);
1359            basicVulnerabilityVolume.add(new AABoxCollisionVolume(12, 5, 42, 27, HitType.HIT));
1360
1361            FixedSizeArray<CollisionVolume> basicAttackVolume =
1362                new FixedSizeArray<CollisionVolume>(1);
1363            basicAttackVolume.add(new AABoxCollisionVolume(12, 5, 42, 27, HitType.HIT));
1364
1365            SpriteAnimation idle = new SpriteAnimation(EnemyAnimations.IDLE.ordinal(), 1);
1366            idle.addFrame(new AnimationFrame(
1367                    textureLibrary.allocateTexture(R.drawable.snailbomb_stand),
1368                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume));
1369
1370            SpriteAnimation walk = new SpriteAnimation(EnemyAnimations.MOVE.ordinal(), 5);
1371            walk.addFrame(new AnimationFrame(
1372                    textureLibrary.allocateTexture(R.drawable.snailbomb_stand),
1373                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume));
1374            walk.addFrame(new AnimationFrame(
1375                        textureLibrary.allocateTexture(R.drawable.snailbomb_walk01),
1376                        Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume));
1377            walk.addFrame(new AnimationFrame(
1378                    textureLibrary.allocateTexture(R.drawable.snailbomb_walk02),
1379                    Utils.framesToTime(24, 6), basicAttackVolume, basicVulnerabilityVolume));
1380            walk.addFrame(new AnimationFrame(
1381                    textureLibrary.allocateTexture(R.drawable.snailbomb_walk01),
1382                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume));
1383            walk.addFrame(new AnimationFrame(
1384                    textureLibrary.allocateTexture(R.drawable.snailbomb_stand),
1385                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume));
1386            walk.setLoop(true);
1387
1388            SpriteAnimation attack = new SpriteAnimation(EnemyAnimations.ATTACK.ordinal(), 2);
1389            attack.addFrame(new AnimationFrame(
1390                    textureLibrary.allocateTexture(R.drawable.snailbomb_shoot01),
1391                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume));
1392            attack.addFrame(new AnimationFrame(
1393                    textureLibrary.allocateTexture(R.drawable.snailbomb_shoot02),
1394                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume));
1395
1396            staticData.add(gravity);
1397            staticData.add(movement);
1398            staticData.add(physics);
1399            staticData.add(idle);
1400            staticData.add(walk);
1401            staticData.add(attack);
1402
1403
1404            setStaticData(GameObjectType.SNAILBOMB, staticData);
1405        }
1406
1407        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
1408        render.setPriority(SortConstants.GENERAL_ENEMY);
1409        BackgroundCollisionComponent bgcollision
1410            = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
1411        bgcollision.setSize(32, 48);
1412        bgcollision.setOffset(16, 5);
1413
1414        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1415        sprite.setSize((int)object.width, (int)object.height);
1416        sprite.setRenderComponent(render);
1417
1418        EnemyAnimationComponent animation
1419            = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
1420        animation.setSprite(sprite);
1421
1422        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
1423        patrol.setMovementSpeed(20.0f, 1000.0f);
1424        patrol.setupAttack(300, 1.0f, 4.0f, true);
1425
1426        DynamicCollisionComponent collision
1427            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
1428        sprite.setCollisionComponent(collision);
1429
1430        HitReactionComponent hitReact
1431            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
1432        collision.setHitReactionComponent(hitReact);
1433
1434        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
1435        lifetime.setVulnerableToDeathTiles(true);
1436        lifetime.setObjectToSpawnOnDeath(GameObjectType.SMOKE_POOF);
1437        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
1438        if (sound != null) {
1439        	lifetime.setDeathSound(sound.load(R.raw.sound_stomp));
1440        }
1441
1442        LaunchProjectileComponent gun
1443            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
1444        gun.setSetsPerActivation(1);
1445        gun.setShotsPerSet(3);
1446        gun.setDelayBeforeFirstSet(1.0f);
1447        gun.setDelayBetweenShots(0.25f);
1448        gun.setObjectTypeToSpawn(GameObjectType.CANNON_BALL);
1449        gun.setOffsetX(55);
1450        gun.setOffsetY(21);
1451        gun.setRequiredAction(GameObject.ActionType.ATTACK);
1452        gun.setVelocityX(100.0f);
1453
1454        object.team = Team.ENEMY;
1455
1456        if (flipHorizontal) {
1457            object.facingDirection.x = -1.0f;
1458        }
1459
1460        object.add(render);
1461        object.add(sprite);
1462        object.add(bgcollision);
1463        object.add(animation);
1464        object.add(patrol);
1465        object.add(collision);
1466        object.add(hitReact);
1467        object.add(lifetime);
1468        object.add(gun);
1469
1470        addStaticData(GameObjectType.SNAILBOMB, object, sprite);
1471
1472        final SpriteAnimation attack = sprite.findAnimation(EnemyAnimations.ATTACK.ordinal());
1473        if (attack != null) {
1474            gun.setDelayBeforeFirstSet(attack.getLength());
1475        }
1476
1477        sprite.playAnimation(0);
1478
1479        return object;
1480    }
1481
1482    public GameObject spawnEnemyShadowSlime(float positionX, float positionY, boolean flipHorizontal) {
1483
1484        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
1485
1486
1487        // Make sure related textures are loaded.
1488        textureLibrary.allocateTexture(R.drawable.energy_ball01);
1489        textureLibrary.allocateTexture(R.drawable.energy_ball02);
1490        textureLibrary.allocateTexture(R.drawable.energy_ball03);
1491        textureLibrary.allocateTexture(R.drawable.energy_ball04);
1492
1493        GameObject object = mGameObjectPool.allocate();
1494        object.getPosition().set(positionX, positionY);
1495        object.activationRadius = mTightActivationRadius;
1496        object.width = 64;
1497        object.height = 64;
1498
1499        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.SHADOWSLIME);
1500        if (staticData == null) {
1501            final int staticObjectCount = 5;
1502            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
1503
1504            PopOutComponent popOut = (PopOutComponent)allocateComponent(PopOutComponent.class);
1505            // edit: these guys turned out to be really annoying, so I'm changing the values
1506            // here to force them to always be out.
1507            popOut.setAppearDistance(2000);
1508            popOut.setHideDistance(4000);
1509
1510            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume = new FixedSizeArray<CollisionVolume>(1);
1511            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 32));
1512            basicVulnerabilityVolume.get(0).setHitType(HitType.HIT);
1513
1514            FixedSizeArray<CollisionVolume> basicAttackVolume = new FixedSizeArray<CollisionVolume>(1);
1515            basicAttackVolume.add(new SphereCollisionVolume(16, 32, 32, HitType.HIT));
1516
1517            SpriteAnimation idle = new SpriteAnimation(EnemyAnimations.IDLE.ordinal(), 2);
1518            AnimationFrame idle1 = new AnimationFrame(
1519                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_idle01),
1520                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume);
1521            AnimationFrame idle2 = new AnimationFrame(
1522                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_idle02),
1523                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume);
1524            idle.addFrame(idle1);
1525            idle.addFrame(idle2);
1526            idle.setLoop(true);
1527
1528
1529            SpriteAnimation appear = new SpriteAnimation(EnemyAnimations.APPEAR.ordinal(), 6);
1530            AnimationFrame appear1 = new AnimationFrame(
1531                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_activate01),
1532                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume);
1533
1534            AnimationFrame appear2 = new AnimationFrame(
1535                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_activate02),
1536                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume);
1537            AnimationFrame appear3 = new AnimationFrame(
1538                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_activate03),
1539                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume);
1540            AnimationFrame appear4 = new AnimationFrame(
1541                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_activate04),
1542                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume);
1543            AnimationFrame appear5 = new AnimationFrame(
1544                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_activate05),
1545                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume);
1546            AnimationFrame appear6 = new AnimationFrame(
1547                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_activate06),
1548                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume);
1549
1550            appear.addFrame(appear1);
1551            appear.addFrame(appear2);
1552            appear.addFrame(appear3);
1553            appear.addFrame(appear4);
1554            appear.addFrame(appear5);
1555            appear.addFrame(appear6);
1556
1557            SpriteAnimation hidden = new SpriteAnimation(EnemyAnimations.HIDDEN.ordinal(), 6);
1558            hidden.addFrame(appear6);
1559            hidden.addFrame(appear5);
1560            hidden.addFrame(appear4);
1561            hidden.addFrame(appear3);
1562            hidden.addFrame(appear2);
1563            hidden.addFrame(appear1);
1564            /*hidden.addFrame(new AnimationFrame(
1565                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_stand),
1566                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume));*/
1567
1568
1569            SpriteAnimation attack = new SpriteAnimation(EnemyAnimations.ATTACK.ordinal(), 10);
1570            AnimationFrame attack1 = new AnimationFrame(
1571                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_attack01),
1572                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume);
1573            AnimationFrame attack2 = new AnimationFrame(
1574                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_attack02),
1575                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume);
1576            AnimationFrame attack3 = new AnimationFrame(
1577                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_attack03),
1578                    Utils.framesToTime(24, 2), basicAttackVolume, basicVulnerabilityVolume);
1579            AnimationFrame attack4 = new AnimationFrame(
1580                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_attack04),
1581                    Utils.framesToTime(24, 6), basicAttackVolume, basicVulnerabilityVolume);
1582            AnimationFrame attackFlash = new AnimationFrame(
1583                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_flash),
1584                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume);
1585
1586            AnimationFrame attack5 = new AnimationFrame(
1587                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_attack03),
1588                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume);
1589            AnimationFrame attack6 = new AnimationFrame(
1590                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_attack02),
1591                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume);
1592
1593            AnimationFrame attack7 = new AnimationFrame(
1594                    textureLibrary.allocateTexture(R.drawable.enemy_shadowslime_attack04),
1595                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume);
1596
1597            attack.addFrame(attack1);
1598            attack.addFrame(attack2);
1599            attack.addFrame(attack3);
1600            attack.addFrame(attack4);
1601            attack.addFrame(attackFlash);
1602            attack.addFrame(attack7);
1603            attack.addFrame(attackFlash);
1604            attack.addFrame(attack5);
1605            attack.addFrame(attack6);
1606            attack.addFrame(attack1);
1607
1608            popOut.setupAttack(200, 2.0f, attack.getLength());
1609
1610
1611            staticData.add(popOut);
1612            staticData.add(idle);
1613            staticData.add(hidden);
1614            staticData.add(appear);
1615            staticData.add(attack);
1616
1617            setStaticData(GameObjectType.SHADOWSLIME, staticData);
1618        }
1619
1620        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
1621        render.setPriority(SortConstants.GENERAL_ENEMY);
1622        BackgroundCollisionComponent bgcollision
1623            = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
1624        bgcollision.setSize(32, 48);
1625        bgcollision.setOffset(16, 5);
1626
1627        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1628        sprite.setSize((int)object.width, (int)object.height);
1629        sprite.setRenderComponent(render);
1630
1631
1632        sprite.playAnimation(0);
1633
1634        EnemyAnimationComponent animation
1635            = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
1636        animation.setSprite(sprite);
1637        animation.setFacePlayer(true);
1638
1639
1640        DynamicCollisionComponent collision
1641            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
1642        sprite.setCollisionComponent(collision);
1643
1644        HitReactionComponent hitReact
1645            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
1646        collision.setHitReactionComponent(hitReact);
1647
1648        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
1649        lifetime.setObjectToSpawnOnDeath(GameObjectType.SMOKE_POOF);
1650        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
1651        if (sound != null) {
1652        	lifetime.setDeathSound(sound.load(R.raw.sound_stomp));
1653        }
1654
1655        LaunchProjectileComponent gun
1656            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
1657
1658
1659        gun.setShotsPerSet(1);
1660        gun.setSetsPerActivation(1);
1661        gun.setObjectTypeToSpawn(GameObjectType.ENERGY_BALL);
1662        gun.setOffsetX(44);
1663        gun.setOffsetY(22);
1664        gun.setRequiredAction(GameObject.ActionType.ATTACK);
1665        gun.setVelocityX(30.0f);
1666
1667        object.team = Team.ENEMY;
1668
1669        if (flipHorizontal) {
1670            object.facingDirection.x = -1.0f;
1671        }
1672
1673        // Hack.  Adjusting position lets us avoid giving this character gravity, physics, and
1674        // collision.
1675
1676        object.getPosition().y -= 5;
1677
1678        object.add(render);
1679        object.add(sprite);
1680        object.add(bgcollision);
1681        object.add(animation);
1682        object.add(collision);
1683        object.add(hitReact);
1684        object.add(lifetime);
1685        object.add(gun);
1686
1687        addStaticData(GameObjectType.SHADOWSLIME, object, sprite);
1688
1689        final SpriteAnimation attack = sprite.findAnimation(EnemyAnimations.ATTACK.ordinal());
1690        final SpriteAnimation appear = sprite.findAnimation(EnemyAnimations.APPEAR.ordinal());
1691        if (attack != null && appear != null) {
1692            gun.setDelayBeforeFirstSet(attack.getLength() / 2.0f);
1693        } else {
1694            gun.setDelayBeforeFirstSet(Utils.framesToTime(24, 12));
1695        }
1696
1697        return object;
1698    }
1699
1700    public GameObject spawnEnemyMudman(float positionX, float positionY, boolean flipHorizontal) {
1701        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
1702
1703
1704        GameObject object = mGameObjectPool.allocate();
1705        object.getPosition().set(positionX, positionY);
1706        object.activationRadius = mNormalActivationRadius;
1707        object.width = 128;
1708        object.height = 128;
1709
1710        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.MUDMAN);
1711        if (staticData == null) {
1712            final int staticObjectCount = 7;
1713            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
1714
1715            GameComponent gravity = allocateComponent(GravityComponent.class);
1716            GameComponent movement = allocateComponent(MovementComponent.class);
1717
1718            GameComponent physics = allocateComponent(SimplePhysicsComponent.class);
1719
1720            SolidSurfaceComponent solidSurface
1721                = (SolidSurfaceComponent)allocateComponent(SolidSurfaceComponent.class);
1722            solidSurface.inititalize(4);
1723            // house shape:
1724            // / \      1/ \2
1725            // | |      3| |4
1726            Vector2 surface1Start = new Vector2(32, 64);
1727            Vector2 surface1End = new Vector2(64, 96);
1728            Vector2 surface1Normal = new Vector2(-0.707f, 0.707f);
1729            surface1Normal.normalize();
1730
1731            Vector2 surface2Start = new Vector2(64, 96);
1732            Vector2 surface2End = new Vector2(75, 64);
1733            Vector2 surface2Normal = new Vector2(0.9456f, 0.3250f);
1734            surface2Normal.normalize();
1735
1736            Vector2 surface3Start = new Vector2(32, 0);
1737            Vector2 surface3End = new Vector2(32, 64);
1738            Vector2 surface3Normal = new Vector2(-1, 0);
1739
1740            Vector2 surface4Start = new Vector2(75, 0);
1741            Vector2 surface4End = new Vector2(75, 64);
1742            Vector2 surface4Normal = new Vector2(1, 0);
1743
1744            solidSurface.addSurface(surface1Start, surface1End, surface1Normal);
1745            solidSurface.addSurface(surface2Start, surface2End, surface2Normal);
1746            solidSurface.addSurface(surface3Start, surface3End, surface3Normal);
1747            solidSurface.addSurface(surface4Start, surface4End, surface4Normal);
1748
1749            SpriteAnimation idle = new SpriteAnimation(EnemyAnimations.IDLE.ordinal(), 4);
1750            idle.addFrame(new AnimationFrame(
1751                    textureLibrary.allocateTexture(R.drawable.enemy_mud_stand),
1752                    Utils.framesToTime(24, 12), null, null));
1753            AnimationFrame idle1 = new AnimationFrame(
1754                    textureLibrary.allocateTexture(R.drawable.enemy_mud_idle01),
1755                    Utils.framesToTime(24, 2), null, null);
1756            AnimationFrame idle2 = new AnimationFrame(
1757                    textureLibrary.allocateTexture(R.drawable.enemy_mud_idle01),
1758                    Utils.framesToTime(24, 7), null, null);
1759            idle.addFrame(idle1);
1760            idle.addFrame(idle2);
1761            idle.addFrame(idle1);
1762            idle.setLoop(true);
1763
1764
1765            SpriteAnimation walk = new SpriteAnimation(EnemyAnimations.MOVE.ordinal(), 6);
1766            walk.addFrame(new AnimationFrame(
1767                    textureLibrary.allocateTexture(R.drawable.enemy_mud_walk01),
1768                    Utils.framesToTime(24, 4), null, null));
1769            walk.addFrame(new AnimationFrame(
1770                    textureLibrary.allocateTexture(R.drawable.enemy_mud_walk02),
1771                    Utils.framesToTime(24, 4), null, null));
1772            walk.addFrame(new AnimationFrame(
1773                    textureLibrary.allocateTexture(R.drawable.enemy_mud_walk03),
1774                    Utils.framesToTime(24, 5), null, null));
1775            walk.addFrame(new AnimationFrame(
1776                    textureLibrary.allocateTexture(R.drawable.enemy_mud_walk04),
1777                    Utils.framesToTime(24, 4), null, null));
1778            walk.addFrame(new AnimationFrame(
1779                    textureLibrary.allocateTexture(R.drawable.enemy_mud_walk05),
1780                    Utils.framesToTime(24, 4), null, null));
1781            walk.addFrame(new AnimationFrame(
1782                    textureLibrary.allocateTexture(R.drawable.enemy_mud_walk06),
1783                    Utils.framesToTime(24, 5), null, null));
1784            walk.setLoop(true);
1785
1786            FixedSizeArray<CollisionVolume> crushAttackVolume =
1787                new FixedSizeArray<CollisionVolume>(1);
1788            crushAttackVolume.add(new AABoxCollisionVolume(64, 0, 64, 96, HitType.HIT));
1789
1790            SpriteAnimation attack = new SpriteAnimation(EnemyAnimations.ATTACK.ordinal(), 8);
1791            attack.addFrame(new AnimationFrame(
1792                    textureLibrary.allocateTexture(R.drawable.enemy_mud_stand),
1793                    Utils.framesToTime(24, 2), null, null));
1794            attack.addFrame(new AnimationFrame(
1795                    textureLibrary.allocateTexture(R.drawable.enemy_mud_attack01),
1796                    Utils.framesToTime(24, 2), null, null));
1797            attack.addFrame(new AnimationFrame(
1798                    textureLibrary.allocateTexture(R.drawable.enemy_mud_attack02),
1799                    Utils.framesToTime(24, 2), null, null));
1800            attack.addFrame(new AnimationFrame(
1801                    textureLibrary.allocateTexture(R.drawable.enemy_mud_attack03),
1802                    Utils.framesToTime(24, 2), null, null));
1803            attack.addFrame(new AnimationFrame(
1804                    textureLibrary.allocateTexture(R.drawable.enemy_mud_attack04),
1805                    Utils.framesToTime(24, 1), crushAttackVolume, null));
1806            attack.addFrame(new AnimationFrame(
1807                    textureLibrary.allocateTexture(R.drawable.enemy_mud_attack05),
1808                    Utils.framesToTime(24, 1), crushAttackVolume, null));
1809            attack.addFrame(new AnimationFrame(
1810                    textureLibrary.allocateTexture(R.drawable.enemy_mud_attack06),
1811                    Utils.framesToTime(24, 8), crushAttackVolume, null));
1812            attack.addFrame(new AnimationFrame(
1813                    textureLibrary.allocateTexture(R.drawable.enemy_mud_attack07),
1814                    Utils.framesToTime(24, 5), null, null));
1815
1816            staticData.add(gravity);
1817            staticData.add(movement);
1818            staticData.add(physics);
1819            staticData.add(solidSurface);
1820            staticData.add(idle);
1821            staticData.add(walk);
1822            staticData.add(attack);
1823
1824            setStaticData(GameObjectType.MUDMAN, staticData);
1825        }
1826
1827        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
1828        render.setPriority(SortConstants.GENERAL_ENEMY);
1829
1830        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
1831		bgcollision.setSize(80, 90);
1832		bgcollision.setOffset(32, 5);
1833
1834        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1835        sprite.setSize((int)object.width, (int)object.height);
1836        sprite.setRenderComponent(render);
1837
1838
1839        sprite.playAnimation(0);
1840
1841        EnemyAnimationComponent animation = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
1842        animation.setSprite(sprite);
1843
1844        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
1845        patrol.setMovementSpeed(20.0f, 400.0f);
1846
1847        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
1848        sprite.setCollisionComponent(collision);
1849
1850        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
1851        collision.setHitReactionComponent(hitReact);
1852
1853        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
1854
1855        object.team = Team.ENEMY;
1856        object.life = 1;
1857
1858        if (flipHorizontal) {
1859            object.facingDirection.x = -1.0f;
1860        }
1861
1862        object.add(render);
1863        object.add(sprite);
1864        object.add(bgcollision);
1865        object.add(animation);
1866        object.add(patrol);
1867        object.add(collision);
1868        object.add(hitReact);
1869        object.add(lifetime);
1870
1871        addStaticData(GameObjectType.MUDMAN, object, sprite);
1872
1873        final SpriteAnimation attack = sprite.findAnimation(EnemyAnimations.ATTACK.ordinal());
1874        if (attack != null) {
1875            patrol.setupAttack(70.0f, attack.getLength(), 0.0f, true);
1876        }
1877
1878        sprite.playAnimation(0);
1879
1880        return object;
1881    }
1882
1883    public GameObject spawnEnemySkeleton(float positionX, float positionY, boolean flipHorizontal) {
1884        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
1885
1886
1887        GameObject object = mGameObjectPool.allocate();
1888        object.getPosition().set(positionX, positionY);
1889        object.activationRadius = mNormalActivationRadius;
1890        object.width = 64;
1891        object.height = 64;
1892
1893        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.SKELETON);
1894        if (staticData == null) {
1895            final int staticObjectCount = 7;
1896            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
1897
1898            GameComponent gravity = allocateComponent(GravityComponent.class);
1899            GameComponent movement = allocateComponent(MovementComponent.class);
1900
1901            GameComponent physics = allocateComponent(SimplePhysicsComponent.class);
1902
1903            SolidSurfaceComponent solidSurface = (SolidSurfaceComponent)allocateComponent(SolidSurfaceComponent.class);
1904            solidSurface.inititalize(4);
1905
1906            Vector2 surface1Start = new Vector2(25, 0);
1907            Vector2 surface1End = new Vector2(25, 64);
1908            Vector2 surface1Normal = new Vector2(-1, 0);
1909
1910            Vector2 surface2Start = new Vector2(40, 0);
1911            Vector2 surface2End = new Vector2(40, 64);
1912            Vector2 surface2Normal = new Vector2(1, 0);
1913
1914            solidSurface.addSurface(surface1Start, surface1End, surface1Normal);
1915            solidSurface.addSurface(surface2Start, surface2End, surface2Normal);
1916
1917            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
1918                new FixedSizeArray<CollisionVolume>(1);
1919            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 32));
1920            basicVulnerabilityVolume.get(0).setHitType(HitType.HIT);
1921
1922            FixedSizeArray<CollisionVolume> basicAttackVolume =
1923                new FixedSizeArray<CollisionVolume>(1);
1924            basicAttackVolume.add(new SphereCollisionVolume(16, 48, 32, HitType.HIT));
1925
1926            SpriteAnimation idle = new SpriteAnimation(EnemyAnimations.IDLE.ordinal(), 1);
1927            idle.addFrame(new AnimationFrame(
1928                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_stand),
1929                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
1930
1931            SpriteAnimation walk = new SpriteAnimation(EnemyAnimations.MOVE.ordinal(), 6);
1932            walk.addFrame(new AnimationFrame(
1933                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_walk01),
1934                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume));
1935            walk.addFrame(new AnimationFrame(
1936                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_walk02),
1937                    Utils.framesToTime(24, 4), null, basicVulnerabilityVolume));
1938            walk.addFrame(new AnimationFrame(
1939                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_walk03),
1940                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume));
1941            walk.addFrame(new AnimationFrame(
1942                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_walk04),
1943                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume));
1944            walk.addFrame(new AnimationFrame(
1945                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_walk05),
1946                    Utils.framesToTime(24, 4), null, basicVulnerabilityVolume));
1947            walk.addFrame(new AnimationFrame(
1948                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_walk03),
1949                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume));
1950
1951            walk.setLoop(true);
1952
1953
1954            SpriteAnimation attack = new SpriteAnimation(EnemyAnimations.ATTACK.ordinal(), 3);
1955            attack.addFrame(new AnimationFrame(
1956                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_attack01),
1957                    Utils.framesToTime(24, 5), null, basicVulnerabilityVolume));
1958            attack.addFrame(new AnimationFrame(
1959                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_attack03),
1960                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
1961            attack.addFrame(new AnimationFrame(
1962                    textureLibrary.allocateTexture(R.drawable.enemy_skeleton_attack04),
1963                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
1964
1965            staticData.add(gravity);
1966            staticData.add(movement);
1967            staticData.add(physics);
1968            staticData.add(solidSurface);
1969            staticData.add(idle);
1970            staticData.add(walk);
1971            staticData.add(attack);
1972
1973            setStaticData(GameObjectType.SKELETON, staticData);
1974        }
1975
1976        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
1977        render.setPriority(SortConstants.GENERAL_ENEMY);
1978
1979        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
1980		bgcollision.setSize(32, 48);
1981		bgcollision.setOffset(16, 5);
1982
1983        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
1984		sprite.setSize((int)object.width, (int)object.height);
1985        sprite.setRenderComponent(render);
1986
1987        EnemyAnimationComponent animation = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
1988        animation.setSprite(sprite);
1989
1990        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
1991        patrol.setMovementSpeed(20.0f, 1000.0f);
1992        patrol.setTurnToFacePlayer(true);
1993
1994        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
1995        sprite.setCollisionComponent(collision);
1996
1997        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
1998        collision.setHitReactionComponent(hitReact);
1999
2000        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
2001        lifetime.setVulnerableToDeathTiles(true);
2002        lifetime.setObjectToSpawnOnDeath(GameObjectType.SMOKE_POOF);
2003        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
2004        if (sound != null) {
2005        	lifetime.setDeathSound(sound.load(R.raw.sound_stomp));
2006        }
2007
2008        object.team = Team.ENEMY;
2009
2010        if (flipHorizontal) {
2011            object.facingDirection.x = -1.0f;
2012        }
2013
2014        object.add(render);
2015        object.add(sprite);
2016        object.add(bgcollision);
2017        object.add(animation);
2018        object.add(patrol);
2019        object.add(collision);
2020        object.add(hitReact);
2021        object.add(lifetime);
2022
2023        addStaticData(GameObjectType.SKELETON, object, sprite);
2024
2025        final SpriteAnimation attack = sprite.findAnimation(EnemyAnimations.ATTACK.ordinal());
2026        if (attack != null) {
2027            patrol.setupAttack(75.0f, attack.getLength(), 2.0f, true);
2028        }
2029
2030        sprite.playAnimation(0);
2031
2032        return object;
2033    }
2034
2035
2036    public GameObject spawnEnemyKaraguin(float positionX, float positionY, boolean flipHorizontal) {
2037        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
2038
2039
2040        GameObject object = mGameObjectPool.allocate();
2041        object.getPosition().set(positionX, positionY);
2042        object.activationRadius = mNormalActivationRadius;
2043        object.width = 32;
2044        object.height = 32;
2045
2046        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.KARAGUIN);
2047        if (staticData == null) {
2048            final int staticObjectCount = 2;
2049            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
2050
2051            GameComponent movement = allocateComponent(MovementComponent.class);
2052
2053            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
2054                new FixedSizeArray<CollisionVolume>(1);
2055            basicVulnerabilityVolume.add(new SphereCollisionVolume(8, 16, 16));
2056            basicVulnerabilityVolume.get(0).setHitType(HitType.HIT);
2057
2058            FixedSizeArray<CollisionVolume> basicAttackVolume =
2059                new FixedSizeArray<CollisionVolume>(1);
2060            basicAttackVolume.add(new SphereCollisionVolume(8, 16, 16, HitType.HIT));
2061
2062            SpriteAnimation idle = new SpriteAnimation(0, 3);
2063            idle.addFrame(new AnimationFrame(
2064                    textureLibrary.allocateTexture(R.drawable.enemy_karaguin01),
2065                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2066            idle.addFrame(new AnimationFrame(
2067                    textureLibrary.allocateTexture(R.drawable.enemy_karaguin02),
2068                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2069            idle.addFrame(new AnimationFrame(
2070                    textureLibrary.allocateTexture(R.drawable.enemy_karaguin03),
2071                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2072            idle.setLoop(true);
2073
2074            staticData.add(movement);
2075            staticData.add(idle);
2076
2077
2078            setStaticData(GameObjectType.KARAGUIN, staticData);
2079        }
2080
2081        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
2082        render.setPriority(SortConstants.GENERAL_ENEMY);
2083
2084        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
2085        sprite.setSize((int)object.width, (int)object.height);
2086        sprite.setRenderComponent(render);
2087
2088        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
2089        patrol.setMovementSpeed(50.0f, 1000.0f);
2090        patrol.setTurnToFacePlayer(false);
2091        patrol.setFlying(true);
2092
2093        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
2094        sprite.setCollisionComponent(collision);
2095
2096        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
2097        collision.setHitReactionComponent(hitReact);
2098
2099        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
2100        lifetime.setObjectToSpawnOnDeath(GameObjectType.SMOKE_POOF);
2101        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
2102        if (sound != null) {
2103        	lifetime.setDeathSound(sound.load(R.raw.sound_stomp));
2104        }
2105
2106        EnemyAnimationComponent animation = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
2107        animation.setSprite(sprite);
2108
2109        object.team = Team.ENEMY;
2110
2111        if (flipHorizontal) {
2112            object.facingDirection.x = -1.0f;
2113        }
2114        // HACK.  These guys originally moved on their own, so let's keep them that way.
2115        object.getVelocity().x = 50.0f * object.facingDirection.x;
2116        object.getTargetVelocity().x = 50.0f * object.facingDirection.x;
2117
2118        object.add(render);
2119        object.add(animation);
2120        object.add(sprite);
2121        object.add(patrol);
2122        object.add(collision);
2123        object.add(hitReact);
2124        object.add(lifetime);
2125
2126        addStaticData(GameObjectType.KARAGUIN, object, sprite);
2127
2128        sprite.playAnimation(0);
2129
2130        return object;
2131    }
2132
2133    public GameObject spawnEnemyPinkNamazu(float positionX, float positionY, boolean flipHorizontal) {
2134        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
2135
2136
2137        GameObject object = mGameObjectPool.allocate();
2138        object.getPosition().set(positionX, positionY);
2139        object.activationRadius = mTightActivationRadius;
2140        object.width = 128;
2141        object.height = 128;
2142
2143        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.PINK_NAMAZU);
2144        if (staticData == null) {
2145            final int staticObjectCount = 7;
2146            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
2147
2148            GameComponent gravity = allocateComponent(GravityComponent.class);
2149            GameComponent movement = allocateComponent(MovementComponent.class);
2150
2151            GameComponent physics = allocateComponent(SimplePhysicsComponent.class);
2152
2153            SolidSurfaceComponent solidSurface
2154                = (SolidSurfaceComponent)allocateComponent(SolidSurfaceComponent.class);
2155            solidSurface.inititalize(5);
2156            // circle shape:
2157            //  __        __3
2158            // /  \      2/ \4
2159            // |   |     1|  |5
2160            /*
2161                0:12,6:22,52:0.98058067569092,-0.19611613513818
2162                0:22,52:50,75:-0.62580046626293,0.77998318983495
2163                0:50,75:81,75:0,1
2164                0:81,75:104,49:0.74038072228541,0.67218776102228
2165                0:104,49:104,6:-0.99997086544204,-0.00763336538505
2166             */
2167            Vector2 surface1Start = new Vector2(12, 3);
2168            Vector2 surface1End = new Vector2(22, 52);
2169            Vector2 surface1Normal = new Vector2(-0.98058067569092f, -0.19611613513818f);
2170            surface1Normal.normalize();
2171
2172            Vector2 surface2Start = new Vector2(22, 52);
2173            Vector2 surface2End = new Vector2(50, 75);
2174            Vector2 surface2Normal = new Vector2(-0.62580046626293f, 0.77998318983495f);
2175            surface2Normal.normalize();
2176
2177            Vector2 surface3Start = new Vector2(50, 75);
2178            Vector2 surface3End = new Vector2(81, 75);
2179            Vector2 surface3Normal = new Vector2(0, 1);
2180
2181            Vector2 surface4Start = new Vector2(81, 75);
2182            Vector2 surface4End = new Vector2(104,49);
2183            Vector2 surface4Normal = new Vector2(0.74038072228541f, 0.67218776102228f);
2184
2185            Vector2 surface5Start = new Vector2(104,49);
2186            Vector2 surface5End = new Vector2(104, 3);
2187            Vector2 surface5Normal = new Vector2(1.0f, 0.0f);
2188
2189            solidSurface.addSurface(surface1Start, surface1End, surface1Normal);
2190            solidSurface.addSurface(surface2Start, surface2End, surface2Normal);
2191            solidSurface.addSurface(surface3Start, surface3End, surface3Normal);
2192            solidSurface.addSurface(surface4Start, surface4End, surface4Normal);
2193            solidSurface.addSurface(surface5Start, surface5End, surface5Normal);
2194
2195
2196            SpriteAnimation idle = new SpriteAnimation(GenericAnimationComponent.Animation.IDLE, 4);
2197            idle.addFrame(new AnimationFrame(
2198                    textureLibrary.allocateTexture(R.drawable.enemy_pinkdude_stand),
2199                    Utils.framesToTime(24, 8), null, null));
2200            AnimationFrame idle1 = new AnimationFrame(
2201                    textureLibrary.allocateTexture(R.drawable.enemy_pinkdude_sleep01),
2202                    Utils.framesToTime(24, 3), null, null);
2203            AnimationFrame idle2 = new AnimationFrame(
2204                    textureLibrary.allocateTexture(R.drawable.enemy_pinkdude_sleep02),
2205                    Utils.framesToTime(24, 8), null, null);
2206            idle.addFrame(idle1);
2207            idle.addFrame(idle2);
2208            idle.addFrame(idle1);
2209            idle.setLoop(true);
2210
2211
2212            SpriteAnimation wake = new SpriteAnimation(GenericAnimationComponent.Animation.MOVE, 4);
2213            AnimationFrame wake1 = new AnimationFrame(
2214                    textureLibrary.allocateTexture(R.drawable.enemy_pinkdude_eyeopen),
2215                    Utils.framesToTime(24, 3), null, null);
2216            AnimationFrame wake2 = new AnimationFrame(
2217                    textureLibrary.allocateTexture(R.drawable.enemy_pinkdude_stand),
2218                    Utils.framesToTime(24, 3), null, null);
2219            wake.addFrame(wake1);
2220            wake.addFrame(wake2);
2221            wake.addFrame(wake1);
2222            wake.addFrame(wake2);
2223
2224            FixedSizeArray<CollisionVolume> crushAttackVolume =
2225                new FixedSizeArray<CollisionVolume>(1);
2226            crushAttackVolume.add(new AABoxCollisionVolume(32, 0, 64, 32, HitType.HIT));
2227
2228            SpriteAnimation attack = new SpriteAnimation(GenericAnimationComponent.Animation.ATTACK, 1);
2229            attack.addFrame(new AnimationFrame(
2230                    textureLibrary.allocateTexture(R.drawable.enemy_pinkdude_jump),
2231                    Utils.framesToTime(24, 2), crushAttackVolume, null));
2232
2233
2234            staticData.add(gravity);
2235            staticData.add(movement);
2236            staticData.add(physics);
2237            staticData.add(solidSurface);
2238            staticData.add(idle);
2239            staticData.add(wake);
2240            staticData.add(attack);
2241
2242            setStaticData(GameObjectType.PINK_NAMAZU, staticData);
2243        }
2244
2245        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
2246        render.setPriority(SortConstants.GENERAL_ENEMY);
2247
2248        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
2249        bgcollision.setSize(100, 75);
2250        bgcollision.setOffset(12, 5);
2251
2252        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
2253        sprite.setSize((int)object.width, (int)object.height);
2254        sprite.setRenderComponent(render);
2255
2256        GenericAnimationComponent animation =
2257            (GenericAnimationComponent)allocateComponent(GenericAnimationComponent.class);
2258        animation.setSprite(sprite);
2259
2260        SleeperComponent sleeper = (SleeperComponent)allocateComponent(SleeperComponent.class);
2261        sleeper.setAttackImpulse(100.0f, 170.0f);
2262        sleeper.setSlam(0.3f, 25.0f);
2263
2264        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
2265        sprite.setCollisionComponent(collision);
2266
2267        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
2268        collision.setHitReactionComponent(hitReact);
2269
2270
2271        object.team = Team.ENEMY;
2272        object.life = 1;
2273
2274        if (flipHorizontal) {
2275            object.facingDirection.x = -1.0f;
2276        }
2277
2278        object.add(render);
2279        object.add(sprite);
2280        object.add(bgcollision);
2281        object.add(animation);
2282        object.add(collision);
2283        object.add(hitReact);
2284        object.add(sleeper);
2285
2286
2287        addStaticData(GameObjectType.PINK_NAMAZU, object, sprite);
2288
2289        final SpriteAnimation wakeUp = sprite.findAnimation(GenericAnimationComponent.Animation.MOVE);
2290        if (wakeUp != null) {
2291            sleeper.setWakeUpDuration(wakeUp.getLength() + 1.0f);
2292        }
2293
2294        sprite.playAnimation(GenericAnimationComponent.Animation.IDLE);
2295
2296        return object;
2297    }
2298
2299    public GameObject spawnEnemyBat(float positionX, float positionY, boolean flipHorizontal) {
2300        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
2301
2302
2303        GameObject object = mGameObjectPool.allocate();
2304        object.getPosition().set(positionX, positionY);
2305        object.activationRadius = mNormalActivationRadius;
2306        object.width = 64;
2307        object.height = 32;
2308
2309        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.BAT);
2310        if (staticData == null) {
2311            final int staticObjectCount = 2;
2312            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
2313
2314            GameComponent movement = allocateComponent(MovementComponent.class);
2315
2316            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
2317                new FixedSizeArray<CollisionVolume>(1);
2318            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 16));
2319            basicVulnerabilityVolume.get(0).setHitType(HitType.HIT);
2320
2321            FixedSizeArray<CollisionVolume> basicAttackVolume =
2322                new FixedSizeArray<CollisionVolume>(1);
2323            basicAttackVolume.add(new SphereCollisionVolume(16, 32, 16, HitType.HIT));
2324
2325            SpriteAnimation idle = new SpriteAnimation(0, 4);
2326            idle.addFrame(new AnimationFrame(
2327                    textureLibrary.allocateTexture(R.drawable.enemy_bat01),
2328                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2329            idle.addFrame(new AnimationFrame(
2330                    textureLibrary.allocateTexture(R.drawable.enemy_bat02),
2331                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2332            idle.addFrame(new AnimationFrame(
2333                    textureLibrary.allocateTexture(R.drawable.enemy_bat03),
2334                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2335            idle.addFrame(new AnimationFrame(
2336                    textureLibrary.allocateTexture(R.drawable.enemy_bat04),
2337                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2338            idle.setLoop(true);
2339
2340            staticData.add(movement);
2341            staticData.add(idle);
2342
2343
2344            setStaticData(GameObjectType.BAT, staticData);
2345        }
2346
2347        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
2348        render.setPriority(SortConstants.GENERAL_ENEMY);
2349
2350        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
2351        sprite.setSize((int)object.width, (int)object.height);
2352        sprite.setRenderComponent(render);
2353
2354        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
2355        patrol.setMovementSpeed(75.0f, 1000.0f);
2356        patrol.setTurnToFacePlayer(false);
2357        patrol.setFlying(true);
2358
2359        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
2360        sprite.setCollisionComponent(collision);
2361
2362        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
2363        collision.setHitReactionComponent(hitReact);
2364
2365        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
2366        lifetime.setObjectToSpawnOnDeath(GameObjectType.SMOKE_POOF);
2367        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
2368        if (sound != null) {
2369        	lifetime.setDeathSound(sound.load(R.raw.sound_stomp));
2370        }
2371
2372        EnemyAnimationComponent animation = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
2373        animation.setSprite(sprite);
2374
2375        object.team = Team.ENEMY;
2376
2377        if (flipHorizontal) {
2378            object.facingDirection.x = -1.0f;
2379        }
2380
2381        // HACK.  These guys originally moved on their own, so let's keep them that way.
2382        object.getVelocity().x = 75.0f * object.facingDirection.x;
2383        object.getTargetVelocity().x = 75.0f * object.facingDirection.x;
2384
2385        object.add(render);
2386        object.add(animation);
2387        object.add(sprite);
2388        object.add(patrol);
2389        object.add(collision);
2390        object.add(hitReact);
2391        object.add(lifetime);
2392
2393        addStaticData(GameObjectType.BAT, object, sprite);
2394
2395        sprite.playAnimation(0);
2396
2397        return object;
2398    }
2399
2400    public GameObject spawnEnemySting(float positionX, float positionY, boolean flipHorizontal) {
2401        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
2402
2403
2404        GameObject object = mGameObjectPool.allocate();
2405        object.getPosition().set(positionX, positionY);
2406        object.activationRadius = mNormalActivationRadius;
2407        object.width = 64;
2408        object.height = 64;
2409
2410        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.STING);
2411        if (staticData == null) {
2412            final int staticObjectCount = 2;
2413            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
2414
2415            GameComponent movement = allocateComponent(MovementComponent.class);
2416
2417            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
2418                new FixedSizeArray<CollisionVolume>(1);
2419            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 16));
2420            basicVulnerabilityVolume.get(0).setHitType(HitType.HIT);
2421
2422            FixedSizeArray<CollisionVolume> basicAttackVolume =
2423                new FixedSizeArray<CollisionVolume>(1);
2424            basicAttackVolume.add(new SphereCollisionVolume(16, 32, 16, HitType.HIT));
2425
2426            SpriteAnimation idle = new SpriteAnimation(0, 3);
2427            idle.addFrame(new AnimationFrame(
2428                    textureLibrary.allocateTexture(R.drawable.enemy_sting01),
2429                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2430            idle.addFrame(new AnimationFrame(
2431                    textureLibrary.allocateTexture(R.drawable.enemy_sting02),
2432                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2433            idle.addFrame(new AnimationFrame(
2434                    textureLibrary.allocateTexture(R.drawable.enemy_sting03),
2435                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2436
2437            idle.setLoop(true);
2438
2439            staticData.add(movement);
2440            staticData.add(idle);
2441
2442
2443            setStaticData(GameObjectType.STING, staticData);
2444        }
2445
2446        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
2447        render.setPriority(SortConstants.GENERAL_ENEMY);
2448
2449        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
2450        sprite.setSize((int)object.width, (int)object.height);
2451        sprite.setRenderComponent(render);
2452
2453        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
2454        patrol.setMovementSpeed(75.0f, 1000.0f);
2455        patrol.setTurnToFacePlayer(false);
2456        patrol.setFlying(true);
2457
2458        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
2459        sprite.setCollisionComponent(collision);
2460
2461        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
2462        collision.setHitReactionComponent(hitReact);
2463
2464        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
2465        lifetime.setObjectToSpawnOnDeath(GameObjectType.SMOKE_POOF);
2466        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
2467        if (sound != null) {
2468        	lifetime.setDeathSound(sound.load(R.raw.sound_stomp));
2469        }
2470
2471        EnemyAnimationComponent animation = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
2472        animation.setSprite(sprite);
2473
2474        object.team = Team.ENEMY;
2475
2476        if (flipHorizontal) {
2477            object.facingDirection.x = -1.0f;
2478        }
2479
2480        // HACK.  These guys originally moved on their own, so let's keep them that way.
2481        object.getVelocity().x = 25.0f * object.facingDirection.x;
2482        object.getTargetVelocity().x = 25.0f * object.facingDirection.x;
2483
2484        object.add(render);
2485        object.add(animation);
2486        object.add(sprite);
2487        object.add(patrol);
2488        object.add(collision);
2489        object.add(hitReact);
2490        object.add(lifetime);
2491
2492        addStaticData(GameObjectType.STING, object, sprite);
2493
2494        sprite.playAnimation(0);
2495
2496        return object;
2497    }
2498
2499    public GameObject spawnEnemyOnion(float positionX, float positionY, boolean flipHorizontal) {
2500        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
2501
2502        GameObject object = mGameObjectPool.allocate();
2503        object.getPosition().set(positionX, positionY);
2504        object.activationRadius = mNormalActivationRadius;
2505        object.width = 64;
2506        object.height = 64;
2507
2508        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.ONION);
2509        if (staticData == null) {
2510            final int staticObjectCount = 5;
2511            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
2512
2513            GameComponent gravity = allocateComponent(GravityComponent.class);
2514            GameComponent movement = allocateComponent(MovementComponent.class);
2515            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
2516            physics.setBounciness(0.2f);
2517
2518
2519            // Animations
2520            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
2521                new FixedSizeArray<CollisionVolume>(1);
2522            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 32));
2523
2524            FixedSizeArray<CollisionVolume> basicAttackVolume =
2525                new FixedSizeArray<CollisionVolume>(1);
2526            basicAttackVolume.add(new SphereCollisionVolume(16, 32, 32, HitType.HIT));
2527
2528            SpriteAnimation idle = new SpriteAnimation(EnemyAnimations.IDLE.ordinal(), 1);
2529            idle.addFrame(new AnimationFrame(
2530                    textureLibrary.allocateTexture(R.drawable.enemy_onion01),
2531                    Utils.framesToTime(24, 3), basicAttackVolume, basicVulnerabilityVolume));
2532
2533            idle.setLoop(true);
2534
2535            SpriteAnimation walk = new SpriteAnimation(EnemyAnimations.MOVE.ordinal(), 3);
2536            walk.addFrame(new AnimationFrame(
2537                    textureLibrary.allocateTexture(R.drawable.enemy_onion01),
2538                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2539            walk.addFrame(new AnimationFrame(
2540                    textureLibrary.allocateTexture(R.drawable.enemy_onion02),
2541                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2542            walk.addFrame(new AnimationFrame(
2543                    textureLibrary.allocateTexture(R.drawable.enemy_onion03),
2544                    Utils.framesToTime(24, 1), basicAttackVolume, basicVulnerabilityVolume));
2545            walk.setLoop(true);
2546
2547            staticData.add(gravity);
2548            staticData.add(movement);
2549            staticData.add(physics);
2550            staticData.add(idle);
2551            staticData.add(walk);
2552
2553            setStaticData(GameObjectType.ONION, staticData);
2554
2555        }
2556        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
2557        render.setPriority(SortConstants.GENERAL_ENEMY);
2558
2559        BackgroundCollisionComponent bgcollision
2560            = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
2561        bgcollision.setSize(32, 48);
2562        bgcollision.setOffset(16, 5);
2563
2564        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
2565        sprite.setSize((int)object.width, (int)object.height);
2566        sprite.setRenderComponent(render);
2567
2568        EnemyAnimationComponent animation
2569            = (EnemyAnimationComponent)allocateComponent(EnemyAnimationComponent.class);
2570        animation.setSprite(sprite);
2571
2572        PatrolComponent patrol = (PatrolComponent)allocateComponent(PatrolComponent.class);
2573        patrol.setMovementSpeed(50.0f, 1000.0f);
2574
2575        DynamicCollisionComponent collision
2576            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
2577        sprite.setCollisionComponent(collision);
2578
2579        HitReactionComponent hitReact
2580            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
2581        collision.setHitReactionComponent(hitReact);
2582
2583        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
2584        lifetime.setVulnerableToDeathTiles(true);
2585        lifetime.setObjectToSpawnOnDeath(GameObjectType.SMOKE_POOF);
2586        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
2587        if (sound != null) {
2588        	lifetime.setDeathSound(sound.load(R.raw.sound_stomp));
2589        }
2590
2591        object.add(render);
2592        object.add(sprite);
2593
2594        object.add(bgcollision);
2595        object.add(animation);
2596        object.add(patrol);
2597        object.add(collision);
2598        object.add(hitReact);
2599        object.add(lifetime);
2600
2601        object.team = Team.ENEMY;
2602
2603
2604        if (flipHorizontal) {
2605            object.facingDirection.x = -1.0f;
2606        }
2607
2608        addStaticData(GameObjectType.ONION, object, sprite);
2609
2610        sprite.playAnimation(0);
2611
2612        return object;
2613    }
2614
2615    public GameObject spawnEnemyWanda(float positionX, float positionY, boolean flipHorizontal) {
2616        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
2617
2618
2619        // Make sure related textures are loaded.
2620        textureLibrary.allocateTexture(R.drawable.energy_ball01);
2621        textureLibrary.allocateTexture(R.drawable.energy_ball02);
2622        textureLibrary.allocateTexture(R.drawable.energy_ball03);
2623        textureLibrary.allocateTexture(R.drawable.energy_ball04);
2624
2625        GameObject object = mGameObjectPool.allocate();
2626        object.getPosition().set(positionX, positionY);
2627        object.activationRadius = mAlwaysActive;
2628        object.width = 64;
2629        object.height = 128;
2630
2631        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.WANDA);
2632        if (staticData == null) {
2633            final int staticObjectCount = 9;
2634            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
2635
2636            GameComponent gravity = allocateComponent(GravityComponent.class);
2637            GameComponent movement = allocateComponent(MovementComponent.class);
2638
2639            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
2640            physics.setBounciness(0.0f);
2641
2642
2643
2644            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
2645                new FixedSizeArray<CollisionVolume>(1);
2646            basicVulnerabilityVolume.add(new AABoxCollisionVolume(20, 5, 26, 80, HitType.COLLECT));
2647
2648            SpriteAnimation idle = new SpriteAnimation(NPCAnimationComponent.IDLE, 1);
2649            idle.addFrame(new AnimationFrame(
2650                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_stand),
2651                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2652
2653
2654
2655            AnimationFrame walkFrame1 = new AnimationFrame(
2656                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_walk01),
2657                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2658            AnimationFrame walkFrame2 = new AnimationFrame(
2659                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_walk02),
2660                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2661            AnimationFrame walkFrame3 = new AnimationFrame(
2662                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_walk03),
2663                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2664            AnimationFrame walkFrame4 = new AnimationFrame(
2665                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_walk04),
2666                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2667            AnimationFrame walkFrame5 = new AnimationFrame(
2668                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_walk05),
2669                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2670            SpriteAnimation walk = new SpriteAnimation(NPCAnimationComponent.WALK, 8);
2671            walk.addFrame(walkFrame1);
2672            walk.addFrame(walkFrame2);
2673            walk.addFrame(walkFrame3);
2674            walk.addFrame(walkFrame4);
2675            walk.addFrame(walkFrame5);
2676            walk.addFrame(walkFrame4);
2677            walk.addFrame(walkFrame3);
2678            walk.addFrame(walkFrame2);
2679            walk.setLoop(true);
2680
2681
2682            AnimationFrame runFrame4 = new AnimationFrame(
2683                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run04),
2684                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
2685
2686            SpriteAnimation run = new SpriteAnimation(NPCAnimationComponent.RUN, 9);
2687            run.addFrame(new AnimationFrame(
2688                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run01),
2689                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2690            run.addFrame(new AnimationFrame(
2691                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run02),
2692                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2693            run.addFrame(new AnimationFrame(
2694                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run03),
2695                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2696            run.addFrame(runFrame4);
2697            run.addFrame(new AnimationFrame(
2698                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run05),
2699                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2700            run.addFrame(new AnimationFrame(
2701                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run06),
2702                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2703            run.addFrame(new AnimationFrame(
2704                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run07),
2705                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2706            run.addFrame(runFrame4);
2707            run.addFrame(new AnimationFrame(
2708                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run08),
2709                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2710            run.setLoop(true);
2711
2712            SpriteAnimation jumpStart = new SpriteAnimation(NPCAnimationComponent.JUMP_START, 4);
2713            AnimationFrame jump1 = new AnimationFrame(
2714                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_jump01),
2715                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
2716            AnimationFrame jump2 = new AnimationFrame(
2717                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_jump01),
2718                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
2719            jumpStart.addFrame(new AnimationFrame(
2720                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_run04),
2721                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
2722            jumpStart.addFrame(new AnimationFrame(
2723                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_crouch),
2724                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2725            jumpStart.addFrame(jump1);
2726            jumpStart.addFrame(jump2);
2727
2728            SpriteAnimation jumpAir = new SpriteAnimation(NPCAnimationComponent.JUMP_AIR, 2);
2729            jumpAir.addFrame(jump1);
2730            jumpAir.addFrame(jump2);
2731            jumpAir.setLoop(true);
2732
2733            SpriteAnimation attack = new SpriteAnimation(NPCAnimationComponent.SHOOT, 11);
2734            attack.addFrame(new AnimationFrame(
2735                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot01),
2736                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
2737            attack.addFrame(new AnimationFrame(
2738                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot02),
2739                    Utils.framesToTime(24, 8), null, basicVulnerabilityVolume));
2740            attack.addFrame(new AnimationFrame(
2741                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot03),
2742                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2743            attack.addFrame(new AnimationFrame(
2744                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot04),
2745                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2746            attack.addFrame(new AnimationFrame(
2747                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot05),
2748                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2749            attack.addFrame(new AnimationFrame(
2750                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot06),
2751                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2752            attack.addFrame(new AnimationFrame(
2753                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot07),
2754                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2755            attack.addFrame(new AnimationFrame(
2756                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot08),
2757                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2758            attack.addFrame(new AnimationFrame(
2759                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot09),
2760                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
2761            attack.addFrame(new AnimationFrame(
2762                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot02),
2763                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume));
2764            attack.addFrame(new AnimationFrame(
2765                    textureLibrary.allocateTexture(R.drawable.enemy_wanda_shoot01),
2766                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume));
2767
2768            staticData.add(gravity);
2769            staticData.add(movement);
2770            staticData.add(physics);
2771            staticData.add(idle);
2772            staticData.add(walk);
2773            staticData.add(run);
2774            staticData.add(jumpStart);
2775            staticData.add(jumpAir);
2776            staticData.add(attack);
2777
2778            setStaticData(GameObjectType.WANDA, staticData);
2779        }
2780
2781        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
2782        render.setPriority(SortConstants.NPC);
2783
2784        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
2785        bgcollision.setSize(32, 82);
2786        bgcollision.setOffset(20, 5);
2787
2788        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
2789        sprite.setSize((int)object.width, (int)object.height);
2790        sprite.setRenderComponent(render);
2791
2792        NPCAnimationComponent animation = (NPCAnimationComponent)allocateComponent(NPCAnimationComponent.class);
2793        animation.setSprite(sprite);
2794
2795        NPCComponent patrol = (NPCComponent)allocateComponent(NPCComponent.class);
2796
2797        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
2798        sprite.setCollisionComponent(collision);
2799
2800        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
2801        collision.setHitReactionComponent(hitReact);
2802
2803        patrol.setHitReactionComponent(hitReact);
2804
2805        SoundSystem sound = sSystemRegistry.soundSystem;
2806
2807        LaunchProjectileComponent gun
2808            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
2809        gun.setShotsPerSet(1);
2810        gun.setSetsPerActivation(1);
2811        gun.setDelayBeforeFirstSet(Utils.framesToTime(24, 11));
2812        gun.setObjectTypeToSpawn(GameObjectType.WANDA_SHOT);
2813        gun.setOffsetX(45);
2814        gun.setOffsetY(42);
2815        gun.setRequiredAction(GameObject.ActionType.ATTACK);
2816        gun.setVelocityX(300.0f);
2817        gun.setShootSound(sound.load(R.raw.sound_poing));
2818
2819        object.team = Team.ENEMY;
2820        object.life = 1;
2821
2822        if (flipHorizontal) {
2823            object.facingDirection.x = -1.0f;
2824        }
2825
2826        object.add(gun);
2827        object.add(render);
2828        object.add(sprite);
2829        object.add(bgcollision);
2830        object.add(animation);
2831        object.add(patrol);
2832        object.add(collision);
2833        object.add(hitReact);
2834
2835        addStaticData(GameObjectType.WANDA, object, sprite);
2836
2837
2838        sprite.playAnimation(0);
2839
2840        return object;
2841    }
2842
2843
2844    public GameObject spawnEnemyKyle(float positionX, float positionY, boolean flipHorizontal) {
2845        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
2846
2847
2848
2849        GameObject object = mGameObjectPool.allocate();
2850        object.getPosition().set(positionX, positionY);
2851        object.activationRadius = mAlwaysActive;
2852        object.width = 64;
2853        object.height = 128;
2854
2855        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.KYLE);
2856        if (staticData == null) {
2857            final int staticObjectCount = 9;
2858            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
2859
2860            GameComponent gravity = allocateComponent(GravityComponent.class);
2861            GameComponent movement = allocateComponent(MovementComponent.class);
2862
2863            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
2864            physics.setBounciness(0.0f);
2865
2866            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
2867                new FixedSizeArray<CollisionVolume>(1);
2868            basicVulnerabilityVolume.add(new AABoxCollisionVolume(20, 5, 26, 80, HitType.COLLECT));
2869
2870            SpriteAnimation idle = new SpriteAnimation(NPCAnimationComponent.IDLE, 1);
2871            idle.addFrame(new AnimationFrame(
2872                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_stand),
2873                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
2874
2875            AnimationFrame walkFrame1 = new AnimationFrame(
2876                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_walk01),
2877                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2878            AnimationFrame walkFrame2 = new AnimationFrame(
2879                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_walk02),
2880                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2881            AnimationFrame walkFrame3 = new AnimationFrame(
2882                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_walk03),
2883                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2884            AnimationFrame walkFrame4 = new AnimationFrame(
2885                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_walk04),
2886                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2887            AnimationFrame walkFrame5 = new AnimationFrame(
2888                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_walk05),
2889                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2890            AnimationFrame walkFrame6 = new AnimationFrame(
2891                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_walk06),
2892                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2893            AnimationFrame walkFrame7 = new AnimationFrame(
2894                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_walk07),
2895                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
2896            SpriteAnimation walk = new SpriteAnimation(NPCAnimationComponent.WALK, 12);
2897            walk.addFrame(walkFrame1);
2898            walk.addFrame(walkFrame2);
2899            walk.addFrame(walkFrame3);
2900            walk.addFrame(walkFrame4);
2901            walk.addFrame(walkFrame3);
2902            walk.addFrame(walkFrame2);
2903            walk.addFrame(walkFrame1);
2904            walk.addFrame(walkFrame5);
2905            walk.addFrame(walkFrame6);
2906            walk.addFrame(walkFrame7);
2907            walk.addFrame(walkFrame6);
2908            walk.addFrame(walkFrame5);
2909
2910            walk.setLoop(true);
2911
2912            AnimationFrame crouch1 = new AnimationFrame(
2913                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_crouch01),
2914                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
2915            AnimationFrame crouch2 = new AnimationFrame(
2916                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_crouch02),
2917                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
2918
2919            SpriteAnimation runStart = new SpriteAnimation(NPCAnimationComponent.RUN_START, 2);
2920            runStart.addFrame(crouch1);
2921            runStart.addFrame(crouch2);
2922
2923            FixedSizeArray<CollisionVolume> attackVolume =
2924                new FixedSizeArray<CollisionVolume>(2);
2925            attackVolume.add(new AABoxCollisionVolume(32, 32, 50, 32, HitType.HIT));
2926            attackVolume.add(new AABoxCollisionVolume(32, 32, 50, 32, HitType.COLLECT));
2927
2928            SpriteAnimation run = new SpriteAnimation(NPCAnimationComponent.RUN, 2);
2929            run.addFrame(new AnimationFrame(
2930                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_dash01),
2931                    Utils.framesToTime(24, 1), attackVolume, basicVulnerabilityVolume));
2932            run.addFrame(new AnimationFrame(
2933                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_dash02),
2934                    Utils.framesToTime(24, 1), attackVolume, basicVulnerabilityVolume));
2935            run.setLoop(true);
2936
2937            SpriteAnimation jumpStart = new SpriteAnimation(NPCAnimationComponent.JUMP_START, 2);
2938            jumpStart.addFrame(crouch1);
2939            jumpStart.addFrame(crouch2);
2940
2941            SpriteAnimation jumpAir = new SpriteAnimation(NPCAnimationComponent.JUMP_AIR, 2);
2942            AnimationFrame jump1 = new AnimationFrame(
2943                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_jump01),
2944                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
2945            AnimationFrame jump2 = new AnimationFrame(
2946                    textureLibrary.allocateTexture(R.drawable.enemy_kyle_jump01),
2947                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
2948            jumpAir.addFrame(jump1);
2949            jumpAir.addFrame(jump2);
2950            jumpAir.setLoop(true);
2951
2952
2953
2954            staticData.add(gravity);
2955            staticData.add(movement);
2956            staticData.add(physics);
2957            staticData.add(idle);
2958            staticData.add(walk);
2959            staticData.add(runStart);
2960            staticData.add(run);
2961            staticData.add(jumpStart);
2962            staticData.add(jumpAir);
2963
2964            setStaticData(GameObjectType.KYLE, staticData);
2965        }
2966
2967        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
2968        render.setPriority(SortConstants.NPC);
2969
2970        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
2971        bgcollision.setSize(32, 90);
2972        bgcollision.setOffset(20, 5);
2973
2974        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
2975        sprite.setSize((int)object.width, (int)object.height);
2976        sprite.setRenderComponent(render);
2977
2978        NPCAnimationComponent animation = (NPCAnimationComponent)allocateComponent(NPCAnimationComponent.class);
2979        animation.setSprite(sprite);
2980        animation.setStopAtWalls(false); // Kyle can run through walls
2981
2982        NPCComponent patrol = (NPCComponent)allocateComponent(NPCComponent.class);
2983        patrol.setSpeeds(350.0f, 50.0f, 400.0f, -10.0f, 400.0f);
2984        patrol.setGameEvent(GameFlowEvent.EVENT_SHOW_ANIMATION, AnimationPlayerActivity.KYLE_DEATH, false);
2985
2986        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
2987        sprite.setCollisionComponent(collision);
2988
2989        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
2990        collision.setHitReactionComponent(hitReact);
2991
2992        patrol.setHitReactionComponent(hitReact);
2993
2994        MotionBlurComponent motionBlur = (MotionBlurComponent)allocateComponent(MotionBlurComponent.class);
2995        motionBlur.setTarget(render);
2996
2997        LauncherComponent launcher = (LauncherComponent)allocateComponent(LauncherComponent.class);
2998        launcher.setup((float)(Math.PI * 0.45f), 1000.0f, 0.0f, 0.0f, false);
2999        launcher.setLaunchEffect(GameObjectType.FLASH, 70.0f, 50.0f);
3000        hitReact.setLauncherComponent(launcher, HitType.HIT);
3001
3002        object.team = Team.NONE;
3003        object.life = 1;
3004
3005        if (flipHorizontal) {
3006            object.facingDirection.x = -1.0f;
3007        }
3008
3009        object.add(render);
3010        object.add(sprite);
3011        object.add(bgcollision);
3012        object.add(animation);
3013        object.add(patrol);
3014        object.add(collision);
3015        object.add(hitReact);
3016        object.add(motionBlur);
3017        object.add(launcher);
3018
3019        addStaticData(GameObjectType.KYLE, object, sprite);
3020
3021
3022        sprite.playAnimation(0);
3023
3024        return object;
3025    }
3026
3027    public GameObject spawnEnemyKyleDead(float positionX, float positionY) {
3028        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3029
3030
3031        GameObject object = mGameObjectPool.allocate();
3032        object.getPosition().set(positionX, positionY);
3033        object.activationRadius = mTightActivationRadius;
3034        object.width = 128;
3035        object.height = 32;
3036
3037        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.KYLE_DEAD);
3038        if (staticData == null) {
3039            final int staticObjectCount = 1;
3040            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3041
3042            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
3043                new FixedSizeArray<CollisionVolume>(1);
3044            basicVulnerabilityVolume.add(new AABoxCollisionVolume(32, 5, 64, 32, HitType.COLLECT));
3045
3046            SpriteAnimation idle = new SpriteAnimation(0, 1);
3047            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.enemy_kyle_dead),
3048                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
3049
3050            idle.addFrame(frame1);
3051
3052            idle.setLoop(true);
3053
3054            staticData.add(idle);
3055
3056            setStaticData(GameObjectType.KYLE_DEAD, staticData);
3057        }
3058
3059        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3060        render.setPriority(SortConstants.GENERAL_OBJECT);
3061
3062        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3063        sprite.setSize((int)object.width, (int)object.height);
3064        sprite.setRenderComponent(render);
3065
3066        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3067        sprite.setCollisionComponent(dynamicCollision);
3068
3069        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3070        dynamicCollision.setHitReactionComponent(hitReact);
3071        hitReact.setSpawnGameEventOnHit(HitType.COLLECT, GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER2, 0);
3072
3073        SelectDialogComponent dialogSelect = (SelectDialogComponent)allocateComponent(SelectDialogComponent.class);
3074        dialogSelect.setHitReact(hitReact);
3075
3076        // Since this object doesn't have gravity or background collision, adjust down to simulate the position
3077        // at which a bounding volume would rest.
3078
3079        object.getPosition().y -= 5.0f;
3080
3081        object.add(dialogSelect);
3082        object.add(render);
3083        object.add(sprite);
3084        object.add(dynamicCollision);
3085        object.add(hitReact);
3086
3087        addStaticData(GameObjectType.KYLE_DEAD, object, sprite);
3088        sprite.playAnimation(0);
3089
3090        return object;
3091    }
3092
3093    public GameObject spawnEnemyAndouDead(float positionX, float positionY) {
3094        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3095
3096
3097        GameObject object = mGameObjectPool.allocate();
3098        object.getPosition().set(positionX, positionY);
3099        object.activationRadius = mTightActivationRadius;
3100        object.width = 64;
3101        object.height = 64;
3102
3103        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.ANDOU_DEAD);
3104        if (staticData == null) {
3105            final int staticObjectCount = 1;
3106            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3107
3108            SpriteAnimation idle = new SpriteAnimation(0, 1);
3109            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_explode12),
3110                    Utils.framesToTime(24, 1), null, null);
3111
3112            idle.addFrame(frame1);
3113
3114            idle.setLoop(true);
3115
3116            staticData.add(idle);
3117
3118            setStaticData(GameObjectType.ANDOU_DEAD, staticData);
3119        }
3120
3121        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3122        render.setPriority(SortConstants.GENERAL_OBJECT);
3123
3124        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3125        sprite.setSize((int)object.width, (int)object.height);
3126        sprite.setRenderComponent(render);
3127
3128        LaunchProjectileComponent smokeGun
3129	        = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
3130	    smokeGun.setDelayBetweenShots(0.25f);
3131	    smokeGun.setObjectTypeToSpawn(GameObjectType.SMOKE_BIG);
3132	    smokeGun.setOffsetX(32);
3133	    smokeGun.setOffsetY(15);
3134	    smokeGun.setVelocityX(-150.0f);
3135	    smokeGun.setVelocityY(100.0f);
3136	    smokeGun.setThetaError(0.1f);
3137
3138	    LaunchProjectileComponent smokeGun2
3139	        = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
3140	    smokeGun2.setDelayBetweenShots(0.35f);
3141	    smokeGun2.setObjectTypeToSpawn(GameObjectType.SMOKE_SMALL);
3142	    smokeGun2.setOffsetX(16);
3143	    smokeGun2.setOffsetY(15);
3144	    smokeGun2.setVelocityX(-150.0f);
3145	    smokeGun2.setVelocityY(150.0f);
3146	    smokeGun2.setThetaError(0.1f);
3147
3148        object.add(render);
3149        object.add(sprite);
3150        object.add(smokeGun);
3151        object.add(smokeGun2);
3152
3153        object.facingDirection.x = -1.0f;
3154
3155        addStaticData(GameObjectType.ANDOU_DEAD, object, sprite);
3156        sprite.playAnimation(0);
3157
3158        return object;
3159    }
3160
3161    public GameObject spawnEnemyKabocha(float positionX, float positionY, boolean flipHorizontal) {
3162        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3163
3164
3165        GameObject object = mGameObjectPool.allocate();
3166        object.getPosition().set(positionX, positionY);
3167        object.activationRadius = mAlwaysActive;
3168        object.width = 64;
3169        object.height = 128;
3170
3171        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.KABOCHA);
3172        if (staticData == null) {
3173            final int staticObjectCount = 5;
3174            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3175
3176            GameComponent gravity = allocateComponent(GravityComponent.class);
3177            GameComponent movement = allocateComponent(MovementComponent.class);
3178
3179            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
3180            physics.setBounciness(0.0f);
3181
3182            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
3183                new FixedSizeArray<CollisionVolume>(1);
3184            basicVulnerabilityVolume.add(new AABoxCollisionVolume(20, 5, 26, 80, HitType.COLLECT));
3185
3186            SpriteAnimation idle = new SpriteAnimation(NPCAnimationComponent.IDLE, 1);
3187            idle.addFrame(new AnimationFrame(
3188                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_stand),
3189                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
3190
3191            AnimationFrame walkFrame1 = new AnimationFrame(
3192                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_walk01),
3193                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3194            AnimationFrame walkFrame2 = new AnimationFrame(
3195                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_walk02),
3196                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3197            AnimationFrame walkFrame3 = new AnimationFrame(
3198                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_walk03),
3199                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3200            AnimationFrame walkFrame4 = new AnimationFrame(
3201                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_walk04),
3202                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3203            AnimationFrame walkFrame5 = new AnimationFrame(
3204                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_walk05),
3205                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3206            AnimationFrame walkFrame6 = new AnimationFrame(
3207                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_walk06),
3208                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3209
3210            SpriteAnimation walk = new SpriteAnimation(NPCAnimationComponent.WALK, 6);
3211            walk.addFrame(walkFrame1);
3212            walk.addFrame(walkFrame2);
3213            walk.addFrame(walkFrame3);
3214            walk.addFrame(walkFrame4);
3215            walk.addFrame(walkFrame5);
3216            walk.addFrame(walkFrame6);
3217
3218
3219            walk.setLoop(true);
3220
3221            staticData.add(gravity);
3222            staticData.add(movement);
3223            staticData.add(physics);
3224            staticData.add(idle);
3225            staticData.add(walk);
3226
3227            setStaticData(GameObjectType.KABOCHA, staticData);
3228        }
3229
3230        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3231        render.setPriority(SortConstants.NPC);
3232
3233        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
3234        bgcollision.setSize(38, 82);
3235        bgcollision.setOffset(16, 5);
3236
3237        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3238        sprite.setSize((int)object.width, (int)object.height);
3239        sprite.setRenderComponent(render);
3240
3241        NPCAnimationComponent animation = (NPCAnimationComponent)allocateComponent(NPCAnimationComponent.class);
3242        animation.setSprite(sprite);
3243
3244        NPCComponent patrol = (NPCComponent)allocateComponent(NPCComponent.class);
3245
3246        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3247        sprite.setCollisionComponent(collision);
3248
3249        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3250        collision.setHitReactionComponent(hitReact);
3251
3252        patrol.setHitReactionComponent(hitReact);
3253
3254        object.team = Team.ENEMY;
3255        object.life = 1;
3256
3257        if (flipHorizontal) {
3258            object.facingDirection.x = -1.0f;
3259        }
3260
3261        object.add(render);
3262        object.add(sprite);
3263        object.add(bgcollision);
3264        object.add(animation);
3265        object.add(patrol);
3266        object.add(collision);
3267        object.add(hitReact);
3268
3269        addStaticData(GameObjectType.KABOCHA, object, sprite);
3270
3271
3272        sprite.playAnimation(0);
3273
3274        return object;
3275    }
3276
3277    public GameObject spawnRokudouTerminal(float positionX, float positionY) {
3278        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3279
3280
3281        GameObject object = mGameObjectPool.allocate();
3282        object.getPosition().set(positionX, positionY);
3283        object.activationRadius = mTightActivationRadius;
3284        object.width = 64;
3285        object.height = 64;
3286
3287        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.ROKUDOU_TERMINAL);
3288        if (staticData == null) {
3289            final int staticObjectCount = 1;
3290            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3291
3292            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume = new FixedSizeArray<CollisionVolume>(1);
3293            basicVulnerabilityVolume.add(new AABoxCollisionVolume(0, 0, 64, 64));
3294            basicVulnerabilityVolume.get(0).setHitType(HitType.COLLECT);
3295
3296
3297            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal01),
3298                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
3299            AnimationFrame frame2 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal02),
3300                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
3301            AnimationFrame frame3 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal03),
3302                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
3303            AnimationFrame frame4 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal01),
3304                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
3305            AnimationFrame frame5 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal02),
3306                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
3307            AnimationFrame frame6 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal01),
3308                    1.0f, null, basicVulnerabilityVolume);
3309
3310            SpriteAnimation idle = new SpriteAnimation(0, 12);
3311            idle.addFrame(frame1);
3312            idle.addFrame(frame5);
3313            idle.addFrame(frame4);
3314            idle.addFrame(frame3);
3315            idle.addFrame(frame2);
3316            idle.addFrame(frame6);
3317            idle.addFrame(frame6);
3318            idle.addFrame(frame3);
3319            idle.addFrame(frame2);
3320            idle.addFrame(frame1);
3321            idle.addFrame(frame2);
3322            idle.addFrame(frame6);
3323
3324            idle.setLoop(true);
3325
3326
3327            staticData.add(idle);
3328
3329            setStaticData(GameObjectType.ROKUDOU_TERMINAL, staticData);
3330        }
3331
3332        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3333        render.setPriority(SortConstants.GENERAL_OBJECT);
3334
3335        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3336        sprite.setSize((int)object.width, (int)object.height);
3337        sprite.setRenderComponent(render);
3338
3339        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3340        sprite.setCollisionComponent(dynamicCollision);
3341
3342        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3343        hitReact.setSpawnGameEventOnHit(HitType.COLLECT, GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER2, 0);
3344
3345        SelectDialogComponent dialogSelect = (SelectDialogComponent)allocateComponent(SelectDialogComponent.class);
3346        dialogSelect.setHitReact(hitReact);
3347
3348        dynamicCollision.setHitReactionComponent(hitReact);
3349
3350        object.add(dialogSelect);
3351        object.add(render);
3352        object.add(sprite);
3353        object.add(dynamicCollision);
3354        object.add(hitReact);
3355
3356        addStaticData(GameObjectType.ROKUDOU_TERMINAL, object, sprite);
3357        sprite.playAnimation(0);
3358
3359        return object;
3360    }
3361
3362
3363    public GameObject spawnKabochaTerminal(float positionX, float positionY) {
3364        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3365
3366
3367        GameObject object = mGameObjectPool.allocate();
3368        object.getPosition().set(positionX, positionY);
3369        object.activationRadius = mTightActivationRadius;
3370        object.width = 64;
3371        object.height = 64;
3372
3373        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.KABOCHA_TERMINAL);
3374        if (staticData == null) {
3375            final int staticObjectCount = 1;
3376            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3377
3378            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume = new FixedSizeArray<CollisionVolume>(1);
3379            basicVulnerabilityVolume.add(new AABoxCollisionVolume(0, 0, 64, 64));
3380            basicVulnerabilityVolume.get(0).setHitType(HitType.COLLECT);
3381
3382
3383            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal_kabocha01),
3384                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
3385            AnimationFrame frame2 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal_kabocha02),
3386                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
3387            AnimationFrame frame3 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal_kabocha03),
3388                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
3389            AnimationFrame frame4 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal_kabocha01),
3390                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
3391            AnimationFrame frame5 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal_kabocha02),
3392                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
3393            AnimationFrame frame6 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_terminal_kabocha01),
3394                    1.0f, null, basicVulnerabilityVolume);
3395
3396            SpriteAnimation idle = new SpriteAnimation(0, 12);
3397            idle.addFrame(frame1);
3398            idle.addFrame(frame5);
3399            idle.addFrame(frame4);
3400            idle.addFrame(frame3);
3401            idle.addFrame(frame2);
3402            idle.addFrame(frame6);
3403            idle.addFrame(frame6);
3404            idle.addFrame(frame3);
3405            idle.addFrame(frame2);
3406            idle.addFrame(frame1);
3407            idle.addFrame(frame2);
3408            idle.addFrame(frame6);
3409
3410            idle.setLoop(true);
3411
3412
3413            staticData.add(idle);
3414
3415            setStaticData(GameObjectType.KABOCHA_TERMINAL, staticData);
3416        }
3417
3418        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3419        render.setPriority(SortConstants.GENERAL_OBJECT);
3420
3421        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3422        sprite.setSize((int)object.width, (int)object.height);
3423        sprite.setRenderComponent(render);
3424
3425        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3426        sprite.setCollisionComponent(dynamicCollision);
3427
3428        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3429        hitReact.setSpawnGameEventOnHit(HitType.COLLECT, GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER2, 0);
3430
3431        SelectDialogComponent dialogSelect = (SelectDialogComponent)allocateComponent(SelectDialogComponent.class);
3432        dialogSelect.setHitReact(hitReact);
3433
3434        dynamicCollision.setHitReactionComponent(hitReact);
3435
3436        object.add(dialogSelect);
3437        object.add(render);
3438        object.add(sprite);
3439        object.add(dynamicCollision);
3440        object.add(hitReact);
3441
3442        addStaticData(GameObjectType.KABOCHA_TERMINAL, object, sprite);
3443        sprite.playAnimation(0);
3444
3445        return object;
3446    }
3447
3448    public GameObject spawnEnemyEvilKabocha(float positionX, float positionY, boolean flipHorizontal) {
3449        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3450
3451
3452        GameObject object = mGameObjectPool.allocate();
3453        object.getPosition().set(positionX, positionY);
3454        object.activationRadius = mNormalActivationRadius;
3455        object.width = 128;
3456        object.height = 128;
3457
3458        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.EVIL_KABOCHA);
3459        if (staticData == null) {
3460            final int staticObjectCount = 8;
3461            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3462
3463            GameComponent gravity = allocateComponent(GravityComponent.class);
3464            GameComponent movement = allocateComponent(MovementComponent.class);
3465
3466            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
3467            physics.setBounciness(0.0f);
3468
3469            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
3470                new FixedSizeArray<CollisionVolume>(1);
3471            basicVulnerabilityVolume.add(new AABoxCollisionVolume(52, 5, 26, 80, HitType.HIT));
3472
3473            SpriteAnimation idle = new SpriteAnimation(NPCAnimationComponent.IDLE, 1);
3474            idle.addFrame(new AnimationFrame(
3475                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_stand),
3476                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
3477
3478            AnimationFrame walkFrame1 = new AnimationFrame(
3479                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_walk01),
3480                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3481            AnimationFrame walkFrame2 = new AnimationFrame(
3482                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_walk02),
3483                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3484            AnimationFrame walkFrame3 = new AnimationFrame(
3485                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_walk03),
3486                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3487            AnimationFrame walkFrame4 = new AnimationFrame(
3488                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_walk04),
3489                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3490            AnimationFrame walkFrame5 = new AnimationFrame(
3491                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_walk05),
3492                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3493            AnimationFrame walkFrame6 = new AnimationFrame(
3494                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_walk06),
3495                    Utils.framesToTime(24, 3), null, basicVulnerabilityVolume);
3496
3497            SpriteAnimation walk = new SpriteAnimation(NPCAnimationComponent.WALK, 6);
3498            walk.addFrame(walkFrame1);
3499            walk.addFrame(walkFrame2);
3500            walk.addFrame(walkFrame3);
3501            walk.addFrame(walkFrame4);
3502            walk.addFrame(walkFrame5);
3503            walk.addFrame(walkFrame6);
3504
3505            walk.setLoop(true);
3506
3507
3508            SpriteAnimation surprised = new SpriteAnimation(NPCAnimationComponent.SURPRISED, 1);
3509            surprised.addFrame(new AnimationFrame(
3510                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_surprised),
3511                    4.0f, null, null));
3512
3513
3514            SpriteAnimation hit = new SpriteAnimation(NPCAnimationComponent.TAKE_HIT, 2);
3515            hit.addFrame(new AnimationFrame(
3516                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_hit01),
3517                    Utils.framesToTime(24, 1), null, null));
3518            hit.addFrame(new AnimationFrame(
3519                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_hit02),
3520                    Utils.framesToTime(24, 10), null, null));
3521
3522            SpriteAnimation die = new SpriteAnimation(NPCAnimationComponent.DEATH, 5);
3523            die.addFrame(new AnimationFrame(
3524                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_die01),
3525                    Utils.framesToTime(24, 6), null, null));
3526            die.addFrame(new AnimationFrame(
3527                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_stand),
3528                    Utils.framesToTime(24, 2), null, null));
3529            die.addFrame(new AnimationFrame(
3530                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_die02),
3531                    Utils.framesToTime(24, 2), null, null));
3532            die.addFrame(new AnimationFrame(
3533                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_die03),
3534                    Utils.framesToTime(24, 2), null, null));
3535            die.addFrame(new AnimationFrame(
3536                    textureLibrary.allocateTexture(R.drawable.enemy_kabocha_evil_die04),
3537                    Utils.framesToTime(24, 6), null, null));
3538
3539            staticData.add(gravity);
3540            staticData.add(movement);
3541            staticData.add(physics);
3542            staticData.add(idle);
3543            staticData.add(walk);
3544            staticData.add(surprised);
3545            staticData.add(hit);
3546            staticData.add(die);
3547
3548            setStaticData(GameObjectType.EVIL_KABOCHA, staticData);
3549        }
3550
3551        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3552        render.setPriority(SortConstants.NPC);
3553
3554        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
3555        bgcollision.setSize(38, 82);
3556        bgcollision.setOffset(45, 5);
3557
3558        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3559        sprite.setSize((int)object.width, (int)object.height);
3560        sprite.setRenderComponent(render);
3561
3562        NPCAnimationComponent animation = (NPCAnimationComponent)allocateComponent(NPCAnimationComponent.class);
3563        animation.setSprite(sprite);
3564
3565        ChannelSystem.Channel surpriseChannel = null;
3566        ChannelSystem channelSystem = BaseObject.sSystemRegistry.channelSystem;
3567        surpriseChannel = channelSystem.registerChannel(sSurprisedNPCChannel);
3568        animation.setChannel(surpriseChannel);
3569        animation.setChannelTrigger(NPCAnimationComponent.SURPRISED);
3570
3571        NPCComponent patrol = (NPCComponent)allocateComponent(NPCComponent.class);
3572        patrol.setSpeeds(50.0f, 50.0f, 0.0f, -10.0f, 200.0f);
3573        patrol.setReactToHits(true);
3574        patrol.setGameEvent(GameFlowEvent.EVENT_SHOW_ANIMATION, AnimationPlayerActivity.ROKUDOU_ENDING, true);
3575
3576        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3577        sprite.setCollisionComponent(collision);
3578
3579        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3580        collision.setHitReactionComponent(hitReact);
3581
3582        SoundSystem sound = sSystemRegistry.soundSystem;
3583        if (sound != null) {
3584        	hitReact.setTakeHitSound(HitType.HIT, sound.load(R.raw.sound_kabocha_hit));
3585        }
3586
3587        patrol.setHitReactionComponent(hitReact);
3588
3589        object.team = Team.ENEMY;
3590        object.life = 3;
3591
3592        if (flipHorizontal) {
3593            object.facingDirection.x = -1.0f;
3594        }
3595
3596        object.add(render);
3597        object.add(sprite);
3598        object.add(bgcollision);
3599        object.add(animation);
3600        object.add(patrol);
3601        object.add(collision);
3602        object.add(hitReact);
3603
3604        addStaticData(GameObjectType.EVIL_KABOCHA, object, sprite);
3605
3606
3607        sprite.playAnimation(0);
3608
3609        return object;
3610    }
3611
3612    public GameObject spawnEnemyRokudou(float positionX, float positionY, boolean flipHorizontal) {
3613    	TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3614
3615    	// Make sure related textures are loaded.
3616        textureLibrary.allocateTexture(R.drawable.energy_ball01);
3617        textureLibrary.allocateTexture(R.drawable.energy_ball02);
3618        textureLibrary.allocateTexture(R.drawable.energy_ball03);
3619        textureLibrary.allocateTexture(R.drawable.energy_ball04);
3620
3621        textureLibrary.allocateTexture(R.drawable.effect_bullet01);
3622        textureLibrary.allocateTexture(R.drawable.effect_bullet02);
3623
3624
3625        GameObject object = mGameObjectPool.allocate();
3626        object.getPosition().set(positionX, positionY);
3627        object.activationRadius = mNormalActivationRadius;
3628        object.width = 128;
3629        object.height = 128;
3630
3631        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.ROKUDOU);
3632        if (staticData == null) {
3633            final int staticObjectCount = 8;
3634            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3635
3636            GameComponent movement = allocateComponent(MovementComponent.class);
3637
3638            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
3639            physics.setBounciness(0.0f);
3640
3641            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
3642                new FixedSizeArray<CollisionVolume>(1);
3643            basicVulnerabilityVolume.add(new AABoxCollisionVolume(45, 23, 42, 75, HitType.HIT));
3644
3645            SpriteAnimation idle = new SpriteAnimation(NPCAnimationComponent.IDLE, 1);
3646            idle.addFrame(new AnimationFrame(
3647                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_stand),
3648                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
3649
3650            SpriteAnimation fly = new SpriteAnimation(NPCAnimationComponent.WALK, 2);
3651            fly.addFrame(new AnimationFrame(
3652                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_fly01),
3653                    1.0f, null, basicVulnerabilityVolume));
3654            fly.addFrame(new AnimationFrame(
3655                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_fly02),
3656                    1.0f, null, basicVulnerabilityVolume));
3657            fly.setLoop(true);
3658
3659            SpriteAnimation shoot = new SpriteAnimation(NPCAnimationComponent.SHOOT, 2);
3660            shoot.addFrame(new AnimationFrame(
3661                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_shoot01),
3662                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
3663            shoot.addFrame(new AnimationFrame(
3664                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_shoot02),
3665                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
3666            shoot.setLoop(true);
3667
3668
3669            SpriteAnimation surprised = new SpriteAnimation(NPCAnimationComponent.SURPRISED, 1);
3670            surprised.addFrame(new AnimationFrame(
3671                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_surprise),
3672                    4.0f, null, null));
3673
3674
3675            SpriteAnimation hit = new SpriteAnimation(NPCAnimationComponent.TAKE_HIT, 7);
3676            AnimationFrame hitFrame1 = new AnimationFrame(
3677                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_hit01),
3678                    Utils.framesToTime(24, 2), null, null);
3679            AnimationFrame hitFrame2 = new AnimationFrame(
3680                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_hit02),
3681                    Utils.framesToTime(24, 1), null, null);
3682            AnimationFrame hitFrame3 = new AnimationFrame(
3683                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_hit03),
3684                    Utils.framesToTime(24, 1), null, null);
3685
3686            hit.addFrame(hitFrame1);
3687            hit.addFrame(hitFrame2);
3688            hit.addFrame(hitFrame3);
3689            hit.addFrame(hitFrame2);
3690            hit.addFrame(hitFrame3);
3691            hit.addFrame(hitFrame2);
3692            hit.addFrame(hitFrame3);
3693
3694            SpriteAnimation die = new SpriteAnimation(NPCAnimationComponent.DEATH, 5);
3695            die.addFrame(new AnimationFrame(
3696                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_stand),
3697                    Utils.framesToTime(24, 6), null, null));
3698            die.addFrame(new AnimationFrame(
3699                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_die01),
3700                    Utils.framesToTime(24, 2), null, null));
3701            die.addFrame(new AnimationFrame(
3702                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_die02),
3703                    Utils.framesToTime(24, 4), null, null));
3704            die.addFrame(new AnimationFrame(
3705                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_die03),
3706                    Utils.framesToTime(24, 6), null, null));
3707            die.addFrame(new AnimationFrame(
3708                    textureLibrary.allocateTexture(R.drawable.enemy_rokudou_fight_die04),
3709                    Utils.framesToTime(24, 6), null, null));
3710
3711            staticData.add(movement);
3712            staticData.add(physics);
3713            staticData.add(idle);
3714            staticData.add(fly);
3715            staticData.add(surprised);
3716            staticData.add(hit);
3717            staticData.add(die);
3718            staticData.add(shoot);
3719
3720            setStaticData(GameObjectType.ROKUDOU, staticData);
3721        }
3722
3723        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3724        render.setPriority(SortConstants.NPC);
3725
3726        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
3727        bgcollision.setSize(45, 75);
3728        bgcollision.setOffset(45, 23);
3729
3730        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3731        sprite.setSize((int)object.width, (int)object.height);
3732        sprite.setRenderComponent(render);
3733
3734
3735
3736        NPCAnimationComponent animation = (NPCAnimationComponent)allocateComponent(NPCAnimationComponent.class);
3737        animation.setSprite(sprite);
3738        animation.setFlying(true);
3739
3740        ChannelSystem.Channel surpriseChannel = null;
3741        ChannelSystem channelSystem = BaseObject.sSystemRegistry.channelSystem;
3742        surpriseChannel = channelSystem.registerChannel(sSurprisedNPCChannel);
3743        animation.setChannel(surpriseChannel);
3744        animation.setChannelTrigger(NPCAnimationComponent.SURPRISED);
3745
3746        NPCComponent patrol = (NPCComponent)allocateComponent(NPCComponent.class);
3747        patrol.setSpeeds(500.0f, 100.0f, 100.0f, -100.0f, 400.0f);
3748        patrol.setFlying(true);
3749        patrol.setReactToHits(true);
3750        patrol.setGameEvent(GameFlowEvent.EVENT_SHOW_ANIMATION, AnimationPlayerActivity.KABOCHA_ENDING, true);
3751        patrol.setPauseOnAttack(false);
3752
3753        DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3754        sprite.setCollisionComponent(collision);
3755
3756        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3757        collision.setHitReactionComponent(hitReact);
3758
3759        SoundSystem sound = sSystemRegistry.soundSystem;
3760        if (sound != null) {
3761        	hitReact.setTakeHitSound(HitType.HIT, sound.load(R.raw.sound_rokudou_hit));
3762        }
3763
3764        patrol.setHitReactionComponent(hitReact);
3765
3766        ChangeComponentsComponent deathSwap = (ChangeComponentsComponent)allocateComponent(ChangeComponentsComponent.class);
3767        deathSwap.addSwapInComponent(allocateComponent(GravityComponent.class));
3768        deathSwap.setSwapAction(ActionType.DEATH);
3769
3770        LaunchProjectileComponent gun
3771	        = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
3772	    gun.setShotsPerSet(1);
3773	    gun.setSetsPerActivation(-1);
3774	    gun.setDelayBetweenSets(1.5f);
3775	    gun.setObjectTypeToSpawn(GameObjectType.ENERGY_BALL);
3776	    gun.setOffsetX(75);
3777	    gun.setOffsetY(42);
3778	    gun.setRequiredAction(GameObject.ActionType.ATTACK);
3779	    gun.setVelocityX(300.0f);
3780	    gun.setVelocityY(-300.0f);
3781        gun.setShootSound(sound.load(R.raw.sound_poing));
3782
3783
3784	    LaunchProjectileComponent gun2
3785        = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
3786	    gun2.setShotsPerSet(5);
3787	    gun2.setDelayBetweenShots(0.1f);
3788	    gun2.setSetsPerActivation(-1);
3789	    gun2.setDelayBetweenSets(2.5f);
3790	    gun2.setObjectTypeToSpawn(GameObjectType.TURRET_BULLET);
3791	    gun2.setOffsetX(75);
3792	    gun2.setOffsetY(42);
3793	    gun2.setRequiredAction(GameObject.ActionType.ATTACK);
3794	    gun2.setVelocityX(300.0f);
3795	    gun2.setVelocityY(-300.0f);
3796        gun.setShootSound(sound.load(R.raw.sound_gun));
3797
3798
3799        object.team = Team.ENEMY;
3800        object.life = 3;
3801
3802        if (flipHorizontal) {
3803            object.facingDirection.x = -1.0f;
3804        }
3805
3806        // HACK! Since there's no gravity and this is a big character, align him to the floor
3807        // manually.
3808        object.getPosition().y -= 23;
3809
3810        object.add(render);
3811        object.add(sprite);
3812        object.add(bgcollision);
3813        object.add(animation);
3814        object.add(patrol);
3815        object.add(collision);
3816        object.add(hitReact);
3817        object.add(deathSwap);
3818        object.add(gun);
3819        object.add(gun2);
3820
3821        addStaticData(GameObjectType.ROKUDOU, object, sprite);
3822
3823
3824        sprite.playAnimation(0);
3825
3826        return object;
3827    }
3828
3829
3830    public GameObject spawnPlayerGhost(float positionX, float positionY, GameObject player, float lifeTime) {
3831        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
3832
3833
3834        GameObject object = mGameObjectPool.allocate();
3835        object.getPosition().set(positionX, positionY);
3836        object.activationRadius = mAlwaysActive;
3837        object.width = 64;
3838        object.height = 64;
3839
3840        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.GHOST);
3841        if (staticData == null) {
3842            final int staticObjectCount = 4;
3843            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3844
3845            //GravityComponent gravity = (GravityComponent)allocateComponent(GravityComponent.class);
3846            //gravity.setGravityMultiplier(0.1f);
3847
3848            GameComponent movement = allocateComponent(MovementComponent.class);
3849            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
3850            physics.setBounciness(0.6f);
3851
3852            GhostComponent ghost = (GhostComponent)allocateComponent(GhostComponent.class);
3853            ghost.setMovementSpeed(2000.0f);
3854            ghost.setAcceleration(700.0f);	//300
3855            ghost.setUseOrientationSensor(true);
3856            ghost.setKillOnRelease(true);
3857
3858            SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
3859            if (sound != null) {
3860            	ghost.setAmbientSound(sound.load(R.raw.sound_possession));
3861            }
3862
3863            FixedSizeArray<CollisionVolume> basicAttackVolume =
3864                new FixedSizeArray<CollisionVolume>(1);
3865            basicAttackVolume.add(new SphereCollisionVolume(32, 32, 32, HitType.POSSESS));
3866
3867            SpriteAnimation idle = new SpriteAnimation(0, 4);
3868            idle.addFrame(new AnimationFrame(
3869                    textureLibrary.getTextureByResource(R.drawable.effect_energyball01),
3870                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3871            idle.addFrame(new AnimationFrame(
3872                    textureLibrary.getTextureByResource(R.drawable.effect_energyball02),
3873                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3874            idle.addFrame(new AnimationFrame(
3875                    textureLibrary.getTextureByResource(R.drawable.effect_energyball03),
3876                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3877            idle.addFrame(new AnimationFrame(
3878                    textureLibrary.getTextureByResource(R.drawable.effect_energyball04),
3879                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3880            idle.setLoop(true);
3881
3882            //staticData.add(gravity);
3883            staticData.add(movement);
3884            staticData.add(physics);
3885            staticData.add(ghost);
3886            staticData.add(idle);
3887
3888            setStaticData(GameObjectType.GHOST, staticData);
3889        }
3890
3891        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3892        render.setPriority(SortConstants.PROJECTILE);
3893
3894        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
3895		bgcollision.setSize(64, 64);
3896		bgcollision.setOffset(0, 0);
3897
3898        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3899		sprite.setSize((int)object.width, (int)object.height);
3900        sprite.setRenderComponent(render);
3901
3902
3903        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3904        sprite.setCollisionComponent(dynamicCollision);
3905
3906        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3907        hitReact.setDieOnAttack(true);
3908
3909        dynamicCollision.setHitReactionComponent(hitReact);
3910        LifetimeComponent life = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
3911        // when the ghost dies it either releases itself or passes control to another object, so we
3912        // don't want control to return to the player.
3913
3914        life.setReleaseGhostOnDeath(false);
3915
3916
3917        object.life = 1;
3918
3919        object.add(bgcollision);
3920        object.add(render);
3921        object.add(sprite);
3922        object.add(dynamicCollision);
3923        object.add(hitReact);
3924        object.add(life);
3925
3926        addStaticData(GameObjectType.GHOST, object, sprite);
3927
3928        object.commitUpdates();
3929
3930        GhostComponent ghost = object.findByClass(GhostComponent.class);
3931        if (ghost != null) {
3932            ghost.setLifeTime(lifeTime);
3933        }
3934        sprite.playAnimation(0);
3935
3936        return object;
3937    }
3938
3939    public GameObject spawnEnergyBall(float positionX, float positionY, boolean flipHorizontal) {
3940        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
3941
3942
3943        GameObject object = mGameObjectPool.allocate();
3944        object.getPosition().set(positionX, positionY);
3945        object.activationRadius = mTightActivationRadius;
3946        object.width = 32;
3947        object.height = 32;
3948
3949        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.ENERGY_BALL);
3950        if (staticData == null) {
3951            final int staticObjectCount = 2;
3952            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
3953
3954            GameComponent movement = allocateComponent(MovementComponent.class);
3955
3956            FixedSizeArray<CollisionVolume> basicAttackVolume =
3957                new FixedSizeArray<CollisionVolume>(1);
3958            basicAttackVolume.add(new SphereCollisionVolume(16, 16, 16, HitType.HIT));
3959
3960            SpriteAnimation idle = new SpriteAnimation(0, 4);
3961            idle.addFrame(new AnimationFrame(
3962                    textureLibrary.allocateTexture(R.drawable.energy_ball01),
3963                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3964            idle.addFrame(new AnimationFrame(
3965                    textureLibrary.allocateTexture(R.drawable.energy_ball02),
3966                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3967            idle.addFrame(new AnimationFrame(
3968                    textureLibrary.allocateTexture(R.drawable.energy_ball03),
3969                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3970            idle.addFrame(new AnimationFrame(
3971                    textureLibrary.allocateTexture(R.drawable.energy_ball04),
3972                    Utils.framesToTime(24, 1), basicAttackVolume, null));
3973            idle.setLoop(true);
3974
3975            staticData.add(movement);
3976            staticData.add(idle);
3977
3978            setStaticData(GameObjectType.ENERGY_BALL, staticData);
3979
3980        }
3981
3982        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
3983        render.setPriority(SortConstants.PROJECTILE);
3984
3985        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
3986        lifetime.setTimeUntilDeath(5.0f);
3987
3988        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
3989		sprite.setSize((int)object.width, (int)object.height);
3990        sprite.setRenderComponent(render);
3991
3992        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
3993        sprite.setCollisionComponent(dynamicCollision);
3994
3995        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
3996        hitReact.setDieOnAttack(true);
3997
3998        dynamicCollision.setHitReactionComponent(hitReact);
3999
4000        object.life = 1;
4001        object.team = Team.ENEMY;
4002        object.destroyOnDeactivation = true;
4003
4004        if (flipHorizontal) {
4005            object.facingDirection.x = -1.0f;
4006        }
4007
4008        object.add(lifetime);
4009        object.add(render);
4010        object.add(sprite);
4011        object.add(dynamicCollision);
4012        object.add(hitReact);
4013
4014        addStaticData(GameObjectType.ENERGY_BALL, object, sprite);
4015
4016        sprite.playAnimation(0);
4017
4018        return object;
4019    }
4020
4021    public GameObject spawnWandaShot(float positionX, float positionY, boolean flipHorizontal) {
4022        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4023
4024
4025        GameObject object = mGameObjectPool.allocate();
4026        object.getPosition().set(positionX, positionY);
4027        object.activationRadius = mTightActivationRadius;
4028        object.width = 32;
4029        object.height = 32;
4030
4031        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.WANDA_SHOT);
4032        if (staticData == null) {
4033            final int staticObjectCount = 2;
4034            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4035
4036            GameComponent movement = allocateComponent(MovementComponent.class);
4037
4038            FixedSizeArray<CollisionVolume> basicAttackVolume =
4039                new FixedSizeArray<CollisionVolume>(1);
4040            basicAttackVolume.add(new SphereCollisionVolume(16, 16, 16, HitType.HIT));
4041
4042            SpriteAnimation idle = new SpriteAnimation(0, 4);
4043            idle.addFrame(new AnimationFrame(
4044                    textureLibrary.allocateTexture(R.drawable.energy_ball01),
4045                    Utils.framesToTime(24, 1), basicAttackVolume, null));
4046            idle.addFrame(new AnimationFrame(
4047                    textureLibrary.allocateTexture(R.drawable.energy_ball02),
4048                    Utils.framesToTime(24, 1), basicAttackVolume, null));
4049            idle.addFrame(new AnimationFrame(
4050                    textureLibrary.allocateTexture(R.drawable.energy_ball03),
4051                    Utils.framesToTime(24, 1), basicAttackVolume, null));
4052            idle.addFrame(new AnimationFrame(
4053                    textureLibrary.allocateTexture(R.drawable.energy_ball04),
4054                    Utils.framesToTime(24, 1), basicAttackVolume, null));
4055            idle.setLoop(true);
4056
4057            staticData.add(movement);
4058            staticData.add(idle);
4059
4060            setStaticData(GameObjectType.WANDA_SHOT, staticData);
4061
4062        }
4063
4064        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4065        render.setPriority(SortConstants.PROJECTILE);
4066
4067        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
4068        lifetime.setTimeUntilDeath(5.0f);
4069
4070        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4071		sprite.setSize((int)object.width, (int)object.height);
4072        sprite.setRenderComponent(render);
4073
4074        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4075        sprite.setCollisionComponent(dynamicCollision);
4076
4077        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4078        //hitReact.setDieOnAttack(true);
4079
4080        dynamicCollision.setHitReactionComponent(hitReact);
4081
4082        object.life = 1;
4083        object.team = Team.NONE;
4084        object.destroyOnDeactivation = true;
4085
4086        if (flipHorizontal) {
4087            object.facingDirection.x = -1.0f;
4088        }
4089
4090        object.add(lifetime);
4091        object.add(render);
4092        object.add(sprite);
4093        object.add(dynamicCollision);
4094        object.add(hitReact);
4095
4096        addStaticData(GameObjectType.WANDA_SHOT, object, sprite);
4097
4098        sprite.playAnimation(0);
4099
4100        return object;
4101    }
4102
4103    public GameObject spawnCannonBall(float positionX, float positionY, boolean flipHorizontal) {
4104        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4105
4106
4107        GameObject object = mGameObjectPool.allocate();
4108        object.getPosition().set(positionX, positionY);
4109        object.activationRadius = mTightActivationRadius;
4110        object.width = 32;
4111        object.height = 32;
4112
4113        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.CANNON_BALL);
4114        if (staticData == null) {
4115            final int staticObjectCount = 2;
4116            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4117
4118            GameComponent movement = allocateComponent(MovementComponent.class);
4119
4120            FixedSizeArray<CollisionVolume> basicAttackVolume =
4121                new FixedSizeArray<CollisionVolume>(1);
4122            basicAttackVolume.add(new SphereCollisionVolume(8, 16, 16, HitType.HIT));
4123
4124            SpriteAnimation idle = new SpriteAnimation(0, 1);
4125            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.snail_bomb),
4126                    Utils.framesToTime(24, 1), basicAttackVolume, null));
4127
4128            staticData.add(movement);
4129            staticData.add(idle);
4130
4131            setStaticData(GameObjectType.CANNON_BALL, staticData);
4132        }
4133
4134        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4135        render.setPriority(SortConstants.PROJECTILE);
4136
4137        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
4138        lifetime.setTimeUntilDeath(3.0f);
4139        lifetime.setDieOnHitBackground(true);
4140
4141        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4142		sprite.setSize((int)object.width, (int)object.height);
4143        sprite.setRenderComponent(render);
4144
4145        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4146        sprite.setCollisionComponent(dynamicCollision);
4147
4148        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4149        hitReact.setDieOnAttack(true);
4150
4151        dynamicCollision.setHitReactionComponent(hitReact);
4152
4153        SimpleCollisionComponent collision = (SimpleCollisionComponent)allocateComponent(SimpleCollisionComponent.class);
4154
4155
4156        object.life = 1;
4157        object.team = Team.ENEMY;
4158        object.destroyOnDeactivation = true;
4159
4160        if (flipHorizontal) {
4161            object.facingDirection.x = -1.0f;
4162        }
4163
4164        object.add(lifetime);
4165        object.add(render);
4166        object.add(sprite);
4167        object.add(dynamicCollision);
4168        object.add(hitReact);
4169        object.add(collision);
4170
4171        addStaticData(GameObjectType.CANNON_BALL, object, sprite);
4172
4173        sprite.playAnimation(0);
4174
4175        return object;
4176    }
4177
4178    public GameObject spawnTurretBullet(float positionX, float positionY, boolean flipHorizontal) {
4179        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4180
4181
4182        GameObject object = mGameObjectPool.allocate();
4183        object.getPosition().set(positionX, positionY);
4184        object.activationRadius = mTightActivationRadius;
4185        object.width = 16;
4186        object.height = 16;
4187
4188        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.TURRET_BULLET);
4189        if (staticData == null) {
4190            final int staticObjectCount = 2;
4191            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4192
4193            GameComponent movement = allocateComponent(MovementComponent.class);
4194
4195            FixedSizeArray<CollisionVolume> basicAttackVolume =
4196                new FixedSizeArray<CollisionVolume>(1);
4197            basicAttackVolume.add(new SphereCollisionVolume(8, 8, 8, HitType.HIT));
4198
4199            SpriteAnimation idle = new SpriteAnimation(0, 2);
4200            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.effect_bullet01),
4201                    Utils.framesToTime(24, 1), basicAttackVolume, null));
4202            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.effect_bullet02),
4203                    Utils.framesToTime(24, 1), basicAttackVolume, null));
4204            idle.setLoop(true);
4205
4206            staticData.add(movement);
4207            staticData.add(idle);
4208
4209            setStaticData(GameObjectType.TURRET_BULLET, staticData);
4210        }
4211
4212        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4213        render.setPriority(SortConstants.PROJECTILE);
4214
4215        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
4216        lifetime.setTimeUntilDeath(3.0f);
4217
4218        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4219        sprite.setSize((int)object.width, (int)object.height);
4220        sprite.setRenderComponent(render);
4221
4222        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4223        sprite.setCollisionComponent(dynamicCollision);
4224
4225        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4226        hitReact.setDieOnAttack(true);
4227
4228        dynamicCollision.setHitReactionComponent(hitReact);
4229
4230
4231        object.life = 1;
4232        object.team = Team.ENEMY;
4233        object.destroyOnDeactivation = true;
4234
4235        if (flipHorizontal) {
4236            object.facingDirection.x = -1.0f;
4237        }
4238
4239        object.add(lifetime);
4240        object.add(render);
4241        object.add(sprite);
4242        object.add(dynamicCollision);
4243        object.add(hitReact);
4244
4245        addStaticData(GameObjectType.TURRET_BULLET, object, sprite);
4246
4247        sprite.playAnimation(0);
4248
4249        return object;
4250    }
4251
4252    public GameObject spawnBrobotBullet(float positionX, float positionY, boolean flipHorizontal) {
4253        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4254
4255
4256        GameObject object = mGameObjectPool.allocate();
4257        object.getPosition().set(positionX, positionY);
4258        object.activationRadius = mTightActivationRadius;
4259        object.width = 64;
4260        object.height = 64;
4261
4262        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.BROBOT_BULLET);
4263        if (staticData == null) {
4264            final int staticObjectCount = 2;
4265            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4266
4267            GameComponent movement = allocateComponent(MovementComponent.class);
4268
4269            SpriteAnimation idle = new SpriteAnimation(0, 3);
4270            idle.addFrame(new AnimationFrame(
4271                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk01),
4272                    Utils.framesToTime(24, 1), null, null));
4273            idle.addFrame(new AnimationFrame(
4274                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk02),
4275                    Utils.framesToTime(24, 1), null, null));
4276            idle.addFrame(new AnimationFrame(
4277                    textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk03),
4278                    Utils.framesToTime(24, 1), null, null));
4279            idle.setLoop(true);
4280
4281            staticData.add(movement);
4282            staticData.add(idle);
4283
4284            setStaticData(GameObjectType.BROBOT_BULLET, staticData);
4285        }
4286
4287        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4288        render.setPriority(SortConstants.PROJECTILE);
4289
4290        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
4291        lifetime.setTimeUntilDeath(3.0f);
4292
4293        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4294        sprite.setSize((int)object.width, (int)object.height);
4295        sprite.setRenderComponent(render);
4296
4297        object.life = 1;
4298        object.team = Team.ENEMY;
4299        object.destroyOnDeactivation = true;
4300
4301        if (flipHorizontal) {
4302            object.facingDirection.x = -1.0f;
4303        }
4304
4305        object.add(lifetime);
4306        object.add(render);
4307        object.add(sprite);
4308
4309
4310        addStaticData(GameObjectType.BROBOT_BULLET, object, sprite);
4311
4312        sprite.playAnimation(0);
4313
4314        return object;
4315    }
4316
4317    public GameObject spawnCoin(float positionX, float positionY) {
4318        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4319
4320
4321        GameObject object = mGameObjectPool.allocate();
4322        object.getPosition().set(positionX, positionY);
4323        object.activationRadius = mTightActivationRadius;
4324        object.width = 16;
4325        object.height = 16;
4326
4327        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.COIN);
4328        if (staticData == null) {
4329            final int staticObjectCount = 2;
4330            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4331
4332            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume = null; /*new FixedSizeArray<CollisionVolume>(1);
4333            basicVulnerabilityVolume.add(new SphereCollisionVolume(8, 8, 8));
4334            basicVulnerabilityVolume.get(0).setHitType(HitType.COLLECT);*/
4335
4336            SpriteAnimation idle = new SpriteAnimation(0, 5);
4337            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_coin01),
4338                    Utils.framesToTime(24, 30), null, basicVulnerabilityVolume));
4339            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_coin02),
4340                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4341            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_coin03),
4342                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4343            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_coin04),
4344                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
4345            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_coin05),
4346                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4347            idle.setLoop(true);
4348
4349            InventoryComponent.UpdateRecord addCoin = new InventoryComponent.UpdateRecord();
4350            addCoin.coinCount = 1;
4351
4352            staticData.add(addCoin);
4353            staticData.add(idle);
4354
4355            setStaticData(GameObjectType.COIN, staticData);
4356        }
4357
4358        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4359        render.setPriority(SortConstants.GENERAL_OBJECT);
4360
4361        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4362		sprite.setSize((int)object.width, (int)object.height);
4363        sprite.setRenderComponent(render);
4364
4365        //DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4366        //sprite.setCollisionComponent(dynamicCollision);
4367
4368        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4369        hitReact.setDieWhenCollected(true);
4370        hitReact.setInvincible(true);
4371
4372        HitPlayerComponent hitPlayer = (HitPlayerComponent)allocateComponent(HitPlayerComponent.class);
4373        hitPlayer.setup(32, hitReact, HitType.COLLECT, false);
4374
4375        SoundSystem sound = sSystemRegistry.soundSystem;
4376        if (sound != null) {
4377            hitReact.setTakeHitSound(HitType.COLLECT, sound.load(R.raw.ding));
4378        }
4379
4380        // TODO: this is pretty dumb.  The static data binding needs to be made generic.
4381        final int staticDataSize = staticData.getCount();
4382        for (int x = 0; x < staticDataSize; x++) {
4383            final BaseObject entry = staticData.get(x);
4384            if (entry instanceof InventoryComponent.UpdateRecord) {
4385                hitReact.setInventoryUpdate((InventoryComponent.UpdateRecord)entry);
4386                break;
4387            }
4388        }
4389
4390        //dynamicCollision.setHitReactionComponent(hitReact);
4391
4392        LifetimeComponent life = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
4393        life.setIncrementEventCounter(EventRecorder.COUNTER_PEARLS_COLLECTED);
4394
4395        object.life = 1;
4396
4397        object.add(render);
4398        object.add(sprite);
4399        //object.add(dynamicCollision);
4400        object.add(hitPlayer);
4401        object.add(hitReact);
4402        object.add(life);
4403
4404        addStaticData(GameObjectType.COIN, object, sprite);
4405        sprite.playAnimation(0);
4406
4407        EventRecorder recorder = sSystemRegistry.eventRecorder;
4408        recorder.incrementEventCounter(EventRecorder.COUNTER_PEARLS_TOTAL);
4409
4410        return object;
4411    }
4412
4413    public GameObject spawnRuby(float positionX, float positionY) {
4414        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4415
4416
4417        GameObject object = mGameObjectPool.allocate();
4418        object.getPosition().set(positionX, positionY);
4419        object.activationRadius = mTightActivationRadius;
4420        object.width = 32;
4421        object.height = 32;
4422
4423        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.RUBY);
4424        if (staticData == null) {
4425            final int staticObjectCount = 2;
4426            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4427
4428            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume = new FixedSizeArray<CollisionVolume>(1);
4429            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 16, 16));
4430            basicVulnerabilityVolume.get(0).setHitType(HitType.COLLECT);
4431
4432            SpriteAnimation idle = new SpriteAnimation(0, 5);
4433            idle.addFrame(new AnimationFrame(
4434                    textureLibrary.allocateTexture(R.drawable.object_ruby01),
4435                    2.0f, null, basicVulnerabilityVolume));
4436            idle.addFrame(new AnimationFrame(
4437                    textureLibrary.allocateTexture(R.drawable.object_ruby02),
4438                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4439            idle.addFrame(new AnimationFrame(
4440                    textureLibrary.allocateTexture(R.drawable.object_ruby03),
4441                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
4442            idle.addFrame(new AnimationFrame(
4443                    textureLibrary.allocateTexture(R.drawable.object_ruby04),
4444                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
4445            idle.addFrame(new AnimationFrame(
4446                    textureLibrary.allocateTexture(R.drawable.object_ruby05),
4447                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4448            idle.setLoop(true);
4449
4450            InventoryComponent.UpdateRecord addRuby = new InventoryComponent.UpdateRecord();
4451            addRuby.rubyCount = 1;
4452
4453            staticData.add(addRuby);
4454
4455            staticData.add(idle);
4456            setStaticData(GameObjectType.RUBY, staticData);
4457        }
4458
4459        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4460        render.setPriority(SortConstants.GENERAL_OBJECT);
4461
4462        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4463		sprite.setSize((int)object.width, (int)object.height);
4464        sprite.setRenderComponent(render);
4465
4466        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4467        sprite.setCollisionComponent(dynamicCollision);
4468
4469        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4470        hitReact.setDieWhenCollected(true);
4471        hitReact.setInvincible(true);
4472        // TODO: this is pretty dumb.  The static data binding needs to be made generic.
4473        final int staticDataSize = staticData.getCount();
4474        for (int x = 0; x < staticDataSize; x++) {
4475            final BaseObject entry = staticData.get(x);
4476            if (entry instanceof InventoryComponent.UpdateRecord) {
4477                hitReact.setInventoryUpdate((InventoryComponent.UpdateRecord)entry);
4478                break;
4479            }
4480        }
4481
4482        dynamicCollision.setHitReactionComponent(hitReact);
4483
4484        LifetimeComponent life = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
4485        life.setObjectToSpawnOnDeath(GameObjectType.GEM_EFFECT_SPAWNER);
4486
4487        object.life = 1;
4488
4489        object.add(render);
4490        object.add(sprite);
4491        object.add(dynamicCollision);
4492        object.add(hitReact);
4493        object.add(life);
4494
4495        addStaticData(GameObjectType.RUBY, object, sprite);
4496
4497        sprite.playAnimation(0);
4498
4499        return object;
4500    }
4501
4502    public GameObject spawnDiary(float positionX, float positionY) {
4503        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4504
4505        LevelSystem level = sSystemRegistry.levelSystem;
4506        if (level != null) {
4507        	final LevelTree.Level currentLevel = level.getCurrentLevel();
4508        	if (currentLevel != null && currentLevel.diaryCollected) {
4509        		return null;
4510        	}
4511        }
4512
4513        GameObject object = mGameObjectPool.allocate();
4514        object.getPosition().set(positionX, positionY);
4515        object.activationRadius = mTightActivationRadius;
4516        object.width = 32;
4517        object.height = 32;
4518
4519        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.DIARY);
4520        if (staticData == null) {
4521            final int staticObjectCount = 2;
4522            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4523
4524            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume = new FixedSizeArray<CollisionVolume>(1);
4525            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 16, 16));
4526            basicVulnerabilityVolume.get(0).setHitType(HitType.COLLECT);
4527
4528            SpriteAnimation idle = new SpriteAnimation(0, 8);
4529            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_diary01),
4530                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
4531            AnimationFrame frame2 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_diary02),
4532                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume);
4533
4534            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_diary01),
4535                    1.0f, null, basicVulnerabilityVolume));
4536            idle.addFrame(frame2);
4537            idle.addFrame(frame1);
4538            idle.addFrame(frame2);
4539            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_diary03),
4540                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4541            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_diary04),
4542                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4543            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_diary05),
4544                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4545            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_diary06),
4546                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
4547
4548            idle.setLoop(true);
4549
4550            InventoryComponent.UpdateRecord addDiary = new InventoryComponent.UpdateRecord();
4551            addDiary.diaryCount = 1;
4552
4553            staticData.add(addDiary);
4554
4555            staticData.add(idle);
4556
4557            setStaticData(GameObjectType.DIARY, staticData);
4558        }
4559
4560        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4561        render.setPriority(SortConstants.GENERAL_OBJECT);
4562
4563        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4564        sprite.setSize((int)object.width, (int)object.height);
4565        sprite.setRenderComponent(render);
4566
4567        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4568        sprite.setCollisionComponent(dynamicCollision);
4569
4570        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4571        hitReact.setDieWhenCollected(true);
4572        hitReact.setInvincible(true);
4573        hitReact.setSpawnGameEventOnHit(CollisionParameters.HitType.COLLECT,
4574                GameFlowEvent.EVENT_SHOW_DIARY, 0);
4575        // TODO: this is pretty dumb.  The static data binding needs to be made generic.
4576        final int staticDataSize = staticData.getCount();
4577        for (int x = 0; x < staticDataSize; x++) {
4578            final BaseObject entry = staticData.get(x);
4579            if (entry instanceof InventoryComponent.UpdateRecord) {
4580                hitReact.setInventoryUpdate((InventoryComponent.UpdateRecord)entry);
4581                break;
4582            }
4583        }
4584
4585        dynamicCollision.setHitReactionComponent(hitReact);
4586
4587        LifetimeComponent life = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
4588
4589        object.life = 1;
4590
4591        object.add(render);
4592        object.add(sprite);
4593        object.add(dynamicCollision);
4594        object.add(hitReact);
4595        object.add(life);
4596
4597        addStaticData(GameObjectType.DIARY, object, sprite);
4598        sprite.playAnimation(0);
4599
4600        return object;
4601    }
4602
4603    public GameObject spawnObjectDoor(float positionX, float positionY, GameObjectType type, boolean solid) {
4604        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4605
4606        GameObject object = mGameObjectPool.allocate();
4607        object.getPosition().set(positionX, positionY);
4608        object.activationRadius = mTightActivationRadius;
4609        object.width = 32;
4610        object.height = 64;
4611
4612        FixedSizeArray<BaseObject> staticData = getStaticData(type);
4613        if (staticData == null) {
4614            final int staticObjectCount = 5;
4615            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4616
4617            final int red_frames[] = {
4618                    R.drawable.object_door_red01,
4619                    R.drawable.object_door_red02,
4620                    R.drawable.object_door_red03,
4621                    R.drawable.object_door_red04,
4622            };
4623
4624            final int blue_frames[] = {
4625                    R.drawable.object_door_blue01,
4626                    R.drawable.object_door_blue02,
4627                    R.drawable.object_door_blue03,
4628                    R.drawable.object_door_blue04,
4629            };
4630
4631            final int green_frames[] = {
4632                    R.drawable.object_door_green01,
4633                    R.drawable.object_door_green02,
4634                    R.drawable.object_door_green03,
4635                    R.drawable.object_door_green04,
4636            };
4637
4638            int frames[] = red_frames;
4639
4640            if (type == GameObjectType.DOOR_GREEN) {
4641                frames = green_frames;
4642            } else if (type == GameObjectType.DOOR_BLUE) {
4643                frames = blue_frames;
4644            }
4645
4646            FixedSizeArray<CollisionVolume> vulnerabilityVolume = null;
4647
4648            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(frames[0]),
4649                    Utils.framesToTime(24, 1), null, vulnerabilityVolume);
4650            AnimationFrame frame2 = new AnimationFrame(textureLibrary.allocateTexture(frames[1]),
4651                    Utils.framesToTime(24, 2));
4652            AnimationFrame frame3 = new AnimationFrame(textureLibrary.allocateTexture(frames[2]),
4653                    Utils.framesToTime(24, 2));
4654            AnimationFrame frame4 = new AnimationFrame(textureLibrary.allocateTexture(frames[3]),
4655                    Utils.framesToTime(24, 1));
4656
4657            // one frame of closing is deadly
4658
4659            FixedSizeArray<CollisionVolume> attackVolume =
4660                new FixedSizeArray<CollisionVolume>(1);
4661            attackVolume.add(new AABoxCollisionVolume(12, 8, 8, 56));
4662            attackVolume.get(0).setHitType(HitType.DEATH);
4663
4664
4665
4666            AnimationFrame closeFrame2 = new AnimationFrame(textureLibrary.allocateTexture(frames[1]),
4667                    Utils.framesToTime(24, 2), attackVolume, vulnerabilityVolume);
4668
4669            SpriteAnimation idle_closed = new SpriteAnimation(DoorAnimationComponent.Animation.CLOSED, 1);
4670            idle_closed.addFrame(frame1);
4671
4672            SpriteAnimation idle_open = new SpriteAnimation(DoorAnimationComponent.Animation.OPEN, 1);
4673            idle_open.addFrame(frame4);
4674
4675            SpriteAnimation open = new SpriteAnimation(DoorAnimationComponent.Animation.OPENING, 2);
4676            open.addFrame(frame2);
4677            open.addFrame(frame3);
4678
4679            SpriteAnimation close = new SpriteAnimation(DoorAnimationComponent.Animation.CLOSING, 2);
4680            close.addFrame(frame3);
4681            close.addFrame(closeFrame2);
4682
4683            SolidSurfaceComponent solidSurface
4684                = (SolidSurfaceComponent)allocateComponent(SolidSurfaceComponent.class);
4685            solidSurface.inititalize(4);
4686            // box shape:
4687            // ___       ___1
4688            // | |      2| |3
4689            // ---       ---4
4690            Vector2 surface1Start = new Vector2(0, object.height);
4691            Vector2 surface1End = new Vector2(object.width, object.height);
4692            Vector2 surface1Normal = new Vector2(0.0f, -1.0f);
4693            surface1Normal.normalize();
4694
4695            Vector2 surface2Start = new Vector2(0, object.height);
4696            Vector2 surface2End = new Vector2(0, 0);
4697            Vector2 surface2Normal = new Vector2(-1.0f, 0.0f);
4698            surface2Normal.normalize();
4699
4700            Vector2 surface3Start = new Vector2(object.width, object.height);
4701            Vector2 surface3End = new Vector2(object.width, 0);
4702            Vector2 surface3Normal = new Vector2(1.0f, 0);
4703
4704            Vector2 surface4Start = new Vector2(0, 0);
4705            Vector2 surface4End = new Vector2(object.width, 0);
4706            Vector2 surface4Normal = new Vector2(0, 1.0f);
4707
4708            solidSurface.addSurface(surface1Start, surface1End, surface1Normal);
4709            solidSurface.addSurface(surface2Start, surface2End, surface2Normal);
4710            solidSurface.addSurface(surface3Start, surface3End, surface3Normal);
4711            solidSurface.addSurface(surface4Start, surface4End, surface4Normal);
4712
4713            staticData.add(idle_open);
4714            staticData.add(idle_closed);
4715            staticData.add(open);
4716            staticData.add(close);
4717            staticData.add(solidSurface);
4718            setStaticData(type, staticData);
4719        }
4720
4721
4722        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4723        render.setPriority(SortConstants.FOREGROUND_OBJECT);
4724
4725        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4726        sprite.setSize((int)object.width, (int)object.height);
4727        sprite.setRenderComponent(render);
4728
4729        DoorAnimationComponent doorAnim = (DoorAnimationComponent)allocateComponent(DoorAnimationComponent.class);
4730        doorAnim.setSprite(sprite);
4731
4732        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
4733        if (sound != null) {
4734        	doorAnim.setSounds(sound.load(R.raw.sound_open), sound.load(R.raw.sound_close));
4735        }
4736
4737        ChannelSystem.Channel doorChannel = null;
4738        ChannelSystem channelSystem = BaseObject.sSystemRegistry.channelSystem;
4739        switch (type) {
4740            case DOOR_RED:
4741                doorChannel = channelSystem.registerChannel(sRedButtonChannel);
4742                break;
4743            case DOOR_BLUE:
4744                doorChannel = channelSystem.registerChannel(sBlueButtonChannel);
4745                break;
4746            case DOOR_GREEN:
4747                doorChannel = channelSystem.registerChannel(sGreenButtonChannel);
4748                break;
4749        }
4750        doorAnim.setChannel(doorChannel);
4751
4752        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4753        sprite.setCollisionComponent(dynamicCollision);
4754
4755        HitReactionComponent hitReact
4756            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4757        dynamicCollision.setHitReactionComponent(hitReact);
4758
4759
4760
4761        object.add(render);
4762        object.add(sprite);
4763        object.add(doorAnim);
4764        object.add(dynamicCollision);
4765        object.add(hitReact);
4766        addStaticData(type, object, sprite);
4767
4768        object.commitUpdates();
4769
4770        SolidSurfaceComponent solidSurface = object.findByClass(SolidSurfaceComponent.class);
4771        if (solid) {
4772            doorAnim.setSolidSurface(solidSurface);
4773        } else {
4774            object.remove(solidSurface);
4775            object.commitUpdates();
4776        }
4777
4778
4779        sprite.playAnimation(0);
4780
4781        return object;
4782    }
4783
4784    public GameObject spawnObjectButton(float positionX, float positionY, GameObjectType type) {
4785        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4786
4787        GameObject object = mGameObjectPool.allocate();
4788        object.getPosition().set(positionX, positionY);
4789        object.activationRadius = mTightActivationRadius;
4790        object.width = 32;
4791        object.height = 32;
4792
4793        FixedSizeArray<BaseObject> staticData = getStaticData(type);
4794        if (staticData == null) {
4795            final int staticObjectCount = 2;
4796            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4797
4798            final int red_frames[] = {
4799                    R.drawable.object_button_red,
4800                    R.drawable.object_button_pressed_red,
4801            };
4802
4803            final int blue_frames[] = {
4804                    R.drawable.object_button_blue,
4805                    R.drawable.object_button_pressed_blue,
4806            };
4807
4808            final int green_frames[] = {
4809                    R.drawable.object_button_green,
4810                    R.drawable.object_button_pressed_green,
4811            };
4812
4813            int frames[] = red_frames;
4814
4815            if (type == GameObjectType.BUTTON_GREEN) {
4816                frames = green_frames;
4817            } else if (type == GameObjectType.BUTTON_BLUE) {
4818                frames = blue_frames;
4819            }
4820
4821            FixedSizeArray<CollisionVolume> vulnerabilityVolume =
4822                new FixedSizeArray<CollisionVolume>(1);
4823            vulnerabilityVolume.add(new AABoxCollisionVolume(0, 0, 32, 16));
4824            vulnerabilityVolume.get(0).setHitType(HitType.DEPRESS);
4825
4826            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(frames[0]),
4827                    Utils.framesToTime(24, 1), null, vulnerabilityVolume);
4828            AnimationFrame frame2 = new AnimationFrame(textureLibrary.allocateTexture(frames[1]),
4829                    Utils.framesToTime(24, 1), null, vulnerabilityVolume);
4830
4831            SpriteAnimation idle = new SpriteAnimation(ButtonAnimationComponent.Animation.UP, 1);
4832            idle.addFrame(frame1);
4833
4834            SpriteAnimation pressed = new SpriteAnimation(ButtonAnimationComponent.Animation.DOWN, 1);
4835            pressed.addFrame(frame2);
4836
4837            staticData.add(idle);
4838            staticData.add(pressed);
4839
4840            setStaticData(type, staticData);
4841        }
4842
4843
4844        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4845        render.setPriority(SortConstants.GENERAL_OBJECT);
4846
4847        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4848        sprite.setSize((int)object.width, (int)object.height);
4849        sprite.setRenderComponent(render);
4850
4851        ButtonAnimationComponent button = (ButtonAnimationComponent)allocateComponent(ButtonAnimationComponent.class);
4852        button.setSprite(sprite);
4853
4854        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
4855        if (sound != null) {
4856        	button.setDepressSound(sound.load(R.raw.sound_button));
4857        }
4858
4859        ChannelSystem.Channel buttonChannel = null;
4860        ChannelSystem channelSystem = BaseObject.sSystemRegistry.channelSystem;
4861        switch (type) {
4862            case BUTTON_RED:
4863                buttonChannel = channelSystem.registerChannel(sRedButtonChannel);
4864                break;
4865            case BUTTON_BLUE:
4866                buttonChannel = channelSystem.registerChannel(sBlueButtonChannel);
4867                break;
4868            case BUTTON_GREEN:
4869                buttonChannel = channelSystem.registerChannel(sGreenButtonChannel);
4870                break;
4871        }
4872        button.setChannel(buttonChannel);
4873
4874        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4875        sprite.setCollisionComponent(dynamicCollision);
4876
4877        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4878        hitReact.setInvincible(false);
4879
4880
4881
4882        dynamicCollision.setHitReactionComponent(hitReact);
4883
4884        object.team = Team.NONE;
4885
4886        object.add(render);
4887        object.add(sprite);
4888        object.add(button);
4889        object.add(dynamicCollision);
4890        object.add(hitReact);
4891
4892        addStaticData(type, object, sprite);
4893
4894        sprite.playAnimation(0);
4895
4896        return object;
4897    }
4898
4899    public GameObject spawnObjectCannon(float positionX, float positionY) {
4900        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4901
4902        GameObject object = mGameObjectPool.allocate();
4903        object.getPosition().set(positionX, positionY);
4904        object.activationRadius = mTightActivationRadius;
4905        object.width = 64;
4906        object.height = 128;
4907
4908        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.CANNON);
4909        if (staticData == null) {
4910            final int staticObjectCount = 2;
4911            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
4912
4913            FixedSizeArray<CollisionVolume> attackVolume =
4914                new FixedSizeArray<CollisionVolume>(1);
4915            attackVolume.add(new AABoxCollisionVolume(16, 16, 32, 80));
4916            attackVolume.get(0).setHitType(HitType.LAUNCH);
4917
4918            AnimationFrame frame1 = new AnimationFrame(
4919                    textureLibrary.allocateTexture(R.drawable.object_cannon),
4920                    1.0f, attackVolume, null);
4921
4922            SpriteAnimation idle = new SpriteAnimation(GenericAnimationComponent.Animation.IDLE, 1);
4923            idle.addFrame(frame1);
4924
4925            AnimationFrame frame1NoAttack = new AnimationFrame(
4926                    textureLibrary.allocateTexture(R.drawable.object_cannon),
4927                    1.0f, null, null);
4928
4929            SpriteAnimation shoot = new SpriteAnimation(GenericAnimationComponent.Animation.ATTACK, 1);
4930            shoot.addFrame(frame1NoAttack);
4931
4932            staticData.add(idle);
4933            staticData.add(shoot);
4934
4935            setStaticData(GameObjectType.CANNON, staticData);
4936        }
4937
4938
4939        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
4940        render.setPriority(SortConstants.FOREGROUND_OBJECT);
4941
4942        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
4943        sprite.setSize((int)object.width, (int)object.height);
4944        sprite.setRenderComponent(render);
4945
4946        LauncherComponent launcher = (LauncherComponent)allocateComponent(LauncherComponent.class);
4947        launcher.setLaunchEffect(GameObjectType.SMOKE_POOF, 32.0f, 85.0f);
4948
4949        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
4950        if (sound != null) {
4951        	launcher.setLaunchSound(sound.load(R.raw.sound_cannon));
4952        }
4953
4954
4955        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
4956        sprite.setCollisionComponent(dynamicCollision);
4957
4958        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
4959        hitReact.setInvincible(false);
4960        hitReact.setLauncherComponent(launcher, HitType.LAUNCH);
4961
4962        dynamicCollision.setHitReactionComponent(hitReact);
4963
4964        GenericAnimationComponent anim = (GenericAnimationComponent)allocateComponent(GenericAnimationComponent.class);
4965        anim.setSprite(sprite);
4966
4967        object.team = Team.NONE;
4968
4969        object.add(render);
4970        object.add(sprite);
4971        object.add(dynamicCollision);
4972        object.add(hitReact);
4973        object.add(launcher);
4974        object.add(anim);
4975
4976        addStaticData(GameObjectType.CANNON, object, sprite);
4977
4978        sprite.playAnimation(0);
4979
4980        return object;
4981    }
4982
4983    public GameObject spawnObjectBrobotSpawner(float positionX, float positionY, boolean flipHorizontal) {
4984
4985        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
4986
4987        // This is pretty heavy-handed.
4988        // TODO: figure out a general solution for objects that depend on other objects.
4989        textureLibrary.allocateTexture(R.drawable.enemy_brobot_idle01);
4990        textureLibrary.allocateTexture(R.drawable.enemy_brobot_idle02);
4991        textureLibrary.allocateTexture(R.drawable.enemy_brobot_idle03);
4992        textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk01);
4993        textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk02);
4994        textureLibrary.allocateTexture(R.drawable.enemy_brobot_walk03);
4995
4996        GameObject object = mGameObjectPool.allocate();
4997        object.getPosition().set(positionX, positionY);
4998        object.activationRadius = mTightActivationRadius;
4999        object.width = 64;
5000        object.height = 64;
5001
5002        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.BROBOT_SPAWNER);
5003        if (staticData == null) {
5004            final int staticObjectCount = 2;
5005            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5006
5007            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
5008                new FixedSizeArray<CollisionVolume>(1);
5009            basicVulnerabilityVolume.add(new SphereCollisionVolume(32, 32, 32));
5010            basicVulnerabilityVolume.get(0).setHitType(HitType.POSSESS);
5011
5012            SpriteAnimation idle = new SpriteAnimation(0, 1);
5013            idle.addFrame(new AnimationFrame(
5014                    textureLibrary.allocateTexture(R.drawable.object_brobot_machine),
5015                    1.0f, null, basicVulnerabilityVolume));
5016
5017            SolidSurfaceComponent solidSurface
5018                = (SolidSurfaceComponent)allocateComponent(SolidSurfaceComponent.class);
5019            solidSurface.inititalize(3);
5020            /*
5021                0:2,0:8,59:-0.99532399996093,0.09659262446878
5022                0:8,59:61,33:0.44551558813576,0.89527418187282
5023                0:61,33:61,-1:1,0
5024
5025             */
5026            // trapezoid shape:
5027            // |\        |\2
5028            // | |      1| |3
5029
5030            Vector2 surface1Start = new Vector2(0, 0);
5031            Vector2 surface1End = new Vector2(8.0f, 59.0f);
5032            Vector2 surface1Normal = new Vector2(-0.9953f, 0.0965f);
5033            surface1Normal.normalize();
5034
5035            Vector2 surface2Start = new Vector2(8.0f, 59.0f);
5036            Vector2 surface2End = new Vector2(61.0f, 33.0f);
5037            Vector2 surface2Normal = new Vector2(0.445515f, 0.89527f);
5038            surface2Normal.normalize();
5039
5040            Vector2 surface3Start = new Vector2(61.0f, 33.0f);
5041            Vector2 surface3End = new Vector2(61.0f, 0.0f);
5042            Vector2 surface3Normal = new Vector2(1.0f, 0.0f);
5043
5044            solidSurface.addSurface(surface1Start, surface1End, surface1Normal);
5045            solidSurface.addSurface(surface2Start, surface2End, surface2Normal);
5046            solidSurface.addSurface(surface3Start, surface3End, surface3Normal);
5047
5048            staticData.add(solidSurface);
5049            staticData.add(idle);
5050
5051
5052            setStaticData(GameObjectType.BROBOT_SPAWNER, staticData);
5053        }
5054
5055        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5056        render.setPriority(SortConstants.GENERAL_OBJECT);
5057
5058
5059        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5060        sprite.setSize((int)object.width, (int)object.height);
5061        sprite.setRenderComponent(render);
5062
5063        DynamicCollisionComponent collision
5064            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5065        sprite.setCollisionComponent(collision);
5066
5067        HitReactionComponent hitReact
5068            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
5069        collision.setHitReactionComponent(hitReact);
5070
5071        LaunchProjectileComponent gun
5072            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
5073        gun.setDelayBeforeFirstSet(3.0f);
5074        gun.setObjectTypeToSpawn(GameObjectType.BROBOT);
5075        gun.setOffsetX(36);
5076        gun.setOffsetY(50);
5077        gun.setVelocityX(100.0f);
5078        gun.setVelocityY(300.0f);
5079        gun.enableProjectileTracking(1);
5080
5081
5082        object.team = Team.ENEMY;
5083
5084        if (flipHorizontal) {
5085            object.facingDirection.x = -1.0f;
5086        } else {
5087            object.facingDirection.x = 1.0f;
5088        }
5089
5090        object.add(render);
5091        object.add(sprite);
5092        object.add(gun);
5093        object.add(collision);
5094        object.add(hitReact);
5095
5096
5097        addStaticData(GameObjectType.BROBOT_SPAWNER, object, sprite);
5098
5099        object.commitUpdates();
5100
5101
5102        sprite.playAnimation(0);
5103
5104        return object;
5105    }
5106
5107    public GameObject spawnObjectInfiniteSpawner(float positionX, float positionY) {
5108    	GameObject object = spawnObjectBrobotSpawner(positionX, positionY, false);
5109    	object.facingDirection.y = -1; //vertical flip
5110    	LaunchProjectileComponent gun = object.findByClass(LaunchProjectileComponent.class);
5111    	if (gun != null) {
5112    		gun.disableProjectileTracking();
5113    		gun.setDelayBetweenShots(0.15f);
5114    		gun.setSetsPerActivation(1);
5115    		gun.setShotsPerSet(60);
5116    	}
5117
5118    	return object;
5119    }
5120
5121    public GameObject spawnObjectCrusherAndou(float positionX, float positionY) {
5122        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
5123
5124        GameObject object = mGameObjectPool.allocate();
5125        object.getPosition().set(positionX, positionY);
5126        object.activationRadius = mAlwaysActive;
5127        object.width = 64;
5128        object.height = 64;
5129
5130        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.CRUSHER_ANDOU);
5131
5132        if (staticData == null) {
5133            final int staticObjectCount = 5;
5134            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5135
5136            GameComponent gravity = allocateComponent(GravityComponent.class);
5137            GameComponent movement = allocateComponent(MovementComponent.class);
5138            PhysicsComponent physics = (PhysicsComponent)allocateComponent(PhysicsComponent.class);
5139
5140            physics.setMass(9.1f);   // ~90kg w/ earth gravity
5141            physics.setDynamicFrictionCoeffecient(0.2f);
5142            physics.setStaticFrictionCoeffecient(0.01f);
5143
5144            // Animation Data
5145            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
5146                new FixedSizeArray<CollisionVolume>(1);
5147            basicVulnerabilityVolume.add(new SphereCollisionVolume(16, 32, 32));
5148
5149            SpriteAnimation idle = new SpriteAnimation(Animation.IDLE, 1);
5150            idle.addFrame(new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stand),
5151                    1.0f, null, basicVulnerabilityVolume));
5152
5153
5154            FixedSizeArray<CollisionVolume> stompAttackVolume =
5155                new FixedSizeArray<CollisionVolume>(1);
5156            stompAttackVolume.add(new AABoxCollisionVolume(16, -5.0f, 32, 37, HitType.HIT));
5157
5158
5159            SpriteAnimation stomp = new SpriteAnimation(Animation.ATTACK, 4);
5160            stomp.addFrame(
5161                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp01),
5162                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
5163            stomp.addFrame(
5164                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp02),
5165                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
5166            stomp.addFrame(
5167                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp03),
5168                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
5169            stomp.addFrame(
5170                    new AnimationFrame(textureLibrary.allocateTexture(R.drawable.andou_stomp04),
5171                    		Utils.framesToTime(24, 1), stompAttackVolume, null));
5172
5173
5174
5175            // Save static data
5176            staticData.add(gravity);
5177            staticData.add(movement);
5178            staticData.add(physics);
5179
5180
5181            staticData.add(idle);
5182            staticData.add(stomp);
5183
5184
5185            setStaticData(GameObjectType.CRUSHER_ANDOU, staticData);
5186        }
5187
5188
5189        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5190        render.setPriority(SortConstants.PLAYER);
5191        BackgroundCollisionComponent bgcollision
5192            = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
5193        bgcollision.setSize(32, 48);
5194        bgcollision.setOffset(16, 0);
5195
5196        GenericAnimationComponent animation = (GenericAnimationComponent)allocateComponent(GenericAnimationComponent.class);
5197
5198        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5199        sprite.setSize((int)object.width, (int)object.height);
5200        sprite.setRenderComponent(render);
5201        animation.setSprite(sprite);
5202
5203
5204        DynamicCollisionComponent dynamicCollision
5205            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5206        sprite.setCollisionComponent(dynamicCollision);
5207
5208        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
5209        hitReact.setBounceOnHit(true);
5210        hitReact.setPauseOnAttack(true);
5211        hitReact.setInvincibleTime(3.0f);
5212        hitReact.setSpawnOnDealHit(HitType.HIT, GameObjectType.CRUSH_FLASH, false, true);
5213
5214
5215        dynamicCollision.setHitReactionComponent(hitReact);
5216
5217
5218
5219        object.life = 1;
5220        object.team = Team.PLAYER;
5221
5222        object.add(animation);
5223        object.add(bgcollision);
5224        object.add(render);
5225        object.add(sprite);
5226        object.add(dynamicCollision);
5227        object.add(hitReact);
5228
5229        addStaticData(GameObjectType.CRUSHER_ANDOU, object, sprite);
5230
5231        sprite.playAnimation(Animation.IDLE);
5232
5233        object.commitUpdates();
5234
5235        ChangeComponentsComponent swap = (ChangeComponentsComponent)allocateComponent(ChangeComponentsComponent.class);
5236
5237        final int count = object.getCount();
5238        for (int x = 0; x < count; x++) {
5239        	swap.addSwapInComponent((GameComponent)object.get(x));
5240        }
5241
5242        object.removeAll();
5243
5244        CrusherAndouComponent crusher = (CrusherAndouComponent)allocateComponent(CrusherAndouComponent.class);
5245
5246        crusher.setSwap(swap);
5247
5248        object.add(swap);
5249        object.add(crusher);
5250
5251        object.commitUpdates();
5252
5253        return object;
5254    }
5255
5256    public GameObject spawnObjectBreakableBlock(float positionX, float positionY) {
5257
5258        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
5259
5260        // Preload block piece texture.
5261        textureLibrary.allocateTexture(R.drawable.object_debris_piece);
5262
5263        GameObject object = mGameObjectPool.allocate();
5264        object.getPosition().set(positionX, positionY);
5265        object.activationRadius = mTightActivationRadius;
5266        object.width = 32;
5267        object.height = 32;
5268
5269        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.BREAKABLE_BLOCK);
5270        if (staticData == null) {
5271            final int staticObjectCount = 2;
5272            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5273
5274            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
5275                new FixedSizeArray<CollisionVolume>(1);
5276            basicVulnerabilityVolume.add(new AABoxCollisionVolume(7, 0, 32 - 7, 42, HitType.HIT));
5277
5278            SpriteAnimation idle = new SpriteAnimation(0, 1);
5279            idle.addFrame(new AnimationFrame(
5280                    textureLibrary.allocateTexture(R.drawable.object_debris_block),
5281                    1.0f, null, basicVulnerabilityVolume));
5282
5283            SolidSurfaceComponent solidSurface
5284                = (SolidSurfaceComponent)allocateComponent(SolidSurfaceComponent.class);
5285            solidSurface.inititalize(4);
5286
5287            // box shape:
5288            // ___       ___2
5289            // | |      1| |3
5290            // ---       ---4
5291
5292            Vector2 surface1Start = new Vector2(0.0f, 0.0f);
5293            Vector2 surface1End = new Vector2(0.0f, 32.0f);
5294            Vector2 surface1Normal = new Vector2(-1.0f, 0.0f);
5295            surface1Normal.normalize();
5296
5297            Vector2 surface2Start = new Vector2(0.0f, 32.0f);
5298            Vector2 surface2End = new Vector2(32.0f, 32.0f);
5299            Vector2 surface2Normal = new Vector2(0.0f, 1.0f);
5300            surface2Normal.normalize();
5301
5302            Vector2 surface3Start = new Vector2(32.0f, 32.0f);
5303            Vector2 surface3End = new Vector2(32.0f, 0.0f);
5304            Vector2 surface3Normal = new Vector2(1.0f, 0.0f);
5305
5306            Vector2 surface4Start = new Vector2(32.0f, 0.0f);
5307            Vector2 surface4End = new Vector2(0.0f, 0.0f);
5308            Vector2 surface4Normal = new Vector2(0.0f, -1.0f);
5309
5310            solidSurface.addSurface(surface1Start, surface1End, surface1Normal);
5311            solidSurface.addSurface(surface2Start, surface2End, surface2Normal);
5312            solidSurface.addSurface(surface3Start, surface3End, surface3Normal);
5313            solidSurface.addSurface(surface4Start, surface4End, surface4Normal);
5314
5315            staticData.add(solidSurface);
5316            staticData.add(idle);
5317
5318
5319            setStaticData(GameObjectType.BREAKABLE_BLOCK, staticData);
5320        }
5321
5322        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5323        render.setPriority(SortConstants.GENERAL_OBJECT);
5324
5325
5326        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5327        sprite.setSize((int)object.width, (int)object.height);
5328        sprite.setRenderComponent(render);
5329
5330        DynamicCollisionComponent collision
5331            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5332        sprite.setCollisionComponent(collision);
5333
5334        HitReactionComponent hitReact
5335            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
5336        collision.setHitReactionComponent(hitReact);
5337
5338        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
5339        lifetime.setObjectToSpawnOnDeath(GameObjectType.BREAKABLE_BLOCK_PIECE_SPAWNER);
5340        SoundSystem sound = BaseObject.sSystemRegistry.soundSystem;
5341        if (sound != null) {
5342        	lifetime.setDeathSound(sound.load(R.raw.sound_break_block));
5343        }
5344
5345        object.life = 1;
5346        object.team = Team.ENEMY;
5347
5348        object.add(render);
5349        object.add(sprite);
5350        object.add(collision);
5351        object.add(hitReact);
5352        object.add(lifetime);
5353
5354
5355        addStaticData(GameObjectType.BREAKABLE_BLOCK, object, sprite);
5356
5357        sprite.playAnimation(0);
5358
5359        return object;
5360    }
5361
5362	public GameObject spawnObjectTheSource(float positionX, float positionY) {
5363
5364	    final TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
5365
5366	    GameObject object = mGameObjectPool.allocate();
5367	    object.activationRadius = mAlwaysActive;
5368	    object.width = 512;
5369	    object.height = 512;
5370        object.getPosition().set(positionX, positionY);
5371
5372	    RenderComponent layer1Render = (RenderComponent)allocateComponent(RenderComponent.class);
5373	    layer1Render.setPriority(SortConstants.THE_SOURCE_START);
5374	    FadeDrawableComponent layer1Fade = (FadeDrawableComponent)allocateComponent(FadeDrawableComponent.class);
5375	    layer1Fade.setRenderComponent(layer1Render);
5376	    layer1Fade.setTexture(textureLibrary.allocateTexture(R.drawable.enemy_source_spikes));
5377	    layer1Fade.setupFade(1.0f, 0.2f, 1.9f, FadeDrawableComponent.LOOP_TYPE_PING_PONG, FadeDrawableComponent.FADE_EASE, 0.0f);
5378
5379	    RenderComponent layer2Render = (RenderComponent)allocateComponent(RenderComponent.class);
5380	    layer2Render.setPriority(SortConstants.THE_SOURCE_START + 1);
5381	    FadeDrawableComponent layer2Fade = (FadeDrawableComponent)allocateComponent(FadeDrawableComponent.class);
5382	    layer2Fade.setRenderComponent(layer2Render);
5383	    layer2Fade.setTexture(textureLibrary.allocateTexture(R.drawable.enemy_source_body));
5384	    layer2Fade.setupFade(1.0f, 0.8f, 5.0f, FadeDrawableComponent.LOOP_TYPE_PING_PONG, FadeDrawableComponent.FADE_EASE, 0.0f);
5385
5386	    RenderComponent layer3Render = (RenderComponent)allocateComponent(RenderComponent.class);
5387	    layer3Render.setPriority(SortConstants.THE_SOURCE_START + 2);
5388	    FadeDrawableComponent layer3Fade = (FadeDrawableComponent)allocateComponent(FadeDrawableComponent.class);
5389	    layer3Fade.setRenderComponent(layer3Render);
5390	    layer3Fade.setTexture(textureLibrary.allocateTexture(R.drawable.enemy_source_black));
5391	    layer3Fade.setupFade(0.0f, 1.0f, 6.0f, FadeDrawableComponent.LOOP_TYPE_PING_PONG, FadeDrawableComponent.FADE_LINEAR, 0.0f);
5392
5393	    RenderComponent layer4Render = (RenderComponent)allocateComponent(RenderComponent.class);
5394	    layer4Render.setPriority(SortConstants.THE_SOURCE_START + 3);
5395	    FadeDrawableComponent layer4Fade = (FadeDrawableComponent)allocateComponent(FadeDrawableComponent.class);
5396	    layer4Fade.setRenderComponent(layer4Render);
5397	    layer4Fade.setTexture(textureLibrary.allocateTexture(R.drawable.enemy_source_spots));
5398	    layer4Fade.setupFade(0.0f, 1.0f, 2.3f, FadeDrawableComponent.LOOP_TYPE_PING_PONG, FadeDrawableComponent.FADE_EASE, 0.0f);
5399
5400	    RenderComponent layer5Render = (RenderComponent)allocateComponent(RenderComponent.class);
5401	    layer5Render.setPriority(SortConstants.THE_SOURCE_START + 4);
5402	    FadeDrawableComponent layer5Fade = (FadeDrawableComponent)allocateComponent(FadeDrawableComponent.class);
5403	    layer5Fade.setRenderComponent(layer5Render);
5404	    layer5Fade.setTexture(textureLibrary.allocateTexture(R.drawable.enemy_source_core));
5405	    layer5Fade.setupFade(0.2f, 1.0f, 1.2f, FadeDrawableComponent.LOOP_TYPE_PING_PONG, FadeDrawableComponent.FADE_EASE, 0.0f);
5406
5407
5408	    OrbitalMagnetComponent orbit = (OrbitalMagnetComponent)allocateComponent(OrbitalMagnetComponent.class);
5409	    orbit.setup(320.0f, 220.0f);
5410
5411	    DynamicCollisionComponent collision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5412	    FixedSizeArray<CollisionVolume> vulnerabilityVolume =
5413            new FixedSizeArray<CollisionVolume>(1);
5414	    vulnerabilityVolume.add(new SphereCollisionVolume(256, 256, 256, HitType.HIT));
5415	    FixedSizeArray<CollisionVolume> attackVolume =
5416            new FixedSizeArray<CollisionVolume>(1);
5417	    attackVolume.add(new SphereCollisionVolume(256, 256, 256, HitType.HIT));
5418	    collision.setCollisionVolumes(attackVolume, vulnerabilityVolume);
5419
5420	    HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
5421        collision.setHitReactionComponent(hitReact);
5422        hitReact.setInvincibleTime(TheSourceComponent.SHAKE_TIME);
5423
5424        TheSourceComponent theSource = (TheSourceComponent)allocateComponent(TheSourceComponent.class);
5425        ChannelSystem.Channel surpriseChannel = null;
5426        ChannelSystem channelSystem = BaseObject.sSystemRegistry.channelSystem;
5427        surpriseChannel = channelSystem.registerChannel(sSurprisedNPCChannel);
5428        theSource.setChannel(surpriseChannel);
5429        theSource.setGameEvent(GameFlowEvent.EVENT_SHOW_ANIMATION, AnimationPlayerActivity.WANDA_ENDING);
5430
5431
5432	    object.life = 3;
5433	    object.team = Team.PLAYER;
5434
5435	    object.add(layer1Render);
5436	    object.add(layer2Render);
5437	    object.add(layer3Render);
5438	    object.add(layer4Render);
5439	    object.add(layer5Render);
5440
5441	    object.add(layer1Fade);
5442	    object.add(layer2Fade);
5443	    object.add(layer3Fade);
5444	    object.add(layer4Fade);
5445	    object.add(layer5Fade);
5446
5447	    object.add(orbit);
5448	    object.add(collision);
5449	    object.add(hitReact);
5450	    object.add(theSource);
5451
5452	    return object;
5453	}
5454
5455	public GameObject spawnObjectSign(float positionX, float positionY) {
5456        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
5457
5458        GameObject object = mGameObjectPool.allocate();
5459        object.getPosition().set(positionX, positionY);
5460        object.activationRadius = mTightActivationRadius;
5461        object.width = 32;
5462        object.height = 32;
5463
5464        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.HINT_SIGN);
5465        if (staticData == null) {
5466            final int staticObjectCount = 1;
5467            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5468
5469            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
5470                new FixedSizeArray<CollisionVolume>(1);
5471            basicVulnerabilityVolume.add(new AABoxCollisionVolume(8, 0, 24, 32, HitType.COLLECT));
5472
5473            SpriteAnimation idle = new SpriteAnimation(0, 1);
5474            AnimationFrame frame1 = new AnimationFrame(textureLibrary.allocateTexture(R.drawable.object_sign),
5475                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume);
5476
5477            idle.addFrame(frame1);
5478
5479            idle.setLoop(true);
5480
5481            staticData.add(idle);
5482
5483            setStaticData(GameObjectType.HINT_SIGN, staticData);
5484        }
5485
5486        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5487        render.setPriority(SortConstants.GENERAL_OBJECT);
5488
5489        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5490        sprite.setSize((int)object.width, (int)object.height);
5491        sprite.setRenderComponent(render);
5492
5493        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5494        sprite.setCollisionComponent(dynamicCollision);
5495
5496        HitReactionComponent hitReact = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
5497        dynamicCollision.setHitReactionComponent(hitReact);
5498        hitReact.setSpawnGameEventOnHit(HitType.COLLECT, GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER2, 0);
5499
5500        SelectDialogComponent dialogSelect = (SelectDialogComponent)allocateComponent(SelectDialogComponent.class);
5501        dialogSelect.setHitReact(hitReact);
5502
5503        object.add(dialogSelect);
5504        object.add(render);
5505        object.add(sprite);
5506        object.add(dynamicCollision);
5507        object.add(hitReact);
5508
5509        addStaticData(GameObjectType.HINT_SIGN, object, sprite);
5510        sprite.playAnimation(0);
5511
5512        return object;
5513    }
5514
5515    public GameObject spawnObjectTurret(float positionX, float positionY, boolean flipHorizontal) {
5516
5517        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
5518
5519        // Make sure related textures are loaded.
5520        textureLibrary.allocateTexture(R.drawable.effect_bullet01);
5521        textureLibrary.allocateTexture(R.drawable.effect_bullet02);
5522
5523
5524        GameObject object = mGameObjectPool.allocate();
5525        object.getPosition().set(positionX, positionY);
5526        object.activationRadius = mTightActivationRadius;
5527        object.width = 64;
5528        object.height = 64;
5529
5530        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.TURRET);
5531        if (staticData == null) {
5532            final int staticObjectCount = 3;
5533            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5534
5535            // Animations
5536            FixedSizeArray<CollisionVolume> basicVulnerabilityVolume =
5537                new FixedSizeArray<CollisionVolume>(1);
5538            basicVulnerabilityVolume.add(new SphereCollisionVolume(32, 32, 32));
5539            basicVulnerabilityVolume.get(0).setHitType(HitType.POSSESS);
5540
5541            SpriteAnimation idle = new SpriteAnimation(EnemyAnimations.IDLE.ordinal(), 2);
5542            idle.addFrame(new AnimationFrame(
5543                    textureLibrary.allocateTexture(R.drawable.object_gunturret01),
5544                    1.0f, null, basicVulnerabilityVolume));
5545            idle.addFrame(new AnimationFrame(
5546                    textureLibrary.allocateTexture(R.drawable.object_gunturret_idle),
5547                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
5548            idle.setLoop(true);
5549
5550            SpriteAnimation attack = new SpriteAnimation(EnemyAnimations.ATTACK.ordinal(), 4);
5551            attack.addFrame(new AnimationFrame(
5552                    textureLibrary.allocateTexture(R.drawable.object_gunturret02),
5553                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
5554            attack.addFrame(new AnimationFrame(
5555                    textureLibrary.allocateTexture(R.drawable.object_gunturret01),
5556                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
5557            attack.addFrame(new AnimationFrame(
5558                    textureLibrary.allocateTexture(R.drawable.object_gunturret03),
5559                    Utils.framesToTime(24, 2), null, basicVulnerabilityVolume));
5560            attack.addFrame(new AnimationFrame(
5561                    textureLibrary.allocateTexture(R.drawable.object_gunturret01),
5562                    Utils.framesToTime(24, 1), null, basicVulnerabilityVolume));
5563            attack.setLoop(true);
5564
5565            GhostComponent ghost = (GhostComponent)allocateComponent(GhostComponent.class);
5566            ghost.setTargetAction(ActionType.IDLE);
5567            ghost.changeActionOnButton(ActionType.ATTACK);
5568
5569            staticData.add(idle);
5570            staticData.add(attack);
5571            staticData.add(ghost);
5572
5573
5574            setStaticData(GameObjectType.TURRET, staticData);
5575        }
5576
5577        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5578        render.setPriority(SortConstants.GENERAL_OBJECT);
5579
5580
5581        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5582        sprite.setSize((int)object.width, (int)object.height);
5583        sprite.setRenderComponent(render);
5584
5585        GenericAnimationComponent animation
5586            = (GenericAnimationComponent)allocateComponent(GenericAnimationComponent.class);
5587        animation.setSprite(sprite);
5588
5589        AttackAtDistanceComponent attack = (AttackAtDistanceComponent)
5590            allocateComponent(AttackAtDistanceComponent.class);
5591        attack.setupAttack(300, 0.0f, 1.0f, true);
5592
5593
5594        DynamicCollisionComponent collision
5595            = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5596        sprite.setCollisionComponent(collision);
5597
5598        HitReactionComponent hitReact
5599            = (HitReactionComponent)allocateComponent(HitReactionComponent.class);
5600        collision.setHitReactionComponent(hitReact);
5601
5602        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
5603        lifetime.setObjectToSpawnOnDeath(GameObjectType.EXPLOSION_LARGE);
5604
5605        SoundSystem sound = sSystemRegistry.soundSystem;
5606
5607        LaunchProjectileComponent gun
5608            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
5609        gun.setShotsPerSet(1);
5610        gun.setDelayBetweenShots(0.0f);
5611        gun.setDelayBetweenSets(0.3f);
5612        gun.setObjectTypeToSpawn(GameObjectType.TURRET_BULLET);
5613        gun.setOffsetX(54);
5614        gun.setOffsetY(13);
5615        gun.setRequiredAction(GameObject.ActionType.ATTACK);
5616        gun.setVelocityX(300.0f);
5617        gun.setVelocityY(-300.0f);
5618        gun.setShootSound(sound.load(R.raw.sound_gun));
5619
5620        // Components for possession
5621
5622        ChangeComponentsComponent componentSwap = (ChangeComponentsComponent)allocateComponent(ChangeComponentsComponent.class);
5623        componentSwap.addSwapOutComponent(attack);
5624        componentSwap.setPingPongBehavior(true);
5625
5626        hitReact.setPossessionComponent(componentSwap);
5627
5628        object.team = Team.ENEMY;
5629
5630        if (flipHorizontal) {
5631            object.facingDirection.x = -1.0f;
5632        } else {
5633            object.facingDirection.x = 1.0f;
5634        }
5635
5636        object.add(render);
5637        object.add(sprite);
5638        object.add(animation);
5639        object.add(attack);
5640        object.add(collision);
5641        object.add(hitReact);
5642        object.add(lifetime);
5643        object.add(gun);
5644        object.add(componentSwap);
5645
5646        addStaticData(GameObjectType.TURRET, object, sprite);
5647
5648        object.commitUpdates();
5649
5650        GhostComponent possessedGhost = object.findByClass(GhostComponent.class);
5651        if (possessedGhost != null) {
5652            object.remove(possessedGhost);   // Not supposed to be added yet.
5653            componentSwap.addSwapInComponent(possessedGhost);
5654        }
5655
5656        sprite.playAnimation(0);
5657
5658        return object;
5659    }
5660
5661    public GameObject spawnDust(float positionX, float positionY, boolean flipHorizontal) {
5662        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
5663
5664        GameObject object = mGameObjectPool.allocate();
5665        object.getPosition().set(positionX, positionY);
5666        object.activationRadius = mTightActivationRadius;
5667        object.width = 32;
5668        object.height = 32;
5669
5670        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.DUST);
5671        if (staticData == null) {
5672            final int staticObjectCount = 1;
5673            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5674
5675            SpriteAnimation idle = new SpriteAnimation(0, 5);
5676            idle.addFrame(new AnimationFrame(textureLibrary.getTextureByResource(R.drawable.dust01),
5677                    Utils.framesToTime(24, 1)));
5678            idle.addFrame(new AnimationFrame(textureLibrary.getTextureByResource(R.drawable.dust02),
5679                    Utils.framesToTime(24, 1)));
5680            idle.addFrame(new AnimationFrame(textureLibrary.getTextureByResource(R.drawable.dust03),
5681                    Utils.framesToTime(24, 1)));
5682            idle.addFrame(new AnimationFrame(textureLibrary.getTextureByResource(R.drawable.dust04),
5683                    Utils.framesToTime(24, 1)));
5684            idle.addFrame(new AnimationFrame(textureLibrary.getTextureByResource(R.drawable.dust05),
5685                    Utils.framesToTime(24, 1)));
5686
5687            staticData.add(idle);
5688            setStaticData(GameObjectType.DUST, staticData);
5689        }
5690
5691
5692        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5693        render.setPriority(SortConstants.EFFECT);
5694
5695        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
5696        lifetime.setTimeUntilDeath(0.30f);
5697
5698        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5699		sprite.setSize((int)object.width, (int)object.height);
5700        sprite.setRenderComponent(render);
5701
5702
5703        if (flipHorizontal) {
5704            object.facingDirection.x = -1.0f;
5705        }
5706        object.destroyOnDeactivation = true;
5707
5708        object.add(lifetime);
5709        object.add(render);
5710        object.add(sprite);
5711
5712        addStaticData(GameObjectType.DUST, object, sprite);
5713
5714        sprite.playAnimation(0);
5715
5716        return object;
5717    }
5718
5719    public GameObject spawnEffectExplosionSmall(float positionX, float positionY) {
5720        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
5721
5722        GameObject object = mGameObjectPool.allocate();
5723        object.getPosition().set(positionX, positionY);
5724        object.activationRadius = mAlwaysActive;
5725        object.width = 32;
5726        object.height = 32;
5727
5728        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.EXPLOSION_SMALL);
5729        if (staticData == null) {
5730            final int staticObjectCount = 1;
5731            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5732
5733            FixedSizeArray<CollisionVolume> basicAttackVolume =
5734                new FixedSizeArray<CollisionVolume>(1);
5735            basicAttackVolume.add(new SphereCollisionVolume(16, 16, 16, HitType.HIT));
5736
5737            SpriteAnimation idle = new SpriteAnimation(0, 7);
5738            idle.addFrame(new AnimationFrame(
5739                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small01),
5740                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5741            idle.addFrame(new AnimationFrame(
5742                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small02),
5743                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5744            idle.addFrame(new AnimationFrame(
5745                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small03),
5746                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5747            idle.addFrame(new AnimationFrame(
5748                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small04),
5749                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5750            idle.addFrame(new AnimationFrame(
5751                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small05),
5752                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5753            idle.addFrame(new AnimationFrame(
5754                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small06),
5755                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5756            idle.addFrame(new AnimationFrame(
5757                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small07),
5758                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5759
5760            staticData.add(idle);
5761            setStaticData(GameObjectType.EXPLOSION_SMALL, staticData);
5762        }
5763
5764        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5765        render.setPriority(SortConstants.EFFECT);
5766
5767        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5768		sprite.setSize((int)object.width, (int)object.height);
5769        sprite.setRenderComponent(render);
5770
5771
5772        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
5773
5774        DynamicCollisionComponent dynamicCollision = (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5775        sprite.setCollisionComponent(dynamicCollision);
5776
5777        object.add(dynamicCollision);
5778        object.add(lifetime);
5779        object.add(render);
5780        object.add(sprite);
5781
5782        addStaticData(GameObjectType.EXPLOSION_SMALL, object, sprite);
5783
5784        final SpriteAnimation idle = sprite.findAnimation(0);
5785        if (idle != null) {
5786            lifetime.setTimeUntilDeath(idle.getLength());
5787        }
5788
5789        sprite.playAnimation(0);
5790
5791        return object;
5792    }
5793
5794    public GameObject spawnEffectExplosionLarge(float positionX, float positionY) {
5795        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
5796
5797        GameObject object = mGameObjectPool.allocate();
5798        object.getPosition().set(positionX, positionY);
5799        object.activationRadius = mAlwaysActive;
5800        object.width = 64;
5801        object.height = 64;
5802
5803        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.EXPLOSION_LARGE);
5804        if (staticData == null) {
5805            final int staticObjectCount = 1;
5806            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5807
5808            FixedSizeArray<CollisionVolume> basicAttackVolume =
5809                new FixedSizeArray<CollisionVolume>(1);
5810            basicAttackVolume.add(new SphereCollisionVolume(32, 32, 32, HitType.HIT));
5811
5812            SpriteAnimation idle = new SpriteAnimation(0, 9);
5813            idle.addFrame(new AnimationFrame(
5814                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big01),
5815                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5816            idle.addFrame(new AnimationFrame(
5817                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big02),
5818                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5819            idle.addFrame(new AnimationFrame(
5820                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big03),
5821                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5822            idle.addFrame(new AnimationFrame(
5823                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big04),
5824                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5825            idle.addFrame(new AnimationFrame(
5826                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big05),
5827                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5828            idle.addFrame(new AnimationFrame(
5829                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big06),
5830                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5831            idle.addFrame(new AnimationFrame(
5832                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big07),
5833                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5834            idle.addFrame(new AnimationFrame(
5835                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big08),
5836                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5837            idle.addFrame(new AnimationFrame(
5838                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big09),
5839                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5840
5841
5842            staticData.add(idle);
5843            setStaticData(GameObjectType.EXPLOSION_LARGE, staticData);
5844        }
5845
5846        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5847        render.setPriority(SortConstants.EFFECT);
5848
5849        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5850		sprite.setSize((int)object.width, (int)object.height);
5851        sprite.setRenderComponent(render);
5852
5853
5854        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
5855
5856        DynamicCollisionComponent dynamicCollision =
5857            (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
5858        sprite.setCollisionComponent(dynamicCollision);
5859
5860        PlaySingleSoundComponent soundEffect = (PlaySingleSoundComponent)allocateComponent(PlaySingleSoundComponent.class);
5861        soundEffect.setSound(sSystemRegistry.soundSystem.load(R.raw.quick_explosion));
5862
5863
5864        object.add(soundEffect);
5865        object.add(dynamicCollision);
5866        object.add(lifetime);
5867        object.add(render);
5868        object.add(sprite);
5869
5870        addStaticData(GameObjectType.EXPLOSION_LARGE, object, sprite);
5871
5872        final SpriteAnimation idle = sprite.findAnimation(0);
5873        if (idle != null) {
5874            lifetime.setTimeUntilDeath(idle.getLength());
5875        }
5876
5877        sprite.playAnimation(0);
5878
5879        return object;
5880    }
5881
5882    public GameObject spawnEffectExplosionGiant(float positionX, float positionY) {
5883        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
5884
5885        GameObject object = mGameObjectPool.allocate();
5886        object.getPosition().set(positionX, positionY);
5887        object.activationRadius = mAlwaysActive;
5888        object.width = 64;
5889        object.height = 64;
5890
5891        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.EXPLOSION_GIANT);
5892        if (staticData == null) {
5893            final int staticObjectCount = 4;
5894            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
5895
5896            FixedSizeArray<CollisionVolume> basicAttackVolume = new FixedSizeArray<CollisionVolume>(1);
5897            basicAttackVolume.add(new SphereCollisionVolume(64, 32, 32, HitType.HIT));
5898
5899            SpriteAnimation idle = new SpriteAnimation(0, 9);
5900            idle.addFrame(new AnimationFrame(
5901                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big01),
5902                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5903            idle.addFrame(new AnimationFrame(
5904                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big02),
5905                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5906            idle.addFrame(new AnimationFrame(
5907                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big03),
5908                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5909            idle.addFrame(new AnimationFrame(
5910                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big04),
5911                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5912            idle.addFrame(new AnimationFrame(
5913                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big05),
5914                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5915            idle.addFrame(new AnimationFrame(
5916                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big06),
5917                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5918            idle.addFrame(new AnimationFrame(
5919                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big07),
5920                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5921            idle.addFrame(new AnimationFrame(
5922                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big08),
5923                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5924            idle.addFrame(new AnimationFrame(
5925                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_big09),
5926                    Utils.framesToTime(24, 1), basicAttackVolume, null));
5927
5928
5929            AnimationFrame smallFrame1 = new AnimationFrame(
5930                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small01),
5931                    Utils.framesToTime(24, 1), null, null);
5932            AnimationFrame smallFrame2 = new AnimationFrame(
5933                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small02),
5934                    Utils.framesToTime(24, 1), null, null);
5935            AnimationFrame smallFrame3 = new AnimationFrame(
5936                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small03),
5937                    Utils.framesToTime(24, 1), null, null);
5938            AnimationFrame smallFrame4 = new AnimationFrame(
5939                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small04),
5940                    Utils.framesToTime(24, 1), null, null);
5941            AnimationFrame smallFrame5 = new AnimationFrame(
5942                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small05),
5943                    Utils.framesToTime(24, 1), null, null);
5944            AnimationFrame smallFrame6 = new AnimationFrame(
5945                    textureLibrary.getTextureByResource(R.drawable.effect_explosion_small06),
5946                    Utils.framesToTime(24, 1), null, null);
5947            AnimationFrame smallFrame7 = new AnimationFrame
5948            (textureLibrary.getTextureByResource(R.drawable.effect_explosion_small07),
5949                    Utils.framesToTime(24, 1), null, null);
5950
5951            SpriteAnimation smallBlast1 = new SpriteAnimation(0, 7);
5952            smallBlast1.addFrame(smallFrame1);
5953            smallBlast1.addFrame(smallFrame2);
5954            smallBlast1.addFrame(smallFrame3);
5955            smallBlast1.addFrame(smallFrame4);
5956            smallBlast1.addFrame(smallFrame5);
5957            smallBlast1.addFrame(smallFrame6);
5958            smallBlast1.addFrame(smallFrame7);
5959
5960            SpriteAnimation smallBlast2 = new SpriteAnimation(0, 8);
5961            smallBlast2.addFrame(new AnimationFrame(null, Utils.framesToTime(24, 4), null, null));
5962            smallBlast2.addFrame(smallFrame1);
5963            smallBlast2.addFrame(smallFrame2);
5964            smallBlast2.addFrame(smallFrame3);
5965            smallBlast2.addFrame(smallFrame4);
5966            smallBlast2.addFrame(smallFrame5);
5967            smallBlast2.addFrame(smallFrame6);
5968            smallBlast2.addFrame(smallFrame7);
5969
5970            SpriteAnimation smallBlast3 = new SpriteAnimation(0, 8);
5971            smallBlast3.addFrame(new AnimationFrame(null, Utils.framesToTime(24, 8), null, null));
5972            smallBlast3.addFrame(smallFrame1);
5973            smallBlast3.addFrame(smallFrame2);
5974            smallBlast3.addFrame(smallFrame3);
5975            smallBlast3.addFrame(smallFrame4);
5976            smallBlast3.addFrame(smallFrame5);
5977            smallBlast3.addFrame(smallFrame6);
5978            smallBlast3.addFrame(smallFrame7);
5979
5980
5981            staticData.add(idle);
5982            staticData.add(smallBlast1);
5983            staticData.add(smallBlast2);
5984            staticData.add(smallBlast3);
5985
5986            setStaticData(GameObjectType.EXPLOSION_GIANT, staticData);
5987        }
5988
5989        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
5990        render.setPriority(SortConstants.EFFECT);
5991        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
5992		sprite.setSize((int)object.width, (int)object.height);
5993        sprite.setRenderComponent(render);
5994
5995        // Hack.  Use static data differently for this object so we can share three animations
5996        // amongst three separate sprites.
5997
5998        final SpriteAnimation idle = (SpriteAnimation)staticData.get(0);
5999        final SpriteAnimation smallBlast1 = (SpriteAnimation)staticData.get(1);
6000        final SpriteAnimation smallBlast2 = (SpriteAnimation)staticData.get(2);
6001        final SpriteAnimation smallBlast3 = (SpriteAnimation)staticData.get(3);
6002
6003        sprite.addAnimation(idle);
6004        sprite.playAnimation(0);
6005
6006        RenderComponent blast1Render = (RenderComponent)allocateComponent(RenderComponent.class);
6007        render.setPriority(SortConstants.EFFECT);
6008        SpriteComponent blast1Sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6009		blast1Sprite.setSize(32, 32);
6010        blast1Sprite.setRenderComponent(blast1Render);
6011        blast1Render.setDrawOffset(40, 50);
6012        blast1Sprite.addAnimation(smallBlast1);
6013        blast1Sprite.playAnimation(0);
6014
6015        RenderComponent blast2Render = (RenderComponent)allocateComponent(RenderComponent.class);
6016        render.setPriority(SortConstants.EFFECT);
6017        SpriteComponent blast2Sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6018		blast2Sprite.setSize(32, 32);
6019        blast2Sprite.setRenderComponent(blast2Render);
6020        blast2Render.setDrawOffset(-10, 0);
6021        blast2Sprite.addAnimation(smallBlast2);
6022        blast2Sprite.playAnimation(0);
6023
6024        RenderComponent blast3Render = (RenderComponent)allocateComponent(RenderComponent.class);
6025        render.setPriority(SortConstants.EFFECT);
6026        SpriteComponent blast3Sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6027		blast3Sprite.setSize(32, 32);
6028        blast3Sprite.setRenderComponent(blast3Render);
6029        blast3Render.setDrawOffset(0, 32);
6030        blast3Sprite.addAnimation(smallBlast3);
6031        blast3Sprite.playAnimation(0);
6032
6033        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6034        lifetime.setTimeUntilDeath(Math.max(
6035                Math.max(
6036                        Math.max(idle.getLength(), smallBlast1.getLength()),
6037                        smallBlast2.getLength()),
6038                smallBlast3.getLength()));
6039
6040        DynamicCollisionComponent dynamicCollision =
6041            (DynamicCollisionComponent)allocateComponent(DynamicCollisionComponent.class);
6042        sprite.setCollisionComponent(dynamicCollision);
6043
6044        PlaySingleSoundComponent soundEffect = (PlaySingleSoundComponent)allocateComponent(PlaySingleSoundComponent.class);
6045        soundEffect.setSound(sSystemRegistry.soundSystem.load(R.raw.quick_explosion));
6046
6047
6048
6049        object.team = Team.PLAYER;  // Maybe this should be an argument to this function.
6050
6051        object.add(dynamicCollision);
6052        object.add(lifetime);
6053        object.add(render);
6054        object.add(sprite);
6055        object.add(soundEffect);
6056
6057
6058        object.add(blast1Render);
6059        object.add(blast1Sprite);
6060
6061        object.add(blast2Render);
6062        object.add(blast2Sprite);
6063
6064        object.add(blast3Render);
6065        object.add(blast3Sprite);
6066
6067
6068        return object;
6069    }
6070
6071
6072    public GameObject spawnGhostNPC(float positionX, float positionY) {
6073
6074        GameObject object = mGameObjectPool.allocate();
6075        object.getPosition().set(positionX, positionY);
6076        object.activationRadius = mAlwaysActive;
6077        object.width = 32;
6078        object.height = 32;
6079
6080        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.GHOST_NPC);
6081        if (staticData == null) {
6082            final int staticObjectCount = 2;
6083            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6084
6085            GameComponent gravity = allocateComponent(GravityComponent.class);
6086            GameComponent movement = allocateComponent(MovementComponent.class);
6087
6088            staticData.add(gravity);
6089            staticData.add(movement);
6090
6091
6092            setStaticData(GameObjectType.GHOST_NPC, staticData);
6093        }
6094
6095        NPCComponent patrol = (NPCComponent)allocateComponent(NPCComponent.class);
6096        LifetimeComponent life = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6097
6098        object.team = Team.NONE;
6099        object.life = 1;
6100
6101        object.add(patrol);
6102        object.add(life);
6103
6104        addStaticData(GameObjectType.GHOST_NPC, object, null);
6105        return object;
6106    }
6107
6108    private GameObject spawnCameraBias(float positionX, float positionY) {
6109    	GameObject object = mGameObjectPool.allocate();
6110        object.getPosition().set(positionX, positionY);
6111        object.activationRadius = mTightActivationRadius;
6112        object.width = 32;
6113        object.height = 32;
6114
6115        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.CAMERA_BIAS);
6116        if (staticData == null) {
6117            final int staticObjectCount = 1;
6118            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6119
6120            GameComponent bias = allocateComponent(CameraBiasComponent.class);
6121
6122            staticData.add(bias);
6123
6124            setStaticData(GameObjectType.CAMERA_BIAS, staticData);
6125        }
6126
6127        addStaticData(GameObjectType.CAMERA_BIAS, object, null);
6128        return object;
6129	}
6130
6131    public GameObject spawnEffectSmokeBig(float positionX, float positionY) {
6132        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
6133
6134        GameObject object = null;
6135        // This is just an effect, so we can live without it if our pools are exhausted.
6136        if (componentAvailable(RenderComponent.class, 1)) {
6137        	object = mGameObjectPool.allocate();
6138
6139	        object.getPosition().set(positionX, positionY);
6140	        object.activationRadius = mTightActivationRadius;
6141	        object.width = 32;
6142	        object.height = 32;
6143
6144	        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.SMOKE_BIG);
6145	        if (staticData == null) {
6146	            final int staticObjectCount = 6;
6147	            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6148
6149	            GameComponent movement = allocateComponent(MovementComponent.class);
6150
6151
6152	            AnimationFrame frame2 = new AnimationFrame(
6153	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big02),
6154	                    Utils.framesToTime(24, 1), null, null);
6155
6156	            AnimationFrame frame3 = new AnimationFrame(
6157	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big03),
6158	                    Utils.framesToTime(24, 1), null, null);
6159
6160	            AnimationFrame frame4 = new AnimationFrame(
6161	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big04),
6162	                    Utils.framesToTime(24, 1), null, null);
6163
6164	            AnimationFrame frame5 = new AnimationFrame(
6165	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big05),
6166	                    Utils.framesToTime(24, 1), null, null);
6167
6168	            SpriteAnimation idle = new SpriteAnimation(0, 5);
6169	            idle.addFrame(new AnimationFrame(
6170	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big01),
6171	                    Utils.framesToTime(24, 10), null, null));
6172	            idle.addFrame(frame2);
6173	            idle.addFrame(frame3);
6174	            idle.addFrame(frame4);
6175	            idle.addFrame(frame5);
6176
6177	            SpriteAnimation idle2 = new SpriteAnimation(1, 5);
6178	            idle2.addFrame(new AnimationFrame(
6179	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big01),
6180	                    Utils.framesToTime(24, 13), null, null));
6181	            idle2.addFrame(frame2);
6182	            idle2.addFrame(frame3);
6183	            idle2.addFrame(frame4);
6184	            idle2.addFrame(frame5);
6185
6186	            SpriteAnimation idle3 = new SpriteAnimation(2, 5);
6187	            idle3.addFrame(new AnimationFrame(
6188	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big01),
6189	                    Utils.framesToTime(24, 8), null, null));
6190	            idle3.addFrame(frame2);
6191	            idle3.addFrame(frame3);
6192	            idle3.addFrame(frame4);
6193	            idle3.addFrame(frame5);
6194
6195	            SpriteAnimation idle4 = new SpriteAnimation(3, 5);
6196	            idle4.addFrame(new AnimationFrame(
6197	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big01),
6198	                    Utils.framesToTime(24, 5), null, null));
6199	            idle4.addFrame(frame2);
6200	            idle4.addFrame(frame3);
6201	            idle4.addFrame(frame4);
6202	            idle4.addFrame(frame5);
6203
6204	            SpriteAnimation idle5 = new SpriteAnimation(4, 5);
6205	            idle5.addFrame(new AnimationFrame(
6206	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_big01),
6207	                    Utils.framesToTime(24, 15), null, null));
6208	            idle5.addFrame(frame2);
6209	            idle5.addFrame(frame3);
6210	            idle5.addFrame(frame4);
6211	            idle5.addFrame(frame5);
6212
6213	            staticData.add(idle);
6214	            staticData.add(idle2);
6215	            staticData.add(idle3);
6216	            staticData.add(idle4);
6217	            staticData.add(idle5);
6218	            staticData.add(movement);
6219	            setStaticData(GameObjectType.SMOKE_BIG, staticData);
6220	        }
6221
6222	        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
6223	        render.setPriority(SortConstants.EFFECT);
6224
6225	        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6226	        sprite.setSize((int)object.width, (int)object.height);
6227	        sprite.setRenderComponent(render);
6228
6229	        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6230	        lifetime.setDieWhenInvisible(true);
6231
6232	        object.destroyOnDeactivation = true;
6233
6234	        object.add(lifetime);
6235	        object.add(render);
6236	        object.add(sprite);
6237
6238	        addStaticData(GameObjectType.SMOKE_BIG, object, sprite);
6239
6240	        final int animIndex = (int)(Math.random() * sprite.getAnimationCount());
6241	        final SpriteAnimation idle = sprite.findAnimation(animIndex);
6242	        if (idle != null) {
6243	            lifetime.setTimeUntilDeath(idle.getLength());
6244	            sprite.playAnimation(animIndex);
6245	        }
6246
6247
6248        }
6249        return object;
6250    }
6251
6252    public GameObject spawnEffectSmokeSmall(float positionX, float positionY) {
6253        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
6254
6255        GameObject object = null;
6256        // This is just an effect, so we can live without it if our pools are exhausted.
6257        if (componentAvailable(RenderComponent.class, 1)) {
6258	        object = mGameObjectPool.allocate();
6259	        object.getPosition().set(positionX, positionY);
6260	        object.activationRadius = mAlwaysActive;
6261	        object.width = 16;
6262	        object.height = 16;
6263
6264	        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.SMOKE_SMALL);
6265	        if (staticData == null) {
6266	            final int staticObjectCount = 2;
6267	            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6268
6269	            GameComponent movement = allocateComponent(MovementComponent.class);
6270
6271	            SpriteAnimation idle = new SpriteAnimation(0, 5);
6272	            idle.addFrame(new AnimationFrame(
6273	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_small01),
6274	                    Utils.framesToTime(24, 10), null, null));
6275	            idle.addFrame(new AnimationFrame(
6276	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_small02),
6277	                    Utils.framesToTime(24, 1), null, null));
6278	            idle.addFrame(new AnimationFrame(
6279	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_small03),
6280	                    Utils.framesToTime(24, 1), null, null));
6281	            idle.addFrame(new AnimationFrame(
6282	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_small04),
6283	                    Utils.framesToTime(24, 1), null, null));
6284	            idle.addFrame(new AnimationFrame(
6285	                    textureLibrary.getTextureByResource(R.drawable.effect_smoke_small05),
6286	                    Utils.framesToTime(24, 1), null, null));
6287
6288	            staticData.add(idle);
6289	            staticData.add(movement);
6290	            setStaticData(GameObjectType.SMOKE_SMALL, staticData);
6291	        }
6292
6293	        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
6294	        render.setPriority(SortConstants.EFFECT);
6295
6296	        SpriteComponent sprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6297	        sprite.setSize((int)object.width, (int)object.height);
6298	        sprite.setRenderComponent(render);
6299
6300	        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6301	        lifetime.setDieWhenInvisible(true);
6302
6303	        object.destroyOnDeactivation = true;
6304
6305	        object.add(lifetime);
6306	        object.add(render);
6307	        object.add(sprite);
6308
6309	        addStaticData(GameObjectType.SMOKE_SMALL, object, sprite);
6310
6311	        final SpriteAnimation idle = sprite.findAnimation(0);
6312	        if (idle != null) {
6313	            lifetime.setTimeUntilDeath(idle.getLength());
6314	        }
6315
6316	        sprite.playAnimation(0);
6317        }
6318
6319        return object;
6320    }
6321
6322    public GameObject spawnEffectCrushFlash(float positionX, float positionY) {
6323        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
6324
6325        GameObject object = null;
6326        // This is just an effect, so we can live without it if our pools are exhausted.
6327        if (componentAvailable(RenderComponent.class, 1)) {
6328	        object = mGameObjectPool.allocate();
6329	        object.getPosition().set(positionX, positionY);
6330	        object.activationRadius = mAlwaysActive;
6331	        object.width = 64;
6332	        object.height = 64;
6333
6334	        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.CRUSH_FLASH);
6335	        if (staticData == null) {
6336	            final int staticObjectCount = 2;
6337	            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6338
6339	            SpriteAnimation back = new SpriteAnimation(0, 3);
6340	            back.addFrame(new AnimationFrame(
6341	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_back01),
6342	                    Utils.framesToTime(24, 1), null, null));
6343	            back.addFrame(new AnimationFrame(
6344	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_back02),
6345	                    Utils.framesToTime(24, 1), null, null));
6346	            back.addFrame(new AnimationFrame(
6347	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_back03),
6348	                    Utils.framesToTime(24, 1), null, null));
6349
6350	            SpriteAnimation front = new SpriteAnimation(1, 7);
6351	            front.addFrame(new AnimationFrame(
6352	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_front01),
6353	                    Utils.framesToTime(24, 1), null, null));
6354	            front.addFrame(new AnimationFrame(
6355	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_front02),
6356	                    Utils.framesToTime(24, 1), null, null));
6357	            front.addFrame(new AnimationFrame(
6358	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_front03),
6359	                    Utils.framesToTime(24, 1), null, null));
6360	            front.addFrame(new AnimationFrame(
6361	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_front04),
6362	                    Utils.framesToTime(24, 1), null, null));
6363	            front.addFrame(new AnimationFrame(
6364	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_front05),
6365	                    Utils.framesToTime(24, 1), null, null));
6366	            front.addFrame(new AnimationFrame(
6367	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_front06),
6368	                    Utils.framesToTime(24, 1), null, null));
6369	            front.addFrame(new AnimationFrame(
6370	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_front07),
6371	                    Utils.framesToTime(24, 1), null, null));
6372
6373
6374	            staticData.add(back);
6375	            staticData.add(front);
6376	            setStaticData(GameObjectType.CRUSH_FLASH, staticData);
6377	        }
6378
6379
6380	        RenderComponent backRender = (RenderComponent)allocateComponent(RenderComponent.class);
6381	        backRender.setPriority(SortConstants.EFFECT);
6382
6383	        SpriteComponent backSprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6384	        backSprite.setSize((int)object.width, (int)object.height);
6385	        backSprite.setRenderComponent(backRender);
6386
6387	        RenderComponent foreRender = (RenderComponent)allocateComponent(RenderComponent.class);
6388	        foreRender.setPriority(SortConstants.FOREGROUND_EFFECT);
6389
6390	        SpriteComponent foreSprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6391	        foreSprite.setSize((int)object.width, (int)object.height);
6392	        foreSprite.setRenderComponent(foreRender);
6393
6394	        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6395
6396
6397	        object.add(lifetime);
6398	        object.add(backRender);
6399	        object.add(foreRender);
6400	        object.add(foreSprite);
6401	        object.add(backSprite);
6402
6403	        addStaticData(GameObjectType.CRUSH_FLASH, object, backSprite);
6404	        addStaticData(GameObjectType.CRUSH_FLASH, null, foreSprite);
6405
6406
6407	        final SpriteAnimation idle = foreSprite.findAnimation(1);
6408	        if (idle != null) {
6409	            lifetime.setTimeUntilDeath(idle.getLength());
6410	        }
6411
6412	        backSprite.playAnimation(0);
6413	        foreSprite.playAnimation(1);
6414        }
6415
6416        return object;
6417    }
6418
6419    public GameObject spawnEffectFlash(float positionX, float positionY) {
6420        TextureLibrary textureLibrary = sSystemRegistry.longTermTextureLibrary;
6421        GameObject object = null;
6422        // This is just an effect, so we can live without it if our pools are exhausted.
6423        if (componentAvailable(RenderComponent.class, 1)) {
6424	        object = mGameObjectPool.allocate();
6425	        object.getPosition().set(positionX, positionY);
6426	        object.activationRadius = mAlwaysActive;
6427	        object.width = 64;
6428	        object.height = 64;
6429
6430	        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.FLASH);
6431	        if (staticData == null) {
6432	            final int staticObjectCount = 1;
6433	            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6434
6435	            SpriteAnimation back = new SpriteAnimation(0, 3);
6436	            back.addFrame(new AnimationFrame(
6437	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_back01),
6438	                    Utils.framesToTime(24, 1), null, null));
6439	            back.addFrame(new AnimationFrame(
6440	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_back02),
6441	                    Utils.framesToTime(24, 1), null, null));
6442	            back.addFrame(new AnimationFrame(
6443	                    textureLibrary.getTextureByResource(R.drawable.effect_crush_back03),
6444	                    Utils.framesToTime(24, 1), null, null));
6445
6446
6447	            staticData.add(back);
6448	            setStaticData(GameObjectType.FLASH, staticData);
6449	        }
6450
6451
6452	        RenderComponent backRender = (RenderComponent)allocateComponent(RenderComponent.class);
6453	        backRender.setPriority(SortConstants.EFFECT);
6454
6455	        SpriteComponent backSprite = (SpriteComponent)allocateComponent(SpriteComponent.class);
6456	        backSprite.setSize((int)object.width, (int)object.height);
6457	        backSprite.setRenderComponent(backRender);
6458
6459
6460
6461	        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6462
6463
6464	        object.add(lifetime);
6465	        object.add(backRender);
6466	        object.add(backSprite);
6467
6468	        addStaticData(GameObjectType.FLASH, object, backSprite);
6469
6470
6471	        final SpriteAnimation idle = backSprite.findAnimation(0);
6472	        if (idle != null) {
6473	            lifetime.setTimeUntilDeath(idle.getLength());
6474	        }
6475
6476	        backSprite.playAnimation(0);
6477        }
6478
6479        return object;
6480    }
6481
6482
6483    public GameObject spawnFrameRateWatcher(float positionX, float positionY) {
6484        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
6485        ContextParameters params = sSystemRegistry.contextParameters;
6486
6487        GameObject object = mGameObjectPool.allocate();
6488        object.getPosition().set(250, 0);	// HACK!
6489        object.activationRadius = mAlwaysActive;
6490        object.width = params.gameWidth;
6491        object.height = params.gameHeight;
6492
6493        DrawableBitmap indicator = new DrawableBitmap(
6494                textureLibrary.allocateTexture(R.drawable.framerate_warning),
6495                (int)object.width,
6496                (int)object.height);
6497
6498        indicator.setCrop(0, 8, 8, 8); // hack!  this shouldn't be hard-coded.
6499
6500        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
6501        render.setPriority(SortConstants.OVERLAY);
6502        render.setCameraRelative(false);
6503
6504        FrameRateWatcherComponent watcher = (FrameRateWatcherComponent)allocateComponent(FrameRateWatcherComponent.class);
6505        watcher.setup(render, indicator);
6506
6507        object.add(render);
6508        object.add(watcher);
6509
6510
6511        return object;
6512    }
6513
6514    public GameObject spawnBreakableBlockPiece(float positionX, float positionY) {
6515        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
6516
6517        GameObject object = mGameObjectPool.allocate();
6518        object.getPosition().set(positionX, positionY);
6519        object.activationRadius = mTightActivationRadius;
6520        object.width = 16;
6521        object.height = 16;
6522
6523        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.BREAKABLE_BLOCK_PIECE);
6524        if (staticData == null) {
6525            final int staticObjectCount = 4;
6526            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6527
6528            GameComponent gravity = allocateComponent(GravityComponent.class);
6529            GameComponent movement = allocateComponent(MovementComponent.class);
6530
6531            SimplePhysicsComponent physics = (SimplePhysicsComponent)allocateComponent(SimplePhysicsComponent.class);
6532            physics.setBounciness(0.3f);
6533
6534            DrawableBitmap piece = new DrawableBitmap(
6535                    textureLibrary.getTextureByResource(R.drawable.object_debris_piece),
6536                    (int)object.width,
6537                    (int)object.height);
6538
6539
6540            RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
6541            render.setPriority(SortConstants.GENERAL_OBJECT);
6542            render.setDrawable(piece);
6543
6544            staticData.add(render);
6545            staticData.add(movement);
6546            staticData.add(gravity);
6547            staticData.add(physics);
6548            setStaticData(GameObjectType.BREAKABLE_BLOCK_PIECE, staticData);
6549        }
6550
6551        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6552        lifetime.setTimeUntilDeath(3.0f);
6553
6554        BackgroundCollisionComponent bgcollision = (BackgroundCollisionComponent)allocateComponent(BackgroundCollisionComponent.class);
6555        bgcollision.setSize(12, 12);
6556        bgcollision.setOffset(2, 2);
6557
6558
6559        object.destroyOnDeactivation = true;
6560
6561        object.add(lifetime);
6562        object.add(bgcollision);
6563
6564        addStaticData(GameObjectType.BREAKABLE_BLOCK_PIECE, object, null);
6565
6566        return object;
6567    }
6568
6569    public GameObject spawnBreakableBlockPieceSpawner(float positionX, float positionY) {
6570
6571        GameObject object = mGameObjectPool.allocate();
6572        object.getPosition().set(positionX, positionY);
6573        object.activationRadius = mTightActivationRadius;
6574        object.width = 1;
6575        object.height = 1;
6576
6577        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6578        lifetime.setTimeUntilDeath(0.5f);
6579
6580        LaunchProjectileComponent pieceSpawner
6581            = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
6582        pieceSpawner.setObjectTypeToSpawn(GameObjectType.BREAKABLE_BLOCK_PIECE);
6583        pieceSpawner.setDelayBeforeFirstSet(0.0f);
6584        pieceSpawner.setSetsPerActivation(1);
6585        pieceSpawner.setShotsPerSet(3);
6586        pieceSpawner.setDelayBetweenShots(0.0f);
6587        pieceSpawner.setOffsetX(16);
6588        pieceSpawner.setOffsetY(16);
6589        pieceSpawner.setVelocityX(600.0f);
6590        pieceSpawner.setVelocityY(-1000.0f);
6591        pieceSpawner.setThetaError(1.0f);
6592
6593        object.life = 1;
6594        object.destroyOnDeactivation = true;
6595
6596        object.add(lifetime);
6597        object.add(pieceSpawner);
6598
6599        return object;
6600    }
6601
6602    public GameObject spawnSmokePoof(float positionX, float positionY) {
6603
6604    	GameObject object = null;
6605        // This is just an effect, so we can live without it if our pools are exhausted.
6606        if (componentAvailable(LaunchProjectileComponent.class, 2)) {
6607	        object = mGameObjectPool.allocate();
6608	        object.getPosition().set(positionX, positionY);
6609	        object.activationRadius = mTightActivationRadius;
6610	        object.width = 1;
6611	        object.height = 1;
6612
6613	        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6614	        lifetime.setTimeUntilDeath(0.5f);
6615
6616	        LaunchProjectileComponent smokeGun
6617		        = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
6618	        smokeGun.setSetsPerActivation(1);
6619	        smokeGun.setShotsPerSet(3);
6620		    smokeGun.setDelayBetweenShots(0.0f);
6621		    smokeGun.setObjectTypeToSpawn(GameObjectType.SMOKE_BIG);
6622		    smokeGun.setVelocityX(200.0f);
6623		    smokeGun.setVelocityY(200.0f);
6624		    smokeGun.setOffsetX(16);
6625		    smokeGun.setOffsetY(16);
6626		    smokeGun.setThetaError(1.0f);
6627
6628		    LaunchProjectileComponent smokeGun2
6629		        = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
6630		    smokeGun2.setSetsPerActivation(1);
6631		    smokeGun2.setShotsPerSet(3);
6632		    smokeGun2.setDelayBetweenShots(0.0f);
6633		    smokeGun2.setObjectTypeToSpawn(GameObjectType.SMOKE_SMALL);
6634		    smokeGun2.setVelocityX(200.0f);
6635		    smokeGun2.setVelocityY(200.0f);
6636		    smokeGun2.setThetaError(1.0f);
6637		    smokeGun2.setOffsetX(16);
6638		    smokeGun2.setOffsetY(16);
6639
6640	        object.life = 1;
6641	        object.destroyOnDeactivation = true;
6642
6643	        object.add(lifetime);
6644	        object.add(smokeGun);
6645	        object.add(smokeGun2);
6646        }
6647        return object;
6648    }
6649
6650    public GameObject spawnGemEffect(float positionX, float positionY) {
6651        TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
6652
6653        GameObject object = mGameObjectPool.allocate();
6654        object.getPosition().set(positionX, positionY);
6655        object.activationRadius = mTightActivationRadius;
6656        object.width = 32;
6657        object.height = 32;
6658
6659        FixedSizeArray<BaseObject> staticData = getStaticData(GameObjectType.GEM_EFFECT);
6660        if (staticData == null) {
6661            final int staticObjectCount = 2;
6662            staticData = new FixedSizeArray<BaseObject>(staticObjectCount);
6663
6664            GameComponent movement = allocateComponent(MovementComponent.class);
6665
6666            staticData.add(movement);
6667
6668            setStaticData(GameObjectType.GEM_EFFECT, staticData);
6669        }
6670
6671        RenderComponent render = (RenderComponent)allocateComponent(RenderComponent.class);
6672        render.setPriority(SortConstants.EFFECT);
6673
6674        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6675        lifetime.setTimeUntilDeath(0.5f);
6676
6677        FadeDrawableComponent fadeOut = (FadeDrawableComponent)allocateComponent(FadeDrawableComponent.class);
6678        fadeOut.setupFade(1.0f, 0.0f, 0.5f, FadeDrawableComponent.LOOP_TYPE_NONE, FadeDrawableComponent.FADE_LINEAR, 0.0f);
6679        fadeOut.setTexture(textureLibrary.allocateTexture(R.drawable.object_ruby01));
6680        fadeOut.setRenderComponent(render);
6681
6682        object.destroyOnDeactivation = true;
6683
6684        object.add(lifetime);
6685        object.add(fadeOut);
6686        object.add(render);
6687
6688        addStaticData(GameObjectType.GEM_EFFECT, object, null);
6689
6690        return object;
6691    }
6692
6693    public GameObject spawnGemEffectSpawner(float positionX, float positionY) {
6694
6695        GameObject object = mGameObjectPool.allocate();
6696        object.getPosition().set(positionX, positionY);
6697        object.activationRadius = mTightActivationRadius;
6698        object.width = 1;
6699        object.height = 1;
6700
6701        LifetimeComponent lifetime = (LifetimeComponent)allocateComponent(LifetimeComponent.class);
6702        lifetime.setTimeUntilDeath(0.5f);
6703
6704        final int gems = 6;
6705        final float angleIncrement = (float)(2.0f * Math.PI) / gems;
6706        for (int x = 0; x < gems; x++) {
6707	        LaunchProjectileComponent gemGun
6708		        = (LaunchProjectileComponent)allocateComponent(LaunchProjectileComponent.class);
6709	        gemGun.setSetsPerActivation(1);
6710	        gemGun.setShotsPerSet(1);
6711	        gemGun.setDelayBetweenShots(0.0f);
6712	        gemGun.setObjectTypeToSpawn(GameObjectType.GEM_EFFECT);
6713	        gemGun.setVelocityX((float)Math.sin(angleIncrement * x) * 150.0f);
6714	        gemGun.setVelocityY((float)Math.cos(angleIncrement * x) * 150.0f);
6715	        gemGun.setOffsetX(16);
6716	        gemGun.setOffsetY(16);
6717
6718	        object.add(gemGun);
6719        }
6720
6721
6722
6723        object.life = 1;
6724        object.destroyOnDeactivation = true;
6725
6726        object.add(lifetime);
6727
6728
6729        return object;
6730    }
6731
6732    /** Comparator for game objects objects. */
6733    private final static class ComponentPoolComparator implements Comparator<GameComponentPool> {
6734        public int compare(final GameComponentPool object1, final GameComponentPool object2) {
6735            int result = 0;
6736            if (object1 == null && object2 != null) {
6737                result = 1;
6738            } else if (object1 != null && object2 == null) {
6739                result = -1;
6740            } else if (object1 != null && object2 != null) {
6741                result = object1.objectClass.hashCode() - object2.objectClass.hashCode();
6742            }
6743            return result;
6744        }
6745    }
6746
6747    public class GameObjectPool extends TObjectPool<GameObject> {
6748
6749        public GameObjectPool() {
6750            super();
6751        }
6752
6753        public GameObjectPool(int size) {
6754            super(size);
6755        }
6756
6757        @Override
6758        protected void fill() {
6759            for (int x = 0; x < getSize(); x++) {
6760                getAvailable().add(new GameObject());
6761            }
6762        }
6763
6764        @Override
6765        public void release(Object entry) {
6766            ((GameObject)entry).reset();
6767            super.release(entry);
6768        }
6769
6770    }
6771}
6772
6773