Bienvenue sur RM-Land : Le forum !
Après votre inscription, vous aurez accès à tout le forum : Partage de ressources, de scripts, résolution de vos problèmes, présentations de projets et montage de teams.
 
AccueilLe sitePortailFAQRechercherS'enregistrerConnexion

Partagez | 
 

 A-RPG simple et rapide :)

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
Invité
Invité



MessageSujet: A-RPG simple et rapide :)   Lun 31 Déc - 18:03

Salut a tous
Voila comment faire un A-RPG (jeu comme zelda)
1 )Faites un script au dessus de main et nommer le Action Battle System :
Code:
#==============================================================================
# ■ Action Battle System
#------------------------------------------------------------------------------
#  By: Near Fantastica
#  Date: 07/2/05
#  Version 2
#
#  A key – X input – Skill Hot Key 1
#  S key – Y input – Skill Hot Key 2
#  D key – Z input – Skill Hot Key 3
#  Q key – L input – Attacking
#  W key –R input – Defending
#
#  The Skill Hot Keys can be changed in the Skill Menu by cursering over to the
#  skill you want and pressing the hot key you want to set that skill too ~!
#
#  Thanks to Harosata, Akura, Hazarim, Deke, Arcaine and
#  Thanks to everyone for testing and for your input
#==============================================================================

class Action_Battle_System
  #--------------------------------------------------------------------------
  # ● Open instance variable
  #--------------------------------------------------------------------------
  attr_accessor :active_actor
  attr_accessor :display
  attr_accessor :player_defending
  attr_accessor :skill_hot_key
  attr_accessor :dash_level
  #--------------------------------------------------------------------------
  # ● Initialization
  #--------------------------------------------------------------------------
  def initialize
    @event_counter = 0
    @display = Sprite.new
    @display.bitmap = Bitmap.new(88, 48)
    @clear_counter = 0
    @active_actor = 0
    @player_defending = false
    @restore = false
    @reduce= false
    @timer = 0
    @dash_level = 5
    @sec = 0
    @skill_hot_key = {}
    @skill_hot_key[1]  = 0
    @skill_hot_key[2]  = 0
    @skill_hot_key[3] = 0
    @enemy_id = {}
    @enemy_name = {}
    @enemy_hp = {}
    @enemy_sp = {}
    @enemy_str = {}
    @enemy_dex = {}
    @enemy_agi  = {}
    @enemy_int = {}
    @enemy_atk = {}
    @enemy_pdef = {}
    @enemy_mdef = {}
    @enemy_eva = {}
    @enemy_animation1_id = {}
    @enemy_animation2_id = {}
    @enemy_exp = {}
    @enemy_gold = {}
    @enemy_item_id = {}
    @enemy_weapon_id = {}
    @enemy_armor_id = {}
    @enemy_treasure_prob = {}
    @enemy_engagement = {}
    @enemy_movment = {}
    @enemy_frequency = {}
    @enemy_speed = {}
    @enemy_defending = {}
    @enemy_dex_loop = {}
  end
  #--------------------------------------------------------------------------
  # ● Enemy Setup
  #--------------------------------------------------------------------------
  def enemy_setup
    # Setup Event Max
    @event_counter = 0
    for i in 1..999
      if $game_map.map.events[i].id > @event_counter
        @event_counter = $game_map.map.events[i].id
      end
    end
    # Setup Event
    for i in 1..@event_counter #$game_map.map.events.size
      # Set the event to nill setting
      @enemy_id[i] = 0
      for x in 1..$data_enemies.size - 1
        if $game_map.map.events[i] == nil
          next i
        end
        if $game_map.map.events[i].name == $data_enemies[x].name
          # Event is an Enemy Setup Emeny
          @enemy_id[i] = $data_enemies[x].id
          @enemy_name[i] = $data_enemies[x].name
          @enemy_hp[i] = $data_enemies[x].maxhp
          @enemy_sp[i] = $data_enemies[x].maxsp
          @enemy_str[i] = $data_enemies[x].str
          @enemy_dex[i] = $data_enemies[x].dex
          @enemy_agi [i] = $data_enemies[x].agi
          @enemy_int[i] = $data_enemies[x].int
          @enemy_atk[i] = $data_enemies[x].atk
          @enemy_pdef[i] = $data_enemies[x].pdef
          @enemy_mdef[i] = $data_enemies[x].mdef
          @enemy_eva[i] = $data_enemies[x].eva
          @enemy_animation1_id[i] = $data_enemies[x].animation1_id
          @enemy_animation2_id[i] = $data_enemies[x].animation2_id
          @enemy_exp[i] = $data_enemies[x].exp
          @enemy_gold[i] = $data_enemies[x].gold
          @enemy_item_id[i] = $data_enemies[x].item_id
          @enemy_weapon_id[i] = $data_enemies[x].weapon_id
          @enemy_armor_id[i] = $data_enemies[x].armor_id
          @enemy_treasure_prob[i] = $data_enemies[x].treasure_prob
          @enemy_states = []
          @enemy_engagement[i] = false
          @enemy_movment[i] = 0
          @enemy_frequency[i] = 0
          @enemy_speed[i] = 0
          @enemy_defending[i] = false
          @enemy_dex_loop[i] = 0
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Update Dash
  #--------------------------------------------------------------------------
  def update_dash
    # check if sheild is active
    if @player_defending == true
      $game_player.move_speed = 3
      return
    end
    # check is Dash Mode Active
    if Input.press?(Input::A)
      if $game_player.moving?
        # If A Key press enter dash mode
        # reduce dash level
        $game_player.move_speed=5
        @restore = false
        if @reduce == false
          @timer = 50 # Initial time off set
          @reduce = true
        else
          @timer-= 1
        end
        @sec = (@timer / Graphics.frame_rate)%60
        if @sec == 0
          if @dash_level != 0
            @dash_level -= 1
            @timer = 50 # Timer Count
          end
        end
        if @dash_level == 0
          $game_player.move_speed=4
        end
      end
    else
      # restore dash level
      $game_player.move_speed=4
      @reduce = false
      if @restore == false
        @timer = 80 # Initial time off set
        @restore = true
      else
        @timer-= 1
      end
      @sec = (@timer / Graphics.frame_rate)%60
      if @sec == 0
        if @dash_level != 5
          @dash_level+= 1
          @timer = 60 # Timer Count
