Pokémon Script Project Index du Forum

S’enregistrer | Rechercher | Connexion
 Information des admins 
Si vous désirez parler de PSP ou obtenir du soutient là dessus, merci d'aller faire un tour sur https://pokemonworkshop.com/forum/index.php Imbécile heureux

Concrete Encounter / Pokemon sur la map
Aller à la page: 1, 2  >
 
Poster un nouveau sujet   Répondre au sujet    Pokémon Script Project Index du Forum -> Game Making -> Ressources techniques -> Scripts
Sujet précédent :: Sujet suivant   
Auteur Message
Ku'rei
Membre


Inscrit le: 10 Aoû 2010
Messages: 546
Adepte du NoMoreExcuses
Localisation: Chambéry
Masculin

MessagePosté le: Sam 15 Juin - 07:52 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Historique des mise à jours et Sommaire
  • 15/06/13 - Création du sujet

  • 15/06/13 - Les ajouts suivants :
  • 16/06/13 - Les ajouts suivants :
  • 17/06/13 - Les ajouts suivants :
  • 18/06/13 - Les ajouts suivants :
  • 19/06/13 - Les ajouts suivants :
    Aucune modifications des script extérieurs ne sera refaites, installer une mise à jour reviens à copier.coller le script pour effacer l'ancien (attention à vos constantes) puis à aller regarder la section de la mise à jour.





    Bonjour à toutes et à tous,
    Je vous présente aujourd'hui mon script Concrete_Encounter permettant de remplacer les rencontres aléatoires normales par la présence concrète de Pokémon sur la map (RENDU, le clignotement des Pokémon en entrée de map à été corrigé, pareil pour la superposition d'un pokémon avec l'event en entrée de map). Ce script vous permettra de gagner en réalisme et en charisme, vos maps se rempliront d'elles-mêmes :


    Installation


    Prérequis :


    Une fois l'Event_Copier installé et les chara mis dans le dossiers appropriés (ne renommez pas les chara), l'installation de ce script peut commencer.

    Copier coller le code suivant dans un nouveau script au dessus de Main appelé Concrete_Encounter (en-dessous de Event_Copier par exemple)
    Code:

    #=============================================================================== 
    # -- Concrete_encounter  --  13/06//13  -- 
    #   Script from Ku'rei Jinwu 
    # CREDIT IF USED - CREDITS OBLIGATOIRES 
    #=============================================================================== 
    #                               --- ENGLISH --- 
    # = Installation = 
    #   1. Copy this script in a new script over Main, call it "Concrete_Encounter" 
    #   2. In Scene_Map script at line 103 roughly, replace : 
    # -> if $game_player.encounter_count == 0 and $game_map.encounter_list != [] 
    #      by : 
    # -> if Kurei::NORMAL_ENCOUNTER_ON and $game_player.encounter_count == 0 and $game_map.encounter_list != [] 
    #   3. In Scene_Map script at line 212 right after the bloc we had modify in 2. insert : 
    # -> if Kurei::CONCRETE_ENCOUNTER_ON 
    # ->      $concrete_encounter.place_monsters() 
    # -> end 
    #   4. In Scene_Title script at line 31 right after global variables declarations, insert 
    # -> $concrete_encounter = Kurei::Concrete_Encounter.new 


    # = Installation for Pokemon Script Project = 
    #   1. Copy this script in a new script over Main, call it "Concrete_Encounter" 
    #   2. In Krosk's Scene_Map at line 97 roughly, replace : 
    # -> if $random_encounter != [0] and $game_player.encounter_count == 0 
    #   by 
    # -> if Kurei::NORMAL_ENCOUNTER_ON and $random_encounter != [0] and $game_player.encounter_count == 0 
    #   3. In the same script at line 109 right after the last bloc, insert : 
    # -> if Kurei::CONCRETE_ENCOUNTER_ON 
    # ->   $concrete_encounter.place_monsters 
    # -> end 
    #   4. In Krosk's Scene_Title at line 20 roughly, right after $BTEST bloc 
    # -> $concrete_encounter = Kurei::Concrete_Encounter.new 
    #   5. In Krosk's Pokemon_Battle_Wild at line 61, set the line in commentaire 
    # -> #@enemy.hp = @enemy.max_hp 


    # = How to use this script = 
    #   1. Create a new map calling lilke you want and remember its ID 
    #       It will use to copy Pokemon Event 
    #   2. Create ONE event you call STANDARD_POKEMON_EVENT and start battle with one 
    #       pkm, it doesn't matter. script(demarrer_combat) 
    #   3. Create yours troops with the same method as PSP 
    #   4. Look at the beginning of the script and correct Constants value 
    #       MONSTERS_STOCKAGE_MAP_ID : index of pokemon_events stockage 
    #       CONCRETE_ENCOUNTER_ON : Enable concrete encounter 
    #       NORMAL_ENCOUNTER_ON : enable normal system of encounting

    #   Level Offset is define by the first troop present in the list (see map properties) 
    #=============================================================================== 
    module Kurei
      #===============================================================================
      # Classe handling the interface between Kurei module's constants and the maker
      # actually, it allow the maker to modfify constants (this is the idea)
     
      # true => concrete_encounter are enabled 
      CONCRETE_ENCOUNTER_ON = true 
       
      # true => normal_encounter are enabled 
      NORMAL_ENCOUNTER_ON = false 
     
      # Enable the STANDARDS 
      USE_STANDARDS = true
     
      # True if you want to event persist after leaving map 
      USE_PERSISTENCE = true
     
      # true => pkm are persistent 
      USE_POKEMON_PERSISTENCE = true
     
      # Enable the Terrain Tag Probailty Coefficient
      USE_T2PC = true
     
      #Enable the Tileset Terrain Tag Probability Coefficient
      USE_T3PC = true
     
      #When you enter the map, Pokemon event are repalce at their intiales places
      # It doesn't work for Travellers
      USE_REPLACEMENT = true
         
      # If false, Event are invisible if they are in water so   
      # it's the same as normal encounter, just on water 
      VISIBLE_ON_WATER = true 
       
      # True if all event are persistent 
      ALL_ARE_PERSISTENT = true 
       
      # True => the first time you enter in map, the count of pokemon event will be saved 
      #  and used to complete map population when player kill someone 
      AUTO_REGENATE_POPULATION = true
     
      #Index of game switche to say "hello i'm gonna run when you fight me !"
      FUGITIVE_SWITCH_ID = 4975
     
      #Name of standard 
      STANDARD_POKEMON_EVENT_NAME = "STANDARD_POKEMON_EVENT" 
       
        # Index of map containing Monsters Events 
      MONSTERS_STOCKAGE_MAP_ID = 16 
       
      #Local Rarity by default 
      DEFAULT_LOCAL_RARITY = 25 
       
      #Game variable ID where is stock the id of next pokemonbttled 
      BTL_PKM_ID_VAR_ID = 4993 
       
      #Game varaible ID where is stock the level of next pokemon battled 
      BTL_PKM_LVL_VAR_ID = 4992 
       
      #Random base (step_encounter/Ramdom_Base)% chances to have Pokemon on case 
      RANDOM_SPAWNING_BASE = 150 
     
         
      #Character name's start 
      CHARA_NAME_START = "Pkm "   
       
      #Word indicate if the event is persistent 
      PERSISTENCE_WORD = "PERSIST" 
       
      #Word indicate the battle start here 
      BATTLE_START_WORD = "START_BATTLE" 
       
      # Key word to change the map (ONLY for Traveller) 
      CHANGE_MAP_WORD = "CHANGE_MAP"

      # Key word to delete the event 
      REMOVE_WORD = "DELETE_EVENT"
     
      # Key Word to make the Pokémon no sensible to the Reject Effect
      REJECT_INSENSITIVE_WORD = "NOT REJECTABLE"
     
      # Key word to make event deplacement different if condition is checked
      # COND_DEPL=["condition", no_page]
      # Expl : prendre le mouvement de la page 2 si hero à moins de 500u
      # COND_DEPL=["hero_close(500)", 2]
      CONDITIONNAL_DEPLACEMENT_WORD = "COND_DEPL"
     
      #Correspondances of standards
      #nom du standard:
      # Nom de l'évent
      #Ou, pour un standard valid sur certaines map seulement
      # [map_1, map_2, map_3, ...]/Nom de l'évent
      #NE PAS UTILISER "/" Dans le nom d'évent
      #Structure
      # keys : [id_pkm, id_pkm2, ...] => "STANDARD_NAME"
      STANDARDS = { 
        "STANDARD_AGGRO" => [111, 112, 208],  #Rhinocorne, Rhinoferos, Steelix
        "STANDARD_STATIC" => [79],            #Ramoloss
        "STANDARD_TRAVELLER" => [380, 381],    #LATIAS, LATIOS
      }
     
      #Correspondances pkm_id => nb_form
      RANDOM_FORMS = {
        201 => 28   #Zarbi 28 formes aléatoires
      }
     
      # List of tag terrain probability coefficient
      # The more the T2PC is important, the less there are Pokémon on the terrain tag
      # Use 1 if the probability on the tag is normal
      # [mult_tag_1, mutl_tag_2, mult_tag_3, mult_tag_4, mult_tag_5, mult_tag_6, mult_tag_7]
      T2PC = [1, 1, 1, 1, 1, 1, 1]
     
      # Dictionnary<tileset_name, T2PC>
      T3PC = {
        1 => [1, 1.5, 1, 1, 1, 1, 1.5],
      } 
       
      # Do not touch 
      VAR_BATTTLE_START_NAME = "demarrer_combat_var" 
      VAR_CHANGE_MAP_NAME = "change_map_traveller_var" 
      VAR_REMOVE_NAME = "remove_event_from_concrete_encounter_var" 
      VAR_EXISTING_BATTLE_NAME = "cE_demarrer_existing_battle_var"
      DISPLAY_ERROR = false 
     
      class Kurei_Config_Panel
        attr_accessor :config_values #{string, constant_name => value}
       
        #Initialize the dynamic panel
        def initialize
          @config_values = {}
          @config_values["STANDARD_POKEMON_EVENT_NAME"] = STANDARD_POKEMON_EVENT_NAME
          @config_values["STANDARDS"] = STANDARDS
          @config_values["MONSTERS_STOCKAGE_MAP_ID"] = MONSTERS_STOCKAGE_MAP_ID
          @config_values["CONCRETE_ENCOUNTER_ON"] = CONCRETE_ENCOUNTER_ON
          @config_values["NORMAL_ENCOUNTER_ON"] = NORMAL_ENCOUNTER_ON
          @config_values["DEFAULT_LOCAL_RARITY"] = DEFAULT_LOCAL_RARITY
          @config_values["BTL_PKM_ID_VAR_ID"] = BTL_PKM_ID_VAR_ID
          @config_values["BTL_PKM_LVL_VAR_ID"] = BTL_PKM_LVL_VAR_ID
          @config_values["RANDOM_SPAWNING_BASE"] = RANDOM_SPAWNING_BASE
          @config_values["USE_STANDARDS"] = USE_STANDARDS
          @config_values["CHARA_NAME_START"] = CHARA_NAME_START
          @config_values["VISIBLE_ON_WATER"] = VISIBLE_ON_WATER
          @config_values["USE_PERSISTENCE"] = USE_PERSISTENCE
          @config_values["ALL_ARE_PERSISTENT"] = ALL_ARE_PERSISTENT
          @config_values["AUTO_REGENATE_POPULATION"] = AUTO_REGENATE_POPULATION
          @config_values["PERSISTENCE_WORD"] = PERSISTENCE_WORD
          @config_values["BATTLE_START_WORD"] = BATTLE_START_WORD
          @config_values["USE_POKEMON_PERSISTENCE"] = USE_POKEMON_PERSISTENCE
          @config_values["CHANGE_MAP_WORD"] = CHANGE_MAP_WORD
          @config_values["REMOVE_WORD"] = REMOVE_WORD
          @config_values["RANDOM_FORMS"] = RANDOM_FORMS
          @config_values["USE_T3PC"] = USE_T3PC
          @config_values["USE_T2PC"] = USE_T2PC
          @config_values["T2PC"] = T2PC
          @config_values["T3PC"] = T3PC
          @config_values["USE_REPLACEMENT"] = USE_REPLACEMENT
          @config_values["FUGITIVE_SWITCH_ID"] = FUGITIVE_SWITCH_ID
        end
       
        # Return the value of constant
        def [](key)
          return @config_values[key]
        end
       
        #Change constant value
        def []=(key, value)
          @config_values[key] = value
        end
      end
     
      class Concrete_Encounter
        #Create the Concrete_Encounter
        def initialize
          $kurei_panel = Kurei_Config_Panel.new
           
          @pokemon_traveller = {} # map_id => [Traveller_Pokemon]
          @event_to_traveller = {} #event => Traveller
          @travellers_event = []
         
          @persist_data = {} #map_id => [count, event, event, event, ...]
          @pokemons = {}  # id => Pokemon
         
          @event_infos = {} #Event => Event_Pokemon_Info
        end
       
        # RETURN : int, index of encounter in $data_map.encounter_list 
        def get_encounter_id() 
          if $data_map.encounter_list != [] 
            return 0 
          else 
            return nil 
          end 
        end 
         
        # Get the event_spec of monster 
        # REURN : int, event_spec 
        def get_enemy_id(terrain_tag = -1) 
          step = rand(@corres_tag_rarities[terrain_tag][0]) 
           
          # Obtention of enemy_id 
          rarity_id = get_enemy_id_by_rarity(terrain_tag, step) 
          @last_corres_id = rarity_id -1 
          enemy_id = @corres_tag_troops[terrain_tag][@last_corres_id] 
           
          return enemy_id 
        end 
         
        def get_enemy_id_by_rarity(terrain_tag, step) 
          sum = 0 
          id = 1 
          for i in 1...@corres_tag_rarities[terrain_tag].length 
            sum+=@corres_tag_rarities[terrain_tag][i] 
            if sum > step 
              id = i 
              break 
            end 
          end 
          return id 
        end 
         
        # Get random enemy_id in the given troop 
        # RETURN : int, enemy_id in DB 
        def get_random_enemy_id_in_troop(terrain_tag) 
          i = rand(@corres_tag_troops[terrain_tag].length) 
          enemy_id = @corres_tag_troops[terrain_tag][i] 
          return enemy_id 
        end 
         
        # use @last_corres_id to find the base level 
        # RETURN : int, base level 
        def get_enemy_level(t_tag) 
     
          return @corres_tag_level[t_tag][@last_corres_id] 
        end 
         
        # Test if coords are valid in map and if they aren't already used 
        # coords : int[2], coordinates tested (form : [x, y]) 
        # RETURN : bool, result of the test 
        def is_valid_coords(coords, terrain_tag = -1) 
          if terrain_tag >=0 and $game_map.terrain_tag(coords[0], coords[1]) != terrain_tag 
            return false 
          end 
           
          if not $game_map.passable?(coords[0], coords[1], 0) 
            return false 
          end 
           
          if $game_map.check_event(coords[0], coords[1]) != nil 
            return false 
          end 
           
          if $game_player.x == coords[0] and $game_player.y == coords[1] 
            return false 
          end 
           
          return true 
        end
       
        def is_valid_tag_coords(coords = [0, 0], tags = nil)
          if tags == nil
            return is_valid_coords(coords)
          else
            for tag in tags
              if is_valid_coords(coords, tag)
                return true
              end
            end
            return false
          end
        end
       
        #Determinate if the placement is ok.
        # tag : int, num of terrain tag, use for T2CP
        def random_placement_validation(tag = -1)
          r = rand($kurei_panel["RANDOM_SPAWNING_BASE"])
          s = $game_map.encounter_step
         
          coef = nil
          if $kurei_panel["USE_T3PC"]
            if  @tileset_id != 0 and tag > 0 and tag < 8
              if T3PC[@tileset_id] != nil
                coef = $kurei_panel["T3PC"][@tileset_id][tag-1]
              else
                coef = $kurei_panel["T2PC"][tag-1]
              end
            end
          elsif $kurei_panel["USE_T2PC"] and not $kurei_panel["USE_T3PC"]
            if tag > 0 and tag < 8
              coef = $kurei_panel["T2PC"][tag-1]
            end
          end
         
          if coef != nil
            r *= coef
          end
         
          if r <= s
            return true
          end
          return false
        end
         
        #RETURN : [dictionnary<int, List<int>>,dictionnary<int, List<int>>, int],   
        # coorespondance entre les terrains et les enemy_id possible, entre terrain et raretés locale 
        # et écrat de niveaux 
        def create_corres_tag_troops 
          c = {} 
          for troop_id in $game_map.encounter_list 
            troop = $data_troops[troop_id] 
            tag = troop.name[0].to_i - 48 
            if c[tag] == nil 
              c[tag] = [] 
            end 
            c[tag] = add_members_id(c[tag], troop.members) 
          end 
          return c 
        end 
         
        # Add members' ids list at the array and return it 
        def add_members_id(arr, members) 
          for m in members 
            arr.push(m.enemy_id) 
          end 
          return arr 
        end 
         
        # Define local rarities 
        # RETURN dictionnary<int, List<int>>, tag => rarities in the same order than 
        #                                   tag_troops correspondences 
        def create_corres_tag_rarities 
          r = {} 
          for troop_id in $game_map.encounter_list 
            troop = $data_troops[troop_id] 
             
            tag = troop.name[0].to_i-48 
            if r[tag] == nil 
              r[tag] = [0] 
            end 
             
            for i in 1...$data_encounter[troop_id][2].length 
              data = $data_encounter[troop_id][2][i] #[id_pkm, nv, rarity] 
               
              d = data[2].to_i 
              if d == 0 
                d = $kurei_panel["DEFAULT_LOCAL_RARITY"]
              end 
              r[tag].push(d) 
              r[tag][0]+=d 
            end 
          end 
          return r 
        end 
         
        #Define local level 
        # RETURN dictionnary<int, List<int>>, tag => levels in the same order than 
        #                                   tag_troops correspondences 
        def create_corres_tag_level 
          l = {} 
          for troop_id in $game_map.encounter_list 
            troop = $data_troops[troop_id] 
             
            tag = troop.name[0].to_i-48 
            if l[tag] == nil 
              l[tag] = [] 
            end 
             
            for i in 1...$data_encounter[troop_id][2].length 
              data = $data_encounter[troop_id][2][i] #[id_pkm, nv, rarity] 
               
              d = data[1].to_i 
              if d == 0 
                d = 1 
              end 
              l[tag].push(d) 
            end 
          end 
          return l 
        end 
         
         
        #Remove the event from the persistence memory 
        # event : Game_Event, event will be removed 
        def remove_event_from_persist(event) 
          @persist_data[event.map_id].delete(event) 
        end 
         
        #Change number of pokémon in the current map 
        # Use persistence OBLIGATORY 
        # count : nombre de pokemon 
        def change_count_of_pkm_in_map(count) 
          if $kurei_panel["USE_PERSISTENCE"]
            @persist_data[$game_map.map_id][0] = count 
          end 
        end 
     
        #=========================================================================== 
        # TRAVELLERS 
         
        #Create and add to Concrete_Encounter 
        # pkm_id : int, id of Pokemon 
        # lvl : int, level of the Pokemon 
        # pkm_name : string, name of traveller (maybe there are two same traveller...) 
        # maps : List<int>, list of index of maps where we can see this Pokemon 
        # tags : List<int>, list of terrain tags where we can see this Pokemon 
        # map_id : int, index of map will the traveller begin. Current map id by default 
        def add_traveler_pokemon(pkm_id, lvl, slot, maps, tags, map_id = $game_map.map_id) 
          traveller = Traveller_Pokemon.new(pkm_id, lvl, slot, maps, tags) 
          if @pokemon_traveller[map_id] == nil 
            @pokemon_traveller[map_id] = [] 
          end 
          @pokemon_traveller[map_id].push(traveller) 
         
          id = search_new_pkm_stock_id
          @pokemons[id] = traveller.pokemon
          traveller.pokemon_stock_id= id
        end 
         
        #Delete the traveller data 
        # traveller : Traveller_Pokemon, trav to delete 
        def remove_traveller(traveller) 
          for k in @pokemon_traveller.keys 
            if @pokemon_traveller[k].include?(traveller) 
              @pokemon_traveller[k].delete(traveller) 
            end 
          end 
        end 
         
        #Change the map where traveller appear 
        # traveller : Traveller_Pokemon, traveller to move 
        # new_map_id : int, index of map where traveller appears 
        def change_map_traveller(traveller, new_map_id) 
          remove_traveller(traveller) 
          if @pokemon_traveller[new_map_id] == nil 
            @pokemon_traveller[new_map_id] = [] 
          end 
          @pokemon_traveller[new_map_id].push(traveller) 
        end 
         
        #Search traveller with his name 
        # name : string, name of traveller 
        # RETURN : Traveller_Pokemon, traveller wanted OR nil 
        def get_traveller_by_slot(slot) 
          for map_id in @pokemon_traveller.keys 
            for t in @pokemon_traveller[map_id] 
              if t.slot == slot 
                return t 
              end 
            end 
          end 
          return nil 
        end 
         
        #Define random coords in map  near of given coorinantes
        # tags : List<int>, list of avaible tags 
        def get_random_coords(tags = [1])
          return get_nearest_valid_coords(tags, rand($game_map.width), rand($game_map.height))
        end
         
        #Return the nearest valid coords from the given coords
        # tags : List<int>, list of valid tags
        # sx, sy : int, source coordinate
        # step_max : int, max step of search,
        #             used to fix the infinite loop in case of no valid coords on map
        #             in this case, result is [sx, sy]
        def get_nearest_valid_coords(tags = [1], sx = $game_map.width/2, sy = $game_map.height/2, step_max = 30)
          x = Integer(sx)
          y = Integer(sy)
         
          dir = 6
          s = 1
          pair = false
          #Until we found valid coordinate
          while not is_valid_tag_coords([x, y], tags) and s <= step_max
            i = 0 #step counter
            while i < s and not is_valid_tag_coords([x, y], tags)
              #Update coordinate
              dx = 0
              dy = 0
              case dir
              when 2
                dy = -1
              when 4
                dx = 1
              when 6
                dx = -1
              when 8
                dy = 1
              end
              x += dx
              y += dy
             
             
              if x >= $game_map.width
                x = $game_map.width
              elsif x < 0
                x = 0
              end
             
              if y >= $game_map.height
                y = $game_map.height
              elsif y < 0
                y = 0
              end
             
              i += 1
            end
           
           
            #Update Direction
            case dir
            when 2
              dir = 6
            when 4
              dir = 2
            when 6
              dir = 8
            when 8
              dir = 4
            end
            #step_update
            if pair
              s += 1
            end
            pair = !(pair)
          end
         
          if  s >= step_max
            print("ERREUR : Vous essayer de trouver des terrains portant les tags #{tags.inspect} sur la map #{$game_map.map_id}.")
            return [sx, sy]
          end
          coords = [x, y] 
          return coords 
        end
         
        #Search traveller and say if the given slot contain a traveller 
        def existing_traveller?(slot) 
          return get_traveller_by_slot(slot) != nil 
        end 
         
        #=========================================================================== 
        # Pokemon Persistence 
         
        # Return the own pokemon 
        # id : int, index of pokemon in @pokemons 
        def get_pokemon(id) 
          return @pokemons[id] 
        end 
         
        #Search the stock_id of the given pokemon 
        # pokemon : POKEMON_S::Pokemon, Pkm you want stock_id 
        def get_pokemon_stock_id(pokemon) 
          for k in @pokemons.keys 
            if @pokemons[k] == pokemon 
              return k 
            end 
          end 
        end 
         
        #Remove pokemon from data list 
        def remove_pokemon(pokemon) 
          for k in @pokemons.keys 
            if @pokemons[k] == pokemon 
              @pokemons.delete(k) 
            end 
          end 
        end 
         
        #Search an empty case for the pokemon 
        def search_new_pkm_stock_id 
          i = 0 
          while @pokemons[i] != nil 
            i+=1 
          end 
          return i 
        end 
         
        #remove dead pokemon from @pokemons 
        def refresh_pokemon_list 
          for k in @pokemons.keys 
            if @pokemons[k].dead? 
              @pokemons.delete(k) 
            end 
          end 
        end 
       
        #Calculate the form of pokémon, if its is random
        def get_random_form(id)
          if $kurei_panel["RANDOM_FORMS"][id] == nil
            return nil
          end
         
          form = rand($kurei_panel["RANDOM_FORMS"][id])+1
          return form
        end
       
        #===========================================================================
        # Method for conditionnal deplacement
        #
       
        #Calcul the distance from hero and return the comparaison with raidus
        # radius : int, distance from hero to be true
        def hero_close(radius = 500)
          return $game_system.map_interpreter.distance_to_hero(@tested_event) < radius
        end
       
        #=========================================================================== 
        # Automatic event handling 
         
        #Create a list of event of pokemon from the event whose named : STANDARD_POKEMON_EVENT 
        # RETURN : List<Game_Event> 
        def create_event_list 
          event_list = [] 
          if $kurei_panel["USE_PERSISTENCE"] 
            if @persist_data[$game_map.map_id] != nil 
              event_list = @persist_data[$game_map.map_id][1...@persist_data[$game_map.map_id].length] 
              if not $kurei_panel["AUTO_REGENATE_POPULATION"]
                return event_list 
              end 
            end 
          end 
           
          @level_offset = $data_encounter[$game_map.encounter_list[0]][2][0] 
          @corres_tag_troops = create_corres_tag_troops 
          @corres_tag_rarities = create_corres_tag_rarities 
          @corres_tag_level = create_corres_tag_level 
           
          for x in 0...$game_map.width 
            for y in 0...$game_map.height 
              tag = $game_map.terrain_tag(x, y) 
              if @corres_tag_troops[tag] != nil 
                if is_valid_coords([x, y]) 
                  if random_placement_validation(tag) 
                    event = nil 
                    id = get_enemy_id(tag) 
                    lvl = [100, get_enemy_level(tag) + rand(@level_offset) .to_i].min
                    pkm = POKEMON_S::Pokemon.new(id, lvl) 
                    c = false #Indiate event creation 
                    if $kurei_panel["USE_PERSISTENCE"] and @persist_data[$game_map.map_id] != nil 
                      if event_list.length < @persist_data[$game_map.map_id][0] 
                        c = true 
                      end 
                    else 
                      c = true 
                    end 
                    if c 
                      if $kurei_panel["USE_POKEMON_PERSISTENCE"]
                        stock_id = search_new_pkm_stock_id
                        @pokemons[stock_id] = pkm
                        event = create_event_from(x, y, tag, id, lvl, pkm) 
                        @event_infos[event].pokemon_stock_id = stock_id
                      else 
                        event = create_event_from(x, y, tag, id, lvl) 
                      end 
                    end 
                    if event != nil 
                      event_list.push(event) 
                    end 
                  end 
                end 
              end 
            end 
          end 
           
          if $kurei_panel["USE_PERSISTENCE"]
            if $kurei_panel["ALL_ARE_PERSISTENT"]
              if @persist_data[$game_map.map_id] == nil 
                l = event_list.length 
              else 
                l = @persist_data[$game_map.map_id][0] 
              end 
              list = event_list[0...l] 
            else 
              list = [] 
              for e in event_list 
                if e.event.pages[0].list[0].parameters[0] == PERSISTENCE_WORD 
                  list.push(e) 
                end 
              end 
            end 
            @persist_data[$game_map.map_id] = [event_list.length]+ list 
          end 
           
          return event_list 
        end 
         
        # Craete a random pokemon event from the standard given event 
        # standard : Game_Event, model, base of the new event 
        # x,y : int, coordinate in the map 
        def create_event_from(x, y, terrain_tag, id, lvl, pokemon = nil, traveller_slot = nil, traveller = nil) 
          standard = get_standard(id) 
           
          event = @copier.get_full_clone(standard) 
          event = @copier.calibrate_event(event, x, y) 
         
          event_pokemon_info = Event_Pokemon_Info.new
           
          if traveller_slot != nil 
            change_map_script = "change_map_traveller_var" 
          end 
           
          if pokemon == nil 
            start_battle = VAR_BATTTLE_START_NAME 
          else 
            start_battle = VAR_EXISTING_BATTLE_NAME
            pokemon.form = get_random_form(pokemon.id)
          end
         
          if $kurei_panel["USE_REPLACEMENT"]
              event_pokemon_info.origin_x = x
              event_pokemon_info.origin_y = y
          end
           
          ids = ("000" + id.to_s) 
          ids = ids[ids.length-3..ids.length-1    ]   
           
          charac_name = $kurei_panel["CHARA_NAME_START"] + ids
          if pokemon != nil
            charac_name += pokemon.battler_form
          end
           
          freq_word = "FREQUENCY=" 
          rap_word = "SPEED=" 
           
          #Param Event 
          for p in 0...event.event.pages.length 
            page = event.event.pages[p] 
            new_list = [] 
            for c in page.list 
              new_list.push(c) 
              if c.code == 355 and c.parameters[0].include?("demarrer_combat") 
                c.parameters[0] = script 
              end 
              if page.graphic.character_name.include?($kurei_panel["CHARA_NAME_START"]) 
                if (terrain_tag == 7 and $kurei_panel["VISIBLE_ON_WATER"]) or terrain_tag != 7 
                  page.graphic.character_name = charac_name 
                end   
                if terrain_tag == 7 and not $kurei_panel["VISIBLE_ON_WATER"] 
                  page.graphic.character_name = "" 
                end 
              end 
              #Alt battle start 
              # Comment with START_BATTLE 
              if c.code == 108 and c.parameters[0].include?(BATTLE_START_WORD) 
                if pokemon == nil 
                  new_list.push(RPG::EventCommand.new(122, c.indent, [$kurei_panel["BTL_PKM_ID_VAR_ID"], $kurei_panel["BTL_PKM_ID_VAR_ID"], 0, 0, id])) 
                  new_list.push(RPG::EventCommand.new(122, c.indent, [$kurei_panel["BTL_PKM_LVL_VAR_ID"], $kurei_panel["BTL_PKM_LVL_VAR_ID"], 0, 0, lvl])) 
                  new_list.push(RPG::EventCommand.new(355, c.indent, [start_battle])) 
                else 
                  stock_id = get_pokemon_stock_id(pokemon) 
                  new_list.push(RPG::EventCommand.new(122, c.indent, [$kurei_panel["BTL_PKM_ID_VAR_ID"], $kurei_panel["BTL_PKM_ID_VAR_ID"], 0, 0, stock_id])) 
                  new_list.push(RPG::EventCommand.new(355, c.indent, [start_battle])) 
                end 
              end 
                 
              #Modifying Frequency 
              # FREQUENCY= 
              if c.code == 108 and c.parameters[0][0,freq_word.length] == freq_word 
                s = c.parameters[0][freq_word.length...c.parameters[0].length] 
                r = rand(s[2]-s[0])+s[0]-48 
                page.move_frequency = r 
              end 
               
              #Modifying Rapidity 
              # RAPIDITY= 
              if c.code == 108 and c.parameters[0][0,rap_word.length] == rap_word 
                s = c.parameters[0][rap_word.length...c.parameters[0].length] 
                r = rand(s[2]-s[0])+s[0]-48 
                page.move_speed = r 
              end 
               
              # Changing map 
              if traveller_slot != nil and c.code == 108 and c.parameters[0] == CHANGE_MAP_WORD 
                new_list.push(RPG::EventCommand.new(122, c.indent, [$kurei_panel["BTL_PKM_ID_VAR_ID"], $kurei_panel["BTL_PKM_ID_VAR_ID"], 0, 0, traveller_slot])) 
                new_list.push(RPG::EventCommand.new(122, c.indent, [$kurei_panel["BTL_PKM_LVL_VAR_ID"], $kurei_panel["BTL_PKM_LVL_VAR_ID"], 0, 0, $game_map.map_id])) 
                new_list.push(RPG::EventCommand.new(355, c.indent, [VAR_CHANGE_MAP_NAME])) 
              end 
               
              # Delete event 
              if c.code == 108 and c.parameters[0] == REMOVE_WORD 
                new_list.push(RPG::EventCommand.new(122, c.indent, [$kurei_panel["BTL_PKM_ID_VAR_ID"], $kurei_panel["BTL_PKM_ID_VAR_ID"], 0, 0, traveller_slot])) 
                new_list.push.push(RPG::EventCommand.new(355, c.indent, [VAR_REMOVE_NAME])) 
              end 
             
              # Insensitive to reject
              if c.code == 108 and c.parameters[0] == REJECT_INSENSITIVE_WORD
                event_pokemon_info.sensitive_to_reject = false
              end
             
              # CONDITIONNAL_DEPLACEMENT
              if c.code == 108 and c.parameters[0].include?(CONDITIONNAL_DEPLACEMENT_WORD)
                values = eval(c.parameters[0].split('=')[1])
               
                param = []
                for i in 1...values.length
                  param.push(values[i])
                end
                event_pokemon_info.cond_depl[values[0]] = param
              end
            end 
             
            page.list = new_list 
          end 
         
          if traveller == nil
            @event_infos[event] = event_pokemon_info
          else
            traveller.event_pokemon_info= event_pokemon_info
          end
          return event 
        end 
         
        # Calcul the stanrd of the given id 
        # id : int, id of the pokemon 
        def get_standard(id)
          std_name = STANDARD_POKEMON_EVENT_NAME
         
          valid_std_list = []
          for k in $kurei_panel["STANDARDS"].keys 
            if $kurei_panel["STANDARDS"][k].include?(id)
              valid_std_list.push(k)
            end 
          end
         
          if valid_std_list != []
            general_name = "" #Nom général du standard (si on ne trouve pas de spécification
            new_name = ""
            for full_name in valid_std_list
              s = full_name.split('/')
              if s.length > 1
                arr = eval(s[0])
                if arr.include?($game_map.map_id)
                  new_name = s[1]
                end
              else
                general_name = full_name
              end
            end
            if new_name != ""
              std_name = new_name
            elsif general_name != ""
              std_name = general_name
            end
          end
         
          standard = @copier.get_event_by_name(std_name)
          return standard 
        end
       
        #=========================================================================== 
        # Public usefull methods 
     
        # Place Monster on Map if the map_id id different to last map id 
        def place_monsters()
          if @last_map_id != $game_map.map_id
            @event_to_traveller.clear
            refresh_pokemon_list
           
            if $kurei_panel["USE_T3PC"]
              @tileset_id = $game_map.tileset_id
            end
           
            if $game_map.encounter_list != [] 
              if @copier == nil 
                @copier = Kurei::Event_Copier.new($kurei_panel["MONSTERS_STOCKAGE_MAP_ID"]) 
              end
              @event_list = create_event_list
              @copier.place_event_list(@event_list)
            end 
            if @pokemon_traveller[$game_map.map_id] != nil 
              for traveller in @pokemon_traveller[$game_map.map_id]
                coords = get_random_coords(traveller.tags)
                if traveller.starting_point != nil
                  if traveller.starting_point[$game_map.map_id] != []
                    coords = traveller.starting_point[$game_map.map_id]
                  end
                end
                 
             
                 
                event = create_event_from(coords[0], coords[1],   
                  $game_map.terrain_tag(coords[0], coords[1]),   
                  traveller.id, traveller.level,   
                  traveller.pokemon, traveller.slot, traveller) 
                @copier.place_event(event)
                @event_to_traveller[event] = traveller
              end 
            end
           
            #Reinit the Event Place
            if $kurei_panel["USE_REPLACEMENT"] and @event_list != nil
              for event in @event_list
                event.moveto(@event_infos[event].origin_x, @event_infos[event].origin_y)
              end
            end
          end
          update_events(@event_list)
          @last_map_id = $game_map.map_id 
        end
       
        #Update event
        #fonctionnalities
        #  - Reject Effect / Repousse
        def update_events(event_list)
          if event_list == nil
            return
          end
         
          flee_route = RPG::MoveRoute.new
          flee_route.skippable = true
          flee_route.repeat  = true
          flee_route.list.insert(0, RPG::MoveCommand.new(11))
         
          for event in event_list
            update_lonely_event(event, flee_route, @event_infos[event])
          end
         
          for event in @event_to_traveller.keys
            update_lonely_event(event, flee_route, @event_to_traveller[event].event_pokemon_info)
          end
        end
       
        # Update the given event
        def update_lonely_event(event, flee_route, event_pokemon_info)
          # INitialize and decompress param
          @tested_event = event
          reset = false
           
          #RejectChecking
          #Reject need USE_POKEMON_PERSISTENCE
          # state_code = 1
          # state_param = [normal_page]
          if event_pokemon_info.state_code == 0 and rejected?(event, event_pokemon_info)
            if event_pokemon_info.state_param == []
              page_id = -1+ event.event.pages.length
              save_route(event, page_id, event_pokemon_info)
             
              page = event.event.pages[page_id].dup
              page.move_frequency = 6
              page.move_speed += 1
              if (page.move_speed == 7)
                page.move_speed = 6
              end
              page.move_type = 3
              page.move_route = flee_route
              event.event.pages[page_id] = page
              event_pokemon_info.state_code = 1
            end
          elsif event_pokemon_info.state_code == 1 and not rejected?(event, event_pokemon_info)
            reset = true
          end

          #Conditionnal Deplacement
          # state_code = 2
          # state_param = [normal_page, move_condition,
          #                         [conserve_mt, conserve_me, conserve_ms, conserve_mf]]
          depl = nil
          move_changed_condition = ""
          if event_pokemon_info.state_code == 0
            for k in event_pokemon_info.cond_depl.keys
              if eval(k)
                depl = event_pokemon_info.cond_depl[k][0]
                move_changed_condition = k
              end
            end
          end
         
          if event_pokemon_info.state_code == 0 and depl != nil
            event_pokemon_info.state_code = 2
            page_id = -1+ event.event.pages.length
            save_route(event, page_id, event_pokemon_info)
             
            conserve = event_pokemon_info.cond_depl[move_changed_condition][1]
            if conserve == nil
              conserve = [false, false, false, false]
            end
           
           
            id = depl-1
            mt = conserve[0] ? event.event.pages[page_id].move_type : event.event.pages[id].move_type
            mr = conserve[1] ? event.event.pages[page_id].move_route : event.event.pages[id].move_route
            ms = conserve[2] ? event.event.pages[page_id].move_speed : event.event.pages[id].move_speed
            mf = conserve[3] ? event.event.pages[page_id].move_frequency : event.event.pages[id].move_frequency
           
            page = event.event.pages[page_id].dup
            page.move_frequency = mf
            page.move_speed = ms
            page.move_type = mt
            page.move_route = mr
            event.event.pages[page_id] = page
            event_pokemon_info.state_param.push(move_changed_condition)
          elsif event_pokemon_info.state_code == 2 and
            (not eval(event_pokemon_info.state_param[1]) or rejected?(event, event_pokemon_info))
            reset = true
          end     
         
          #RESETING
          if reset
            case event_pokemon_info.state_code
            when 1 #Reject Reset
              page_id = -1+event.event.pages.length
              event.event.pages[page_id] = event_pokemon_info.state_param[0]
            when 2 #Condition Movement Reset
              page_id = -1+event.event.pages.length
              event.event.pages[page_id] = event_pokemon_info.state_param[0]
            end
            event_pokemon_info.state_code = 0
            event_pokemon_info.state_param = []
          end
         
          event.refresh
        end
       
        # Save the road in state_param
        def save_route(event, page_id, event_pokemon_info)
          p = copy_page(event,page_id)
          event_pokemon_info.state_param.push(p)
        end
       
        #copy the given event page
        def copy_page(event, page_id)
          p = event.event.pages[page_id].dup
          p.move_route = event.event.pages[page_id].move_route.dup
          p.move_route.list = []
          for mc in event.event.pages[page_id].move_route.list
            c = mc.dup
            c.parameters = mc.parameters.dup
                 
            p.move_route.list.push(mc.dup)
          end
          return p
        end
       
        #====
        # Updating test
        def rejected?(event, event_pokemon_info)
          return ($kurei_panel["USE_POKEMON_PERSISTENCE"] and $reject_counter != nil and
                  $game_system.map_interpreter.distance_to_hero(event) < $reject_counter.distance and
                  $pokemon_party.actors[0] != nil and
            ($pokemon_party.actors[0].level > get_pokemon(event_pokemon_info.pokemon_stock_id).level or
            $reject_counter.all) and
            event_pokemon_info.sensitive_to_reject)
        end
         
      end
       
      # Class containing Event_Information
      class Event_Pokemon_Info
        attr_accessor :pokemon_stock_id     # Pokemon object id in @pokemons
        attr_accessor :old_route            # Use for Update
        attr_accessor :sensitive_to_reject  # Indicate if Pokémon is sensitive to reject
        attr_accessor :cond_depl            # {"condition" => [no_page, [conserve_mt, conserve_me, conserve_ms, conserve_mf]]}
        attr_accessor :origin_x
        attr_accessor :origin_y
       
        attr_accessor :state_code           #code of event state
                                            # 0 : Normal
                                            # 1 : Rejected
                                            # 2 : In conditionnal Movement
        attr_accessor :state_param          #Parameters of state
       
        def initialize
          pokemon_stock_id = nil
          old_route = nil
          @sensitive_to_reject = true
          @cond_depl = {}
          @origin_x = 0
          @origin_y = 0
         
          @state_code = 0
          @state_param = []
        end
      end
     
      class Traveller_Pokemon 
        attr_accessor :id 
        attr_accessor :level 
        attr_accessor :slot 
        attr_accessor :maps 
        attr_accessor :tags 
        attr_accessor :pokemon 
        attr_accessor :event_pokemon_info
        attr_accessor :starting_point     #Map anchor to appear
     
        #Acces to pokemon slot id
        def pokemon_stock_id=(value)
          @event_pokemon_info.pokemon_stock_id = value
        end
        def pokemon_stock_id
          return @event_pokemon_info.pokemon_stock_id
        end
       
        # Create a traveller data 
        # pkm_id : int, id of Pokemon 
        # lvl : int, level of th Pokemon 
        # slot : int, slot of traveller, same system as existing battle 
        # maps : List<int>, list of index of maps where we can see this Pokemon 
        # tags : List<int>, list of terrain tags where we can see this Pokemon 
        def initialize(pkm_id, lvl, slot, maps, tags) 
          @id = pkm_id 
          @level = lvl 
          @slot = slot 
          @maps = maps
          @starting_point = nil
          @tags = tags
          @pokemon = POKEMON_S::Pokemon.new(@id, @level)
          @event_pokemon_info = Event_Pokemon_Info.new
         
          if maps.is_a?(Hash)
            @maps = []
            @starting_point = {}
            for k in maps.keys
              if k != -1
                @maps.push(k)
                @starting_point[k] = maps[k]
              else
                for map_id in maps[k]
                  @maps.push(map_id)
                  @starting_point[map_id] = []
                end
              end
            end
          end
        end
         
        # Get a map_id in @maps randomly, the map index will be different to current_map_id 
        # whatever, if there is only one map, the index will be the same 
        #   current_map_id : int, index of current map 
        def get_random_map_id(current_map_id = -1) 
          i = rand(@maps.length) 
          if @maps.length > 1 
            while @maps[i] == current_map_id 
              i = rand(@maps.length) 
            end 
          end 
          return @maps[i] 
        end 
      end 
     
      #===============================================================================
      # -- Reject System  --  16/06//13  --
      # A script for Concrete_Encounter
      #   Script from Ku'rei Jinwu
      # CREDIT IF USED - CREDITS OBLIGATOIRES
      #===============================================================================
      # -- Intallation --
      #   1. Create a new script under Main, call it "Reject" or "Repousse"
      #   2. In Krosk's Scene_Map under "# Comptage Rencontre aléatoire"
      #       add
      # -> $reject_counter == nil and
      #       right after the if
      #   3. In Krosk's Game_Player at line 90 roughly, in increase_step method, after the unless
      #       insert
      # -> if $reject_counter != nil
      # ->   $reject_counter.decrease_step_count
      # -> end
      #
      # -- How to use --
      #   1. Call the script
      # -> demarrer_repousse(step_count, name = "REPOUSSE", radient=500)
      #     step_count : int, nb of step when reject is efficient
      #     name : string, name of the reject item, by default is "REPOUSSE"
      #     radient : int, distance of reject effect (see distance_to_hero)
      #   2. Reject has automatic end, but you can shorten it with
      # -> stop_rejecting / arreter_repousse
      #
      # -- Additionnal interpreter methods --
      # -> distance_to_hero(event) alias distance_avec_le_heros
      #       event : Game_Event
      #    Calculate the distance between the event and the $game_player
      #===============================================================================
      class Repousse
        attr_reader :step_count #int, number of step before end of Reject effect
        attr_reader :distance   #int, distance of effect
        attr_reader :all        #bool, true if all pokemon are rejected
       
        #Create the Reject
        # step_count : int, number of step before end of Reject effect
        # distance : int, distance of effect. 500 = rougly 4 cases
        def initialize(step_count = 50, distance = 500, all = false)
          @step_count = step_count
          @distance = distance
          @all = all
        end
       
        #Minus by one the step count
        def decrease_step_count
          @step_count -= 1
          if @step_count <= 0
            $game_system.map_interpreter.stop_rejecting
          end
        end
      end
    end

    class Game_Map 
      #Overidding original methods to add a nil return if there's no event 
      def check_event(x, y) 
        for event in $game_map.events.values 
          if event.x == x and event.y == y 
            return event.id 
          end 
        end 
        return nil 
      end 
    end 

    class Game_Event
      attr_accessor :page
    end

    class Game_Map
      def tileset_id
        return @map.tileset_id
      end
    end

    # Utiliser pour détecter si le pokémon sauvage a été capturé ou non
    #
    # NE PAS OUBLIER :

    # POKEMON BATTLE WILD :
    # ligne 393 : apres le end_battle
    # -> if  @enemy_caught == true
    # ->   $battle_var.result_caught_enemy = true
    # -> end

    module POKEMON_S
      class Pokemon_Battle_Variable
        attr_accessor :result_caught_pokemon
        attr_accessor :enemy_is_fugitive
       
        def initialize
          @weather = [0, 0]
          @actor_last_used = nil
          @enemy_last_used = nil
          @battle_order = (0..5).to_a
          @enemy_battle_order = (0..5).to_a
          @in_battle = false
          @actor_last_taken_damage = 0
          @enemy_last_taken_damage = 0
          @have_fought = []
          @enemy_party = Pokemon_Party.new
          @action_id = 0
          @window_index = 0
          @result_flee = false
          @result_flee_enemy = false
          @result_win = false
          @result_defeat = false
          @last_index = 0
          @round = 0
          @run_count = 0
          @money = 0
         
          @result_caught_pokemon = false
          @enemy_is_fugitive = false
        end
       
        def reset
          @weather = [0, 0]
          @actor_last_used = nil
          @enemy_last_used = nil
          @battle_order = (0..5).to_a
          @enemy_battle_order = (0..5).to_a
          @in_battle = false
          @actor_last_taken_damage = 0
          @enemy_last_taken_damage = 0
          @have_fought = []
          @enemy_party = Pokemon_Party.new
          @action_id = 0
          @window_index = 0
          @last_index = 0
          @round = 0
          @run_count = 0
          @money = 0
         
          @result_caught_pokemon = false
          @enemy_is_fugitive = false
        end
      end
    end

    class Interpreter 
      #Change number of pokémon in the current map 
      # Use persistence OBLIGATORY 
      # count : nombre de pokemon 
      def change_pokemon_max_count_in_map(count) 
        $concrete_encounter.change_count_of_pkm_in_map(count) 
      end 
      alias changer_nb_pokemon_max change_pokemon_max_count_in_map
       
      # Start Battle, paramters are int variables BTL_PKM_ID_VAR_ID and BTL_PKM_LVL_VAR_ID 
      def demarrer_combat_var 
        demarrer_combat($game_variables[$kurei_panel["BTL_PKM_ID_VAR_ID"]], $game_variables[$kurei_panel["BTL_PKM_LVL_VAR_ID"]]) 
      end 
       
      #============== 
      # TRAVELLERS 
       
      # Create a traveller data 
      # pkm_id : int, id of Pokemon 
      # lvl : int, level of th Pokemon 
      # pkm_name : string, name of traveller (maybe there are two same traveller...) 
      # maps : List<int>, list of index of maps where we can see this Pokemon 
      # tags : List<int>, list of terrain tags where we can see this Pokemon 
      def create_traveller(pkm_id, lvl, slot, maps, tags) 
        if $concrete_encounter.existing_traveller?(slot) 
          print("ERREUR::Concrete_Encounter, tentative de création d'un Traveller_Pokemon\nLe slot " + slot.to_s + " est déjà occupé. Abandon de la création") 
        else 
          $concrete_encounter.add_traveler_pokemon(pkm_id, lvl, slot, maps, tags)
          change_map_traveller(slot)
        end 
      end 
      alias creer_traveller create_traveller
       
      #Remove the travel had the given name 
      # slot : int, slot of deleting traveller 
      def remove_traveller(slot) 
        traveller = $concrete_encounter.get_traveller_by_slot(slot) 
        $concrete_encounter.remove_traveller(traveller) 
      end 
       
      #Change the map where the traveller will appears 
      # slot : int, slot of traveller 
      def change_map_traveller(slot, current_map_id = -1) 
        traveller = $concrete_encounter.get_traveller_by_slot(slot) 
        map_id = traveller.get_random_map_id(current_map_id) 
        $concrete_encounter.change_map_traveller(traveller, map_id) 
      end
      alias changer_map_traveller change_map_traveller
       
      #Change the map of traveller whose the name is in BTL_PKM_ID_VAR_ID, and reject map_id in BTL_PKM_LVL_VAR_ID 
      def change_map_traveller_var 
        change_map_traveller($game_variables[$kurei_panel["BTL_PKM_ID_VAR_ID"]], $game_variables[$kurei_panel["BTL_PKM_LVL_VAR_ID"]]) 
      end 
      alias changer_map_traveller_var change_map_traveller_var
       
      #Use game variable to delete the event and remove from traveller list 
      def remove_event_from_concrete_encounter_var 
        command_116 #Delete_Event 
        $concrete_encounter.remove_event_from_persist($game_map.events[@event_id]) 
        slot = $game_variables[$kurei_panel["BTL_PKM_ID_VAR_ID"]] 
        t = $concrete_encounter.get_traveller_by_slot(slot) 
        if t != nil 
          $concrete_encounter.remove_traveller(t) 
          $concrete_encounter.remove_pokemon(t.pokemon) 
        end 
      end
      alias supprimer_event_du_CE_var remove_event_from_concrete_encounter_var
       
      #Set the map of the traveller to given param 
      # slot : int, slot of traveller 
      # map_id : int, arbitrate map_id 
      def set_map_traveller(slot, map_id) 
        traveller = $concrete_encounter.get_traveller_by_slot(slot) 
        $concrete_encounter.change_map_traveller(traveller, map_id) 
      end
      alias definir_map_traveller set_map_traveller
       
      #Start an existing battle for Concrete_Encounter 
      def cE_demarrer_existing_battle_var 
        slot = $game_variables[$kurei_panel["BTL_PKM_ID_VAR_ID"]] 
        pokemon = $concrete_encounter.get_pokemon(slot) 
        demarrer_combat_existant(pokemon) 
      end
      alias cE_demarrer_combat_existant_var cE_demarrer_existing_battle_var
     
      #calculate the distance to the hero in number of pixel
      # event : Game_Event, event to measure
      def distance_to_hero(event = $game_map[@event_id])
        d = Math.sqrt((event.real_x - $game_player.real_x)**2 + (event.real_y - $game_player.real_y)**2)
        return d.to_i
      end
      alias distance_avec_le_heros distance_to_hero
     
        #Create a Reject and stock it in $reject_counter
      # step_count : int, number of step before end of Reject effect
      def start_rejecting(step_count = 50, name = "REPOUSSE", distance = 500, all = false)
        $reject_counter = Kurei::Repousse.new(step_count, distance, all)
        afficher_message("#{Player.name} utilise " + name + ".")
      end
      alias demarrer_repousse start_rejecting
     
      #Strop reject effect
      def stop_rejecting
        $reject_counter = nil
        afficher_message("L'effet de la Repousse disparaît")
      end
      alias arreter_repousse stop_rejecting
    end



    Il y a quelques autres script à modifier, des modifications mineures
    • Scene_Map de Krosk (pas l'original)
      Ligne 97 environ remplacer :
      Code:
      if $random_encounter != [0] and $game_player.encounter_count == 0

      par :
      Code:
      if Kurei::NORMAL_ENCOUNTER_ON and $random_encounter != a[0] and $game_player.encounter_count == 0

      Utilité : permet de desactiver (et non supprimer) les rencontres aléatoires de Krosk.

      Dans le même script à la ligne 50 environ, juste après :
      Code:
      def update
        loop do

      insérez :
      Code:
      if Kurei::CONCRETE_ENCOUNTER_ON
              $concrete_encounter.place_monsters
            end

      Ce qui donne
      Code:
      def update
        loop do
          if Kurei::CONCRETE_ENCOUNTER_ON
            $concrete_encounter.place_monsters
          end


    • Scene_Title de Krosk
      Ligne 20 environ, ajouter après le bloc de test de $BTEST
      Placer :
      Code:
      $concrete_encounter = Kurei::Concrete_Encounter.new

      ce qui donne
      Code:
      def main 
          if $BTEST 
            battle_test 
            return 
          end 
       
          $concrete_encounter = Kurei::Concrete_Encounter.new 

      Utilité : Créer le gestion de rencontres concrètes

    • Pokemon_Battle_Wild de Krosk
      Si vous souhaitez utiliser la persistance des Pokémon, il vous faudra faire cette modification. Elle vous sera aussi utile si vous utiliser les enregistrement de pokémon.
      • Ligne 61 :
        Code:
        @enemy.hp = @enemy.max_hp

        Il faut la même en commentaire (ajouter un "#" en début de ligne)
        Code:
        #@enemy.hp = @enemy.max_hp

        Utilité : Empêche la vie du Pokémon de remonter entre chaque combat
      • Ligne 251 environ : immédiatement après la ligne
        Code:
        @enemy_action = 1

        Ajouter :
        Code:
        switch_id = $kurei_panel["FUGITIVE_SWITCH_ID "]
        if $game_switches[switrch_id] and flee_able(@enemy, @actor)
          @enemy_action = 4
        end

        switch_id est la variable contenant l'index de l'interrupteur indiquant si le prochain pokémon sera fuyard. Si vous n'utilisez pas Concrete_Encounter, vous pourrez mettre directement l'id de cet interrupteur.


    • Pokemon_Battle_Core_1 de Krosk
      • Ligne 182 environ : juste avant la fin de la methode main
        Code:
          ...
          @actor_sprite.dispose
          @actor_status.dispose
          @enemy_status.dispose
          @actor_party_status.dispose
          @enemy_party_status.dispose
        end

        Ajouter $game_switches[$kurei_panel["FUGITIVE_SWITCH_ID"]] = false ce qui donne
        Code:
          ...
          @actor_sprite.dispose
          @actor_status.dispose
          @enemy_status.dispose
          @actor_party_status.dispose
          @enemy_party_status.dispose

          $game_switches[$kurei_panel["FUGITIVE_SWITCH_ID"]] = false
        end

      • Ligne 507 environ :
        Code:
        if @enemy_action == 4
          #run_enemy       Mettre cette ligne en commentaire
        end

      • Ligne 540 environ, remplacer :
        Code:
        if not(@enemy_caught) and @enemy_action == 1 and not(@enemy.dead?)
          attack_action(@enemy, @enemy_skill, @actor)
        end

        Par :
        Code:
        if not(@enemy_caught) and @enemy_action == 1 and not(@enemy.dead?)
          attack_action(@enemy, @enemy_skill, @actor)
        end
        if not(@enemy_caught) and @enemy_action == 4 and not(@enemy.dead?) and flee_able(@enemy, @actor)
          run_enemy
        end

      • Ligne 561 environ : faire la même chose que ligne 540


    • Script Game_Player de Krosk
      ligne 90 environ, après :
      Code:
      def increase_steps
        super
        unless @move_route_forcing

      ajoutez-y :
      Code:
      if $reject_counter != nil
        $reject_counter.decrease_step_count
      end

      ce qui donne
      Code:
      def increase_steps
        super
        unless @move_route_forcing
          if $reject_counter != nil
            $reject_counter.decrease_step_count
          end

      Utilité : rendre la repousse disponible


    Installation terminée


    Il y a quelques autres script à modifier, des modifications mineures
    La différence avec PSP4G+ est le numéro des lignes
    • Scene_Map de Krosk (pas l'original)
      Ligne 92 environ remplacer :
      Code:
      if $random_encounter != [0] and $game_player.encounter_count == 0

      par :
      Code:
      if Kurei::NORMAL_ENCOUNTER_ON and $random_encounter != a[0] and $game_player.encounter_count == 0

      Utilité : permet de desactiver (et non supprimer) les rencontres aléatoires de Krosk.

      Dans le même script à la ligne 45 environ, juste après :
      Code:
      def update
        loop do

      insérez :
      Code:
      if Kurei::CONCRETE_ENCOUNTER_ON
              $concrete_encounter.place_monsters
            end

      Ce qui donne
      Code:
      def update
        loop do
          if Kurei::CONCRETE_ENCOUNTER_ON
            $concrete_encounter.place_monsters
          end


    • Scene_Title de Krosk
      Ligne 20 environ, ajouter après le bloc de test de $BTEST
      Placer :
      Code:
      $concrete_encounter = Kurei::Concrete_Encounter.new

      ce qui donne
      Code:
      def main 
          if $BTEST 
            battle_test 
            return 
          end 
       
          $concrete_encounter = Kurei::Concrete_Encounter.new 

      Utilité : Créer le gestion de rencontres concrètes

    • Pokemon_Battle_Wild de Krosk
      Si vous souhaitez utiliser la persistance des Pokémon, il vous faudra faire cette modification. Elle vous sera aussi utile si vous utiliser les enregistrement de pokémon.
      • Ligne 243 environ : immédiatement après la ligne
        Code:
        @enemy_action = 1

        Ajouter :
        Code:
        switch_id = $kurei_panel["FUGITIVE_SWITCH_ID "]
        if $game_switches[switrch_id] and flee_able(@enemy, @actor)
          @enemy_action = 4
        end

        switch_id est la variable contenant l'index de l'interrupteur indiquant si le prochain pokémon sera fuyard. Si vous n'utilisez pas Concrete_Encounter, vous pourrez mettre directement l'id de cet interrupteur.


    • Pokemon_Battle_Core_1 de Krosk
      • Ligne 312 environ : juste avant la fin de la methode main
        Code:
          ...
          @actor_sprite.dispose
          @actor_status.dispose
          @enemy_status.dispose
          @actor_party_status.dispose
          @enemy_party_status.dispose
          if not @enemy_sprite_dresseur == nil
            @enemy_sprite_dresseur.dispose
          end
        end

        Ajouter $game_switches[$kurei_panel["FUGITIVE_SWITCH_ID"]] = false ce qui donne
        Code:
          ...
          @actor_sprite.dispose
          @actor_status.dispose
          @enemy_status.dispose
          @actor_party_status.dispose
          @enemy_party_status.dispose
          if not @enemy_sprite_dresseur == nil
            @enemy_sprite_dresseur.dispose
          end

          $game_switches[$kurei_panel["FUGITIVE_SWITCH_ID"]] = false
        end

      • Ligne 507 environ :
        Code:
        if @enemy_action == 4
          #run_enemy       Mettre cette ligne en commentaire
        end

      • Ligne 908 environ, remplacer :
        Code:
        if not(@enemy_caught) and @enemy_action == 1 and not(@enemy.dead?)
          attack_action(@enemy, @enemy_skill, @actor)
        end

        Par :
        Code:
        if not(@enemy_caught) and @enemy_action == 1 and not(@enemy.dead?)
          attack_action(@enemy, @enemy_skill, @actor)
        end
        if not(@enemy_caught) and @enemy_action == 4 and not(@enemy.dead?) and flee_able(@enemy, @actor)
          run_enemy
        end

      • Ligne 930 environ : faire la même chose que ligne 908


    • Script Game_Player de Krosk
      ligne 117 environ, après :
      Code:
      def increase_steps
        super
        unless @move_route_forcing

      ajoutez-y :
      Code:
      if $reject_counter != nil
        $reject_counter.decrease_step_count
      end

      ce qui donne
      Code:
      def increase_steps
        super
        unless @move_route_forcing
          if $reject_counter != nil
            $reject_counter.decrease_step_count
          end

      Utilité : rendre la repousse disponible


    Installation terminée


    Utilisation


    L'utilisation est décrite dans la vidéo : ICI
    Voici la version papier du tutoriel (petit tutoriel car le script est très simple d'utilisation)
    • Map entrepôt
      Vous avez besoin d'une map entrepôt dans laquelle le joueur n'a aucune possibilité d'accès. C'est une map parfaitement vide, mais retenez bien son ID (notez le dans le nom de la map afin d'y avoir accès tout le temp)
      Cette map servira de stockage pour l'event standard, et tout les autres qui seront disponibles dans une prochaine mise à jour du script
    • Event standard
      Dans le script Concrete_Encounter vous avez une constante nommée STANDARD_POKEMON_EVENT_NAME, c'est le nom UNIQUE dans la map entrepôt que devra porté l'évènement standard. Créer donc cet event comme vous le souhaitez, voici celui que j'utilise dans la vidéo :

      Oui, l'appel de script ne contient que "demarrer_combat" car Concrete_Encounter repérera tout les script débutant par "demarrer_combat" et les remplacera par la commande voulue.

      Une alternative est possible si vous utilisez un script de sécurité (dont je ne comprend toujours pas le principe), comme me l'a suggéré Yuri, réservez-vous deux variables donc vous noterez les id dans les constantes prévues à cet effet (cf. plus loin). Et à la place de mettre un appel de script "demarrer_combat", placez un commentaire "START_BATTLE" :


      Deuxième remarque, l’apparence de l'event doit absolument être un chara commençant par "Pkm " sinon l'apparence ne sera pas remplacée.
    • Créez vos Troops, vos groupe de combat comme le décrit la methode standard de PSP, rien à changer de ce côté là.
    • Placez vos groupes de monstres dans la liste de la map, l'écart de niveau de la première Troop placée détermine l'écart de toutes les autres
      Le nombre de pas moyen est la probabilité de trouver un Pokémon sur chaque case, ne mettez pas une valeur trop élevée sous peine d'avoir une plage de la côte d'azur en plein mois de juillet (sauf que tout le monde vous attaque au moindre contact) :

      Il y (nb_pas_moyen/RANDOM_SPAWNING_BASE) chances d'avoir un Pokémon sur une case
    • Paramétrez les constantes présentes dans le script Concrete_Encounter, elles permettent une petites personnalisation :
      • MONSTERS_STOCKAGE_MAP_ID : index de la map entrepôt
      • CONCRETE_ENCOUNTER_ON : fais apparaître les Pokémon sur la map si est true
      • NORMAL_ENCOUNTER_ON : true si vous voulez conserver les rencontres aléatoires normales
      • USE_AUTOMATIC_EVENT : pas touche, la version true ne marche plus (je l'ai utilisé pour l'évolution du script)
      • DEFAULT_LOCAL_RARITY : rareté local si elle n'a pas été précisée
      • RANDOM_SPAWNING_BASE : il y (nb_pas_moyen/RANDOM_SPAWNING_BASE) chances d'avoir un Pokémon sur une case
      • STANDARD_POKEMON_EVENT_NAME : nom du standard de base
      • STANDARDS : correspondance des standards (voir ci-après)
      • USE_STANDARDS : true si vous voulez utiliser les standards autres que STANDARD_POKEMON_EVENT_NAME
      • CHARA_NAME_START : début du nom de la ressource chara
      • VISIBLE_ON_WATER : true si les Pokémon sur l'eau sont visible, false sinon (on tombe dessus par hasard)
      • USE_PERSISTENCE : true si la persistance des event est utilisée
      • ALL_ARE_PERSISTENT : true si tout les event de Pokémon sont persistant
      • AUTO_REGENATE_POPULATION : true si la population d'event se régénère quand l'un d'entre eux disparaît
      • PERSISTENCE_WORD : mot à inserer dans un commentaire en première ligne d'un commentaire de la première page d'un standard pour dire qu'il est persistant
      • BTL_PKM_ID_VAR_ID : numéro de la variable de jeu contenant l'ID du Pokémon
      • BTL_PKM_LVL_VAR_ID : numéro de la variable de jeu contenant le niveau du Pokémon
      • BATTLE_START_WORD : Mot à mettre en commentaire (première ligne) pour débuter le combat
      • CHANGE_MAP_WORD : Mot à mettre en commentaire (première ligne) pour que le traveller change de map
      • REMOVE_WORD : Mot à mettre en commentaire (première ligne) pour supprimer l'event
      • USE_POKEMON_PERSISTENCE : true si la persistance des Pokémon est activée
      • RANDOM_FORMS : correspondance entre les id des pokémon et le nombre de formes qu'ils peuvents prendre

    • Jouez



    MAJ : Standards


    Pour activer l'utilisation des standards, modifier la valeur de la constante USE_STANDARDS en true

    Utilité : dans cette mise à jour, vous pourrez utiliser un event spécialement conçu pour un type de Pokémon. Par exemple, un RHINOFEROS est très agressif, donc il marchera vers le joueur tandis que SUICUNE fuira le joueur ou que PSYKOKWAK n'en aura rien à faire. Voici déjà trois event standards.

    Configuration :
    Dans le script Concrete_Encounter, vous avez la constante : STANDARDS qui est un dictionnaire associant les id de Pokémon à un nom d'event standard.
    Par exemple :
    Code:
    STANDARDS = {
       "AGGRO_STANDARD_001"=> [111, 112],
       "FLEES_POKEMON_001" => [243, 244, 245]
    }

    Associe Rinhocorne et Rinhoféros au standard aggressif n°1
    et les trois légendaires fuyards de Jotho sont associé au standard de fuite n°1

    Si un pokémon n'a pas son id dans les clef du dictionnaire, le standard par défaut sera utilisé.

    Pour associer un standard à une liste d'id, ajoutez la ligne structuré comme suit au dictionnaire (en pensant à la virgule à la fin de la ligne précédente :
    Code:
    "NOM_STANDARD" => [id_pkm_1, id_pkm_2, id_pkm_3, ...]

    Puis créez l'event standard portant le nom précisé. Dans mes exemples :

    Recapitulatif sur les commentaires de commande (par défaut):
    • START_BATTLE : commence le combat contre le Pokémon
    • DELETE_EVENT : supprime l'event de la map (utile quand le pokémon est vaincu par exemple)
    • CHANGE_MAP : Traveller seulement, change la map où le traveller apparaît
    • FREQUENCY=a,b : change la fréquence de déplacement pour un chiffre en a et b
    • SPEED=a,b : même principe mais pour la rapidité de déplacement
    • DEPL_COND=["condition", no_page, conservateurs] : cf. MAJ : Déplacements Conditionnels


    Règles à respecter dans la création d'un standard :
    • une seule page active
    • les apparences de pokémon doivent être des chara pokémon, commençant par "Pkm " (espace à la fin)
    • la commande de commentaire "PERSIST" doit être placé en première position dans la première page



    MAJ : Persistance des événements


    Utilité : les event de pokémon placés sur une map sont persistant, c'est-à-dire que si vous changez de map et que vous revenez ils seront toujours là.
    Plusieurs persistances :
    • Tout le monde est persistant : aucun event ne disparaîtra par magie (il faudra mettre KO le pokémon)
    • Tout le monde n'est pas persistant : il faut préciser dans le standard que l'event est persistant. Cela se fait en insérant un commentaire en première ligne de la première page, et ce commentaire c'est ni plus ni moins
      Code:
      PERSIST

      Modifiable à souhait dans les constantes de configuration

    Par exemple, un Aggro persistant (vous ne lui échapperez pas en changeant de map !)


    Auto régénération de la population :
    Quand vous battez un pokémon, il disparaît et ne reviendra pas même si vous quitter la map. Vous pouvez choisir cela, mais le mode AUTO_REGENATE_POPULATION est actif par défaut (cf. constantes). Cela implique qu'un pokémon battu laissera la place à un autre lorsque vous reviendrez sur la map. Le nombre de pokémon sur une map sera donc fixe et dépendra de la première fois que vous venez sur la map.
    Vous pourrez tout de même utiliser la commande de script :
    Code:
    change_pokemon_max_count_in_map(new_max_count)

    pour changer le nombre maximal d'event sur la map.


    MAJ : Rapidité et Fréquence aléatoire


    Si tout les Pokémons ont la même vitesse et la même fréquence, ils pourraient avoir l'air de bouger en même temps, au même moment. Pour tirer aléatoirement la Rapidité ou la fréquence
    Entrez en commentaire
    Code:
    SPEED=a,b

    Code:
    FREQUENCY=a,b

    Dans les deux cas : a et b sont à remplacer par un chiffre entre 1 et 6 avec a < b. Il correspondent aux chiffre de vitesse et fréquence.

    Un exemple :



    MAJ : Pokémons Voyageurs


    Comme à chaque fois que je parle de Pokémon Voyageurs tout le monde me demande ce que c'est à quoi ça sert, je le dit une bonne fois pour toutes :
    Citation:
    Un Pokémon Voyageur est un Pokémon qui change de map à la fin de chaque combat, les jeux officiel en contiennent quelques uns comme SUICUNE, LATIOS, etc.

    Et pour nos amis anglais :
    Citation:
    A traveller pokemon is a Pokemon who randomly change the map where they appear at the end of each battle, official games include some like SUICUNE, LATIOS, ...


    Bien que ce soit le troisième script que je post à ce sujet (Liens vers le seul fonctionnant à peu près : ICI, il n'a pas besoin de Concrete_Encounter), celui-ci fonctionne avec Concrete_Encounter. Voyons comment créer un Traveller.

    Nous allons créer un ARTIKONDIN se balandant dans les maps 2,3 et 4 sur les terrains de tag 1 et 0.
      1. Créer le traveller

Pour créer le traveller, il faut appeler la commande de script suivante dans un event :
Code:
create_traveller(pkm_id, level, slot, [maps_id], [tags_id])

avec :
  • pkm_id : int, ID du pokemon voyageur (pour ARTIKODIN : 144)
  • level : int, niveau du Pokemon Voyageur (pour l'exemple : 20)
  • slot : int, slot de sauvegarde, casier où sera ranger les données du traveller (même fonctionnement que pour les combat existant de PSP mais pas les même casiers)
    NE PAS UTILISER LE SLOT 0 (ZERO)
  • maps_id : List<int>, tableau contenant les index des maps dans lesquelles il apparaîtra (ici : [2,3,4])
  • tags : List<int>, tableau contenant les tag terrains sur lesquels il apparaîtra, assurez vous d'en avoir sur chaque maps où il apparaîtra. (ici : [0,1])

Ce qui nous donne pour l'exemple :
Code:
create_traveller(144, 20, 1, [2,3,4], [0,1])

    2. Changer la map du traveller manuellement

Peut-être voudrez vous qu'en parlant à quelqu'un, le traveller aille vers une map particulière, appellez cette commande dans une commande script
Code:
set_map_traveller(slot, map_id)

Ou les arguments sont :
  • slot : int, slot du traveller
  • map_id : int, index de la map où le traveller doit apparaître

    3. Supprimer manuellement le traveller

Vous voudrez peut-être que le traveller disparaissent via une commande d'event. La voici :
Code:
remove_traveller(slot)

ou slot est le slot du traveller (mais vous connaissez)
    4. Standard de traveller

Un standard de traveller :

Pour lancer le changement de map, il faut placer un commentaire avec en première ligne CHANGE_MAP dans le standard


MAJ : Persistance des Pokémons


Les événements sont persistant depuis longtemps déjà, mais à chaque combat avec le même event, le Pokémon était réinitialisé oh, j'ai affaibli le Pokémon trop fort pour moi, je fuis je me soigne et retourne me battre... Mais ! Le Pokémon à tous ses PV ! Et , tiens c'est un transsexuel ? Il est passé de mâle à femelle !)

Si vous souhaitez utiliser la persistance des Pokémon, il vous faudra faire cette modification. Elle vous sera aussi utile si vous utiliser les enregistrement de pokémon.
Ligne 61 du script Pokemon_Battle_Wild de Krosk
Code:
@enemy.hp = @enemy.max_hp

Il faut la même en commentaire (ajouter un "#" en début de ligne), sinon la vie du pokémon sera réinitialisé à chaque combat
Code:
#@enemy.hp = @enemy.max_hp


Avec la persistance des Pokémon toutes ces bizarreries seront finies. Elle est active par défaut mais aller faire un tour du côté des constantes.


MAJ : Repousse


Une fonctionnalité qui fait défaut à PSP, je l'ai implémenté pour Concrete_Encounter en mode rencontres concrètes. Je n'ai malheureusement pas eu le courage de passer plus d'une demi-heure sur la repousse des rencontres aléatoires (problème : après la fin de repousse, vous étiez tranquille pendant ce même nombre de pas :/). La repousse sera disponible si la persistance des Pokémon l'est aussi.

Bref, l'installation est un peu plus compliquée que celle des autres Mise à jours.
  • Script Game_Player de Krosk
    ligne 90 environ, après :
    Code:
    def increase_steps
      super
      unless @move_route_forcing

    ajoutez-y :
    Code:
    if $reject_counter != nil
      $reject_counter.decrease_step_count
    end

    ce qui donne
    Code:
    def increase_steps
      super
      unless @move_route_forcing
        if $reject_counter != nil
          $reject_counter.decrease_step_count
        end

  • Evénements commun de repousse
    Aller dans la BDD, section événements Commun et créez-y trois événement portant les noms des trois repousse (REPOUSSE, SUPEREPOUSSE, MAX REPOUSSE), les trois n'ayant qu'une seule commande :
    Code:
    demarrer_repousse(nb_pas, nom_repousse="REPOUSSE", rayon_action=500, tous=false)

    où les arguments sont :
    • nb_pas : nombre de pas pendant lesquels le repousse fait effet
    • nom_repousse : nom de l'objet appelant le script, c'est pour le message de début de repousse ("Machin utilise SUPERREPOUSSE.") par défaut "REPOUSSE"
    • rayon_action : rayon d'action du repousse, par défaut 500
    • tous : indique si tous les Pokémon sont rejeté (officiellement, le repousse ne repousse que les pokémons de niveau inférieur au premier pokémon de l'équipe)

    Concernant le rayon d'action, c'est une exclusivité de Concrete_Encounter, en effet les Pokémon étant sur la map, il est normal que ceux qui sont à 20 000km de vous ne fuis pas. Et puis, ça donne tellement une sensation de puissance quand les Pokémon fuie à votre approche !
    Voici les trois appel de script pour chacune des repousse officielles
    Code:
    demarrer_repousse(100, "REPOUSSE", 500)          #REPOUSSE
    demarrer_repousse(200, "SUPERREPOUSSE", 750) #SUPERREPOUSSE
    demarrer_repousse(250, "MAX REPOUSSE", 1000)  #MAX REPOUSSE

    Toujours dans la BDD, associés ces événements communs aux trois Item Repousse, et le Repousse est disponible, il vous suffira d'utiliser l'objet.
  • Aller plus loin : la MEGA REPOUSSE
    Vous avez vu l'arguments "tous" dans le script ci-dessus, il n'a pas été utilisé. Vous pouvez modifier les repousse comme vous le souhaitez, je vous propose de créer un nouvel objet "MEGA REPOUSSE" qui possèdera les caractéristique du MAX REPOUSSE en plus de repousser tous les Pokémons.
    • Créer un événement commun que vous appeler "MEGA REPOUSSE", et faites en sorte qu'il appel le script
      Code:
      demarrer_repousse(250, "MEGA REPOUSSE, attention les yeux", 1000, true)

    • Lorsque cela est fait, créez un nouvel item que vous appellerez "MEGA REPOUSSE" aussi, remplissez le comme vous le souhaitez et faites le appeler l'événement commun "MEGA REPOUSSE".

    • C'est fini pour le MEGA REPOUSSE, testez-le en jeu.



MAJ : Panneau de configuration dynamique


Imaginons qu'au cours du jeu vous vouliez désactiver les rencontres concrétes, ou activé les rencontres normales ou désactiver la persistance des event, etc, modifier toutes les constantes décrites au début du sujet. Maintenant vous pouvez, en utilisant la variables $kurei_panel. Exemple :
Code:
$kurei_panel["CONCRETE_ENCOUNTER_ON"] = false
$kurei_panel["NORMAL_ENCOUNTER_ON"] = true

Désactivera les rencontres contrète et activera les rencontres normales
Attentions, les Pokémon ne disparaîtront pas de la map des l'instant où vous désactiverez les rencontres concrétes (il vous faudra changer de map)
Pour ce qui est des rencontres normales, elles seront réactivé des l'instant ou vous les activerez (étonnant non ?)

Pour plus de précisions sur les constantes modifiables (paradoxe) je vous invite à lire leurs descriptions au début du sujet. Toutefois, les constante concernant le nom de commandes de commentaires ne sont pas modifiables dynamiquement pour des questions de sécurité.


MAJ : Formes aléatoires


Les Zarbis, si vous voulez placer des zarbi avec des formes aléatoires sur une map. Vous pouvez désormais paramétrer le nombre de formes que peut avoir un pokémon, lors de la rencontres la forme sera déterminée aléatoirement.

Pour définir le nombre de forme pour un pokémon, allez dans les constantes de début de script.
Code:
#Correspondances pkm_id => nb_form
  RANDOM_FORMS = {
    201 => 28   #Zarbi 28 formes aléatoires
  }

Ici, les zarbi ont 28 formes différentes.

Ajouter un pokemon a forme aléatoires, comme pour les standard, ajouter une ligne avant la "{" finale répondant au format suivant :
Code:
pkm_id => nb_forme,

Où les arguments sont :
  • pkm_id : index du pokémon
  • nb_forme : nombre de formes disponibles pour ce pokémon

Assurez vous que les character de ce pokémon sont bien nommée Pkm_201_2 pour le pokemon 201 forme 2


MAJ : Standards spécifiques à une liste de map


Vous voudrez peut-être utiliser un standard spécial pour un Pokémon seulement sur quelques maps, le monde étant vaste, on peut avoir des Rattata agressifs dans un coin, d'autres hyper actif dans un autre. Grâce à cette mise à jour vous pourrez.

Imaginons que nous voulons un Rattata agressif sur les maps 12,14 et 20, et qu'il soit hyper actif sur les maps 15, 21,17, 16 et 8. Remarquez que l'ont ne peut pas avoir deux standards pour le même pokémon sur la même map.

Nous avions la constantes des Standards :
Code:
STANDARDS = {
   "AGGRO_STANDARD_001"=> [111, 112],
   "FLEES_POKEMON_001" => [243, 244, 245]
}

qui sera maintenant :
Code:
STANDARDS = {
   "AGGRO_STANDARD_001"=> [111, 112],
   "FLEES_POKEMON_001" => [243, 244, 245],
   "[12,14,20]/AGGRO_STANDARD_001" => [19],
   "[15,21,17,16]/HYPERACTIVE_STANDARD" => [19]
}

La structure de base de l'affectation d'un standard est :
Code:
"NOM_DU_STANDARD" => [pkm_1, pkm_2,  pkm_3, pkm_4, ...]

avec pkm_X les id des pokémons ayant ce standards
Maintenant, nous aurons
Code:
"[map_1, map_2, map_3, map_4, map_5, ...]/NOM_DU_STANDARD" => [pkm_1, pkm_2,  pkm_3, pkm_4, ...]

avec map_X les id des map où devra être appliqué le standard.


MAJ : T2PC (Terrain Tag Probability Coefficient)


Vous aurez remarqué que le nombre de pokémons sur les rochers où sur l'eau est généralement bien plus élevé que le nombre de pokémon dans l'herbe. Cela est du au fait que le nombre de pokémon n'est pas prédétermioné mais qu'il y un certain nombre de chance qu'un pokémon soit sur chaque case. Logiquement :

Plus de surface => Plus de Pokémon

Le T2PC permet d'appliquer un coefficient au tag terrain, ainsi il y aura :

(nb_pas_moyen * T2PC) sur RANDOM_SPAWNING_BASE chances qu'un Pokémon soit présent sur une case.
avec nb_pas_moyen le nombre de pas moyen avant de rencontrer un Monstre (Propriétés de la map), T2CP le coefficient de terrain, et RANDOM_SPAWNING_BASE la base (cf. Constantes).


Mise en place du T2PC :
La constante T2PC permet le réglage des coefficient :
Code:
T2PC = [coef_tag_1, coef_tag_2, coef_tag_3, coef_tag_4, coef_tag_5, coef_tag_6, coef_tag_7]

avec coef_tag_X le coefficient à appliquer au tag terrain X. Pour une probabilité de rencontre normal, mettre le coefficient à 1.
Dans un premier temps, je préconise les coefficients suivants :
  • Terrain Herbe : coef 1
  • Terrain Eau : coef 1.5
  • Terrain Roche : coef 1.5

Sachez cela : plus le coefficient est grand, moins il y aura de chance qu'un pokémon soit sur la case. Un coefficient > 1 réduit les chances d'apparition tandis qu'un coefficient < 1 les augmentes.
T2PC par défaut :
Code:
T2PC = [1, 1, 1, 1, 1, 1, 1]


Exemple d'utilisation EXAGÉRÉE du T2PC (regardez bien les coefficient), la map à un nombre de pas moyen de 150:



MAJ : T3PC (Tileset Terrain Tag Probability Coefficient)


Maintenant, imaginons que vous changiez de Tileset, que les tags terrains sont affectez différemment, les coefficients ne seraient certainement plus bons... Grâce au T3PC, vous pouvez définir les coefficient selon le tileset utilisé. En attachant un id de tileset à un tableau de coefficient comme celui vu dans la MAJ T2PC. Cela se passe dans la constante T3PC :
Code:
T3PC = {
  1 => [1, 1.5, 1, 1, 1, 1, 1.5],
}

Pour affecter un T2PC à un tileset, la ligne du tableau de hash devra respecter le format suivant :
Code:
tileset_id => [coef_tag_1, coef_tag_2, coef_tag_3, coef_tag_4, coef_tag_5, coef_tag_6, coef_tag_7],

Vous connaissez les coef_tag, tileset_id est l'index du tileset dans la BDD.


MAJ : Insensibilité à la repousse


Pour rendre un Standard totalement insensible à la Repousse (même le Mega Repousse n'y fera rien), ajouter le commentaire : "NOT REJECTABLE" dans sa page. Vous pouvez modifier le mot dans la constante REJECT_INSENSITIVE_WORD.


MAJ : Déplacements Conditionnels


Je ne sais pas si vous avez remarqué que le standard agressif vous poursuit où que vous soyez, même si vous êtes à 100 tiles de lui, derrière une montagne. Certain Pokémon paisibles, comme les Arakdo peuvent avoir peur du joueur approchant et le fuir s'il est trop prêt, ...

Tout ces déplacements ont une condition, c'est ce qui rend le déplacement conditionné.

Définir un déplacement conditionnel
  • Notions de page principale et pages secondaires :
    Jusqu'à maintenant, tout mes standards étaient sur une seule page, la page principale, celle où est définit ce qu'il se passe lorsque l'event entre en contact avec le Héros, combat, ... Cette page, je le répète est LA page principale(cf. Standards).
    Les pages secondaires seront celle qui serviront à définir les Déplacements Conditionnels, elles devront être AVANT la page principale. Si la page 2 est secondaires, la principale sera la page 3 ou plus.
  • La Page Secondaire :
    Il vous faut créer une page secondaire tout en gardant la page principale comme dernière page. Exemple :

  • La Commande de Commentaire :
    Pour définir un Déplacement Conditionnel, il vous faut insérer un commentaire comme vous l'auriez fait pour modifier la Frequence de façon aléatoire et y écrire une ligne respectant le format suivant :
    Code:
    COND_DEPL=["condition", no_page, [conserve_mt, conserve_mr, conserve_ms, conserve_mf]]
    ou plus simplement :
    COND_DEPL=["condition", no_page]

    C'est un peu plus compliqué que la fréquence et la vitesse. Mais reprenons point par point

    • condition (sans guillemets) : Condition d’exécution du Déplacement Conditionnel.
      Méthodes existantes par défaut :

      • hero_close(radius = 500)
        radius : int, defaut=500, distance testée
        Méthode testant si la distance de l'événement Pokémon avec le Héros est inférieure à radius
      • C'est tout pour l'instant mais je compte bien en ajouter d'autres

      Pour les scripteur, j'utilise un simple eval sur la condition, ce qui vous permet de passer les commande de l'interpreter en entrant "$game_system.map_interpreter.nom_methode" en tant que condition.
    • no_page :
      numéro de la page depuis laquelle seront importés les paramètres du mouvement. Exemple, si je met 1, le déplacement de la page 1 sera importé dans ma page principale quand la condition sera validée :

    • (OPTIONNEL)indications de conservations:
      comme son nom l'indique, ce tableau de booléen indique si l'on doit conserver (ne pas remplacer) par exemple la vitesse de la page principale, ou sa fréquence, ...

      • conserve_mt : conservation du type de mouvement
      • conserve_mr : conservation de la personnalisation du mouvement
      • conserve_ms : conservation de la vitesse de déplacement
      • conserve_mf : conservation de la fréquence de déplacement

      Ainsi : [false, false, true, true] utilisera le mouvement de la page no_page, ainsi que sa personnalisation mais gardera la vitesse et la fréquence de la page principale.
      Cette argument vaut [false, false, false, false] par défaut, cela implique rien n'est conservé.




MAJ : Replacement des Event de Pokémon


Imaginons la situation suivante : vous vous êtes amusé à ranger les Pokémon d'une map dans un coin avec un Mega Repousse (comme ça m'est arrivé), c'est amusant, mais quand vous quitter la map pour faire autre chose, puis que vous revenez, les Event de Pokémon sont toujours à leur place rangés dans un coin.

En mettant la constante USE_REPLACEMENT à true, les Event de Pokémon seront automatique replacés sur leurs positions de départ à chaque fois que vous entrerez dans la map.


MAJ : Changement de méthodes d’acquisition de coordonnées aléatoires


Vous avez sans doute remarqué que les Pokémon Voyageurs apparaissaient beaucoup plus souvent sur la partie gauche de la map qu'ailleurs. Cela venait de la façon dont était obtenu les coordonnées de placement. J'ai tout changer pour une implémentation plus rapide, plus efficace et plus claire.

Dans l'absolue cela ne change rien pour vous, a ceci près que vous avez maintenant la possibilité de définir un point centrale autour duquel apparaîtra le Pokémon Voyageur.
Pour créer un Pokémon Voyageur, vous utilisiez la commande de script :
Code:
create_traveller(pkm_id, level, slot, [maps_id], [tags_id])

Je vous laisse voir (ICI) les différents rôle des paramètres. Ces rôles sont toujours valables.

Définir coordonnées d'apparitions approximatives :
Remplacer [maps_id] par un tableau de hash de la forme suivante :
Code:
{
  map_id => [x, y],
  map_id_2 => [x, y],
  etc
}

où map_id est l'id de la map où les coordonnées approximatives doivent être utilisées.

Deux façons de conserver le placement aléatoire :
    1. Map par Map

Dans [maps_id], la ligne
Code:
map_id => []

conservera le placement aléatoire
[list=2]2. Liste de map à placement aléatoire
La ligne
Code:
{
  -1 => [12, 45, 32, 11, 10]

garantira un placement aléatoire dans les maps 12, 45, 32, 11 et 10.

Exemple
Code:
create_traveller(381, 40, 1,{21 => [10, 12], 10 => [20, 11], -1 => [2, 5, 64, 32, 12, 22]}, [1, 2])

Créera un Latios niveau 40 sur le slot 1 qui voyagera sur les maps 21, 10, 2, 5, 64, 32, 12 et 22 et sur les terrains 1 et 2. Sur les maps 21 et 10 sa position sera approximativement (10,12) et (20,11).


MAJ : Pokémon Fuyard


Je vous ai parlé de Pokémon Voyageant de map en map comme le célèbre Suicune. Le problème était qu'ils ne fuyaient pas une fois en combat... Et que cela enlevait beauuucoup de charme à la chasse au Voyageur. En deux ans, j'ai chercher à trois reprise comment gérer efficacement la fuite d'un Pokémon. Voici donc une façon qui ne m'a pas déçu et qui est simple d'utilisation et de mise en place.


Constante
Dans la partie constantes du script.
Code:
FUGITIVE_SWITCH_ID = 4975

La constante définisant l'id de l'interrupteur indiquant si le prochain pokémon combattu sera fuyard ou non.

Modifications de Scripts
  • Pokemon_Battle_Wild
    • Ligne 251 environ : immédiatement après la ligne
      Code:
      @enemy_action = 1

      Ajouter :
      Code:
      switch_id = $kurei_panel["FUGITIVE_SWITCH_ID "]
      if $game_switches[switrch_id] and flee_able(@enemy, @actor)
        @enemy_action = 4
      end

      switch_id est la variable contenant l'index de l'interrupteur indiquant si le prochain pokémon sera fuyard. Si vous n'utilisez pas Concrete_Encounter, vous pourrez mettre directement l'id de cet interrupteur.

  • Pokemon_Battle_Core_1
    • Ligne 182 environ : juste avant la fin de la methode main
      Code:
        ...
        @actor_sprite.dispose
        @actor_status.dispose
        @enemy_status.dispose
        @actor_party_status.dispose
        @enemy_party_status.dispose
      end

      Ajouter $game_switches[$kurei_panel["FUGITIVE_SWITCH_ID"]] = false ce qui donne
      Code:
        ...
        @actor_sprite.dispose
        @actor_status.dispose
        @enemy_status.dispose
        @actor_party_status.dispose
        @enemy_party_status.dispose

        $game_switches[$kurei_panel["FUGITIVE_SWITCH_ID"]] = false
      end

    • Ligne 507 environ :
      Code:
      if @enemy_action == 4
        #run_enemy       Mettre cette ligne en commentaire
      end

    • Ligne 540 environ, remplacer :
      Code:
      if not(@enemy_caught) and @enemy_action == 1 and not(@enemy.dead?)
        attack_action(@enemy, @enemy_skill, @actor)
      end

      Par :
      Code:
      if not(@enemy_caught) and @enemy_action == 1 and not(@enemy.dead?)
        attack_action(@enemy, @enemy_skill, @actor)
      end
      if not(@enemy_caught) and @enemy_action == 4 and not(@enemy.dead?) and flee_able(@enemy, @actor)
        run_enemy
      end

    • Ligne 561 environ : faire la même chose que ligne 540


Voici qui est fait pour l'installation de cette partie du script.

Rendre un Standard fuyard
Avant la commande de commentaire START_BATTLE, activer l'interrupteur indiquant que le pokémon fuira :


Remarques : l'interrupteur est automatiquement désactivé à chaque fin de combat.




Voilà tout, j'espère que le script vous sera utile ! Votre avis sur les améliorations et ajouts de fonctionnalités possibles m’intéressent ![target][/target]


Dernière édition par Ku'rei le Dim 8 Sep - 12:13 (2013); édité 59 fois
Revenir en haut
Publicité






MessagePosté le: Sam 15 Juin - 07:52 (2013)    Sujet du message: Publicité

PublicitéSupprimer les publicités ?
Revenir en haut
Nuri Yuri
Administrateur
Administrateur


Inscrit le: 15 Oct 2008
Messages: 6 383
~Entity~
Localisation: Nancy
Non renseigné (Visible...)
ID Steam: Nuri_Yuri

MessagePosté le: Sam 15 Juin - 09:15 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Ce script aidera bien des projets @_@
J'aimerais te proposer une petite suggestion au niveau de celui-ci :
Pourrait-il au lieu de modifier la commande demarrer_combat modifier l'état d'une variable locale et ajouter une commande dans l'interpreter qui provoque le combat mais en fonction de cette variable. (Personnellement, j'utilise un script qui efface toute les commandes de script et ne les exécute pas InGame si elle existent, pour la sécurité du projet...)
Bon, je vais probablement pas l'utiliser vu qu'officiellement je n'ai pas de projets mais ça pourrait être intéressant pour certains projets qui se doteraient de la même protection x)
Revenir en haut
Facebook Twitter
Ku'rei
Membre


Inscrit le: 10 Aoû 2010
Messages: 546
Adepte du NoMoreExcuses
Localisation: Chambéry
Masculin

MessagePosté le: Sam 15 Juin - 09:24 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Je ne comprend pas bien ce que tu veux me dire, ce serait quelque chose comme ça ?
Dans l'event, commande script
param = ""
eval_str(param)

Puis dans mon script je remplacerais
par param = "demarrer_combat(1, 5)"
eval_str(param)

Puis ajouter la commande
Code:
def eval_str(str)
  eval(str)
end


Si c'est ça je ne voit pas trop la différence

Je suis peut-être à la masse, mais pourquoi supprimer tous les appel de script ?
Revenir en haut
Nuri Yuri
Administrateur
Administrateur


Inscrit le: 15 Oct 2008
Messages: 6 383
~Entity~
Localisation: Nancy
Non renseigné (Visible...)
ID Steam: Nuri_Yuri

MessagePosté le: Sam 15 Juin - 10:46 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

C'est tout le contraire x)
Dans l'interpreter tu mets ça :
Code:
def demarrer_combat_var()
  demarrer_combat($game_variables[BTL_ID_PKMN],$game_variables[BTL_LVL_PKMN])

Après ton script au lieu de modifier la commande de script il modifie les deux variables dans l'évent et tout se passe bien. Quand ma sécurité passera à la compilation du projet elle remplacera "demarrer_combat_var()" par l'id de la commande et il n'y a plus de problèmes x)
Enfin, c'est assez compliqué expliqué comme ça x)
Revenir en haut
Facebook Twitter
Ku'rei
Membre


Inscrit le: 10 Aoû 2010
Messages: 546
Adepte du NoMoreExcuses
Localisation: Chambéry
Masculin

MessagePosté le: Sam 15 Juin - 11:15 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Ok, je crois que j'ai compris ^^ Par contre, pour definir les valeurs des variable je suis obligé de le faire en modifiant la commande d'event.
Mettons, je détecte un appel de script
Code:
START_BATTLE

je remplace ça via mon script par
Code:

$game_variables[BTL_ID_PKMN] = {id_pkm}
$game_variables[BTL_LVL_PKMN] = {lvl_pkm}
demarrer_combat_var()


Oui surtout que la sécurité moi ça me prend plus la tête qu'autre chose ^^
Revenir en haut
Nuri Yuri
Administrateur
Administrateur


Inscrit le: 15 Oct 2008
Messages: 6 383
~Entity~
Localisation: Nancy
Non renseigné (Visible...)
ID Steam: Nuri_Yuri

MessagePosté le: Sam 15 Juin - 11:40 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Non, ça n'ira pas. Il faut modifier les commandes d'évent de gestion des variables.
Sinon ça ne change rien au problème initial x)
(Par contre, mets la possibilité initiale et celle que je propose si tu mets celle que je propose :b)
Revenir en haut
Facebook Twitter
Ku'rei
Membre


Inscrit le: 10 Aoû 2010
Messages: 546
Adepte du NoMoreExcuses
Localisation: Chambéry
Masculin

MessagePosté le: Sam 15 Juin - 12:07 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Aaaaaaaaaaah ! Mais ta sécurité ! Elle enlève JUSTE les commandes d'appel de script ! Non ? J'y comprend plus rien ^^
Tu me parle d'un truc comme ça :


Revenir en haut
Nuri Yuri
Administrateur
Administrateur


Inscrit le: 15 Oct 2008
Messages: 6 383
~Entity~
Localisation: Nancy
Non renseigné (Visible...)
ID Steam: Nuri_Yuri

MessagePosté le: Sam 15 Juin - 12:56 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Ouais, un truc de ce genre Gros matou qui ronronne
Ainsi, les deux commandes que t'as mis ne seront normalement pas modifier par ton script et seront exécutes par le jeu :b
Revenir en haut
Facebook Twitter
Ku'rei
Membre


Inscrit le: 10 Aoû 2010
Messages: 546
Adepte du NoMoreExcuses
Localisation: Chambéry
Masculin

MessagePosté le: Sam 15 Juin - 13:56 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Okay, c'est intégré. Concrete_Encounter possède maintenant une alternative pour lancer le combat. ^^ Merci
Revenir en haut
Sphinx
Scribe
Scribe


Inscrit le: 07 Jan 2008
Messages: 9 736
Localisation: Quelque part, dans le monde... Ou peut être sur une autre planète...
ID Steam: FaQuinator

MessagePosté le: Sam 15 Juin - 15:13 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Juste une petite interrogation : pourquoi les commentaires de ton script sont en anglais ? Pleurnicheur
Revenir en haut
Lonel
Membre


Inscrit le: 19 Mar 2012
Messages: 512
Mégalomane confirmé et diplômé
Localisation: J'ai oublié
Masculin

MessagePosté le: Sam 15 Juin - 15:28 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Je trouves que ça rends un peut la carte surchargée...
Enfin, bon, c'est mon opinion personnel, mais...
Revenir en haut
Ku'rei
Membre


Inscrit le: 10 Aoû 2010
Messages: 546
Adepte du NoMoreExcuses
Localisation: Chambéry
Masculin

MessagePosté le: Sam 15 Juin - 15:53 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Tout dépend de combien tu met en nombre de pas moyen, sur toutes mes map sauf la grand je suis à 10 pas moyen, tu peux mettre 5 voit moins et cela réduira le nombre Pokémon placé sur une map.
après c'est vrai que dans l'eau, je trouve que ça surcharge beaucoup.
Revenir en haut
Eurons くさ
Animateur
Animateur


Inscrit le: 23 Nov 2011
Messages: 1 040
La mort.
Localisation: Partout dans ce monde ou je puis ôter la vie.
Non renseigné (Visible...)

MessagePosté le: Sam 15 Juin - 16:00 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Après, moi je fais tous ceci en Event mais c'est une bonne initiative que tu as eu la Clin d'œil foireux
Revenir en haut
Skype
Ku'rei
Membre


Inscrit le: 10 Aoû 2010
Messages: 546
Adepte du NoMoreExcuses
Localisation: Chambéry
Masculin

MessagePosté le: Dim 16 Juin - 08:15 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Si tu fait tout en event, peut-être que mon Event_Copier pourrait t'intéresser.

MAJ : Ajout de la gestion des Pokémon Voyageurs (SUICUNE, LATIOS, ...)
Revenir en haut
Sphinx
Scribe
Scribe


Inscrit le: 07 Jan 2008
Messages: 9 736
Localisation: Quelque part, dans le monde... Ou peut être sur une autre planète...
ID Steam: FaQuinator

MessagePosté le: Dim 16 Juin - 13:51 (2013)    Sujet du message: Concrete Encounter / Pokemon sur la map

Remarque, tu t'appuies sans doute aussi sur un système équivalent pour ce script, non ?

^^ Si non, tu devrais peut être te baser dessus, ca éviterait la possible installation de deux scripts ayant comme effet parmi tant d'autre de permettre la duplication d'évents d'une map sur une autre Clin d'œil foireux

Quoiqu'il en soit, je n'ai pas testé, mais rien qu'à voir c'est un script qui a du te prendre pas mal de temps, et qui est réussi apparemment ^^ (même si je ne comprends pas pourquoi les commentaires sont en anglais Pleurnicheur)
Revenir en haut
Contenu Sponsorisé






MessagePosté le: Aujourd’hui à 07:56 (2017)    Sujet du message: Concrete Encounter / Pokemon sur la map

Revenir en haut
Montrer les messages depuis:   
Poster un nouveau sujet   Répondre au sujet    Pokémon Script Project Index du Forum -> Game Making -> Ressources techniques -> Scripts Toutes les heures sont au format GMT + 1 Heure
Aller à la page: 1, 2  >
Page 1 sur 2

 
Sauter vers:  

Index | Creer un forum | Forum gratuit d’entraide | Annuaire des forums gratuits | Signaler une violation | Conditions générales d'utilisation
Powered by phpBB © 2001, 2005 phpBB Group
Thème par Thomas et l'équipe de la refonte PSP 2012 (version 1.0)
Traduction par : phpBB-fr.com