Jump to content
Rpg²S Forum
Attenzione: Cambio modalità di Login

Rap1em

Utenti
 View Profile  See their activity

  • Posts

    5

  • Joined

  • Last visited

 Content Type 

Posts posted by Rap1em

    *Creare personaggio nel gioco: In-Game Character Creation

    in Scripts RGSS3 (VX-Ace)

    Posted

    In Game Character Creation

    Descrizione:

    Questo script ha due funzioni: consente di creare eroi che utilizzano la grafica in composito che possono avere grafiche differenti (sia per il viso che per la camminata) a seconda delle voci selezionate, e di chiamare a schermo in-game la creazione del personaggio che permetterà al giocatore di cambiare grafica. Questo script non è "user friendly", ma è abbastanza semplice. Ha una terribile quantità di impostazioni da configurare e ottimizzare per ottenere i materiali compositi e permettere che la schermata di creazione funzioni correttamente. Se si desidera utilizzare questo script solo per i personaggi compositi, è un po 'più facile da configurare e utilizzare.

     

    Autore:

    Neon Black.

     

    Istruzioni per l'uso:

    Inserisci lo script in una nuova finestra nella sezione "Materiali".

    Script:

     

    ##----------------------------------------------------------------------------##

## Composite Character v2.1
## Created by Neon Black
##
## Only for non-commercial use. See full terms of use and contact info at:
## http://cphouseset.wordpress.com/liscense-and-terms-of-use/
##----------------------------------------------------------------------------##
##
##----------------------------------------------------------------------------##
## Revision Info:
## V2.1 - 2.12.2013
## Added new script calls
## V2.0 - 1.24.2013
## Rewrote entire script from scratch
## V1.0 - 10.17.2012
## Wrote and debugged main script
##----------------------------------------------------------------------------##
##
$imported = {} if $imported.nil? ##
$imported["COMPOSITE"] = 2.1 ##
##
##----------------------------------------------------------------------------##
## Instructions:
## Place this script in the "Materials" section of the scripts above "Main".
## To use this script you must have additional composite graphics in a folder
## for characters and a folder for faces. Charactersets will use composites
## based on their names in the NAMES setting. Some layers of the composite
## may also change based on the equipped items on the actor associated with
## file name. There are several tags that work with both actors and equips.
##
## Tags:
## tag init[Handler, hue]
## - Can only be tagged in actors. Changes composite layer :tag to handler
## "Handler" with the defined hue. Do not use colons for layer names or
## quotes for file handler names.
## gender[male]
## - Sets the character's initial gender to "male" or "female" depending on
## which you place in the brackets. This can only tag actors.
## alt name[Christopher]
## - Sets the character's name for the opposite gender. If the player changes
## the gender in the GUI and has not changed the name, the new name will be
## displayed. The name "Christopher" here can be any name you desire.
## tag image[Handler, hue]
## - Changes the default images for layer :tag to file handler "Handler".
##
## Script Calls:
## The character creation screen can be called with either of these two script
## calls from an event. Other script calls also exist.
##
## creation(id) -or- creation(id, array)
## - The value "id" can be either the actor's ID or the name of the character
## set to modify. The "array" value does not need to be used ever. This is
## the array of handlers from "GUI_LISTS" to use. If no array is defined,
## "BASE_GUI" is used instead.
## composite_custom(id, handler, name, hue)
## - Changes composite "id"'s layer "handler" into file "name" with a hue of
## "hue". This occurs on the same priority level as the character creation
## screen, so it is covered by armour and can be modified by the player.
## "id" must be a value from NAMES, "handler" a layer from COMPOSITE, "name"
## a file from FILE_HANDLERS, and "hue" a number from 0 to 255.
## composite_force(id, handler, name, hue)
## - Similar to the command above, but this takes the highest priority when
## being drawn and cannot be changed by the player.
## composite_reset(id)
## - Removes all layers added using the "composite_force" script call.
##
## Special Layers:
## In order to allow a slight bit more customization, there are 3 types of
## special layers that link directly to other layers. These layers end with
## "Back", "Hueless", and "All".
##
## Back Layers
## - These layers do not actually need to be behind the normal layer. They
## are simply a second layer with all the same properties of the parent
## layer. An example would be :hairRear which would be a rear layer of
## :hair.
## Hueless Layers
## - These layers ignore the changed hue values. The main use of these would
## be objects with skin tone or perhaps objects that you only want to change
## part of the colour on. The only object that uses this in the example
## is :eyesHueless which is a hueless layer of :eyes.
## All Layers
## - These are special layers on the character. They are a layer that appears
## on the character no matter what the player does. The file that appears
## is still linked to the file part it is attatched to for the sake of hue.
## The file that appears for one of these layers is defined in the hash
## GUI_OPTIONS.
##----------------------------------------------------------------------------##
##
module CP # Do not touch ##
module COMPOSITE # these lines. ##
##
##----------------------------------------------------------------------------##
## Config:
## The config options are below. You can set these depending on the flavour of
## your game. Each option is explained in a bit more detail above it.
##
##------

