Props, maps et dupes

Ajouter du contenu sans écrire de code : des modèles 3D à faire apparaître, des cartes jouables et des constructions toutes prêtes.

Identifiants de props

Chaque prop a un identifiant texte, utilisé par ents.SpawnProp, les hooks et les dupes.

Props intégrés

Pack Construction

Le jeu fournit aussi 31 props texturés pour bâtir (onglet Construction du menu de spawn), aux dimensions métriques rondes pour qu'ils s'alignent. Identifiants addon:base/models/<fichier>, par exemple addon:base/models/concrete_wall_2x2.glb.

Les objets creux sont faits de pièces convexes séparées (une collision par pièce) : on passe dans un tube, on monte un escalier. Ils sont générés avec Blender par tools/blender/construction_pack.py, qui sert aussi d'exemple pour créer un pack par script.

Créer un prop

Le plus simple est l'éditeur de modèles (Créer → Modèles) : il importe les fichiers glTF, GLB et FBX, et règle la taille, la physique, les collisions, les matériaux et les animations, avec un aperçu.

Pour préparer le modèle dans Blender :

1. Modélise l'objet à l'échelle réelle, en mètres, avec l'origine au centre de l'objet (l'éditeur permet aussi de corriger l'échelle et le pivot).
2. Exporte en glTF binaire (.glb) avec les matériaux. Les textures doivent être des images (les nœuds procéduraux ne s'exportent pas).

Tu peux aussi déposer directement le .glb dans le dossier models/ d'un addon : il apparaît dans le menu de spawn avec les réglages par défaut.

Collisions et masse

• Par défaut, la collision est une enveloppe convexe par maillage. Pour un objet creux (une tasse, une arche), place des formes simples dans l'éditeur de modèles.
• Sans masse indiquée, elle est estimée d'après la taille de l'objet et la densité de son matériau physique.
• Les props flottent si leur densité est inférieure à celle de l'eau (1000 kg/m³) : le bois flotte, le métal coule.

props.json

Les réglages de chaque modèle sont dans models/props.json. L'éditeur de modèles l'écrit pour toi ; son format complet est décrit dans Le fichier props.json. Version minimale :

{
	"chaise.glb": { "name": "Chaise de bureau", "mass": 12 },
	"armoire.glb": { "name": "Grande armoire", "mass": 90 }
}

Cartes intégrées

Le jeu fournit trois cartes, choisies dans Jouer → Créer une partie ou par leur identifiant (server.cfg, /map, rotation des maps) :

Créer une map

Les maps se construisent dans le jeu avec l'éditeur de map (Créer → Maps → Nouvelle map) : blocs, props, lumières, eau, points d'apparition et ciel, seul ou à plusieurs. Elles sont enregistrées en .pcmap dans le dossier maps/ d'un addon, et apparaissent dans Jouer → Créer une partie et Explorer → Cartes.

• L'identifiant d'une map suit la même règle que les props : addon:<clé>/maps/<fichier>.pcmap.
• Les props posés dans une map deviennent de vrais props physiques au lancement de la partie (créés par le serveur, sans propriétaire).
• Les anciennes maps .glb ne sont plus chargées : un .pcmap ne contient que des données, ce qui empêche une map du Workshop d'exécuter du code.

Importer une map Source (.bsp)

L'outil tools/bsp_to_physicore.py (dans le dossier du projet) convertit une map de Garry's Mod, Counter-Strike: Source ou Half-Life 2 en addon local : un .pcmap qui s'ouvre dans l'éditeur de map et se lance comme les autres.

pip install srctools Pillow numpy
python tools/bsp_to_physicore.py C:/Maps/rp_downtown_v2/maps/rp_downtown_v2.bsp

Les textures et modèles absents du .bsp sont lus dans les VPK de Garry's Mod (contenu HL2 et CS:S compris) : il faut Garry's Mod installé (--gmod pour un autre dossier, --content pour un dossier materials/ models/ en plus). L'addon est écrit dans le dossier des addons de PhysiCore (--out pour un autre).

Les modèles de la map sont rangés dans models/<map>/ (un sous-dossier) : ils n'apparaissent pas dans le menu de spawn. Les autres entités (logique, trains, sons, décalcomanies…) ne sont pas converties.

Portes et boutons

Les classes sdoor et sbutton sont écrites dans lua/entities/ de l'addon ; chaque modèle a sa petite classe qui en hérite (ENT.Base, ENT.Model). Leurs propriétés se modifient dans l'éditeur de map (onglet Entités) :

Entrées reconnues par les portes : Open, Close, Toggle, Lock, Unlock ; par les boutons : Press. En Lua (serveur) : SourceIO.Fire("porte_1", "Open", ply). Pendant son mouvement, une porte laisse passer les joueurs (COLLISION_GROUP_PASSABLE_DOOR).

Options

Importer une map Unreal Engine

Le plugin PhysiCore Exporter (dossier tools/unreal/PhysiCoreExporter du projet, écrit en Python, sans compilation) convertit le niveau ouvert dans Unreal Engine 5 en addon local : un pack de modèles (un .glb par mesh, dans le menu de spawn) et une map .pcmap qui place ces modèles.

Installation

1. Copie le dossier PhysiCoreExporter dans le dossier Plugins/ de ton projet Unreal (crée-le s'il n'existe pas).
2. Ouvre le projet : le plugin active tout seul Python Editor Script Plugin, Editor Scripting Utilities et Procedural Mesh Component (Unreal peut demander de redémarrer).
3. Ouvre le niveau à convertir, puis menu Outils → PhysiCore → Exporter vers PhysiCore…
4. Choisis le dossier de sortie (en général %APPDATA%\Godot\app_userdata\PhysiCore\addons) et valide. Relance PhysiCore : l'addon apparaît, sa map s'ouvre dans l'éditeur de map ou se lance comme les autres.

Ne sont pas convertis : Landscape, Blueprints (leur logique), Niagara, décalcomanies, ciel et brouillard, éclairage Lumen ou précalculé, graphes de matériaux complexes (seules les textures branchées sont reprises). Avec World Partition, seules les cellules chargées dans l'éditeur sont exportées. Une map garde au plus 20 000 objets, à moins de 10 km de l'origine.

Réglages

Les réglages sont gardés dans Saved/PhysiCoreExporter.json du projet Unreal. Réexporter remplace les modèles, les textures et la map, garde addon.json et les réglages de props.json des modèles qui ne sont plus exportés. Les retouches faites dans l'éditeur de modèles sur un modèle réexporté sont perdues. Le résumé de l'export s'affiche à la fin, et le détail est dans le journal de sortie d'Unreal (lignes [PhysiCore]).

Exporter tout un dossier de contenu (sans niveau)

Pour convertir tous les meshes d'un pack (et pas seulement ceux placés dans un niveau), le dossier tools/unreal/ contient un export en ligne de commande. Le projet peut rester ouvert dans Unreal :

1. export_asset_pack.py, lancé par UnrealEditor-Cmd.exe Projet.uproject -run=pythonscript -script=… avec -nullrhi : variables PC_PACK (dossier, ex. /Game/ModernCityEnvironment01), PC_OUT (dossier de l'addon), PC_STAGE (dossier de travail) et PC_KIND (StaticMesh, puis SkeletalMesh). Chaque Static Mesh devient un .glb à l'échelle 1 (LOD 0, ou le LOD le plus détaillé sous 60 000 triangles) ; les Skeletal Meshes sont exportés en glTF dans leur pose de repos ; les textures sont sorties à leur résolution d'origine ;
2. finish_asset_pack.py (Python avec Pillow) : convertit les Skeletal Meshes en modèles statiques via Blender, les textures en JPEG (PNG si transparence, normal maps en PNG avec le vert inversé, textures ORM séparées en rugosité et métal), applique les teintes des instances de matériaux et écrit props.json d'après un fichier de règles (nom traduit, catégorie, physique, modèles cachés du menu de spawn) — exemple : moderncity_config.json.

Les modèles sont gelés au spawn avec une masse estimée d'après leur taille ; le jeu calcule lui-même des LOD simplifiés au chargement.

Options utiles : PC_INCLUDE (expression régulière sur le chemin des assets, pour ne garder que certains dossiers) ; PC_PARAM_MATERIALS=1 pour les packs dont les matériaux maîtres sont trop complexes : les textures sont alors prises d'après les noms de paramètres des instances et de leurs parents (BaseColor, Normal, ORM/ORMH, Tint, Brightness) ; dans le fichier de règles, "max_texture": 2048 plafonne la taille des textures.

Pour les packs dont les immeubles sont assemblés dans les niveaux (pièces modulaires posées par des Blueprints), export_buildings.py fusionne chaque immeuble en un seul modèle : variable PC_LEVELS (niveaux séparés par des virgules) et PC_GROUP (expression sur le dossier des acteurs dans l'Outliner, défaut ^Buildings/([^/]+)). Pivot au centre de la base, un matériau par surface, un immeuble identique dans deux niveaux n'est écrit qu'une fois. Ajoute "extra_manifests": ["manifest_buildings.json"] au fichier de règles pour que finish_asset_pack.py les inclue.

Pour refaire ensuite un niveau du pack avec ces modèles, export_level_to_pack.py (même commande, variable PC_LEVEL, ex. /Game/ModernCityEnvironment01/Maps/ModernCityMap01) écrit maps/<niveau>.pcmap dans l'addon : chaque mesh placé à l'échelle 1 avec ses matériaux d'origine reprend le modèle du pack ; un mesh mis à l'échelle, aux matériaux remplacés ou hors du pack devient une variante lvl_<nom>_<n>.glb, cachée du menu de spawn par finish_asset_pack.py (à relancer après). Les Skeletal Meshes placés à l'échelle 1 reprennent leur modèle figé, et les lumières sont exportées en lumières statiques : calcule l'éclairage de la map dans l'éditeur (Monde → Éclairage) pour qu'elles passent au système de lumières économique.

Importer une scène Unity

Le package PhysiCore Exporter pour Unity 6 (dossier tools/unity/PhysiCoreExporter du projet, en C#) convertit la scène ouverte en addon local, au même format que l'export Unreal : un modèle .glb par maillage (dans le menu de spawn) et une map .pcmap qui les place.

1. Copie le dossier PhysiCoreExporter dans Assets/ du projet Unity, ou installe-le avec Package Manager → + → Install package from disk… (fichier package.json).
2. Ouvre la scène, puis menu Tools → PhysiCore → Exporter la scène…
3. Règle l'export, clique Exporter… et choisis le dossier de l'addon (la fenêtre part de %APPDATA%\Godot\app_userdata\PhysiCore\addons). Relance PhysiCore : la map est dans la liste et s'ouvre dans l'éditeur de map.

Ne sont pas convertis : terrains Unity, végétation peinte sur les terrains, particules, scripts, sons, ciel et brouillard. Les surfaces métalliques précalculées sortent un peu plus sombres ; un shader qui déplace ses sommets (vent) ou dépend de la position dans le monde (triplanar) peut mal se précalculer : décoche alors Précalculer les matériaux. Réexporter dans le même dossier remplace les modèles et la map, et garde addon.json et les autres entrées de props.json. Le résumé s'affiche à la fin et dans la console d'Unity.

Les dupes

Une dupe est une construction sauvegardée : des props, leurs positions, et depuis la version 2, leurs contraintes (soudures, axes, cordes…) et leurs gadgets (propulseurs, roues avec leurs touches et réglages). Une voiture dupliquée repart donc entièrement fonctionnelle.

Créer et utiliser une dupe

1. Prends le toolgun (2) et choisis l'outil Duplicateur dans le menu de spawn.
2. Clic gauche sur les props à inclure (ils s'éclairent en cyan), puis clic droit pour sauvegarder en lui donnant un nom.
3. Pour la recoller : menu de spawn → onglet Dupes → clique sur la dupe. Elle apparaît là où tu vises, orientée selon ton regard.

Les dupes sauvegardées sont dans %APPDATA%\Godot\app_userdata\PhysiCore\dupes\. Pour en partager une dans un addon, place son fichier dans le dossier dupes/ de l'addon (ou utilise Publier, qui le fait pour toi).

Format d'une dupe

Un fichier JSON. Les positions sont relatives à l'origine de la dupe (centre au sol de la construction, orienté comme le joueur au moment de la sauvegarde). Les valeurs Godot (vecteurs, couleurs dans data) sont écrites en texte au format Godot.

{
	"name": "Ma voiture",
	"version": 2,
	"props": [
		{
			"id": "builtin:plate_2x2",
			"pos": [0.0, 0.55, 0.0],
			"rot": [0.0, 0.0, 0.0, 1.0],
			"frozen": false,
			"color": "ffffffff",
			"data": "{}"
		},
		{
			"id": "gadget:wheel",
			"pos": [1.1, 0.45, 0.8],
			"rot": [0.0, 0.0, -0.7071, 0.7071],
			"frozen": false,
			"color": "ffffffff",
			"data": "{\"key_back\": 4194440, \"key_fwd\": 4194446, \"radius\": 0.45, \"speed\": 18.0, \"torque\": 800.0}"
		}
	],
	"constraints": [
		{
			"type": "axis",
			"a": 1,
			"b": 0,
			"la": "Vector3(0, 0, 0)",
			"lb": "Vector3(1.1, -0.1, 0.8)",
			"axis": "Vector3(0, 1, 0)",
			"params": "{\"motor\": true, \"torque\": 800.0}"
		}
	]
}

Les dupes de la version 1 (sans data ni constraints) restent lisibles.

Limites

Les props d'une dupe dont l'addon manque sont ignorés ; le joueur est prévenu du nombre de props non créés.