SCRIPT CONTINUE !!


Dernière édition par le Lun 31 Déc - 18:09, édité 1 fois
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Lun 31 Déc - 18:05

Code:
end
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Clear Display
  #--------------------------------------------------------------------------
  def clear_display
    @clear_counter += 1
    if @clear_counter == 50
      @clear_counter = 0
      @display.bitmap.clear
    end
  end
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------
  def update
    update_dash
    clear_display
    for i in 1..@event_counter
      # Check if Event is an Enemy
      if @enemy_id[i] == 0
        next
      else
        # Enemy Engaged
        if @enemy_engagement[i] == true
          # Check Range
          if in_range?(i,5)
            # Update Battle
            if in_range?(i,1)
              event_melee_attack(i)
            else
              event_skill_attack(i)
            end
            next
          else
            @enemy_engagement[i] = false
            # Change Movement
            $game_map.events[i].move_type = @enemy_movment[i]
            $game_map.events[i].move_frequency = @enemy_frequency[i]
            $game_map.events[i].move_speed = @enemy_speed[i]
            next
          end
        end
        # Check Range
        if in_range?(i,5)
          # Check Event Direction
          if facing_player?(i)
            # Set Enemy Engaged
            @enemy_engagement[i] = true
            # Change Movement
            @enemy_movment[i] = $game_map.events[i].move_type
            $game_map.events[i].move_type = 2
            @enemy_frequency[i] = $game_map.events[i].move_frequency
            $game_map.events[i].move_frequency = 5
            @enemy_speed[i] = $game_map.events[i].move_speed
            $game_map.events[i].move_speed = 4
            # Update Battle
            if in_range?(i,1)
              event_melee_attack(i)
            else
              event_skill_attack(i)
            end
          end
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Check If Event Is In Range
  #--------------------------------------------------------------------------
  def in_range?(event_index, range)
    playerx = $game_player.x
    playery = $game_player.y
    eventx = $game_map.events[event_index].x
    eventy = $game_map.events[event_index].y
    # Determine x and y of circle
    x = (playerx - eventx) * (playerx - eventx)
    y = (playery - eventy) * (playery - eventy)
    # Determine raduis
    r = x +y
    if r <= (range * range)
      return true
    else
      return false
    end
  end
  #--------------------------------------------------------------------------
  # ● Check If Event Is Facing Player
  #--------------------------------------------------------------------------
  def facing_player?(event_index)
    playerx = $game_player.x
    playery = $game_player.y
    eventx = $game_map.events[event_index].x
    eventy = $game_map.events[event_index].y
    event_direction = $game_map.events[event_index].direction
    # Check down
    if event_direction == 2
      if playery >= eventy
        return true
      end
    end
    # Check Left
    if event_direction == 4
      if playerx <= eventx
        return true
      end
    end
    # Check Right
    if event_direction == 6
      if playerx >= eventx
        return true
      end
    end
    # Check Up
    if event_direction == 8
      if playery <= eventy
        return true
      end
    end
    return false
  end
  #--------------------------------------------------------------------------
  # ● Check Event Attack Condisions
  #    NOTE : there is no turns in the ABS therfore there is no turn percondition
  #--------------------------------------------------------------------------
  def event_melee_preconditions(event_index)
    if @enemy_dex_loop[event_index] >= @enemy_dex[event_index] * 20
      @enemy_dex_loop[event_index]  = 0
      for i in 0..$data_enemies[@enemy_id[event_index]].actions.size - 1
        if $data_enemies[@enemy_id[event_index]].actions[i].kind == 0
          actions = $data_enemies[@enemy_id[event_index]].actions[i]
          # Check Hp Level condition
          if @enemy_hp[event_index] * 100.0 / $data_enemies[@enemy_id[event_index]].maxhp > actions.condition_hp
            next
          end
          # Check Max Level condition
          if $game_party.max_level < actions.condition_level
            next
          end
          # Check switch condition
          switch_id = actions.condition_switch_id
          if actions.condition_switch_id > 0 and $game_switches[switch_id] == false
            next
          end
          # Check Rank to see if it is larger then the dice roll
          n = rand(10)
          if actions.rating < n
            next
          end
          # Return Action
          case actions.basic
          when 0
            return 0
          when 1
            return 1
          when 2
            return 2
          when 3
            return 3
          end
        end
      end
      # No action taken
      return 3
    else
      # add to the dex loop
      @enemy_dex_loop[event_index] += @enemy_dex[event_index]
      return 3
    end
  end
  #--------------------------------------------------------------------------
  # ● Check Event Attack Condisions
  #    NOTE : there is no turns in the ABS therfore there is no turn percondition
  #--------------------------------------------------------------------------
  def event_skill_preconditions(event_index)
    if @enemy_dex_loop[event_index] >= @enemy_dex[event_index] * 100
      @enemy_dex_loop[event_index]  = 0
      for i in 0..$data_enemies[@enemy_id[event_index]].actions.size - 1
        if $data_enemies[@enemy_id[event_index]].actions[i].kind == 1
          actions = $data_enemies[@enemy_id[event_index]].actions[i]
          # Check Hp Level condition
          if @enemy_hp[event_index] * 100.0 / $data_enemies[@enemy_id[event_index]].maxhp > actions.condition_hp
            return 0
          end
          # Check Max Level condition
          if $game_party.max_level < actions.condition_level
            return 0
          end
          # Check switch condition
          switch_id = action.condition_switch_id
          if actions.condition_switch_id > 0 and $game_switches[switch_id] == false
            return 0
          end
          return actions.skill_id
        end
      end
      return 0
    else
      # add to the dex loop
      @enemy_dex_loop[event_index] += @enemy_dex[event_index]
      return 0
    end
  end
  #--------------------------------------------------------------------------
  # ● Calculation of attribute correction
  #    element_set : Attribute
  #--------------------------------------------------------------------------
  def player_elements_correct(element_set)
    # In case of non attribute
    if element_set == []
      # return 100
      return 100
    end
    # The weakest one is returned in the attribute which is given * method element_rate
    #  is defined in Game_Actor and the Game_Enemy class which are succeeded from this class
    weakest = -100
    for i in element_set
      weakest = [weakest, $game_party.actors[@active_actor].element_rate(i)].max
    end
    return weakest
  end
  #--------------------------------------------------------------------------
  # ● Event Melee Attack
  #--------------------------------------------------------------------------
  def event_melee_attack(event_index)
    kind = event_melee_preconditions(event_index)
    case kind
    when 0 # Enemy Attacking
      @enemy_defending[event_index] = false
      # First on-target hit decision
      hit_rate = 100
      for i in @enemy_states
          hit_rate *= $data_states[i].hit_rate / 100.0
      end
      hit_result = (rand(100) < hit_rate)
      # In case of on-target hit
      if hit_result == true
        # Calculating the basic damage
        atk = [@enemy_atk[event_index] - $game_party.actors[@active_actor].pdef / 2, 0].max
        damage = atk * (20 + @enemy_str[event_index] ) / 20
        # Attribute correction
        damage *= player_elements_correct([])
        damage /= 100
        # When the mark of the damage is correct
        if damage > 0
          # Critical correction
          if rand(100) < 4 * @enemy_dex[event_index] / $game_party.actors[@active_actor].agi
            damage *= 2
          end
          # Defense correction
          if  @player_defending == true
            damage /= 2
          end
        end
        # Dispersion
        if damage.abs > 0
          amp = [damage.abs * 15 / 100, 1].max
          damage += rand(amp+1) + rand(amp+1) - amp
        end
        # Second on-target hit decision
        eva = 8 * $game_party.actors[@active_actor].agi / @enemy_dex[event_index] + $game_party.actors[@active_actor].eva
        hit = damage < 0 ? 100 : 100 - eva
        # Check evade
        cant_evade = false
        for i in $game_party.actors[@active_actor].states
          if $data_states[i].cant_evade
            cant_evade = true
          end
        end
        hit = cant_evade ? 100 : hit
        hit_result = (rand(100) < hit)
      end
      # In case of on-target hit
      if hit_result == true
        # State shocking cancellation
        # Note : I still can not get the states effects to work correctly
        # remove_states_shock
        # From HP damage subtraction
        damage = damage.abs
        $game_party.actors[@active_actor].hp -= damage
        hit_player(damage, @enemy_animation2_id[event_index])
        if $game_party.actors[@active_actor].hp <= 0
          player_dead
        end
        # State change
        # Note : I still can not get the states effects to work correctly
        # states_plus(@enemy_states)
        # states_minus(@enemy_states)
      end
    when 1 # Enemy Defening
      if @enemy_defending[event_index] != true
        @enemy_defending[event_index] = true
        $game_map.events[event_index].move_speed = $game_map.events[event_index].move_speed - 1
      end
    when 2 # Enemy Escaping
      # Note : Could Add a Teleport Event to make the Event jump far away from player
    when 3 # No Action Taken
    end
  end
  #--------------------------------------------------------------------------
  # ● Event Skill Attack
  #--------------------------------------------------------------------------
  def event_skill_attack(event_index)
    # Check Percondisions  of the Enemy
    skill_id = event_skill_preconditions(event_index)
    # If Condisions not meet
    if skill_id ==  0
      return
    end
    skill = $data_skills[skill_id]