# The folders containing the composite parts for characters and for facesets.
CHAR_FOLDER = "Graphics/Composite/Charas/"
FACE_FOLDER = "Graphics/Composite/Faces/"

# Determines if the creation screen uses face sets are not. Set to false if
# you do not want a faceset displayed.
	USE_FACESETS = true
	
	# The width and height of the character window in the creation screen. The
	# character in the screen is zoomed in to 200%.
	WINDOW_WIDTH = 90
	WINDOW_HEIGHT = 112
	
	# The text options for the character selection GUI. EMPTY_TEXT refers to an
	# option which is blank for some reason.
	GUI_CLOSE = "Finish Editing"
	EMPTY_TEXT = "None"
	
	# The number of allowed character spaces for names when input from the editor.
	CHARACTERS = 6
	
	# Names for the male and female genders.
	GENDER_NAMES = ["Male", "Female"]
	
	# Determines if male undefined characters start out as male characters.
	MALE_DEFAULT = true
	
	##------
	
	# Determine the files that are recognized as composite images and the actor
	# they are linked to, for the sake of armour, storage, etc.
	NAMES ={
	"$Hero1" => 11,
	"$Hero2" => 12,
	}
	
	# The switches related to characters. A switch is turned ON when the character
	# is male and OFF when the character is female.
	SWITCHES ={
	11 => 72,
	12 => 73,
	}
	
	# The order for composite layers. The first layer is the lowest layer.
	COMPOSITE =[
	:hairRear,
	:cape,
	:armorRear,
	:headAll,
	:head,
	:eyes,
	:eyesAll,
	:eyesHueless,
	:armor,
	:hair,
	:glasses,
	:helmet,
	]
	
	# These are the handlers for all files in the composite folders. Actor and
	# equip tags as well as GUI options point to a handler and the handler
	# determines the male and female files to look up. Make sure every handler
	# has a different name.
	FILE_HANDLERS ={
	# "Handler" => ["Male_File", "Female_File"],
	"Shaggy" => ["Hair1M", nil],
	"Slick" => ["Hair2M", nil],
	"Spiked" => ["Hair3M", nil],
	"Fancy" => ["Hair4M", nil],
	"Stylish" => [nil, "Hair1F"],
	"Waist Length" => [nil, "Hair2F"],
	"Curled" => [nil, "Hair3F"],
	"Pigtails" => [nil, "Hair4F"],
	"Short" => ["Hair1U", "Hair1U"],
	"Long" => ["Hair2U", "Hair2U"],
	"Observant" => ["Eye1M", "Eye1F"],
	"Closed" => ["Eye2M", "Eye2F"],
	"Intent" => ["Eye3M", "Eye3F"],
	
	"HeadBase" => ["HeadAll", "HeadAll"],
	"FaceBase" => ["FaceM", "FaceF"],
	"BodyBase" => ["BaseM", "BaseF"],
	
	"Clothes" => ["ClothesM", "ClothesF"],
	"Cloth" => ["ClothM", "ClothF"],
	"Armor" => ["ArmourM", "ArmourF"],
	"Glasses" => ["Glasses", "Glasses"],
	"Sunglasses" => ["Sunglasses", "Sunglasses"],
	"Goggles" => ["Goggles", "Goggles"],
	}
	
	# Standard handlers. These are default handlers of certain layers.
	STANDARD ={
	:headAll => "HeadBase",
	:head => "FaceBase",
	:armor => "BodyBase",
	}
	
	# The GUI options that may be called from an array. If the "Name" field is set
	# to a :symbol like the :barber example, it will point back to another option
	# and use that option's name and layer. The point is simply to link different
	# handlers to it as well as giving it different colour options. The colorize?
	# option can be set to a value of 0, 1, or 2 depending on the style of hue bar
	# you would like displayed. If it is set to 0, no bar will be displayed.
	GUI_OPTIONS ={
	# :handler => ["Name", colorize?, "AllFile"],
	:Name => ["Name", 0, nil],
	:Gender => ["Gender", 0, nil],
	:hair => ["Hair", 1, nil],
	:eyes => ["Eyes", 1, "EyeAll"],
	
	:barber => [:hair, true, nil],
	}
	
	# These are the basic options to use in the GUI if no array is defined.
	BASE_GUI = [:Name, :Gender, :hair, :eyes]
	
	# These are the lists that refer to the options. Male and Female only options
	# are automatically filtered depending on the character's gender.
	GUI_LISTS ={
	:hair => ["Shaggy", "Slick", "Spiked", "Fancy", "Stylish", "Waist Length",
	"Curled", "Pigtails"],
	:eyes => ["Observant", "Intent", "Closed"],
	
	
	:barber => ["Shaggy", "Slick", "Spiked", "Fancy", "Stylish", "Waist Length",
	"Curled", "Pigtails", "Short", "Long"],
	}
	
	##----------------------------------------------------------------------------##
	##
	##
	##----------------------------------------------------------------------------##
	## The following lines are the actual core code of the script. While you are
	## certainly invited to look, modifying it may result in undesirable results.
	## Modify at your own risk!
	###----------------------------------------------------------------------------
	
	
