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

Grayfoxflavio

Utenti
 View Profile  See their activity

  • Posts

    26

  • Joined

  • Last visited

 Content Type 

Posts posted by Grayfoxflavio

    Fantasy Of Memory

    in Progetti XP

    Posted · Edited by Grayfoxflavio

    Aggiornamento F.O.M

     

    A causa di un esplosione del mio pc, devo fermare temporaneamente lo sviluppo del gioco finkè non avrò un nuovo pc. :'(

    Che sfigaaaaaaaaaaaaaaaa!!!!!!!!!!!!!!!!!!!!

    La Cover del mio gioco

    in Grafica

    Posted

    Penso che hai ragione ma era una prova per vedere se magari potevano andare bene o meno....cmq il mio gioco parla un avvenimento che mi è successo e che ho voluto riportarlo nel mio videogame, nella prima cover mostro i mio lato buono e quello cattivo che nel gioco sarà il giocatore a scegliere la via dell'eroe buono oppure dell'eroe oscuro; Questo era più o meno il succo.

    Non riesco a trovarne uno buono

    in Richieste scripts RGSS (XP)

    Posted

    Scusa ancora per il doppio post ma non è più necessiario cercare; accidentalmente sono incappato in un sito di maker dove ho trovato lo script che cercavo (finalmente) ,cmq grazie lo stesso. Ah lo script era il KGC overdrive quello uguale al limitbrek di ffvii.

     

     

     

    #==============================================================================

    # ** Game_Actor

    #==============================================================================

    KGC_Game_Actor_first = "LimitBreak" unless defined?(KGC_Game_Actor)

    module KGC_Game_Actor

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

    # * Active decision of skill

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

    if defined?(skill_can_use?) && !@_skill_can_use_overdrive

    alias skill_can_use_KGC_OverDrive skill_can_use?

    else

    @_skill_can_use_overdrive = true

    end

    def skill_can_use?(skill_id)

    result = true

    skill = $data_skills[skill_id]

    if skill != nil &&

    skill.element_set.include?($game_special_elements["limitbreak"])

    result = self.overdrive == KGC::OD_GAUGE_MAX

    end

    if defined?(skill_can_use_KGC_OverDrive)

    return result & skill_can_use_KGC_OverDrive(skill_id)

    else

    return result & super

    end

    end

    module_function :skill_can_use?

    public :skill_can_use?

    end

     

     

    class Game_Actor < Game_Battler

    include KGC_Game_Actor

    attr_writer :overdrive_type

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

    # * Setup

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

    alias setup_KGC_OverDrive setup

    def setup(actor_id)

    # Executing the processing of the origin

    setup_KGC_OverDrive(actor_id)

    @overdrive, @overdrive_type = 0, 1

    end

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

    # * Acquisition of OverDrive gauge

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

    def overdrive

    @overdrive = 0 if @overdrive == nil

    return @overdrive

    end

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

    # * Operation of OverDrive gauge

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

    def overdrive=(value)

    @overdrive = [[value, 0].max, KGC::OD_GAUGE_MAX].min

    end

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

    # * Acquisition of OverDrive type

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

    def overdrive_type

    @overdrive_type = 0 if @overdrive_type == nil

    return @overdrive_type

    end

    end

     

     

    #==============================================================================

    # ** Scene_Battle (Part 1)

    #==============================================================================

    class Scene_Battle

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

    # * Battle Ends

    # result : results (0:win 1:lose 2:escape)

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

    alias battle_end_KGC_OverDrive battle_end

    def battle_end(result)

    case result

    when 0 # Victory

    $game_party.actors.each { |actor|

    next unless actor.exist?

    #When drive type "victory" is, addition

    if actor.overdrive_type == 2

    actor.overdrive += KGC::OD_GAIN_RATE[2]

    end

    }

    when 1 # Flight

    $game_party.actors.each { |actor|

    next unless actor.exist?

    # When drive type "flight" is, addition

    if actor.overdrive_type == 3

    actor.overdrive += KGC::OD_GAIN_RATE[3]

    end

    }

    end

    # Defeat

    battle_end_KGC_OverDrive(result)

    end

    end

     

     

     

    #==============================================================================

    # ** Scene_Battle (Part 4)

    #==============================================================================

     

    class Scene_Battle

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

    # * Frame Update (main phase step 2 : start action) (Edited)

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

    alias update_phase4_step2_KGC_OverDrive update_phase4_step2

    def update_phase4_step2(battler)

    if battler.is_a?(Game_Actor)

    # Gauge increase decision

    case battler.overdrive_type

    when 4 # Lonely battle

    alone = true

    $game_party.actors.each { |actor|

    next if actor == battler

    # When the survivor is, it is not lonely

    if actor.exist?

    alone = false

    break

    end

    }

    od_up = alone ? KGC::OD_GAIN_RATE[4] : 0

    when 5 # When acting

    od_up = KGC::OD_GAIN_RATE[5]

    when 6 # Dying

    od_up = (battler.hp <= battler.maxhp / 4) ?

    KGC::OD_GAIN_RATE[6] : 0

    else

    od_up = 0

    end

    battler.overdrive += od_up

    end

    # Executing the processing of the origin

    update_phase4_step2_KGC_OverDrive(battler)

    end

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

    # * Frame Update (main phase step 4 : animation for target) (Meter Edited)

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

    alias update_phase4_step4_KGC_OverDrive update_phase4_step4

    def update_phase4_step4(battler)

    @status_window.refresh

    update_phase4_step4_KGC_OverDrive(battler)

    end

    end

     

    #==============================================================================

    # ** Window_BattleStatus

    #==============================================================================

     

    class Window_BattleStatus < Window_Base

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

    # * Add Overdrive Meters

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

    alias refresh_KGC_OverDrive refresh

    def refresh(number = 0)

    if self.contents == nil

    self.contents = Bitmap.new(width - 32, height - 32)

    end

    if number == 0

    for i in 0...$game_party.actors.size

    draw_actor_od($game_party.actors, i * 160 + 4, 88, 120)

    end

    else

    if $game_party.actors[number].is_a?(Game_Actor)

    draw_actor_od($game_party.actors[number], number * 160 + 4, 88, 120)

    end

    end

    refresh_KGC_OverDrive(number)

    end

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

    # * Opacity Fix

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

    alias update_KGC_OverDrive update

    def update

    if $game_temp.battle_main_phase

    self.contents_opacity -= 4 if self.contents_opacity > 191

    else

    self.contents_opacity += 4 if self.contents_opacity < 255

    end

    end

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

    # * Draw Overdrive Meter

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

    def draw_actor_od(actor, x, y, width = 144)

    rate = actor.overdrive.to_f / KGC::OD_GAUGE_MAX

    plus_x = 0

    rate_x = 0

    plus_y = 25

    plus_width = 0

    rate_width = 100

    height = 10

    align1 = 1

    align2 = 2

    align3 = 0

    grade1 = 1

    grade2 = 0

    color1 = Color.new(0, 0, 0, 192)

    color2 = Color.new(255, 255, 192, 192)

    color3 = Color.new(0, 0, 0, 192)

    color4 = Color.new(64, 0, 0, 192)

    color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)

    color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)

    od = (width + plus_width) * actor.overdrive * rate_width / 100 /

    KGC::OD_GAUGE_MAX

    gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,

    width, plus_width + width * rate_width / 100,

    height, od, align1, align2, align3,

    color1, color2, color3, color4, color5, color6, grade1, grade2)

    end

    end

    #==============================================================================

    # ** KGC_Overdrive Ringer (09-05-2006)

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

    # by DerVVulfman

    #

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

    # A requested feature, this script checks whenever the overdrive bar is filled

    # and plays a pre-set sound effect accordingly. There isn't much to the script

    # and was fairly easy to write. It will work with both versions 1 and 2 of the

    # KGC_Overdrive script that I've posted, and will probably work with the ori-

    # ginal version of KGC_Overdrive before it was edited by Minkoff.

    #

    #==============================================================================

     

     

     

    #==============================================================================

    # ** Scene_Battle

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

    # This class performs battle screen processing.

    #==============================================================================

    class Scene_Battle

     

    # Overdrive gauge maximum (same value as in KGC_OverDrive Script).

    OD_GAUGE_MAX = 500

     

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

    # * Full OD Gauge SE

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

    def fullod_se

    Audio.se_play("Audio/SE/015-jump01", 100, 100)

    end

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

    # * Frame renewal (OD gauge renewal phase)

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

    alias update_phase0_overring update_phase0

    def update_phase0

    # Call the original def from RTAB

    update_phase0_overring

    # Go through the Actors

    $game_party.actors.each { |actor|

    # Only perform if the actor exists

    next unless actor.exist?

    # When the Overdrive bar is set to zero,

    # Reset the Overdrive Ringer to false

    if actor.overdrive == 0

    actor.overdrive_ring = false

    end

    # When the Overdrive Ringer hasn't rung

    if actor.overdrive_ring == false

    # But the Overdrive Bar is filled

    if actor.overdrive == OD_GAUGE_MAX

    # Play the Overdrive Sound Effect

    fullod_se

    # And Set the Overdrive Ringer to true

    actor.overdrive_ring = true

    end

    end

    }

    end

    end

     

     

     

    #==============================================================================

    # ** Game_Actor

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

    # This class handles the actor. It's used within the Game_Actors class

    # ($game_actors) and refers to the Game_Party class ($game_party).

    #==============================================================================

    class Game_Actor < Game_Battler

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

    # * Public Instance Variables

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

    attr_accessor :overdrive_ring

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

    # * Setup

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

    alias setup_KGC_OverRing setup

    def setup(actor_id)

    # Executing the processing of the origin

    setup_KGC_OverRing(actor_id)

    @overdrive_ring = false

    end

    end

     

×
×
  • Create New...