Comment puis-je implémenter un script intelligent dans mon jeu?

Je développe un moteur de jeu. Il est censé être basé sur une entité / composants. Pour développer mon jeu lui-même, j'ai pensé à utiliser un langage de script pour réellement créer les entités.

Par exemple, si je veux ajouter une sorte de monstre agressif pour le joueur, ce sera une entité à plusieurs composants; ces composants changeront avec le type de monstre, donc si j'ai cent types de monstres différents, dans mon jeu, je n'aurai pas à créer une nouvelle méthode pour chacun d'eux directement dans mon code de jeu.

Dois-je utiliser un langage de script pour décrire cette entité, en termes de composants ou existe-t-il autre chose qui fonctionnerait mieux? Plus généralement, comment utiliser les scripts dans mon jeu?

Mon jeu utilise un framework de composants d'entité et utilise des scripts pour définir des entités (cela ne définit pas directement le comportement, j'en parlerai plus à la fin). Les scripts définissent les composants réels à utiliser pour créer chaque entité. Il utilise un langage de script simple que j'ai créé. Voici une version simplifiée d'un de mes scripts:

ENTITY:"Goblin"
{
    description="It's currently their age."
    commonname="goblin"
    pluralCommonName="goblins"
    childname="gob'in"
    pluralChildName="gob'ins"
    active=Nocturnal
    tags=Mobile
    baseAttributes="OrganicMobileCreature"

    [Model]{
            meshname="Goblin"
            texturename="GoblinTexture"
    }

    [Motion]{
            maxvelocity=0.01:0.015
            locomotion=Walk,Swim
    }

    [Skills]{
            ALL=0.01:0.05,Mine=8.3:8.8,PlaceCube=8.3:8.8
    }

    [Inventory]{
            maxItems=2
            Allow=ALL
            Disallow=NONE
    }
}

Une grande partie de cela est auto-décrivant, mais voici quelques points saillants:

• La première section décrit les informations communes à l'entité. Cela inclut une description et des noms d'affichage pour divers aspects de l'entité.
• La baseAttributesbalise fait référence à un autre fichier de script qui définit des composants communs que je ne veux pas avoir à redéfinir plusieurs fois. Il contient des composants tels que position, liferequirementsetc. Si un composant est défini ici à nouveau, ce composant remplacera le composant commun.
• Chaque [NAME] { }ensemble définit un nouveau composant qui sera ajouté à ces entités.
• Cette description n'est pas seulement pour une seule entité , c'est pour tous les gobelins créés. Vous verrez que certaines valeurs ont des plages (c'est-à-dire 0.01:0.015), lorsqu'un nouveau gobelin est créé, il est créé avec un composant qui a une valeur aléatoire dans cette plage. Ainsi, chaque gobelin aura des compétences légèrement différentes et des vitesses légèrement différentes. Cette configuration définit que tous les gobelins commenceront avec de très bonnes compétences pour placer des cubes et extraire, ce qui est vraiment juste pour mes propres tests. Mais comme je suis sûr que vous pouvez le deviner, il est très facile de changer les valeurs en ce que je veux.

Tout cela implique de créer un analyseur personnalisé, une sorte de structure pour contenir les définitions d'entités (j'appelle le mien le Lexique!) Et une usine pour prendre ces définitions d'entités et générer de nouvelles entités. Pour moi, ce système est encore à ses débuts, mais il se révèle vraiment, vraiment bien. C'est un système assez puissant pour définir rapidement des entités et vous permet de créer n'importe quelle entité que vous souhaitez en utilisant les composants que vous avez créés. Si vous n'êtes pas à l'aise de créer votre propre analyseur, je pense que XML fonctionnera très bien. J'ai converti le mien à partir d'un analyseur récursif pushback que j'ai écrit pour un langage de programmation un peu inventé.

Comme vous pouvez le voir, cela définit l'entité. J'ai mentionné qu'il ne définit pas directement le comportement. Il peut, cependant, définir facilement des choses comme des ennemis détestés et comment réagir agressivement à ces ennemis. Ce serait aussi simple que de définir le composant que vous utilisez pour contrôler un tel comportement. Mes entités ont également un composant de renseignement (non illustré) qui définit des choses comme:

• Comment ils trouvent leur chemin (simple mouvement en ligne de visée, A * simple, A * prédictif, etc.)
• Comme ils sont agressifs / défensifs. Les entités peuvent avoir des zones d'origine qui seront défendues, mais peut-être pas agressives en dehors de ces zones.
• Sensibilisation à la technologie (ouvrir les portes, utiliser des gadgets, éviter les pièges, etc.)
• Et plus...

Quelle que soit la vôtre, c'est votre système qui pilotera les données de ce composant, ce qui affectera à son tour le comportement de vos entités.

Si tout ce dont vous avez vraiment besoin est un moyen de définir les composants d'un Monster, alors XML fonctionnerait bien, C # et java en ont une implémentation rapide comme l'éclair.

Votre xml pourrait être

<?xml version="1.0" encoding="UTF-8"?>
<mobs>
  <mob>
    <personality>Aggressive</personality>
    <intelligence>20</intelligence>
  </mob>
</mobs>

Ensuite, votre classe Mob pourrait ressembler. (Java)

public class Mob {
  private IPersonality personality;
  private Integer intelligence

  //**  Getters & Setters **//
}

Où IPersonality est une interface.

Vous pouvez ensuite charger votre xml et analyser chaque valeur via une usine.

par exemple, analyser la valeur de personnalité dans la personnalité de l'usine qui est simplement:

public IPersonality getPersonality(String personalityName) {
  if(personalityName.equals("Aggressive")) {
    return new AggressivePersonality();
  }
  else if(personalityName.equals("Passive")) {
    return new PassivePersonality();
  }
  else {
     //Maybe allow for no personality (We all know monster like that ;) )
     return null; 
  }
}

Ensuite, vous pouvez mettre en place une foule comme ça

Mob mob = new Mob();
mob.setPersonality(getPersonality(xmlValue));
mobList.add(mob);

La clé est que votre moteur connaît le format du XML et dispose d'une usine pour tout ce dont il a besoin.

Un avantage de xml est que vous pouvez définir votre propre schéma pour vous assurer que le format est toujours correct, voir ici .

J'espère que cela t'aides

Python va bien je pense. Souvent, LUA est également une bonne alternative si vous souhaitez ajouter des capacités de script à vos programmes.

Vous pouvez soit utiliser XML pour décrire le comportement de vos monstres, cela impliquerait un certain codage dans le code du jeu, car vous n'enregistrerez que le "nom" ou certains attributs en fonction du comportement (vitesse, type d'arme que le monstre utilise, etc.) du comportement à utiliser dans votre code de jeu.

Si vous utilisez un Scriptengine (par exemple LUA), vous pouvez transférer ce code depuis votre programme précompilé vers des fichiers de script qui sont chargés pendant l'exécution. Pour ce faire, vous devez exposer l'API de vos "monstres" au scriptengine. Cela vous permet d'appeler les méthodes du code du jeu monstre de l'extérieur.