end
nd
odule Cache
class << self ## Alias for the used methods in this module.
	alias cp_cm_character character
	alias cp_cm_face face
	alias cp_cm_clear clear
end

def self.character(*args) ## Checks if the file is a composite.
	return cp_cm_character(*args) unless Composites.include?(args[0])
	create_composite(args[0], "Graphics/Characters/")
	hue = args[1] ? args[1] : 0
	load_bitmap("Graphics/Characters/", args[0], hue)
end

def self.face(*args) ## Checks if the face is a composite.
	return cp_cm_face(*args) unless Composites.include?(args[0])
	create_composite(args[0], "Graphics/Faces/")
	hue = args[1] ? args[1] : 0
	load_bitmap("Graphics/Faces/", args[0], hue)
end

def self.need_comp_ref?(file, path) ## Checks refresh status.
	return true if Composites.refresh?(file)
	return true if @cache[path].nil? || @cache[path].disposed?
	return false
end

def self.create_composite(file, folder) ## Find and create the composite.
	path = "#{folder}#{file}"
	return unless need_comp_ref?(file, path)
	foldrs = ["Graphics/Characters/", "Graphics/Faces/"]
	Composites.constants.each_with_index do |fld, i|
		paths = "#{foldrs[i]}#{file}"
		array = Composites.images(file)
		Composites.layers do |i|
			image = array[i]
			unless @temp
				@temp = Bitmap.new("#{fld}#{image}") rescue next
				@temp.hue_change(Composites.hues(file)[i]) unless Composites.hues(file)[i].nil?
			else
				t = Bitmap.new("#{fld}#{image}") rescue next
				t.hue_change(Composites.hues(file)[i]) unless Composites.hues(file)[i].nil?
				@temp.blt(0, 0, t, t.rect)
				t.dispose; t = nil
			end
		end
		@temp = Bitmap.new unless @temp
		Composites.refreshed(file)
		@cache[paths] = Bitmap.new(@temp.width, @temp.height)
		@cache[paths].blt(0, 0, @temp, @temp.rect)
		@temp.dispose; @temp = nil
	end
	Composites.remove_temp_layers(file)
end

def self.clear ## Reset the composite cache.
	cp_cm_clear
	Composites.clear
end
nd
odule Composites
def self.include?(file) ## Checks if a file is a composite.
	return CP::COMPOSITE::NAMES.include?(file)
end

def self.options ## Easy access of the options hash.
	return CP::COMPOSITE::GUI_OPTIONS
end

def self.lists ## Easy access of the gui lists hash.
	return CP::COMPOSITE::GUI_LISTS
end

def self.list_by_block(handler, block) ## Returns a list based on gender.
	return [] unless [0, 1].include?(block) && lists.include?(handler)
	return lists[handler].select {|a| !files[a][block].nil?}
end

def self.layers ## Gets each layer key one at a time.
	CP::COMPOSITE::COMPOSITE.each do |key|
		yield key
	end
end

def self.constants ## Gets the folder constants.
	if CP::COMPOSITE::USE_FACESETS
		return [CP::COMPOSITE::CHAR_FOLDER, CP::COMPOSITE::FACE_FOLDER]
	else
		return [CP::COMPOSITE::CHAR_FOLDER]
	end
end

def self.files ## Gets the file handler hash.
	return CP::COMPOSITE::FILE_HANDLERS
end

def self.include_block?(block, handler) ## Checks gender blocks to handlers.
	return false unless files.include?(handler)
	return !files[handler][block].nil?
end

def self.standard ## Gets the standard GUI display.
	return CP::COMPOSITE::STANDARD
end

def self.get_first_handler(block, key) ## Gets the init files based on block.
	return nil if ![0, 1].include?(block) || !lists.include?(key)
	lists[key].each do |handler|
		next unless files.include?(handler)
		return handler unless files[handler][block].nil?
	end
	return nil
end

def self.n(file) ## Returns a number from a file.
	return CP::COMPOSITE::NAMES[file]
end

def self.refreshed(file) ## Resets a file's refresh status.
	return unless n(file)
	actor(file).composite_refresh = false
end

def self.images(file) ## Get all images of a file.
	return @temp_images[file] if @temp_images && @temp_images[file]
	return actor(file).composite_images
end

def self.hues(file) ## Get all hues of a file.
	return @temp_hues[file] if @temp_hues && @temp_hues[file]
	return actor(file).composite_hues
end

def self.remove_temp_layers(file) ## Removes temporary (save) layers.
	@temp_images.delete(file) if @temp_images
	@temp_hues.delete(file) if @temp_hues
end