LE SCRIPT CONTINUE
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Lun 31 Déc - 18:06

Code:
# Check Sp Cost
    if skill.sp_cost > @enemy_sp[event_index]
      return
    end
    @enemy_sp[event_index] -= skill.sp_cost
    # When the effective range of skill with friend of HP 1 or more, your own HP 0,
    # or the effective range of skill with the friend of HP 0, your own HP are 1 or more,
    if ((skill.scope == 3 or skill.scope == 4) and @enemy_hp == 0) or
      ((skill.scope == 5 or skill.scope == 6) and @enemy_hp >= 1)
      # メソッド終了
      return
    end
    # Clearing the effective flag
    effective = false
    # When common event ID is effective, setting the effective flag
    effective |= skill.common_event_id > 0
    # First on-target hit decision
    skill_hit = 100
    for i in @enemy_states
      skill_hit *= $data_states[i].hit_rate / 100.0
    end
    user_hit = 100
    for i in @enemy_states
      user_hit *= $data_states[i].hit_rate / 100.0
    end
    hit = skill_hit
    if skill.atk_f > 0
      hit *= user_hit / 100
    end
    hit_result = (rand(100) < hit)
    # In case of uncertain skill setting the effective flag
    effective |= hit < 100
    # In case of on-target hit
    if hit_result == true
      # Calculating power
      power = skill.power + @enemy_atk[event_index] * skill.atk_f / 100
      if power > 0
        power -= $game_party.actors[@active_actor].pdef * skill.pdef_f / 200
        power -= $game_party.actors[@active_actor].mdef * skill.mdef_f / 200
        power = [power, 0].max
      end
      # Calculating magnification ratio
      rate = 20
      rate += (@enemy_str[event_index] * skill.str_f / 100)
      rate += (@enemy_dex[event_index] * skill.dex_f / 100)
      rate += (@enemy_agi[event_index] * skill.agi_f / 100)
      rate += (@enemy_int[event_index] * skill.int_f / 100)
      # Calculating the basic damage
      damage = power * rate / 20
      # Attribute correction
      damage *= player_elements_correct(skill.element_set)
      damage /= 100
      # When the mark of the damage is correct,
      if damage > 0
        # Defense correction
        if @player_defending == true
          damage /= 2
        end
      end
      # Dispersion
      if skill.variance > 0 and damage.abs > 0
        amp = [damage.abs * skill.variance / 100, 1].max
        damage += rand(amp+1) + rand(amp+1) - amp
      end
      # Second on-target hit decision
      eva = 8 * $game_party.actors[@active_actor].agi / @enemy_dex[event_index] + $game_party.actors[@active_actor].eva
      hit = damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
      cant_evade = false
      for i in $game_party.actors[@active_actor].states
        if $data_states[i].cant_evade
          cant_evade = true
        end
      end
      hit = cant_evade ? 100 : hit
      hit_result = (rand(100) < hit)
      # In case of uncertain skill setting the effective flag
      effective |= hit < 100
    end
    # In case of on-target hit
    if hit_result == true
      # In case of physical attack other than power 0
      if skill.power != 0 and skill.atk_f > 0
        # State shocking cancellation
        # Note : I still can not get the states effects to work correctly
        # remove_states_shock
        # Setting the effective flag
        effective = true
      end
      # From HP damage subtraction
      last_hp = $game_party.actors[@active_actor].hp
      $game_party.actors[@active_actor].hp -= damage
      effective |= $game_party.actors[@active_actor].hp != last_hp
      # State change
      # Note : I still can not get the states effects to work correctly
      # effective |= states_plus(skill.plus_state_set)
      # effective |= states_minus(skill.minus_state_set)
      if skill.power == 0 # When power is 0
        # Set Damage to Zero
        damage = 0
      end
      hit_player(damage, skill.animation2_id)
      if $game_party.actors[@active_actor].hp <= 0
          player_dead
        end
    end
  end
  #--------------------------------------------------------------------------
  # ● Display Hit Animation
  #--------------------------------------------------------------------------
  def player_dead
    if $game_party.all_dead?
      $game_temp.gameover = true
    end
    $scene = Scene_Menu.new
  end
  #--------------------------------------------------------------------------
  # ● Display Hit Animation
  #--------------------------------------------------------------------------
  def hit_player(damage, animation_id)
    if damage != 0
      $game_player.jump(0, 0)
      $game_player.animation_id = animation_id
      @display.bitmap.clear
      @clear_counter = 0
      @display.bitmap.font.name = $defaultfonttype  # Unknown At This Time
      @display.bitmap.font.size = 32
      @display.x = ($game_player.real_x - $game_map.display_x) / 4
      @display.y = ($game_player.real_y - $game_map.display_y) / 4
      @display.z = 500
      @display.bitmap.font.color.set(255, 0, 0)
      @display.bitmap.draw_text(@display.bitmap.rect, damage.to_s, 1)
    end
  end
  #--------------------------------------------------------------------------
  # ● Calculation of attribute correction
  #    element_set : Attribute
  #--------------------------------------------------------------------------
  def event_elements_correct(element_set, event_index)
    # In case of non attribute
    if element_set == []
      # return 100
      return 100
    end
    # The weakest one is returned in the attribute which is given * method element_rate
    #  is defined in Game_Actor and the Game_Enemy class which are succeeded from this class
    weakest = -100
    for i in element_set
      # Note: I still can not get the states effects to work correctly
      weakest = [weakest, $data_enemies[@enemy_id[event_index]].element_rate(i)].max
    end
    return weakest
  end

