Ruby Source code

#==============================================================================
# ** ICG - Generator
#------------------------------------------------------------------------------
# Das Skript ist teil des ICG.
# Dies ist das Herzstück - Der Generator!
#------------------------------------------------------------------------------
#  Author:  ITgenie98
#   website: https://www.rpg-studio.org/forum/index.php?page=User&userID=9315/
#  Datum:   Januar 2018 / January 2018
#
#  Maker:  RPG Maker XP
#
#  Nutzungsbedingungen:
#   Schreibe den namen des Author's in die Credits.
#   Freier gebrauch für nicht-kommerzielle Zwecke,
#   für Kommerzielle zwecke Author auf www.RPG-Studio.org anfragen
#   Keine Weiterverbreitung in orginaler oder abgeänderter form
#   
#   Put the Author's name in the Credits.
#   Free for non-commercial Usage,
#   for Commercial Projects ask the Author on www.RPG-Studio.org
#   No Sharing of original or modifed version
#==============================================================================
# ** ICG
#==============================================================================
module ICG
  VERSION = "v1.7.3"
 
  #============================================================================
  # ** ICG::Generator
  #============================================================================
  class Generator
 
    def initialize(filename)
      @filename = filename
      @resList = ICG_Config.loadResList(filename)
      @rect = nil
    end
    #--------------------------------------------------------------------------
    # * logging method
    #--------------------------------------------------------------------------
    DEBUG = false
    def log(msg)
      if DEBUG and (defined?(Console) == 'constant' && Console.class == Class)
        puts("[ICG-Generator] " + msg)
      end
    end
    #------------------------------------------------------------------------
    # * Generates the charset
    # please see the User Manual for detailed Instructions
    #------------------------------------------------------------------------
    def generateChar(data = [], key = nil)
      @genKey = []
      @genKey.push(@filename)
 
      #exist = key == nil ? false : ICG_Cache.getGenKey(key)
 
      #no body image? error...
      raise "No body image found for '#{@filename}'" if @resList.findType("body") == nil
 
      body = RPG::Cache.character(@resList.findType("body")[0][1], 0)
      @rect = body.rect
 
      #create a new bitmap
      bmp = Bitmap.new(@rect.width, @rect.height)
 
      hairRes = getMultiLayerRes(data, "hair")
      @genKey.push(hairRes[1]) if hairRes != nil
 
      capeRes = getMultiLayerRes(data, "cape")
      @genKey.push(capeRes[1]) if capeRes != nil
 
      acc5Res = getMultiLayerRes(data, "acc5")
      @genKey.push(acc5Res[1]) if acc5Res != nil
 
      #render back hair, for long hairs
      renderFile(bmp, hairRes[3], true) if hairRes != nil
 
      #render the back cape
      renderFile(bmp, capeRes[3], true) if capeRes != nil
 
      #render back acc5
      renderFile(bmp, acc5Res[3], true) if acc5Res != nil
 
      bmp.blt(0, 0, body, @rect)   #add the body
 
      renderResource(bmp, "eyes", data)   #render some eyes
 
      renderResource(bmp, "shoes", data, true)  #shoes for the people
 
      #difficult rendering: clothing
      armor2 = getTypeFromData(data, "armor2")
      if armor2 == nil
        armor2 = [nil, nil, "true"]
      end
 
      armor1 = getTypeFromData(data, "armor1")
      if armor1 == nil
        armor1 = [nil, nil, "true"]
      end
 
      renderResource(bmp, "clothing2", data, true) if armor2[2]=="true"
      renderFile(bmp, armor2[1]) if armor2[1] != nil
 
      renderResource(bmp, "clothing1", data, true) if armor1[2]=="true"
      renderFile(bmp, armor1[1]) if armor1[1] != nil
 
      #render the upper part of the cape
      renderFile(bmp, capeRes[2], true) if capeRes != nil
 
      #front hair
      renderFile(bmp, hairRes[2], true) if hairRes != nil
 
      renderResource(bmp, "ears", data) #ears to hear
 
      #all accessory (hat's etc)
      renderResource(bmp, "acc1", data, true)
      renderResource(bmp, "acc2", data, true)
      renderResource(bmp, "acc3", data, true)
      renderResource(bmp, "acc4", data, true)
