@EventHandler
public void init(FMLInitializationEvent event) throws Exception {
packetPipeline.registerMessage(
AnvilTechniquePacket.Handler.class, AnvilTechniquePacket.class, 0, Side.SERVER);
packetPipeline.registerMessage(
ChunkPutNbtPacket.Handler.class, ChunkPutNbtPacket.class, 1, Side.CLIENT);
packetPipeline.registerMessage(
ChunkRemoveNbtPacket.Handler.class, ChunkRemoveNbtPacket.class, 2, Side.CLIENT);
packetPipeline.registerMessage(
SoundEffectToServerPacket.Handler.class, SoundEffectToServerPacket.class, 3, Side.SERVER);
packetPipeline.registerMessage(
MechanicalNetworkNBTPacket.ClientHandler.class,
MechanicalNetworkNBTPacket.class,
4,
Side.CLIENT);
packetPipeline.registerMessage(
StartMeteorShowerPacket.ClientHandler.class, StartMeteorShowerPacket.class, 5, Side.CLIENT);
packetPipeline.registerMessage(
WorldDataPacket.ClientHandler.class, WorldDataPacket.class, 6, Side.CLIENT);
packetPipeline.registerMessage(
CarpentryTechniquePacket.Handler.class, CarpentryTechniquePacket.class, 7, Side.SERVER);
BlocksVC.init();
ItemsVC.init();
AchievementsVC.init();
FMLCommonHandler.instance().bus().register(this);
MinecraftForge.EVENT_BUS.register(this);
proxy.registerTileEntities();
NetworkRegistry.INSTANCE.registerGuiHandler(instance, proxy);
System.out.println("vcraft has init.");
GameRegistry.registerWorldGenerator(new WorldGenDeposits(), 4);
WorldType.DEFAULT = WorldTypeVC.DEFAULT;
WorldType.FLAT = WorldTypeVC.FLAT;
// DimensionManager.unregisterDimension(-1);
DimensionManager.unregisterDimension(0);
DimensionManager.unregisterDimension(1);
// DimensionManager.unregisterProviderType(-1);
DimensionManager.unregisterProviderType(0);
DimensionManager.unregisterProviderType(1);
DimensionManager.registerProviderType(0, WorldProviderVC.class, true);
DimensionManager.registerProviderType(1, WorldProviderVC.class, false);
// DimensionManager.registerDimension(-1, -1);
DimensionManager.registerDimension(0, 0);
DimensionManager.registerDimension(1, 1);
proxy.init(event);
}
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);
}
@EventHandler()
public void Init(FMLInitializationEvent Init) {
loadProps(CBCMod.config);
XenBlocks.init(CBCMod.config);
proxy.init();
DimensionManager.registerProviderType(
xenContinentDimensionID, WorldProviderXenContinent.class, true);
DimensionManager.registerDimension(xenContinentDimensionID, xenContinentDimensionID);
EntityRegistry.addSpawn(
EntityHoundeye.class,
25,
15,
15,
EnumCreatureType.monster,
MainBiomes.xenHill,
MainBiomes.xenPlain);
EntityRegistry.addSpawn(
EntityHeadcrab.class,
25,
15,
15,
EnumCreatureType.monster,
MainBiomes.xenHill,
MainBiomes.xenPlain);
EntityRegistry.addSpawn(
EntityAlienSlave.class, 10, 15, 15, EnumCreatureType.monster, MainBiomes.xenHill);
EntityRegistry.addSpawn(
EntityBarnacle.class,
6,
15,
15,
EnumCreatureType.monster,
MainBiomes.xenHill,
MainBiomes.xenPlain);
}
public static void LoadDim() {
// generation
GameRegistry.registerWorldGenerator(new DreSca(), 0);
// dimension
DimensionManager.registerProviderType(dimension, WorldProviderDreSca.class, false);
DimensionManager.registerDimension(dimension, dimension);
}
public void execute() {
// Only do this on client side.
for (int id : dimensions) {
RFTools.log("DimensionSyncPacket: Registering id: id = " + id);
if (!DimensionManager.isDimensionRegistered(id)) {
DimensionManager.registerProviderType(id, GenericWorldProvider.class, false);
DimensionManager.registerDimension(id, id);
}
}
}
@PreInit
public void preInit(FMLPreInitializationEvent event) {
WCConfig.preInit(event);
WCMCMod.preInit(event);
WCBlockIDs.init();
WCItemIDs.init();
WCRecipes.init();
WCAchievements.init();
MinecraftForge.EVENT_BUS.register(new EventSounds());
MinecraftForge.EVENT_BUS.register(new EventHookHandler());
NetworkRegistry.instance().registerGuiHandler(this, guiHandler);
GameRegistry.registerPickupHandler(itemHandler);
DimensionManager.registerProviderType(DIM, WorldProviderWarp.class, true);
DimensionManager.registerDimension(DIM, DIM);
}
/** Initiates mod, registers block and item for use. Generates the necessary folders. */
@EventHandler
public void load(FMLInitializationEvent event) {
initialize();
registerBlocks();
addNames();
addSmelt();
mkDirs();
registerEntities();
addRecipes();
guihandler = new GuiHandler();
GameRegistry.registerTileEntity(TileEntityCollision.class, "collide");
GameRegistry.registerTileEntity(TileEntityExtractor.class, "extractor");
GameRegistry.registerTileEntity(TileEntityParadoxCondenser.class, "condenser");
GameRegistry.registerTileEntity(TileEntityTimeTravel.class, "timetravel");
GameRegistry.registerTileEntity(TileEntityMarker.class, "marker");
GameRegistry.registerTileEntity(TileEntityTimeDistorter.class, "timeDistorter");
// TickRegistry.registerTickHandler(new TickerClient(), Side.CLIENT);
GameRegistry.registerWorldGenerator(new StructureGenerator(), 0);
NetworkRegistry.INSTANCE.registerGuiHandler(this, guihandler);
EntityRegistry.registerGlobalEntityID(
EntityPlayerPast.class,
"PlayerPast",
EntityRegistry.findGlobalUniqueEntityId(),
0x191919,
0x000000); // registers the mobs name and id
EntityRegistry.registerGlobalEntityID(EntityChair.class, "Chiar", 1001);
EntityRegistry.registerGlobalEntityID(EntityXPOrbTT.class, "XP Orb", 1002);
DimensionManager.registerProviderType(
TimeTraveler.dimensionId, WorldProviderFuture.class, false);
DimensionManager.registerDimension(TimeTraveler.dimensionId, TimeTraveler.dimensionId);
FluidContainerRegistry.registerFluidContainer(
timeFluid, new ItemStack(bucket), new ItemStack(Items.bucket));
proxy.initCapes();
proxy.registerRenderThings();
}
@EventHandler
public void load(FMLInitializationEvent event) {
proxy.registerRenderers();
// Block Registration
GameRegistry.registerBlock(bauxite);
GameRegistry.registerBlock(moonDust);
GameRegistry.registerBlock(meteorite);
GameRegistry.registerBlock(moonPortal);
GameRegistry.registerBlock(moonRock);
// Block Name Registration
LanguageRegistry.addName(bauxite, "Bauxite");
LanguageRegistry.addName(moonDust, "Moon Dust");
LanguageRegistry.addName(meteorite, "Meteorite");
LanguageRegistry.addName(moonPortal, "Moon Portal");
LanguageRegistry.addName(moonRock, "Moon Rock");
// Item Name Registration
LanguageRegistry.addName(aluminum, "Aluminum Ingot");
LanguageRegistry.addName(stainlessSteel, "Steel Ingot");
LanguageRegistry.addName(steelRod, "Steel Rod");
// Crafting Recipes
GameRegistry.addRecipe(
new ItemStack(steelRod, 8),
new Object[] {
" S ", " S ", " S ", 'S', stainlessSteel,
});
GameRegistry.addSmelting(bauxite.blockID, new ItemStack(aluminum), 0.1f);
GameRegistry.addSmelting(meteorite.blockID, new ItemStack(stainlessSteel), 0.5f);
DimensionManager.registerProviderType(DimensionId, WorldProviderMoon.class, false);
DimensionManager.registerDimension(DimensionId, DimensionId);
GameRegistry.registerWorldGenerator(spacecraftGenerator);
}
// Initialisation Event
@Init
public void loadSequence(FMLInitializationEvent event) {
try {
MaterialRegistry.init();
logger.info("Loading Module Aurora...");
AuroraInit.init();
proxy.registerCommonEventHandlers();
proxy.registerClientEventHandlers();
proxy.registerTileEntities();
proxy.registerEntities();
EnchantmentRegistry.init();
ItemRegistry.init();
BlockRegistry.init();
ItemRegistry.initDepend();
BlockRegistry.initDepend();
LoaderEngine.registerMod(instance);
CorruptionRegistry.init();
OreDictionaryHelper.registerItems();
LiquidDictionaryHelper.init();
HandleRegistry.registerTools();
ArmorRegistry.init();
LiquidRegistry.init();
EnergyNetMain.init();
BiomeRegistry.init();
Debug.init();
DimensionManager.registerProviderType(
Config.providerIDAtlantis.getValueInt(), CraftMineWorldProvider.class, true);
DimensionManager.registerDimension(
Config.dimensionIDAtlantis.getValueInt(), Config.providerIDAtlantis.getValueInt());
GameRegistry.registerWorldGenerator(new WorldGenHandler());
proxy.registerClientTicks();
proxy.registerServerTicks();
proxy.registerMiscTicks();
KeyLib.beginKeyValueLocalization();
proxy.registerKeyBindings();
RecipeManager.init();
proxy.registerRenderInformation();
ItemDuplicatorRegistry.init();
DictionaryLib.init();
AchievementManager.init();
TurretRegistry.init();
} catch (Exception e) {
CrashLogger.killWithError(e, "Fatal error during initialization");
}
}
@SideOnly(Side.CLIENT)
@Override
public void handleClientSide(EntityPlayer player) {
GCEntityClientPlayerMP playerBaseClient = null;
if (player instanceof GCEntityClientPlayerMP) {
playerBaseClient = (GCEntityClientPlayerMP) player;
} else {
return;
}
switch (this.type) {
case C_AIR_REMAINING:
if (String.valueOf(this.data.get(2))
.equals(
String.valueOf(
FMLClientHandler.instance()
.getClient()
.thePlayer
.getGameProfile()
.getName()))) {
TickHandlerClient.airRemaining = (Integer) this.data.get(0);
TickHandlerClient.airRemaining2 = (Integer) this.data.get(1);
}
break;
case C_UPDATE_DIMENSION_LIST:
if (String.valueOf(this.data.get(0))
.equals(FMLClientHandler.instance().getClient().thePlayer.getGameProfile().getName())) {
final String[] destinations = ((String) this.data.get(1)).split("\\.");
if (FMLClientHandler.instance().getClient().theWorld != null
&& !(FMLClientHandler.instance().getClient().currentScreen
instanceof GuiCelestialSelection
|| FMLClientHandler.instance().getClient().currentScreen
instanceof GuiGalaxyMap)) {
FMLClientHandler.instance().getClient().displayGuiScreen(new GuiCelestialSelection());
}
}
break;
case C_SPAWN_SPARK_PARTICLES:
int x, y, z;
x = (Integer) this.data.get(0);
y = (Integer) this.data.get(1);
z = (Integer) this.data.get(2);
Minecraft mc = Minecraft.getMinecraft();
for (int i = 0; i < 4; i++) {
if (mc != null
&& mc.renderViewEntity != null
&& mc.effectRenderer != null
&& mc.theWorld != null) {
final EntityFX fx =
new EntityFXSparks(
mc.theWorld,
x - 0.15 + 0.5,
y + 1.2,
z + 0.15 + 0.5,
mc.theWorld.rand.nextDouble() / 20 - mc.theWorld.rand.nextDouble() / 20,
mc.theWorld.rand.nextDouble() / 20 - mc.theWorld.rand.nextDouble() / 20);
if (fx != null) {
mc.effectRenderer.addEffect(fx);
}
}
}
break;
case C_UPDATE_GEAR_SLOT:
int subtype = (Integer) this.data.get(2);
EntityPlayer gearDataPlayer = null;
MinecraftServer server = MinecraftServer.getServer();
if (server != null) {
gearDataPlayer =
server.getConfigurationManager().getPlayerForUsername((String) this.data.get(0));
} else {
gearDataPlayer = player.worldObj.getPlayerEntityByName((String) this.data.get(0));
}
if (gearDataPlayer != null) {
PlayerGearData gearData =
ClientProxyCore.playerItemData.get(gearDataPlayer.getPersistentID());
if (gearData == null) {
gearData = new PlayerGearData(player);
}
EnumModelPacket type = EnumModelPacket.values()[(Integer) this.data.get(1)];
switch (type) {
case ADDMASK:
gearData.setMask(0);
break;
case REMOVEMASK:
gearData.setMask(-1);
break;
case ADDGEAR:
gearData.setGear(0);
break;
case REMOVEGEAR:
gearData.setGear(-1);
break;
case ADDLEFTGREENTANK:
gearData.setLeftTank(0);
break;
case ADDLEFTORANGETANK:
gearData.setLeftTank(1);
break;
case ADDLEFTREDTANK:
gearData.setLeftTank(2);
break;
case ADDRIGHTGREENTANK:
gearData.setRightTank(0);
break;
case ADDRIGHTORANGETANK:
gearData.setRightTank(1);
break;
case ADDRIGHTREDTANK:
gearData.setRightTank(2);
break;
case REMOVE_LEFT_TANK:
gearData.setLeftTank(-1);
break;
case REMOVE_RIGHT_TANK:
gearData.setRightTank(-1);
break;
case ADD_PARACHUTE:
String name = "";
if (subtype != -1) {
name = ItemParaChute.names[subtype];
gearData.setParachute(
new ResourceLocation(
GalacticraftCore.ASSET_DOMAIN,
"textures/model/parachute/" + name + ".png"));
}
break;
case REMOVE_PARACHUTE:
gearData.setParachute(null);
break;
case ADD_FREQUENCY_MODULE:
gearData.setFrequencyModule(0);
break;
case REMOVE_FREQUENCY_MODULE:
gearData.setFrequencyModule(-1);
break;
case ADD_THERMAL_HELMET:
gearData.setThermalPadding(0, 0);
break;
case ADD_THERMAL_CHESTPLATE:
gearData.setThermalPadding(1, 0);
break;
case ADD_THERMAL_LEGGINGS:
gearData.setThermalPadding(2, 0);
break;
case ADD_THERMAL_BOOTS:
gearData.setThermalPadding(3, 0);
break;
case REMOVE_THERMAL_HELMET:
gearData.setThermalPadding(0, -1);
break;
case REMOVE_THERMAL_CHESTPLATE:
gearData.setThermalPadding(1, -1);
break;
case REMOVE_THERMAL_LEGGINGS:
gearData.setThermalPadding(2, -1);
break;
case REMOVE_THERMAL_BOOTS:
gearData.setThermalPadding(3, -1);
break;
default:
break;
}
ClientProxyCore.playerItemData.put(playerBaseClient.getPersistentID(), gearData);
}
break;
case C_CLOSE_GUI:
FMLClientHandler.instance().getClient().displayGuiScreen(null);
break;
case C_RESET_THIRD_PERSON:
FMLClientHandler.instance().getClient().gameSettings.thirdPersonView =
playerBaseClient.getThirdPersonView();
break;
case C_UPDATE_SPACESTATION_LIST:
try {
if (WorldUtil.registeredSpaceStations != null) {
for (Integer registeredID : WorldUtil.registeredSpaceStations) {
DimensionManager.unregisterDimension(registeredID);
}
}
WorldUtil.registeredSpaceStations = new ArrayList<Integer>();
if (this.data.size() > 0) {
if (this.data.get(0) instanceof Integer) {
for (Object o : this.data) {
Integer dimID = (Integer) o;
if (!WorldUtil.registeredSpaceStations.contains(dimID)) {
WorldUtil.registeredSpaceStations.add(dimID);
if (!DimensionManager.isDimensionRegistered(dimID)) {
DimensionManager.registerDimension(
dimID, ConfigManagerCore.idDimensionOverworldOrbit);
} else {
GCLog.severe(
"Dimension already registered on client: unable to register space station dimension "
+ dimID);
}
}
}
} else if (this.data.get(0) instanceof Integer[]) {
for (Object o : (Integer[]) this.data.get(0)) {
Integer dimID = (Integer) o;
if (!WorldUtil.registeredSpaceStations.contains(dimID)) {
WorldUtil.registeredSpaceStations.add(dimID);
if (!DimensionManager.isDimensionRegistered(dimID)) {
DimensionManager.registerDimension(
dimID, ConfigManagerCore.idDimensionOverworldOrbit);
} else {
GCLog.severe(
"Dimension already registered on client: unable to register space station dimension "
+ dimID);
}
}
}
}
}
break;
} catch (final Exception e) {
e.printStackTrace();
}
case C_UPDATE_SPACESTATION_DATA:
SpaceStationWorldData var4 =
SpaceStationWorldData.getMPSpaceStationData(
player.worldObj, (Integer) this.data.get(0), player);
var4.readFromNBT((NBTTagCompound) this.data.get(1));
break;
case C_UPDATE_SPACESTATION_CLIENT_ID:
ClientProxyCore.clientSpaceStationID = (Integer) this.data.get(0);
break;
case C_UPDATE_PLANETS_LIST:
try {
if (WorldUtil.registeredPlanets != null) {
for (Integer registeredID : WorldUtil.registeredPlanets) {
DimensionManager.unregisterDimension(registeredID);
}
}
WorldUtil.registeredPlanets = new ArrayList<Integer>();
if (this.data.size() > 0) {
if (this.data.get(0) instanceof Integer) {
for (Object o : this.data) {
Integer dimID = (Integer) o;
if (!WorldUtil.registeredPlanets.contains(dimID)) {
WorldUtil.registeredPlanets.add(dimID);
DimensionManager.registerDimension(dimID, dimID);
}
}
} else if (this.data.get(0) instanceof Integer[]) {
for (Object o : (Integer[]) this.data.get(0)) {
Integer dimID = (Integer) o;
if (!WorldUtil.registeredPlanets.contains(dimID)) {
WorldUtil.registeredPlanets.add(dimID);
DimensionManager.registerDimension(dimID, dimID);
}
}
}
}
break;
} catch (final Exception e) {
e.printStackTrace();
}
case C_ADD_NEW_SCHEMATIC:
final ISchematicPage page =
SchematicRegistry.getMatchingRecipeForID((Integer) this.data.get(0));
if (!playerBaseClient.unlockedSchematics.contains(page)) {
playerBaseClient.unlockedSchematics.add(page);
}
break;
case C_UPDATE_SCHEMATIC_LIST:
for (Object o : this.data) {
Integer schematicID = (Integer) o;
if (schematicID != -2) {
Collections.sort(playerBaseClient.unlockedSchematics);
if (!playerBaseClient.unlockedSchematics.contains(
SchematicRegistry.getMatchingRecipeForID(Integer.valueOf(schematicID)))) {
playerBaseClient.unlockedSchematics.add(
SchematicRegistry.getMatchingRecipeForID(Integer.valueOf(schematicID)));
}
}
}
break;
case C_PLAY_SOUND_BOSS_DEATH:
player.playSound(GalacticraftCore.ASSET_PREFIX + "entity.bossdeath", 10.0F, 0.8F);
break;
case C_PLAY_SOUND_EXPLODE:
player.playSound("random.explode", 10.0F, 0.7F);
break;
case C_PLAY_SOUND_BOSS_LAUGH:
player.playSound(GalacticraftCore.ASSET_PREFIX + "entity.bosslaugh", 10.0F, 0.2F);
break;
case C_PLAY_SOUND_BOW:
player.playSound("random.bow", 10.0F, 0.2F);
break;
case C_UPDATE_OXYGEN_VALIDITY:
playerBaseClient.oxygenSetupValid = (Boolean) this.data.get(0);
break;
case C_OPEN_PARACHEST_GUI:
switch ((Integer) this.data.get(1)) {
case 0:
if (player.ridingEntity instanceof EntityBuggy) {
FMLClientHandler.instance()
.getClient()
.displayGuiScreen(
new GuiBuggy(
player.inventory,
(EntityBuggy) player.ridingEntity,
((EntityBuggy) player.ridingEntity).getType()));
player.openContainer.windowId = (Integer) this.data.get(0);
}
break;
case 1:
int entityID = (Integer) this.data.get(2);
Entity entity = player.worldObj.getEntityByID(entityID);
if (entity != null && entity instanceof IInventorySettable) {
FMLClientHandler.instance()
.getClient()
.displayGuiScreen(
new GuiParaChest(player.inventory, (IInventorySettable) entity));
}
player.openContainer.windowId = (Integer) this.data.get(0);
break;
}
break;
case C_UPDATE_WIRE_BOUNDS:
TileEntity tile =
player.worldObj.getTileEntity(
(Integer) this.data.get(0), (Integer) this.data.get(1), (Integer) this.data.get(2));
if (tile instanceof TileEntityConductor) {
((TileEntityConductor) tile).adjacentConnections = null;
player
.worldObj
.getBlock(tile.xCoord, tile.yCoord, tile.zCoord)
.setBlockBoundsBasedOnState(player.worldObj, tile.xCoord, tile.yCoord, tile.zCoord);
}
break;
case C_OPEN_SPACE_RACE_GUI:
if (Minecraft.getMinecraft().currentScreen == null) {
TickHandlerClient.spaceRaceGuiScheduled = false;
player.openGui(
GalacticraftCore.instance,
GuiIdsCore.SPACE_RACE_START,
player.worldObj,
(int) player.posX,
(int) player.posY,
(int) player.posZ);
} else {
TickHandlerClient.spaceRaceGuiScheduled = true;
}
break;
case C_UPDATE_SPACE_RACE_DATA:
Integer teamID = (Integer) this.data.get(0);
String teamName = (String) this.data.get(1);
FlagData flagData = (FlagData) this.data.get(2);
Vector3 teamColor = (Vector3) this.data.get(3);
List<String> playerList = new ArrayList<String>();
for (int i = 4; i < this.data.size(); i++) {
String playerName = (String) this.data.get(i);
ClientProxyCore.flagRequestsSent.remove(playerName);
playerList.add(playerName);
}
SpaceRace race = new SpaceRace(playerList, teamName, flagData, teamColor);
race.setSpaceRaceID(teamID);
SpaceRaceManager.addSpaceRace(race);
break;
case C_OPEN_JOIN_RACE_GUI:
playerBaseClient.spaceRaceInviteTeamID = (Integer) this.data.get(0);
player.openGui(
GalacticraftCore.instance,
GuiIdsCore.SPACE_RACE_JOIN,
player.worldObj,
(int) player.posX,
(int) player.posY,
(int) player.posZ);
break;
case C_UPDATE_FOOTPRINT_LIST:
ClientProxyCore.footprintRenderer.footprints.clear();
for (int i = 0; i < this.data.size(); i++) {
Footprint print = (Footprint) this.data.get(i);
ClientProxyCore.footprintRenderer.addFootprint(print);
}
break;
case C_UPDATE_STATION_SPIN:
if (playerBaseClient.worldObj.provider instanceof WorldProviderOrbit) {
((WorldProviderOrbit) playerBaseClient.worldObj.provider)
.setSpinRate((Float) this.data.get(0), (Boolean) this.data.get(1));
}
break;
case C_UPDATE_STATION_DATA:
if (playerBaseClient.worldObj.provider instanceof WorldProviderOrbit) {
((WorldProviderOrbit) playerBaseClient.worldObj.provider)
.setSpinCentre((Double) this.data.get(0), (Double) this.data.get(1));
}
break;
case C_UPDATE_STATION_BOX:
if (playerBaseClient.worldObj.provider instanceof WorldProviderOrbit) {
((WorldProviderOrbit) playerBaseClient.worldObj.provider)
.setSpinBox(
(Integer) this.data.get(0),
(Integer) this.data.get(1),
(Integer) this.data.get(2),
(Integer) this.data.get(3),
(Integer) this.data.get(4),
(Integer) this.data.get(5));
}
break;
case C_UPDATE_THERMAL_LEVEL:
playerBaseClient.thermalLevel = (Integer) this.data.get(0);
break;
case C_DISPLAY_ROCKET_CONTROLS:
player.addChatMessage(
new ChatComponentText(
Keyboard.getKeyName(KeyHandlerClient.spaceKey.getKeyCode())
+ " - "
+ GCCoreUtil.translate("gui.rocket.launch.name")));
player.addChatMessage(
new ChatComponentText(
Keyboard.getKeyName(KeyHandlerClient.leftKey.getKeyCode())
+ " / "
+ Keyboard.getKeyName(KeyHandlerClient.rightKey.getKeyCode())
+ " - "
+ GCCoreUtil.translate("gui.rocket.turn.name")));
player.addChatMessage(
new ChatComponentText(
Keyboard.getKeyName(KeyHandlerClient.accelerateKey.getKeyCode())
+ " / "
+ Keyboard.getKeyName(KeyHandlerClient.decelerateKey.getKeyCode())
+ " - "
+ GCCoreUtil.translate("gui.rocket.updown.name")));
player.addChatMessage(
new ChatComponentText(
Keyboard.getKeyName(KeyHandlerClient.openFuelGui.getKeyCode())
+ " - "
+ GCCoreUtil.translate("gui.rocket.inv.name")));
break;
default:
break;
}
}
public static void setupDimensions() {
DimensionManager.registerProviderType(
IDsHelper.PrehistoricAgeID, PrehistoricWorldProvider.class, true);
DimensionManager.registerDimension(IDsHelper.PrehistoricAgeID, IDsHelper.PrehistoricAgeID);
}
public static void init() {
/* Initialize each mod block individually */
HarmonionOre = new BlockHarmonionOre(Config.getBlockID("blocks.base.harmonionore.id"), 0);
HarmonionBlock = new BlockHarmonionBlock(Config.getBlockID("blocks.base.harmonionblock.id"), 3);
HarmonionLog = new BlockHarmonionLog(Config.getBlockID("blocks.base.harmonionlog.id"));
HarmonionLeaves = new BlockHarmonionLeaves(Config.getBlockID("blocks.base.harmonionleaves.id"));
HarmonionSapling =
new BlockHarmonionSapling(Config.getBlockID("blocks.base.harmonionsapling.id"), 13);
HarmonionDoor =
new BlockHarmonionDoor(
Config.getBlockID("blocks.base.harmoniondoor.id"), 11, 12, Material.iron);
HarmonionGlass =
new BlockHarmonionGlass(
Config.getBlockID("blocks.base.harmonionglass.id"), 4, Material.glass, false);
HarmonionPortal =
(BlockHarmonionPortal)
((BlockHarmonionPortal)
(new BlockHarmonionPortal(
Config.getBlockID("blocks.base.harmonionportal.id"), 14)));
HarmonionFire =
(new BlockHarmonionFire(
Config.getBlockID("blocks.base.harmonionfire.id"), Block.fire.blockIndexInTexture));
blockPower = new BlockMicro(Config.getBlockID("blocks.base.harmonionwire.id"));
blockPower.setBlockName("Harmonionwire");
GameRegistry.registerBlock(blockPower, ItemMicro.class, "micro");
blockPower.addTileEntityMapping(0, TileCovered.class);
CoverLib.blockCoverPlate = blockPower;
blockMachine = new BlockMachine(Config.getBlockID("blocks.base.harmonionmachine.id"));
blockMachine.setBlockName("Harmonionmachine");
GameRegistry.registerBlock(blockMachine, ItemExtended.class, "machine");
blockMachine.setItemName(0, "Harmonionbatbox");
GameRegistry.registerTileEntity(TileBatteryBox.class, "HarmoionBatBox");
blockMachine.addTileEntityMapping(0, TileBatteryBox.class);
blockMachinePanel =
new BlockMachinePanel(Config.getBlockID("blocks.base.harmonionmachinepanel.id"));
GameRegistry.registerBlock(blockMachinePanel, ItemMachinePanel.class, "machinePanel");
GameRegistry.registerTileEntity(TileSolarPanel.class, "HarmonionSolar");
blockMachinePanel.addTileEntityMapping(0, TileSolarPanel.class);
blockMachinePanel.setItemName(0, "Harmonionsolar");
blockAppliance = new BlockAppliance(Config.getBlockID("blocks.base.harmonionappliance.id"));
GameRegistry.registerBlock(blockAppliance, ItemExtended.class, "appliance");
GameRegistry.registerTileEntity(TileChargingBench.class, "HarmonionCharge");
blockAppliance.setItemName(0, "harmonioncharge");
blockAppliance.addTileEntityMapping(0, TileChargingBench.class);
int var1;
int var2;
HarmonionLib.addCompatibleMapping(0, 1);
for (var1 = 0; var1 < 16; ++var1) {
HarmonionLib.addCompatibleMapping(0, 2 + var1);
HarmonionLib.addCompatibleMapping(1, 2 + var1);
HarmonionLib.addCompatibleMapping(65, 2 + var1);
for (var2 = 0; var2 < 16; ++var2) {
HarmonionLib.addCompatibleMapping(19 + var2, 2 + var1);
}
HarmonionLib.addCompatibleMapping(18, 2 + var1);
HarmonionLib.addCompatibleMapping(18, 19 + var1);
}
HarmonionLib.addCompatibleMapping(0, 65);
HarmonionLib.addCompatibleMapping(1, 65);
HarmonionLib.addCompatibleMapping(64, 65);
HarmonionLib.addCompatibleMapping(64, 67);
HarmonionLib.addCompatibleMapping(65, 67);
HarmonionLib.addCompatibleMapping(66, 67);
/* Adds Blocks into the game */
OreDictionary.registerOre("HarmonionOre", HarmonionOre);
GameRegistry.registerBlock(HarmonionOre, BlockOresMeta.class);
GameRegistry.registerBlock(HarmonionLeaves);
GameRegistry.registerBlock(HarmonionLog);
GameRegistry.registerBlock(HarmonionDoor);
GameRegistry.registerBlock(HarmonionGlass);
GameRegistry.registerBlock(HarmonionBlock);
GameRegistry.registerBlock(HarmonionPortal);
GameRegistry.registerBlock(HarmonionFire);
DimensionManager.registerProviderType(
Config.getBlockID("dimension.dimension.id"), WorldProviderHarmonion.class, false);
DimensionManager.registerDimension(
Config.getBlockID("dimension.dimension.id"), Config.getBlockID("dimension.dimension.id"));
/* WorldGen */
GameRegistry.registerWorldGenerator(new WorldPopulator());
EnumMachineBeta[] var6 = EnumMachineBeta.values();
int var3 = var6.length;
int var4;
var3 = var6.length;
for (var4 = 0; var4 < var3; ++var4) {
EnumMachineBeta var12 = var6[var4];
if (var12.isEnabled()) {
ItemRegistry.registerItem(var12.getTag(), var12.getItem());
}
}
}
@Override
public World createWorld(WorldCreator creator) {
if (creator == null) {
throw new IllegalArgumentException("Creator may not be null");
}
String name = creator.name();
World world = getWorld(name);
// WorldType type = WorldType.parseWorldType(creator.type().getName());
if (world != null) { // Existing forge world
return world;
}
if (firstBukkitWorld) {
DimensionManager.registerProviderType(
CraftWorldProvider.ProviderID, CraftWorldProvider.class, false);
firstBukkitWorld = false;
}
int dimension = -1000;
if (CraftWorldProvider.hasDimensionIdForName(name)) {
dimension = CraftWorldProvider.getDimensionIdForName(name);
} else {
dimension = DimensionManager.getNextFreeDimId();
CraftWorldProvider.setDimensionIdForName(name, dimension);
}
DimensionManager.registerDimension(dimension, CraftWorldProvider.ProviderID);
CraftWorldProvider wp = (CraftWorldProvider) DimensionManager.createProviderFor(dimension);
wp.setName(creator.name());
File folder = new File(getWorldContainer(), wp.getDimName());
if ((folder.exists()) && (!folder.isDirectory())) {
throw new IllegalArgumentException(
"File exists with the name '" + name + "' and isn't a folder");
}
ChunkGenerator generator = creator.generator();
boolean generateStructures = creator.generateStructures();
AnvilSaveConverter converter = new AnvilSaveConverter(folder);
if (converter.isOldMapFormat(wp.getDimensionName())) {
getLogger().info("Converting world '" + name + "'");
converter.convertMapFormat(name, new ConvertingProgressUpdate(theServer));
}
WorldType type = WorldType.parseWorldType(creator.type().getName());
// WorldServer internal = new WorldServer(theServer, new
// AnvilSaveHandler(getWorldContainer().getParentFile(), name, true), name, dimension, new
// WorldSettings(creator.seed(), EnumGameType.getByID(getDefaultGameMode().getValue()),
// generateStructures, false, type), theServer.theProfiler);
// WorldServerMulti internal = new WorldServerMulti(theServer, new
// AnvilSaveHandler(getWorldContainer() , name, true), name, dimension, new
// WorldSettings(creator.seed(), EnumGameType.getByID(getDefaultGameMode().getValue()),
// generateStructures, false, type), theServer.theProfiler, creator.environment(),
// generator);
WorldServer internal =
new WorldServerMulti(
theServer,
new AnvilSaveHandler(getWorldContainer(), wp.getDimName(), true),
name,
dimension,
new WorldSettings(
creator.seed(),
EnumGameType.getByID(getDefaultGameMode().getValue()),
generateStructures,
false,
type),
worlds.get(0).getHandle(),
theServer.theProfiler);
internal.addWorldAccess((IWorldAccess) new WorldManager(theServer, internal));
internal.difficultySetting = 1;
internal.provider = wp;
wp.registerWorld(internal);
// DimensionManager.setWorld(dimension, internal); not necessary, done in constructor of
// WorldServer
worlds.cacheIfNotPresent(dimension);
if (generator != null) {
(worlds.get(dimension))
.getPopulators()
.addAll(generator.getDefaultPopulators(worlds.get(dimension)));
}
pluginManager.callEvent(new WorldInitEvent((worlds.get(dimension))));
System.out.print(
"Preparing start region for level "
+ (theServer.worldServers.length - 1)
+ " (Seed: "
+ internal.getSeed()
+ ")");
if (DimensionManager.shouldLoadSpawn(dimension)) {
short short1 = 196;
long i = System.currentTimeMillis();
for (int j = -short1; j <= short1; j += 16) {
for (int k = -short1; k <= short1; k += 16) {
long l = System.currentTimeMillis();
if (l < i) {
i = l;
}
if (l > i + 1000L) {
int i1 = (short1 * 2 + 1) * (short1 * 2 + 1);
int j1 = (j + short1) * (short1 * 2 + 1) + k + 1;
System.out.println("Preparing spawn area for " + name + ", " + (j1 * 100 / i1) + "%");
i = l;
}
ChunkCoordinates chunkcoordinates = internal.getSpawnPoint();
internal.theChunkProviderServer.provideChunk(
chunkcoordinates.posX + j >> 4, chunkcoordinates.posZ + k >> 4);
} //
}
}
MinecraftForge.EVENT_BUS.post(new WorldEvent.Load(internal));
pluginManager.callEvent(new WorldLoadEvent(worlds.get(dimension)));
return worlds.get(dimension);
}
private static void registerCustomBiomesAndDimensions(AdditionalInfo info) {
int dimensionId = DimensionManager.getNextFreeDimId();
DimensionManager.registerProviderType(dimensionId, MonsterHunterWorld.class, false);
DimensionManager.registerDimension(dimensionId, dimensionId);
}
/** Add and register World Providers & Dimensions * */
public static void dimensionInit() {
DimensionManager.registerProviderType(tutDimensionID, WorldProviderAzanor.class, false);
DimensionManager.registerDimension(tutDimensionID, tutDimensionID);
}
