net.minecraftforge.common

## Class ForgeChunkManager

- java.lang.Object
- - net.minecraftforge.common.ForgeChunkManager

-     public class ForgeChunkManager
      extends Object

  Manages chunkloading for mods. The basic principle is a ticket based system. 1. Mods register a callback `setForcedChunkLoadingCallback(Object, LoadingCallback)` 2. Mods ask for a ticket `requestTicket(Object, World, Type)` and then hold on to that ticket. 3. Mods request chunks to stay loaded `forceChunk(Ticket, ChunkCoordIntPair)` or remove chunks from force loading `unforceChunk(Ticket, ChunkCoordIntPair)`. 4. When a world unloads, the tickets associated with that world are saved by the chunk manager. 5. When a world loads, saved tickets are offered to the mods associated with the tickets. The `ForgeChunkManager.Ticket.getModData()` that is set by the mod should be used to re-register chunks to stay loaded (and maybe take other actions). The chunkloading is configurable at runtime. The file "config/forgeChunkLoading.cfg" contains both default configuration for chunkloading, and a sample individual mod specific override section.
  Author:
    cpw

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ForgeChunkManager.ForceChunkEvent`
    `static interface` | `ForgeChunkManager.LoadingCallback` All mods requiring chunkloading need to implement this to handle the re-registration of chunk tickets at world loading time
    `static interface` | `ForgeChunkManager.OrderedLoadingCallback` This is a special LoadingCallback that can be implemented as well as the LoadingCallback to provide access to additional behaviour.
    `static interface` | `ForgeChunkManager.PlayerOrderedLoadingCallback`
    `static class` | `ForgeChunkManager.Ticket`
    `static class` | `ForgeChunkManager.Type`
    `static class` | `ForgeChunkManager.UnforceChunkEvent`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ForgeChunkManager()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static void` | `addConfigProperty(Object mod, String propertyName, String value, Property.Type type)`
    `static Chunk` | `fetchDormantChunk(long coords, World world)`
    `static void` | `forceChunk(ForgeChunkManager.Ticket ticket, ChunkCoordIntPair chunk)` Force the supplied chunk coordinate to be loaded by the supplied ticket.
    `static Map<String,Property>` | `getConfigMapFor(Object mod)`
    `static int` | `getMaxChunkDepthFor(String modId)`
    `static int` | `getMaxTicketLengthFor(String modId)`
    `static com.google.common.collect.ImmutableSetMultimap<ChunkCoordIntPair,ForgeChunkManager.Ticket>` | `getPersistentChunksFor(World world)` The list of persistent chunks in the world.
    `static void` | `putDormantChunk(long coords, Chunk chunk)`
    `static void` | `releaseTicket(ForgeChunkManager.Ticket ticket)` Release the ticket back to the system.
    `static void` | `reorderChunk(ForgeChunkManager.Ticket ticket, ChunkCoordIntPair chunk)` Reorganize the internal chunk list so that the chunk supplied is at the *end* of the list This helps if you wish to guarantee a certain "automatic unload ordering" for the chunks in the ticket list
    `static ForgeChunkManager.Ticket` | `requestPlayerTicket(Object mod, String player, World world, ForgeChunkManager.Type type)`
    `static ForgeChunkManager.Ticket` | `requestTicket(Object mod, World world, ForgeChunkManager.Type type)` Request a chunkloading ticket of the appropriate type for the supplied mod
    `static boolean` | `savedWorldHasForcedChunkTickets(File chunkDir)` Allows dynamically loading world mods to test if there are chunk tickets in the world Mods that add dynamically generated worlds (like Mystcraft) should call this method to determine if the world should be loaded during server starting.
    `static void` | `setForcedChunkLoadingCallback(Object mod, ForgeChunkManager.LoadingCallback callback)` Set a chunkloading callback for the supplied mod object
    `static int` | `ticketCountAvailableFor(Object mod, World world)` Discover the available tickets for the mod in the world
    `static int` | `ticketCountAvailableFor(String username)`
    `static void` | `unforceChunk(ForgeChunkManager.Ticket ticket, ChunkCoordIntPair chunk)` Unforce the supplied chunk, allowing it to be unloaded and stop ticking.

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ForgeChunkManager

          public ForgeChunkManager()

  - ### Method Detail

    - #### savedWorldHasForcedChunkTickets

          public static boolean savedWorldHasForcedChunkTickets(File chunkDir)

      Allows dynamically loading world mods to test if there are chunk tickets in the world Mods that add dynamically generated worlds (like Mystcraft) should call this method to determine if the world should be loaded during server starting.
      Parameters:
        `chunkDir` - The chunk directory to test: should be equivalent to `WorldServer.getChunkSaveLocation()`
      Returns:
        if there are tickets outstanding for this world or not

    - #### setForcedChunkLoadingCallback

          public static void setForcedChunkLoadingCallback(Object mod,
                                           ForgeChunkManager.LoadingCallback callback)

      Set a chunkloading callback for the supplied mod object
      Parameters:
        `mod` - The mod instance registering the callback
        `callback` - The code to call back when forced chunks are loaded

    - #### ticketCountAvailableFor

          public static int ticketCountAvailableFor(Object mod,
                                    World world)

      Discover the available tickets for the mod in the world
      Parameters:
        `mod` - The mod that will own the tickets
        `world` - The world
      Returns:
        The count of tickets left for the mod in the supplied world

    - #### getMaxTicketLengthFor

          public static int getMaxTicketLengthFor(String modId)

    - #### getMaxChunkDepthFor

          public static int getMaxChunkDepthFor(String modId)

    - #### ticketCountAvailableFor

          public static int ticketCountAvailableFor(String username)

    - #### requestPlayerTicket

          public static ForgeChunkManager.Ticket requestPlayerTicket(Object mod,
                                                     String player,
                                                     World world,
                                                     ForgeChunkManager.Type type)

    - #### requestTicket

          public static ForgeChunkManager.Ticket requestTicket(Object mod,
                                               World world,
                                               ForgeChunkManager.Type type)

      Request a chunkloading ticket of the appropriate type for the supplied mod
      Parameters:
        `mod` - The mod requesting a ticket
        `world` - The world in which it is requesting the ticket
        `type` - The type of ticket
      Returns:
        A ticket with which to register chunks for loading, or null if no further tickets are available

    - #### releaseTicket

          public static void releaseTicket(ForgeChunkManager.Ticket ticket)

      Release the ticket back to the system. This will also unforce any chunks held by the ticket so that they can be unloaded and/or stop ticking.
      Parameters:
        `ticket` - The ticket to release

    - #### forceChunk

          public static void forceChunk(ForgeChunkManager.Ticket ticket,
                        ChunkCoordIntPair chunk)

      Force the supplied chunk coordinate to be loaded by the supplied ticket. If the ticket's `ForgeChunkManager.Ticket.maxDepth` is exceeded, the least recently registered chunk is unforced and may be unloaded. It is safe to force the chunk several times for a ticket, it will not generate duplication or change the ordering.
      Parameters:
        `ticket` - The ticket registering the chunk
        `chunk` - The chunk to force

    - #### reorderChunk

          public static void reorderChunk(ForgeChunkManager.Ticket ticket,
                          ChunkCoordIntPair chunk)

      Reorganize the internal chunk list so that the chunk supplied is at the *end* of the list This helps if you wish to guarantee a certain "automatic unload ordering" for the chunks in the ticket list
      Parameters:
        `ticket` - The ticket holding the chunk list
        `chunk` - The chunk you wish to push to the end (so that it would be unloaded last)

    - #### unforceChunk

          public static void unforceChunk(ForgeChunkManager.Ticket ticket,
                          ChunkCoordIntPair chunk)

      Unforce the supplied chunk, allowing it to be unloaded and stop ticking.
      Parameters:
        `ticket` - The ticket holding the chunk
        `chunk` - The chunk to unforce

    - #### getPersistentChunksFor

          public static com.google.common.collect.ImmutableSetMultimap<ChunkCoordIntPair,ForgeChunkManager.Ticket> getPersistentChunksFor(World world)

      The list of persistent chunks in the world. This set is immutable.
      Parameters:
        `world` -
      Returns:
        the list of persistent chunks in the world

    - #### putDormantChunk

          public static void putDormantChunk(long coords,
                             Chunk chunk)

    - #### fetchDormantChunk

          public static Chunk fetchDormantChunk(long coords,
                                World world)

    - #### getConfigMapFor

          public static Map<String,Property> getConfigMapFor(Object mod)

    - #### addConfigProperty

          public static void addConfigProperty(Object mod,
                               String propertyName,
                               String value,
                               Property.Type type)