public void newDay(Collection<TownBuilding> buildings) {
    Set<GatheringLocation> previous = new HashSet(locations);
    locations = new HashSet();

    // Remove all previous locations
    for (GatheringLocation location : previous) {
      World world = DimensionManager.getWorld(location.dimension);
      if (world.getBlock(location.x, location.y, location.z) == location.block) {
        if (world.getBlockMetadata(location.x, location.y, location.z) == location.meta) {
          world.setBlockToAir(location.x, location.y, location.z);
        }
      }
    }

    // Create some new spawn spots based on where we have buildings
    for (TownBuilding building : buildings) {
      World world = DimensionManager.getWorld(building.dimension);
      int placed = 0;
      for (int i = 0; i < 64 && placed < 10; i++) {
        int x = building.xCoord + 32 - world.rand.nextInt(64);
        int y = building.yCoord + 4 - world.rand.nextInt(8);
        int z = building.zCoord + 32 - world.rand.nextInt(64);
        if (world.getBlock(x, y, z) == Blocks.grass
            && world.getBlock(x, y + 1, z).isAir(world, x, y + 1, z)) {
          ItemStack random = getRandomBlock();
          Block block = Block.getBlockFromItem(random.getItem());
          int meta = random.getItemDamage();
          if (world.setBlock(x, y + 1, z, block, meta, 2)) {
            locations.add(new GatheringLocation(block, meta, building.dimension, x, y + 1, z));
            placed++;
          }
        }
      }
    }
  }
 @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);
 }
Exemple #3
0
  /** Checking right click actions on blocks. */
  public boolean checkBlockInteraction(
      Resident res, BlockPos bp, PlayerInteractEvent.Action action) {
    Block blockType =
        DimensionManager.getWorld(bp.getDim()).getBlock(bp.getX(), bp.getY(), bp.getZ());
    for (SegmentBlock segment : segmentsBlocks) {
      if (segment.getCheckClass().isAssignableFrom(blockType.getClass())
          && (segment.getMeta() == -1
              || segment.getMeta()
                  == DimensionManager.getWorld(bp.getDim())
                      .getBlockMetadata(bp.getX(), bp.getY(), bp.getZ()))
          && (segment.getType() == BlockType.ANY_CLICK
              || segment.getType() == BlockType.RIGHT_CLICK
                  && action == PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK
              || segment.getType() == BlockType.LEFT_CLICK
                  && action == PlayerInteractEvent.Action.LEFT_CLICK_BLOCK)) {
        int dim = bp.getDim();
        int x = bp.getX();
        int y = bp.getY();
        int z = bp.getZ();

        if (!hasPermission(res, segment, dim, x, y, z)) {
          if (segment.hasClientUpdate())
            sendClientUpdate(
                segment.getClientUpdateCoords(), bp, (EntityPlayerMP) res.getPlayer(), null);
          return true;
        }
      }
    }

    return false;
  }
 /** Gets the worldServer by the given dimension. */
 public WorldServer worldServerForDimension(int par1) {
   WorldServer ret = DimensionManager.getWorld(par1);
   if (ret == null) {
     DimensionManager.initDimension(par1);
     ret = DimensionManager.getWorld(par1);
   }
   return ret;
 }
Exemple #5
0
  public static void LoadDim() {

    // generation
    GameRegistry.registerWorldGenerator(new DreSca(), 0);

    // dimension
    DimensionManager.registerProviderType(dimension, WorldProviderDreSca.class, false);
    DimensionManager.registerDimension(dimension, dimension);
  }
 private void innerLoad() {
   File f = DimensionManager.getCurrentSaveRootDirectory();
   conf =
       new HyperCubeConfig(
           new File(
               DimensionManager.getCurrentSaveRootDirectory(),
               "enderio/dimensionalTransceiver.cfg"));
   publicChannels.addAll(conf.getPublicChannels());
   userChannels.putAll(conf.getUserChannels());
 }
 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);
     }
   }
 }
 /**
  * Return the current root directory for the world save. Accesses getSaveHandler from the
  * overworld
  *
  * @return the root directory of the save
  */
 public static File getCurrentSaveRootDirectory() {
   if (DimensionManager.getWorld(0) != null) {
     return ((SaveHandler) DimensionManager.getWorld(0).getSaveHandler()).getWorldDirectory();
   } else if (MinecraftServer.getServer() != null) {
     MinecraftServer srv = MinecraftServer.getServer();
     SaveHandler saveHandler =
         (SaveHandler) srv.getActiveAnvilConverter().getSaveLoader(srv.getFolderName(), false);
     return saveHandler.getWorldDirectory();
   } else {
     return null;
   }
 }
  public WorldServer getWorld() {
    WorldServer world = DimensionManager.getWorld(dimension);

    if (world == null) {
      DimensionManager.initDimension(dimension);
      world = DimensionManager.getWorld(dimension);

      if (world == null) {
        return null; // How?
      }
    }

    return world;
  }
