Système d'échange par internet

Posté par alves57 le 31 Mar - 18:41 (2010)
Titre : Système d'échange par internet

Bonjour, aujourd'huit j'ai réussi à modifier la script de krosk pour pouvoir utiliser l'échange de pokémon par internet.
ps : je remercie berka pour le script permettant de télécharger et d'uploader des fichiers.

autreps : le système est en version béta, j'ai fait quelque test concluant, mais j'attent vos test pour être sur.

PREREQUIS

Avoir un serveur ftp(ex : lycosmultimania).

Puis créer un dossier Echange à la racine du serveur ftp.

SCRIPT A MODIFIER

Spoiler

Code:

#==============================================================================[/i]
# ■ TRADE
# Pokemon Script Project - Krosk - alves57
# 24/01/08
# 29/08/08 - Script complété
#-----------------------------------------------------------------------------
# Scène à ne pas modifier de préférence
#-----------------------------------------------------------------------------
# Gestion d'échange
#-----------------------------------------------------------------------------

TABLE = [
"0","1","2","3","4","5","6","7","8","9",
"a","b","c","d","e","f","g","h","i","j",
"k","l","m","n","o","p","q","r","s","t",
"u","v","w","x","y","z","A","B","C","D",
"E","F","G","H","I","J","K","L","M","N",
"O","P","Q","R","S","T","U","V","W","X",
"Y","Z","?","!"] # base 64

module POKEMON_S
  class Player
    def self.trainer_trade_code
      if POKEMON_S::TRADEGROUP == nil
        trade_group = 0
      else
        trade_group = POKEMON_S::TRADEGROUP
      end

      trade_bit_code = ""
      trade_bit_code += sprintf("%010d", trade_group.to_s(2))
      trade_bit_code += sprintf("%032d", Player.code.to_s(2))

      trade_string_code = ""
      for i in 1..7
        trade_string_code += TABLE[ trade_bit_code[(i-1)*6..(i*6-1)].to_i(2) ]
      end

      file = File.open("Echange/Mon_code.txt", "w")
      file.write(trade_string_code)
      file.close

      return trade_string_code
    end
  end
end