def self.make_temp_file(file, handlers) ## Create a new temp of a file.
	@temp_images = {} if @temp_images.nil?; @temp_hues = {} if @temp_hues.nil?
	@temp_images[file] = {}; @temp_hues[file] = {}
	handlers.each do |key, array|
		@temp_images[file][key] = array[0]
		@temp_hues[file][key] = array[1]
	end
end

def self.refresh?(file) ## Check if a file needs refreshing.
	return false unless n(file) ## Includes temp file checking.
	return true if @temp_images && @temp_images.include?(file)
	return actor(file).composite_refresh
end

def self.actor(file) ## Gets a game actor from a file name.
	return $game_actors[n(file)]
end

def self.clear ## Allows forced reset of each file.
	CP::COMPOSITE::NAMES.keys.each do |file|
		actor(file).composite_refresh = true
	end
end
nd
lass Game_Actor < Game_Battler
attr_accessor :composite_refresh

alias cp_cmpst_init initialize
def initialize(*args) ## Sets the initial values for composites.
	cp_cmpst_init(*args)
	@composite_refresh = true
	@editor_changes = {}
	@editor_hues = {}
	@forced_composites = {}
end

def composite_images ## Returns the composite images for an actor.
	make_composite_lists if @composite_refresh
	return @composite_images
end

def composite_hues ## Returns the composite hues.
	make_composite_lists if @composite_refresh
	return @composite_hues
end

def edd_additions(hueless, rear) ## Make a new filename based on layers.
	a = ""
	b = hueless ? "#{a}Hueless" : a
	c = rear ? "#{b}Rear" : b
	return c
end

def get_composite_lists ## Gets a composite list for save files.
	return {} unless Composites.include?(character_name)
	make_composite_lists
	r = {}
	@composite_images.each {|k, v| r[k] = [v, @composite_hues[k]]}
	return r
end

def make_composite_lists ## Makes the list of composites and hues.
	@composite_images = {}
	@composite_hues = {}
	@composite_male = get_base_gender ## Sets gender.
	if CP::COMPOSITE::SWITCHES.include?(@actor_id) ## Sets a gender switch.
		$game_switches[CP::COMPOSITE::SWITCHES[@actor_id]] = @composite_male
	end
	block = @composite_male ? 0 : 1
	make_equip_hashes(block) ## Ensures equips are set up.
	Composites.layers do |key| ## Check each layer.
		@composite_hues[key] = 0 ## Gets init values for variables.
		name = nil
		string = key.to_s
		hueless = string.include?("Hueless")
		rear = string.include?("Rear")
		all = string.include?("All")
		string.gsub!(/(Hueless|All|Rear)/, '')
		edd = edd_additions(hueless, rear)
		line = CP::COMPOSITE::GUI_OPTIONS[string.to_sym]
		handler = get_composite_handler(key)
		parent = get_composite_handler(string.to_sym)
		hues = get_composite_hue(key)
		if all && !line.nil? ## Determines the needed value.
			name = line[2]
		elsif handler && Composites.files.include?(handler) &&
			Composites.files[handler][block]
			name = "#{Composites.files[handler][block]}#{edd}"
		elsif parent && Composites.files.include?(parent) &&
			Composites.files[parent][block] && (rear || hueless)
			name = "#{Composites.files[parent][block]}#{edd}"
		elsif Composites.standard.include?(key)
			name = Composites.files[Composites.standard[key]][block]
		end
		next unless name ## Skips if there is no name.
		@composite_images[key] = name ## Creates the hashes.
		@composite_hues[key] = hueless ? 0 : hues
	end
end

def get_base_gender ## Gets the gender.
	return @editor_changes[:Gender] if @editor_changes.include?(:Gender)
	return actor.gender_base
end

def get_composite_handler(key) ## Complex method to find the file handler.
	block = @composite_male ? 0 : 1
	if @forced_composites.include?(key) && Composites.include_block?(block,
		@forced_composites[key][0])
		hues = @forced_composites[key][0]
	elsif @equip_hashes.include?(key) && Composites.include_block?(block,
		@equip_hashes[key][0])
		handler = @equip_hashes[key][0]
	elsif @editor_changes.include?(key) && Composites.include_block?(block,
		@editor_changes[key])
		handler = @editor_changes[key]
	elsif actor.composite_init.include?(key) && Composites.include_block?(block,
		actor.composite_init[key][0])
		handler = actor.composite_init[key][0]
	elsif Composites.get_first_handler(block, key)
		handler = Composites.get_first_handler(block, key)
	else
		handler = nil
	end
	return handler
end

def get_composite_hue(key) ## Same as above but for hues.
	block = @composite_male ? 0 : 1
	if @forced_composites.include?(key) && Composites.include_block?(block,
		@forced_composites[key][0])
		hues = @forced_composites[key][1]
	elsif @equip_hashes.include?(key) && Composites.include_block?(block,
		@equip_hashes[key][0])
		hues = @equip_hashes[key][1]
	elsif @editor_changes.include?(key) && Composites.include_block?(block,
		@editor_changes[key])
		hues = @editor_hues[key]
	elsif actor.composite_init.include?(key) && Composites.include_block?(block,
		actor.composite_init[key][0])
		hues = actor.composite_init[key][1]
	else
		hues = 0
	end
	return hues
