001    package net.minecraft.src;
002    
003    import java.util.Map;
004    
005    import com.google.common.collect.Maps;
006    
007    import cpw.mods.fml.common.Side;
008    import cpw.mods.fml.common.asm.SideOnly;
009    
010    public class WorldInfo
011    {
012        /** Holds the seed of the currently world. */
013        private long randomSeed;
014        private WorldType terrainType;
015    
016        /** The spawn zone position X coordinate. */
017        private int spawnX;
018    
019        /** The spawn zone position Y coordinate. */
020        private int spawnY;
021    
022        /** The spawn zone position Z coordinate. */
023        private int spawnZ;
024    
025        /** The current world time in ticks, ranging from 0 to 23999. */
026        private long worldTime;
027    
028        /** The last time the player was in this world. */
029        private long lastTimePlayed;
030    
031        /** The size of entire save of current world on the disk, isn't exactly. */
032        private long sizeOnDisk;
033        private NBTTagCompound playerTag;
034        private int dimension;
035    
036        /** The name of the save defined at world creation. */
037        private String levelName;
038    
039        /** Introduced in beta 1.3, is the save version for future control. */
040        private int saveVersion;
041    
042        /** True if it's raining, false otherwise. */
043        private boolean raining;
044    
045        /** Number of ticks until next rain. */
046        private int rainTime;
047    
048        /** Is thunderbolts failing now? */
049        private boolean thundering;
050    
051        /** Number of ticks untils next thunderbolt. */
052        private int thunderTime;
053    
054        /** The Game Type. */
055        private EnumGameType theGameType;
056    
057        /**
058         * Whether the map features (e.g. strongholds) generation is enabled or disabled.
059         */
060        private boolean mapFeaturesEnabled;
061    
062        /** Hardcore mode flag */
063        private boolean hardcore;
064        private boolean allowCommands;
065        private boolean initialized;
066        private Map<String,NBTBase> additionalProperties;
067    
068        protected WorldInfo()
069        {
070            this.terrainType = WorldType.DEFAULT;
071        }
072    
073        public WorldInfo(NBTTagCompound par1NBTTagCompound)
074        {
075            this.terrainType = WorldType.DEFAULT;
076            this.randomSeed = par1NBTTagCompound.getLong("RandomSeed");
077    
078            if (par1NBTTagCompound.hasKey("generatorName"))
079            {
080                String var2 = par1NBTTagCompound.getString("generatorName");
081                this.terrainType = WorldType.parseWorldType(var2);
082    
083                if (this.terrainType == null)
084                {
085                    this.terrainType = WorldType.DEFAULT;
086                }
087                else if (this.terrainType.isVersioned())
088                {
089                    int var3 = 0;
090    
091                    if (par1NBTTagCompound.hasKey("generatorVersion"))
092                    {
093                        var3 = par1NBTTagCompound.getInteger("generatorVersion");
094                    }
095    
096                    this.terrainType = this.terrainType.getWorldTypeForGeneratorVersion(var3);
097                }
098            }
099    
100            this.theGameType = EnumGameType.getByID(par1NBTTagCompound.getInteger("GameType"));
101    
102            if (par1NBTTagCompound.hasKey("MapFeatures"))
103            {
104                this.mapFeaturesEnabled = par1NBTTagCompound.getBoolean("MapFeatures");
105            }
106            else
107            {
108                this.mapFeaturesEnabled = true;
109            }
110    
111            this.spawnX = par1NBTTagCompound.getInteger("SpawnX");
112            this.spawnY = par1NBTTagCompound.getInteger("SpawnY");
113            this.spawnZ = par1NBTTagCompound.getInteger("SpawnZ");
114            this.worldTime = par1NBTTagCompound.getLong("Time");
115            this.lastTimePlayed = par1NBTTagCompound.getLong("LastPlayed");
116            this.sizeOnDisk = par1NBTTagCompound.getLong("SizeOnDisk");
117            this.levelName = par1NBTTagCompound.getString("LevelName");
118            this.saveVersion = par1NBTTagCompound.getInteger("version");
119            this.rainTime = par1NBTTagCompound.getInteger("rainTime");
120            this.raining = par1NBTTagCompound.getBoolean("raining");
121            this.thunderTime = par1NBTTagCompound.getInteger("thunderTime");
122            this.thundering = par1NBTTagCompound.getBoolean("thundering");
123            this.hardcore = par1NBTTagCompound.getBoolean("hardcore");
124    
125            if (par1NBTTagCompound.hasKey("initialized"))
126            {
127                this.initialized = par1NBTTagCompound.getBoolean("initialized");
128            }
129            else
130            {
131                this.initialized = true;
132            }
133    
134            if (par1NBTTagCompound.hasKey("allowCommands"))
135            {
136                this.allowCommands = par1NBTTagCompound.getBoolean("allowCommands");
137            }
138            else
139            {
140                this.allowCommands = this.theGameType == EnumGameType.CREATIVE;
141            }
142    
143            if (par1NBTTagCompound.hasKey("Player"))
144            {
145                this.playerTag = par1NBTTagCompound.getCompoundTag("Player");
146                this.dimension = this.playerTag.getInteger("Dimension");
147            }
148        }
149    
150        public WorldInfo(WorldSettings par1WorldSettings, String par2Str)
151        {
152            this.terrainType = WorldType.DEFAULT;
153            this.randomSeed = par1WorldSettings.getSeed();
154            this.theGameType = par1WorldSettings.getGameType();
155            this.mapFeaturesEnabled = par1WorldSettings.isMapFeaturesEnabled();
156            this.levelName = par2Str;
157            this.hardcore = par1WorldSettings.getHardcoreEnabled();
158            this.terrainType = par1WorldSettings.getTerrainType();
159            this.allowCommands = par1WorldSettings.areCommandsAllowed();
160            this.initialized = false;
161        }
162    
163        public WorldInfo(WorldInfo par1WorldInfo)
164        {
165            this.terrainType = WorldType.DEFAULT;
166            this.randomSeed = par1WorldInfo.randomSeed;
167            this.terrainType = par1WorldInfo.terrainType;
168            this.theGameType = par1WorldInfo.theGameType;
169            this.mapFeaturesEnabled = par1WorldInfo.mapFeaturesEnabled;
170            this.spawnX = par1WorldInfo.spawnX;
171            this.spawnY = par1WorldInfo.spawnY;
172            this.spawnZ = par1WorldInfo.spawnZ;
173            this.worldTime = par1WorldInfo.worldTime;
174            this.lastTimePlayed = par1WorldInfo.lastTimePlayed;
175            this.sizeOnDisk = par1WorldInfo.sizeOnDisk;
176            this.playerTag = par1WorldInfo.playerTag;
177            this.dimension = par1WorldInfo.dimension;
178            this.levelName = par1WorldInfo.levelName;
179            this.saveVersion = par1WorldInfo.saveVersion;
180            this.rainTime = par1WorldInfo.rainTime;
181            this.raining = par1WorldInfo.raining;
182            this.thunderTime = par1WorldInfo.thunderTime;
183            this.thundering = par1WorldInfo.thundering;
184            this.hardcore = par1WorldInfo.hardcore;
185            this.allowCommands = par1WorldInfo.allowCommands;
186            this.initialized = par1WorldInfo.initialized;
187        }
188    
189        /**
190         * Gets the NBTTagCompound for the worldInfo
191         */
192        public NBTTagCompound getNBTTagCompound()
193        {
194            NBTTagCompound var1 = new NBTTagCompound();
195            this.updateTagCompound(var1, this.playerTag);
196            return var1;
197        }
198    
199        /**
200         * Creates a new NBTTagCompound for the world, with the given NBTTag as the "Player"
201         */
202        public NBTTagCompound cloneNBTCompound(NBTTagCompound par1NBTTagCompound)
203        {
204            NBTTagCompound var2 = new NBTTagCompound();
205            this.updateTagCompound(var2, par1NBTTagCompound);
206            return var2;
207        }
208    
209        private void updateTagCompound(NBTTagCompound par1NBTTagCompound, NBTTagCompound par2NBTTagCompound)
210        {
211            par1NBTTagCompound.setLong("RandomSeed", this.randomSeed);
212            par1NBTTagCompound.setString("generatorName", this.terrainType.getWorldTypeName());
213            par1NBTTagCompound.setInteger("generatorVersion", this.terrainType.getGeneratorVersion());
214            par1NBTTagCompound.setInteger("GameType", this.theGameType.getID());
215            par1NBTTagCompound.setBoolean("MapFeatures", this.mapFeaturesEnabled);
216            par1NBTTagCompound.setInteger("SpawnX", this.spawnX);
217            par1NBTTagCompound.setInteger("SpawnY", this.spawnY);
218            par1NBTTagCompound.setInteger("SpawnZ", this.spawnZ);
219            par1NBTTagCompound.setLong("Time", this.worldTime);
220            par1NBTTagCompound.setLong("SizeOnDisk", this.sizeOnDisk);
221            par1NBTTagCompound.setLong("LastPlayed", System.currentTimeMillis());
222            par1NBTTagCompound.setString("LevelName", this.levelName);
223            par1NBTTagCompound.setInteger("version", this.saveVersion);
224            par1NBTTagCompound.setInteger("rainTime", this.rainTime);
225            par1NBTTagCompound.setBoolean("raining", this.raining);
226            par1NBTTagCompound.setInteger("thunderTime", this.thunderTime);
227            par1NBTTagCompound.setBoolean("thundering", this.thundering);
228            par1NBTTagCompound.setBoolean("hardcore", this.hardcore);
229            par1NBTTagCompound.setBoolean("allowCommands", this.allowCommands);
230            par1NBTTagCompound.setBoolean("initialized", this.initialized);
231    
232            if (par2NBTTagCompound != null)
233            {
234                par1NBTTagCompound.setCompoundTag("Player", par2NBTTagCompound);
235            }
236        }
237    
238        /**
239         * Returns the seed of current world.
240         */
241        public long getSeed()
242        {
243            return this.randomSeed;
244        }
245    
246        /**
247         * Returns the x spawn position
248         */
249        public int getSpawnX()
250        {
251            return this.spawnX;
252        }
253    
254        /**
255         * Return the Y axis spawning point of the player.
256         */
257        public int getSpawnY()
258        {
259            return this.spawnY;
260        }
261    
262        /**
263         * Returns the z spawn position
264         */
265        public int getSpawnZ()
266        {
267            return this.spawnZ;
268        }
269    
270        /**
271         * Get current world time
272         */
273        public long getWorldTime()
274        {
275            return this.worldTime;
276        }
277    
278        @SideOnly(Side.CLIENT)
279        public long getSizeOnDisk()
280        {
281            return this.sizeOnDisk;
282        }
283    
284        /**
285         * Returns the player's NBTTagCompound to be loaded
286         */
287        public NBTTagCompound getPlayerNBTTagCompound()
288        {
289            return this.playerTag;
290        }
291    
292        public int getDimension()
293        {
294            return this.dimension;
295        }
296    
297        @SideOnly(Side.CLIENT)
298    
299        /**
300         * Set the x spawn position to the passed in value
301         */
302        public void setSpawnX(int par1)
303        {
304            this.spawnX = par1;
305        }
306    
307        @SideOnly(Side.CLIENT)
308    
309        /**
310         * Sets the y spawn position
311         */
312        public void setSpawnY(int par1)
313        {
314            this.spawnY = par1;
315        }
316    
317        /**
318         * Set current world time
319         */
320        public void setWorldTime(long par1)
321        {
322            this.worldTime = par1;
323        }
324    
325        @SideOnly(Side.CLIENT)
326    
327        /**
328         * Set the z spawn position to the passed in value
329         */
330        public void setSpawnZ(int par1)
331        {
332            this.spawnZ = par1;
333        }
334    
335        /**
336         * Sets the spawn zone position. Args: x, y, z
337         */
338        public void setSpawnPosition(int par1, int par2, int par3)
339        {
340            this.spawnX = par1;
341            this.spawnY = par2;
342            this.spawnZ = par3;
343        }
344    
345        /**
346         * Get current world name
347         */
348        public String getWorldName()
349        {
350            return this.levelName;
351        }
352    
353        public void setWorldName(String par1Str)
354        {
355            this.levelName = par1Str;
356        }
357    
358        /**
359         * Returns the save version of this world
360         */
361        public int getSaveVersion()
362        {
363            return this.saveVersion;
364        }
365    
366        /**
367         * Sets the save version of the world
368         */
369        public void setSaveVersion(int par1)
370        {
371            this.saveVersion = par1;
372        }
373    
374        @SideOnly(Side.CLIENT)
375    
376        /**
377         * Return the last time the player was in this world.
378         */
379        public long getLastTimePlayed()
380        {
381            return this.lastTimePlayed;
382        }
383    
384        /**
385         * Returns true if it is thundering, false otherwise.
386         */
387        public boolean isThundering()
388        {
389            return this.thundering;
390        }
391    
392        /**
393         * Sets whether it is thundering or not.
394         */
395        public void setThundering(boolean par1)
396        {
397            this.thundering = par1;
398        }
399    
400        /**
401         * Returns the number of ticks until next thunderbolt.
402         */
403        public int getThunderTime()
404        {
405            return this.thunderTime;
406        }
407    
408        /**
409         * Defines the number of ticks until next thunderbolt.
410         */
411        public void setThunderTime(int par1)
412        {
413            this.thunderTime = par1;
414        }
415    
416        /**
417         * Returns true if it is raining, false otherwise.
418         */
419        public boolean isRaining()
420        {
421            return this.raining;
422        }
423    
424        /**
425         * Sets whether it is raining or not.
426         */
427        public void setRaining(boolean par1)
428        {
429            this.raining = par1;
430        }
431    
432        /**
433         * Return the number of ticks until rain.
434         */
435        public int getRainTime()
436        {
437            return this.rainTime;
438        }
439    
440        /**
441         * Sets the number of ticks until rain.
442         */
443        public void setRainTime(int par1)
444        {
445            this.rainTime = par1;
446        }
447    
448        /**
449         * Gets the GameType.
450         */
451        public EnumGameType getGameType()
452        {
453            return this.theGameType;
454        }
455    
456        /**
457         * Get whether the map features (e.g. strongholds) generation is enabled or disabled.
458         */
459        public boolean isMapFeaturesEnabled()
460        {
461            return this.mapFeaturesEnabled;
462        }
463    
464        /**
465         * Sets the GameType.
466         */
467        public void setGameType(EnumGameType par1EnumGameType)
468        {
469            this.theGameType = par1EnumGameType;
470        }
471    
472        /**
473         * Returns true if hardcore mode is enabled, otherwise false
474         */
475        public boolean isHardcoreModeEnabled()
476        {
477            return this.hardcore;
478        }
479    
480        public WorldType getTerrainType()
481        {
482            return this.terrainType;
483        }
484    
485        public void setTerrainType(WorldType par1WorldType)
486        {
487            this.terrainType = par1WorldType;
488        }
489    
490        /**
491         * Returns true if commands are allowed on this World.
492         */
493        public boolean areCommandsAllowed()
494        {
495            return this.allowCommands;
496        }
497    
498        /**
499         * Returns true if the World is initialized.
500         */
501        public boolean isInitialized()
502        {
503            return this.initialized;
504        }
505    
506        /**
507         * Sets the initialization status of the World.
508         */
509        public void setServerInitialized(boolean par1)
510        {
511            this.initialized = par1;
512        }
513    
514        /**
515         * Allow access to additional mod specific world based properties
516         * Used by FML to store mod list associated with a world, and maybe an id map
517         * Used by Forge to store the dimensions available to a world
518         * @param additionalProperties
519         */
520        public void setAdditionalProperties(Map<String,NBTBase> additionalProperties)
521        {
522            // one time set for this
523            if (this.additionalProperties == null)
524            {
525                this.additionalProperties = additionalProperties;
526            }
527        }
528    
529        public NBTBase getAdditionalProperty(String additionalProperty)
530        {
531            return this.additionalProperties!=null? this.additionalProperties.get(additionalProperty) : null;
532        }
533    }