AutoUpdate

[blendman]

salut

J'update ce sujet, car j'ai testé la méthode et ça marche nickel

Cependant, j'ai une autre interrogation :
- comme il s'agit d'un jeu en ligne, les updates seront assez courants.

Imaginons 2 joueurs A et B qui téléchargent la version 0.1 :
- le joueur A met à jour régulièrement le jeu
- le joueur B ne joue jamais

Arrivé à la version 0.4, il existe une nouvelle version 0.5 :
- le joueur A télécharge donc la nouvelle version
- et le joueur B qui se connecte à nouveau doit mettre à jour

Mais si le joueur B ne télécharge que la version 0.5 (qui est un update, pas une version complète), il lui manquera des choses pour jouer.

Alors, comment feriez-vous pour ce genre de choses ?
Etant donné que je vérifie d'après un fichier texte le numéro de version, je pourrais faire ceci :
- si la version actuelle est <0.2 --> télécharge maj02.exe
- si la version actuelle est <0.3 --> télécharger maj03.exe
etc..

Avez -vous une autre méthode pour ce genre de cas de figure ?
Merci

[case]

salut, une approche a creuser peut être, sans doute optimisable

un fichier en local : version.txt

version.txt

Code : Tout sélectionner

1.0

un fichier distant : manifest.txt qui contient tout les infos sur les patch precedents

manifest.txt

Code : Tout sélectionner

version_3_0M.dat,900000
version_3_0U.dat,90000
version_2_6U.dat,35000
version_2_5U.dat,35000
version_2_4U.dat,35000
version_2_3U.dat,35000
version_2_1U.dat,40000
version_2_0M.dat,800000
version_2_0U.dat,70000
version_1_7U.dat,250000
version_1_6U.dat,405000
version_1_3U.dat,99000
version_1_1U.dat,150000
version_1_0M.dat,500000

mon idée a creuser, le programme ajoute a une liste les fichiers a télécharger
et tiens compte de leur taille pour décider si il ajoute la version majeure ou ajoute toute les updates.
ceci bien évidement dans le but de garder de la bande passante...

les fichiers manifest.txt et version.txt sont a sauver dans le répertoire du programme, étant un test je n'ai bien sur pas integré de download depuis un serveur...

Code : Tout sélectionner

Structure upd
   filename.s  ; fichier distant
   size.i      ; taille en octet
   type.b      ; 
   number.i    ; utilisé pour trier