le script continue !
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Lun 31 Déc - 18:07

Code:
#--------------------------------------------------------------------------
  # ● Player Melee Attack Preconditions
  #--------------------------------------------------------------------------
  def player_melee_preconditions
    for i in 1..@event_counter
      # Check if Event is an Enemy
      if @enemy_id[i] == 0
        next
      end
      if in_range?(i,1)
        player_melee_attack(i)
        next
      end
    end
  end
  #--------------------------------------------------------------------------
  # ● Event Melee Attack
  #--------------------------------------------------------------------------
  def player_melee_attack(event_index)
      # First on-target hit decision
      hit_rate = 100
      for i in  $game_party.actors[@active_actor].states
          hit_rate *= $data_states[i].hit_rate / 100.0
      end
      hit_result = (rand(100) < hit_rate)
      # In case of on-target hit
      if hit_result == true
        # Calculating the basic damage
        atk = [$game_party.actors[@active_actor].atk - @enemy_pdef[event_index] / 2, 0].max
        damage = atk * (20 + $game_party.actors[@active_actor].str) / 20
        # Attribute correction
        damage *= 100 #event_elements_correct($game_party.actors[@active_actor].element_set, event_index)
        damage /= 100
        # When the mark of the damage is correct
        if damage > 0
          # Critical correction
          if rand(100) < 4 * $game_party.actors[@active_actor].dex / @enemy_agi[event_index]
            damage *= 2
          end
          # Defense correction
          if @enemy_defending== true
            damage /= 2
          end
        end
        # Dispersion
        if damage.abs > 0
          amp = [damage.abs * 15 / 100, 1].max
          damage += rand(amp+1) + rand(amp+1) - amp
        end
        # Second on-target hit decision
        eva = 8 * @enemy_agi[event_index] / $game_party.actors[@active_actor].dex + @enemy_eva[event_index]
        hit = damage < 0 ? 100 : 100 - eva
        # Check evade
        cant_evade = false
        for i in @enemy_states
          if $data_states[i].cant_evade
            cant_evade = true
          end
        end
        hit = cant_evade ? 100 : hit
        hit_result = (rand(100) < hit)
      end
      # In case of on-target hit
      if hit_result == true
        # State shocking cancellation
        # Note : I still can not get the states effects to work correctly
        # remove_states_shock
        # From HP damage subtraction
        damage = damage.abs
        @enemy_hp[event_index] -= damage
        # State change
        # Note : I still can not get the states effects to work correctly
        # states_plus($game_party.actors[@active_actor].states)
        # states_minus($game_party.actors[@active_actor].states)
        hit_event(event_index,damage, $game_party.actors[@active_actor].animation2_id)
        if @enemy_hp[event_index] <= 0
          battle_spoils(event_index)
        end
      end
    end
  #--------------------------------------------------------------------------
  # ● Player Skill Attack Preconditions
  #--------------------------------------------------------------------------
  def player_skill_preconditions(index)
    if$game_party.actors[@active_actor].skill_learn?(@skill_hot_key[index])
      # Set Skill
      skill = $data_skills[@skill_hot_key[index]]
      # Check Sp Cost
      if skill.sp_cost > $game_party.actors[@active_actor].sp
        return
      end
      # Set Sp
      $game_party.actors[@active_actor].sp -= skill.sp_cost
      # Check Skills Scope
      case skill.scope
      when 1 # One Enemy
        for i in 1..@event_counter
        # Check if Event is an Enemy
          if @enemy_id[i] == 0
            next
          else
            case $data_classes[$game_party.actors[@active_actor].class_id].position
            when 0
              if in_range?(i,1)
                player_skill_attack(skill, i)
                return
              end
            when 1
              if in_range?(i,2)
                player_skill_attack(skill, i)
                return
              end
            when 2
              if in_range?(i,5)
                player_skill_attack(skill, i)
                return
              end
            end
          end
        end
      when 2 # All Emenies
        for i in 1..@event_counter
        # Check if Event is an Enemy
          if @enemy_id[i] == 0
            next
          else
            case $data_classes[$game_party.actors[@active_actor].class_id].position
            when 0
              if in_range?(i,1)
                player_skill_attack(skill, i)
                return
              end
            when 1
              if in_range?(i,2)
                player_skill_attack(skill, i)
                return
              end
            when 2
              if in_range?(i,5)
                player_skill_attack(skill, i)
                return
              end
            end
          end
        end
      when 3 # One Ally
        # Note : I still can not get the states effects to work correctly and therefore
        # can not scrïpt this but these skill can skill be actived from the Main Menu
      when 4 # All Allies
        # Note : I still can not get the states effects to work correctly and therefore
        # can not scrïpt this but these skill can skill be actived from the Main Menu
      end
    else
      return
    end
  end
  #--------------------------------------------------------------------------
  # ● Player Skill Attack
  #--------------------------------------------------------------------------
  def player_skill_attack(skill, event_index)
    # When the effective range of skill with friend of HP 1 or more, your own HP 0,
    # or the effective range of skill with the friend of HP 0, your own HP are 1 or more,
      if ((skill.scope == 3 or skill.scope == 4) and @enemy_hp == 0) or
        ((skill.scope == 5 or skill.scope == 6) and @enemy_hp >= 1)
        return
      end
    # Clearing the effective flag
    effective = false
    # When common event ID is effective, setting the effective flag
    effective |= skill.common_event_id > 0
    # First on-target hit decision
    skill_hit = 100
    for i in $game_party.actors[@active_actor].states
      skill_hit *= $data_states[i].hit_rate / 100.0
    end
    user_hit = 100
    for i in $game_party.actors[@active_actor].states
      user_hit *= $data_states[i].hit_rate / 100.0
    end
    hit = skill_hit
    if skill.atk_f > 0
      hit *= user_hit / 100
    end
    hit_result = (rand(100) < hit)
    # In case of uncertain skill setting the effective flag
    effective |= hit < 100
    # In case of on-target hit
    if hit_result == true
      # Calculating power
      power = skill.power + $game_party.actors[@active_actor].atk * skill.atk_f / 100
      if power > 0
        power -= @enemy_pdef[event_index] * skill.pdef_f / 200
        power -= @enemy_mdef[event_index] * skill.mdef_f / 200
        power = [power, 0].max
      end
      # Calculating magnification ratio
      rate = 20
      rate += ($game_party.actors[@active_actor].str * skill.str_f / 100)
      rate += ($game_party.actors[@active_actor].dex * skill.dex_f / 100)
      rate += ($game_party.actors[@active_actor].agi * skill.agi_f / 100)
      rate += ($game_party.actors[@active_actor].int * skill.int_f / 100)
      # Calculating the basic damage
      damage = power * rate / 20
      # Attribute correction
      damage *= 100 #event_elements_correct(skill.element_set, event_index)
      damage /= 100
      # When the mark of the damage is correct,
      if damage > 0
        # Defense correction
        if @enemy_defending == true
          damage /= 2
        end
      end
      # Dispersion
      if skill.variance > 0 and damage.abs > 0
        amp = [damage.abs * skill.variance / 100, 1].max
        damage += rand(amp+1) + rand(amp+1) - amp
      end
      # Second on-target hit decision
      eva = 8 * @enemy_agi[event_index] / $game_party.actors[@active_actor].dex + @enemy_eva[event_index]
      hit = damage < 0 ? 100 : 100 - eva * skill.eva_f / 100
      cant_evade = false
      for i in @enemy_states
        if $data_states[i].cant_evade
          cant_evade = true
        end
      end
      hit = cant_evade ? 100 : hit
      hit_result = (rand(100) < hit)
      # In case of uncertain skill setting the effective flag
      effective |= hit < 100
    end
    # In case of on-target hit
    if hit_result == true
      # In case of physical attack other than power 0
      if skill.power != 0 and skill.atk_f > 0
        # State shocking cancellation
        # Note : I still can not get the states effects to work correctly
        # remove_states_shock
        # Setting the effective flag
        effective = true
      end
      # From HP damage subtraction
      last_hp = @enemy_hp[event_index]
      @enemy_hp[event_index] -= damage
      effective |= @enemy_hp[event_index] != last_hp
      # State change
      # Note : I still can not get the states effects to work correctly
      # effective |= states_plus(skill.plus_state_set)
      # effective |= states_minus(skill.minus_state_set)
      if skill.power == 0 # When power is 0
        # Set Damage to Zero
        damage = 0
      end
      hit_event(event_index, damage, skill.animation2_id)
      if @enemy_hp[event_index] <= 0
            battle_spoils(event_index)
        end
      return
    end
  end
  #--------------------------------------------------------------------------
  # ● Display Hit Animation
  #--------------------------------------------------------------------------
  def hit_event(event_index, damage, animation_id)
    if damage != 0
      $game_map.events[event_index].jump(0, 0)
      $game_map.events[event_index].animation_id = animation_id
      @display.bitmap.clear
      @clear_counter = 0
      @display.bitmap.font.name = $defaultfonttype  # Unknown At This Time
      @display.bitmap.font.size = 32
      @display.x = ($game_map.events[event_index].real_x - $game_map.display_x) / 4
      @display.y = ($game_map.events[event_index].real_y - $game_map.display_y) / 4
      @display.z = 500
      @display.bitmap.font.color.set(255, 0, 0)
      @display.bitmap.draw_text(@display.bitmap.rect, damage.to_s, 1)
    end
  end
  #--------------------------------------------------------------------------
  # ● Spoils of Battle
  #--------------------------------------------------------------------------
  def battle_spoils(event_index)
    $game_map.map.events[event_index].name = "Dead"
    @enemy_id[event_index] = 0
    $game_map.events[event_index].erase
    treasures = []
    if rand(100) < @enemy_treasure_prob[event_index]
      if @enemy_item_id[event_index] > 0
        treasures.push($data_items[@enemy_item_id[event_index]])
      end
      if @enemy_weapon_id[event_index]> 0
        treasures.push($data_weapons[@enemy_weapon_id[event_index]])
      end
      if @enemy_armor_id[event_index] > 0
        treasures.push($data_armors[@enemy_armor_id[event_index]])
      end
    end
    # トレジャーの数を 6 個までに限定
    treasures = treasures[0..5]
    # EXP 獲得
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      if actor.cant_get_exp? == false
        last_level = actor.level
        actor.exp += @enemy_exp[event_index]
      end
    end
    # ゴールド獲得
    $game_party.gain_gold(@enemy_gold[event_index] )
    # トレジャー獲得
    for item in treasures
      case item
      when RPG::Item
        $game_party.gain_item(item.id, 1)
      when RPG::Weapon
        $game_party.gain_weapon(item.id, 1)
      when RPG::Armor
        $game_party.gain_armor(item.id, 1)
      end
    end
  end
