Jump to content
Rpg²S Forum

Pech

Utenti
  • Posts

    439
  • Joined

  • Last visited

Posts posted by Pech

  1. Domanda semplice semplice... io possiedo la versione di rpg maker xp 1.01 ... su internet ho trovato altre versioni gratuite... 1.02 e 1.04 ora prima domanda se io istallo rpg maker 1.02 per esempio posso avere problemi di incompatibilità con i miei progetti avviati su 1.01 e seconda esiste davvero la versione 1.04 o è una cavolata trovata sul web...?
  2. Ho provato a metterlo in un nuovo progetto ma crasha dall'inizio... all'ora il problema è il computer o forse la versione di rpg maker uso la 1.01

    comunque non è che qualcuno potrebbe per caso modificarmi il primo script di near fantastica in modo che non influisca o su determinati eventi con un certo commento o nome oppure una determinata mappa...

    Chiunque lo facesse sarebbe un grande... anche se non mi aspetto chissà cosa

  3. Ok grazie comuque si è come ha detto giver cioè ho fatto immagini più corte comunque ecco l'immagine

     

    http://img585.imageshack.us/img585/3189/screenshotki.png

     

    Comunque mi potete dire i tasti per lo screenshot? E se per favore mi spieghi in generale come modificare la lunghezza della barra

    tanto per imparare!

    Grazie

  4. Credo che una domanda come questa non meriti l'apertura di un nuovo topic. Per questo allego anche script e immagini per la massima chiarezza. Allora non soddisfatto della barra d'esperienza ne ho tagliato un pezzo però la percentuale dell'esperienza vera e propria non è cambia di conseguenza, ovvero la barra si riempie ma ancora non sono salito di livello, non sapendo quali valori cambiare chiedo a voi. Se non sono stato chiaro allego questo screenshot (tra l'altro qual'è è il tasto screenshot che per questo ho dovuto usare print, scusate il nabbismo... e tra l'altro dopo che è stato modificato il sito non riesco più a mettere lo spoiler!)....

    Visto che non riesco a mettere l'immagine che ho salvato sul desktop posterò lo script

    #_________________________________________________
    # Nirvanos - HUD V 1.7		   
    #_________________________________________________
    # Script original -
    #		  MOG_MPWindow Status Elen V1.1 - By Moghunter   
    # Modificação e adaptação -
    #		  Nirvanos	
    #_________________________________________________
    #Mostra o HP, SP, EXP, STATUS e o Level do Heroi.
    #É preciso ter as imagens dentro da pasta
    #
    #\Graphics\pictures
    #
    #   IMG-HUD.png
    #	 BAR_Meter.png
    #	   HP_Meter.png
    #	   SP_Meter.png
    #	 Exp_Back.png
    #	   Exp_Meter.png
    #-------------------------------------------------------------------------------
    module MOG
    #Posição da janela na horizontal.
    STMAPX = -16
    #Posição da janela na vertical.
    STMAPY = - 16
    #Switch que desativa a janela de status. 
    STMAPVIS = 5
    #Windows Skin da janela.
    STMAPSKIN = "skin copy"
    #Opacidade da janela.
    STMAPOPA = 0
    end
    ###############
    # Window_Base #
    ###############
    class Window_Base < Window  
    def draw_maphp2(actor, x, y)
    meter = RPG::Cache.picture("HP_Meter")   
    cw = meter.width  * actor.hp / actor.maxhp
    ch = meter.height
    src_rect = Rect.new(0, 0, cw, ch)
    self.contents.blt(x, y, meter, src_rect)
    self.contents.font.color = Color.new(0,0,0,255)
    self.contents.draw_text(x+1+57, y - 1-14, 48, 32, actor.hp.to_s, 2)
    self.contents.font.color = Color.new(250,255,255,255)
    self.contents.draw_text(x+57, y - 2-14, 48, 32, actor.hp.to_s, 2)   
    end 
    def draw_mapsp2(actor, x, y)
    meter = RPG::Cache.picture("SP_Meter")   
    cw = meter.width  * actor.sp / actor.maxsp
    ch = meter.height
    src_rect = Rect.new(0, 0, cw, ch)
    self.contents.blt(x, y, meter, src_rect)
    self.contents.font.color = Color.new(0,0,0,255)
    self.contents.draw_text(x+1+57, y - 1-14, 48, 32, actor.sp.to_s, 2)   
    self.contents.font.color = Color.new(250,255,255,255)
    self.contents.draw_text(x+57, y - 2-14, 48, 32, actor.sp.to_s, 2)   
    end
    def draw_mexp(actor, x, y)
    actor = $game_party.actors[0]
    bitmap2 = RPG::Cache.picture("Exp_Back")
    cw = bitmap2.width
    ch = bitmap2.height
    src_rect = Rect.new(0, 0, cw, ch)
    self.contents.blt(x , y, bitmap2, src_rect)
    rate = actor.now_exp.to_f / actor.next_exp
    bitmap = RPG::Cache.picture("Exp_Meter")
    if actor.level < 99
    cw = bitmap.width * rate
    else
    cw = bitmap.width
    end  
    ch = bitmap.height
    src_rect = Rect.new(0, 0, cw, ch)
    self.contents.blt(x, y, bitmap, src_rect)
    self.contents.font.color = normal_color
    self.contents.font.size = 20
    if actor.now_exp != 0
     text = (actor.now_exp.to_f / actor.next_exp.to_f)*100.00
    
    if actor.level < 99
     text = text.round
    else
     text = 99
    end
    else
     text = 0
    end
    if actor.level < 99
    self.contents.draw_text(x + 570, y - 13, 84, 32, text.to_s+"%")
    else
    self.contents.draw_text(x + 570, y - 13, 84, 32, "99%")
    end
    end
    def draw_actor_statemap(actor, x, y, width = 120)
    text = make_battler_state_text(actor, width, true)
    self.contents.font.color = Color.new(0,0,0,255)
    self.contents.draw_text(x + 1, y + 1, width, 32, text)
    self.contents.font.color = Color.new(250,255,255,255)
    self.contents.draw_text(x, y, width, 32, text)
    end
    def draw_actor_levelmap(actor, x, y)
    self.contents.font.color = Color.new(0,0,0,255)
    self.contents.draw_text(x+1, y+1, 24, 32, actor.level.to_s, 1)
    self.contents.font.color = Color.new(255,255,255,255)   
    self.contents.draw_text(x, y, 24, 32, actor.level.to_s, 1)   
    end
    end
    ##############
    # Game_Actor #
    ##############
    class Game_Actor < Game_Battler
    def now_exp
    return @exp - @exp_list[@level]
    end
    def next_exp
    return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
    end
    end
    #####################
    # Window_Status_Map #
    #####################
    class Window_Sthero < Window_Base
    def initialize
    super(0, 0, 640+32, 480+32)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.windowskin = RPG::Cache.windowskin(MOG::STMAPSKIN)   
    self.contents.font.bold = true
    self.contents.font.size = 20
    self.contents.font.name = "Papyrus"
    self.opacity = MOG::STMAPOPA
    refresh
    end 
    def refresh
    self.contents.clear
    pictu = RPG::Cache.picture("IMG-HUD2.png")
    cw = pictu.width
    ch = pictu.height
    src_rect = Rect.new(0, 0, cw, ch)
    self.contents.blt(0, 0, pictu, src_rect)   
    actor = $game_party.actors[0]
    self.contents.font.size = 20
    draw_maphp2(actor, 172, 387)
    draw_mapsp2(actor, 172, 403)
    draw_actor_statemap(actor, 39, 350, 70)
    self.contents.font.size = 20
    draw_actor_levelmap(actor, 200, 412)  
    draw_mexp(actor, 31, 470)
    
    end
    end
    ###############
    # Game_Player #
    ###############
    class Game_Player < Game_Character
    attr_accessor :wref
    end
    #############
    # Scene_Map #
    #############
    class Scene_Map
    alias mog11_main main
    def main
    @sthero = Window_Sthero.new
    @sthero.x = MOG::STMAPX
    @sthero.y = MOG::STMAPY
    @sthero.z = 1
    if $game_switches[MOG::STMAPVIS] == false
    @sthero.visible = true 
    else
    @sthero.visible = false 
    end   
    mog11_main
    @sthero.dispose
    end
    alias mog11_update update
    def update
    if $game_switches[MOG::STMAPVIS] == false
    @sthero.visible = true 
    else
    @sthero.visible = false 
    
    end	 
    if $game_player.wref == true
    @sthero.refresh
    $game_player.wref = false
    end
    mog11_update
    @sthero.refresh
    end 
    end 
    ################
    # Game_Battler #
    ################
    class Game_Battler
    alias mog11_attack_effect attack_effect
    def attack_effect(attacker)
    mog11_attack_effect(attacker) 
    $game_player.wref = true
    end
    alias mog11_skill_effect skill_effect
    def skill_effect(user, skill)
    mog11_skill_effect(user, skill)
    $game_player.wref = true 
    end 
    alias mog11_item_effect item_effect
    def item_effect(item)
    mog11_item_effect(item)
    $game_player.wref = true 
    end
    alias mog11_add_state add_state
    def add_state(state_id, force = false)
    mog11_add_state(state_id, force = false)
    $game_player.wref = true 
    end
    end
    

  5. Scusate ma nel web ho trovato questo antilag (da quello che ho capito il migliore da cui tutti prendono spunto è quello di near fantastica!) comunque ho provato Raldon e da quello che ho visto utilizzano lo xas non è che si può reperire l'antilag utilizzato da loro?

    Questo è quello che ho trovato però quando parto il gioco mi crasha tutto

    #===============================================================================
    # ** AntiLag Script
    #-------------------------------------------------------------------------------
    # f0tz!baerchen
    # 0.71
    # 06.01.2007
    #-------------------------------------------------------------------------------
    # Credits:
    # Chaosg1 (for testing ;) )
    # NearFantastica (for the Event AntiLag I used and improved)
    #-------------------------------------------------------------------------------
    # Features:
    # - Event AntiLag: Event (and their Sprites) which are not on the screen are
    #   not updated except they run on "Autostart" or "Parallel Process" or they
    #   have an empty comment in the first line
    # - High Priority: Game can be run on high priority
    # - Smooth Antilag: the Event AntiLag does only work fine if the events are
    #   distributed over the whole map, but when there are many events at the same
    #   place it lags again. If the script notices that the CPU utilization
    #   gets higher than $antilag.max_cpu_utilization it will slow down the game and
    #   reduce the framerate as long as needed.
    #-------------------------------------------------------------------------------
    # Settings:
    # can be changed anytime during the game. They are found at the end of the
    # script.
    #===============================================================================
    #===============================================================================
    # Class for Antilag Settings
    #===============================================================================
    class Antilag_Settings
    
     attr_accessor :event
     attr_accessor :max_cpu_utilization
     attr_accessor :cpu_tolerance
     #-----------------------------------------------------------------------------
     # initializes default settings
     #-----------------------------------------------------------------------------
     def initialize
       @event = true
       @high_priority = true
       @max_cpu_utilization = 100
       @cpu_tolerance = 20
       @SetPriorityClass = Win32API.new('kernel32', 'SetPriorityClass',
    								 ['p', 'i'], 'i')
       @GetProcessTimes = Win32API.new('kernel32', 'GetProcessTimes',
    							    ['i','p','p','p','p'], 'i')
     end
     #-----------------------------------------------------------------------------
     # turns high priority on/off
     #-----------------------------------------------------------------------------
     def high_priority=(value)
       @high_priority = value
      
       if @high_priority
      @SetPriorityClass.call(-1, 0x00000080) # High Priority
       else
      @SetPriorityClass.call(-1, 0x00000020) # Normal Priority
       end
     end
     #-----------------------------------------------------------------------------
     # returns the current CPU Utilization
     #-----------------------------------------------------------------------------
     def get_cpu_utilization
       # uses API Call to get the Kernel and User Time
       creation_time = '0' * 10
       exit_time = '0' * 10
       kernel_time = '0' * 10
       user_time = '0' * 10
       @GetProcessTimes.call(-1, creation_time, exit_time, kernel_time, user_time)
       # converts times into integer (in 100ns)
       kernel_time = kernel_time.unpack('l2')
       user_time = user_time.unpack('l2')
       kernel_time = kernel_time[0] + kernel_time[1]
       user_time = user_time[0] + user_time[1]
       # takes differences to calculate cpu utilization
       if @old_time != nil
      timer_difference = Time.new - @old_timer
      time_difference = kernel_time + user_time - @old_time
      result = time_difference / timer_difference / 100000
       else
      result = $antilag.max_cpu_utilization
       end
       # saves values (to calculate the differences, s.a.)
       @old_timer = Time.new
       @old_time = kernel_time + user_time
       return result
     end
    end
    $antilag = Antilag_Settings.new
    #===============================================================================
    # Scene_Map class
    #===============================================================================
    class Scene_Map
     #-----------------------------------------------------------------------------
     # update method, smooth antilag has been added
     #-----------------------------------------------------------------------------
     alias f0tzis_anti_lag_scene_map_update update
     def update
       f0tzis_anti_lag_scene_map_update
       if Graphics.frame_count % 20 == 0 and $antilag.max_cpu_utilization <= 100
      # calculates difference between max utilization and current utilization
      abs = $antilag.max_cpu_utilization - $antilag.get_cpu_utilization
      # changes Frame Rate if difference is bigger than the tolerance
      if abs.abs >= $antilag.max_cpu_utilization * $antilag.cpu_tolerance/100.0
        Graphics.frame_rate = [[10, Graphics.frame_rate + abs / 2].max, 40].min
      end
       end
     end
    end
    #==============================================================================
    # Game_Event Class
    #===============================================================================
    class Game_Event
     #-----------------------------------------------------------------------------
     # for AntiLag, decides, if an event is on the screen or not.
     #-----------------------------------------------------------------------------
     def in_range?
       
       # returns true if $event_antilag is false or the event is an
       # Autostart/Parallel Process event or it has an empty
       # comment in the first line
       if not $antilag.event or (@trigger == 3 or @trigger == 4 or
       (@list != nil and @list[0].code == 108 and @list[0].parameters == ['']))
      return true
       end
    	 
       screne_x = $game_map.display_x
       screne_x -= 256
       screne_y = $game_map.display_y
       screne_y -= 256
       screne_width = $game_map.display_x
       screne_width += 2816
       screne_height = $game_map.display_y
       screne_height += 2176
      
       return false if @real_x <= screne_x
       return false if @real_x >= screne_width
       return false if @real_y <= screne_y
       return false if @real_y >= screne_height
       return true
    	   
     end
     #-----------------------------------------------------------------------------
     # update method
     #-----------------------------------------------------------------------------
     alias f0tzis_anti_lag_game_event_update update
     def update
       return if not self.in_range?	 
       f0tzis_anti_lag_game_event_update
     end
    
    end
    #===============================================================================
    # Sprite_Character Class
    #===============================================================================
    class Sprite_Character < RPG::Sprite
     #-----------------------------------------------------------------------------
     # update method, parameters added for Loop_Map, rebuild for 8dirs
     #-----------------------------------------------------------------------------
     alias f0tzis_anti_lag_sprite_char_update update
     def update
       return if @character.is_a?(Game_Event) and not @character.in_range?
       f0tzis_anti_lag_sprite_char_update
     end
    
    end
    #===============================================================================
    # Settings
    #===============================================================================
    $antilag.max_cpu_utilization = 70 # the maximum CPU utilization, the script
    							  # try to stay under this value during changing
    							  # changing the frame rate. The lower this
    							  # value the higher will be the lag reduction
    							  # (and the smoothness, too), a value > 100
    							  # will disable this feature completely
    $antilag.cpu_tolerance = 20	   # this value tells the script how many % of
    							  # the CPU utilization change should be ignored
    							  # If you change it too a higher value you,
    							  # your Frame Rate will be more constant but
    							  # smaller lags will be ignored.
    $antilag.high_priority = true	 # set this to true if you want the game to run
    							  # on high priority
    $antilag.event = true			 # set this to true to enable normal anti-lag
    #===============================================================================
    # Interpreter Class
    #===============================================================================
    class Interpreter
     #-----------------------------------------------------------------------------
     # * Script
     #-----------------------------------------------------------------------------
     def command_355
       # Set first line to script
       script = @list[@index].parameters[0] + "\n"
       # Loop
       loop do
      # If next event command is second line of script or after
      if @list[@index+1].code == 655
        # Add second line or after to script
        script += @list[@index+1].parameters[0] + "\n"
      # If event command is not second line or after
      else
        # Abort loop
        break
      end
      # Advance index
      @index += 1
       end
       # Evaluation
       result = eval(script)
       #---------------------------------------------------------------------------
       # If return value is false
       # NEW: the last word of the code mustnt be false!
       #---------------------------------------------------------------------------
       if result == false and script[script.length-6..script.length-2] != 'false'
      # End
      return false
       end
       # Continue
       return true
     end
    end
    

     

    Se qualcuno capisce perchè....

  6. Ora funziona ma non del tutto provo a spiegarmi. Lo script è in quattro finestre: provo a spiegarmi

    1. in cima con scritto diario missioni

    2. La parte che premendo destra e sinistra cambia tra missioni principali ecc... ed è quello che mi mantiene la windoskin predefinita

    3.L'elenco delle missioni e funziona

    4.la spiegazione della missione e funziona.

    Spero di essere stato chiaro almeno su quello che credi che debba essere cambiato

  7. Scusa! Comunque se ho capito bene la prima la due righe di codice che dici te si trovano per la prima volta dopo

     

    if Input.trigger?(Input::RIGHT)

    return if @childview

     

    e io ho aggiunto subito sotto return il pezzo di codice che mi hai detto ma mi da questo errore

     

    ????'questlog'? 589 ??? Argument error ?????????

    Wrong number of arguments (2 for 5)

     

    Ho provato a aggiungerlo anche dopo

     

    if Input.trigger?(Input::LEFT)

    Sempre nella solita modalità ma non so se sbaglio io o cosa...

    Se magari potessi essere più preciso ti ringrazierei!

  8. :blink: !!! Non so perchè ma adesso funziona... non capisco... l'importante è che non ci siano problemi! Non vorrei sconfinare però già che sono qua vorrei approfittare del tuo aiuto! La quest log che utilizzo io è Ceasars Questlog enhanced by Tidloc però ho notato un piccolo bug, lo script praticamente funziona come un normale quest log però praticamente si può dividere in più sezioni e premendo destra e sinistra si scorre queste sezioni ora il bug consiste che si può scegliere la windoskin che si vuole però quando lo si scorre a destra o a sinistra ritorna la windoskin originale. Non so se sono stato chiaro comunque questo è la parte di script interessata

     

    ################################################################################
    #																			  #
    #	 Ceasars Questlog enhanced by Tidloc									  #
    #		 I'd say V 4.0 ;-)												    #
    #==============================================================================#
    # This is by far my favourite Questlog out there and because I don't want to   #
    # reinvent the wheel, I took and improved it by my means. ^_^				  #
    # Because the script-command was way to small for most of descriptions I	   #
    # wanted to use for my quests I enabled to add text to descriptions with:	  #
    #   Questlog.addtext(quest, description)									   #
    #------------------------------------------------------------------------------#
    # Furthermore Quests don't have to be deleted after completion and can simply  #
    # be flagged 'resolved' by using the following command:					    #
    #   Questlog.resolve(quest)												    #
    # if you wish, a custom resolvetext may be added in the top of the quest-	  #
    # description. (Questlog_resolved)											 #
    #------------------------------------------------------------------------------#
    # Enabled to categorize Quests, you may choose to use any numbers of		   #
    # categories, but you have to declare them in an array (Questlog_cat)		  #
    # To change the category in the interface press Right or left arrow key	    #
    #------------------------------------------------------------------------------#
    # Quests now may have Child-Quests. Quests with Children will be flagged in    #
    # the title (Questlog_child) to mak it visible, they got Children.			 #
    ################################################################################
    module Tidloc
     Questlog = true
    
     Questlog_resolved = "<size=28><style=system>Risolta</style></size>\n\n"
     Questlog_cat	  = ["Missioni Principali","Missioni Secondarie","Ricercati"]
     Questlog_child    = ""
     Questlog_reward   = "Ricompensa ottenuta"
    end
    
    #//////////////////////////////////Questlog 3.0/////////////////////////////////
    #~~~~~~~~~~~~~~~~~~by Caesar~~~~~~~~~~~~~~~~~
    #\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
    #===================Parameter==================
    # if true, new Quests will be inserted on the top, false at the bottom
    INSERT_AT_TOP = true
    # line heigt in descriptions
    LINE_HEIGHT = 24
    # Windowskin of Questlog (nil = default)
    WINDOWSKIN = "Simple line"
    # Header of the Questlog
    HEADER_TEXT = "DIARIO MISSIONI"
    # speed of scrolling (Pixel / Frame)
    SCROLL_SPEED = 7
    # staletable for descriptions of quests
    STYLES = {
    "h1" => "<size=45><font=Papyrus><b>|</b></font></size><down=40>",
    "h2" => "<big><b><font=Papyrus>|</font></b></big><down=32>",
    "disabled" => "<color=disabled_color>|</color>",
    "highlight" => "<color=#eeee32>|</color>",
    "system" => "<color=system_color>|</color>"
    }
    # this process will be made, when closing the Questlog;
    # (Default: back to map)
    ON_CLOSE = Proc.new {$scene = Scene_Map.new}
    #============================================
    class Scene_Questlog
     def main
       temp = []
       @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
       temp = @window_titles.refresh
       @window_titles.windowskin = RPG::Cache.windowskin(WINDOWSKIN) unless WINDOWSKIN.nil?
       @window_description = Window_Questlog_Description.new(
    	   temp.map{|q| q.description})
       @window_description.windowskin = RPG::Cache.windowskin(WINDOWSKIN) unless WINDOWSKIN.nil?
       @window_titles.refresh
       @index = @window_titles.index
       @cat = 0
       @cat_window = Window_Category_Display.new
       @childview  = false
       @childindex = 0
       spriteset = Spriteset_Map.new
       Graphics.transition
       loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
       end
       Graphics.freeze
       @cat_window.dispose
       @window_header.dispose
       @window_titles.dispose
       @window_description.dispose
       spriteset.dispose
     end
     #----------------
     def update
       @window_titles.update
       @cat_window.update
       if Input.trigger?(Input::B)
      if @childview
        @window_titles.index = @childindex
        @window_titles.refresh
        @window_description.dispose
        @window_description = Window_Questlog_Description.new(
    		    @window_titles.catquests.map{|q| q.description})
        @window_description.index = @childindex
        @childview = false
        return
      end
      $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 Input.trigger?(Input::C)
      return if @window_titles.index == -1
      if @childview
        $game_system.se_play($data_system.cursor_se)
        @window_titles.index = @childindex
        @window_titles.refresh
        @window_description.dispose
        @window_description = Window_Questlog_Description.new(
    		    @window_titles.catquests.map{|q| q.description})
        @window_description.index = @childindex
        @childview = false
        return
      end
      catquests = []
      for i in 0...$game_system.questlog.quests.length
        if $game_system.questlog.quests[i].title == @window_titles.catquests[@window_titles.index].title
    	  catquests.push $game_system.questlog.quests[i]
    	  for j in 0...catquests[0].child_count
    	    catquests.push catquests[0].child[j]
    	  end
    	  if catquests.length > 1
    	    $game_system.se_play($data_system.cursor_se)
    	    @childindex = @window_description.index
    	    @window_titles.index = 0
    	    @window_titles.catquests = catquests
    	    @window_description.dispose
    	    @window_description = Window_Questlog_Description.new(
    			  catquests.map{|q| q.description})
    	    temp = @window_titles.cat
    	    @window_titles.cat = -1
    	    @window_titles.refresh
    	    @window_titles.cat = temp
    	    @childview = true
    	  end
    	  return
        end
      end
       end
       if Input.trigger?(Input::RIGHT)
      return if @childview
      $game_system.se_play($data_system.cursor_se)
      @cat += 1
      @cat = 0 if @cat >= Tidloc::Questlog_cat.length
      @cat_window._category   = @cat
      @window_titles.cat	  = @cat
      @cat_window.refresh
      temp = @window_titles.refresh
      @window_description.dispose
      @window_description = Window_Questlog_Description.new(
    		   temp.map{|q| q.description})
      return
       end
       if Input.trigger?(Input::LEFT)
      return if @childview
      $game_system.se_play($data_system.cursor_se)
      @window_description.index = 0
      @window_titles.index = 0
      @cat -= 1
      @cat = Tidloc::Questlog_cat.length-1 if @cat < 0
      @cat_window._category   = @cat
      @window_titles.cat	  = @cat
      @cat_window.refresh
      temp = @window_titles.refresh
      @window_description.dispose
      @window_description = Window_Questlog_Description.new(
    		   temp.map{|q| q.description})
      return
       end
       if @index != @window_titles.index
      @window_description.index = @index = @window_titles.index
       end
     end
    end
    #=============
    class Quest
     attr_reader   :title
     attr_accessor :description
     attr_reader   :resolved
     attr_reader   :category
     attr_reader   :child_count
     attr_reader   :child
     attr_reader   :reward
     attr_reader   :rewarded
     def initialize(title, category, description)
       @title	   = title
       @description = description
       @resolved    = false
       @category    = category
       @child_count = 0
       @child	   = []
       @reward	  = []
       @rewarded    = false
     end
     def resolve
       @description = Tidloc::Questlog_resolved + @description
       @resolved = true
     end
     def add_child(title, description)
       for i in 0...@child_count
      if @child[i].title == title
        @child[i].description = description
        return
      end
       end
       @child.push Quest.new(title,0,description)
       @child_count += 1
     end
     def add_child_text(title, description)
       for i in 0...@child_count
      if @child[i].title == title
        @child[i].description += description
        return
      end
       end
     end
     def resolve_child(title)
       for i in 0...@child_count
      if @child[i].title == title
        @child[i].resolve
        return
      end
       end
     end
     def add_reward(cat, id, number)
       @reward = [cat, id, number]
     end
     def gain_reward
       return if @rewarded
       if @reward[0] == 0
      $game_party.gain_item(@reward[1],@reward[2])
       elsif @reward[0] == 1
      $game_party.gain_weapon(@reward[1],@reward[2])
       elsif @reward[0] == 2
      $game_party.gain_armor(@reward[1],@reward[2])
       elsif @reward[0] == 3
      $game_party.gain_gold(@reward[2])
       end
       @rewarded = true
     end
    end
    #============
    class Questlog
     attr_reader :quests
     def initialize
       @quests = []
     end
    #-----------
     def add(quest, category = 0, description="")
       return add(Quest.new(quest, category, 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, category, description="")
       $game_system.questlog.add(title, category, description)
     end
    #------------
     def Questlog.remove(title)
       $game_system.questlog.remove(title)
     end
    #TIDLOC
     def addtext(questtitle, description="")
       for i in 0...@quests.length
      if @quests[i].title == questtitle
        @quests[i].description += description
        return true
      end
       end
       return false
     end
     def resolve(questtitle)
       for i in 0...@quests.length
      if @quests[i].title == questtitle
        @quests[i].resolve
        return true
      end
       end
       return false
     end
     def add_child(questtitle, title, description)
       for i in 0...@quests.length
      if @quests[i].title == questtitle
        @quests[i].add_child(title, description)
        return true
      end
       end
       return false
     end
     def add_child_text(questtitle, title, description)
       for i in 0...@quests.length
      if @quests[i].title == questtitle
        @quests[i].add_child_text(title, description)
        return true
      end
       end
       return false
     end
     def resolve_child(questtitle, title)
       for i in 0...@quests.length
      if @quests[i].title == questtitle
        @quests[i].resolve_child(title)
        return true
      end
       end
       return false
     end
     def add_reward(questtitle, category, id, number)
       for i in 0...@quests.length
      if @quests[i].title == questtitle
        @quests[i].add_reward(category, id, number)
        return true
      end
       end
       return false
     end
     def gain_reward(questtitle)
       for i in 0...@quests.length
      if @quests[i].title == questtitle
        @quests[i].gain_reward
        return true
      end
       end
       return false
     end
     def Questlog.addtext(title, description="")
       $game_system.questlog.addtext(title, description)
     end
     def Questlog.resolve(title)
       $game_system.questlog.resolve(title)
     end
     def Questlog.child(questtitle, title, description)
       $game_system.questlog.add_child(questtitle, title, description)
     end
     def Questlog.childtext(questtitle, title, description)
       $game_system.questlog.add_child_text(questtitle, title, description)
     end
     def Questlog.childres(questtitle, title)
       $game_system.questlog.resolve_child(questtitle, title)
     end
     def Questlog.reward(questtitle, category, id, number)
       $game_system.questlog.add_reward(questtitle, category, id, number)
     end
     def Questlog.gain(questtitle)
       $game_system.questlog.gain_reward(questtitle)
     end
    end
    #=============
    class Window_Questlog_Description < Window_Base
     attr_reader   :index
     attr_accessor :cat
     attr_accessor :descriptions
    #------------------
     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
       self.cat = 0
     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
     attr_accessor :cat
     attr_accessor :catquests
     def initialize
       @catquests = []
       @cat = 0
       super(64, 156, 210, 296)
       self.z = 500
       @index = 0
       self.cat = 0
       self.contents = Bitmap.new(width-32, 32)
       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
       j = 0
       if @cat != -1
      @catquests = []
      for i in 0...$game_system.questlog.quests.length
        if $game_system.questlog.quests[i].category == @cat
    	  @catquests.push $game_system.questlog.quests[i]
    	  j += 1
        end
      end
       else
      j = @catquests.length
       end
       @item_max = @catquests.length
       self.contents = Bitmap.new(width-32, @item_max > 0 ? @item_max*32 : 32)
       for i in 0...j
      quest = @catquests[i]
      y = i*32
      if quest.resolved
        self.contents.font.color = disabled_color
      else
        self.contents.font.color = normal_color
      end
      if quest.child_count > 0
        self.contents.draw_html(4, y, 150, 32, Tidloc::Questlog_child + quest.title)
      else
        self.contents.draw_html(4, y, 150, 32, quest.title)
      end
       end
       if @item_max < 1
      @index = -1
       elsif @item_max <= @index
      @index = @item_max-1
       elsif @index == -1 && @item_max > 0
      @index = 0
       end
       return @catquests
     end
    #------------
     def update
       super
       if self.active && @item_max > 0 && @index >= 0
      if Input.repeat?(Input::DOWN) && (Input.trigger?(Input::DOWN) || @index < @item_max - 1)
        $game_system.se_play($data_system.cursor_se)
        @index = (@index + 1) % @item_max
      end
      if Input.repeat?(Input::UP) && (Input.trigger?(Input::UP) || @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
       c
     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 Window_Category_Display < Window_Selectable
     attr_accessor :_category
     def initialize(x=64,y=92,xe=210)
       super(x,y,xe, 64)
       self.contents = Bitmap.new(width - 32, height - 32)
       self._category = 0
       @align = 2
       refresh
     end
     def refresh
       self.contents.clear
       rect = Rect.new(8, 0, self.width - 16, 32)
       self.contents.font.size = 24
       self.contents.font.color=system_color
       self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
       self.contents.draw_text(rect, Tidloc::Questlog_cat[_category])
     end
    end
    

     

    Tuttavia se vorrai provarlo ti serviranno anche questi due script

    ################################################################################
    #  Tidloc's Header  v.1.0													  #
    #				   by Tidloc												  #
    #==============================================================================#
    #  Feel free to use it in your own RPG-Maker game.							 #
    #  But please give me credits for this hell of work ^_^					    #
    #------------------------------------------------------------------------------#
    #  the Versions may differ from script to script you use of me, but be assured #
    #  to always use the highest version available, so that no incompatibility may #
    #  occur.																	  #
    #  I've decided to use this header instead of implementing everything inside   #
    #  my scripts as I first encountered the error of the stack going to deep by   #
    #  aliasing.																   #
    #==============================================================================#
    #  Now supported scripts by this header:									   #
    #		  Blacksmith script *												 #
    #		  Alchemy script *												    #
    #		  Questlog *														  #
    #		  Timephase script *												  #
    #		  Town script *													   #
    #		  Item classes script												 #
    #		  Runes script													    #
    #------------------------------------------------------------------------------#
    #  scripts with a '*' behind their names need this header to work correctly    #
    ################################################################################
    module Tidloc
     Alchemy  = nil
     Smith    = nil
    
     Phases   = nil
     Questlog = nil
     Town	 = nil
     Classes  = nil
     Runes    = nil
    end
    
    class Scene_Title
     alias wo_tidloc_command_new_game command_new_game
     def command_new_game
       $game_temp_tidloc_smith = Game_Temp_Tidloc_Smith.new if Tidloc::Smith
       $game_temp_tidloc_alch  = Game_Temp_Tidloc_Alch.new  if Tidloc::Alchemy
       $game_temp_tidloc_town  = Game_Temp_Tidloc_Town.new  if Tidloc::Town
       wo_tidloc_command_new_game
     end
    end
    
    class Scene_Save < Scene_File
     alias wo_tidloc_write_save_data write_save_data
     def write_save_data(file)
       wo_tidloc_write_save_data(file)
       Marshal.dump($game_temp_tidloc_smith, file) if Tidloc::Smith
       Marshal.dump($game_temp_tidloc_alch, file)  if Tidloc::Alchemy
       Marshal.dump($game_temp_tidloc_town, file)  if Tidloc::Town
     
     end
    end
    
    class Scene_Load < Scene_File
     alias wo_tidloc_read_save_data read_save_data
     def read_save_data(file)
       wo_tidloc_read_save_data(file)
     
       $game_temp_tidloc_smith = Marshal.load(file) if Tidloc::Smith
       $game_temp_tidloc_alch = Marshal.load(file)  if Tidloc::Alchemy
       $game_temp_tidloc_town = Marshal.load(file)  if Tidloc::Town
     
       $game_system.questlog = Questlog.new if $game_system.questlog.nil? && Tidloc::Questlog
     end
    end
    
    class Scene_Map
     alias wo_tidloc_main main
     def main
       @neuemap = false if Tidloc::Town
       wo_tidloc_main
     end
    
     alias wo_tidloc_map_update update
     def update
       wo_tidloc_map_update
       if (Graphics.frame_count * 3 / Graphics.frame_rate) != @total_seconds
      @total_seconds = Graphics.frame_count * 3 / Graphics.frame_rate
      if Tidloc::Smith
        for i in 0...$game_temp_tidloc_smith.smith_busy.length
    	  if $game_temp_tidloc_smith.smith_busy[i] && $game_temp_tidloc_smith.smith_time[i] > 0
    	    $game_temp_tidloc_smith.smith_time[i] -= 1
    	  end
        end
      end
      if Tidloc::Alchemy
        for i in 0...$game_temp_tidloc_alch.alch_busy.length
    	  if $game_temp_tidloc_alch.alch_busy[i] && $game_temp_tidloc_alch.alch_time[i] > 0
    	    $game_temp_tidloc_alch.alch_time[i] -= 1
    	  end
        end
      end
    
       end
       if Tidloc::Phases
      if (Graphics.frame_count * 1 / Graphics.frame_rate) != @total_sec
        if $game_switches.[](PHASE_SW3) == false
    	  @total_sec = Graphics.frame_count * 1  / Graphics.frame_rate
    	  $game_variables.[]=(PHASE_VAR2, $game_variables.[](PHASE_VAR2)+1)
        end
        if $game_switches.[](PHASE_SW2) == true
    	  if $game_variables.[](PHASE_VAR2) < 10
    	    $game_screen.pictures[5].show("Balken/SP_0" + $game_variables.[](PHASE_VAR2).to_s + ".bmp", 0, 535, 85, 100, 100, 255, 0)
    	  else
    	    $game_screen.pictures[5].show("Balken/SP_" + $game_variables.[](PHASE_VAR2).to_s + ".bmp", 0, 535, 85, 100, 100, 255, 0)
    	  end
    	  $game_screen.pictures[4].show("phase_" + $game_variables.[](PHASE_VAR1).to_s + ".png", 0, 0, 0, 100, 100, 255, 0)
        else
    	  $game_screen.pictures[5].erase
    	  $game_screen.pictures[4].erase
        end
        if $game_variables.[](PHASE_VAR2) == 64
    	  if $game_temp.smith_script
    	    for i in 0...$game_temp.smith_busy.length
    		  if $game_temp.smith_busy[i] && $game_temp.smith_time[i]
    		    if $game_temp.smith_time[i] < 0
    			  $game_temp.smith_time[i] += 1
    		    end
    		  end
    	    end
    	  end
    	  if $game_temp.alch_script
    	    for i in 0...$game_temp.alch_busy.length
    		  if $game_temp.alch_busy[i] && $game_temp.alch_time[i]
    		    if $game_temp.alch_time[i] < 0
    			  $game_temp.alch_time[i] += 1
    		    end
    		  end
    	    end
    	  end
    	  $game_variables.[]=(PHASE_VAR2, -1)
    	  if $game_switches.[](PHASE_SW1) == true
    	    $game_variables.[]=(PHASE_VAR1, $game_variables.[](PHASE_VAR1) + 1)
    	  else
    	    $game_variables.[]=(PHASE_VAR1, $game_variables.[](PHASE_VAR1) - 1)
    	  end
    	  if $game_variables.[](PHASE_VAR1) == 0
    	    $game_switches.[]=(PHASE_SW1, true)
    	  elsif $game_variables.[](PHASE_VAR1) == 8
    	    $game_switches.[]=(PHASE_SW1, false)
    	  end
        end
      end
       end
       if Tidloc::Town
      if $game_switches.[](TIDLOC_TOWN_NEW_AREA) && !@neuemap
        @neuemap_seconds = Graphics.frame_count * 3 / Graphics.frame_rate
        @neuemap = true
      elsif @neuemap
        if (Graphics.frame_count * 3 / Graphics.frame_rate) != @neuemap_seconds
    	  @neuemap = false
    	  $game_switches.[]=(TIDLOC_TOWN_NEW_AREA,false)
        end
      end
      if (Graphics.frame_count * 3 / Graphics.frame_rate) != @total_seconds3
        @total_seconds3 = Graphics.frame_count * 3 / Graphics.frame_rate
        if $game_temp_tidloc_town._town_busy && $game_temp_tidloc_town._town_time > 0
    	  $game_temp_tidloc_town._town_time -= 1
        end
      end
       end
     
     end
    end
    

     

    #///////////////////////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!(/<f=([0-9]+)>(.+?)<\/f>/) {$game_switches[$1.to_i] ? $2 : ""}
    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
    

     

    In questo ordine... comunque se conoscessi qualche bel quest log e già che ci siamo un bello skill system (senza considerare lo sphere grid di sephirot spawn) ti sarei molto grato! Detto questo grazie ancora sia della pazienza che della disponibilità!

  9. Io ho studiato e ristudiato questo script ma non trovo scappatoie... almeno senza doverlo modificare, ma non saprei come fare come dici te, perchè le mie abilità di scripter sono molto ridotte! Ma se esistesse qualche piccola modifica da poter fare, magari che aggiungendo poi ad un evento appunto un commento non venga considerato dall'antilag, se qualcuno la potesse fare mi farebbe un gran favore!
  10. Ho cercato a lungo sul web per un antilag compatibile con lo xas, io uso il 3.0, e alla fine sono riuscito a trovare un antilag leggermente modificato, l'antilag di near fantastica, e funziona! Tuttavia faccio un esempio per vedere se riesco a spiegarmi, quando attacco con una determinata spada dovrebbe uscire una palla di fuoco oltre all'attacco normale, che infligge danno al nemico, il problema è il seguente il danno viene considerato ma non si vede la palla di fuoco, ora spero di essermi spiegato a dovere. Questo è lo script da me utilizzato

    #======================================
    # ¦ Anti Event Lag Script
    #======================================
    # By: Near Fantastica
    # Modificado por: Soramaro
    # Date: 12.04.06
    #======================================
    #======================================
    # ¦ Game_Map
    #======================================
    class Game_Map
    #--------------------------------------------------------------------------
    def in_range?(object)
    screne_x = $game_map.display_x
    screne_x -= 256
    screne_y = $game_map.display_y
    screne_y -= 256
    screne_width = $game_map.display_x
    screne_width += 2816
    screne_height = $game_map.display_y
    screne_height += 2176
    return false if object.real_x <= screne_x
    return false if object.real_x >= screne_width
    return false if object.real_y <= screne_y
    return false if object.real_y >= screne_height
    return true
    end
    #--------------------------------------------------------------------------
    def update
    if $game_map.need_refresh
    refresh
    end
    if @scroll_rest > 0
    distance = 2 ** @scroll_speed
    case @scroll_direction
    when 2
    scroll_down(distance)
    when 4
    scroll_left(distance)
    when 6
    scroll_right(distance)
    when 8
    scroll_up(distance)
    end
    @scroll_rest -= distance
    end
    for event in @events.values
    if in_range?(event) or event.trigger == 3 or event.trigger == 4
    event.update
    end
    end
    for common_event in @common_events.values
    common_event.update
    end
    @fog_ox -= @fog_sx / 8.0
    @fog_oy -= @fog_sy / 8.0
    if @fog_tone_duration >= 1
    d = @fog_tone_duration
    target = @fog_tone_target
    @fog_tone.red = (@fog_tone.red * (d - 1) + target.red) / d
    @fog_tone.green = (@fog_tone.green * (d - 1) + target.green) / d
    @fog_tone.blue = (@fog_tone.blue * (d - 1) + target.blue) / d
    @fog_tone.gray = (@fog_tone.gray * (d - 1) + target.gray) / d
    @fog_tone_duration -= 1
    end
    if @fog_opacity_duration >= 1
    d = @fog_opacity_duration
    @fog_opacity = (@fog_opacity * (d - 1) + @fog_opacity_target) / d
    @fog_opacity_duration -= 1
    end
    end
    end
    #======================================
    # ¦ Spriteset_Map
    #======================================
    class Spriteset_Map
    #--------------------------------------------------------------------------
    def in_range?(object)
    screne_x = $game_map.display_x
    screne_x -= 256
    screne_y = $game_map.display_y
    screne_y -= 256
    screne_width = $game_map.display_x
    screne_width += 2816
    screne_height = $game_map.display_y
    screne_height += 2176
    return false if object.real_x <= screne_x
    return false if object.real_x >= screne_width
    return false if object.real_y <= screne_y
    return false if object.real_y >= screne_height
    return true
    end
    #--------------------------------------------------------------------------
    def update
    if @panorama_name != $game_map.panorama_name or
    @panorama_hue != $game_map.panorama_hue
    @panorama_name = $game_map.panorama_name
    @panorama_hue = $game_map.panorama_hue
    if @panorama.bitmap != nil
    @panorama.bitmap.dispose
    @panorama.bitmap = nil
    end
    if @panorama_name != ""
    @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue)
    end
    Graphics.frame_reset
    end
    if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue
    @fog_name = $game_map.fog_name
    @fog_hue = $game_map.fog_hue
    if @fog.bitmap != nil
    @fog.bitmap.dispose
    @fog.bitmap = nil
    end
    if @fog_name != ""
    @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue)
    end
    Graphics.frame_reset
    end
    @tilemap.ox = $game_map.display_x / 4
    @tilemap.oy = $game_map.display_y / 4
    @tilemap.update
    @panorama.ox = $game_map.display_x / 8
    @panorama.oy = $game_map.display_y / 8
    @fog.zoom_x = $game_map.fog_zoom / 100.0
    @fog.zoom_y = $game_map.fog_zoom / 100.0
    @fog.opacity = $game_map.fog_opacity
    @fog.blend_type = $game_map.fog_blend_type
    @fog.ox = $game_map.display_x / 4 + $game_map.fog_ox
    @fog.oy = $game_map.display_y / 4 + $game_map.fog_oy
    @fog.tone = $game_map.fog_tone
    i=0
    for sprite in @character_sprites
    if sprite.character.is_a?(Game_Event)
    if in_range?(sprite.character) or sprite.character.trigger == 3 or sprite.character.trigger == 4
    sprite.update
    i+=1
    end
    else
    sprite.update
    i+=1
    end
    end
    #p i
    @weather.type = $game_screen.weather_type
    @weather.max = $game_screen.weather_max
    @weather.ox = $game_map.display_x / 4
    @weather.oy = $game_map.display_y / 4
    @weather.update
    for sprite in @picture_sprites
    sprite.update
    end
    @timer_sprite.update
    @viewport1.tone = $game_screen.tone
    @viewport1.ox = $game_screen.shake
    @viewport3.color = $game_screen.flash_color
    @viewport1.update
    @viewport3.update
    end
    end
    

     

    Se qualcuno potesse aiutarmi mi farebbe un grandissimo piacere! Grazie in anticipo

  11. Scusate il doppio post ma notando che nessuno mi ha risposto volevo aggiungere qualcosa per semplificare il lavoro di chiunque mi aiuti io utilizzo lo script mog scene name (comunque mi segnala errore anche con lo script per cambiare il nome predefinito) comunque per semplicità voglio postare anche mog scene name e ringrazio chiunque mi aiuti

    #_______________________________________________________________________________
    # MOG_Scene_Name V1.3		  
    #_______________________________________________________________________________
    # By Moghunter	
    # http://www.atelier-rgss.com
    #_______________________________________________________________________________
    # Scene Name com layout e movimento.
    # (Crie seu próprio estilo.)
    #_______________________________________________________________________________
    module MOG
     # Tempo de transição.
     MSNTT1 = 30
     # Definição do tipo de transição.
     MSNTT2 = "004-Blind04"
    end
    #===============================================================================
    # Window_Base
    #===============================================================================
    class Window_Base < Window
    #--------------------------------------------------------------------------
    # draw_battler
    #-------------------------------------------------------------------------- 
     def draw_battler(actor,x,y)
       battler = battler = RPG::Cache.battler(actor.battler_name, actor.battler_hue)
       cw = battler.width
       ch = battler.height
       src_rect = Rect.new(0, 0, cw, ch)
       self.contents.blt(x , y - ch, battler, src_rect)   
     end
    #--------------------------------------------------------------------------
    # draw_actor_level_name
    #-------------------------------------------------------------------------- 
     def draw_actor_level_name(actor, x, y)
       self.contents.font.color = normal_color
       self.contents.draw_text(x , y, 24, 32, actor.level.to_s, 1)
     end
    #--------------------------------------------------------------------------
    # draw_actor_class
    #-------------------------------------------------------------------------- 
     def draw_actor_class_name(actor, x, y)
       self.contents.font.color = normal_color
       self.contents.draw_text(x, y, 120, 32, actor.class_name,1)
     end
    #--------------------------------------------------------------------------
    # draw_actr_name
    #-------------------------------------------------------------------------- 
     def draw_actr_name(actor, x, y)
       self.contents.font.color = normal_color
       self.contents.draw_text(x, y, 120, 32, actor.name,1)
     end
    end
    #===============================================================================
    # Window_Status_Name
    #===============================================================================
    class Window_Status_Name < Window_Base
    #--------------------------------------------------------------------------
    # initialize
    #--------------------------------------------------------------------------   
     def initialize(actor)
       super(0, 0, 320, 480)
       self.contents = Bitmap.new(width - 32, height - 32)
       self.contents.font.name = "Knights Quest"
       @actor = actor
       self.opacity = 0
       refresh
     end
    #--------------------------------------------------------------------------
    # refresh
    #-------------------------------------------------------------------------- 
     def refresh
       self.contents.clear
       draw_actor_graphic(@actor, 50, 110)
       draw_actor_class_name(@actor, 55, 395)
       draw_actor_level_name(@actor, 20, 120)
       draw_battler(@actor, 20, 350)
     end
    end
    #===============================================================================
    # Window_NameEdit2
    #===============================================================================
    class Window_NameEdit2 < Window_Base
     attr_reader   :name				  
     attr_reader   :index		  
    #--------------------------------------------------------------------------
    # Initialize
    #-------------------------------------------------------------------------- 
     def initialize(actor, max_char)
       super(0, 25, 640, 128)
       self.contents = Bitmap.new(width - 32, height - 32)
       @actor = actor
       @name = actor.name
       @max_char = max_char
       name_array = @name.split(//)[0...@max_char]
       @name = ""
       for i in 0...name_array.size
      @name += name_array[i]
       end
       @default_name = @name
       @index = name_array.size
       refresh
       update_cursor_rect
     end
    #--------------------------------------------------------------------------
    # restore_default
    #-------------------------------------------------------------------------- 
     def restore_default
       @name = @default_name
       @index = @name.split(//).size
       refresh
       update_cursor_rect
     end
    #--------------------------------------------------------------------------
    # add
    #-------------------------------------------------------------------------- 
     def add(character)
       if @index < @max_char and character != ""
      @name += character
      @index += 1
      refresh
      update_cursor_rect
       end
     end
    #--------------------------------------------------------------------------
    # back
    #-------------------------------------------------------------------------- 
     def back
       if @index > 0
      name_array = @name.split(//)
      @name = ""
      for i in 0...name_array.size-1
        @name += name_array[i]
      end
      @index -= 1
      refresh
      update_cursor_rect
       end
     end
    #--------------------------------------------------------------------------
    # refresh
    #-------------------------------------------------------------------------- 
     def refresh
       self.contents.clear
       name_array = @name.split(//)
       for i in 0...@max_char
      c = name_array[i]
      if c == nil
        c = "_"
      end
      x = 320 - @max_char * 14 + i * 28
      self.contents.draw_text(x + 32, 64, 28, 32, c, 1)
       end
       draw_actr_name(@actor, 295, 20)
     end
    #--------------------------------------------------------------------------
    # update_cursor_rect
    #-------------------------------------------------------------------------- 
     def update_cursor_rect
       x = 320 - @max_char * 14 + @index * 28
       self.cursor_rect.set(x + 32, 64, 28, 32)
     end
    #--------------------------------------------------------------------------
    # update
    #-------------------------------------------------------------------------- 
     def update
       super
       update_cursor_rect
     end
    end
    #===============================================================================
    # Window_NameInput2
    #===============================================================================
    class Window_NameInput2 < Window_Base
    CHARACTER_TABLE =
    [
    "A","B","C","D","E",
    "F","G","H","I","J",
    "K","L","M","N","O",
    "P","Q","R","S","T",
    "U","V","W","X","Y",
    "Z",""," "," "," ",
    "+","-","*","/","!",
    "1","2","3","4","5",
    "" ,"" ,"" ,"" ,"" ,
    "a","b","c","d","e",
    "f","g","h","i","j",
    "k","l","m","n","o",
    "p","q","r","s","t",
    "u","v","w","x","y",
    "z"," "," "," "," ",
    "#","$","%","&","@",
    "6","7","8","9","0",
    "" ,"" ,"" ,"" ,"" ,
    ]
    #--------------------------------------------------------------------------
    # Initialize
    #-------------------------------------------------------------------------- 
     def initialize
       super(64, 140, 640, 352)
       self.contents = Bitmap.new(width - 32, height - 32)
       @index = 0
       refresh
       update_cursor_rect
     end
    
    #--------------------------------------------------------------------------
    # character
    #-------------------------------------------------------------------------- 
     def character
       return CHARACTER_TABLE[@index]
     end
    #--------------------------------------------------------------------------
    # refresh
    #-------------------------------------------------------------------------- 
     def refresh
       self.contents.clear
       for i in 0...90
       x = 140 + i / 5 / 9 * 180 + i % 5 * 32
       y = i / 5 % 9 * 32
       self.contents.draw_text(x, y, 32, 32, CHARACTER_TABLE[i], 1)
       end
       self.contents.draw_text(428, 9 * 32, 48, 32, "OK", 1)
     end
    #--------------------------------------------------------------------------
    # update_cursor_rect
    #-------------------------------------------------------------------------- 
     def update_cursor_rect
       if @index >= 90
      self.cursor_rect.set(428, 9 * 32, 48, 32)
       else
      x = 140 + @index / 5 / 9 * 180 + @index % 5 * 32
      y = @index / 5 % 9 * 32
      self.cursor_rect.set(x, y, 32, 32)
       end
     end
    #--------------------------------------------------------------------------
    # update
    #-------------------------------------------------------------------------- 
    def update
    super
     if @index >= 90
      if Input.trigger?(Input::DOWN)
        $game_system.se_play($data_system.cursor_se)
        @index -= 90
      end
      if Input.repeat?(Input::UP)
        $game_system.se_play($data_system.cursor_se)
        @index -= 90 - 40
      end
       else
       if Input.repeat?(Input::RIGHT)
      if Input.trigger?(Input::RIGHT) or
        @index / 45 < 3 or @index % 5 < 4
        $game_system.se_play($data_system.cursor_se)
        if @index % 5 < 4
    	  @index += 1
        else
    	  @index += 45 - 4
        end
        if @index >= 90
    	  @index -= 90
        end
      end
       end
       if Input.repeat?(Input::LEFT)
      if Input.trigger?(Input::LEFT) or
        @index / 45 > 0 or @index % 5 > 0
        $game_system.se_play($data_system.cursor_se)
      if @index % 5 > 0
        @index -= 1
      else
        @index -= 45 - 4
      end
      if @index < 0
        @index += 90
      end
       end
     end
     if Input.repeat?(Input::DOWN)
       $game_system.se_play($data_system.cursor_se)
       if @index % 45 < 40
      @index += 5
       else
      @index += 90 - 40
       end
     end
     if Input.repeat?(Input::UP)
       if Input.trigger?(Input::UP) or @index % 45 >= 5
      $game_system.se_play($data_system.cursor_se)
      if @index % 45 >= 5
        @index -= 5
      else
        @index += 90
      end
       end
     end
     if Input.repeat?(Input::L) or Input.repeat?(Input::R)
       $game_system.se_play($data_system.cursor_se)
       if @index < 45
      @index += 45
       else
      @index -= 45
       end
       end
     end
     update_cursor_rect
    end
    end
    #===============================================================================
    # Scene_Name
    #===============================================================================
    class Scene_Name
    #--------------------------------------------------------------------------
    # Main
    #--------------------------------------------------------------------------   
     def main
       @actor = $game_actors[$game_temp.name_actor_id]
       @edit_window = Window_NameEdit2.new(@actor, $game_temp.name_max_char)
       @edit_window.opacity = 0
       @input_window = Window_NameInput2.new
       @input_window.opacity = 0
       @name_back = Plane.new
       @name_back.bitmap = RPG::Cache.picture("normal_panorama11")
       @name_back.z = 10
       @name_back.opacity = 255
       @name_lay = Plane.new
       @name_lay.bitmap = RPG::Cache.picture("Name_Lay")
       @name_lay.z = 15
       @name_lay.opacity = 255
       @name_status_window = Window_Status_Name.new(@actor)
       @name_status_window.x -= 300
       @name_status_window.contents_opacity = 0
       Graphics.transition(MOG::MSNTT1, "Graphics/Transitions/" + MOG::MSNTT2)
       loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
       end
       Graphics.freeze
       @edit_window.dispose
       @input_window.dispose
       @name_back.dispose
       @name_lay.dispose
       @name_status_window.dispose
     end
    #--------------------------------------------------------------------------
    # Update
    #--------------------------------------------------------------------------   
     def update
       @name_back.ox += 1
       if @name_status_window.x < 0
      @name_status_window.x += 15
      @name_status_window.contents_opacity += 5
       elsif @name_status_window.x >= 0
      @name_status_window.x = 0
      @name_status_window.contents_opacity = 255
       end
       @edit_window.update
       @input_window.update
       if Input.repeat?(Input::B)
      if @edit_window.index == 0
        return
      end
      $game_system.se_play($data_system.cancel_se)
      @edit_window.back
      return
       end
       if Input.trigger?(Input::C)
      if @input_window.character == nil
        if @edit_window.name == ""
    	  @edit_window.restore_default
    	  if @edit_window.name == ""
    	    $game_system.se_play($data_system.buzzer_se)
    	    return
    	  end
    	  $game_system.se_play($data_system.decision_se)
    	  return
        end
        @actor.name = @edit_window.name
        $game_system.se_play($data_system.decision_se)
        $scene = Scene_Map.new
        return
      end
      if @edit_window.index == $game_temp.name_max_char
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      if @input_window.character == ""
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_system.se_play($data_system.decision_se)
      @edit_window.add(@input_window.character)
      return
       end
     end
    end
    
    $mog_rgss_Scene_Name = true
    

  12. Ho provato a ricercare per il web ma non sono riuscito a trovare una soluzione valida quindi ho deciso di rivolgermi direttamente a degli scripter... il mio problema è che il menù di samo the thief 1.1 mi crea conflitto con l'inserimento dei nomi, ovvero quando chiamo l'evento e cambio nome mi crasha ogni cosa allora ho cercato di risalire al problema è ho trovato che il problema è all'interno dell'Advanced Text effect contenuto nello script del menù... però una volta trovato il problema non riesco a risolvere il conflitto... quindi chiedo aiuto sperando che qualcuno mi illumini sulla faccenda e che riesca a trovare una soluzione al problema raggirando in qualche modo grazie questo è la parte di script interessata

     

    =begin[/b]
    [b]Advanced Text Effects(ATE) V1.1 by Samo, the thief.[/b]
    [b]This script will evitate you doing your methods of special drawing text manually.
    You will be able to do an outline, a shadow, and something else, by only putting
    when you draw the text:
    (x,y,width,height,str,align,method)
    Name Description Type
    x x coordinate Integer
    y y coordinate Integer
    width width Integer
    height height Integer
    str string Integer
    align alignment: Integer
    Like in Micro Word
    0 Left, 1 Medium,
    2 Right.
    method The Method That String
    will indicate
    what we want.
    Look Down for a List.
    In a Normal window, a draw_text with outline should be like this:[/b]
    [b]self.contents.draw_text(60,45,120,32,"Thanks Outline Script! Now i look Better!", 1, 'outline')[/b]
    [b]List of Methods:[/b]
    [b]'outline'
    'Shadow Wide'
    'Shadow Small'
    'Selected Item'
    'Light Bisel'
    'Small Bisel'
    'Medium Bisel'[/b]
    
    [b]This also comes with a message system(if you don't like it, just erase the part
    of Window_Mesagge)[/b]
    [b]The message System Works in this Way. There are especial Characters that will
    define the type of effect to apply. Just put them, they will appear invisible:[/b]
    [b]~ No method is used in the message. It makes special characters appear.
    @ Outline
    # Small Shadow
    $ Big Shadow
    % Selected Item
    ^ Light Bisel
    & Small Bisel
    * Medium Bisel
    ` Text is Drawn Normally, text effects can appear in the message.
    =end[/b]
    
    [b]class Bitmap
    #-----------------------------------------------------------------------
    alias samo_outline_bitmap_draw_text draw_text #Alias of original Draw_text
    #------------------------------------------------------------------------
    def draw_text(x, y, width, height, str, align = 0, method = 'normal')
    if method == 'outline'
    r = font.color.red #Takes the original color of the window by numbers
    g = font.color.green
    b = font.color.blue
    a = font.color.alpha
    font.color= Color.new(50,50,50) #Color Black
    samo_outline_bitmap_draw_text(x - 1, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x + 1, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y+1, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y-1, width, height, str, align)
    font.color = Color.new(r,g,b,a) #Returns teh color no to normal
    samo_outline_bitmap_draw_text(x, y, width, height, str, align) #draw the text without outline
    end
    if method == 'Shadow Wide'
    r = font.color.red #Takes the original color of the window by numbers
    g = font.color.green
    b = font.color.blue
    a = font.color.alpha
    font.color = Color.new(0,0,0,75)
    samo_outline_bitmap_draw_text(x +12, y + 4, width, height, str, align)
    font.color = Color.new(r,g,b,a) #Returns teh color no to normal
    samo_outline_bitmap_draw_text(x, y, width, height, str, align) #draw the text without outline
    end
    if method == 'Shadow Small'
    r = font.color.red #Takes the original color of the window by numbers
    g = font.color.green
    b = font.color.blue
    a = font.color.alpha
    font.color = Color.new(0,0,0,175)
    samo_outline_bitmap_draw_text(x +3, y + 3, width, height, str, align)
    font.color = Color.new(r,g,b,a) #Returns teh color no to normal
    samo_outline_bitmap_draw_text(x, y, width, height, str, align) #draw the text without outline
    end
    if method == 'Selected Item'
    r = font.color.red #Takes the original color of the window by numbers
    g = font.color.green
    b = font.color.blue
    a = font.color.alpha
    font.color= Color.new(120,255,120,225)
    samo_outline_bitmap_draw_text(x - 1, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x + 1, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y+1, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y-1, width, height, str, align)
    font.color = Color.new(r,g,b,a) #Returns teh color no to normal
    samo_outline_bitmap_draw_text(x, y, width, height, str, align) #draw the text without outline
    end
    if method == 'Light Bisel'
    r = font.color.red #Takes the original color of the window by numbers
    g = font.color.green
    b = font.color.blue
    a = font.color.alpha
    font.color= Color.new(0,0,0,255)
    samo_outline_bitmap_draw_text(x + 1, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y+1, width, height, str, align)
    font.color = Color.new(r,g,b,a) #Returns teh color no to normal
    samo_outline_bitmap_draw_text(x, y, width, height, str, align) #draw the text without outline
    end
    if method == 'Small Bisel'
    r = font.color.red #Takes the original color of the window by numbers
    g = font.color.green
    b = font.color.blue
    a = font.color.alpha
    font.color= Color.new(0,0,0,255)
    samo_outline_bitmap_draw_text(x + 1, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y+1, width, height, str, align)
    font.color= Color.new(125,125,125,255)
    samo_outline_bitmap_draw_text(x - 1, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y-1, width, height, str, align)
    font.color = Color.new(r,g,b,a) #Returns teh color no to normal
    samo_outline_bitmap_draw_text(x, y, width, height, str, align) #draw the text without outline
    end
    if method == 'Medium Bisel'
    r = font.color.red #Takes the original color of the window by numbers
    g = font.color.green
    b = font.color.blue
    a = font.color.alpha
    font.color= Color.new(0,0,0,255)
    samo_outline_bitmap_draw_text(x + 2, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y+2, width, height, str, align)
    samo_outline_bitmap_draw_text(x + 2, y+2, width, height, str, align)
    font.color= Color.new(125,125,125,255)
    samo_outline_bitmap_draw_text(x - 2, y, width, height, str, align)
    samo_outline_bitmap_draw_text(x , y-2, width, height, str, align)
    samo_outline_bitmap_draw_text(x - 2, y-2, width, height, str, align)
    font.color = Color.new(r,g,b,a) #Returns teh color no to normal
    samo_outline_bitmap_draw_text(x - 1, y - 1, width, height, str, align) #draw the text without outline
    end
    if method == 'normal'
    samo_outline_bitmap_draw_text(x, y, width, height, str, align) #draw the text without outline
    end
    end
    #-----------------------------------------------------------------------
    #-----------------------------------------------------------------------
    end[/b]
    
    [b]class Sprite_Timer < Sprite
    #--------------------------------------------------------------------------
    def update
    super
    self.visible = $game_system.timer_working
    if $game_system.timer / Graphics.frame_rate != @total_sec
    self.bitmap.clear
    @total_sec = $game_system.timer / Graphics.frame_rate
    min = @total_sec / 60
    sec = @total_sec % 60
    text = sprintf("%02d:%02d", min, sec)
    self.bitmap.font.color.set(255, 255, 255)
    self.bitmap.draw_text(0,0,88,48, text, 1, true)
    end
    end
    end[/b]
    [b]#==============================================================================
    # ■ Window_Command
    #------------------------------------------------------------------------------[/b]
    [b]class Window_Command < Window_Selectable
    #--------------------------------------------------------------------------
    #--------------------------------------------------------------------------
    def draw_item(index, color)
    self.contents.font.color = color
    rect = Rect.new(4, 32 * index, self.contents.width - 8, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    self.contents.draw_text(rect.x,rect.y,rect.width,rect.height, @commands[index])
    end
    end[/b]
    
    [b]#==============================================================================
    # ■ Window_PartyCommand
    #------------------------------------------------------------------------------[/b]
    [b]class Window_PartyCommand < Window_Selectable
    #--------------------------------------------------------------------------
    def draw_item(index, color)
    self.contents.font.color = color
    rect = Rect.new(160 + index * 160 + 4, 0, 128 - 10, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    self.contents.draw_text(rect.x,rect.y,rect.width,rect.height, @commands[index], 1)
    end
    end[/b]
    [b]# Delay Method
    def delay(seconds)
    for i in 0...seconds # * 1
    sleep 0.01
    Graphics.update
    end
    end[/b]
    [b]#wait method
    def wait(frames)
    return true if frames == 0
    if Graphics.frame_count % (frames) == 0
    return true
    end
    end[/b]
    
    [b]#========================================
    #■ Game_Map
    #--------------------------------------------------------------------------
    # Setting functions for the Map
    #========================================
    class Game_Map[/b]
    [b]def name
    $map_infos[@map_id]
    end
    end
    

    non so se il finale serva però ho copiato tutto per sicurezza...

    chiunque mi risolva l'errore sarà un grande! Grazie

×
×
  • Create New...