Jump to content
New account registrations are disabed. This website is now an archive. Read more here.
  • 0
Broken Messiah

Help shrink project file size

Asked by Broken Messiah

Question

Broken Messiah    20

Broken Messiah
Posted

The Code Geass RPG Game Demo is ready, but the exported size is 100 mb. I know that over half of that is stuff I'm not even using in the Demo, so is there a time effienct way to delete those files?

Share this post

Link to post
Share on other sites

7 answers to this question

Recommended Posts

  • 0

FranklinX    37

FranklinX
Posted

There is not a way to delete the files. In my Dark Chaos project there are maps made that the player cannot access without hacking. You know when you are making your demo, but do not include everything such as characters, maps, events, etc. The things you are leaving out are still under construction in the project file, and will be added when you make the demo.

Share this post

Link to post
Share on other sites
  • 0

Enigma    10

Enigma
Posted (edited)

But wait!~!!! :king:

The fact of the matter is that extra resources tend to take up most of the the space

What I'm saying is that you can use a one of the following to remove unused music or picture files in your demo

 

If thats the case which is 95 % chance it is Then your fine :alright:

since Map data and other .rxdata files rarely reach 1mb

 

lol I just now saw that this was an VX and not XP thread

 

however, the .rvdata files are basically around the same size as the .rxdata files

 

so the same advice can be applied

unfortunately, I can find the program that does that easily

 

However, there is a chance that the method below will work

like 30%

 

Resource Sorter (XP)?

I have no idea if it is compatible with vx on its own

if its not try using this

 

Compatibility Module, Snagged from GubiD's Gtbs 1.54 (Could work) :o

 

#===============================================================================
# Determines if the using RPG Maker VX or XP
#===============================================================================
module GTBS
 VX = defined?(Window_BattleMessage) == nil ? false : true
end

#===============================================================================
#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# This module is so that I can use VX commands to carry out XP functions
#   This will make it so that the VX version will work in XP and such.  
#   Keep in mind that this compatibility module was written specifically for 
#   GTBS and **MAY** work with other scripts but is not guaranteed. 
#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#===============================================================================
# This Script is made specfically for usage with GTBS version 1.5.1.4 by GubiD.
#===============================================================================