end

SUITE :
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Lun 31 Déc - 18:08

Coller un script (au dessus de main)et nommer le Action Battle System1 :

Code:
#==============================================================================
# ■ Scene_Map
#------------------------------------------------------------------------------
#  It is the class which processes the title picture
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # ● Refer setup to Scene Map
  #--------------------------------------------------------------------------
  alias scene_map_main main
  alias scene_map_update update
  #--------------------------------------------------------------------------
  # ● Refers to Main
  #--------------------------------------------------------------------------
  def main
    @on_map_diplay = Window_Mapstats.new
    $ABS.display = Sprite.new
    $ABS.display.bitmap = Bitmap.new(88, 48)
    scene_map_main
    $ABS.display.dispose
    @on_map_diplay.dispose
  end
  #--------------------------------------------------------------------------
  # ● Refers to Update
  #--------------------------------------------------------------------------
  def update
    @on_map_diplay.update
    $ABS.update
    if Input.trigger?(Input::L)
      # Player Attack
      if $ABS.player_defending == false
        $ABS.player_melee_preconditions
      end
    end
    if Input.press?(Input::R)
      # Player Shield Active
      $ABS.player_defending= true
    else
      # Player Sheild Disactive
      $ABS.player_defending = false
    end
    if Input.trigger?(Input::X)
      # Player Skill Hot Key 1
      $ABS.player_skill_preconditions(1)
    end
    if Input.trigger?(Input::Y)
      # Player Skill Hot Key 2
      $ABS.player_skill_preconditions(2)
    end
    if Input.trigger?(Input::Z)
      # Player Skill Hot Key 3
      $ABS.player_skill_preconditions(3)
    end
    scene_map_update
  end
