mirror of
https://github.com/MinecraftForge/MinecraftForge.git
synced 2026-11-21 04:32:15 +00:00
303 lines
10 KiB
Java
303 lines
10 KiB
Java
package net.minecraftforge.common;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.BitSet;
|
|
import java.util.Hashtable;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.logging.Level;
|
|
|
|
import com.google.common.collect.ArrayListMultimap;
|
|
import com.google.common.collect.ImmutableListMultimap;
|
|
import com.google.common.collect.ListMultimap;
|
|
import com.google.common.collect.Maps;
|
|
|
|
import cpw.mods.fml.common.FMLCommonHandler;
|
|
import cpw.mods.fml.common.FMLLog;
|
|
|
|
import net.minecraft.server.MinecraftServer;
|
|
import net.minecraft.src.*;
|
|
import net.minecraftforge.event.world.WorldEvent;
|
|
|
|
public class DimensionManager
|
|
{
|
|
private static Hashtable<Integer, Class<? extends WorldProvider>> providers = new Hashtable<Integer, Class<? extends WorldProvider>>();
|
|
private static Hashtable<Integer, Boolean> spawnSettings = new Hashtable<Integer, Boolean>();
|
|
private static Hashtable<Integer, WorldServer> worlds = new Hashtable<Integer, WorldServer>();
|
|
private static boolean hasInit = false;
|
|
private static Hashtable<Integer, Integer> dimensions = new Hashtable<Integer, Integer>();
|
|
private static Map<World, ListMultimap<ChunkCoordIntPair, String>> persistentChunkStore = Maps.newHashMap(); //FIXME: Unused?
|
|
private static ArrayList<Integer> unloadQueue = new ArrayList<Integer>();
|
|
private static BitSet dimensionMap = new BitSet(Long.SIZE << 4);
|
|
|
|
public static boolean registerProviderType(int id, Class<? extends WorldProvider> provider, boolean keepLoaded)
|
|
{
|
|
if (providers.containsValue(id))
|
|
{
|
|
return false;
|
|
}
|
|
providers.put(id, provider);
|
|
spawnSettings.put(id, keepLoaded);
|
|
return true;
|
|
}
|
|
|
|
public static void init()
|
|
{
|
|
if (hasInit)
|
|
{
|
|
return;
|
|
}
|
|
registerProviderType( 0, WorldProviderSurface.class, true);
|
|
registerProviderType(-1, WorldProviderHell.class, true);
|
|
registerProviderType( 1, WorldProviderEnd.class, false);
|
|
registerDimension( 0, 0);
|
|
registerDimension(-1, -1);
|
|
registerDimension( 1, 1);
|
|
}
|
|
|
|
public static void registerDimension(int id, int providerType)
|
|
{
|
|
if (!providers.containsKey(providerType))
|
|
{
|
|
throw new IllegalArgumentException(String.format("Failed to register dimension for id %d, provider type %d does not exist", id, providerType));
|
|
}
|
|
if (dimensions.containsKey(id))
|
|
{
|
|
throw new IllegalArgumentException(String.format("Failed to register dimension for id %d, One is already registered", id));
|
|
}
|
|
dimensions.put(id, providerType);
|
|
if (id >= 0)
|
|
{
|
|
dimensionMap.set(id);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* For unregistering a dimension when the save is changed (disconnected from a server or loaded a new save
|
|
*/
|
|
public static void unregisterDimension(int id)
|
|
{
|
|
if (!dimensions.containsKey(id))
|
|
{
|
|
throw new IllegalArgumentException(String.format("Failed to unregister dimension for id %d; No provider registered", id));
|
|
}
|
|
dimensions.remove(id);
|
|
}
|
|
|
|
public static int getProviderType(int dim)
|
|
{
|
|
if (!dimensions.containsKey(dim))
|
|
{
|
|
throw new IllegalArgumentException(String.format("Could not get provider type for dimension %d, does not exist", dim));
|
|
}
|
|
return dimensions.get(dim);
|
|
}
|
|
|
|
public static WorldProvider getProvider(int dim)
|
|
{
|
|
return getWorld(dim).provider;
|
|
}
|
|
|
|
public static Integer[] getIDs()
|
|
{
|
|
return worlds.keySet().toArray(new Integer[worlds.size()]); //Only loaded dims, since usually used to cycle through loaded worlds
|
|
}
|
|
|
|
public static void setWorld(int id, WorldServer world)
|
|
{
|
|
if (world != null) {
|
|
worlds.put(id, world);
|
|
MinecraftServer.getServer().worldTickTimes.put(id, new long[100]);
|
|
FMLLog.info("Loading dimension %d (%s) (%s)", id, world.getWorldInfo().getWorldName(), world.getMinecraftServer());
|
|
} else {
|
|
worlds.remove(id);
|
|
MinecraftServer.getServer().worldTickTimes.remove(id);
|
|
FMLLog.info("Unloading dimension %d", id);
|
|
}
|
|
|
|
ArrayList<WorldServer> tmp = new ArrayList<WorldServer>();
|
|
if (worlds.get( 0) != null)
|
|
tmp.add(worlds.get( 0));
|
|
if (worlds.get(-1) != null)
|
|
tmp.add(worlds.get(-1));
|
|
if (worlds.get( 1) != null)
|
|
tmp.add(worlds.get( 1));
|
|
|
|
for (Entry<Integer, WorldServer> entry : worlds.entrySet())
|
|
{
|
|
int dim = entry.getKey();
|
|
if (dim >= -1 && dim <= 1)
|
|
{
|
|
continue;
|
|
}
|
|
tmp.add(entry.getValue());
|
|
}
|
|
|
|
MinecraftServer.getServer().worldServers = tmp.toArray(new WorldServer[0]);
|
|
}
|
|
|
|
public static void initDimension(int dim) {
|
|
WorldServer overworld = getWorld(0);
|
|
if (overworld == null) {
|
|
throw new RuntimeException("Cannot Hotload Dim: Overworld is not Loaded!");
|
|
}
|
|
try {
|
|
DimensionManager.getProviderType(dim);
|
|
} catch (Exception e) {
|
|
System.err.println("Cannot Hotload Dim: " + e.getMessage());
|
|
return; //If a provider hasn't been registered then we can't hotload the dim
|
|
}
|
|
MinecraftServer mcServer = overworld.getMinecraftServer();
|
|
ISaveHandler savehandler = overworld.getSaveHandler();
|
|
WorldSettings worldSettings = new WorldSettings(overworld.getWorldInfo());
|
|
|
|
WorldServer world = (dim == 0 ? overworld : new WorldServerMulti(mcServer, savehandler, overworld.getWorldInfo().getWorldName(), dim, worldSettings, overworld, mcServer.theProfiler));
|
|
world.addWorldAccess(new WorldManager(mcServer, world));
|
|
MinecraftForge.EVENT_BUS.post(new WorldEvent.Load(world));
|
|
if (!mcServer.isSinglePlayer())
|
|
{
|
|
world.getWorldInfo().setGameType(mcServer.getGameType());
|
|
}
|
|
|
|
mcServer.setDifficultyForAllWorlds(mcServer.getDifficulty());
|
|
}
|
|
|
|
public static WorldServer getWorld(int id)
|
|
{
|
|
return worlds.get(id);
|
|
}
|
|
|
|
public static WorldServer[] getWorlds()
|
|
{
|
|
return worlds.values().toArray(new WorldServer[0]);
|
|
}
|
|
|
|
public static boolean shouldLoadSpawn(int dim)
|
|
{
|
|
int id = getProviderType(dim);
|
|
return spawnSettings.contains(id) && spawnSettings.get(id);
|
|
}
|
|
|
|
static
|
|
{
|
|
init();
|
|
}
|
|
|
|
/**
|
|
* Not public API: used internally to get dimensions that should load at
|
|
* server startup
|
|
* @return
|
|
*/
|
|
public static Integer[] getStaticDimensionIDs()
|
|
{
|
|
return dimensions.keySet().toArray(new Integer[dimensions.keySet().size()]);
|
|
}
|
|
public static WorldProvider createProviderFor(int dim)
|
|
{
|
|
try
|
|
{
|
|
if (dimensions.containsKey(dim))
|
|
{
|
|
WorldProvider provider = providers.get(getProviderType(dim)).newInstance();
|
|
provider.setDimension(dim);
|
|
return provider;
|
|
}
|
|
else
|
|
{
|
|
throw new RuntimeException(String.format("No WorldProvider bound for dimension %d", dim)); //It's going to crash anyway at this point. Might as well be informative
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
FMLCommonHandler.instance().getFMLLogger().log(Level.SEVERE,String.format("An error occured trying to create an instance of WorldProvider %d (%s)",
|
|
dim, providers.get(getProviderType(dim)).getSimpleName()),e);
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
public static void unloadWorld(int id) {
|
|
unloadQueue.add(id);
|
|
}
|
|
|
|
/*
|
|
* To be called by the server at the appropriate time, do not call from mod code.
|
|
*/
|
|
public static void unloadWorlds(Hashtable<Integer, long[]> worldTickTimes) {
|
|
for (int id : unloadQueue) {
|
|
try {
|
|
worlds.get(id).saveAllChunks(true, null);
|
|
} catch (MinecraftException e) {
|
|
e.printStackTrace();
|
|
}
|
|
MinecraftForge.EVENT_BUS.post(new WorldEvent.Unload(worlds.get(id)));
|
|
((WorldServer)worlds.get(id)).flush();
|
|
setWorld(id, null);
|
|
}
|
|
unloadQueue.clear();
|
|
}
|
|
|
|
/**
|
|
* Return the next free dimension ID. Note: you are not guaranteed a contiguous
|
|
* block of free ids. Always call for each individual ID you wish to get.
|
|
* @return
|
|
*/
|
|
public static int getNextFreeDimId() {
|
|
int next = 0;
|
|
while (true)
|
|
{
|
|
next = dimensionMap.nextClearBit(next);
|
|
if (dimensions.containsKey(next))
|
|
{
|
|
dimensionMap.set(next);
|
|
}
|
|
else
|
|
{
|
|
return next;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static NBTTagCompound saveDimensionDataMap()
|
|
{
|
|
int[] data = new int[(dimensionMap.length() + Integer.SIZE - 1 )/ Integer.SIZE];
|
|
NBTTagCompound dimMap = new NBTTagCompound();
|
|
for (int i = 0; i < data.length; i++)
|
|
{
|
|
int val = 0;
|
|
for (int j = 0; j < Integer.SIZE; j++)
|
|
{
|
|
val |= dimensionMap.get(i * Integer.SIZE + j) ? (1 << j) : 0;
|
|
}
|
|
data[i] = val;
|
|
}
|
|
dimMap.setIntArray("DimensionArray", data);
|
|
return dimMap;
|
|
}
|
|
|
|
public static void loadDimensionDataMap(NBTTagCompound compoundTag)
|
|
{
|
|
if (compoundTag == null)
|
|
{
|
|
dimensionMap.clear();
|
|
for (Integer id : dimensions.keySet())
|
|
{
|
|
if (id >= 0)
|
|
{
|
|
dimensionMap.set(id);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int[] intArray = compoundTag.getIntArray("DimensionArray");
|
|
for (int i = 0; i < intArray.length; i++)
|
|
{
|
|
for (int j = 0; j < Integer.SIZE; j++)
|
|
{
|
|
dimensionMap.set(i * Integer.SIZE + j, (intArray[i] & (1 << j)) != 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|