Home | History | Annotate | Download | only in replicaisland 
      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 
     17 
     18 package com.replica.replicaisland;
     19 
     20 public class LevelBuilder extends BaseObject {
     21     private final static int THEME_GRASS = 0;
     22     private final static int THEME_ISLAND = 1;
     23     private final static int THEME_SEWER = 2;
     24     private final static int THEME_UNDERGROUND = 3;
     25     private final static int THEME_LAB = 4;
     26     private final static int THEME_LIGHTING = 5;
     27     private final static int THEME_TUTORIAL = 6;
     28 
     29 
     30     private final static int BACKGROUND_SUNSET = 0;
     31     private final static int BACKGROUND_ISLAND = 1;
     32     private final static int BACKGROUND_SEWER = 2;
     33     private final static int BACKGROUND_UNDERGROUND = 3;
     34     private final static int BACKGROUND_FOREST = 4;
     35     private final static int BACKGROUND_ISLAND2 = 5;
     36     private final static int BACKGROUND_LAB = 6;
     37 
     38     public LevelBuilder() {
     39         super();
     40     }
     41 
     42     @Override
     43     public void reset() {
     44     }
     45 
     46 
     47     public GameObject buildBackground(int backgroundImage, int levelWidth, int levelHeight) {
     48         // Generate the scrolling background.
     49         TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
     50 
     51         GameObject background = new GameObject();
     52 
     53         if (textureLibrary != null) {
     54 
     55             int backgroundResource = -1;
     56 
     57             switch (backgroundImage) {
     58                 case BACKGROUND_SUNSET:
     59                     backgroundResource = R.drawable.background_sunset;
     60                     break;
     61                 case BACKGROUND_ISLAND:
     62                     backgroundResource = R.drawable.background_island;
     63                     break;
     64                 case BACKGROUND_SEWER:
     65                     backgroundResource = R.drawable.background_sewage;
     66                     break;
     67                 case BACKGROUND_UNDERGROUND:
     68                     backgroundResource = R.drawable.background_underground;
     69                     break;
     70                 case BACKGROUND_FOREST:
     71                     backgroundResource = R.drawable.background_grass2;
     72                     break;
     73                 case BACKGROUND_ISLAND2:
     74                     backgroundResource = R.drawable.background_island2;
     75                     break;
     76                 case BACKGROUND_LAB:
     77                     backgroundResource = R.drawable.background_lab01;
     78                     break;
     79                 default:
     80                     assert false;
     81             }
     82 
     83             if (backgroundResource > -1) {
     84 
     85                 // Background Layer //
     86                 RenderComponent backgroundRender = new RenderComponent();
     87                 backgroundRender.setPriority(SortConstants.BACKGROUND_START);
     88 
     89                 ContextParameters params = sSystemRegistry.contextParameters;
     90                 // The background image is ideally 1.5 times the size of the largest screen axis
     91                 // (normally the width, but just in case, let's calculate it).
     92                 final int idealSize = (int)Math.max(params.gameWidth * 1.5f, params.gameHeight * 1.5f);
     93                 int width = idealSize;
     94                 int height = idealSize;
     95 
     96                 ScrollerComponent scroller3 =
     97                         new ScrollerComponent(0.0f, 0.0f, width, height,
     98                             textureLibrary.allocateTexture(backgroundResource));
     99                 scroller3.setRenderComponent(backgroundRender);
    100 
    101                 // Scroll speeds such that the background will evenly match the beginning
    102                 // and end of the level.  Don't allow speeds > 1.0, though; that would be faster than
    103                 // the foreground, which is disorienting and looks like rotation.
    104                 final float scrollSpeedX = Math.min((float)(width - params.gameWidth) / (levelWidth - params.gameWidth), 1.0f);
    105                 final float scrollSpeedY = Math.min((float)(height - params.gameHeight) / (levelHeight - params.gameHeight), 1.0f);
    106 
    107 
    108                 scroller3.setScrollSpeed(scrollSpeedX, scrollSpeedY);
    109 
    110                 backgroundRender.setCameraRelative(false);
    111 
    112                 background.add(scroller3);
    113                 background.add(backgroundRender);
    114             }
    115         }
    116         return background;
    117     }
    118 
    119     public void addTileMapLayer(GameObject background, int priority, float scrollSpeed,
    120             int width, int height, int tileWidth, int tileHeight, TiledWorld world,
    121             int theme) {
    122 
    123         int tileMapIndex = 0;
    124         switch(theme) {
    125             case THEME_GRASS:
    126                 tileMapIndex = R.drawable.grass;
    127                 break;
    128             case THEME_ISLAND:
    129                 tileMapIndex = R.drawable.island;
    130                 break;
    131             case THEME_SEWER:
    132                 tileMapIndex = R.drawable.sewage;
    133                 break;
    134             case THEME_UNDERGROUND:
    135                 tileMapIndex = R.drawable.cave;
    136                 break;
    137             case THEME_LAB:
    138                 tileMapIndex = R.drawable.lab;
    139                 break;
    140             case THEME_LIGHTING:
    141                 tileMapIndex = R.drawable.titletileset;
    142                 priority = SortConstants.OVERLAY; //hack!
    143                 break;
    144             case THEME_TUTORIAL:
    145                 tileMapIndex = R.drawable.tutorial;
    146                 break;
    147             default:
    148                 assert false;
    149         }
    150 
    151         RenderComponent backgroundRender = new RenderComponent();
    152         backgroundRender.setPriority(priority);
    153 
    154         //Vertex Buffer Code
    155         TextureLibrary textureLibrary = sSystemRegistry.shortTermTextureLibrary;
    156         TiledVertexGrid bg = new TiledVertexGrid(textureLibrary.allocateTexture(tileMapIndex),
    157                 width, height, tileWidth, tileHeight);
    158         bg.setWorld(world);
    159 
    160         //TODO: The map format should really just output independent speeds for x and y,
    161         // but as a short term solution we can assume parallax layers lock in the smaller
    162         // direction of movement.
    163         float xScrollSpeed = 1.0f;
    164         float yScrollSpeed = 1.0f;
    165 
    166         if (world.getWidth() > world.getHeight()) {
    167         	xScrollSpeed = scrollSpeed;
    168         } else {
    169         	yScrollSpeed = scrollSpeed;
    170         }
    171 
    172         ScrollerComponent scroller = new ScrollerComponent(xScrollSpeed, yScrollSpeed,
    173                 width, height, bg);
    174         scroller.setRenderComponent(backgroundRender);
    175 
    176         background.add(scroller);
    177         background.add(backgroundRender);
    178         backgroundRender.setCameraRelative(false);
    179     }
    180 
    181     // This method is a HACK to workaround the stupid map file format.
    182     // We want the foreground layer to be render priority FOREGROUND, but
    183     // we don't know which is the foreground layer until we've added them all.
    184     // So now that we've added them all, find foreground layer and make sure
    185     // its render priority is set.
    186 	public void promoteForegroundLayer(GameObject backgroundObject) {
    187 		backgroundObject.commitUpdates();	// Make sure layers are sorted.
    188 		final int componentCount = backgroundObject.getCount();
    189 		for (int x = componentCount - 1; x >= 0; x--) {
    190 			GameComponent component = (GameComponent)backgroundObject.get(x);
    191 			if (component instanceof RenderComponent) {
    192 				RenderComponent render = (RenderComponent)component;
    193 				if (render.getPriority() != SortConstants.OVERLAY) {
    194 					// found it.
    195 					render.setPriority(SortConstants.FOREGROUND);
    196 					break;
    197 				}
    198 			}
    199 		}
    200 	}
    201 
    202 }
    203