class Interpreter
  def pokemon_trade_code(pokemon, trade_string_code = nil)
    if trade_string_code == nil
      file = File.open("Echange/Son_code.txt", "r")
      trade_string_code = file.read(7)
      file.close
    end
    bit_code = ""
    bit_code += sprintf("%010d", pokemon.id.to_s(2))
    name_array = pokemon.trainer_name.unpack('c12')
    for value in name_array
      if value != nil
        bit_code += sprintf("%08d", value.to_s(2))
      else
        bit_code += sprintf("%08d", 0)
      end
    end
    bit_code += sprintf("%032d", Player.code.to_s(2))
    bit_code += sprintf("%032d", pokemon.code.to_s(2))
    shiny_code = pokemon.shiny ? 1 : 0
    bit_code += sprintf("%02d", shiny_code.to_s(2))
    bit_code += sprintf("%05d", pokemon.dv_hp.to_s(2))
    bit_code += sprintf("%05d", pokemon.dv_atk.to_s(2))
    bit_code += sprintf("%05d", pokemon.dv_dfe.to_s(2))
    bit_code += sprintf("%05d", pokemon.dv_spd.to_s(2))
    bit_code += sprintf("%05d", pokemon.dv_ats.to_s(2))
    bit_code += sprintf("%05d", pokemon.dv_dfs.to_s(2))
    bit_code += sprintf("%016d", pokemon.hp_plus.to_s(2))
    bit_code += sprintf("%016d", pokemon.atk_plus.to_s(2))
    bit_code += sprintf("%016d", pokemon.dfe_plus.to_s(2))
    bit_code += sprintf("%016d", pokemon.spd_plus.to_s(2))
    bit_code += sprintf("%016d", pokemon.ats_plus.to_s(2))
    bit_code += sprintf("%016d", pokemon.dfs_plus.to_s(2))
    name_array = pokemon.given_name.unpack('c10')
    for value in name_array
      if value != nil
        bit_code += sprintf("%08d", value.to_s(2))
      else
        bit_code += sprintf("%08d", 0)
      end
    end
    bit_code += sprintf("%024d", pokemon.exp.to_s(2))
    for i in 0..3
      if pokemon.skills_set[i] != nil
   skill = pokemon.skills_set
        bit_code += sprintf("%010d", skill.id.to_s(2))
        bit_code += sprintf("%06d", skill.pp.to_s(2))
        bit_code += sprintf("%06d", skill.ppmax.to_s(2))
      else
        bit_code += sprintf("%022d", 0)
      end
    end
    bit_code += sprintf("%04d", pokemon.status.to_s(2))
    bit_code += sprintf("%010d", pokemon.item_hold.to_s(2))
    bit_code += sprintf("%08d", pokemon.loyalty.to_s(2))
    bit_code += sprintf("%010d", pokemon.hp.to_s(2))
    bit_code += sprintf("%06d", $data_ball.index(pokemon.ball_data).to_s(2))

    bit_code += sprintf("%016d", pokemon.step_remaining.to_s(2))
    egg_code = pokemon.egg ? 1 : 0
    bit_code += sprintf("%02d", egg_code.to_s(2))
    bit_code += sprintf("%06d", pokemon.form.to_s(2))

    trade_bit_code = ""
    for i in 1..7
      trade_bit_code += sprintf("%06d", TABLE.index(trade_string_code[i][/i]).to_s(2))
    end

    srand(trade_bit_code.to_i(2)%(2**32))

    string_code = ""
    validation_key_high = 0
    validation_key_low = 0
    trigger = false
    for i in 1..92
      value = (bit_code[(i-1)*6..(i*6-1)].to_i(2)) ^ (rand(64))
      string_code += TABLE[value]
      if trigger
        validation_key_high ^= value
      else
        validation_key_low ^= value
      end
      trigger = (trigger == false)
    end

    # ---------- Sequence de redondance

    bit_code += sprintf("%010d", POKEMON_S::TRADEGROUP.to_s(2))
    validation_key = validation_key_low + validation_key_high*(2**6)
    validation_key ^= POKEMON_S::TRADEGROUP

    bit_code += "00"
    bit_code += sprintf("%012d", validation_key.to_s(2))

    for i in 93..96
      value = (bit_code[(i-1)*6..(i*6-1)].to_i(2))^(rand(64))
      string_code += TABLE[value]
    end
    srand
    file = File.open("Echange/Envoi.txt", "w")
    filee = File.open("Echange/" + trade_string_code + ".txt" , "w")
    file.write(string_code)
    filee.write(string_code)
    #file.write("     ")
    #file.write(bit_code)
    file.close
    filee.close

    Net::FTP.upload('./Echange/' + read_his_code + '.txt',"/Echange/" + read_his_code + ".txt")

    Player.erase_code(pokemon.code)
  end
  alias echange_transferer pokemon_trade_code


  def pokemon_trade_decode
    Net::HTTP.download('ftp://nom-utilisateur:motdepasse@addresse_serveur/Echange/' + Player.trainer_trade_code + '.txt', './Echange/')
    file = File.open("Echange/" + Player.trainer_trade_code + ".txt", "r")
    string_code = file.read(96)
    file.close

    trade_string_code = read_my_code
    trade_bit_code = ""
    for i in 1..7
      trade_bit_code += sprintf("%06d", TABLE.index(trade_string_code[i][/i]).to_s(2))
    end
    srand(trade_bit_code.to_i(2)%(2**32))

    bit_code = ""
    validation_key_high = 0
    validation_key_low = 0
    trigger = false
    for i in 1..92
      index = TABLE.index(string_code[i][/i])
      value = index ^ (rand(64))
      bit_code += sprintf("%06d", value.to_s(2))
      if trigger
        validation_key_high ^= index
      else
        validation_key_low ^= index
      end
      trigger = (trigger == false)
    end

    for i in 93..96
      index = TABLE.index(string_code[i][/i])
      value = index ^ (rand(64))
      bit_code += sprintf("%06d", value.to_s(2))
    end
    trade_groupe = bit_code[552..561].to_i(2)

    read_validation_key = bit_code[564..575].to_i(2)
    validation_key = validation_key_low + validation_key_high*(2**6)
    validation_key ^= trade_groupe

    if trade_groupe != POKEMON_S::TRADEGROUP and POKEMON_S::TRADEGROUP != 0
      return 1 # Erreur tradegroup
    end

    if read_validation_key != validation_key
      return 2 # Erreur de validation
    end

    pokemon = POKEMON_S::Pokemon.new(1,1)
    pokemon.bit_code_interpreter(bit_code)

    if existing_pokemon_check(pokemon)
      return 3
    end

    return pokemon
  end
  alias echange_lire pokemon_trade_decode

  def existing_pokemon_check(pokemon_to_check)
    return Player.trade_list.include?(pokemon_to_check.code)
  end

  def ajouter_pokemon_echange(pokemon)
    Player.register_code(pokemon.code)
    check = pokemon.evolve_check("trade")
    if check != false
      Graphics.freeze
      scene = POKEMON_S::Pokemon_Evolve.new(pokemon, check, 15000, true)
      scene.main
      Graphics.transition
    end
    ajouter_pokemon_cree(pokemon)
  end

  def read_my_code
    return Player.trainer_trade_code
  end

  def read_his_code
    if FileTest.exist?("Echange/Son_code.txt")
      file = File.open("Echange/Son_code.txt", "r")
      trade_string_code = file.read(7)
      file.close
    else
      trade_string_code = "0000000"
      write_his_code(trade_string_code)
    end
    return trade_string_code
  end

  def write_his_code(trade_string_code)
    file = File.open("Echange/Son_code.txt", "w")
    file.write(trade_string_code)
    file.close
  end

  def entrer_code_echange(code)
    Graphics.freeze
    Scene_Name.new(code).main
    Graphics.transition
    return true
  end