end

def make_equip_hashes(block) ## Makes the handler hash for equips.
	@equip_hashes = {}
	equips.each do |eq|
		next unless eq
		eq.composite_hash.each do |key, array|
			next if Composites.files[array[0]][male? ? 0 : 1].nil?
			@equip_hashes[key] = array
		end
	end
end

alias cp_composite_change_eq change_equip
def change_equip(*args) ## Ensures refreshing on equip change.
	cp_composite_change_eq(*args)
	@composite_refresh = true
end

def change_composite(hand, value = nil, hue = nil)
	array = ["#{hand}".to_sym, "#{hand}Rear".to_sym, "#{hand}Hueless".to_sym,
	"#{hand}All".to_sym]
	array.each do |handler| ## Changes values for a layer and sublayers.
		unless value.nil?
			@editor_changes[handler] = value
			@editor_hues[handler] = hue if hue
		else
			@editor_changes.delete(handler)
			@editor_hues.delete(handler)
		end
	end
	@composite_refresh = true
end

def force_composite(hand, value = nil, hue = nil)
	array = ["#{hand}".to_sym, "#{hand}Rear".to_sym, "#{hand}Hueless".to_sym,
	"#{hand}All".to_sym]
	array.each do |handler| ## Changes values for a layer and sublayers.
		unless value.nil?
			@forced_composites[handler] = []
			@forced_composites[handler][0] = value
			@forced_composites[handler][1] = hue if hue
		else
			@forced_composites.delete(handler)
		end
	end
	@composite_refresh = true
end

def reset_composite
	@forced_composites = {}
	@composite_refresh = true
end

def reset_name ## Changes the name to a default name.
	return if actor.alt_name.empty?
	@composite_male = get_base_gender
	if @composite_male == actor.gender_base
		@name = actor.name if @name == actor.alt_name
	else
		@name = actor.alt_name if @name == actor.name
	end
end

def male? ## Check if the actor is male.
	return @composite_male
end
nd
lass Window_SaveFile < Window_Base
def draw_party_characters(x, y) ## Creates a temp array for the save file.
	header = DataManager.load_header(@file_index)
	return unless header
	header[:characters].each_with_index do |data, i|
		Composites.make_temp_file(data[0], data[2])
		draw_character(data[0], data[1], x + i * 48, y)
	end
end
nd
lass Game_Party < Game_Unit
def characters_for_savefile ## Adds the composite arrays to a save file.
	battle_members.collect do |actor|
		[actor.character_name, actor.character_index, actor.get_composite_lists]
	end
end
nd
lass Scene_Load < Scene_File ## Clears the composites on a load.
alias cp_comp_load_succ on_load_success
def on_load_success
	Composites.clear
	cp_comp_load_succ
end
nd
lass Scene_Save < Scene_File ## Clears the composites on save.
alias cp_comp_save_ok on_savefile_ok
def on_savefile_ok
	Composites.clear
	cp_comp_save_ok
end
nd
lass Bitmap
def draw_rainbow(*args) ## Draws a rainbow rectangle.
	case args.size
	when 1
		rect = args[0].clone
	when 4
		rect = Rect.new(args[0], args[1], args[2], args[3])
	end
	ca = rainbow_colours
	6.times do |i|
		wv = rect.width / (6 - i)
		n = i == 5 ? 0 : 1
		r2 = Rect.new(rect.x, rect.y, wv + n, rect.height)
		self.gradient_fill_rect(r2, ca[i], ca[(i + 1) % 6])
		rect.width -= wv
		rect.x += wv
	end
end

def rainbow_colours ## Colours for the rectangle.
	c1 = Color.new(255, 0, 0); c2 = Color.new(255, 255, 0)
	c3 = Color.new( 0, 255, 0); c4 = Color.new( 0, 255, 255)
	c5 = Color.new( 0, 0, 255); c6 = Color.new(255, 0, 255)
	return [c1, c2, c3, c4, c5, c6]
end

@@wheel = Bitmap.new(360, 1)
@@wheel.draw_rainbow(0, 0, 360, 1)

def self.hue_colour_wheel(hue) ## Show the new hue colour.
	if @@wheel.disposed?
		@@wheel = Bitmap.new(360, 1)
		@@wheel.draw_rainbow(0, 0, 360, 1)
	end
	return @@wheel.get_pixel(hue % 360, 0)
end
nd
# The core bits of the script scene are below.
lass Window_CCFace < Window_Base
def initialize(actor, input)
	super(0, 0, 120, 120)
	self.visible = CP::COMPOSITE::USE_FACESETS
	@input_window = input
	self.y = @input_window.y
	self.x = @input_window.x - (self.width + 8)
	@actor = $data_actors[actor]
	refresh