end


#==============================================================================
#  Window_Base
#------------------------------------------------------------------------------
#  Adds Draw line function, Draw Hp, Draw Sp, Draw Exp,
#  Adds Draw Actors Battler, Refines Draw Text Actors Level
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ● The drawing of HP
  #    actor : actor
  #    x    : Ahead drawing X coordinate
  #    y    : Ahead drawing Y-coordinate
  #    width : Width ahead drawing
  #--------------------------------------------------------------------------
  def draw_actor_hp_text(actor, x, y, width = 144)
    # Character string "HP" It draws
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, 32, $data_system.words.hp)
    # Calculates is a space which draws MaxHP
    if width - 32 >= 108
      hp_x = x + width - 108
      flag = true
    elsif width - 32 >= 48
      hp_x = x + width - 48
      flag = false
    end
    # Drawing HP
    self.contents.font.color = actor.hp == 0 ? knockout_color :
      actor.hp <= actor.maxhp / 4 ? crisis_color : normal_color
    self.contents.draw_text(hp_x, y, 40, 32, actor.hp.to_s, 2)
    # Drawing MaxHP
    if flag
      self.contents.font.color = normal_color
      self.contents.draw_text(hp_x + 40, y, 12, 32, "/", 1)
      self.contents.draw_text(hp_x + 52, y, 48, 32, actor.maxhp.to_s)
    end
  end
  #--------------------------------------------------------------------------
  # ● The drawing of SP
  #    actor : actor
  #    x    : Ahead drawing X coordinate
  #    y    : Ahead drawing Y-coordinate
  #    width : Width ahead drawing
  #--------------------------------------------------------------------------
  def draw_actor_sp_text(actor, x, y, width = 144)
    # Character string "sP" It draws
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 32, 32, $data_system.words.sp)
    # Calculates is a space which draws MaxSP
    if width - 32 >= 108
      sp_x = x + width - 108
      flag = true
    elsif width - 32 >= 48
      sp_x = x + width - 48
      flag = false
    end
    # Drawing HP
    self.contents.font.color = actor.sp == 0 ? knockout_color :
      actor.sp <= actor.maxsp / 4 ? crisis_color : normal_color
    self.contents.draw_text(sp_x, y, 40, 32, actor.sp.to_s, 2)
    # Drawing MaxHP
    if flag
      self.contents.font.color = normal_color
      self.contents.draw_text(sp_x + 40, y, 12, 32, "/", 1)
      self.contents.draw_text(sp_x + 52, y, 48, 32, actor.maxsp.to_s)
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Hp meter
  #--------------------------------------------------------------------------
  def draw_actor_hp_bar(actor, x, y, width = 100, height = 10, bar_color = Color.new(255, 0, 0, 255))
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    w = width * actor.hp / actor.maxhp
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Sp meter
  #--------------------------------------------------------------------------
  def draw_actor_sp_bar(actor, x, y, width = 100, height = 10, bar_color = Color.new(0, 0, 255, 255))
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    w = width * actor.sp / actor.maxsp
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Exp meter
  #--------------------------------------------------------------------------
  def draw_actor_exp_bar(actor, x, y, width = 100, height = 10, bar_color = Color.new(255, 255, 0, 255))
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    if actor.level == 99
      w = 0
    else
      w = width * actor.exp / actor.next_exp_s.to_f
    end
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Str meter
  #--------------------------------------------------------------------------
  def draw_actor_str_bar(actor, i, x, y, width = 100, height = 10, bar_color = Color.new(255, 0, 0, 255))
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    w = width * actor.str / 999
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Dex meter
  #--------------------------------------------------------------------------
  def draw_actor_dex_bar(actor, i, x, y, width = 100, height = 10, bar_color = Color.new(0, 255, 0, 255))
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    w = width * actor.dex / 999
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Agi meter
  #--------------------------------------------------------------------------
  def draw_actor_agi_bar(actor, i, x, y, width = 100, height = 10, bar_color = Color.new(0, 0, 255, 255))
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    w = width * actor.agi / 999
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Int meter
  #--------------------------------------------------------------------------
  def draw_actor_int_bar(actor, i, x, y, width = 100, height = 10, bar_color = Color.new(180, 100, 200, 255))
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    w = width * actor.int / 999
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Dash Power bar
  #--------------------------------------------------------------------------
  def draw_dash_bar(x, y, width = 50, height = 10)
    self.contents.fill_rect(x, y, width, height, Color.new(255, 255, 255, 100))
    case $ABS.dash_level
    when 0 .. 1
      bar_color = Color.new(255, 0, 0, 255)
    when 2 .. 3
      bar_color = Color.new(255, 255, 0, 255)
    else
      bar_color = Color.new(0, 255, 0, 255)
    end
    w = width * $ABS.dash_level / 5
    for i in 0..height
      r = bar_color.red  * (height -i)/height  + 0  * i/height
      g = bar_color.green * (height -i)/height  + 0 * i/height
      b = bar_color.blue  * (height -i)/height  + 0 * i/height
      a = bar_color.alpha * (height -i)/height  + 255 * i/height
      self.contents.fill_rect(x, y+i, w , 1, Color.new(r, g, b, a))
    end
  end
  #--------------------------------------------------------------------------
  # ● Draws Actors Battler
  #--------------------------------------------------------------------------
  def draw_actor_battler(actor, x, y)
      bitmap = RPG::Cache.battler(actor.character_name, actor.character_hue)
      cw = bitmap.width
      ch = bitmap.height
      src_rect = Rect.new(0, 0, cw, ch)
      self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect)
  end
