Concrete Encounter / Pokemon sur la map

Posté par Ku'rei le 15 Juin - 07:52 (2013)
Titre : 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 :
- Pokemon a changement de map en fin de combat (Pokemon Voyageur)
- Persistance des Pokémon
17/06/13 - Les ajouts suivants :
18/06/13 - Les ajouts suivants :
- IMPORTANT : Ajout de standards pour certaines maps, implique une modification de la constante STANDARDS
- T2PC : Terrain Tag Probability Coefficient
- T3PC : Tileset Terrain Tag Probability Coefficient
- Déplacements Conditionnels
- La Repousse et les Déplacements Conditionnels sont appliqués aux Pokémons Voyageur

19/06/13 - Les ajouts suivants :

Replacement automatique des événements de Pokémon
Personnalisation des coordonnées approximative d'apparition d'un Pokémon Voyageur
Pokémon fuyant le combat (vidéo de démonstration)

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 :

VIDEO DU RENDU (17/06/13)

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)

Concrete_Encounter

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

Installation PSP4G+

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

Installation PSP DS

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:

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:

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 :
Image

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" :
Spoiler

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 :

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 :

Spoiler

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:

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]