end

def refresh
	contents.clear
	draw_face(@actor.face_name, @actor.face_index, 0, 0)
end
nd
lass Window_CCCharacter < Window_Base
def initialize(actor, input)
	super(0, 0, CP::COMPOSITE::WINDOW_WIDTH, CP::COMPOSITE::WINDOW_HEIGHT)
	@input_window = input
	self.y = @input_window.y
	self.x = @input_window.x + @input_window.width + 8
	@actor = $data_actors[actor]
	@ticker = 10
	@last_frame = 1
	@frame = 1
	refresh
end

def update
	@ticker += 1
	@frame = (@ticker % 40) / 10; @frame = 1 if @frame == 3
	return if @frame == @last_frame
	@last_frame = @frame
	refresh
end

def refresh
	contents.clear
	x = contents.width / 2
	y = contents.height - 6
	draw_character(@actor.character_name, @actor.character_index, x, y, @frame)
end

def draw_character(character_name, character_index, x, y, frame = 1)
	return unless character_name
	bitmap = Cache.character(character_name)
	sign = character_name[/^[\!\$]./]
	if sign && sign.include?('$')
		cw = bitmap.width / 3
		ch = bitmap.height / 4
	else
		cw = bitmap.width / 12
		ch = bitmap.height / 8
	end
	n = character_index
	src_rect = Rect.new((n%4*3+frame)*cw, (n/4*4)*ch, cw, ch)
	ret_rect = Rect.new(x - cw, y - cw * 2, cw * 2, ch * 2)
	contents.stretch_blt(ret_rect, bitmap, src_rect)
end
nd
lass Window_CCGui < Window_Selectable
def initialize(file, list)
	@list = list
	extra_width = CP::COMPOSITE::WINDOW_WIDTH + 8
	extra_width += 128 if CP::COMPOSITE::USE_FACESETS
	x = (Graphics.width - (180 + extra_width)) / 2
	x += 128 if CP::COMPOSITE::USE_FACESETS
	y = (Graphics.height - window_height) / 2
	h = window_height
	super(x, y, 180, h)
	@file = file
	refresh
end

def window_height
	[fitting_height(item_max * 2), Graphics.height].min
end

def item_max
	@list.size + 1
end

def contents_height
	(item_max * 2) * line_height
end

def item_height
	line_height * 2
end

def refresh
	contents.clear
	draw_all_items
end

def data
	@list[@index]
end

def adj_data
	if Composites.options[data][0].is_a?(Symbol)
		return Composites.options[data][0]
	else
		return data
	end
end

def draw_item(index)
	rect = item_rect(index)
	lh = line_height
	if index == @list.size
		text = CP::COMPOSITE::GUI_CLOSE
		change_color(normal_color)
		draw_text(rect.x + 2, rect.y + lh / 2, rect.width - 4, lh, text, 1)
	else
		block = Composites.options[@list[index]]
		if block[0].is_a?(Symbol)
			title = Composites.options[block[0]][0]
		else
			title = block[0]
		end
		value = (CP::COMPOSITE::COMPOSITE.include?(@list[index]) ||
		@list[index] == :Gender || @list[index] == :Name)
		sym = value ? @list[index] : block[0]
		change_color(system_color)
		draw_text(rect.x + 2, rect.y, rect.width - 4, lh, title)
		case sym
		when :Gender
			na = CP::COMPOSITE::GENDER_NAMES
			name = Composites.actor(@file).male? ? na[0] : na[1]
		when :Name
			name = Composites.actor(@file).name
		else
			name = Composites.actor(@file).get_composite_handler(sym)
			name = CP::COMPOSITE::EMPTY_TEXT if name.nil?
			hue = Composites.actor(@file).get_composite_hue(sym)
			if block[1]
				c1 = Bitmap.hue_colour_wheel(hue)
				c2 = Color.new(c1.red, c1.green, c1.blue, 0)
				r2 = contents.text_size(name).width
				hr = Rect.new(contents.width - (r2 + 6), rect.y + lh + 3, r2 + 1, lh - 6)
				contents.gradient_fill_rect(hr, c2, c1)
			end
		end
		change_color(normal_color)
		draw_text(rect.x + 2, rect.y + lh, rect.width - 6, lh, name, 2)
	end
end
nd
lass Window_CCSelect < Window_Selectable
attr_reader :hue

def initialize(file, input)
	super(0, 0, 160, 0)
	@input_window = input
	@file = file
	@data = nil
	@hue = 0
end

def item_max
	return 1 if @data.nil? || @data.empty?
	return @data.size
end

def refresh
	contents.clear
	draw_all_items
	draw_hue_wheel
end

def draw_item(index)
	rect = item_rect(index); rect.x += 2; rect.width -= 4
	change_color(normal_color)
	draw_text(rect, @data[index])
end