end

#==============================================================================
#  ■  On Map Display
#------------------------------------------------------------------------------
#    Displayes curent player stats to the window
#=============================================================================

class Window_Mapstats < Window_Base
  #--------------------------------------------------------------------------
  # ● Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(0, 400, 640, 80)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = 20
    self.back_opacity = 125
    # self.opacity = 0
    update
  end
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    actor = $game_party.actors[$ABS.active_actor]
    draw_actor_graphic(actor, 10, 45) # draws the actor graphic
    draw_actor_name(actor, 30, -5) #draws the actors name
    draw_actor_level(actor, 30, 15) #draws the actor level
    draw_actor_hp_text(actor, 110, -5) #draws the actors hp
    draw_actor_hp_bar(actor, 260, 5)  #draws the actors hp bar
    draw_actor_sp_text(actor,110, 15) #draws the actors sp
    draw_actor_sp_bar(actor, 260, 27) #draws the actors sp bar
    draw_dash_bar(375, 27) #draws the dash level bar
    self.contents.draw_text(377, -5, 120, 32, "Dash")
  end
  #--------------------------------------------------------------------------
  # ● Update
  #--------------------------------------------------------------------------
  def update
    if Graphics.frame_count / Graphics.frame_rate != @total_sec
      refresh
    end
  end
end

#==============================================================================
# ■ Scene_Title
#------------------------------------------------------------------------------
#  It is the class which processes the title picture
#==============================================================================

class Scene_Title
  #--------------------------------------------------------------------------
  # ● Refer setup to Scene Title
  #--------------------------------------------------------------------------
  alias scene_title_update update
  #--------------------------------------------------------------------------
  # ● Loads Event names
  #--------------------------------------------------------------------------
  def update
    $ABS = Action_Battle_System.new
    scene_title_update
  end
end

#==============================================================================
# ■ Game_Map
#------------------------------------------------------------------------------
#  Add defenision of the names to Game Map Class
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # ● Refer setup to Game Map
  #--------------------------------------------------------------------------
  attr_accessor :map
  alias game_map_setup setup
  #--------------------------------------------------------------------------
  # ● Refers the Map Setup
  #--------------------------------------------------------------------------
  def setup(map_id)
    game_map_setup(map_id)
    $ABS.enemy_setup
  end
end
LE SCRIPT CONTINUE


Dernière édition par le Lun 31 Déc - 18:10, édité 1 fois
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Lun 31 Déc - 18:09

Code:

#==============================================================================
# ■ Game_Character
#------------------------------------------------------------------------------
#  Add move_type to the accessor adderse
#==============================================================================

class Game_Character
  #--------------------------------------------------------------------------
  # ● Open instance variable
  #--------------------------------------------------------------------------
  attr_accessor :move_type
  attr_accessor :move_speed
  attr_accessor :move_frequency
  attr_accessor :character_name
end

#==============================================================================
# ■ Scene_Skill
#------------------------------------------------------------------------------
#  It is the class which processes the skill picture.
#==============================================================================