Exemple #10
0
    @Override
    public void readFromNBT(NBTTagCompound tagCom) {
      TEC.idToUsername.clear();
      NBTTagList idUsernameTag = tagCom.getTagList("idUsernames", 10);
      for (int i = 0; i < idUsernameTag.tagCount(); i++) {
        NBTTagCompound tag = idUsernameTag.getCompoundTagAt(i);
        TEC.idToUsername.put(
            UUID.fromString(tagCom.getString("UUID")), tagCom.getString("playerName"));
      }

      TEC.aspectBuffer.clear();
      NBTTagList bufferTag = tagCom.getTagList("bufferTag", 10);
      for (int i = 0; i < bufferTag.tagCount(); i++) {
        NBTTagCompound idedBuffer = bufferTag.getCompoundTagAt(i);
        UUID playerID = UUID.fromString(idedBuffer.getString("playerID"));
        NBTTagList playersBuffer = idedBuffer.getTagList("buffer", 10);
        for (int j = 0; j < playersBuffer.tagCount(); j++) {
          NBTTagCompound bufferEntry = playersBuffer.getCompoundTagAt(j);

          NBTTagCompound scanTag = bufferEntry.getCompoundTag("scan");
          ScanResult scan =
              new ScanResult(
                  scanTag.getByte("type"),
                  scanTag.getInteger("id"),
                  scanTag.getInteger("meta"),
                  EntityList.createEntityFromNBT(
                      scanTag.getCompoundTag("entityTag"), DimensionManager.getWorld(0)),
                  scanTag.getString("phenomena"));

          TEC.addAspect(
              playerID, scan, bufferEntry.getDouble("chance"), bufferEntry.getDouble("percent"));
        }
      }
    }
  private void serverTick(boolean doEffects) {
    World entityWorld = MinecraftServer.getServer().getEntityWorld();
    RfToolsDimensionManager dimensionManager =
        RfToolsDimensionManager.getDimensionManager(entityWorld);

    if (!dimensionManager.getDimensions().isEmpty()) {
      DimensionStorage dimensionStorage = DimensionStorage.getDimensionStorage(entityWorld);

      for (Map.Entry<Integer, DimensionDescriptor> entry :
          dimensionManager.getDimensions().entrySet()) {
        Integer id = entry.getKey();
        // If there is an activity probe we only drain power if the dimension is loaded (a player is
        // there or a chunkloader)
        DimensionInformation information = dimensionManager.getDimensionInformation(id);
        WorldServer world = DimensionManager.getWorld(id);

        // Power handling.
        if (world != null || information.getProbeCounter() == 0) {
          handlePower(doEffects, dimensionStorage, entry, id, information);
        }

        // Special effect handling.
        if (world != null && !world.playerEntities.isEmpty()) {
          handleRandomEffects(world, information);
        }
      }

      dimensionStorage.save(entityWorld);
    }
  }
  public static SpaceStationWorldData getMPSpaceStationData(
      World var0, int var1, EntityPlayer player) {
    final String var2 = SpaceStationWorldData.getSpaceStationID(var1);
    if (var0 == null) {
      var0 = DimensionManager.getProvider(0).worldObj;
    }
    SpaceStationWorldData var3 =
        (SpaceStationWorldData) var0.loadItemData(SpaceStationWorldData.class, var2);

    if (var3 == null) {
      var3 = new SpaceStationWorldData(var2);
      var0.setItemData(var2, var3);
      var3.dataCompound = new NBTTagCompound();

      if (player != null) {
        var3.owner = player.getGameProfile().getName().replace(".", "");
      }

      var3.spaceStationName = "Station: " + var3.owner;

      if (player != null) {
        var3.allowedPlayers.add(player.getGameProfile().getName());
      }

      var3.markDirty();
    }

    if (var3.getSpaceStationName().replace(" ", "").isEmpty()) {
      var3.setSpaceStationName("Station: " + var3.owner);
      var3.markDirty();
    }

    return var3;
  }
  /** Saves all necessary data as preparation for stopping the server. */
  public void stopServer() {
    if (!this.worldIsBeingDeleted) {
      this.func_98033_al().func_98233_a("Stopping server");

      if (this.getNetworkThread() != null) {
        this.getNetworkThread().stopListening();
      }

      if (this.serverConfigManager != null) {
        this.func_98033_al().func_98233_a("Saving players");
        this.serverConfigManager.saveAllPlayerData();
        this.serverConfigManager.removeAllPlayers();
      }

      this.func_98033_al().func_98233_a("Saving worlds");
      this.saveAllWorlds(false);

      for (int i = 0; i < this.worldServers.length; ++i) {
        WorldServer worldserver = this.worldServers[i];
        MinecraftForge.EVENT_BUS.post(new WorldEvent.Unload(worldserver));
        worldserver.flush();
      }

      WorldServer[] tmp = worldServers;
      for (WorldServer world : tmp) {
        DimensionManager.setWorld(world.provider.dimensionId, null);
      }

      if (this.usageSnooper != null && this.usageSnooper.isSnooperRunning()) {
        this.usageSnooper.stopSnooper();
      }
    }
  }
  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.func_147139_a(mcServer.func_147135_j());
  }
  @SubscribeEvent
  public void onClientPacket(ClientCustomPacketEvent event) {

    EntityClientPlayerMP player = Minecraft.getMinecraft().thePlayer;
    ByteBufInputStream bbis = new ByteBufInputStream(event.packet.payload());
    byte packetType;
    int dimension;
    byte packetID;
    try {
      packetType = bbis.readByte();
      dimension = bbis.readInt();
      World world = DimensionManager.getWorld(dimension);
      if (packetType == 2) {
        this.handleRocketJumpHackyPacket(bbis, world);
      }
      if (packetType == 3) {
        this.handleExplodePacket(bbis, world);
      }
      //        	for (int i = 0; i < 3; i++){
      //        		player.worldObj.spawnParticle("smoke", x, y, z, -0.005D+(Math.random()*0.01D),
      // 0.025D, -0.005D+(Math.random()*0.01D));
      //        	}

      bbis.close();
    } catch (Exception e) {
      e.printStackTrace();
      return;
    }
  }
  @Override
  public void onSpaceDimensionChanged(
      World newWorld, EntityPlayerMP player, boolean ridingAutoRocket) {
    if (BlankPlanet.makelandingplatform) {
      int X = player.getPlayerCoordinates().posX;
      int Z = player.getPlayerCoordinates().posZ;
      if (newWorld.isAirBlock(X, 100, Z)
          && newWorld == DimensionManager.getWorld(BlankPlanet.dimensionid)) {
        for (int i = 0; i < 5; i++) {
          for (int j = 0; j < 5; j++) {
            newWorld.setBlock(X + i, 100, Z + j, Blocks.stone);
          }
        }

        for (int i = 0; i < 5; i++) {
          for (int j = 0; j < 5; j++) {
            newWorld.setBlock(X - i, 100, Z + j, Blocks.stone);
          }
        }

        for (int i = 0; i < 5; i++) {
          for (int j = 0; j < 5; j++) {
            newWorld.setBlock(X + i, 100, Z - j, Blocks.stone);
          }
        }

        for (int i = 0; i < 5; i++) {
          for (int j = 0; j < 5; j++) {
            newWorld.setBlock(X - i, 100, Z - j, Blocks.stone);
          }
        }
      }
    }
  }