#      renderResource(bmp, "acc5", data, true)
 
      #store the char and return its internal name
      return key if ICG_Cache.setChar(key, bmp, @genKey)
      return ICG_Cache.storeChar(bmp, @genKey) 
    end
    #------------------------------------------------------------------------
    # * returns the resource entry from our Resourcelist or return !type
    #------------------------------------------------------------------------
    def getTypeFromData(data, type)
      return nil if data == nil or data.size == 0
      data.each {|item|
        if item == "?"+type
          return item
        end
        if item == "!"+type
          return item
        end
        e = @resList.findRes(item)
        next if e == nil
        if e[0] == type
          return e
        end
      }
      return nil
    end
    #------------------------------------------------------------------------
    # * returns a combined array of the both genData's, dublicates not included
    #------------------------------------------------------------------------
    def combineData(oldData, newData)
      tags = ["body", "eye", "ear", "shoes", "acc1", "acc2", "acc3", "acc4", 
        "acc5", "clothing1", "clothing2", "hair", "cape", "armor1", "armor2"]
      res = []
      tags.each {|tag|
        dold = getTypeFromData(oldData, tag)
        dnew = getTypeFromData(newData, tag)
        if (dnew == nil and dold != nil)
          if (dold.is_a?(Array))
            res.push(dold[1])
          elsif (dold[0] != "?")
            res.push(dold)
          end
        elsif (dnew != nil)
          if (dnew.is_a?(Array))
            res.push(dnew[1])
          elsif (dnew[0] != "?")
            res.push(dnew)
          end
        end
      }
      return res
    end
    #------------------------------------------------------------------------
    # * returns an random Resource entry from our Resourcelist
    #------------------------------------------------------------------------
    def getRandomRes(type)
      list = @resList.findType(type)
      return if list.size == 0
      idx = rand(list.size)
      return list[idx]
    end
    #------------------------------------------------------------------------
    # * renders a file on the given bmp
    #------------------------------------------------------------------------
    def renderFile(bmp, file, customGenKey=false)
      return if file == nil
      begin
        res = RPG::Cache.character(file, 0)
        @genKey.push(file) unless customGenKey
        bmp.blt(0, 0, res, @rect)
      rescue
        #if resource not found...
      end      
    end
    #------------------------------------------------------------------------
    # * get the resource entry for a multilayer resource
    #------------------------------------------------------------------------
    def getMultiLayerRes(data, tag, optional=true)
      d = getTypeFromData(data, tag)
 
      if d == nil
        return nil if optional
        return getRandomRes(tag)
      end
 
      if d == ("?"+tag)
        return getRandomRes(tag)
      end
 
      return d
    end
    #------------------------------------------------------------------------
    # * renders a standard (1 file) resource
    #------------------------------------------------------------------------
    def renderResource(bmp, type, data, isOptionalResource=false)
      return if type == "cape" 
      return if type == "hair"
      return if type == "acc5"
      #no need to render non-1-file resources
 
      d = getTypeFromData(data, type)
      if d == nil 
        if !isOptionalResource
          res = getRandomRes(type)
          log("resource for #{type} is NIL!") if res == nil
          renderFile(bmp, res[1])
        end
      elsif d.instance_of?(String) and (d[0] == "?" or d[0] == 63)
        res = getRandomRes(type)
        log("resource for #{type} is NIL!") if res == nil
        renderFile(bmp, res[1])
      else
        renderFile(bmp, d[1])
      end
    end
 
  end
  #============================================================================
  # -- end of ICG::Generator --
  #============================================================================
 
  #--------------------------------------------------------------------------
  # * returns an new instance of the generator
  #--------------------------------------------------------------------------
  def self.getNewGenerator(resFile)
    return Generator.new(resFile)
  end
  #--------------------------------------------------------------------------
  # * generates and set the char for a Event
  #--------------------------------------------------------------------------
  def self.generateEventChar(eventID, resFile, genData)
    key = Generator.new(resFile).generateChar(genData)
    $game_map.events[eventID].setGraphics(key)
  end
  #--------------------------------------------------------------------------
  # * generates and set the char for the Player
  #--------------------------------------------------------------------------
  def self.generatePlayerChar(resFile, genData)
    key = Generator.new(resFile).generateChar(genData)
    $game_player.setGraphics(key)
  end
  #--------------------------------------------------------------------------
  # * modify the genkey and re-generate the char. re-use the internal ID-key
  #--------------------------------------------------------------------------
  def self.modifyChar(genData, key)
    oldData = ICG_Cache.getGenKey(key)
    resFile = oldData.shift()
 
    gen = Generator.new(resFile)
    res = gen.combineData(oldData, genData)
 
    gen.generateChar(res, key)
  end
  #--------------------------------------------------------------------------
  # * changes the player state. Like normal, run, etc.
  #--------------------------------------------------------------------------
  PLAYERSTATE_KEYS = {}
  def self.changePlayerState(state, genData=nil)
    if state.include?(".txt")
      #state is a generator config
      if PLAYERSTATE_KEYS.has_key?(state)
        if genData == nil
          $game_player.setGraphics(PLAYERSTATE_KEYS[state])
        elsif
          modifyChar(genData, PLAYERSTATE_KEYS[state])
          $game_player.setGraphics(PLAYERSTATE_KEYS[state])
        end
      else
        key = Generator.new(state).generateChar(genData)
        $game_player.setGraphics(key)
        PLAYERSTATE_KEYS[state]=key
      end
    else
      #state is a standard charset
      $game_player.setGraphics(state)
    end
  end
 
end
#==============================================================================
# ** Game_Character
#==============================================================================
class Game_Character
  #--------------------------------------------------------------------------
  # * generate NEW charset
  #--------------------------------------------------------------------------
  def generateCharset(resFile, genData)
    key = ICG::Generator.new(resFile).generateChar(genData)
    setGraphics(key)
  end
  #--------------------------------------------------------------------------
  # * modify the current charset
  #--------------------------------------------------------------------------
  def modifyCharset(genData)
    oldData = ICG_Cache.getGenKey(@character_name)
    resFile = oldData.shift()
 
    gen = ICG::Generator.new(resFile)
    res = gen.combineData(oldData, genData)
 
    gen.generateChar(res, @character_name)
    setGraphics(@character_name)
  end
end