d923e98942
Reimplemented Limbo Decay in two forms. Firstly, Unraveled Fabric accepts random ticks now and has a 50% chance of searching the 6 blocks against its faces for blocks to decay. The average time for this decay to occur is about 2 minutes and 17 seconds. The decay progresses a little slowly because of having to go through stages. We might want to consider decaying straight into Unraveled Fabric, or at least having fewer stages. This approach is better than randomly decaying isolated blocks because it looks like decay is spreading from the Unraveled Fabric. Secondly, every tick, we pick a random block from each active section in Limbo and turn it into Unraveled Fabric immediately. Note that a section is a 16x16x16 block cube inside a chunk. This is "fast decay", and it's meant to stop players from avoiding Limbo decay by building floating structures. It's not immediately obvious if you place a single block, but if you build a 5x5 block platform, the average time for some block to get converted drops to about 8 seconds, and it spreads from there. Most of the logic for this is in a new class: LimboDecay. It's worth studying whether this new implementation affects Minecraft's performance. I'm not completely sure whether that would be an issue. The frequency of either decay type can be decreased to improve performance.
444 lines
18 KiB
Java
444 lines
18 KiB
Java
package StevenDimDoors.mod_pocketDim;
|
|
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.block.material.Material;
|
|
import net.minecraft.creativetab.CreativeTabs;
|
|
import net.minecraft.entity.EntityEggInfo;
|
|
import net.minecraft.entity.EntityList;
|
|
import net.minecraft.entity.item.EntityItem;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.world.biome.BiomeGenBase;
|
|
import net.minecraftforge.common.DimensionManager;
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
import StevenDimDoors.mod_pocketDim.blocks.BlockDimWall;
|
|
import StevenDimDoors.mod_pocketDim.blocks.BlockDimWallPerm;
|
|
import StevenDimDoors.mod_pocketDim.blocks.BlockLimbo;
|
|
import StevenDimDoors.mod_pocketDim.blocks.BlockRift;
|
|
import StevenDimDoors.mod_pocketDim.blocks.ChaosDoor;
|
|
import StevenDimDoors.mod_pocketDim.blocks.ExitDoor;
|
|
import StevenDimDoors.mod_pocketDim.blocks.dimDoor;
|
|
import StevenDimDoors.mod_pocketDim.blocks.dimHatch;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandCreateDungeonRift;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandDeleteAllLinks;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandDeleteDimensionData;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandDeleteRifts;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandEndDungeonCreation;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandPrintDimensionData;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandPruneDimensions;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandResetDungeons;
|
|
import StevenDimDoors.mod_pocketDim.commands.CommandStartDungeonCreation;
|
|
import StevenDimDoors.mod_pocketDim.helpers.BlockRotationHelper;
|
|
import StevenDimDoors.mod_pocketDim.helpers.DungeonHelper;
|
|
import StevenDimDoors.mod_pocketDim.helpers.dimHelper;
|
|
import StevenDimDoors.mod_pocketDim.items.ItemBlockDimWall;
|
|
import StevenDimDoors.mod_pocketDim.items.ItemChaosDoor;
|
|
import StevenDimDoors.mod_pocketDim.items.ItemRiftBlade;
|
|
import StevenDimDoors.mod_pocketDim.items.ItemStabilizedRiftSignature;
|
|
import StevenDimDoors.mod_pocketDim.items.ItemStableFabric;
|
|
import StevenDimDoors.mod_pocketDim.items.itemDimDoor;
|
|
import StevenDimDoors.mod_pocketDim.items.itemExitDoor;
|
|
import StevenDimDoors.mod_pocketDim.items.itemLinkSignature;
|
|
import StevenDimDoors.mod_pocketDim.items.itemRiftRemover;
|
|
import StevenDimDoors.mod_pocketDim.ticking.MobObelisk;
|
|
import StevenDimDoors.mod_pocketDim.world.BiomeGenLimbo;
|
|
import StevenDimDoors.mod_pocketDim.world.BiomeGenPocket;
|
|
import StevenDimDoors.mod_pocketDim.world.LimboProvider;
|
|
import StevenDimDoors.mod_pocketDim.world.pocketProvider;
|
|
import StevenDimDoors.mod_pocketDimClient.ClientPacketHandler;
|
|
import StevenDimDoors.mod_pocketDimClient.ClientTickHandler;
|
|
import cpw.mods.fml.common.Mod;
|
|
import cpw.mods.fml.common.Mod.Init;
|
|
import cpw.mods.fml.common.Mod.Instance;
|
|
import cpw.mods.fml.common.Mod.PostInit;
|
|
import cpw.mods.fml.common.Mod.PreInit;
|
|
import cpw.mods.fml.common.Mod.ServerStarting;
|
|
import cpw.mods.fml.common.Mod.ServerStopping;
|
|
import cpw.mods.fml.common.SidedProxy;
|
|
import cpw.mods.fml.common.event.FMLInitializationEvent;
|
|
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
|
|
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
|
import cpw.mods.fml.common.event.FMLServerStartingEvent;
|
|
import cpw.mods.fml.common.event.FMLServerStoppingEvent;
|
|
import cpw.mods.fml.common.network.NetworkMod;
|
|
import cpw.mods.fml.common.network.NetworkMod.SidedPacketHandler;
|
|
import cpw.mods.fml.common.registry.EntityRegistry;
|
|
import cpw.mods.fml.common.registry.GameRegistry;
|
|
import cpw.mods.fml.common.registry.LanguageRegistry;
|
|
import cpw.mods.fml.common.registry.TickRegistry;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
|
|
|
|
@Mod(modid = mod_pocketDim.modid, name = "Dimensional Doors", version = mod_pocketDim.version)
|
|
|
|
|
|
@NetworkMod(clientSideRequired = true, serverSideRequired = false,
|
|
clientPacketHandlerSpec =
|
|
@SidedPacketHandler(channels = {"pocketDim" }, packetHandler = ClientPacketHandler.class),
|
|
serverPacketHandlerSpec =
|
|
@SidedPacketHandler(channels = {"pocketDim" }, packetHandler = ServerPacketHandler.class),
|
|
channels={"DimDoorPackets"}, packetHandler = PacketHandler.class, connectionHandler=ConnectionHandler.class)
|
|
|
|
public class mod_pocketDim
|
|
{
|
|
public static final String version = "1.5.2R1.4.1RC1";
|
|
public static final String modid = "DimDoors";
|
|
|
|
//need to clean up
|
|
@SidedProxy(clientSide = "StevenDimDoors.mod_pocketDimClient.ClientProxy", serverSide = "StevenDimDoors.mod_pocketDim.CommonProxy")
|
|
public static CommonProxy proxy;
|
|
|
|
@Instance("PocketDimensions")
|
|
public static mod_pocketDim instance = new mod_pocketDim();
|
|
|
|
public static SchematicLoader loader;
|
|
public static pocketTeleporter teleporter;
|
|
public static BlockRotationHelper rotationHelper;
|
|
|
|
public static Block transientDoor;
|
|
public static Block ExitDoor;
|
|
public static Block chaosDoor;
|
|
public static Block blockRift;
|
|
public static Block blockLimbo;
|
|
public static Block dimDoor;
|
|
public static Block blockDimWall;
|
|
public static Block dimHatch;
|
|
public static Block blockDimWallPerm;
|
|
|
|
public static Item itemRiftBlade;
|
|
public static Item itemDimDoor;
|
|
public static Item itemExitDoor;
|
|
public static Item itemRiftRemover;
|
|
public static Item itemLinkSignature;
|
|
public static Item itemStableFabric;
|
|
public static Item itemChaosDoor;
|
|
public static Item itemStabilizedLinkSignature;
|
|
|
|
public static BiomeGenBase limboBiome;
|
|
public static BiomeGenBase pocketBiome;
|
|
|
|
public static PlayerRespawnTracker tracker;
|
|
|
|
public static HashMap<String,ArrayList<EntityItem>> limboSpawnInventory = new HashMap<String,ArrayList<EntityItem>>();
|
|
|
|
public static ArrayList<Integer> blocksImmuneToRift = new ArrayList<Integer>();
|
|
|
|
public static boolean hasInitDims = false;
|
|
public static boolean isPlayerWearingGoogles = false;
|
|
|
|
private static DDProperties properties;
|
|
public static RiftGenerator riftGen;
|
|
|
|
public static long genTime;
|
|
public static int teleTimer = 0;
|
|
|
|
public static CreativeTabs dimDoorsCreativeTab = new CreativeTabs("dimDoorsCreativeTab")
|
|
{
|
|
@Override
|
|
public ItemStack getIconItemStack()
|
|
{
|
|
return new ItemStack(mod_pocketDim.itemDimDoor, 1, 0);
|
|
}
|
|
|
|
@Override
|
|
public String getTranslatedTabLabel()
|
|
{
|
|
return "Dimensional Doors";
|
|
}
|
|
};
|
|
|
|
|
|
|
|
@PreInit
|
|
public void PreInit(FMLPreInitializationEvent event)
|
|
{
|
|
//This should be the FIRST thing that gets done.
|
|
properties = DDProperties.initialize(event.getSuggestedConfigurationFile());
|
|
|
|
//Now do other stuff
|
|
MinecraftForge.EVENT_BUS.register(new EventHookContainer());
|
|
|
|
//These fields MUST be initialized after properties are loaded to prevent
|
|
//instances from holding onto null references to the properties.
|
|
|
|
loader = new SchematicLoader();
|
|
teleporter = new pocketTeleporter();
|
|
tracker = new PlayerRespawnTracker();
|
|
riftGen = new RiftGenerator();
|
|
rotationHelper = new BlockRotationHelper();
|
|
}
|
|
|
|
@Init
|
|
public void Init(FMLInitializationEvent event)
|
|
{
|
|
|
|
transientDoor = (new TransientDoor(properties.TransientDoorID, Material.iron)).setHardness(1.0F) .setUnlocalizedName("transientDoor");
|
|
|
|
blockDimWall = (new BlockDimWall(properties.FabricBlockID, 0, Material.iron)).setLightValue(1.0F).setHardness(0.1F).setUnlocalizedName("blockDimWall");
|
|
blockDimWallPerm = (new BlockDimWallPerm(properties.PermaFabricBlockID, 0, Material.iron)).setLightValue(1.0F).setBlockUnbreakable().setResistance(6000000.0F).setUnlocalizedName("blockDimWallPerm");
|
|
ExitDoor = (new ExitDoor(properties.WarpDoorID, Material.wood)).setHardness(1.0F) .setUnlocalizedName("dimDoorWarp");
|
|
blockRift = (new BlockRift(properties.RiftBlockID, 0, Material.air).setHardness(1.0F) .setUnlocalizedName("rift"));
|
|
blockLimbo = (new BlockLimbo(properties.LimboBlockID, 15, Material.iron, properties.LimboDimensionID).setHardness(.2F).setUnlocalizedName("BlockLimbo").setLightValue(.0F));
|
|
chaosDoor = (new ChaosDoor(properties.UnstableDoorID, Material.iron).setHardness(.2F).setUnlocalizedName("chaosDoor").setLightValue(.0F) );
|
|
dimDoor = (new dimDoor(properties.DimensionalDoorID, Material.iron)).setHardness(1.0F).setResistance(2000.0F) .setUnlocalizedName("dimDoor");
|
|
dimHatch = (new dimHatch(properties.TransTrapdoorID, 84, Material.iron)).setHardness(1.0F) .setUnlocalizedName("dimHatch");
|
|
// dimRail = (new DimRail(dimRailID, 88, false)).setHardness(.5F) .setUnlocalizedName("dimRail");
|
|
|
|
itemDimDoor = (new itemDimDoor(properties.DimensionalDoorItemID, Material.iron)).setUnlocalizedName("itemDimDoor");
|
|
itemExitDoor = (new itemExitDoor(properties.WarpDoorItemID, Material.wood)).setUnlocalizedName("itemDimDoorWarp");
|
|
itemLinkSignature = (new itemLinkSignature(properties.RiftSignatureItemID)).setUnlocalizedName("itemLinkSignature");
|
|
itemRiftRemover = (new itemRiftRemover(properties.RiftRemoverItemID, Material.wood)).setUnlocalizedName("itemRiftRemover");
|
|
itemStableFabric = (new ItemStableFabric(properties.StableFabricItemID, 0)).setUnlocalizedName("itemStableFabric");
|
|
itemChaosDoor = (new ItemChaosDoor(properties.UnstableDoorItemID, Material.iron)).setUnlocalizedName("itemChaosDoor");
|
|
itemRiftBlade = (new ItemRiftBlade(properties.RiftBladeItemID)).setUnlocalizedName("ItemRiftBlade");
|
|
itemStabilizedLinkSignature = (new ItemStabilizedRiftSignature(properties.StabilizedRiftSignatureItemID)).setUnlocalizedName("itemStabilizedRiftSig");
|
|
|
|
mod_pocketDim.limboBiome= (new BiomeGenLimbo(properties.LimboBiomeID));
|
|
mod_pocketDim.pocketBiome= (new BiomeGenPocket(properties.PocketBiomeID));
|
|
|
|
GameRegistry.registerWorldGenerator(mod_pocketDim.riftGen);
|
|
|
|
GameRegistry.registerBlock(chaosDoor, "Unstable Door");
|
|
GameRegistry.registerBlock(ExitDoor, "Warp Door");
|
|
GameRegistry.registerBlock(blockRift, "Rift");
|
|
GameRegistry.registerBlock(blockLimbo, "Unraveled Fabric");
|
|
GameRegistry.registerBlock(dimDoor, "Dimensional Door");
|
|
GameRegistry.registerBlock(dimHatch,"Transdimensional Trapdoor");
|
|
GameRegistry.registerBlock(blockDimWallPerm, "Fabric of RealityPerm");
|
|
GameRegistry.registerBlock(transientDoor, "transientDoor");
|
|
|
|
GameRegistry.registerBlock(blockDimWall, ItemBlockDimWall.class, "Fabric of Reality");
|
|
|
|
GameRegistry.registerPlayerTracker(tracker);
|
|
|
|
DimensionManager.registerProviderType(properties.PocketProviderID, pocketProvider.class, false);
|
|
DimensionManager.registerProviderType(properties.LimboProviderID, LimboProvider.class, false);
|
|
DimensionManager.registerDimension(properties.LimboDimensionID, properties.LimboProviderID);
|
|
|
|
LanguageRegistry.addName(transientDoor , "transientDoor");
|
|
LanguageRegistry.addName(blockRift , "Rift");
|
|
LanguageRegistry.addName(blockLimbo , "Unraveled Fabric");
|
|
LanguageRegistry.addName(ExitDoor , "Warp Door");
|
|
LanguageRegistry.addName(chaosDoor , "Unstable Door");
|
|
LanguageRegistry.addName(blockDimWall , "Fabric of Reality");
|
|
LanguageRegistry.addName(blockDimWallPerm , "Eternal Fabric");
|
|
LanguageRegistry.addName(dimDoor, "Dimensional Door");
|
|
LanguageRegistry.addName(dimHatch, "Transdimensional Trapdoor");
|
|
|
|
LanguageRegistry.addName(itemExitDoor, "Warp Door");
|
|
LanguageRegistry.addName(itemLinkSignature , "Rift Signature");
|
|
LanguageRegistry.addName(itemStabilizedLinkSignature, "Stabilized Rift Signature");
|
|
LanguageRegistry.addName(itemRiftRemover , "Rift Remover");
|
|
LanguageRegistry.addName(itemStableFabric , "Stable Fabric");
|
|
LanguageRegistry.addName(itemChaosDoor , "Unstable Door");
|
|
LanguageRegistry.addName(itemDimDoor, "Dimensional Door");
|
|
LanguageRegistry.addName(itemRiftBlade , "Rift Blade");
|
|
|
|
/**
|
|
* Add names for multiblock inventory item
|
|
*/
|
|
LanguageRegistry.addName(new ItemStack(blockDimWall, 1, 0), "Fabric of Reality");
|
|
LanguageRegistry.addName(new ItemStack(blockDimWall, 1, 1), "Ancient Fabric");
|
|
|
|
|
|
LanguageRegistry.instance().addStringLocalization("itemGroup.dimDoorsCustomTab", "en_US", "Dimensional Doors Items");
|
|
|
|
TickRegistry.registerTickHandler(new ClientTickHandler(), Side.CLIENT);
|
|
TickRegistry.registerTickHandler(new CommonTickHandler(), Side.SERVER);
|
|
|
|
//GameRegistry.registerTileEntity(TileEntityDimDoor.class, "TileEntityDimRail");
|
|
|
|
GameRegistry.registerTileEntity(TileEntityDimDoor.class, "TileEntityDimDoor");
|
|
GameRegistry.registerTileEntity(TileEntityRift.class, "TileEntityRift");
|
|
|
|
EntityRegistry.registerModEntity(MobObelisk.class, "Monolith", properties.MonolithEntityID, this, 70, 1, true);
|
|
EntityList.IDtoClassMapping.put(properties.MonolithEntityID, MobObelisk.class);
|
|
EntityList.entityEggs.put(properties.MonolithEntityID, new EntityEggInfo(properties.MonolithEntityID, 0, 0xffffff));
|
|
LanguageRegistry.instance().addStringLocalization("entity.DimDoors.Obelisk.name", "Monolith");
|
|
|
|
//GameRegistry.addBiome(this.limboBiome);
|
|
//GameRegistry.addBiome(this.pocketBiome);
|
|
|
|
if (properties.CraftingDimensionaDoorAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(itemDimDoor, 1), new Object[]
|
|
{
|
|
" ", "yxy", " ", 'x', Item.enderPearl, 'y', Item.doorIron
|
|
});
|
|
|
|
GameRegistry.addRecipe(new ItemStack(itemDimDoor, 1), new Object[]
|
|
{
|
|
" ", "yxy", " ", 'x', mod_pocketDim.itemStableFabric, 'y', Item.doorIron
|
|
});
|
|
}
|
|
|
|
/**
|
|
if(this.enableDimRail)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(dimRail, 1), new Object[]
|
|
{
|
|
" ", "yxy", " ", 'x', this.itemDimDoor, 'y', Block.rail
|
|
});
|
|
|
|
GameRegistry.addRecipe(new ItemStack(dimRail, 1), new Object[]
|
|
{
|
|
" ", "yxy", " ", 'x', this.itemExitDoor, 'y', Block.rail
|
|
});
|
|
}
|
|
**/
|
|
|
|
if(properties.CraftingUnstableDoorAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(itemChaosDoor, 1), new Object[]
|
|
{
|
|
" ", "yxy", " ", 'x', Item.eyeOfEnder, 'y', mod_pocketDim.itemDimDoor
|
|
});
|
|
}
|
|
if(properties.CraftingWarpDoorAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(itemExitDoor, 1), new Object[]
|
|
{
|
|
" ", "yxy", " ", 'x', Item.enderPearl, 'y', Item.doorWood
|
|
});
|
|
|
|
GameRegistry.addRecipe(new ItemStack(itemExitDoor, 1), new Object[]
|
|
{
|
|
" ", "yxy", " ", 'x', mod_pocketDim.itemStableFabric, 'y', Item.doorWood
|
|
});
|
|
}
|
|
if(properties.CraftingTransTrapdoorAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(dimHatch, 1), new Object[]
|
|
{
|
|
" y ", " x ", " y ", 'x', Item.enderPearl, 'y', Block.trapdoor
|
|
});
|
|
|
|
GameRegistry.addRecipe(new ItemStack(dimHatch, 1), new Object[]
|
|
{
|
|
" y ", " x ", " y ", 'x', mod_pocketDim.itemStableFabric, 'y', Block.trapdoor
|
|
});
|
|
}
|
|
if(properties.CraftingRiftSignatureAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(itemLinkSignature, 1), new Object[]
|
|
{
|
|
" y ", "yxy", " y ", 'x', Item.enderPearl, 'y', Item.ingotIron
|
|
});
|
|
|
|
GameRegistry.addRecipe(new ItemStack(itemLinkSignature, 1), new Object[]
|
|
{
|
|
" y ", "yxy", " y ", 'x', mod_pocketDim.itemStableFabric, 'y', Item.ingotIron
|
|
});
|
|
}
|
|
|
|
if(properties.CraftingRiftRemoverAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(itemRiftRemover, 1), new Object[]
|
|
{
|
|
" y ", "yxy", " y ", 'x', Item.enderPearl, 'y', Item.ingotGold
|
|
});
|
|
GameRegistry.addRecipe(new ItemStack(itemRiftRemover, 1), new Object[]
|
|
{
|
|
"yyy", "yxy", "yyy", 'x', mod_pocketDim.itemStableFabric, 'y', Item.ingotGold
|
|
});
|
|
}
|
|
|
|
if (properties.CraftingRiftBladeAllowed)
|
|
{
|
|
|
|
GameRegistry.addRecipe(new ItemStack(itemRiftBlade, 1), new Object[]
|
|
{
|
|
" x ", " x ", " y ", 'x', Item.enderPearl, 'y',mod_pocketDim.itemRiftRemover
|
|
});
|
|
}
|
|
|
|
if (properties.CraftingStableFabricAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(itemStableFabric, 4), new Object[]
|
|
{
|
|
" y ", "yxy", " y ", 'x', Item.enderPearl, 'y', mod_pocketDim.blockDimWall
|
|
});
|
|
}
|
|
|
|
if (properties.CraftingStabilizedRiftSignatureAllowed)
|
|
{
|
|
GameRegistry.addRecipe(new ItemStack(mod_pocketDim.itemStabilizedLinkSignature,1), new Object[]
|
|
{
|
|
" y ", "yxy", " y ", 'x', mod_pocketDim.itemLinkSignature, 'y', mod_pocketDim.itemStableFabric
|
|
});
|
|
}
|
|
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.FabricBlockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.PermaFabricBlockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.DimensionalDoorID);
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.WarpDoorID);
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.TransTrapdoorID);
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.UnstableDoorID);
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.RiftBlockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(properties.TransientDoorID);
|
|
mod_pocketDim.blocksImmuneToRift.add(Block.blockIron.blockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(Block.blockDiamond.blockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(Block.blockEmerald.blockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(Block.blockGold.blockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(Block.blockLapis.blockID);
|
|
mod_pocketDim.blocksImmuneToRift.add(Block.bedrock.blockID);
|
|
|
|
DungeonHelper.initialize();
|
|
|
|
proxy.loadTextures();
|
|
proxy.registerRenderers();
|
|
}
|
|
|
|
|
|
@PostInit
|
|
public void PostInit(FMLPostInitializationEvent event)
|
|
{
|
|
//Register loot chests
|
|
DDLoot.registerInfo();
|
|
}
|
|
|
|
@ServerStopping
|
|
public void serverStopping(FMLServerStoppingEvent event)
|
|
{
|
|
try
|
|
{
|
|
dimHelper.instance.save();
|
|
dimHelper.instance.unregsisterDims();
|
|
dimHelper.dimList.clear();
|
|
dimHelper.blocksToDecay.clear();
|
|
dimHelper.instance.interDimLinkList.clear();
|
|
mod_pocketDim.hasInitDims=false;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
|
|
@ServerStarting
|
|
public void serverStarting(FMLServerStartingEvent event)
|
|
{
|
|
CommandResetDungeons.instance().register(event);
|
|
CommandCreateDungeonRift.instance().register(event);
|
|
CommandDeleteAllLinks.instance().register(event);
|
|
CommandDeleteDimensionData.instance().register(event);
|
|
CommandDeleteRifts.instance().register(event);
|
|
CommandEndDungeonCreation.instance().register(event);
|
|
CommandPrintDimensionData.instance().register(event);
|
|
CommandPruneDimensions.instance().register(event);
|
|
CommandStartDungeonCreation.instance().register(event);
|
|
dimHelper.instance.load();
|
|
|
|
if(!dimHelper.dimList.containsKey(properties.LimboDimensionID))
|
|
{
|
|
dimHelper.dimList.put(properties.LimboDimensionID, new DimData( properties.LimboDimensionID, false, 0, new LinkData()));
|
|
}
|
|
}
|
|
|
|
|
|
}
|