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
18package com.replica.replicaisland;
19
20public 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