Exemple #17
0
  @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);
  }
 @Override
 public void reload() {
   MinecraftScriptMod.getLogger().fine("Reloading Scripting Scope");
   loadScope(false);
   loadAllScripts(_scriptsDirectory, false);
   loadAllScripts(new File(DimensionManager.getCurrentSaveRootDirectory(), "scripts"), true);
 }
 @Override
 public void doCommand(ItemStack duplicator, EntityPlayerMP sender, String[] arguments) {
   try {
     String name = arguments.length == 2 ? arguments[1] : sender.getCommandSenderName();
     File file =
         new File(
             DimensionManager.getCurrentSaveRootDirectory().getPath()
                 + File.separator
                 + "managers"
                 + File.separator
                 + name
                 + ".nbt");
     if (!file.exists()) {
       throw new CommandException("Couldn't access file: " + name + ".nbt");
     }
     NBTTagCompound tagCompound = CompressedStreamTools.read(file);
     duplicator.setTagCompound(unstripBaseNBT(tagCompound));
     CommandBase.getCommandSenderAsPlayer(sender)
         .addChatComponentMessage(
             new ChatComponentText(
                 LocalizationHelper.translateFormatted(
                     "stevesaddons.command.loadSuccess", name + ".nbt")));
   } catch (IOException e) {
     throw new CommandException("stevesaddons.command.loadFailed");
   }
 }
  public TileEntity getBlockTileEntity() {
    WorldServer world = getWorld();

    if (world == null) {
      DimensionManager.initDimension(dimension);
      world = DimensionManager.getWorld(dimension);

      if (world == null) {
        return null; // How?
      }
    }

    world.getChunkProvider().loadChunk(posX >> 4, posY >> 4);

    return world.getBlockTileEntity(posX, posY, posZ);
  }
  public static void teleport(EntityPlayerMP player, WarpPoint point) {
    if (point.getWorld() == null) {
      DimensionManager.initDimension(point.getDimension());
      if (point.getWorld() == null) {
        ChatOutputHandler.chatError(
            player, Translator.translate("Unable to teleport! Target dimension does not exist"));
        return;
      }
    }

    // Check permissions
    UserIdent ident = UserIdent.get(player);
    if (!APIRegistry.perms.checkPermission(player, TELEPORT_FROM))
      throw new TranslatedCommandException("You are not allowed to teleport from here.");
    if (!APIRegistry.perms.checkUserPermission(ident, point.toWorldPoint(), TELEPORT_TO))
      throw new TranslatedCommandException("You are not allowed to teleport to that location.");
    if (player.dimension != point.getDimension()
        && !APIRegistry.perms.checkUserPermission(ident, point.toWorldPoint(), TELEPORT_CROSSDIM))
      throw new TranslatedCommandException("You are not allowed to teleport across dimensions.");

    // Get and check teleport cooldown
    int teleportCooldown =
        ServerUtil.parseIntDefault(
                APIRegistry.perms.getUserPermissionProperty(ident, TELEPORT_COOLDOWN), 0)
            * 1000;
    if (teleportCooldown > 0) {
      PlayerInfo pi = PlayerInfo.get(player);
      long cooldownDuration =
          (pi.getLastTeleportTime() + teleportCooldown) - System.currentTimeMillis();
      if (cooldownDuration >= 0) {
        ChatOutputHandler.chatNotification(
            player,
            Translator.format("Cooldown still active. %d seconds to go.", cooldownDuration / 1000));
        return;
      }
    }

    // Get and check teleport warmup
    int teleportWarmup =
        ServerUtil.parseIntDefault(
            APIRegistry.perms.getUserPermissionProperty(ident, TELEPORT_WARMUP), 0);
    if (teleportWarmup <= 0) {
      checkedTeleport(player, point);
      return;
    }

    if (!canTeleportTo(point)) {
      ChatOutputHandler.chatError(
          player, Translator.translate("Unable to teleport! Target location obstructed."));
      return;
    }

    // Setup timed teleport
    tpInfos.put(player.getPersistentID(), new TeleportInfo(player, point, teleportWarmup * 1000));
    ChatOutputHandler.chatNotification(
        player,
        Translator.format(
            "Teleporting. Please stand still for %s.",
            ChatOutputHandler.formatTimeDurationReadable(teleportWarmup, true)));
  }
  @SideOnly(Side.CLIENT)
  public void addInformation(
      ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4) {
    par3List.add(
        String.format(
            "Charge: %d / %d RF",
            new Object[] {
              Integer.valueOf(getEnergyStored(par1ItemStack)), Integer.valueOf(10000000)
            }));

    DimensionalLinkEntry[] entries = readEntries(par1ItemStack);
    if (entries.length != 0) {
      par3List.add("");
      par3List.add("Bound to:");
      for (DimensionalLinkEntry entry : entries) {
        String dimName = DimensionManager.getProvider(entry.dimID).getDimensionName();

        par3List.add(
            String.format(
                "[%s] %d:%d:%d",
                new Object[] {
                  dimName,
                  Integer.valueOf(entry.x),
                  Integer.valueOf(entry.y),
                  Integer.valueOf(entry.z)
                }));
      }
    }
  }