if !GTBS::VX
 #===============================================================================
 # * Sound Module * 
 #  This is a module used by RPG Maker VX - it has been modified to process XP
 #  sound commands.  
 #===============================================================================
 module Sound
   # Cursor
   def self.play_cursor
     $game_system.se_play($data_system.cursor_se)
   end
   # Decision
   def self.play_decision
     $game_system.se_play($data_system.decision_se)
   end
   # Cancel
   def self.play_cancel
     $game_system.se_play($data_system.cancel_se)
   end
   # Buzzer
   def self.play_buzzer
     $game_system.se_play($data_system.buzzer_se)
   end
   # Equip
   def self.play_equip
     $game_system.se_play($data_system.equip_se)
   end
   # Save
   def self.play_save
     $game_system.se_play($data_system.save_se)
   end
   # Load
   def self.play_load
     $game_system.se_play($data_system.load_se)
   end
   # Battle Start
   def self.play_battle_start
     $game_system.se_play($data_system.battle_start_se)
   end
   # Escape
   def self.play_escape
     $game_system.se_play($data_system.escape_se)
   end
   # Enemy Attack - Not used by XP - replace to play decision
   def self.play_enemy_attack
     $game_system.se_play($data_system.decision_se)
   end
   # Enemy Damage - Not used by XP - replace to play decision
   def self.play_enemy_damage
     $game_system.se_play($data_system.decision_se)
   end
   # Enemy Collapse
   def self.play_enemy_collapse
     $game_system.se_play($data_system.enemy_collapse_se)
   end
   # Actor Damage - Not used by XP - replace to play decision
   def self.play_actor_damage
     $game_system.se_play($data_system.decision_se)
   end
   # Actor Collapse
   def self.play_actor_collapse
     $game_system.se_play($data_system.enemy_collapse_se)
   end
   # Recovery - Not used by XP - replace to play decision
   def self.play_recovery
     $game_system.se_play($data_system.decision_se)
   end
   # Miss - Not used by XP - replace to play decision
   def self.play_miss
     $game_system.se_play($data_system.decision_se)
   end
   # Evasion - Not used by XP - replace to play decision
   def self.play_evasion
     $game_system.se_play($data_system.decision_se)
   end
   # Shop
   def self.play_shop
     $game_system.se_play($data_system.shop_se)
   end
   # Use Item - Not used by XP - replace to play decision
   def self.play_use_item
     $game_system.se_play($data_system.decision_se)
   end
   # Use Skill - Not used by XP - replace to play decision
   def self.play_use_skill
     $game_system.se_play($data_system.decision_se)
   end
 end
 #===============================================================================
 # * Vocab Module
 #===============================================================================
 DataSystem = load_data("Data/System.rxdata")
 module Vocab
   def self.gold
     return DataSystem.words.gold
   end
   def self.hp
     return DataSystem.words.hp
   end
   def self.mp
     return DataSystem.words.sp
   end
   def self.attack
     return DataSystem.words.attack
   end
   def self.skill
     return DataSystem.words.skill
   end
   def self.guard
     return "Defend"
   end
   def self.item
     return DataSystem.words.item
   end
   def self.equip
     return DataSystem.words.equip
   end
   def self.status
     return "Status"
   end
 end
 #===============================================================================
 # * Game Party
 #===============================================================================
 class Game_Party
   #--------------------------------------------------------------------------
   # Members
   #--------------------------------------------------------------------------
   def members
     return @actors
   end
   #--------------------------------------------------------------------------
   # Remove States Battle
   #--------------------------------------------------------------------------
   def remove_states_battle
     for actor in members
       actor.remove_states_battle
     end
   end
   #--------------------------------------------------------------------------
   # Gain Item
   #--------------------------------------------------------------------------
   alias gain_item_vx_compatibility gain_item
   def gain_item(*args)
     item = *args[0]
     case item
     when RPG::Item
       return gain_item_vx_compatibility(item.id, *args[1])
     when RPG::Weapon
       return gain_weapon(item.id, *args[1])
     when RPG::Armor
       return gain_armor(item.id, *args[1])
     end
     return gain_item_vx_compatibility(*args)
   end
   #--------------------------------------------------------------------------
   # Item Can Use - Determines if an item can be used
   #--------------------------------------------------------------------------
   alias can_use_vx_compat item_can_use?
   def item_can_use?(item)
     if item.is_a?(Numeric)
       return can_use_vx_compat(item)
     else
       return can_use_vx_compat(item.id)
     end
   end
 end

 #==============================================================================
 # ** Cache
 #------------------------------------------------------------------------------
 #  This module loads each of graphics, creates a Bitmap object, and retains it.
 # To speed up load times and conserve memory, this module holds the created
 # Bitmap object in the internal hash, allowing the program to return
 # preexisting objects when the same bitmap is requested again.
 #==============================================================================

 module Cache
   #--------------------------------------------------------------------------
   # * Get Animation Graphic
   #     filename : Filename
   #     hue      : Hue change value
   #--------------------------------------------------------------------------
   def self.animation(filename, hue)
     load_bitmap("Graphics/Animations/", filename, hue)
   end
   #--------------------------------------------------------------------------
   # * Get Battler Graphic
   #     filename : Filename
   #     hue      : Hue change value
   #--------------------------------------------------------------------------
   def self.battler(filename, hue)
     load_bitmap("Graphics/Battlers/", filename, hue)
   end
   #--------------------------------------------------------------------------
   # * Get Character Graphic
   #     filename : Filename
   #--------------------------------------------------------------------------
   def self.character(filename, hue=0)
     load_bitmap("Graphics/Characters/", filename, hue)
   end
   #--------------------------------------------------------------------------
   # * Get Parallax Background Graphic
   #     filename : Filename
   #--------------------------------------------------------------------------
   def self.parallax(filename)
     load_bitmap("Graphics/Parallaxes/", filename)
   end
   #--------------------------------------------------------------------------
   # * Get Picture Graphic
   #     filename : Filename
   #--------------------------------------------------------------------------
   def self.picture(filename)
     load_bitmap("Graphics/Pictures/", filename)
   end
   #--------------------------------------------------------------------------
   # * Get Icon Graphic
   #     filename : Filename
   #--------------------------------------------------------------------------
   def self.icon(filename)
     load_bitmap("Graphics/Icons/", filename)
   end
   #--------------------------------------------------------------------------
   # * Get System Graphic
   #     filename : Filename
   #--------------------------------------------------------------------------
   def self.system(filename)
     load_bitmap("Graphics/System/", filename)
   end
   #--------------------------------------------------------------------------
   # * Clear Cache
   #--------------------------------------------------------------------------
   def self.clear
     @cache = {} if @cache == nil
     @cache.clear
     GC.start
   end
   #--------------------------------------------------------------------------
   # * Load Bitmap
   #--------------------------------------------------------------------------
   def self.load_bitmap(folder_name, filename, hue = 0)
     @cache = {} if @cache == nil
     path = folder_name + filename
     if not @cache.include?(path) or @cache[path].disposed?
       if filename.empty?
         @cache[path] = Bitmap.new(32, 32)
       else
         @cache[path] = Bitmap.new(path)
       end
     end
     if hue == 0
       return @cache[path]
     else
       key = [path, hue]
       if not @cache.include?(key) or @cache[key].disposed?
         @cache[key] = @cache[path].clone
         @cache[key].hue_change(hue)
       end
       return @cache[key]
     end
   end
 end

 class Game_Unit
 end

 class Game_Troop
   #--------------------------------------------------------------------------
   # Members
   #--------------------------------------------------------------------------
   def members
     return @enemies
   end
   #--------------------------------------------------------------------------
   # Interpreter
   #--------------------------------------------------------------------------
   def interpreter
     return $game_system.battle_interpreter if $scene.is_a?(Scene_Battle)
     if @interp.nil?
       @interp = Interpreter.new(0, true)
     end
     return @interp
   end
   #--------------------------------------------------------------------------
   # Screen
   #--------------------------------------------------------------------------
   def screen
     return $game_screen
   end
   #--------------------------------------------------------------------------
   # Setup
   #--------------------------------------------------------------------------
   alias vx_compat_gt_setup setup
   def setup(troop_id)
     @troop_id = troop_id
     vx_compat_gt_setup(troop_id)
   end
   #--------------------------------------------------------------------------
   # Update Process
   #--------------------------------------------------------------------------
   def update
     self.interpreter.update
     screen.update
   end
   def setup_battle_event
     # If battle event is running
     if interpreter.running?
       return
     end
     return if @troop_id == nil or @troop_id == 0
     # Search for all battle event pages
     for index in 0...$data_troops[@troop_id].pages.size
       # Get event pages
       page = $data_troops[@troop_id].pages[index]
       # Make event conditions possible for reference with c
       c = page.condition
       # Go to next page if no conditions are appointed
       unless c.turn_valid or c.enemy_valid or
             c.actor_valid or c.switch_valid
         next
       end
       # Go to next page if action has been completed
       if $game_temp.battle_event_flags[index]
         next
       end
       # Confirm turn conditions
       if c.turn_valid
         n = $game_temp.battle_turn
         a = c.turn_a
         b = c.turn_b
         if (b == 0 and n != a) or
           (b > 0 and (n < 1 or n < a or n % b != a % b))
           next
         end
       end
       # Confirm enemy conditions
       if c.enemy_valid
         enemy = $game_troop.enemies[c.enemy_index]
         if enemy == nil or enemy.hp * 100.0 / enemy.maxhp > c.enemy_hp
           next
         end
       end
       # Confirm actor conditions
       if c.actor_valid
         actor = $game_actors[c.actor_id]
         if actor == nil or actor.hp * 100.0 / actor.maxhp > c.actor_hp
           next
         end
       end
       # Confirm switch conditions
       if c.switch_valid
         if $game_switches[c.switch_id] == false
           next
         end
       end
       # Set up event
       interpreter.setup(page.list, 0)
       # If this page span is [battle] or [turn]
       if page.span <= 1
         # Set action completed flag
         $game_temp.battle_event_flags[index] = true
       end
       return
     end
   end
   def can_lose?
     return (not $game_temp.battle_can_lose)
   end
   def troop_id
     return $game_temp.battle_troop_id
   end
   def make_drop_items
     treasures = []
     for i in $game_system.tactics_dead + $scene.dead_enemies
       if i.is_a?(Game_Actor)
         next
       else
         treasures += make_treasure(i)
       end
     end
     return treasures[0..5]
   end
 end
 #--------------------------------------------------------------------------
 # Game Map
 #--------------------------------------------------------------------------
 class Game_Map
   #--------------------------------------------------------------------------
   # * Set Display Position
   #     x : New display X coordinate (*256)
   #     y : New display Y coordinate (*256)
   #--------------------------------------------------------------------------
   def set_display_pos(x, y)
     @display_x = (x + @map.width * 128) % (@map.width * 128)
     @display_y = (y + @map.height * 128) % (@map.height * 128)
     #@panorama.ox = x/2
     #@panorama.oy = y/2
   end
   #--------------------------------------------------------------------------
   # Loop Horizontal?
   #--------------------------------------------------------------------------
   def loop_horizontal?
     return false
   end
   #--------------------------------------------------------------------------
   # Loop Vertical?
   #--------------------------------------------------------------------------
   def loop_vertical?
     return false
   end
   #--------------------------------------------------------------------------
   # * Calculate X coordinate after loop adjustment
   #     x : x-coordinate
   #--------------------------------------------------------------------------
   def round_x(x)
     if loop_horizontal?
       return (x + width) % width
     else
       return x
     end
   end
   #--------------------------------------------------------------------------
   # * Calculate Y coordinate after loop adjustment
   #     y : y-coordinate
   #--------------------------------------------------------------------------
   def round_y(y)
     if loop_vertical?
       return (y + height) % height
     else
       return y
     end
   end
   #--------------------------------------------------------------------------
   # Interpreter
   #--------------------------------------------------------------------------
   def interpreter
     return $game_system.map_interpreter
   end
 end
 #--------------------------------------------------------------------------
 # Game Screen - Added additional variables
 #--------------------------------------------------------------------------
 class Game_Screen
   #-------------------------------------------------------------------------- 
   # Brightness - from VX.  XP has and will never use it.
   #--------------------------------------------------------------------------
   def brightness
     return 255
   end
 end
 #--------------------------------------------------------------------------
 # Create Alias to Interpreter
 #--------------------------------------------------------------------------
 class Game_Interpreter < Interpreter
 end
 #--------------------------------------------------------------------------
 # Game Temp
 #--------------------------------------------------------------------------
 class Game_Temp
   attr_accessor  :next_scene

   #--------------------------------------------------------------------------
   # Object Initialization
   #--------------------------------------------------------------------------
   alias vx_compat_gt_init initialize
   def initialize
     @next_scene = nil
     vx_compat_gt_init
   end
   #--------------------------------------------------------------------------
   # Set next scene updates
   #--------------------------------------------------------------------------
   def menu_calling=(bool)
     @menu_calling = bool
     @next_scene = "menu"
   end
   def battle_calling=(bool)
     @battle_calling = bool
     @next_scene = "battle"
   end
   def debug_calling=(bool)
     @debug_calling = bool
     @next_scene = "debug"
   end
   def save_calling=(bool)
     @save_calling = bool
     @next_scene = "save"
   end
   def shop_calling=(bool)
     @shop_calling = bool
     @next_scene = "shop"
   end
   def gameover=(bool)
     @gameover = bool
     @next_scene = "gameover"
   end
   def to_title=(bool)
     @to_title = bool
     @next_scene = "title"
   end
   #--------------------------------------------------------------------------
   # End Set next sceen updates
   #--------------------------------------------------------------------------
 end
 #--------------------------------------------------------------------------
 # Game Character
 #--------------------------------------------------------------------------
 class Game_Character
   def set_direction(dir)
     @direction = dir
   end
 end
 #--------------------------------------------------------------------------
 # Game Battler
 #--------------------------------------------------------------------------
 class Game_Battler
   def mp
     return self.sp
   end
   def mp=(sp)
     return self.sp=sp
   end
   def maxmp
     return self.maxsp
   end
   def character_index
     return 0
   end
   def perform_collapse
     @collapsed = true
   end
   #--------------------------------------------------------------------------
   # Get user animation - this normally doesnt exist in VX, but was made for my
   # battle system when I was converting it to VX.  And rather than re-outdate my 
   # code, I will just make a translation piece.
   #--------------------------------------------------------------------------
   def animation1
     if self.current_action.kind == 1 #skill
       return $data_skills[self.current_action.skill_id].animation1_id
     elsif self.current_action.kind == 2 #item
       return $data_items[self.current_action.item_id].animation1_id
     end
     return self.animation1_id
   end
   #--------------------------------------------------------------------------
   # Get attack animation
   #--------------------------------------------------------------------------
   def atk_animation_id
     return self.animation2_id
   end
   #--------------------------------------------------------------------------
   # * Get Experience (for the double experience point option)
   #     exp  : Amount to increase experience.
   #     show : Level up display flag
   #--------------------------------------------------------------------------
   def gain_exp(exp, show)
     if double_exp_gain
       change_exp(@exp + (exp * 2), show)
     else
       change_exp(@exp + exp, show)
     end
   end
   #--------------------------------------------------------------------------
   # Double Exp Gain - Always returns false for XP
   #--------------------------------------------------------------------------
   def double_exp_gain
     return false
   end
   #--------------------------------------------------------------------------
   # Change exp 
   #--------------------------------------------------------------------------
   def change_exp(amount, show)
     @exp = [[amount, 9999999].min, 0].max
   end
   #--------------------------------------------------------------------------
   # Half MP Cost
   #--------------------------------------------------------------------------
   def half_mp_cost 
     return false
   end
   #--------------------------------------------------------------------------
   # * Calculation of MP Consumed for Skills
   #     skill : skill
   #--------------------------------------------------------------------------
   def calc_mp_cost(skill)
     if half_mp_cost
       return skill.mp_cost / 2
     else
       return skill.mp_cost
     end
   end
 end
 #--------------------------------------------------------------------------
 # RPG::Skill - Updates so that VX calls return XP answers
 class RPG::Skill
   #--------------------------------------------------------------------------
   # MP Cost - Returns SP_Cost (since they renamed SP to MP in VX)
   #--------------------------------------------------------------------------
   def mp_cost
     return sp_cost
   end
   #--------------------------------------------------------------------------
   # Animation ID - Returns Animation2_ID (Because VX got rid of user animations)
   #--------------------------------------------------------------------------
   def animation_id
     return @animation2_id
   end
   #--------------------------------------------------------------------------
   # Dual? - Skill status in VX, doesnt exist in XP
   #--------------------------------------------------------------------------
   def dual?
     return false
   end
 end
 #--------------------------------------------------------------------------
 # Game BattleAction - Adding new VX call command
 #--------------------------------------------------------------------------
 class Game_BattleAction
   #--------------------------------------------------------------------------
   # Set Skill
   #--------------------------------------------------------------------------
   def set_skill(skill_id)
     @skill_id = skill_id
     @kind = 1
   end
 end

 module RPG::BGM
   def self.fade(time)
     $game_system.bgm_fade(time)
   end
   def self.play
     $game_system.bgm_play($game_system.playing_bgm)
   end
 end

 module RPG
   class Item
     def animation_id
       return @animation2_id
     end
     def dual?
       return false
     end
   end
   class Skill
     def dual?
       return false
     end
   end
 end

 module Graphics
   def self.fadeout(time)
     self.transition(time)
   end
 end
else
 # Addional RMVX compatible entries
 #===============================================================================
 # * Vocab Module
 #===============================================================================
 DataSystem = load_data("Data/System.rvdata")
 module Vocab
   def self.gold
     return DataSystem.terms.gold
   end
   def self.hp
     return DataSystem.terms.hp
   end
   def self.mp
     return DataSystem.terms.mp
   end
   def self.attack
     return DataSystem.terms.attack
   end
   def self.skill
     return DataSystem.terms.skill
   end
   def self.guard
     return DataSystem.terms.guard
   end
   def self.item
     return DataSystem.terms.item
   end
   def self.equip
     return DataSystem.terms.equip
   end
   def self.status
     return DataSystem.terms.status
   end
 end
 class RPG::Item
   def atk_animation
     return @animation_id
   end
 end
 $data_skills        = load_data("Data/Skills.rvdata")
 $data_items         = load_data("Data/Items.rvdata")
 $data_weapons        = load_data("Data/Weapons.rvdata")
 module Cache
   #--------------------------------------------------------------------------
   # * Get Icon Graphic
   #     filename : Filename
   #--------------------------------------------------------------------------
   def self.icon(filename)
     load_bitmap("Graphics/Icons/", filename)
   end
 end
 RPG::Cache = Cache
 class Game_Battler
   def character_hue
     return 0
   end
   def int
     return self.spi
   end

   def sp
     return self.mp
   end
   def sp=(mp)
     return self.mp=mp
   end
   def maxsp
     return self.maxmp
   end
 end
 class Game_Battler
   def pdef
     return self.def
   end
 end
 class Game_Party
   alias gain_item_vx_compatibility gain_item
   def gain_item(*args)
     if args[0].is_a?(Numeric)
       args[0] = $data_items[*args[0]]
     end
     gain_item_vx_compatibility(*args)
   end
   def gain_weapon(id, n)
     item = $data_weapons[id]
     gain_item(item, n)
   end
   def gain_armor(id, n)
     item = $data_armors[id]
     gain_item(item, n)
   end
   alias can_use_xp_compat item_can_use?
   def item_can_use?(item)
     if item.is_a?(Numeric)
       item = $data_items[item]
       return can_use_xp_compat(item)
     else
       return can_use_xp_compat(item)
     end
   end
 end    
 class Game_Troop
   attr_accessor   :turn_count
   def can_lose?
     return (not self.can_lose)
   end
 end
 class Sprite_Base < Sprite
   def animation(anim, hit, direction = 8)
     mirror = false
     if !@battler.nil?
       mirror = @battler.animation_mirror
     end
     start_animation(anim, mirror, direction)
   end
 end
 class RPG::Skill
   def sp_cost
     return @mp_cost
   end
 end
end

 

Edited by Enigma

Share this post

Link to post
Share on other sites
  • 0

Polraudio    122

Polraudio
Posted

About 95% of the time its the music taking up all the space. If you can find a converter and convert them to file types that are lower in size like .midi.

RMXP/VX does a very good job in playing .midi files.

 

Graphics/maps/data don't take up very much at all.

Share this post

Link to post
Share on other sites

Please sign in to comment

You will be able to leave a comment after signing in



Sign In Now
Go To Question Listing

  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...