[Résolu] Apprendre les bases du scriptage

N'ayant pas trouvé de section appropriée je me permets de poster ici.
J'ai parcouru divers tutoriels afin d'en apprendre un peu sur le scriptage, je sais faire quelques trucs débiles du genre :

Code:

begin
@var_1 = "variable 1"
print @var_1
@var_2 = "variable 2"
print @var_2
end

ou en plus simple :

Code:

begin
print "texte"
end

Mais j'aimerais en apprendre plus concernant les bases du scriptage, c'est pourquoi je demande l'aide d'un scripteur, qui puisse me guider via MSN par exemple^^
Je suis disponible sur MSN le mercredi après-midi et le week-end.

Merci d'avance à qui me répondra, en espérant avoir posté dans la bonne section du forum

Pas trop dispo par MSN mais je peux répondre sur le forum quand tu veux .

Ce qui m'inquiete un peu quand je vois les lignes de code que tu nous montre , c'est que j'ai l'impression que tu fais pas la différence entre languages proceduraux et languages objets . Le ruby est un language objet , il faut donc plutot essayer de raisonner en classes , propriétés et methodes .

Moi , j'ai appris sur le tas mais en ayant des notions de languages objet .
J'ai beaucoup utilisé les classes fournies avec rpgmaker pour apprendre . Game_Actor et Game_Actors sont super interessantes par exemple . J'utilise encore beaucoup la classe Game_Interpreter aussi .

Je viens tout juste de m'y mettre, je n'y connais vraiment presque rien ^^'
Je ne sais faire que très peu de choses et ne connais même pas le vocabulaire employé

Mais je ne lâche pas, j'ai bien l'intention d'apprendre à scripter.

C'est plus simple qu'on veux bien le croire

Le probleme avec rpgmaker , c'est qu'il y a des classes cachées . Et notemment , celle qui s'appele "RPG" (on peux la voir tout de meme grace à l'aide en ligne F1) .

Tiens , je vais essayer de t'expliquer le début de la classe game_actor :

class Game_Actor < Game_Battler

# On déclare une classe s'appelant Game_Actor . Cette classe herite de
# Game_Battler , ce qui signifie que dans la classe Game_Actor , il y
aura par
# défaut toutes les methodes et propriétés de Game_Battler .
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :name # name
# ça , c'est une propriété . Note qu'il n'y a pas de type .
# attr_reader est pour dire que ce n'est pas une propriété modifiable
attr_reader :character_name # character graphic filename
attr_reader :character_index # character graphic index
attr_reader :face_name # face graphic filename
attr_reader :face_index # face graphic index
attr_reader :class_id # class ID
attr_reader :weapon_id # weapon ID
attr_reader :armor1_id # shield ID
attr_reader :armor2_id # helmet ID
attr_reader :armor3_id # body armor ID
attr_reader :armor4_id # accessory ID
attr_reader :level # level
attr_reader :exp # experience
attr_accessor :last_skill_id # for cursor memory: Skill
# attr_accessor => propriété modifiable
#--------------------------------------------------------------------------
# * Object Initialization
# actor_id : actor ID
#--------------------------------------------------------------------------
def initialize(actor_id)
#Voila une methode . initialize est une methode particuliere que l'on
retrouve #dans toutes les classes . C'est ce qu'on appele le
constructeur . C'est là qu'on #va donner la valeur par défaut de toutes
les propriétés
super()
# super() permet d'appeler la meme methode mais dans la classe parente
# (Game_Battler donc)
setup(actor_id)
# setup est une methode définie en dessous .
@last_skill_id = 0
end
#--------------------------------------------------------------------------
# * Setup
# actor_id : actor ID
#--------------------------------------------------------------------------
def setup(actor_id)
actor = $data_actors[actor_id]
# pour récupérer un acteur , on utilise $data_actors , c'est un objet de classe Game_Actors (avec un "s" cette fois) . Si on regarde la classe Game_Actors , on s'aperçoit que actor est de la classe Game_Actor .
@actor_id = actor_id
# cette ligne peux sembler étrange ... le premier @actor_id est la propriété de la classe en cours de définition , le deuxieme actor_id est le parametre
@name = actor.name
# là , on voit comment on retrouve une propriété d'une classe . En l'occurence la propriété name de l'objet actor qui est de classe Game_Actor .
.......

