common/codechicken/multipart/MultiPartRegistry.scala

package codechicken.multipart

import scala.collection.mutable.HashMap
import codechicken.lib.packet.PacketCustom
import codechicken.lib.data.MCDataOutput
import codechicken.lib.data.MCDataInput
import net.minecraft.world.World
import codechicken.lib.vec.BlockCoord
import scala.collection.mutable.ListBuffer
import cpw.mods.fml.common.ModContainer
import cpw.mods.fml.common.Loader

/**
 * This class handles the registration and internal ID mapping of all multipart classes.
 */
object MultiPartRegistry
{
    /**
     * Interface to be registered for constructing parts.
     * Every instance of every multipart is constructed from an implementor of this.
     */
    trait IPartFactory
    {
        /**
         * Create a new instance of the part with the specified type name identifier
         * @param client If the part instance is for the client or the server
         */
        def createPart(name:String, client:Boolean):TMultiPart
    }
    
    /**
     * An interface for converting existing blocks/tile entities to multipart versions.
     */
    trait IPartConverter
    {
        /**
         * Return true if this converter can handle the specific blockID (may or may not actually convert the block)
         */
        def canConvert(blockID:Int):Boolean
        /**
         * Return a multipart version of the block at pos in world. Return null if no conversion is possible.
         */
        def convert(world:World, pos:BlockCoord):TMultiPart
    }
    
    private val typeMap:HashMap[String, (Boolean)=>TMultiPart] = new HashMap
    private val nameMap:HashMap[String, Int] = new HashMap
    private var idMap:Array[(String, (Boolean)=>TMultiPart)] = _
    private val idWriter = new IDWriter
    private val converters:Array[Seq[IPartConverter]] = Array.fill(4096)(Seq())
    private val containers:HashMap[String, ModContainer] = new HashMap()
    
    /**
     * The state of the registry. 0 = no parts, 1 = registering, 2 = registered
     */
    private var state:Int = 0
    
    /**
     * Register a part factory with an array of types it is capable of instantiating. Must be called before postInit
     */
    def registerParts(partFactory:IPartFactory, types:Array[String])
    {
        registerParts(partFactory.createPart _, types:_*)
    }
    
    /**
     * Scala function version of registerParts
     */
    def registerParts(partFactory:(String, Boolean)=>TMultiPart, types:String*)
    {
        if(loaded)
            throw new IllegalStateException("Parts must be registered in the init methods.")
        state=1
        
        val container = Loader.instance.activeModContainer
        if(container == null)
            throw new IllegalStateException("Parts must be registered during the initialization phase of a mod container")
        
        types.foreach{s => 
            if(typeMap.contains(s))
                throw new IllegalStateException("Part with id "+s+" is already registered.")

            typeMap.put(s, (c:Boolean) => partFactory(s, c))
            containers.put(s, container)
        }
    }
    
    /**
     * Register a part converter instance
     */
    def registerConverter(c:IPartConverter)
    {
        for(i <- 0 until 4096)
            if(c.canConvert(i))
                converters(i) = converters(i):+c
    }
    
    private[multipart] def beforeServerStart()
    {
        idMap = typeMap.toList.sortBy(_._1).toArray
        idWriter.setMax(idMap.length)
        nameMap.clear()
        for(i <- 0 until idMap.length)
            nameMap.put(idMap(i)._1, i)
    }
    
    private[multipart] def writeIDMap(packet:PacketCustom)
    {
        packet.writeInt(idMap.length)
        idMap.foreach(e => packet.writeString(e._1))
    }
    
    private[multipart] def readIDMap(packet:PacketCustom):Seq[String] =
    {
        val k = packet.readInt()
        idWriter.setMax(k)
        idMap = new Array(k)
        nameMap.clear()
        val missing = ListBuffer[String]()
        for(i <- 0 until k)
        {
            val s = packet.readString()
            val v = typeMap.get(s)
            if(v.isEmpty)
                missing+=s
            else {
                idMap(i) = (s, v.get)
                nameMap.put(s, i)
            }
        }
        return missing
    }
    
    /**
     * Return true if any multiparts have been registered
     */
    private[multipart] def required = state > 0
    
    /**
     * Return true if no more parts can be registered
     */
    def loaded = state == 2
    
    private[multipart] def postInit(){state = 2}
    
    /**
     * Writes the id of part to data
     */
    def writePartID(data:MCDataOutput, part:TMultiPart)
    {
        idWriter.write(data, nameMap.get(part.getType).get)
    }
    
    /**
     * Uses instantiators to creat a new part from the id read from data
     */
    def readPart(data:MCDataInput) = idMap(idWriter.read(data))._2(true)
    
    /**
     * Uses instantiators to create a new part with specified identifier on side
     */
    def createPart(name:String, client:Boolean):TMultiPart = 
    {
        val part = typeMap.get(name)
        if(part.isDefined)
            return part.get(client)
        else
        {
            System.err.println("Missing mapping for part with ID: "+name)
            return null
        }
    }
    
    /**
     * Calls converters to create a multipart version of the block at pos
     */
    def convertBlock(world:World, pos:BlockCoord, id:Int):TMultiPart =
    {
        converters(id).foreach{c =>
            val ret = c.convert(world, pos)
            if(ret != null)
                return ret
        }
        return null
    }
    
    def getModContainer(name:String) = containers(name)
}