end

module POKEMON_S
  class Pokemon
    def bit_code_interpreter(bit_code)
      @id = bit_code[0..9].to_i(2)
      @trainer_name = ""
      name_array = []
      for i in 1..12
        value = bit_code[10+(i-1)*8..10+(i*8-1)].to_i(2)
        name_array.push(value)
      end
      name_array.delete(0)
      @trainer_name = name_array.pack('c*')
      @trainer_code = bit_code[106..137].to_i(2)
      @code = bit_code[138..169].to_i(2)
      @trainer_id = sprintf("%05d", @trainer_code % (2**16))
      @shiny = bit_code[170..171].to_i(2)
      @shiny = @shiny == 1 ? true : false
      archetype(@id)
      @dv_hp = bit_code[172..176].to_i(2)
      @dv_atk = bit_code[177..181].to_i(2)
      @dv_dfe = bit_code[182..186].to_i(2)
      @dv_spd = bit_code[187..191].to_i(2)
      @dv_ats = bit_code[192..196].to_i(2)
      @dv_dfs = bit_code[197..201].to_i(2)
      @hp_plus = bit_code[202..217].to_i(2)
      @atk_plus = bit_code[218..233].to_i(2)
      @dfe_plus = bit_code[234..249].to_i(2)
      @spd_plus = bit_code[250..265].to_i(2)
      @ats_plus = bit_code[266..281].to_i(2)
      @dfs_plus = bit_code[282..297].to_i(2)
      given_name_array = []
      @given_name = ""
      for i in 1..10
        value = bit_code[298+(i-1)*8..298+(i*8-1)].to_i(2)
        given_name_array.push(value)
      end
      given_name_array.delete(0)
      @given_name = given_name_array.pack('c*')
      @exp = bit_code[378..401].to_i(2)
      while @exp >= exp_list[@level+1]
        @level += 1
      end
      statistic_refresh
      @skills_set = []
      for i in 1..4
        id_skill = bit_code[402+(i-1)*22..411+(i-1)*22].to_i(2)
        if id_skill != 0
          skill = Skill.new(id_skill)
          skill.pp = bit_code[412+(i-1)*22..417+(i-1)*22].to_i(2)
          skill.define_ppmax(bit_code[418+(i-1)*22..423+(i-1)*22].to_i(2))
          skills_set.push(skill)
        end
      end
      @status = bit_code[490..493].to_i(2)
      @item_hold = bit_code[494..503].to_i(2)
      @loyalty = bit_code[504..511].to_i(2)
      @hp = bit_code[512..521].to_i(2)
      @ball_data = $data_ball[bit_code[522..527].to_i(2)]
      @nature = nature_generation
      @ability = ability_conversion
      @step_remaining = bit_code[528..543].to_i(2)
      @egg = bit_code[544..545].to_i(2)
      @egg = shiny == 1 ? true : false
      @form = bit_code[546..551].to_i(2)
    end
  end