def draw_hue_wheel
	rect = item_rect(item_max); contents.clear_rect(rect)
	rect.y += 4; rect.height -= 8; rect.x += 8; rect.width -= 16
	ind = Composites.options[@input_window.data]
	return if !ind || ind[1] == 0
	if ind[1] == 2
		value = @hue >= 180 ? @hue - 360 : @hue
		rect.height /= 2; rect.height -= 1; rect.x -= 60
		contents.draw_rainbow(rect)
		rect.y += (rect.height + 1); rect.x -= value / 3
		contents.draw_rainbow(rect)
		rect.x += 119
		contents.draw_rainbow(rect)
		rect.y -= (rect.height + 1); rect.x += value / 3
		contents.draw_rainbow(rect)
		bitmap2 = Bitmap.new(10, 19)
		bitmap2.fill_rect(0, 0, 10, 19, Color.new(255, 255, 255))
		c1 = Bitmap.hue_colour_wheel(0)
		c2 = Bitmap.hue_colour_wheel(@hue)
		bitmap2.gradient_fill_rect(1, 1, 8, 17, c1, c2, true)
		rect = item_rect(item_max)
		contents.blt((rect.width - 10) / 2, rect.y + 2, bitmap2, bitmap2.rect)
		rect.width = 10
		contents.clear_rect(rect)
		rect.x = contents.width - rect.width
		contents.clear_rect(rect)
	elsif ind[1] == 1
		contents.draw_rainbow(rect)
		bitmap2 = Bitmap.new(7, 20)
		bitmap2.fill_rect(0, 0, 7, 20, Color.new(255, 255, 255))
		bitmap2.fill_rect(1, 2, 5, 16, Bitmap.hue_colour_wheel(@hue))
		off = @hue / 3
		contents.blt(rect.x - 3 + off, rect.y - 2, bitmap2, bitmap2.rect)
	end
end

def show
	val = @input_window.adj_data
	ind = @input_window.data
	actor = Composites.actor(@file)
	block = Composites.actor(@file).male? ? 0 : 1
	@name = Composites.list_by_block(ind, block).index(actor.get_composite_handler(val))
	@index = val != :Gender ? @name : Composites.actor(@file).male? ? 0 : 1
	@index = 0 if @index.nil?
	@hue = actor.get_composite_hue(val) unless val == :Gender
	cont = Composites.options[ind]
	if val == :Gender
		@data = CP::COMPOSITE::GENDER_NAMES
	else
		@data = Composites.list_by_block(ind, block)
	end
	add = Composites.options[ind][1] ? 1 : 0
	add = 0 if val == :Gender
	self.height = fitting_height(@data.size + add)
	create_contents
	refresh
	self.x = @input_window.x + 16
	iw = @input_window
	self.y = iw.y + iw.standard_padding + (iw.index * (iw.line_height * 2)) - iw.oy + 28
	self.y = Graphics.height - self.height if y + height > Graphics.height
	super
	activate
end

def cursor_right(wrap)
	return if Composites.options.include?(@input_window.data) &&
	!Composites.options[@input_window.data][1]
	@hue /= 12; @hue *= 12
	@hue += 12; @hue -= 360 if @hue >= 360
	draw_hue_wheel
end

def cursor_left(wrap)
	return if Composites.options.include?(@input_window.data) &&
	!Composites.options[@input_window.data][1]
	@hue /= 12; @hue *= 12
	@hue -= 12; @hue += 360 if @hue < 0
	draw_hue_wheel
end
nd
lass Game_Interpreter
def creation(char, list = nil) ## Allows for easy calling of the scene.
	return if $game_party.in_battle
	if char.is_a?(Integer)
		return unless CP::COMPOSITE::NAMES.has_value?(char)
		char = CP::COMPOSITE::NAMES.index(char)
	else
		return unless Composites.include?(char)
	end
	list = CP::COMPOSITE::BASE_GUI if list.nil?
	return unless list.is_a?(Array)
	SceneManager.call(Scene_CharacterCreation)
	SceneManager.scene.prepare(char, list)
	Fiber.yield
end

def composite_force(char, handler, name, hue = 0)
	if char.is_a?(Integer)
		return unless CP::COMPOSITE::NAMES.has_value?(char)
	else
		return unless Composites.include?(char)
		char = CP::COMPOSITE::NAMES[char]
	end
	$game_actors[char].force_composite(handler, name, hue)
end

def composite_custom(char, handler, name, hue = 0)
	if char.is_a?(Integer)
		return unless CP::COMPOSITE::NAMES.has_value?(char)
	else
		return unless Composites.include?(char)
		char = CP::COMPOSITE::NAMES[char]
	end
	$game_actors[char].change_composite(handler, name, hue)
end

def composite_reset(char)
	if char.is_a?(Integer)
		return unless CP::COMPOSITE::NAMES.has_value?(char)
	else
		return unless Composites.include?(char)
		char = CP::COMPOSITE::NAMES[char]
	end
	$game_actors[char].reset_composite
