[RESOLU]Un système d'évaluation comme dans Suikoden

Bonjour !

Je voudrais faire un magasin "d'évaluation" comme dans les Suikoden. Je m'explique : certains objet que l'on trouverait serait "inconnus", genre "Vase?". Si on se rend dans ce magasin, le marchant pourrait évaluer un prix de vente pour ces objets et nous proposer de l'acheter.
J'ai tenté de le faire en events mais j'ai vite abandonné tant la tâche me paraît colossale !
N'y aurait-il pas un moyen de simplifier cela ? Pour info, j'ai le script "Item Categorization - KGC_CategorizeItem" qui permet de classer des objets par catégorie...

On peut facilement faire un tableau d'association avec differente probabilité.
Genre "Vase??" d'id 3 a 10 % de chance d'etre un "Super vase", 35 % d'etre un "Super beau vase", ...
Chaque objet etant bien entendu definie dans la BDD.
( On peut utiliser la note pour faire les config' ).
Le prix de l'objet "Vase??" determine le prix de l'evaluation, on choisi l'objet final aléatoirement, on l'echange.
Apres la partie revente, c'est du classique, les nouveaux objets ayant un prix differents du "Vase??".

Ca te convient comme systeme ?
Il te faut une scene pour l'evaluation ou tu gere en event ?

Ce serait vraiment cool avec une scene...

Et le systeme te convient tel quel ?

c'est nickel !

comme Ashka ou tu crait deux trois "vase?" et par evennement du dit
"que voulez vous examiner?"
choix : [vase, sculpture, peinture, rien]
si "vase"
si vase? (id35, parexemple) est possédé.
ajout vase banal
retirer 25 or
retirer vase? (id35)
"Vous obtenez un simple vase en terre !"
fin
si vase? (id36) est possédé
ajout beau vase
retirer25 or
retirer vase? id 36
"Vous obtenez un beau en porcelaine !"
fin
si vase? id37 est possédé
ajout vase vénitien
retirer 25 or
retirer vase? id37
"Vous obtenez un vase magnifque en porcelaine émaillé d'un des plus artiste de l'antique Venise !"
sinon
"vous n'avez pas de vase? !"
fin
si sculpture
.
.
.
tu repette çà pour sculpture est peinture si tu as plus de quatre catégorie
tu fais choix
étiquette 1
choix [Peinture, vase, sculpture, suivant]
si peiture
blablabla
si suivant
étiquette2
choix [précédent, vaiselle, bouteille, suivant]
si précédent
allez étiquette 1
si vaiselle
blablabla
si suivant
choix [précédent, arme, armure, rien]
si précédent
aller à l'étiquette 2
si arme
blablabla
si rien
"Aurevoir!"

pourquoi une ID au vase ? ne serait-il pas plus simple de n'avoir qu'un seule vase et une variable aléatoire qui fasse gagner plus ou moins de sous ?
Tiens je te montre:

-choix ...
-si "vase" :
-modifier une variable [0001] = une valeur aléatoire entre 1 et 100
-condition si la variable [0001] < 20
--ajouter "vieux vase"
--retirer 25 or
--retirer "vase?"
--message "ce vase est une vrai daube !"
-sinon
--condition si la variable [0001] < 40
ect...

Voila

c'est un choix, je n'aime pas trop le aléatoire donc j'aurai fait comme çà ^^
sinon c'est bon aussi mais apparemment Joey à pris l'autre solution ^^

Je suis rester simple, si tu veux des améliorations, faudra demander ...

Bon, d'abord les explications.

Voici à quoi devra ressembler la note d'un objet à evaluer ( exemple "Vase??" ) :



La premiere ligne, tu la reconnait, c'est la categorie telle que tu la defini pour la script KGC.
Faudra configurer le debut de mon script pour qu'il reconnaisse cette categorie.

Les lignes suivantes, ce sont les objets que l'evaluation pourra donner.
Faut respecter la forme "EVA=" + nombre + "-" + autre nombre.
Une ligne par objet, autant de ligne que tu veux.
Le premier nombre est l'ID de l'objet "à decouvrir" ( Exemple : "Beau vase" ).
Le second, c'est la probabilité.

Pour que tu puisse choisir au mieux ce nombre, voici comment ça fonctionne au moment du "tirage au sort".
Je prends le premier objet possible, c'est-à-dire celui à la plus forte proba defini dans la note.
Je choisi un nombre aléatoire entre 0 et 99 que je compare à cette proba.
S'il est inferieur, l'objet est "choisi", sinon, je passe à l'objet suivant de la liste ( donc une proba un peu plus faible ).
Si au final, rien n'a été choisi par cette methode, l'objet choisi par defaut sera avec la plus grosse proba ( donc celui qui avait été examiné en premier ).

Si tu veux un autre systeme de tirage au sort, faudra demander ...

Le prix à payer pour expertise est le prix de l'objet à expertiser ( celui de "Vase??" )
La valeur est le prix de l'objet tiré au sort ( celui de "Beau vase" )

Ensuite, les screens :



Comme tu le remarque, j'ai laissé une zone vide à droite.
Je te suggere de placer un "Deplacer ecran" avant et apres l'appel de script pour que lors de l'evaluation, on vois bien le comptoir.
( Un peu comme sur le screen ... sauf qu'il y a pas de comptoir ... )



Comme déjà dit, je suis resté simple, si tu veux des améliorations, faudra demander ...

Reste le script :

Code:

###################################
module Evaluation
# Place de la categorie "Evaluable" dans la liste CATEGORY_IDENTIFIER du script KGC
# ( en comptant à partir de 0 )
  Eval_type = 7
end
###################################
class String
  def decoupe
    bloc = []
    self.split(/[\r\n]+/).each { |line| bloc.push(line) }
    return bloc
  end
end
###################################
module RPG
  class Item < UsableItem
    def eval_list
      list = []
      text = @note.decoupe
      for line in text
        if line.include?("EVA=")
          list.push(line.delete("EVA=").split("-"))
        end
      end
      return list.sort { |a, b| b[1].to_i <=> a[1].to_i }
    end
  end
end
###################################
class Scene_Expertise < Scene_Base
  def start
    create_menu_background
    @entete = Window_Help.new
    @desc = Window_Help.new
    @desc.y = 56
    @gold = Window_Gold.new((544/2)+((544/4)-(160/2)), 2*56)
    @win_expert = Win_Expertisable.new(0, 56*2, 544/2, 416-(2*56))
    @win_expert.help_window = @desc
    @expertise = nil
    @final = nil
  end
 
  def terminate
    dispose_menu_background
    @entete.dispose
    @desc.dispose
    @gold.dispose
    @win_expert.dispose
    @expertise.dispose if @expertise != nil
    @final.dispose if @final != nil
  end
 
  def update
    update_menu_background
    @gold.update
    if @final != nil
      update_final
    elsif @expertise != nil
      update_expertise
    else
      update_choix
    end
  end
 
  def update_choix
    @entete.set_text("Choississez l'objet que je dois evaluer", 1)
    @win_expert.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      @item = @win_expert.item
      if @item != nil and @win_expert.enable?(@item)
        Sound.play_shop
        $game_party.lose_gold(@item.price)
        $game_party.lose_item(@item, 1)
        @expertise = Win_Evaluation.new(@item)
      else
        Sound.play_buzzer
      end
    end
  end
 
  def update_expertise
    @entete.set_text("Expertise en cours, veuillez patienter !!", 1)
    @expertise.refresh
    if @expertise.timer > 180
      id = @item.eval_list[0][0].to_i
      for bloc in @item.eval_list
        test = rand(100) <= bloc[1].to_i
        if test
          id = bloc[0].to_i
          @result = $data_items[id]
          @final = Final_Expertise.new(@result)
          @expertise.dispose
          @expertise = nil
          break
        end
      end
    end
  end
 
  def update_final
    @entete.set_text("Que voulez vous faire de cet objet ?", 1)
    @final.update
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      Sound.play_decision
      if @final.index == 0
        $game_party.gain_gold(@result.price)
      else
        $game_party.gain_item(@result, 1)
      end
      $scene = Scene_Expertise.new
    end
  end

end
###################################
class Win_Expertisable < Window_Item
  def initialize(x, y, width, height)
    super(x, y, width, height)
    @column_max = 1
    self.index = 0
    refresh
  end
  def include?(item)
    return false if item == nil
    return false unless item.is_a?(RPG::Item)
    return item.item_category.include?(Evaluation::Eval_type)
  end
  def enable?(item)
    return item.price <= $game_party.gold
  end
  def refresh
    @data = []
    for item in $game_party.items
      next unless include?(item)
      number = $game_party.item_number(item)
      number.times do
        @data.push(item)
      end
    end
    @item_max = @data.size
    create_contents
    for i in 0...@item_max
      draw_item(i)
    end
  end
  def draw_item(index)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      enabled = enable?(item)
      rect.width -= 4
      draw_item_name(item, rect.x, rect.y, enabled)
      self.contents.draw_text(rect, sprintf("%2d", item.price), 2)
    end
  end
end
###################################
class Win_Evaluation < Window_Base
  attr_reader :timer
  def initialize(item)
    w = 232
    super((544/2)-(w/2), (416/2)-(56/2), w, 56)
    @item = item
    @timer = 0
    refresh
  end
  def refresh
    self.contents.clear
    @timer += 1
    text = "Evaluation "
    n = @timer / 30
    n.times do
      text += "."
    end
    self.contents.draw_text(50, 0, 200, 24, text)
  end
end
###################################
class Final_Expertise < Window_Selectable
  def initialize(item)
    w = 232
    super((544/2)-(w/2), (416/2)-(56/2), w, 4*24+32)
    @item = item
    @active = true
    @index = 0
    @item_max = 2
    @column_max = 1
    refresh
  end
  def refresh
    self.contents.clear
    draw_item_name(@item,30, 0, true)
    self.contents.draw_text(0, 24, self.width-32, 24, "Valeur estimé : #{@item.price} "+Vocab::gold, 1)
    self.contents.draw_text(0, 2*24, self.width-32, 24, "Vendre l'objet", 1)
    self.contents.draw_text(0, 3*24, self.width-32, 24, "Garder l'objet", 1)
  end
  def item_rect(index)
    rect = Rect.new(0, 0, 0, 0)
    rect.width = (contents.width + @spacing) / @column_max - @spacing
    rect.height = WLH
    rect.x = 0
    rect.y = (index + 2) * WLH
    return rect
  end
end
###################################


Derniere chose, la scene s'appelle grace à l'insertion de script suivante :

Code:

$scene = Scene_Expertise.new

Voila, je crois que c'est tout ...

Géant ! Un tout grand merci ! Je teste dès que je peux et je te dis quoi !

Ce qui serait sympa , serait de le faire indépendant du KGC
car un système d'évaluation, c'est une bonne idée pour des armes ou autre ^^

Pas testé mais en théorie, suffit juste de mettre ça en dessous :

Code:

class Win_Expertisable < Window_Item
  def include?(item)
    return false if item == nil
    return false unless item.is_a?(RPG::Item)
    return item.eval_list != []
  end


ok je garde le script sous la main ^^ merci