end

A la ligne 166, remplacer nom-utilisateur par le login pour vous connecter a votre serveur ftp, motdepasse pour le mot de passe, et addresseserveur pour l'adresse de la racine de votre serveur.

SCRIPT A AJOUTER

Puis rajouter ce script de berka, permettant de faire des téléchargement depuis RPG MAKER XP, et aussi depuis PSP.

Spoiler

Code:

#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#                    Download & Upload Files with RGSS
#  par berka                      v 2.1                     rgss 2
#                          www.rpgmakervx-fr.com
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# ! Ne pas utiliser de serveur ftp contenant ds données perso et confidentielles
# ! ce script possède vos identifiants ftp: un  crack du projet les rend publics
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# Ftp :
#     ▼ Recevoir :
#           Net::Ftp.download("dos_sur_ftp/fichier.zip","./Graphics")
#     ▼ Envoyer :
#           Net::Ftp.upload("./Graphics/fichier.zip","/dos_sur_ftp/fichier.zip")
#     ▼ Créer un répertoire distant :
#           Net::Ftp.mkdir("/dos_sur_ftp")
# Http :
#     ▼ recevoir :
#           Net::Http.download("url","./Graphics")
#     ▼ total octets téléchargés :
#           Net::HTTP.transfered
#     ▼ Taille du fichier :
#           Net::HTTP.size("test.zip")
#     ▼ % de progression :
#           Net::HTTP.progress("test.zip")
#     ▼ temps de transfert individuel:
#           Net::HTTP.temps("test.zip")
#     ▼ fichiers à télécharger :
#           Net::HTTP.transfers
#     ▼ fichier téléchargé ? :
#           Net::HTTP.loaded?("test.zip")
#-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
module Berka
  module NetError
    ErrConIn="Impossible de se connecter à Internet"
    ErrConFtp="Impossible de se connecter au Ftp"
    ErrConHttp="Impossible de se connecter au Serveur"
    ErrNoFFtpIn="Le fichier à recevoir n'existe pas"
    ErrNoFFtpEx="Le fichier à envoyer n'existe pas"
    ErrTranHttp="Le téléchargement Http a échoué"
    ErrDownFtp="Le téléchargement Ftp a échoué"
    ErrUpFtp="L'envoi Ftp a échoué"
    ErrNoFile="Aucun fichier à télécharger"
    ErrMkdir="Impossible de créer le répertoire distant"
  end