EndStructure
;
;
Declare getversion(info$)
Declare type(info$)
NewList calculate.upd()   
NewList download.upd()
; RECUPERE LA VERSION ACTUELLE DU LOGICIEL
rd=ReadFile(#PB_Any,"version.txt") ; fichier local contenant la version actuelle du logiciel
If RD
   version$=ReadString(rd)
   CloseFile(rd)
EndIf
;
; recupere la liste des patches disponibles 
;
rd=ReadFile(#PB_Any,"manifest.txt") ; en local pour l'exemple mais ce fichier doit etre sur le serveur distant.
If RD
   Repeat
      l$=ReadString(rd)
      If getversion(l$)<>ValF(version$      )
         AddElement(calculate())
         calculate()\filename=StringField(l$,1,",")
         calculate()\type=type(StringField(l$,1,","))
         calculate()\size=Val(StringField(l$,2,","))
         calculate()\number=ListIndex(calculate())
      Else 
         Break ; on sort si on arrive a la version deja utilisée 
      EndIf
   Until Eof(rd)         
   CloseFile(rd)
   ; ajoute a la liste des telechargement les updates les plus recentes jusqu'a la derniere version majeure
   Repeat
      FirstElement(calculate())                ; reviens au debut de la liste  
      If calculate()\type=0 ; minor         
         AddElement(download())
         CopyStructure(@calculate(),@download(),upd)
         DeleteElement(calculate(),1)
      Else
         Break
      EndIf
   Until NextElement(calculate())=0
   latestmajor.upd
   FirstElement(calculate())                ; reviens au debut de la liste  
   CopyStructure(@calculate(),@latestmajor,upd)   ; recupere les infos de la derniere update majeure
   ; 
   Repeat
      major.upd
      FirstElement(calculate())                ; reviens au debut de la liste  
      CopyStructure(@calculate(),@major,upd)   ; recupere les infos de l'update majeure
      DeleteElement(calculate(),1)             ; suprime l'update majeure de la liste de telechargement possibles
      FirstElement(calculate())
      totalsize=0
      Repeat
         If calculate()\type=0                 ; il s'agis d'une update
            Debug calculate()\filename
            totalsize + calculate()\size       ; ajoute la taille des patch
            If ListIndex(calculate())<ListSize(calculate())-1 ; jusqu'a la fin de la liste
               NextElement(calculate())           
            Else 
               Break
            EndIf
         Else
            Break
         EndIf
      ForEver 
      ;     
      Debug totalsize
      If totalsize>=major\size                 ; la taille des patch cumulatifs est superieur ou egal a la taille de l'update majeure
         AddElement(download())     
         CopyStructure(@major,@download(),upd) ; ajout de l'update majeure a la liste de telechargements
      EndIf
      Repeat
         FirstElement(calculate())      
         If calculate()\type=0                             ; il s'agis d'une update
            If totalsize<major\size                        ; la taille de l'update majeure est superieure au patch cumulatifs
               AddElement(download())           
               CopyStructure(@calculate(),@download(),upd) ; ajout de l'update cumulative a la liste de telechargements
            EndIf
            DeleteElement(calculate(),1)                   ; suprime l'update cumulative de la liste de telechargement possibles
         Else
            Break
         EndIf
      Until ListSize(calculate())=0                  
   Until ListSize(calculate())=0
EndIf
;
ForEach(download())
   If getversion(download()\filename)<=getversion(latestmajor\filename)
      sizedl +download()\size
   EndIf
Next
If sizedl>=latestmajor\size ; meme taille en patch cumulatifs ou plus grand   
   ForEach(download())
      If getversion(download()\filename)=getversion(latestmajor\filename) ; version majeure remplace les telechargements
         CopyStructure(@latestmajor,@download(),upd)
         Break
      EndIf
   Next
   NextElement(download())
   Repeat
      DeleteElement(download())
   Until NextElement(download())=0   
EndIf
; affichage des resultats
;
Debug "PATCHES A TELECHARGER pour passer de la version "+version$+" a la derniere version " 
;

SortStructuredList(download(),#PB_Sort_Descending,OffsetOf(upd\number),#PB_Sort_Integer) ; tri la liste de la plus ancienne vers la plus recente 

ForEach(download())
   Debug download()\filename   
Next

;
;
;

Procedure getversion(info$)
   file$=StringField(info$,1,",")   
   pos=FindString(file$,"_")
   Debug ValF(StringField(Mid(file$,pos,Len(file$)-(pos+4)),2,"_")+"."+StringField(Mid(file$,pos,Len(file$)-(pos+4)),3,"_"))
   ProcedureReturn ValF(StringField(Mid(file$,pos,Len(file$)-(pos+4)),2,"_")+"."+StringField(Mid(file$,pos,Len(file$)-(pos+4)),3,"_"))
EndProcedure
Procedure type(info$)   
   Select Mid(info$,Len(info$)-4,1)
      Case "U"
         ProcedureReturn 0
      Case "M"
         ProcedureReturn 1
   EndSelect   
EndProcedure

[Ar-S]

Je vois pas trop le soucis. Il faut que ton patch le plus récent incluent tous les fichiers nécessaires au bon fonctionnement du jeu, peu importe la version précédente.
Ainsi,
Si A passe de 0.1 à 0.5 et B passe de 0.4 à 0.5, dans les 2 cas ça marche.
Les patchs sont un peu plus gros mais tout de même, avec un débit "commun", ça se fait vite.

[case]

je ne suis pas d'accord avec ton affirmation ar-s

"ça se fait vite" dépend aussi grandement de comment tu héberge ton jeu, si c'est sur un pc a la maison et que t'as 3 utilisateurs qui patchent en même temps tu risque des ralentissements importants...

[blendman]

Merci case, grâce à ta méthode, j'ai réussi à trouvé une technique qui fonctionne très bien et qui est très simple : elle ne télécharge que les fichiers nécessaires, et ce d'après un simple fichier ini .

EDIT : par contre, je me demandais comment on devait faire avec une archive (genre .pack)

Imaginons que j'ai un pack et dans celui-ci 5 images, si je dois en changer 1 seule, dois-je télécharger à nouveau le .pack complet ?

[case]

je pense que oui, a moins que tu intègre a ton patcheur un module pour repacker les pack. et donc si tu met juste a jour une image dans un pack, tu ne télécharge que l'image et ton patcheur mette le pack a jour lui même...

une solution serait d'avoir un logiciel qui crée des patch avec juste les modifications ça demande une comparaison octet par octet a mon avis.


exemple tu as un fichier texte avec une phrase dedans.
v1.0
bonjour.txt
"bonjour il fait beau"

tu veux y ajouter "super "

v1.1
bonjour.txt
"bonjour il fait super beau"

ton logiciel vas prendre le fichier v1.0 et le comparer au fichier v1.1

donc octet
1 b 2 o 3 n etc...
1 b 2 o 3 n etc... la il n'écrit rien dans sa base de donnée interne

il arrive a super dans la version 1.1

ca vas donner

18 b
18 s

donc tu n'incrémente plus le premier fichier et il continue de lire le second en stockant les octets differents
18 b 18 b 18 b 18 b 18b 18 b 18 b
18 s 19 u 20 p 21 e 22 r 23 24 b

si le patcheur trouve a nouveau l'octet attendu il défini les octets précédents comme une insertion

donc il stocke la chaine , le type de patch et la position

18 i "super "

a la fin pour patcher ce fichier tu aura un petit fichier

avec noté "bonjour.txt,18,i,6,super " comme ca s'aplique aussi a du binaire il est sage d'avoir la taille du patch avant les donées brutes. pour eviter les problemes

le patcheur vas lire ce fichier il vas trouver le nom du fichier a patcher, l'ouvrir et le lire, avancer jusqu’à l'octet 18 , ecrire les nouvelles données et ecrire la suite du fichier original

de ce fait tu peux très bien patcher un fichier pak ou tu aura juste modifié une image ne ne téléchargeant que les données modifiées réellement.

dans le cas de fichier compressés c'est possible que ça fonctionne mal du fait que la compression vas melanger les données de la nouvelle image a des données d'autres images et modifier pas mal le fichier par rapport a l'original.

cette méthode n'est pas très bonne pour les petits fichiers comme mon exemple...

bien sur une fois le fichier patch crée tu peux encore le compresser pour gagner de la place pour l'envoi...

[blendman]

ok, merci, je comprends l'idée .

je pense qu'au début, le plus simple sera de renvoyer le .pack lol, car vu qu'il sera compressé et peut être encrypté, ça risque d'être plus galère à juste changer 1 image, la repacker, compreseer, encrypter que de télécharger à nouveau le .pack

Mais je garde ton idée sous le coude, lorsque je serai plus avancé en pb, je m'y re-pencherai c'est certain, encore merci .

[Geo Trouvpatou]

Salut.

J'ai fait un système de Maj pour un script de livre d'or en php que je diffuse.

Voici grosso-merdo le principe.

La personne installe mon software qui contient un client Ftp (Pour envoyer le script php sur son serveur), ainsi que le vérificateur de Maj et le fichier qui contient le numéro de cette 1ère version.
La version de départ du script est la v2.0.0 (2000000)

J'utilise la bibliothèque Preference.

Donc en local elle à un fichier :
__NumeroDeVersion_Script_Local.pcfg avec ce contenu :

[Grp_NumeroDeVersion_Script_Local]
; Version du script A.I-Pifou, Livre d'or de l'utilisateur [Local].
versionDuScript_Local = 2000000

Lorsque l'on clique sur vérifier les mises à jour, cela télécharge sur mon site ce fichier :
_NumeroDeVersion_Exe_Script_SiteOfficiel.pcfg avec ce contenu :

[Grp_NumeroDeVersion_Exe_Script_SiteOfficiel]
; Version en cours sur le site officiel du script A.I-Pifou, Livre d'or.
2000001
2000002
2000004

Pour 2000001, 2000002 et 2000004, ceci correspond aux différentes mises à jour qu'il y a eu avec le temps.

Ensuite comparaison entre ces 2 fichiers.

Il y a 3 mises à jour.

Donc celles-ci vont être faite l'une à la suite de l'autre.
Mais pour ne pas télécharger la totalité des fichiers, on ne va télécharger que ceux qui ont été modifiés.
Pour passer à la v2.0.1 on se connecte sur mon site et l'on télécharge dans le dossier : maj_2000001 le fichier :
_Fichier_Maj_xxx.pcfg dont le contenu est :

[Grp_DescriptionMaj]
; Description de la mise à jour.
data_100 = Mise à jour : 2.0.1
data_200 =
data_300 = *La mise à jour permet de rectifier les bugs suivants :
data_320 =
data_340 = > Fixé : Mise à jour de toutes les fonctions dépréciées en PHP5
data_399 =
data_400 = > Fixé : Bug sur l'interface de signature, lorsque l'on appuyait sur un bouton "?" pour faire apparaître l'aide.
data_500 = Si on appuyait sur tous les boutons, toutes les aides étaient présentes.
data_600 = Alors que le but était de ne faire apparaître que l'aide du dernier bouton sur lequel on avait appuyé.
data_700 =
data_710 = > Modifié : Captcha.
data_800 =
data_810 = > Ajouté : Fichier PHP info, pour connaître la version de son serveur PHP ainsi que les extensions installées.
;
;
[Grp_ListeFichiersATelecharger]
; Liste des fichiers à télécharger.
data_0 = livre_lire.pifou
data_1 = livre_signer.pifou
data_2 = parametrage_livre.pifou
data_3 = upload.pifou
data_4 = verification_fichiers.pifou
data_5 = inc/function.pifou
data_6 = inc/inc_verf_chps.pifou
data_7 = inc/js_parametrage_livre.js
data_8 = inc/meta.pifou
data_9 = inc/page_haut_image.pifou
data_10 = inc/vars_init_no_exist.pifou
data_11 = inc/vars_init_param.pifou
data_12 = inc/vrs.dat
;
;
[Grp_ListeDossiersACreer]
; Liste des dossiers à créer.
;
;
[Grp_ListeChmodAAppliquer]
; Liste des fichiers à Chmoder.

Comme indiqué dans le fichier Prefs :
[Grp_DescriptionMaj] = Description de la mise à jour.
[Grp_ListeFichiersATelecharger] = Liste des fichiers à télécharger.
[Grp_ListeDossiersACreer] = Liste des dossiers à créer : Ici dans certains cas, il se peut qu'un nouveau dossier soit créé au fur et à mesure de ta programmation, donc il faut le créer en local avant de pouvoir envoyer des fichiers dedans, parce que si le dossier n'existe pas, le fichier partira dans le monde des limbes.

Bien évidemment tous les fichiers, dossiers et sous-dossiers de [Grp_ListeFichiersATelecharger] se trouvent aussi dans le dossier maj_2000001.
Ceux-ci sont téléchargés et écrasent les fichiers existants.

Pour te rendre compte de l'interface onglet 1, avec le numéro de version actuel et la dernière version ainsi que la description, voir cette image - Onglet 1.

Et si mise à jour il y a, on peut passer dans l'onglet 2, sinon cela n'est pas possible.
voir cette image - Onglet 2.
Dans mon cas, les personnes téléchargent les fichiers en local, pour les envoyer ensuite sur leur serveur, c'est pour ça qu'il y des stringGadgets pour se connecter sur son compte.

Et ensuite une fois cette Maj effectuée, rebelote avec la v2.0.2 et v2.0.4

Donc pas de problème avec ceux qui ont des retards de mise à jour et ceux qui les font régulièrement.

Cela reprend un peu le principe de ce qui a été dit par certains.

Bye.

[case]

Geo Trouvpatou ton système est bon mais peut être que tu devrais télécharger tout les fichiers ini en premier pour toute les maj a faire d'un coup plutôt que faire chaque maj séparée a la suite. car si tu modifie le même fichier dans plusieurs maj tu vas le télécharger 3 fois (dans ton exemple) au lieu de ne télécharger que la dernière version.

[Geo Trouvpatou]

Salut.

Geo Trouvpatou ton système est bon mais peut être que tu devrais télécharger tout les fichiers ini en premier pour toute les maj a faire d'un coup plutôt que faire chaque maj séparée a la suite. car si tu modifie le même fichier dans plusieurs maj tu vas le télécharger 3 fois (dans ton exemple) au lieu de ne télécharger que la dernière version.

En réalité, dans mon cas c'est un peu plus complexe que ça.
Parce que _NumeroDeVersion_Exe_Script_SiteOfficiel.pcfg n'a pas rééllement ce contenu :

[Grp_NumeroDeVersion_Exe_Script_SiteOfficiel]
; Version en cours sur le site officiel du script A.I-Pifou, Livre d'or.
2000001
2000002
2000004

Mais celui-ci :

[Grp_NumeroDeVersion_Exe_Script_SiteOfficiel]
; Version en cours sur le site officiel du script A.I-Pifou, Livre d'or.
; =
; Version en cours sur le site officiel de l'executable A.I-Pifou, Maj.
2000001 = 1000000
2000002 = 1000000
2000003 = 1000000
2000004 = 1000000

A gauche c'est la version du script et à droite, c'est la version de l'updateur.

Pour essayer de faire simple, en prenant un petit exemple, le fichier pourrait correspondre à ça :

[Grp_NumeroDeVersion_Exe_Script_SiteOfficiel]
; Version en cours sur le site officiel du script A.I-Pifou, Livre d'or.
; =
; Version en cours sur le site officiel de l'executable A.I-Pifou, Maj.
2000001 = 1000000
2000002 = 1000000
2000003 = 1000001
2000004 = 1000002

Imaginons que dans la v2.0.3 je décide de modifier la structure du fichier contenant les messages du livre d'or, par défaut mon updateur ne fait que ce que j'ai expliqué dans mon post précédent.
Il faut donc que je vérifie dans 1 premier temps que la personne a bien la bonne version de l'updateur et si ce n'est pas le cas, de télécharger celui-ci qui fera donc ce qui est expliqué dans mon post précédent + Modif de la structure du fichier contenant les messages du livre d'or.
Et forcemment à la mise à jour suivante il faut télécharger la nouvelle version de l'updateur qui ne fera plus la modif de la structure du fichier contenant les messages.

Pour ce que tu dis Case, c'est qu'il faut penser aux retardataires

Imaginons qu'à la base mon script v1.0 contient ces fichiers :

admin_pass.pifou
ajout_blacklist_flood.pifou
choix_design.pifou
livre_lire.pifou
livre_signer.pifou

Dans ma v1.1 j'ai modifié :

livre_lire.pifou
livre_signer.pifou

Je le met donc dans ma maj v1.1

Dans ma v1.2 j'ai modifié :

admin_pass.pifou
ajout_blacklist_flood.pifou
choix_design.pifou

Donc là, 2 cas de figure :

1er cas (Ma technique, peu de fichier à chaque fois) Dans ma maj v1.2 je ne met que les 3 fichiers modifiés, auquel cas, le retardataire doit télécharger et installer la maj v1.1 et ensuite pareil pour la maj v1.2

2ème cas (Plus simple, mais plus de fichiers à la longue): Dans ma maj v1.2 je met tous les fichiers modifiés depuis le début du script, c'est à dire :
Maj v1.2:

admin_pass.pifou
ajout_blacklist_flood.pifou
choix_design.pifou
livre_lire.pifou
livre_signer.pifou

Donc maintenant imagine à la version 1.8, si j'ai modifié au fil du temps chaque fichiers, à un moment donné, je vais devoir filé un dossier Maj avec la totalité des fichiers du script.

Depuis 2003 que mon script existe, tu penses bien que 100% des fichiers ont été modifiés, ce qui fait qu'aujourd'hui, c'est 309 fichiers que je devrais diffuser à chaque maj.
Alors qu'avec ma technique, ça peut être 4, 10, ou une trentaines de fichier, c'est tout.

Je m'étais fait cette réflexion dés le début c'est pour cela que j'ai opté pour ma solution.
Même si un fichier ne pèse quasiment rien et que cela est rapide à uploader.

Bye.

[case]

ce que je veux dire c'est que si par exemple sur le script 1.2 tu change

admin_pass.pifou
ajout_blacklist_flood.pifou
choix_design.pifou
livre_lire.pifou
livre_signer.pifou


que sur la v1.3 tu change

admin_pass.pifou
livre_lire.pifou
livre_signer.pifou
blah.pifou
bidule.pifou

que sur la 1.4 tu change

choix_design.pifou
autrefichier.pifou
autrefichier2.pifou

on est bien d'accord que quelqu'un qui passerais de la 1.0 a la 1.4 et qui ferais donc toute les mises a jour a la suite vas devoir télécharger

2 fois (maj 1.2 et maj 1.3)

admin_pass.pifou
livre_lire.pifou
livre_signer.pifou

et 2 fois (maj 1.2 et maj 1.4)
choix_design.pifou

alors que si ton logiciel prend tout les scripts des versions entre la V1.1 et la V1.4 et qu'il regarde les fichiers modifiés dans la dernière mise a jour et y ajoute les fichiers mis a jour dans les mises a jour précédentes non présents dans sa liste de téléchargement au final tu vas en télécharger moins .

mise a jour 1.4 il prend tout car c'est la derniere maj

telechargements :

choix_design.pifou
autrefichier.pifou
autrefichier2.pifou

il verifie les fichiers de la 1.3

admin_pass.pifou
livre_lire.pifou
livre_signer.pifou
blah.pifou
bidule.pifou

aucun de ces fichiers n'est présent dans la liste de téléchargements
il les ajoutes tous

telechargement :

choix_design.pifou
autrefichier.pifou
autrefichier2.pifou
admin_pass.pifou
livre_lire.pifou
livre_signer.pifou
blah.pifou
bidule.pifou

il verifie la v1.2

admin_pass.pifou
ajout_blacklist_flood.pifou
choix_design.pifou
livre_lire.pifou
livre_signer.pifou

admin_pass.pifou est deja dans la liste il le passe
choix_design.pifou est deja dans la liste il le passe
livre_lire.pifou est deja dans la liste il le passe
livre_signer.pifou est deja dans la liste il le passe

ajout_blacklist_flood.pifou n'est pas dans la liste il l'ajoute

telechargement :

choix_design.pifou
autrefichier.pifou
autrefichier2.pifou
admin_pass.pifou
livre_lire.pifou
livre_signer.pifou
blah.pifou
bidule.pifou
ajout_blacklist_flood.pifou

au final tu ne télécharge que les dernières versions des fichiers et tu ne les télécharges qu'une seule fois.

au lieu de faire toute les maj dans l'ordre et de mettre a jour plusieurs fois les mêmes fichiers. cela n'est valable bien sur que si les fichiers de mises a jours sont disponible indépendamment sur le serveur.

[Geo Trouvpatou]

Salut.

Ok, je pense avoir compris ton système.

Tu vérifies les maj à l'envers pour voir les fichiers qui ont été changés.

Si j'en suis à la v1.0 du script, je scanne les fichiers modifiés de la v1.4 vers v1.1
Si j'en suis à la v1.2 du script, je scanne les fichiers modifiés de la v1.4 vers v1.3

On met les fichiers modifiés dans une liste chainée et on télécharge tout ça.

Effectivement, dans la théorie c'est pas mal .
Et comme tu disais il n'y a que celui qui n'a jamais fait de maj, qui se tape 100% des fichiers modifiés à télécharger.

Bye.

[case]

c'est exactement ca

[blendman]

Salut Case et Geo.

Merci pour ton exemple Case, j'ai finalement trouvé une méthode vraiment très simple, en essayant de transcrire ta méthode, Case :

- je télécharge d'abord un fichier texte avec le numéro de version actuelle, ainsi que d'autres informations. Dans mon cas, je me sers d'un fichier type ini/pref, c'est beaucoup plus simple.
- si mon jeu est plus récent, je lance jeu.exe et je ferme update.exe.
- si la version de mon jeu est plus ancienne que la version la plus récente, alors, je télécharge maj.exe, que je lance et je ferme update.exe
- maj.exe lit les informations de ce fichier ini ("newversion.ini"), qui ressemble à ça :

Code : Tout sélectionner

[general]
cur_version = 0.0.2454 ; c'est la version la plus récente
nbreversion = 3 ; c'est le nombre de version max

[version1]
version = 0.0154
nbre = 2
file1 = quete.txt
file2 =image1.png

[version2]
version = 0.0192
nbre = 3
file1 = texte.txt
file2 = image5.png
file3 = image6.jpg

[version1]
version = 0.02454
nbre = 1
file1 = quete2.txt

[exe]
; ici, je télécharge si besoin les nouvelles versions des exe, si elles ont changées
nbre = 2
file1= update.exe
fle2 =jeu.exe

- j'ai fait une boucle dans maj.exe qui ressemble à ça :

Code : Tout sélectionner

OpenPreferences("newversion.ini")
preferencegroupe("general")
nbreversion.i = ReadPreferenceInteger("nbreversion",0)

For i= 1 To nbreversion
nom$ = "[version" +Str(i)+"]"
preferencegroupe(nom$)
versionsection.d = ReadPreferenceDouble("numero",0)
nbre = ReadPreferenceinteger("nbre",0)
If maversion < versionsection
for u = 1 to nbre
file$ = "file"+Str(i)
filetoUp$= ReadPreferencestring(file$,"")
downloadFile(filetoUp$)
next u
EndIf
Next i
ClosePreferences()

DownloadFile() étant une fonction que j'ai créée pour downloader mes fichiers (à partir de ReceiveHTTPFile() pour le moment, car je n'ai pas encore de serveur).
- une fois que c'est fini, je lance update.exe à nouveau et ferme maj.exe et le supprime ainsi que le fichier ini.
- update.exe étant à jour, il lance le jeu et voilà .

Très simple à mettre (je modifie le fichier ini uniquement), et très simple niveau code, c'est aussi plutôt rapide et ça fonctionne .

Encore merci à vous pour les conseils.