Monde et physique

Angles et vecteurs, traces (rayons), repères et physique des entités (forme de collision, frottement, rebond, collisions au cas par cas), attacher un prop à un autre, réagir aux chocs, chercher des entités, créer des contraintes (soudures, cordes, treuils, vérins, moteurs…), explosions, date et heure, changement de map.

Angles et vecteurs

Un angle est un Vector(pitch, yaw, roll) en degrés ; Angle(p, y, r) le crée. C'est le format renvoyé par ent:GetAngles() et ply:EyeAngles(). Convention du jeu : avant = -Z, Y en haut, pitch positif = vers le haut, yaw positif = vers la gauche (rotation autour de Y).

Les vecteurs ont aussi les noms de Garry's Mod : :Length(), :LengthSqr(), :Length2D() (sur le sol, x et z), :Distance(v), :DistToSqr(v), :Dot(v), :Cross(v), :GetNormalized(), :IsZero(), :IsEqualTol(v, tolérance), :WithinAABox(min, max). Les méthodes Godot (length(), normalized(), distance_to()…) restent disponibles. Un vecteur ne se modifie jamais « en place » : chaque méthode renvoie un nouveau vecteur.

local ang = ply:EyeAngles()
local devant = ply:EyePos() + ang:Forward() * 2 -- 2 m devant les yeux
local cap = (cible - ply:GetPos()):Angle().y     -- yaw pour regarder la cible

Aides mathématiques

Traces

Une trace lance un rayon (ou une boîte) entre deux points et dit ce qu'il touche. Des deux côtés.

util.TraceLine(options) → table

Options : start, endpos (des Vector), filter, mask, ignoreworld. Longueur 20 000 m au plus. Résultat :

-- Le prop sous le viseur, en ignorant le joueur.
local tr = util.TraceLine({ start = ply:EyePos(), endpos = ply:EyePos() + ply:GetAimVector() * 10, filter = ply })
if tr.Hit and IsValid(tr.Entity) then print("Je vise", tr.Entity:GetModel()) end

util.TraceHull(options) → table