end
module Net
  W='wininet'
  SPC=Win32API.new('kernel32','SetPriorityClass','pi','i').call(-1,128)
  IOA=Win32API.new(W,'InternetOpenA','plppl','l').call('',0,'','',0)
  IC=Win32API.new(W,'InternetConnectA','lplpplll','l')
  print(Berka::NetErrorErr::ConIn)if IOA==0
  module FTP
    FSCD=Win32API.new(W,'FtpSetCurrentDirectoryA','lp','l')
    FGF=Win32API.new(W,'FtpGetFileA','lppllll','l')
    FPF=Win32API.new(W,'FtpPutFile','lppll','l')
    FCD=Win32API.new(W,'FtpCreateDirectoryA','lp','l')
    module_function
    def init
      #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-#
      ftp="ftp.membres.multimania.fr"          #
      port=21                       #
      identifiant="*****"            #
      motdepasse="******"         #
      #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-#
      @fb=IC.call(IOA,ftp,port,identifiant,motdepasse,1,0,0)
      ftp,port,identifiant,motdepasse=[nil]*4 # efface les ids par sécurité
      (print(Berka::NetError::ErrConFtp))if @fb==0
    end
    def download(ext,int='./')
      init if @fb.nil?
      c=ext.split('/').pop
      if FSCD.call(@fb,ext.gsub(c,''))!=0
        print(Berka::NetErrorErr::ErrDownFtp)if FGF.call(@fb,c,"#{int}/#{c}",0,32,2,0)==0
      else
        print(Berka::NetErrorErr::ErrNoFFtpIn)
      end
    end
    def mkdir(rep)
      init if @fb.nil?
      print(Berka::NetErrorErr::ErrMkdir)if FCD.call(@fb,rep)==0
    end
    def upload(int,ext)
      init if @fb.nil?
      if FSCD.call(@fb,ext)&&File.exist?(int)
        print(Berka::NetErrorErr::ErrUpFtp)if FPF.call(@fb,int,ext,2,0)==0
      else
        print(Berka::NetErrorErr::ErrNoFFtpEx)
      end
    end
  end
  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  module HTTP
    IOU=Win32API.new(W,'InternetOpenUrl','lppllp','l')
    IRF=Win32API.new(W,'InternetReadFile','lpip','l')
    ICH=Win32API.new(W,'InternetCloseHandle','l','l')
    HQI=Win32API.new(W,'HttpQueryInfo','llppp','i')
    module_function
    def sizeloaded(i='');@read[i];end
    def transfered;@dloaded;end
    def transfers;@dls;end
    def progress(i='');(@read[i].to_f/@size[i]*100);end
    def loaded?(i='');@read[i]>=@size[i]rescue nil;end
    def temps(i='');@tps[i]if loaded?(i);end
    def size(i='');@size[i];end
    def download(url,int='./')
      @dloaded||=0;@dls||={};@i||=-1;@size||={};@read||={};@tps={}
      a=url.split('/');serv,root,fich=a[2],a[3..a.size].join('/'),a[-1]
      print(Berka::NetErrorErr::ErrNoFile)if fich.nil?
      @dls[fich]=Thread.start(url,int){|url,int|txt='';t=Time.now
      Berka::NetErrorErr::ErrConHttp if(e=IC.call(IOA,serv,80,'','',3,1,0))==0
      f=IOU.call(IOA,url,nil,0,0,0)
      HQI.call(f,5,k="\0"*1024,[k.size-1].pack('l'),nil)
      @read[fich],@size[fich]=0,k.delete!("\0").to_i
      loop do
        buf,n=' '*1024,0
        r=IRF.call(f,buf,1024,o=[n].pack('i!'))
        n=o.unpack('i!')[0]
        break if r&&n==0
        txt<<buf[0,n]
        @read[fich]=txt.size
      end
      (File.open(int+fich,'wb')<<txt).close
      @dloaded+=@read[fich]
      ICH.call(f);sleep(0.01)
      @tps[fich]=Time.now-t}
    end
  end
end

Vers les lignes 62, remplacer les information par les information de votre serveur.

FAITES ATTENTION : NE METTEZ AUCUNE INFORMATION PERSONNELLE OU IMPORTANTE SUR LE SERVEUR, CAR AVEC UN CRACK DU JEU, ON PEUT VOIR CES INFORMATION.JE NE SERAIS PAS TENU RESPONSABLE SI CELA ARRIVE.