Exemple #23
0
public class DreSca implements IWorldGenerator {

  public static SparkWorld worldTypeDreSca;
  public static int dimension = DimensionManager.getNextFreeDimId();

  // biome
  public static BiomeGenBase dscape = new BiomeGenDreSca(52).setBiomeName("DreamScape");

  public static CreativeTabs DreScaTab =
      new CreativeTabs("DreScaThings") {
        public Item getTabIconItem() {
          return SparkItems.DreScaPorter;
        };
      };

  public static void LoadDim() {

    // generation
    GameRegistry.registerWorldGenerator(new DreSca(), 0);

    // dimension
    DimensionManager.registerProviderType(dimension, WorldProviderDreSca.class, false);
    DimensionManager.registerDimension(dimension, dimension);
  }

  public void generate(
      Random random,
      int chunkX,
      int chunkZ,
      World world,
      IChunkProvider chunkGenerator,
      IChunkProvider chunkProvider) {
    switch (world.provider.dimensionId) {
      case 0:
        generateSurface(world, random, chunkX * 16, chunkZ * 16);
        break;
    }
  }

  public void generateSurface(World world, Random random, int blockX, int blockZ) {

    int RandPosX = blockX + random.nextInt(5);
    int RandPosY = random.nextInt(128);
    int RandPosZ = blockZ + random.nextInt(5);
    (new WorldGenCactus()).generate(world, random, RandPosX, RandPosY, RandPosZ);

    int RandPosX1 = blockX + random.nextInt(5);
    int RandPosY1 = random.nextInt(128);
    int RandPosZ1 = blockZ + random.nextInt(5);
    (new WorldGenIceSpike()).generate(world, random, RandPosX1, RandPosY1, RandPosZ1);

    /*for(int k = 0; k < 2; k++) {
    	int RandPosX = blockX + random.nextInt(16);
        int RandPosY = random.nextInt(128);
        int RandPosZ = blockZ + random.nextInt(16);
        (new WorldGenCreeperTemple()).generate(world, random, RandPosX, RandPosY, RandPosZ);
    }*/
  }
}
  @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 World getWorld() {
   // Cauldron start - fixes MFR proxy worlds used with grinder/slaughterhouse
   if (entity.worldObj.getWorld() == null) {
     return DimensionManager.getWorld(0).getWorld();
   }
   // Cauldron end
   return entity.worldObj.getWorld();
 }
  protected void loadAllWorlds(
      String par1Str, String par2Str, long par3, WorldType par5WorldType, String par6Str) {
    this.convertMapIfNeeded(par1Str);
    this.setUserMessage("menu.loadingLevel");
    ISaveHandler isavehandler = this.anvilConverterForAnvilFile.getSaveLoader(par1Str, true);
    WorldInfo worldinfo = isavehandler.loadWorldInfo();
    WorldSettings worldsettings;

    if (worldinfo == null) {
      worldsettings =
          new WorldSettings(
              par3,
              this.getGameType(),
              this.canStructuresSpawn(),
              this.isHardcore(),
              par5WorldType);
      worldsettings.func_82750_a(par6Str);
    } else {
      worldsettings = new WorldSettings(worldinfo);
    }

    if (this.enableBonusChest) {
      worldsettings.enableBonusChest();
    }

    WorldServer overWorld =
        (isDemo()
            ? new DemoWorldServer(this, isavehandler, par2Str, 0, theProfiler, func_98033_al())
            : new WorldServer(
                this, isavehandler, par2Str, 0, worldsettings, theProfiler, func_98033_al()));
    for (int dim : DimensionManager.getStaticDimensionIDs()) {
      WorldServer world =
          (dim == 0
              ? overWorld
              : new WorldServerMulti(
                  this,
                  isavehandler,
                  par2Str,
                  dim,
                  worldsettings,
                  overWorld,
                  theProfiler,
                  func_98033_al()));
      world.addWorldAccess(new WorldManager(this, world));

      if (!this.isSinglePlayer()) {
        world.getWorldInfo().setGameType(this.getGameType());
      }

      this.serverConfigManager.setPlayerManager(this.worldServers);

      MinecraftForge.EVENT_BUS.post(new WorldEvent.Load(world));
    }

    this.serverConfigManager.setPlayerManager(new WorldServer[] {overWorld});
    this.setDifficultyForAllWorlds(this.getDifficulty());
    this.initialWorldChunkLoad();
  }