end
nd
lass Scene_CharacterCreation < Scene_MenuBase
def prepare(file, list)
	@file = file
	@list = list
end

def start
	super
	@actor = Composites.actor(@file)
	create_windows
end

def create_windows
	@input_window = Window_CCGui.new(@file, @list)
	@input_window.set_handler(:ok, method(:gui_ok))
	@input_window.set_handler(:cancel, method(:gui_cancel))
	@select_window = Window_CCSelect.new(@file, @input_window)
	@select_window.set_handler(:ok, method(:select_ok))
	@select_window.set_handler(:cancel, method(:select_cancel))
	@chara_window = Window_CCCharacter.new(@actor.id, @input_window)
	@face_window = Window_CCFace.new(@actor.id, @input_window)
	@input_window.activate.select(0)
	@select_window.hide
end

def gui_ok
	val = @input_window.data
	if val == :Name
		SceneManager.call(Scene_Name)
		SceneManager.scene.prepare(Composites.actor(@file).id, CP::COMPOSITE::CHARACTERS)
		@input_window.refresh
	elsif val == nil
		return_scene
	else
		@select_window.show
	end
end

def gui_cancel
	@input_window.activate.select(@input_window.item_max - 1)
end

def select_ok
	val = @input_window.data
	adj = @input_window.adj_data
	id = @select_window.index
	if adj == :Gender
		if id == 0
			Composites.actor(@file).change_composite(:Gender, true)
			Composites.actor(@file).reset_name
		elsif id == 1
			Composites.actor(@file).change_composite(:Gender, false)
			Composites.actor(@file).reset_name
		end
	else
		block = Composites.actor(@file).male? ? 0 : 1
		handler = Composites.list_by_block(val, block)[@select_window.index]
		hue = @select_window.hue
		Composites.actor(@file).change_composite(adj, handler, hue)
	end
	@select_window.hide
	@chara_window.refresh
	@face_window.refresh
	@input_window.activate.refresh
end

def select_cancel
	@select_window.hide
	@input_window.activate
end
nd
lass RPG::BaseItem
def composite_hash
	add_composite_data if @composite_hash.nil?
	return @composite_hash
end

def composite_init
	add_composite_data if @composite_init.nil?
	return @composite_init
end

def gender_base
	add_composite_data if @gender_base.nil?
	return @gender_base
end

def alt_name
	add_composite_data if @alt_name.nil?
	return @alt_name
end

INITI_RE = /(.+) init\[(.+)[,]\s*(\d+)\]/i
IMAGE_RE = /(.+) image\[(.+)[,]\s*(\d+)\]/i
GENDER_RE = /gender\[(male|female)\]/i
ALT_NAME = /alt name\[(.+)\]/i

def add_composite_data
	@gender_base = CP::COMPOSITE::MALE_DEFAULT
	@composite_hash = {}; @composite_init = {}; @alt_name = ""
	self.note.split(/[\r\n]+/).each do |line|
		case line
		when INITI_RE
			@composite_init[$1.to_sym] = [$2.to_s, $3.to_i]
			@composite_init["#{$1.to_s}Rear".to_sym] = [$2.to_s, $3.to_i]
			@composite_init["#{$1.to_s}Hueless".to_sym] = [$2.to_s, 0]
			@composite_init["#{$1.to_s}All".to_sym] = [$2.to_s, $3.to_i]
		when IMAGE_RE
			@composite_hash[$1.to_sym] = [$2.to_s, $3.to_i]
			@composite_hash["#{$1.to_s}Rear".to_sym] = [$2.to_s, $3.to_i]
			@composite_hash["#{$1.to_s}Hueless".to_sym] = [$2.to_s, 0]
			@composite_hash["#{$1.to_s}All".to_sym] = [$2.to_s, $3.to_i]
		when GENDER_RE
			@gender_base = true if $1.to_s.downcase == "male"
			@gender_base = false if $1.to_s.downcase == "female"
		when ALT_NAME
			@alt_name = $1.to_s
		end
	end
end
nd
##--------------------------------------------------------------------------###
 End of script. #
##--------------------------------------------------------------------------###

     

    Screenshot:

    http://i.imgur.com/8nsTH.png

     

     

    Bugs e conflitti noti:

    Questo script non funziona con gli script che modificano l'aspetto di una sprite o l'aspetto di un volto in gioco. Non ci dovrebbe essere alcun motivo per cui non dovrebbe funzionare con script che basta scegliere diverse "emozioni" da un foglio sprite (a patto di creare un composito per un foglio sprite).
    Inoltre questo script modifica il metodo "characters_for_savefile" per visualizzare correttamente compositi in savefile e come tale non funzionerà con altri script che modificano questo metodo.
    Altri dettagli:
    Se volete ulteriori permessi chiedeteli qui: http://cphouseset.wordpress.com/license-and-terms-of-use/
×
×
  • Create New...