Posté par FinalArt le 1 Avr - 18:42 (2010)

   Et le problème qu'il se pose, c'est bien qu'il faut l'acheter, ce serveur, et Psp est tout, sauf un site marketing,

   Je ne vois aucune autre solutions... A par peut-être de réalisé des codes...

   Je m'explique,

   Imaginons qu'une personne A veut échanger un pokémon avec une personne B
   Le pokémon de la personne A se nomme A1
   Le pokémon de la personne B se nommes B2

   Il faudrait créer un script, qui permet que quand on entre un code, un pokémon apparaisse de l'équipe, et qu'un autre disparaisse.

   Le code serrait de type :

Citation:

(x1; x2; x3; x4; x5; y1)

   x1 l'ID du pokémon envoyer
   x2 le niveau du pokémon
   x3 première attaque
   x4 deuxième attaque
   x5 x6 x7 x8... les autres attaque, puis les stats, la nature, le Do ect...

   y1 l'ID du pokémon à supprimer de l'équipe

   La personne A devra donner ce code à la personne B, pour que cette personne puisse recevoir le pokémon A1, et que le pokémon A1 de la personne A soit suprimmer, la personne B doit faire la même chose en retour.

   Schéma :

   Donc, pour faire un soit disant " échange ", il faut que A et B fassent chacun un code

   Ce code, sera composer de deux membres assemblés,
   Pour A, qui veut recevoir le pokémon B2 et supprimer le pokémon A1, il faudra un code ( x1; x2; x3... + y1 )
   x1 et tout les autres x--- définiront les caractéristiques du pokémon à recevoir, x1 son iD, x2 sont niveau, mais vraiment toute les caractéristique, et ce pokémon doit être ajouté à l'équipe,
   En même temps, le deuxième membre, il n'y a que y1, qui va définire l'ID du pokémon à supprimmer de l'équipe.

   Donc pour résumer, premier membre en x---, qui permet de définir les caractéristiques du pokémon " reçus ", mais véritablement, cela va créer le pokémon, avec les caractéristique qu'il a dans la partie de B, contenu dans ce code
Et le deuxième membre, simplement le y1 qui va définir l'ID du pokémon à " envoyer ", véritablement pour le supprimmer

   Et B devra faire la même chose

   Pas trop difficile, vu qu'il faudra définir en script que x1 est l'ID du pokémon à recevoir, x2 le niveau... et y1 le pokémon à supprimmer ( qui est entre guillemets, envoyés )

   Le code pour un échange avec des personnes A et B qui veulent s'échanger un Bulbizarre ( posseder par A ) et un Salamèche ( posseder par B ) donnerrait un code dans le genre, pour A :

(004; 05; ???; ???; ???; 001)
(ID [du pokémon à ajouter à l'équipe]; Niveau; caractéristique, caractéristique, caractéristique [il faudra mettre toutes les caractéristiques]; ID [du pokémon à suprimmer de l'équipe] )

   Et donc, B devra avoir comme code :

(001; 06; ???; ???; ???; 004)
(ID [du pokémon à ajouter à l'équipe]; Niveau; caractéristique, caractéristique, caractéristique [il faudra mettre toutes les caractéristiques]; ID [du pokémon à suprimmer de l'équipe] )

   Attention, il y aura tout de même un truc à s'échanger, le code. Juste en haut, les codes sont déjà échanger, cela veut dire, que au début, A à le code | (001; 06; ???; ???; ???; 004) | et B | (004; 05; ???; ???; ???; 001) |, ils devront donc s'échanger les deux codes

   Je prévoit, pour créer les codes, un générateur de ces codes, reprenant les informations en couleurs,

   Mais, il y a une faille, imaginons que quelqu'un veut tricher ( il devra être caler en script ) il pourrait se créer un code, en s'ajoutant un Arceus, et en se défaisant un Magicarpe, c'est pour çà qu'il faudrait créer une clé de sécurité.