class Scene_Skill
 #--------------------------------------------------------------------------
 # ● Object initialization
 #    actor_index : Actor index
 #--------------------------------------------------------------------------
 def initialize(actor_index = 0, equip_index = 0)
  @actor_index = actor_index
 end
 #--------------------------------------------------------------------------
 # ● Main processing
 #--------------------------------------------------------------------------
 def main
  # Acquiring the actor
  @actor = $game_party.actors[@actor_index]
  # Drawing up the help window, the status window and the skill window
  @help_window = Window_Help.new
  @status_window = Window_SkillStatus.new(@actor)
  @skill_window = Window_Skill.new(@actor)
  # Help window association
  @skill_window.help_window = @help_window
  # Target window compilation (invisibility non actively setting)
  @target_window = Window_Target.new
  @target_window.visible = false
  @target_window.active = false
  # Skill Hot Key Window
  @shk_window = Window_Command.new(250, ["Compétence assignée à cette touche"])
  @shk_window.visible = false
  @shk_window.active = false
  @shk_window.x = 200
  @shk_window.y = 250
  @shk_window.z = 1500
  # Transition execution
  Graphics.transition
  # Main loop
  loop do
    # Renewing the game picture
    Graphics.update
    # Updating the information of input
    Input.update
    # Frame renewal
    update
    # When the picture changes, discontinuing the loop
    if $scene != self
      break
    end
  end
  # Transition preparation
  Graphics.freeze
  # Releasing the window
  @help_window.dispose
  @status_window.dispose
  @skill_window.dispose
  @target_window.dispose
  @shk_window.dispose
 end
 #--------------------------------------------------------------------------
 # ● Frame renewal
 #--------------------------------------------------------------------------
 def update
  # Renewing the windows
  @help_window.update
  @status_window.update
  @skill_window.update
  @target_window.update
  @shk_window.update
  # When the skill window is active: Update_skill is called
  if @skill_window.active
    update_skill
    return
  end
  # When the target window is active: Update_target is called
  if @target_window.active
    update_target
    return
  end
  # When the skill_hot_key window is active: Update_shk is called
  if @shk_window.active
    update_shk
    return
  end
 end
 #--------------------------------------------------------------------------
 # ● When frame renewal (the skill window is active)
 #--------------------------------------------------------------------------
 def update_skill
  # The B when button is pushed,
  if Input.trigger?(Input::B)
    # Performing cancellation SE
    $game_system.se_play($data_system.cancel_se)
    # Change to menu screen
    $scene = Scene_Menu.new(1)
    return
  end
  # When C button is pushed,
  if Input.trigger?(Input::C)
    # Acquiring the data which presently is selected in the skill window
    @skill = @skill_window.skill
    # When you cannot use,
    if @skill == nil or not @actor.skill_can_use?(@skill.id)
      # Performing buzzer SE
      $game_system.se_play($data_system.buzzer_se)
      return
    end
    # Performing decision SE
    $game_system.se_play($data_system.decision_se)
    # When the effective range takes part,
    if @skill.scope >= 3
      # Active conversion target window
      @skill_window.active = false
      @target_window.x = (@skill_window.index + 1) % 2 * 304
      @target_window.visible = true
      @target_window.active = true
      # Setting cursor position the effective range (the single unit/the whole) according to
      if @skill.scope == 4 || @skill.scope == 6
        @target_window.index = -1
      elsif @skill.scope == 7
        @target_window.index = @actor_index - 10
      else
        @target_window.index = 0
      end
    # When the effective range is other than taking part,
    else
      # When common event ID is effective,
      if @skill.common_event_id > 0
        # Common event call reservation
        $game_temp.common_event_id = @skill.common_event_id
        # When using the skill performing SE
        $game_system.se_play(@skill.menu_se)
        #SP consumption
        @actor.sp -= @skill.sp_cost
        # Rewriting the contents of each window
        @status_window.refresh
        @skill_window.refresh
        @target_window.refresh
        # Change to map picture
        $scene = Scene_Map.new
        return
      end
    end
    return
  end
  # When X button is pushed,
  if Input.trigger?(Input::X)
    # Performing decision SE
    $game_system.se_play($data_system.decision_se)
    @skill_window.active = false
    @shk_window.active = true
    @shk_window.visible = true
    $ABS.skill_hot_key[1] = @skill_window.skill.id
  end
  #The Y when button is pushed,
  if Input.trigger?(Input::Y)
    # Performing decision SE
    $game_system.se_play($data_system.decision_se)
    @skill_window.active = false
    @shk_window.active = true
    @shk_window.visible = true
    $ABS.skill_hot_key[2] = @skill_window.skill.id
  end
  # The Z when button is pushed,
  if Input.trigger?(Input::Z)
    # Performing decision SE
    $game_system.se_play($data_system.decision_se)
    @skill_window.active = false
    @shk_window.active = true
    @shk_window.visible = true
    $ABS.skill_hot_key[3] = @skill_window.skill.id
  end
  # The R when button is pushed,
  if Input.trigger?(Input::R)
    # Performing cursor SE
    $game_system.se_play($data_system.cursor_se)
    # To the following actor
    @actor_index += 1
    @actor_index %= $game_party.actors.size
    # Change to another skill picture
    $scene = Scene_Skill.new(@actor_index)
    return
  end
  #The L when button is pushed,
  if Input.trigger?(Input::L)
    # Performing cursor SE
    $game_system.se_play($data_system.cursor_se)
    # To actor before
    @actor_index += $game_party.actors.size - 1
    @actor_index %= $game_party.actors.size
    # Change to another skill picture
    $scene = Scene_Skill.new(@actor_index)
    return
  end
 end
 #--------------------------------------------------------------------------
 # ● When frame renewal (the shk window is active)
 #--------------------------------------------------------------------------
 def update_shk
  # The C when button is pushed,
  if Input.trigger?(Input::C)
    # Performing decision SE
    $game_system.se_play($data_system.decision_se)
    # Reset Skill hot key window
    @shk_window.active = false
    @shk_window.visible = false
    @skill_window.active = true
    #Change to menu screen
    $scene = Scene_Skill.new(@actor_index)
    return
  end
 end
end

VOILA , FINI

TESTER ET MARCHE !
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Jeu 3 Jan - 18:08

mdr, rapide ^^ une démo aurait plus facile a comprendre sinon bah je l'avais déja.. lol
D'ailleurs la démo zelda que je trouve super belle est l'une des meilleurs ^^
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Jeu 3 Jan - 19:01

Quand je disais Rapide c'est pas si rapide

Au mieu de faire un looonnngg tutos avec evenement communs blabla....
La c'est un script a copier====viaannn rapidement ===== (donne l'impression d'être rapide lol) et c'est tout pas besoin d'autre chose...
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Jeu 3 Jan - 19:08

ok ^^ je me suis meme demander si c'était pas de l'ironie aussi lol
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Jeu 3 Jan - 19:39

Non sache que je suis sérieu ... défois...
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Mer 9 Jan - 21:54

Hello ninjaxp78 j'ai testé tes scripts ^^.

J'ai eu des barres au bas de l'écran donc je suppose qu'un des 2 à marché, mais pour si le script sert aussi à faire des combats au tour par tour ça n'a pas marché, comment ça se fait ?
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Mer 9 Jan - 21:58

C'est A pour frapper ...
J'ai pas trop compris se que tu dit (en faite je l'ai pas dit mais je suis pas français... Sou português! lool)
Bref
enfin quelqu'un remarque mon talent mdr

Sinon , demain j'essaierai de faire une démo
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Dim 1 Juin - 6:51

il marche comment ce script -_-
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Lun 2 Juin - 22:10

Ce qui me fait marrer c'est le "simple et rapide" ^^
Revenir en haut Aller en bas
Invité
Invité



MessageSujet: Re: A-RPG simple et rapide :)   Mer 4 Juin - 22:44

ok mais il MARCHE comment!
Revenir en haut Aller en bas
Contenu sponsorisé




MessageSujet: Re: A-RPG simple et rapide :)   

Revenir en haut Aller en bas
 
A-RPG simple et rapide :)
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» [Tuto] - Moulage rapide et simple
» Go Habs Go - Simple Plan
» Peinture rapide de 6 truks
» AVIS DE RECHERCHE !!!!! LE PASSE SIMPLE AU PASSE COMPOSE !
» Petit décor rapide pour pas cher.

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
RM-Land : le forum :: Quartier des makers :: Bibliothèque-
Sauter vers: