Ruby Quellcode

#==============================================================================
# ** Questlog V3
# von Caesar (07.08.2008)
#------------------------------------------------------------------------------
# http://www.rpg-studio.de/http://www.rpg-studio.de/itzamna/node/53
# http://rapidshare.com/files/133831391/Questlog-3.0.pdf
# http://forum.rpg-xp.net/thread.php?threadid=3986
#==============================================================================
 
#///////////////////////HTML-Rendering-Engine///////////////////////////////// 
#~~~~~~~~~~~~~~~~by Caesar~~~~~~~~~~~~~~~~~~~ 
#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ 
class Bitmap 
  def draw_shadow_text(x, y, width, height, str, align=0) 
color = font.color.dup 
font.color = Color.new(192, 192, 192, 156) 
draw_text(x+2, y+2, width, height, str, align) 
font.color = color 
draw_text(x, y, width, height, str, align) 
  end 
  #---------------- 
  def draw_html(x, y, width, height, str) 
# remember string and font variables 
str = str.dup 
color = font.color.dup 
bold = font.bold 
italic = font.italic 
size = font.size 
name = font.name.dup 
#:::::::::: 
shadow = false 
underlined = false 
opacity = 255 
str.gsub!(/<if=([0-9]+)>(.+?)<else>(.+?)<\/if>/) {$game_switches[$1.to_i] ? $2 : $3} 
str.gsub!(/<var=([0-9]+)>/) {$game_variables[$1.to_i].to_s} 
str.gsub!(/<eval={(.+?)}>/) {eval $1} 
str.gsub!(/<style=([A-Za-z0-9_-]+)>(.+?)<\/style>/) { 
  STYLES.has_key?($1) ? STYLES[$1].sub("|", $2) : "" 
} if defined?(STYLES) 
str.gsub!(/<br>/) {"\n"} 
str.gsub!(/\\\\/) {"\00"} 
str.gsub!(/<b>/) {"\01"} 
str.gsub!(/<\/b>/) {"\02"} 
str.gsub!(/<i>/) {"\03"} 
str.gsub!(/<\/i>/) {"\04"} 
str.gsub!(/<color=(#?[0-9a-z_]+)>/) {"\05[#{$1}]"} 
str.gsub!(/<\/color>/) {"\06"} 
str.gsub!(/<shadow>/) {"\16"} 
str.gsub!(/<\/shadow>/) {"\17"} 
str.gsub!(/<small>/) {"\20"} 
str.gsub!(/<\/small>/) {"\21"} 
str.gsub!(/<big>/) {"\23"} 
str.gsub!(/<\/big>/) {"\21"} 
str.gsub!(/<size=([0-9]+)>/) {"\24[#{$1}]"} 
str.gsub!(/<\/size>/) {"\21"} 
str.gsub!(/<font=([A-Za-z0-9\s]+)>/) {"\25[#{$1}]"} 
str.gsub!(/<\/font>/) {"\26"} 
str.gsub!(/<u>/) {"\27"} 
str.gsub!(/<\/u>/) {"\30"} 
str.gsub!(/<icon=([_A-Za-z0-9-]+)>/) {"\11[#{$1}]"} 
str.gsub!(/<image=([_A-Za-z0-9-]+)>/) {"\31[#{$1}]"} 
str.gsub!(/<down=([0-9]+)>/) {"\22[#{$1}]"} 
str.gsub!(/<space=([0-9]+)>/) {"\100[#{$1}]"} 
str.gsub!(/<line>/) {"\07"} 
ix = 0 
iy = 0 
while ((c = str.slice!(/./m)) != nil) 
  if c == "\00" # \\ 
    c = "\\" 
  end 
  if c == "\01" # <b> 
    font.bold = true
  end 
  if c == "\02" #</b> 
    font.bold = bold 
  end 
  if c == "\03" # <i> 
    font.italic = true 
  end 
  if c == "\04" # </i> 
    font.italic = false 
  end 
  if c == "\05" # <color=xxx> 
    str.sub!(/\[(#?[0-9a-z_]+)\]/, "") 
    if $1[0] == 35 
      col = Color.decode($1) 
    elsif $1.to_i != 0 
      col = Window_Base.text_color($1.to_i) 
    else 
      col = Color.get($1) 
    end 
    font.color = col 
  end 
  if c == "\06" # </color> 
    font.color = color 
  end 
  if c == "\16" # <shadow> 
    shadow = true 
  end 
  if c == "\17" # </shadow> 
    shadow = false 
  end 
  if c == "\20" # <small> 
    font.size -= 5 if font.size > 10 
  end 
  if c == "\21" # </small> </big> </size> 
    font.size = size 
  end 
  if c == "\23" # <big> 
    font.size += 5 if font.size < 92 
  end 
  if c == "\24" # <size=xx> 
    str.sub!(/\[([0-9]+)\]/, "") 
    newsize = $1.to_i 
    font.size = newsize if newsize > 5 and newsize < 97 
  end 
  if c == "\25" # <font=xxx> 
    str.sub!(/\[([A-Za-z0-9\s]+)\]/, "") 
    font.name = $1 if Font.exist?($1) 
  end 
  if c == "\26" # </font> 
    font.name = name 
  end 
  if c == "\27" # <u> 
    underlined = true 
  end 
  if c == "\30" # </u> 
    underlined = false 
  end 
  if c == "\11" #<icon=xxx> 
    str.sub!(/\[([_A-Za-z0-9-]+)\]/, "") 
    icon = RPG::Cache.icon($1) 
    blt(ix + 8, iy + LINE_HEIGHT/2 - 12, icon, Rect.new(0, 0, 24, 24)) 
    ix += 24 
  end 
  if c == "\31" # <image=xxx> 
    str.sub!(/\[([_A-Za-z0-9-]+)\]/, "") 
    image = RPG::Cache.picture($1) 
    iy += LINE_HEIGHT 
    blt((width-image.rect.width)/2, iy, image, image.rect)
    iy += image.rect.height 
    ix = 0 
  end 
  if c == "\22" # <down=xxx> 
    str.sub!(/\[([0-9]+)\]/, "") 
    iy += $1.to_i 
    ix = 0 
  end 
  if c == "\100" # <space=xxx> 
    str.sub!(/\[([0-9]+)\]/, "") 
    ix += $1.to_i 
    c = "" 
  end 
  if c == "\07" # <line> 
    iy += LINE_HEIGHT + 3 
    fill_rect(16, iy, width-32, 2, font.color) 
    fill_rect(16, iy, width-32, 2, Color.new(192, 192, 192, 156)) if shadow 
    iy += 5 
    ix = 0 
  end 
  if c == "\n" 
    iy += LINE_HEIGHT 
    ix = 0 
  end 
  #::::::::: 
  if shadow 
    draw_shadow_text(x+ix+4, y+iy, 40, font.size, c) 
  else 
    draw_text(x+ix+4, y+iy, 40, font.size, c) 
  end 
  w = text_size(c).width 
  if underlined 
    fill_rect(x+ix+4, y+iy+text_size("T").height+3, w, 2, font.color) 
  end 
  ix += w 
end 
#:::::::::: 
#reset font variables 
font.color = color 
font.bold = bold 
font.italic = italic 
font.size = size 
font.name = name 
#return height of the bitmap 
return iy + LINE_HEIGHT 
  end 
end 
#============== 
class Color 
  def Color.get(s) 
eval "Color.#{s}" rescue Color.white 
  end 
  #------------ 
  def Color.decode(hex) 
return Color.decode(hex[1..hex.length]) if hex[0] == 35 
hex.downcase! 
red = hex[0..1].hex 
green = hex[2..3].hex 
blue = hex[4..5].hex 
alpha = hex.length == 8 ? hex[6..7].hex : 255 
return Color.new(red, green, blue, alpha) 
  end 
  #------------ 
  def Color.normal_color 
return Color.new(255, 255, 255, 255) 
  end 
  #----------- 
  def Color.disabled_color
return Color.new(255, 255, 255, 128) 
  end 
  #----------- 
  def Color.system_color 
return Color.new(192, 224, 255, 255) 
  end 
  #----------- 
  def Color.crisis_color 
return Color.new(255, 255, 64, 255) 
  end 
  #----------- 
  def Color.knockout_color 
return Color.new(255, 64, 0) 
  end 
  #------------ 
  def Color.white(alpha=255) 
return Color.new(255, 255, 255, alpha) 
  end 
  #----------- 
  def Color.black(alpha=255) 
return Color.new(0, 0, 0, alpha) 
  end 
  #---------- 
  def Color.red(alpha=255) 
return Color.new(255, 0, 0, alpha) 
  end 
  #---------- 
  def Color.green(alpha=255) 
return Color.new(0, 255, 0, alpha) 
  end 
  #--------- 
  def Color.blue(alpha=255) 
return Color.new(0, 0, 255, alpha) 
  end 
  #---------- 
  def Color.yellow(alpha=255) 
return Color.new(255, 255, 0, alpha) 
  end 
  #---------- 
  def Color.cyan(alpha=255) 
return Color.new(0, 255, 255, alpha) 
  end 
  #---------- 
  def Color.magenta(alpha=255) 
return Color.new(255, 255, 0, alpha) 
  end 
  #---------- 
  def Color.light_gray(alpha=255) 
return Color.new(192, 192, 192, alpha) 
  end 
  #----------- 
  def Color.gray(alpha=255) 
return Color.new(128, 128, 128, alpha) 
  end 
  #----------- 
  def Color.dark_gray(alpha=255) 
return Color.new(64, 64, 64, alpha) 
  end 
  #----------- 
  def Color.pink(alpha=255) 
return Color.new(255, 175, 175, alpha) 
  end 
  #----------- 
  def Color.orange(alpha=255) 
return Color.new(255, 200, 0, alpha) 
  end 
end 
#=====================
class Window_Base < Window 
  # redefine text colors for static context 
  def self.text_color(n) 
case n 
when 0 
  return Color.new(255, 255, 255, 255) 
when 1 
  return Color.new(128, 128, 255, 255) 
when 2 
  return Color.new(255, 128, 128, 255) 
when 3 
  return Color.new(128, 255, 128, 255) 
when 4 
  return Color.new(128, 255, 255, 255) 
when 5 
  return Color.new(255, 128, 255, 255) 
when 6 
  return Color.new(255, 255, 128, 255) 
when 7 
  return Color.new(192, 192, 192, 255) 
else 
  return Color.white 
end 
  end 
end 
 
 
#//////////////////////////////////Questlog 3.0///////////////////////////////// 
#~~~~~~~~~~~~~~~~~~by Caesar~~~~~~~~~~~~~~~~~ 
#\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ 
#===================Parameter================== 
# Wenn true, werden neue Quests oben eingefügt, ansonsten unten 
INSERT_AT_TOP = true 
# Zeilenhöhe in der Questbeschreibung 
LINE_HEIGHT = 24 
# Windowskin der Questlog-Fenster (nil = default) 
WINDOWSKIN = nil 
# "Überschrift" des Questlogs 
HEADER_TEXT = "Questlog" 
# Geschwindigkeit beim Scrollen (Pixel / Frame) 
SCROLL_SPEED = 7 
# Styles für die Beschreibungen der Quests 
STYLES = { 
  "h1" => "<size=45><font=Cambria><b>|</b></font></size><down=40>", 
  "h2" => "<big><b><font=Cambria>|</font></b></big><down=32>", 
  "disabled" => "<color=disabled_color>|</color>", 
  "highlight" => "<color=#eeee32>|</color>", 
  "system" => "<color=system_color>|</color>" 
} 
# Dieser Process wird ausgeführt, sobald das Questlog geschlossen wird; 
# (Default: Spieler kommt wieder auf die Map) 
ON_CLOSE = Proc.new {$scene = Scene_Map.new} 
#============================================ 
class Scene_Questlog 
  def main 
@window_header = Window_Help.new
@window_header.x = 65 
@window_header.y = 28 
@window_header.z = 500 
@window_header.width = 510 
@window_header.windowskin = RPG::Cache.windowskin(WINDOWSKIN) unless 
    WINDOWSKIN.nil? 
@window_header.contents = Bitmap.new(478, 32) 
@window_header.contents.font.size = 30 
@window_header.contents.draw_text(0, 0, 510, 32, HEADER_TEXT, 1) 
@window_titles = Window_Questlog_Titles.new 
@window_titles.windowskin = RPG::Cache.windowskin(WINDOWSKIN) unless 
    WINDOWSKIN.nil? 
@window_description = Window_Questlog_Description.new( 
    $game_system.questlog.quests.map{|q| q.description}) 
@window_description.windowskin = RPG::Cache.windowskin(WINDOWSKIN) unless 
  WINDOWSKIN.nil? 
@index = @window_titles.index 
spriteset = Spriteset_Map.new 
Graphics.transition 
loop do 
  Graphics.update 
  Input.update 
  update 
  if $scene != self 
    break 
  end 
end 
Graphics.freeze 
@window_header.dispose 
@window_titles.dispose 
@window_description.dispose 
spriteset.dispose 
  end 
  #---------------- 
  def update 
@window_titles.update 
if Input.trigger?(Input::B) 
  $game_system.se_play($data_system.cancel_se) 
  ON_CLOSE.call 
  return 
end 
if Input.press?(Input::R) 
  @window_description.scroll_down 
elsif Input.press?(Input::L) 
  @window_description.scroll_up 
end 
if @index != @window_titles.index 
  @window_description.index = @index = @window_titles.index 
end 
  end 
end 
#============= 
class Quest 
  attr_reader :title 
  attr_reader :description 
  def initialize(title, description) 
@title = title 
@description = description 
  end 
end 
#============ 
class Questlog 
  attr_reader  :quests 
  def initialize 
@quests = [] 
  end 
  #----------- 
  def add(quest, description="")
return add(Quest.new(quest, description)) unless quest.is_a?(Quest) 
i = index(quest.title) 
return @quests[i] = quest if i != nil 
if INSERT_AT_TOP 
  # insert quest at top of the list 
  @quests.unshift(quest) 
else 
   # insert quest at bottom of the list 
  @quests.push(quest) 
end 
  end 
  #----------- 
  def remove(title) 
@quests.delete_if{ |quest| quest.title == title} 
  end 
  #----------- 
  def count 
return @quests.length 
  end 
  #------------ 
  def index(title) 
for i in 0..@quests.length-1 
  return i if @quests[i].title == title 
end 
return nil 
  end 
  #------------ 
  def Questlog.add(title, description="") 
$game_system.questlog.add(title, description) 
  end 
  #------------ 
  def Questlog.remove(title) 
$game_system.questlog.remove(title) 
  end 
end 
#============= 
class Window_Questlog_Description < Window_Base 
  attr_reader :index 
  #------------------ 
  def initialize(descriptions) 
super(275, 92, 300, 360) 
@descriptions = descriptions 
@cache = Array.new(descriptions.size) 
self.contents = Bitmap.new(width-32, height-32) 
self.index = 0 
self.z = 500 
  end 
  #----------- 
  def index=(index) 
return if index == @index or @descriptions.empty? 
@index = index 
self.oy = 0 
# bitmaps are only rendered once and than cached to reach more efficiency 
if @cache[index].nil? 
  buffer = Bitmap.new(width-32, 2000) 
  docheight = buffer.draw_html(0, 0, 270, 2000, @descriptions[index]) 
  @cache[index] = self.contents = Bitmap.new(width-32, docheight) 
  self.contents.blt(0, 0, buffer, Rect.new(0, 0, self.width-32, docheight)) 
else 
  self.contents = @cache[index] 
end 
  end 
  #----------- 
  def scroll_down 
self.oy += SCROLL_SPEED if self.height + self.oy - 32 < self.contents.height 
  end 
  #------------ 
  def scroll_up
self.oy -= SCROLL_SPEED 
self.oy = 0 if self.oy < 0 
  end 
end 
#============= 
class Window_Questlog_Titles < Window_Base 
  attr_reader :index 
  def initialize 
super(65, 92, 210, 360) 
self.z = 500 
@item_max = $game_system.questlog.count 
self.contents = Bitmap.new(width-32, @item_max > 0 ? @item_max*32 : 32) 
@index = 0 
refresh 
  end 
  #------------- 
  def index=(index) 
@index = index 
update_cursor_rect 
  end 
  #------------- 
  def top_row=(row) 
if row < 0 
  row = 0 
end 
if row > @item_max - 1 
  row = @item_max - 1 
end 
self.oy = row * 32 
  end 
  #------------- 
  def page_row_max 
return (self.height - 32) / 32 
  end 
  #------------- 
  def page_item_max 
return page_row_max * @column_max 
  end 
  #------------- 
  def update_cursor_rect 
if @index < 0 
  self.cursor_rect.empty 
  return 
end 
row = @index 
top_row = self.oy / 32 
if row < top_row 
  self.top_row = row 
end 
if row > top_row + (self.page_row_max - 1) 
  self.top_row = row - (self.page_row_max - 1) 
end 
self.cursor_rect.set(0, @index * 32 - self.oy, self.width - 32, 32) 
  end 
  #------------- 
  def refresh 
self.contents.clear 
for i in 0...$game_system.questlog.count 
  quest = $game_system.questlog.quests[i] 
  y = i*32 
  self.contents.draw_html(4, y, 150, 32, quest.title) 
end 
  end 
  #------------ 
  def update 
super 
if self.active and @item_max > 0 and @index >= 0 
  if Input.repeat?(Input::DOWN) and 
    (Input.trigger?(Input::DOWN) or @index < @item_max - 1) 
      $game_system.se_play($data_system.cursor_se) 
      @index = (@index + 1) % @item_max 
  end 
  if Input.repeat?(Input::UP) and 
    (Input.trigger?(Input::UP) or @index > 0) 
      $game_system.se_play($data_system.cursor_se) 
      @index = (@index - 1 + @item_max) % @item_max 
  end 
end 
update_cursor_rect 
  end 
end 
#=========== 
class Scene_Map 
  def call_questlog 
$game_temp.questlog_calling = false 
$game_player.straighten 
$scene = Scene_Questlog.new 
  end 
end 
#=========== 
class Game_System 
  attr_accessor :questlog 
  alias questlog_init initialize 
  def initialize 
questlog_init 
@questlog = Questlog.new 
  end 
end 
#=========== 
class Game_Temp 
  attr_accessor :questlog_calling 
  alias questlog_init initialize 
  def initialize 
questlog_init 
@questlog_calling = false 
  end 
end 
#======================== 
class Scene_Load < Scene_File 
  # if a game that does not yet contain the questlog is loaded 
  # a new (empty) questlog instance is created 
  alias questlog_read_save_data read_save_data 
  def read_save_data(file) 
questlog_read_save_data(file) 
$game_system.questlog = Questlog.new if $game_system.questlog.nil? 
  end 
end

Ruby Quellcode

def no_f1(bool)
  Win32API.new(*%w(NoF12 NoF1 L V)).call(bool ? 1 : 0)
end
 
def no_f12(bool)
  Win32API.new('NoF12', 'NoF12', 'L', nil).call(bool ? 1 : 0)
end
 
def no_alt_enter(bool)
  Win32API.new('NoF12', 'NoAltEnter', 'L', nil).call(bool ? 1 : 0)
end

Ruby Quellcode

#===============================================================================
#  Neues Speicher- und Laden-System 1.4
#  Autor/Credits: Cow
#  (+ Screenshotscript von Andreas21) 
#  11.03.2009
#===============================================================================
module Saves
  DelMessage = "Datei wirklich löschen?"
  Playtime = "Spielzeit"
  Time = "Datum, Zeit:"
  SaveMessage = "Namen eingeben!" 
  LoadMessage = "Spielstand auswählen!"
  ReplMessage = "Datei überschreiten?"  
  DecsMessage = "Enter: Ja  Esc: Nein" 
  LimtMessage = "Löschen und Fortfahren!"
  NoFile = "Keine Speicherstände vorhanden!"
  AllowScreen = true # false/true: Screenshot-Funktion aktivieren/deaktivieren 
  ScreenOpc = 200 # 0-255: Transparenz des Screenshots
  FrameSkin = '001-Blue01' # Windowskin, dessen Rahmen den Screenshot umrahmt
  KLimit = 30   # Anzahl maximaler Buchstaben für eine Datei
  HideEnd = true   # Wenn dieser Wert auf true gesetzt wird, wird die 
                # Dateiendung .rxdata nicht mehr angezeigt.
  WalkSpeed = 10# Geschwindigkeit der Charaktere im SaveFile-Window:
                # WalkSpeed ist die Anzahl an Frames, die zwischen den 
                # Schritten gewartet werden soll.
  ArrowSpeed = 25   # Geschwindigkeit des Cursor-Blinkens
  Limit = 10    # Limit für Speicherdateien, Zahl durch nil ersetzen, wenn 
                # es kein Limit geben soll.
#===============================================================================
  CopyFile = Win32API.new('kernel32', 'CopyFile' , 'ppi', 'i')
  def self.copy(from, to)
CopyFile.call(from, to, 0)
  end
end
class Window_Command
  def enable_item(index)
draw_item(index, normal_color)
  end
end
class Scene_Title
  def main
if $BTEST
  battle_test
  return
end
$data_actors    = load_data("Data/Actors.rxdata")
$data_classes   = load_data("Data/Classes.rxdata")
$data_skills    = load_data("Data/Skills.rxdata")
$data_items     = load_data("Data/Items.rxdata")
$data_weapons   = load_data("Data/Weapons.rxdata")
$data_armors    = load_data("Data/Armors.rxdata")
$data_enemies   = load_data("Data/Enemies.rxdata")
$data_troops    = load_data("Data/Troops.rxdata")
$data_states    = load_data("Data/States.rxdata")
$data_animations= load_data("Data/Animations.rxdata")
$data_tilesets  = load_data("Data/Tilesets.rxdata")
$data_common_events = load_data("Data/CommonEvents.rxdata")
$data_system    = load_data("Data/System.rxdata")
$game_system = Game_System.new
@sprite = Sprite.new
@sprite.bitmap = RPG::Cache.title($data_system.title_name)
s1 = ""
s2 = ""
s3 = ""
@command_window = Window_Command.new(192, [s1, s2, s3])
@command_window.back_opacity = 160
@command_window.x = 999 - @command_window.width / 2
@command_window.y = 999
@continue_enabled = true
$game_system.bgm_play($data_system.title_bgm)
Audio.me_stop
Audio.bgs_stop
Graphics.transition
loop do
  Graphics.update
  Input.update
  update
  break if $scene != self
end
Graphics.freeze
@command_window.dispose
@sprite.bitmap.dispose
@sprite.dispose
  end
end
class Window_Input < Window_Base
Set ={" " =>    0x20,   
  "a" =>    0x41,
  "b" =>    0x42,
  "c" =>    0x43,
  "d" =>    0x44,
  "e" =>    0x45,
  "f" =>    0x46,
  "g" =>    0x47,
  "h" =>    0x48,
  "i" =>    0x49,
  "j" =>    0x4A,
  "k" =>    0x4B,
  "l" =>    0x4C,
  "m" =>    0x4D,
  "n" =>    0x4E,
  "o" =>    0x4F,
  "p" =>    0x50,
  "q" =>    0x51,
  "r" =>    0x52,
  "s" =>    0x53,
  "t" =>    0x54,
  "u" =>    0x55,
  "v" =>    0x56,
  "w" =>    0x57,
  "x" =>    0x58,
  "y" =>    0x59,
  "z" =>    0x5A,
  "0" =>    0x60,
  "1" =>    0x61,
  "2" =>    0x62,
  "3" =>    0x63,
  "4" =>    0x64,
  "5" =>    0x65,
  "6" =>    0x66,
  "7" =>    0x67,
  "8" =>    0x68,
  "9" =>    0x69,
  "," =>    0x6E,
  "." =>    0xBE,
  "ü" =>    0xBA,
  "," =>    0xBC,
  "-" =>    0xBD,
  "ö" =>    0xC0,
  "ß" =>    0xDB,
  "ä" =>    0xDE}
  attr_accessor :string
  def initialize(x, y, width = 96, height = 64)
super(x, y, width, height)
@width = width
@count = 0
self.contents = Bitmap.new(width - 32, height - 32)
self.opacity = 255
@string = ""
  end
  def refresh
@count += 1
self.contents.clear
if self.active && (@count / Saves::ArrowSpeed) % 2 == 0
  cursor_x = 304 + self.contents.text_size(@string).width / 2
  self.contents.fill_rect(cursor_x, 3, 2, 26, Color.new(255,255,255))
end
self.contents.draw_text(-16, 0, @width, 32, @string, 1)
  end
  def update
super
if self.active
  if Key.press?(0x10)
    Set.each_pair do |letter, key|
      if Key.trigger?(key)
        if @string.size >= Saves::KLimit
          $game_system.se_play($data_system.cancel_se)
          return
        end
        @string += letter.upcase
      end
    end
  elsif Key.trigger?(0x08) 
    @string = @string[0,@string.size-1]
  else
    Set.each_pair do |letter, key|
      if Key.trigger?(key)
        if @string.size >= Saves::KLimit
          $game_system.se_play($data_system.cancel_se)
          return
        end
        @string += letter
      end
    end
  end
  @string = @string == nil ? "" : @string
  refresh
end
  end
end
module Key
  GetKeyState = Win32API.new("user32","GetAsyncKeyState",['i'],'i')
  GetKeyboardState = Win32API.new("user32","GetKeyState",['i'],'i')
  GetSetKeyState = Win32API.new("user32","SetKeyboardState",['i'],'i')
  module_function
  def press?(key)
if GetKeyState.call(key) != 0
  return true
end
return false
  end
  def trigger?(key)
if GetKeyState.call(key)&0x01==1
  return true
end
return false
  end
  def times?(key,times=0)
if GetKeyboardState.call(key)&0x01==times 
  return true
end
return false
  end
end
class Window_Directory < Window_Command
  attr_accessor :change
  attr_reader   :commands
  def initialize(x, y, width, height, path)
@path = path
files = Dir.glob(path + '*')
commands = Array.new
files.each do |file|
  if file.include?('.rxdata') 
    commands.push(file) 
  end
end
if commands.empty?
  commands.push('')
end
super(width, commands)
self.x = x
self.y = y
self.height = height
  end
  def refill(path)
files = Dir.glob(path + '*')
commands = Array.new
files.each do |file|
  if file.include?('.rxdata') 
    commands.push(file) 
  end
end
if commands.empty?
  commands.push('')
end
@item_max = commands.size
self.contents = Bitmap.new(self.width - 32, (@commands.size + 1) * 32)
@commands = commands
refresh
  end
  def draw_item(index, color)
self.contents.font.color = color
rect = Rect.new(32, 32 * index, self.contents.width - 8, 32)
if @commands[index].include?('.rxdata')
  @bitmap = RPG::Cache.icon('save.png')
else 
  @bitmap = Bitmap.new(24, 24)
end
self.contents.blt(4 + x, 4 + 32 * index, @bitmap, Rect.new(0, 0, 24, 24))
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
@commands[index].sub!(@path, '')
type = Saves::HideEnd
real = @commands[index]
name = type ? real.sub('.rxdata', '') : real
self.contents.draw_text(rect, name)
  end
  def update
super
@change = false
if self.active and @item_max > 0 and @index >= 0
  if Key.trigger?(0x28)
    if (@column_max == 1 and Input.trigger?(Input::DOWN)) or
       @index < @item_max - @column_max
      $game_system.se_play($data_system.cursor_se)
      @index = (@index + @column_max) % @item_max
    end
    @change = true
  end
  if Key.trigger?(0x26)
    if (@column_max == 1 and Input.trigger?(Input::UP)) or
       @index >= @column_max
      $game_system.se_play($data_system.cursor_se)
      @index = (@index - @column_max + @item_max) % @item_max
    end
    @change = true
  end
end
if self.active and @help_window != nil
  update_help
end
update_cursor_rect
  end
  def command
return @commands[self.index]
  end
end
class Window_SaveFile < Window_Base
  attr_reader   :filename            
  def initialize(y = 128, height = 352)
super(320, y, 320, height)
self.contents = Bitmap.new(width - 32, height - 32)
@step_count = 0
@last_step = 0
  end
  def fill(filename)
@step_count = 0
@last_step = 0
@time_stamp = Time.at(0)
return if filename.empty?
file = File.open('Saves/' + filename, "r")
@time_stamp = file.mtime
@characters = Marshal.load(file)
@frame_count = Marshal.load(file)
@game_system = Marshal.load(file)
@game_switches = Marshal.load(file)
@game_variables = Marshal.load(file)
@total_sec = @frame_count / Graphics.frame_rate
file.close
self.contents.clear
self.contents.font.color = normal_color
for i in 0...@characters.size
  bitmap = RPG::Cache.character(@characters[i][0], @characters[i][1])
  cw = bitmap.rect.width / 4
  ch = bitmap.rect.height / 4
  src_rect = Rect.new(0, 0, cw, ch)
  x = 32 + i * 64 - cw / 2
  self.contents.blt(x, 220 + 68 - ch, bitmap, src_rect)
end
hour = @total_sec / 60 / 60
min = @total_sec / 60 % 60
sec = @total_sec % 60
time_string = sprintf("d:d:d", hour, min, sec)
self.contents.draw_text(0, 96, 288, 32, Saves::Playtime)
self.contents.draw_text(0, 96, 288, 32, time_string, 2)
time_string = @time_stamp.strftime("%d.%m.%Y, %H:%M")
self.contents.draw_text(0, 64, 288, 32, Saves::Time)
self.contents.draw_text(0, 64, 288, 32, time_string, 2)
self.contents.font.color = Color.new(255, 255, 155)
type = Saves::HideEnd
real = filename
name = type ? real.sub('.rxdata', '') : real
self.contents.draw_text(0, 0, 288, 32, name, 1)
  end
  def update
super
speed = Saves::WalkSpeed
@step_count += 1
@step_count %= 4 * speed
step = @step_count / speed
if step != @last_step
  return if @characters == nil
  self.contents.fill_rect(0, 200, 320, 200, Color.new(0, 0, 0, 0))
  for i in 0...@characters.size
    bitmap = RPG::Cache.character(@characters[i][0], @characters[i][1])
    cw = bitmap.rect.width / 4
    ch = bitmap.rect.height / 4
    src_rect = Rect.new(step * cw, 0, cw, ch)
    x = 32 + i * 64 - cw / 2
    self.contents.blt(x, 220 + 68 - ch, bitmap, src_rect)
  end
  @last_step = step
end
  end
end
class Scene_Save
  def main
unless Dir.glob('*').include?('Saves')
  Dir.mkdir('Saves')
end
@main_window = Window_Base.new(0, 0, 640, 64)
@main_window.contents = Bitmap.new(408, 32)
@main_window.contents.draw_text(0, 0, 608, 32, Saves::SaveMessage, 1)
@input_window = Window_Input.new(0, 64, 640)
@input_window.active = true
@browser = Window_Directory.new(0, 128, 320, 352, 'Saves/')
@browser.active = true
@info = Window_SaveFile.new
@info.fill(@browser.command)
Graphics.transition
loop do
  Graphics.update
  update
  break if $scene != self
end
Graphics.freeze
@main_window.dispose
@input_window.dispose
@browser.dispose
@info.dispose
  end 
  def update
input
@browser.update
@info.update
@info.fill(@browser.command) if @browser.change
delete if Key.trigger?(0x2E)
if Key.trigger?(0x1B)
  $game_system.se_play($data_system.cancel_se)
  if $game_temp.save_calling
    $game_temp.save_calling = false
    $scene = Scene_Map.new
    return
  end
  $scene = Scene_Menu.new(4)
end
  end
  def input
@input_window.update
if Key.trigger?(0x0D) && ! @input_window.string.empty?
  @filename = 'Saves/' + @input_window.string + '.rxdata'
  @replace = true
  replace if FileTest.exist?(@filename)
  if Saves::Limit != nil
    if @browser.commands.size >= Saves::Limit
      limit
      $game_system.se_play($data_system.buzzer_se)
      return
    end
  end
  if @replace
    file = File.open(@filename, 'wb')
    save!(file)
    file.close
    @input_window.string = ''
    @browser.refill('Saves/')
    $game_system.se_play($data_system.save_se)
    Graphics.transition
    if $game_temp.save_calling
      $game_temp.save_calling = false
      $scene = Scene_Map.new
      return
    end
    $scene = Scene_Menu.new(4)
  end
end
  end
  def save!(file)
Saves.copy('Saves/~', 'Saves/~' + @input_window.string)
File.delete('Saves/~')
characters = []
for i in 0...$game_party.actors.size
  actor = $game_party.actors[i]
  characters.push([actor.character_name, actor.character_hue])
end
Marshal.dump(characters, file)
Marshal.dump(Graphics.frame_count, file)
$game_system.save_count += 1
$game_system.magic_number = $data_system.magic_number
Marshal.dump($game_system, file)
Marshal.dump($game_switches, file)
Marshal.dump($game_variables, file)
Marshal.dump($game_self_switches, file)
Marshal.dump($game_screen, file)
Marshal.dump($game_actors, file)
Marshal.dump($game_party, file)
Marshal.dump($game_troop, file)
Marshal.dump($game_map, file)
Marshal.dump($game_player, file)
  end
  def replace
window = Window_Base.new(220, 176, 200, 96)
window.contents = Bitmap.new(168, 64)
window.z = 500
@main_window.opacity = 155
@input_window.opacity = 155
@browser.opacity = 155
@info.opacity = 155
rect = [Rect.new(0, 0, 168, 32), Rect.new(0, 32, 168, 32)]
window.contents.draw_text(rect[0], Saves::ReplMessage, 1)
window.contents.draw_text(rect[1], Saves::DecsMessage, 1)
loop do
  Graphics.update
  if Key.trigger?(0x1B)
    $game_system.se_play($data_system.cancel_se)
    @replace = false
  elsif Key.trigger?(0x0D)
    @replace = true
  else
    next
  end
  window.dispose
  @main_window.opacity = 255
  @input_window.opacity = 255
  @browser.opacity = 255
  @info.opacity = 255
  break
end
  end
  def delete
unless FileTest.exist?('Saves/' + @browser.command)
  $game_system.se_play($data_system.cancel_se)
  return
end
window = Window_Base.new(220, 176, 200, 96)
window.contents = Bitmap.new(168, 64)
window.z = 500
@main_window.opacity = 155
@input_window.opacity = 155
@browser.opacity = 155
@info.opacity = 155
rect = [Rect.new(0, 0, 168, 32), Rect.new(0, 32, 168, 32)]
window.contents.draw_text(rect[0], Saves::DelMessage, 1)
window.contents.draw_text(rect[1], Saves::DecsMessage, 1)
loop do
  Graphics.update
  if Key.trigger?(0x0D)
    File.delete('Saves/' + @browser.command)
    @browser.refill('Saves/')
    @info.fill(@browser.command)
  elsif Key.trigger?(0x1B)
    $game_system.se_play($data_system.cancel_se)
  else
    next
  end
  window.dispose
  @main_window.opacity = 255
  @input_window.opacity = 255
  @browser.opacity = 255
  @info.opacity = 255
  break
end
  end
  def limit
@main_window.contents.clear
@main_window.contents.font.color = Color.new(255, 150, 150)
@main_window.contents.draw_text(0, 0, 608, 32, Saves::LimtMessage, 1)
75.times { Graphics.update }
@main_window.contents.clear
@main_window.contents.font.color = normal_color
@main_window.contents.draw_text(0, 0, 608, 32, Saves::SaveMessage, 1)
  end
end
class Scene_Load
  def main
@main_window = Window_Base.new(0, 0, 640, 64)
@main_window.contents = Bitmap.new(608, 32)
@browser = Window_Directory.new(0, 64, 320, 416, 'Saves/')
@info = Window_SaveFile.new(64, 416)
@no_file = false
no_file unless Dir.glob('*').include?('Saves')
no_file if Dir.glob('Saves/*').empty?
return if @no_file
@main_window.contents.draw_text(0,0,608,32,Saves::LoadMessage,1)
@info.fill(@browser.command)
Graphics.transition
loop do
  Graphics.update
  update
  break if $scene != self 
end
Graphics.freeze
@main_window.dispose
@browser.dispose
@info.dispose
  end
  def update
@browser.update
@info.update
@info.fill(@browser.command) if @browser.change
if Key.trigger?(0x1B)
  $game_system.se_play($data_system.cancel_se)
  $scene = Scene_Map.new
  return
end
if Key.trigger?(0x0D)
  load
elsif Key.trigger?(0x25) || Key.trigger?(0x26)
  return unless Saves::AllowScreen
  unless FileTest.exist?('Saves/~' + @browser.command.sub('.rxdata', ''))
    $game_system.se_play($data_system.buzzer_se)
    return
  end
  show_screen
end
  end
  def no_file
@no_file = true
@main_window.contents.clear
@main_window.contents.draw_text(0,0,608,32,Saves::NoFile,1)
Graphics.transition
loop do
  Graphics.update
  @browser.update
  if Key.trigger?(0x0D) || Key.trigger?(0x1B)
    $game_system.se_play($data_system.cancel_se)
    $scene = Scene_Map.new
    break
  end
end
Graphics.freeze
@main_window.dispose
@browser.dispose
@info.dispose
  end
  def show_screen
$game_system.se_play($data_system.decision_se)
window = Window_Base.new(0, 0, 640, 0)
window.back_opacity = 0
window.opacity = 0
window.height = 480
window.z = 1001
window.windowskin = RPG::Cache.windowskin(Saves::FrameSkin)
sprite = Sprite.new
sprite.z = 1000
sprite.opacity = 0
sprite.bitmap = RPG::Cache.saves(@browser.command)
until sprite.opacity >= Saves::ScreenOpc
  Graphics.update
  sprite.opacity += 30
  window.opacity += 30
end
until Key.trigger?(0x0D)
  Graphics.update
end
$game_system.se_play($data_system.cancel_se)
until sprite.opacity <= 0
  Graphics.update
  sprite.opacity -= 30
  window.opacity -= 30
end
sprite.dispose
window.dispose
  end
  def load
$game_system.se_play($data_system.load_se)
file = File.open('Saves/' + @browser.command, "rb")
characters = Marshal.load(file)
Graphics.frame_count = Marshal.load(file)
$game_system    = Marshal.load(file)
$game_switches  = Marshal.load(file)
$game_variables = Marshal.load(file)
$game_self_switches = Marshal.load(file)
$game_screen    = Marshal.load(file)
$game_actors    = Marshal.load(file)
$game_party     = Marshal.load(file)
$game_troop     = Marshal.load(file)
$game_map       = Marshal.load(file)
$game_player    = Marshal.load(file)
if $game_system.magic_number != $data_system.magic_number
  $game_map.setup($game_map.map_id)
  $game_player.center($game_player.x, $game_player.y)
end
$game_party.refresh
file.close
$game_system.bgm_play($game_system.playing_bgm)
$game_system.bgs_play($game_system.playing_bgs)
$game_map.update
$scene = Scene_Map.new
  end
end
module Screen
  @screen = Win32API.new('screenshot', 'Screenshot', 'llllpll', '')
  @readini = Win32API.new('kernel32', 'GetPrivateProfileStringA', 'pppplp', 'l') 
  @findwindow = Win32API.new('user32', 'FindWindowA', 'pp', 'l')  
  module_function
  def shot(x, y, width, height, file, typ)
@screen.call(x, y, width, height, file, handel, typ)
  end
  def handel
game_name = "\0" * 256
@readini.call('Game', 'Title', '', game_name, 255, ".\\Game.ini")
game_name.delete!("\0")
return @findwindow.call('RGSS Player', game_name)
  end
end
module RPG
  module Cache
def self.saves(filename)
  self.load_bitmap("Saves/~", filename.sub('.rxdata', ''))
end
  end
end
class Scene_Map
  def main
@spriteset = Spriteset_Map.new
@message_window = Window_Message.new
Graphics.transition
loop do
  Graphics.update
  Input.update
  update
  if $scene != self
    break
  end
end
unless Dir.glob('*').include?('Saves')
  Dir.mkdir('Saves')
end
Screen.shot(0, 0, 640, 480, 'Saves/~', 2)
Graphics.freeze
@spriteset.dispose
@message_window.dispose
if $scene.is_a?(Scene_Title)
  Graphics.transition
  Graphics.freeze
end
  end
end

Ruby Quellcode

#------------------------------------------------------------------------------
#  Ring_Menu
#------------------------------------------------------------------------------
#  By:  XRXS, Dubealex, and Hypershadow180
#------------------------------------------------------------------------------
class Scene_Menu
#------------------------------------------------------------------------------
#  Initialize
#------------------------------------------------------------------------------
  def initialize(menu_index = 0)
@menu_index = menu_index
$location_text=[]
$gold_text=[]
$window_size=[]
$ring_menu_text=[]
$chara_select=[]
@window_opacity=[]
@chara_select=[]
@window_position=[]
$location_text[0]="Tahoma" # Font Type
$location_text[1]=24 # Font Size
$location_text[2]=0 # Location Title Color
$location_text[4]=0 # Map Name Color
$location_text[3]="Karte:" # Text
$gold_text[0]="Tahoma" # Font Type
$gold_text[1]=24 # Font Size
$gold_text[2]=0 # Gold Title Color
$gold_text[3]=0 # Gold Color
$gold_text[4]="Gold" # Text
@window_opacity[0]=255 # Border Opacity
@window_opacity[1]=130 # Background Opacity
$window_location_skin="001-Blue01" # Location Windowskin
$window_gold_skin="001-Blue01" # Gold Windowskin
@window_position[0]=0 # X Axis Position
@window_position[1]=0 # Location Y Axis Position
@window_position[2]=384 # Gold Y Axis Position
$window_size[0]=160 # Length
$window_size[1]=96 # Height
$ring_menu_text[0]="Tahoma" # Font Type
$ring_menu_text[7]=0 # Font Color
$ring_menu_text[8]=24 # Font Size
$ring_menu_text[1]="Item"
$ring_menu_text[2]="Magie"
$ring_menu_text[3]="Rüstung"
$ring_menu_text[4]="Status"
$ring_menu_text[5]="Speichern"
$ring_menu_text[6]="Beenden"
@chara_select[0]=408 # X Axis Position
@chara_select[1]=0 # Y Axis Position
$chara_select[0]="Tahoma" # Font Type
$chara_select[1]=0 # Font Color
$chara_select[5]=24 # Font Size
$chara_select[2]=255 # Border Opacity
$chara_select[3]=130 # Background Opacity
$chara_select[4]="001-Blue01" # Windowskin
  end
#------------------------------------------------------------------------------
#  Main
#------------------------------------------------------------------------------
  def main
@window_location = Window_Location.new
@window_location.x = @window_position[0]
@window_location.y = @window_position[1]
@window_location.opacity = @window_opacity[0]
@window_location.back_opacity = @window_opacity[1]
@window_gold = Window_MenuGold.new
@window_gold.x = @window_position[0]
@window_gold.y = @window_position[2]
@window_gold.opacity = @window_opacity[0]
@window_gold.back_opacity = @window_opacity[1]
@spriteset = Spriteset_Map.new
px = $game_player.screen_x - 15
py = $game_player.screen_y - 24
@command_window = Window_RingMenu.new(px,py)
@command_window.index = @menu_index
if $game_party.actors.size == 0
  @command_window.disable_item(0)
  @command_window.disable_item(1)
  @command_window.disable_item(2)
  @command_window.disable_item(3)
end
@command_window.z = 100
if $game_system.save_disabled
  @command_window.disable_item(4)
end
@status_window = Window_RingMenuStatus.new
@status_window.x = @chara_select[0]
@status_window.y = @chara_select[1]
@status_window.z = 200
@status_window.opacity=$chara_select[2]
@status_window.back_opacity=$chara_select[3]
@status_window.visible = false
Graphics.transition
loop do
  Graphics.update
  Input.update
  update
  if $scene != self
    break
  end
end
Graphics.freeze
@spriteset.dispose
@window_location.dispose
@window_gold.dispose
@command_window.dispose
@status_window.dispose
  end
#------------------------------------------------------------------------------
#  Update
#------------------------------------------------------------------------------
  def update
@window_location.update
@window_gold.update
@command_window.update
@status_window.update
if @command_window.active
  update_command
  return
end
if @status_window.active
  update_status
  return
end
  end
#------------------------------------------------------------------------------
#  Update Comman
#------------------------------------------------------------------------------
  def update_command
if Input.trigger?(Input::B)
  $game_system.se_play($data_system.cancel_se)
  $scene = Scene_Map.new
  return
end
if Input.trigger?(Input::C)
  if $game_party.actors.size == 0 and @command_window.index < 4
    $game_system.se_play($data_system.buzzer_se)
    return
  end
case @command_window.index
when 0
  $game_system.se_play($data_system.decision_se)
  $scene = Scene_Item.new
when 1
  $game_system.se_play($data_system.decision_se)
  @command_window.active = false
  @status_window.active = true
  @status_window.visible = true
  @status_window.index = 0
when 2
  $game_system.se_play($data_system.decision_se)
  @command_window.active = false
  @status_window.active = true
  @status_window.visible = true
  @status_window.index = 0
when 3
  $game_system.se_play($data_system.decision_se)
  @command_window.active = false
  @status_window.active = true
  @status_window.visible = true
  @status_window.index = 0
when 4
  if $game_system.save_disabled
    $game_system.se_play($data_system.buzzer_se)
    return
  end
  $game_system.se_play($data_system.decision_se)
  $scene = Scene_Save.new
when 5
  $game_system.se_play($data_system.decision_se)
  $scene = Scene_End.new
end
return
  end
  return if @command_window.animation?
if Input.press?(Input::UP) or  Input.press?(Input::LEFT)
  $game_system.se_play($data_system.cursor_se)
  @command_window.setup_move_move(Window_RingMenu::MODE_MOVEL)
  return
end
if Input.press?(Input::DOWN) or  Input.press?(Input::RIGHT)
  $game_system.se_play($data_system.cursor_se)
  @command_window.setup_move_move(Window_RingMenu::MODE_MOVER)
  return
end
  end
#------------------------------------------------------------------------------
#  Update Status
#------------------------------------------------------------------------------
  def update_status
if Input.trigger?(Input::B)
  $game_system.se_play($data_system.cancel_se)
  @command_window.active = true
  @status_window.active = false
  @status_window.visible = false
  @status_window.index = -1
  return
end
if Input.trigger?(Input::C)
case @command_window.index
when 1
  if $game_party.actors[@status_window.index].restriction >= 2
    $game_system.se_play($data_system.buzzer_se)
    return
  end
  $game_system.se_play($data_system.decision_se)
  $scene = Scene_Skill.new(@status_window.index)
when 2
  $game_system.se_play($data_system.decision_se)
  $scene = Scene_Equip.new(@status_window.index)
when 3
  $game_system.se_play($data_system.decision_se)
  $scene = Scene_Status.new(@status_window.index)
  end
  return
end
  end
end
#------------------------------------------------------------------------------
#  Window_RingMenu
#------------------------------------------------------------------------------
class Window_RingMenu < Window_Base
  STARTUP_FRAMES = 20
  MOVING_FRAMES = 5
  RING_R = 72    
  ICON_ITEM   = RPG::Cache.icon("034-Item03")
  ICON_SKILL  = RPG::Cache.icon("044-Skill01") 
  ICON_EQUIP  = RPG::Cache.icon("001-Weapon01") 
  ICON_STATUS = RPG::Cache.icon("050-Skill07") 
  ICON_SAVE   = RPG::Cache.icon("038-Item07") 
  ICON_EXIT   = RPG::Cache.icon("046-Skill03") 
  ICON_DISABLE= RPG::Cache.icon("") 
  SE_STARTUP = "056-Right02" 
  MODE_START = 1 
  MODE_WAIT  = 2 
  MODE_MOVER = 3 
  MODE_MOVEL = 4 
  attr_accessor :index
#------------------------------------------------------------------------------
#  Initialize
#------------------------------------------------------------------------------
  def initialize( center_x, center_y )
super(0, 0, 640, 480)
self.contents = Bitmap.new(width-32, height-32)
self.contents.font.name = $ring_menu_text[0]
self.contents.font.color = text_color($ring_menu_text[7]) 
self.contents.font.size = $ring_menu_text[8]
self.opacity = 0
self.back_opacity = 0
s1 = $ring_menu_text[1]
s2 = $ring_menu_text[2]
s3 = $ring_menu_text[3]
s4 = $ring_menu_text[4]
s5 = $ring_menu_text[5]
s6 = $ring_menu_text[6]
@commands = [ s1, s2, s3, s4, s5, s6 ]
@item_max = 6
@index = 0
@items = [ ICON_ITEM, ICON_SKILL, ICON_EQUIP, ICON_STATUS, ICON_SAVE, ICON_EXIT ]
@disabled = [ false, false, false, false, false, false ]
@cx = center_x - 16
@cy = center_y - 16
setup_move_start
refresh
  end
#------------------------------------------------------------------------------
#  Update
#------------------------------------------------------------------------------
  def update
super
refresh
  end
#------------------------------------------------------------------------------
#  Refresh
#------------------------------------------------------------------------------
  def refresh
self.contents.clear
case @mode
when MODE_START
  refresh_start
when MODE_WAIT
  refresh_wait
when MODE_MOVER
  refresh_move(1)
when MODE_MOVEL
  refresh_move(0)
end
rect = Rect.new(@cx - 272, @cy + 24, self.contents.width-32, 32)
self.contents.draw_text(rect, @commands[@index],1)
  end
#------------------------------------------------------------------------------
#  Refresh Start
#------------------------------------------------------------------------------
  def refresh_start
d1 = 2.0 * Math::PI / @item_max
d2 = 1.0 * Math::PI / STARTUP_FRAMES
r = RING_R - 1.0 * RING_R * @steps / STARTUP_FRAMES
for i in 0...@item_max
  j = i - @index
  d = d1 * j + d2 * @steps
  x = @cx + ( r * Math.sin( d ) ).to_i
  y = @cy - ( r * Math.cos( d ) ).to_i
  draw_item(x, y, i)
end
@steps -= 1
if @steps < 1
  @mode = MODE_WAIT
end
  end
#------------------------------------------------------------------------------
#  Refresh Wait
#------------------------------------------------------------------------------
  def refresh_wait
d = 2.0 * Math::PI / @item_max
for i in 0...@item_max
  j = i - @index
  x = @cx + ( RING_R * Math.sin( d * j ) ).to_i
  y = @cy - ( RING_R * Math.cos( d * j ) ).to_i
  draw_item(x, y, i)
end
  end
#------------------------------------------------------------------------------
#  Refresh Move
#------------------------------------------------------------------------------
  def refresh_move( mode )
d1 = 2.0 * Math::PI / @item_max
d2 = d1 / MOVING_FRAMES
d2 *= -1 if mode != 0
for i in 0...@item_max
  j = i - @index
  d = d1 * j + d2 * @steps
  x = @cx + ( RING_R * Math.sin( d ) ).to_i
  y = @cy - ( RING_R * Math.cos( d ) ).to_i
  draw_item(x, y, i)
end
@steps -= 1
if @steps < 1
  @mode = MODE_WAIT
end
  end
#------------------------------------------------------------------------------
#  Draw Item
#------------------------------------------------------------------------------
  def draw_item(x, y, i)
rect = Rect.new(0, 0, @items[i].width, @items[i].height)
if @index == i
  self.contents.blt( x, y, @items[i], rect )
  if @disabled[@index]
    self.contents.blt( x, y, ICON_DISABLE, rect )
  end
else
  self.contents.blt( x, y, @items[i], rect, 128 )
  if @disabled[@index]
    self.contents.blt( x, y, ICON_DISABLE, rect, 128 )
  end
end
  end
#------------------------------------------------------------------------------
#  Disable Item
#------------------------------------------------------------------------------
  def disable_item(index)
@disabled[index] = true
  end
#------------------------------------------------------------------------------
#  Setup Move Start
#------------------------------------------------------------------------------
  def setup_move_start
@mode = MODE_START
@steps = STARTUP_FRAMES
if  SE_STARTUP != nil and SE_STARTUP != ""
  Audio.se_play("Audio/SE/" + SE_STARTUP, 80, 100)
end
  end
#------------------------------------------------------------------------------
#  Setup Move Move
#------------------------------------------------------------------------------
  def setup_move_move(mode)
if mode == MODE_MOVER
  @index -= 1
  @index = @items.size - 1 if @index < 0
elsif mode == MODE_MOVEL
  @index += 1
  @index = 0 if @index >= @items.size
else
  return
end
@mode = mode
@steps = MOVING_FRAMES
  end
#------------------------------------------------------------------------------
#  Animation
#------------------------------------------------------------------------------
  def animation?
return @mode != MODE_WAIT
  end
end
#------------------------------------------------------------------------------
#  Window_RingMenuStatus
#------------------------------------------------------------------------------
class Window_RingMenuStatus < Window_Selectable
#------------------------------------------------------------------------------
#  Initialize
#------------------------------------------------------------------------------
  def initialize
super(204, 64, 232, 352)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.size = $chara_select[5]
refresh
self.active = false
self.index = -1
  end
#------------------------------------------------------------------------------
#  Refresh
#------------------------------------------------------------------------------
  def refresh
self.contents.clear
self.windowskin = RPG::Cache.windowskin($chara_select[4]) 
self.contents.font.name = $chara_select[0]
self.contents.font.color = text_color($chara_select[1]) 
@item_max = $game_party.actors.size
for i in 0...$game_party.actors.size
  x = 80
  y = 80 * i
  actor = $game_party.actors[i]
  draw_actor_graphic(actor, x - 60, y + 65)
  draw_actor_name(actor, x, y + 2)
  draw_actor_hp(actor, x - 40, y + 26)
  draw_actor_sp(actor, x - 40, y + 50)
end
  end
#------------------------------------------------------------------------------
#  Update Cursor Rect
#------------------------------------------------------------------------------
  def update_cursor_rect
if @index < 0
  self.cursor_rect.empty
else
  self.cursor_rect.set(0, @index * 80, self.width - 32, 80)
end
  end
end
#------------------------------------------------------------------------------
#  Game_Map
#------------------------------------------------------------------------------
class Game_Map
#------------------------------------------------------------------------------
#  Name
#------------------------------------------------------------------------------
  def name
$map_infos[@map_id]
  end
end
#------------------------------------------------------------------------------
#  Scene_Title
#------------------------------------------------------------------------------
class Scene_Title
  $map_infos = load_data("Data/MapInfos.rxdata")
  for key in $map_infos.keys
$map_infos[key] = $map_infos[key].name
  end
end
#------------------------------------------------------------------------------
#  Window_Location
#------------------------------------------------------------------------------
class Window_Location < Window_Base 
#------------------------------------------------------------------------------
#  Initialize
#------------------------------------------------------------------------------
  def initialize 
super(0, 0, $window_size[0], $window_size[1]) 
self.contents = Bitmap.new(width - 32, height - 32) 
self.contents.font.name = $location_text[0]
self.contents.font.size = $location_text[1]
refresh 
  end 
#------------------------------------------------------------------------------
#  Refresh
#------------------------------------------------------------------------------
  def refresh 
self.contents.clear 
self.windowskin = RPG::Cache.windowskin($window_location_skin) 
self.contents.font.color = text_color($location_text[2]) 
self.contents.draw_text(4, 0, 120, 32, $location_text[3]) 
self.contents.font.color = text_color($location_text[4]) 
self.contents.draw_text(4, 32, 120, 32, $game_map.name, 2) 
  end 
end 
#------------------------------------------------------------------------------
#  Window_MenuGold
#------------------------------------------------------------------------------
class Window_MenuGold < Window_Base
#------------------------------------------------------------------------------
#  Initialize
#------------------------------------------------------------------------------
  def initialize
super(0, 0, $window_size[0], $window_size[1])
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $gold_text[0]
self.contents.font.size = $gold_text[1]
refresh
  end
#------------------------------------------------------------------------------
#  Refresh
#------------------------------------------------------------------------------
  def refresh
self.contents.clear
self.windowskin = RPG::Cache.windowskin($window_gold_skin) 
self.contents.font.color = text_color($gold_text[2]) 
self.contents.draw_text(4, 0, 120, 32, $gold_text[4]) 
self.contents.font.color = text_color($gold_text[3]) 
self.contents.draw_text(4, 32, 120, 32, $game_party.gold.to_s, 2)
  end
end

Ruby Quellcode

#----- Credits an Xiderowg -----#
class Game_System  
  attr_accessor :move_speed
  alias xas_system_initialize initialize
  def initialize
  xas_system_initialize
  @move_speed = 4
  end  
end
#===============================================================================
# Game_Player
#===============================================================================
class Game_Player < Game_Character
 
  def hero_dash_graphic?(actor)
if  (Input.press?(Input::RIGHT) or Input.press?(Input::LEFT) or
     Input.press?(Input::UP) or Input.press?(Input::DOWN))
RPG::Cache.character(actor.character_name.to_s + "_dash", actor.character_hue) rescue return false
end
  end
 
  def hero_dash_quarter_graphic?(actor)
if  (Input.press?(Input::RIGHT) or Input.press?(Input::LEFT) or
     Input.press?(Input::UP) or Input.press?(Input::DOWN))  
RPG::Cache.character(actor.character_name.to_s + "_dash_quarter", actor.character_hue) rescue return false
end
  end
 
  def hero_quarter_graphic?(actor) 
RPG::Cache.character(actor.character_name.to_s + "_quarter", actor.character_hue) rescue return false
  end
 
  def update
@actor = $game_party.actors[0]
if @actor != nil
   actor = $game_party.actors[0] 
   if actor.hp <= 0 
   if XAS_BA::AUTOGAMEOVER == true
   $scene = Scene_Gameover.new rescue nil if self.collapse_done
   else
   $game_switches[XAS_BA::GAMEOVER_SWITCH_ID] = true
   $game_map.refresh
   end
   end  
end 
last_moving = moving?
unless moving? or $game_system.map_interpreter.running? or
       @move_route_forcing or $game_temp.message_window_showing #or
 #  $game_temp.dodge_time_real > 0 
  case Input.dir8
  when 1
  move_left
  move_down
  when 2
  move_down
  when 3
  move_down
  move_right
  when 4
  move_left
  when 6
  move_right
  when 7
  move_up
  move_left
  when 8
  move_up
  when 9
  move_right
  move_up
  end
 
case Input.dir8
 when 1 
 quarter = true
 when 2 
 quarter = false  
 when 3 
 quarter = true  
 when 4 
 quarter = false 
 when 6 
 quarter = false  
 when 7 
 quarter = true   
 when 8
 quarter = false  
 when 9
 quarter = true   
 end
actor = $game_party.actors[0]  
     @move_speed = $game_system.move_speed
     if (quarter != nil and quarter == true) and
         hero_quarter_graphic?(actor) #and self.action == nil 
     @character_name = actor.character_name + "_quarter"
     else
     @character_name = actor.character_name
     end
 
 
end
last_real_x = @real_x
last_real_y = @real_y
super
if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
  $game_map.scroll_down(@real_y - last_real_y)
end
if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
  $game_map.scroll_left(last_real_x - @real_x)
end
if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
  $game_map.scroll_right(@real_x - last_real_x)
end
if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
  $game_map.scroll_up(last_real_y - @real_y)
end
unless moving?
  if last_moving
    result = check_event_trigger_here([1,2])
    if result == false
      unless $DEBUG and Input.press?(Input::CTRL)
        if @encounter_count > 0
          @encounter_count -= 1
        end
      end
    end
  end
  if Input.trigger?(Input::C)
    check_event_trigger_here([0])
    check_event_trigger_there([0,1,2])
  end
end
  end
end