Exemple #27
0
 @Override
 public boolean unloadWorld(World world, boolean save) {
   WorldServer handle = ((CraftWorld) world).getHandle();
   WorldUnloadEvent ev = new WorldUnloadEvent(world);
   getPluginManager().callEvent(ev);
   if (ev.isCancelled()) return false; // cancelled
   DimensionManager.unloadWorld(handle.getWorldInfo().getDimension());
   worlds.remove(handle.getWorldInfo().getDimension());
   return true;
 }
Exemple #28
0
	public World getWorld(int dimID) {
		if (worlds.containsKey(dimID))
			return worlds.get(dimID);
		else if (!worlds.containsKey(dimID) && Arrays.asList(DimensionManager.getIDs()).contains(dimID)) {
			// dim there but not registered with us.
			WorldServer internal = DimensionManager.getWorld(dimID);
			int dim = internal.getWorldInfo().getDimension();
				System.out.println("Registering dimension with BukkitForge: " + dim + "..." );
				WorldProvider w = internal.provider;
				
				Environment env = w.isHellWorld ? Environment.NETHER : Environment.NORMAL;
				ChunkGenerator cg = new NormalChunkGenerator(internal);//(((WorldServer)ev.world).theChunkProviderServer);
				BukkitWorld bukkit = new BukkitWorld(internal, cg, env);
				BukkitServer.instance().worlds.put(dim, bukkit);
				return bukkit;
			
		}
		return null;
	}
  @Override
  public void fromBytes(ByteBuf buf) {
    world = DimensionManager.getWorld(buf.readInt());

    try {
      packet = EnumConnectionState.PLAY.getPacket(EnumPacketDirection.SERVERBOUND, buf.readInt());
      packet.readPacketData(new PacketBuffer(buf));
    } catch (InstantiationException | IllegalAccessException | IOException e) {
      throw new DecoderException(e);
    }
  }
  /** Checks if the block whitelist is still valid */
  public static boolean isBlockWhitelistValid(BlockWhitelist bw) {
    // Delete if the town is gone
    if (MyTownUtils.getTownAtPosition(bw.getDim(), bw.getX() >> 4, bw.getZ() >> 4) == null)
      return false;

    if (bw.getFlagType() == FlagType.ACTIVATE
        && !checkActivatedBlocks(
            DimensionManager.getWorld(bw.getDim()).getBlock(bw.getX(), bw.getY(), bw.getZ()),
            DimensionManager.getWorld(bw.getDim())
                .getBlockMetadata(bw.getX(), bw.getY(), bw.getZ()))) return false;
    if (bw.getFlagType() == FlagType.MODIFY
        || bw.getFlagType() == FlagType.ACTIVATE
        || bw.getFlagType() == FlagType.USAGE) {
      TileEntity te =
          DimensionManager.getWorld(bw.getDim()).getTileEntity(bw.getX(), bw.getY(), bw.getZ());
      if (te == null) return false;
      return getFlagsForTile(te.getClass()).contains(bw.getFlagType());
    }
    return true;
  }