Attends, ça va un peu vite pour moi là ^^'

Peux-tu me définir les termes tels que méthode, propriété, etc...?

une methode , c'est comme une fonction .
On les reconnait avec un def au début :

def setup(actor_id)

ça peux retourner une valeur mais ce n'est pas obligatoire

Une propriété , c'est ... comment dire ... plus ou moins une variable .
ça se reconnait grace au attr_XXXX avant :

attr_reader :name # name

Pour utiliser tout ça ensuite , il faudra que je définisse mon acteur :
actor = Game_Actor.new(1)
# ça dit en clair : je défini une variable actor de classe Game_Actor
# new , c'est pour appeler le contructeur (donc initialize)
Et ensuite , je pourrais faire :
name = actor.name
# dans la variable name , je met le nom de l'acteur
ou :
actor.setup(2)
# j'appele la methode setup pour changer d'acteur , je met le 2éme

Donc en gros "actor = Game_Actor.new(1)", tu crées ton acteur, "name = actor.name" tu lui crées un nom, "attr_reader :name # name" tu peux lire son nom...?
(l'acteur étant ici le personnage d'ID = 1...? J'y comprends rien )

Ah , faut comprendre le concept de classes . Pas simple quand on vient du monde procedural . Il faut penser en objet , "Game_Actor" permet de défnir ce qu'est un acteur . Mais c'est juste une structure , un modele . ça ne stocke rien .

C'est pour ça qu'on a besoin d'un "constructeur" .

Je suis encore plus perdu

Tu peux tout réexpliquer en détails depuis le début s'il te plaît ? Désolé de t'embêter autant mais je n'y comprends plus rien là ^^'

C'est pas simple à expliquer
Comme je disait , il faut penser objet .
On a besoin d'un objet "Acteur" , alors on crée sa structure . On lui crée des attribut (comme name pour le nom) , des methodes (Comme gain_exp pour lui faire gagner de l'expérience) . Bref , tout ce dont on a besoin pour définir un acteur et le faire évoluer . C'est Game_Actor .
Aprés , on a besoin d'un objet qui est la liste des acteurs . C'est Game_Actors

Je vais essayer de prendre un autre exemple : Scene_Status .
On l'appele comme ça :
$scene = Scene_Status.new(2)
D'abord , le ".new" . ça va te créer une nouvelle instance de la classe Scene_Status et appeler la methode initialize de celle-ci . Si tu la regarde , tu verras que ça fait pas grand chose , ça memorise juste le 2 .
L'explication pour le "$scene" se trouve dans "main" en bas de ta liste de script . Trés important ce script , c'est celui qui contient la boucle infinie :
$scene.main while $scene != nil
$scene est à l'origine de classe Scene_Title mais on l'a modifié en Scene_Map puis en Scene_Status .
Du coup , c'est la methode main de la classe Scene_Status qui sera appelé indéfiniment . Si tu regardes , tu auras une petite surprise : pas de methode main . En fait , elle est héritée de la classe Scene_Base .

C'est vachement... complexe, quand même...
Et en ce qui concerne la création d'un script ?

Le plus simple est de prendre un script existant et de le décortiquer pour essayer de comprendre ce qu'il fait .
Quand tu regardes La plupart des scripts qu'on peux trouver sur les forums , ils sont quasiment toujours inspirés de classes existantes .

Ok...
Bon, je pense surtout commencer par lire des tutoriels à ce sujet avant de me lancer dans ce genre de travaux ^^"

Je laisse le topic en suspend pour le moment, on peut considérer qu'il est résolu, j'en referai un si j'ai d'autres questions en la matière.

Merci pour ton aide dricc, ce fut sympathique de ta part