Comme TraceLine, mais avec une boîte : mins et maxs (autour du point) en plus. StartSolid vaut true si la boîte est déjà bloquée au départ (pratique pour vérifier qu'un joueur tient à un endroit).

Autres aides

• util.QuickTrace(origine, décalage, filtre) : TraceLine de origine à origine + décalage.
• util.IsInWorld(pos) : true si la position n'est pas dans un mur et qu'il y a du sol en dessous.

Filtres et masques

filter : une entité ou un joueur (ignoré), une table de ceux-ci, ou une fonction function(ent) return true end (true = on touche cet objet, false = on passe à travers ; le monde n'est jamais filtré ; 16 objets traversés au plus).

ignoreworld = true retire le monde.

Repères des entités

Ces méthodes existent des deux côtés, sur les props, les entités scriptées et les véhicules.

-- Une caisse 1 m devant et 0,5 m au-dessus d'un prop, tournée comme lui.
local pos = prop:LocalToWorld(Vector(0, 0.5, -1))
local caisse = ents.SpawnProp("builtin:crate", pos)
caisse:SetAngles(prop:GetAngles())

Physique

Vitesse et forces serveur

Objet physique

ent:GetPhysicsObject() renvoie un objet à la manière de Garry's Mod, pour reprendre du code existant. Ses méthodes sont des raccourcis vers celles de l'entité ; les modifications n'existent que côté serveur.

Matériau, freinage, flottaison et repos :

Les lectures (GetDamping, IsAsleep, ent:GetFriction…) sont exactes côté serveur, qui simule les props.

-- /saut : envoie le prop visé en l'air en le faisant tourner.
concommand.Add("saut", function(ply)
	local ent = ply:GetEyeTrace().Entity
	if not IsValid(ent) or ent:IsPlayer() then return end
	local phys = ent:GetPhysicsObject()
	phys:EnableMotion(true)
	phys:AddVelocity(Vector(0, 8, 0))
	phys:AddAngleVelocity(Vector(0, 360, 0))
end)

Collisions et apparence serveur

-- Un fantôme : transparent, doré, les joueurs passent au travers.
local f = ents.SpawnProp("builtin:barrel", Vector(0, 1, 0))
f:SetMaterial("gold")
f:SetColor(Color(255, 255, 255, 120))
f:SetCollisionGroup(COLLISION_GROUP_INTERACTIVE_DEBRIS)
f:SetModelScale(1.5)

Forme et solidité serveur

Par défaut, une entité collisionne avec les formes de son modèle. Ces méthodes la remplacent par une forme simple ou la rendent traversable. Le changement s'applique chez tous les joueurs (ils butent aussi sur la nouvelle forme). Unités : mètres, dans le repère de l'entité.

Constantes : SOLID_NONE (0), SOLID_BSP (1), SOLID_BBOX (2), SOLID_OBB (3), SOLID_OBB_YAW (4), SOLID_CUSTOM (5), SOLID_VPHYSICS (6) ; FSOLID_NOT_SOLID (4) et FSOLID_TRIGGER (8) existent pour reprendre du code de Garry's Mod.

-- Une caisse qui roule comme une boule et rebondit.
local c = ents.SpawnProp("builtin:crate", Vector(0, 3, 0))
c:PhysicsInitSphere(0.5)
c:SetElasticity(0.8)
c:SetFriction(0.2)

Collisions au cas par cas : ShouldCollide

ent:SetCustomCollisionCheck(true) serveur fait demander au hook ShouldCollide(ent1, ent2) si l'entité doit heurter un autre corps : ent1 est l'entité réglée, ent2 un prop, un joueur, un PNJ, ou un élément du décor de la map (qui n'est pas une entité : vérifie avec istable avant d'appeler ses méthodes). La question est posée quand le corps s'approche à moins de 50 cm environ de l'entité, sur chaque machine (chaque joueur simule son propre déplacement) : ajoute le hook dans un fichier partagé. Renvoyer false : les deux se traversent, jusqu'à ce que la règle soit remise en question. Autre chose : ils se heurtent, et la question sera reposée la prochaine fois que le corps reviendra.

Après avoir changé ta règle, appelle ent:CollisionRulesChanged() (serveur) : les réponses déjà données sont oubliées et le hook est redemandé. ent:GetCustomCollisionCheck() lit le réglage ; SetCustomCollisionCheck(false) l'enlève et rend les collisions normales.

-- Partagé : les joueurs de l'équipe 1 traversent les portes de leur équipe.
hook.Add("ShouldCollide", "portes_equipe", function(ent, autre)
	if ent:GetClass() == "porte_equipe" and istable(autre) and autre.IsPlayer and autre:IsPlayer() and autre:Team() == 1 then
		return false
	end
end)

-- Serveur, à la création de la porte :
-- porte:SetCustomCollisionCheck(true)

Attacher : SetParent

ent:SetParent(ent ou ply ou nil) serveur : le prop suit l'entité ou le joueur en gardant sa position relative actuelle (il est figé tant qu'il est attaché). nil le détache et il retombe. Si le parent disparaît, il est détaché tout seul. ent:GetParent() renvoie le parent.

-- Un ballon qui suit le joueur au-dessus de sa tête.
local ballon = ents.SpawnProp("builtin:ball", ply:GetPos() + Vector(0, 2.5, 0))
ballon:SetParent(ply)

Réagir aux chocs : PhysicsCollide

ENT:PhysicsCollide(data) (entités scriptées, serveur) est appelé quand l'entité heurte un prop ou un joueur (au plus toutes les 0,05 s). Seulement si la classe définit PhysicsCollide : sinon les chocs ne sont pas suivis.

-- entities/vase.lua : un vase qui se brise quand il tombe fort.
ENT.Model = "builtin:cylinder"
if SERVER then
	function ENT:PhysicsCollide(data)
		if data.Speed > 6 then
			self:EmitSound("physicore/clic.wav")
			self:Remove()
		end
	end
end

Chercher des entités

-- Qui est devant moi, à moins de 20 m ?
for _, ent in ipairs(ents.FindInCone(ply:EyePos(), ply:GetAimVector(), 20, 0.9)) do
	if ent:IsPlayer() and ent ~= ply then ply:ChatPrint(ent:Nick() .. " est devant toi") end
end

Contraintes

La bibliothèque constraint serveur crée les mêmes liens que le toolgun : ils sont dessinés chez tous (cordes) et sauvés dans les dupes. Les arguments suivent Garry's Mod ; les « bones » sont ignorés (mets 0). Les positions locales sont dans le repère de chaque entité. ent2 = nil accroche au monde. Chaque fonction renvoie l'identifiant de la contrainte (un nombre) ou nil.

Contraintes pilotées au pavé numérique

Ces contraintes bougent quand le joueur ply (le propriétaire, celui dont on écoute les touches) appuie sur des touches du pavé numérique (KEY_PAD_0 à KEY_PAD_9…), comme celles du toolgun. Longueurs en mètres (0,05 à 100), vitesses en m/s. Les arguments de Garry's Mod sans effet (os, largeur, matériau…) gardent leur place : mets 0.

Pour constraint.FindConstraints et RemoveConstraints, leurs types sont "winch", "hydraulic", "muscle", "pulley" et "advballsocket" ; un moteur est un "axis". Elles sont dessinées chez tous et gardées dans les dupes, comme les autres.

-- Un vérin entre une base figée et une plateforme : 1,5 m au repos, 3 m tant que le joueur tient 8 du pavé numérique.
local base = ents.SpawnProp("builtin:crate", ply:GetPos() + Vector(0, 0.5, -4))
base:SetFrozen(true)
local plateforme = ents.SpawnProp("builtin:crate", base:GetPos() + Vector(0, 1.5, 0))
constraint.Hydraulic(ply, base, plateforme, 0, 0, Vector(0, 0, 0), Vector(0, 0, 0), 1.5, 3, 0, KEY_PAD_8, 0, 1)

Gestion : constraint.Remove(id), constraint.RemoveAll(ent) (renvoie le nombre retiré), constraint.RemoveConstraints(ent, "weld"), constraint.FindConstraints(ent, type) → liste de {Index, Type, Ent1, Ent2} (type facultatif), constraint.GetAllConstrainedEntities(ent) → toutes les entités reliées (ent compris).

local a = ents.SpawnProp("builtin:crate", Vector(0, 1, 0))
local b = ents.SpawnProp("builtin:crate", Vector(0, 2, 0))
constraint.Weld(a, b)
constraint.Rope(a, nil, 0, 0, Vector(0, 0.45, 0), Vector(0, 6, 0), 0, 0.5) -- pend à 6 m du sol

Explosions

util.BlastDamage(pos, rayon, dégâts, attaquant, force) serveur : dégâts aux joueurs avec ligne de vue, qui baissent avec la distance ; pousse les props ; effet visible et hook WeaponExplosion. Rayon de 0,1 à 100 m ; attaquant et force sont facultatifs. Respecte le réglage « dégâts entre joueurs ».

-- Un baril qui explose quand on le supprime.
hook.Add("EntityRemoved", "baril_explosif", function(ent)
	if SERVER and ent:GetModel() == "builtin:barrel" then
		util.BlastDamage(ent:GetPos(), 6, 80)
	end
end)

Changer de map

game.ChangeMap(id, gamemode) serveur change de map (et de gamemode, facultatif) à la fin de l'image ; les scripts actuels s'arrêtent (hook ShutDown). Renvoie false si la map n'existe pas. game.GetMapList() donne les ids : maps intégrées (builtin:…) et .pcmap des addons activés (addon:…/maps/…pcmap).

concommand.Add("prochaine", function(ply)
	if not ply:IsAdmin() then return end
	local maps = game.GetMapList()
	game.ChangeMap(maps[math.random(#maps)])
end)

Date et heure : os

Une version sûre de os, des deux côtés. Rien d'autre (pas de fichiers, pas de commandes).

print(os.date("%A %d %B à %H:%M")) -- « mardi 13 octobre à 07:30 »