How do i make these commands for my dummies vs noobs game

Help and Feedback Scripting Support
,
1

i tried so much trying to make this image

RobloxScreenShot20250517_084129764
RobloxScreenShot20250517_0841297641262×669 69.3 KB

can someone make these for me i am not the best at making admin commands and the spawn npc whatever name 1 true spawns a ally and the same command without true spawns a enemy heres some code

–[[

Created by: @V3N0M_Z
Reference: https://v3n0m-z.github.io/RBLX-SimplePath/
License: MIT

]]

local DEFAULT_SETTINGS = {

TIME_VARIANCE = 0.07;

COMPARISON_CHECKS = 1;

JUMP_WHEN_STUCK = true;

}

local PathfindingService = game:GetService(“PathfindingService”)
local Players = game:GetService(“Players”)
local function output(func, msg)
func(((func == error and "SimplePath Error: ") or "SimplePath: ")…msg)
end
local Path = {
StatusType = {
Idle = “Idle”;
Active = “Active”;
};
ErrorType = {
LimitReached = “LimitReached”;
TargetUnreachable = “TargetUnreachable”;
ComputationError = “ComputationError”;
AgentStuck = “AgentStuck”;
};
}
Path.__index = function(table, index)
if index == “Stopped” and not table._humanoid then
output(error, “Attempt to use Path.Stopped on a non-humanoid.”)
end
return (table._events[index] and table._events[index].Event)
or (index == “LastError” and table._lastError)
or (index == “Status” and table._status)
or Path[index]
end

–Used to visualize waypoints
local visualWaypoint = Instance.new(“Part”)
visualWaypoint.Size = Vector3.new(0.3, 0.3, 0.3)
visualWaypoint.Anchored = true
visualWaypoint.CanCollide = false
visualWaypoint.Material = Enum.Material.Neon
visualWaypoint.Shape = Enum.PartType.Ball

–[[ PRIVATE FUNCTIONS ]]–
local function declareError(self, errorType)
self._lastError = errorType
self._events.Error:Fire(errorType)
end

–Create visual waypoints
local function createVisualWaypoints(waypoints)
local visualWaypoints = {}
for _, waypoint in ipairs(waypoints) do
local visualWaypointClone = visualWaypoint:Clone()
visualWaypointClone.Position = waypoint.Position
visualWaypointClone.Parent = workspace
visualWaypointClone.Color =
(waypoint == waypoints[#waypoints] and Color3.fromRGB(0, 255, 0))
or (waypoint.Action == Enum.PathWaypointAction.Jump and Color3.fromRGB(255, 0, 0))
or Color3.fromRGB(255, 139, 0)
table.insert(visualWaypoints, visualWaypointClone)
end
return visualWaypoints
end

–Destroy visual waypoints
local function destroyVisualWaypoints(waypoints)
if waypoints then
for _, waypoint in ipairs(waypoints) do
waypoint:Destroy()
end
end
return
end

–Get initial waypoint for non-humanoid
local function getNonHumanoidWaypoint(self)
–Account for multiple waypoints that are sometimes in the same place
for i = 2, self._waypoints do
if (self._waypoints[i].Position - self._waypoints[i - 1].Position).Magnitude > 0.1 then
return i
end
end
return 2
end

–Make NPC jump
local function setJumpState(self)
pcall(function()
if self._humanoid:GetState() ~= Enum.HumanoidStateType.Jumping and self._humanoid:GetState() ~= Enum.HumanoidStateType.Freefall then
self._humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
end
end)
end

–Primary move function
local function move(self)
if self._waypoints[self._currentWaypoint].Action == Enum.PathWaypointAction.Jump then
setJumpState(self)
end
self._humanoid:MoveTo(self._waypoints[self._currentWaypoint].Position)
end

–Disconnect MoveToFinished connection when pathfinding ends
local function disconnectMoveConnection(self)
self._moveConnection:Disconnect()
self._moveConnection = nil
end

–Fire the WaypointReached event
local function invokeWaypointReached(self)
local lastWaypoint = self._waypoints[self._currentWaypoint - 1]
local nextWaypoint = self._waypoints[self._currentWaypoint]
self._events.WaypointReached:Fire(self._agent, lastWaypoint, nextWaypoint)
end

local function moveToFinished(self, reached)

--Stop execution if Path is destroyed
if not getmetatable(self) then return end

--Handle case for non-humanoids
if not self._humanoid then
	if reached and self._currentWaypoint + 1 <= #self._waypoints then
		invokeWaypointReached(self)
		self._currentWaypoint += 1
	elseif reached then
		self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
		self._target = nil
		self._events.Reached:Fire(self._agent, self._waypoints[self._currentWaypoint])
	else
		self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
		self._target = nil
		declareError(self, self.ErrorType.TargetUnreachable)
	end
	return
end

if reached and self._currentWaypoint + 1 <= #self._waypoints  then --Waypoint reached
	if self._currentWaypoint + 1 < #self._waypoints then
		invokeWaypointReached(self)
	end
	self._currentWaypoint += 1
	move(self)
elseif reached then --Target reached, pathfinding ends
	disconnectMoveConnection(self)
	self._status = Path.StatusType.Idle
	self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
	self._events.Reached:Fire(self._agent, self._waypoints[self._currentWaypoint])
else --Target unreachable
	disconnectMoveConnection(self)
	self._status = Path.StatusType.Idle
	self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
	declareError(self, self.ErrorType.TargetUnreachable)
end

end

–Refer to Settings.COMPARISON_CHECKS
local function comparePosition(self)
if self and self._currentWaypoint == self._waypoints then return end
self._position._count = ((self._agent.PrimaryPart.Position - self._position._last).Magnitude <= 0.07 and (self._position._count + 1)) or 0
self._position._last = self._agent.PrimaryPart.Position
if self._position._count >= self._settings.COMPARISON_CHECKS then
if self._settings.JUMP_WHEN_STUCK then
setJumpState(self)
end
declareError(self, self.ErrorType.AgentStuck)
end
end

–[[ STATIC METHODS ]]–
function Path.GetNearestCharacter(fromPosition)
local character, dist = nil, math.huge
for _, player in ipairs(Players:GetPlayers()) do
if player.Character and (player.Character.PrimaryPart.Position - fromPosition).Magnitude < dist then
character, dist = player.Character, (player.Character.PrimaryPart.Position - fromPosition).Magnitude
end
end
return character
end

–[[ CONSTRUCTOR ]]–
function Path.new(agent, agentParameters, override)
if not (agent and agent:IsA(“Model”) and agent.PrimaryPart) then
output(error, “Pathfinding agent must be a valid Model Instance with a set PrimaryPart.”)
end

local self = setmetatable({
	_settings = override or DEFAULT_SETTINGS;
	_events = {
		Reached = Instance.new("BindableEvent");
		WaypointReached = Instance.new("BindableEvent");
		Blocked = Instance.new("BindableEvent");
		Error = Instance.new("BindableEvent");
		Stopped = Instance.new("BindableEvent");
	};
	_agent = agent;
	_humanoid = agent:FindFirstChildOfClass("Humanoid");
	_path = PathfindingService:CreatePath(agentParameters);
	_status = "Idle";
	_t = 0;
	_position = {
		_last = Vector3.new();
		_count = 0;
	};
}, Path)

--Configure settings
for setting, value in pairs(DEFAULT_SETTINGS) do
	self._settings[setting] = self._settings[setting] == nil and value or self._settings[setting]
end

--Path blocked connection
self._path.Blocked:Connect(function(...)
	if (self._currentWaypoint <= ... and self._currentWaypoint + 1 >= ...) and self._humanoid then
		setJumpState(self)
		self._events.Blocked:Fire(self._agent, self._waypoints[...])
	end
end)

return self

end

–[[ NON-STATIC METHODS ]]–
function Path:Destroy()
for _, event in ipairs(self._events) do
event:Destroy()
end
self._events = nil
if rawget(self, “_visualWaypoints”) then
self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
end
self._path:Destroy()
setmetatable(self, nil)
for k, _ in pairs(self) do
self[k] = nil
end
end

function Path:Stop()
if not self._humanoid then
output(error, “Attempt to call Path:Stop() on a non-humanoid.”)
return
end
if self._status == Path.StatusType.Idle then
output(function(m)
warn(debug.traceback(m))
end, “Attempt to run Path:Stop() in idle state”)
return
end
disconnectMoveConnection(self)
self._status = Path.StatusType.Idle
self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
self._events.Stopped:Fire(self._model)
end

function Path:Run(target)

--Non-humanoid handle case
if not target and not self._humanoid and self._target then
	moveToFinished(self, true)
	return
end

--Parameter check
if not (target and (typeof(target) == "Vector3" or target:IsA("BasePart"))) then
	output(error, "Pathfinding target must be a valid Vector3 or BasePart.")
end

--Refer to Settings.TIME_VARIANCE
if os.clock() - self._t <= self._settings.TIME_VARIANCE and self._humanoid then
	task.wait(os.clock() - self._t)
	declareError(self, self.ErrorType.LimitReached)
	return false
elseif self._humanoid then
	self._t = os.clock()
end

--Compute path
local pathComputed, _ = pcall(function()
	self._path:ComputeAsync(self._agent.PrimaryPart.Position, (typeof(target) == "Vector3" and target) or target.Position)
end)

--Make sure path computation is successful
if not pathComputed
	or self._path.Status == Enum.PathStatus.NoPath
	or #self._path:GetWaypoints() < 2
	or (self._humanoid and self._humanoid:GetState() == Enum.HumanoidStateType.Freefall) then
	self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
	task.wait()
	declareError(self, self.ErrorType.ComputationError)
	return false
end

--Set status to active; pathfinding starts
self._status = (self._humanoid and Path.StatusType.Active) or Path.StatusType.Idle
self._target = target

--Set network owner to server to prevent "hops"
pcall(function()
	self._agent.PrimaryPart:SetNetworkOwner(nil)
end)

--Initialize waypoints
self._waypoints = self._path:GetWaypoints()
self._currentWaypoint = 2

--Refer to Settings.COMPARISON_CHECKS
if self._humanoid then
	comparePosition(self)
end

--Visualize waypoints
destroyVisualWaypoints(self._visualWaypoints)
self._visualWaypoints = (self.Visualize and createVisualWaypoints(self._waypoints))

--Create a new move connection if it doesn't exist already
self._moveConnection = self._humanoid and (self._moveConnection or self._humanoid.MoveToFinished:Connect(function(...)
	moveToFinished(self, ...)
end))

--Begin pathfinding
if self._humanoid then
	self._humanoid:MoveTo(self._waypoints[self._currentWaypoint].Position)
elseif #self._waypoints == 2 then
	self._target = nil
	self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
	self._events.Reached:Fire(self._agent, self._waypoints[2])
else
	self._currentWaypoint = getNonHumanoidWaypoint(self)
	moveToFinished(self, true)
end
return true

end

return Path

and

local Mechanics = {}
local RP = game:GetService(“ReplicatedStorage”)

local info = workspace.Info
local Players = game:GetService(“Players”)

function Mechanics.RemoveEnemies ()
for i, Enemies in ipairs(workspace:GetChildren()) do
if Enemies:IsA(“Model”) and Enemies:FindFirstChildOfClass(“Humanoid”) and Enemies.Humanoid:GetAttribute(“Team”) == “Enemies” then
Enemies.Humanoid.Health = 0
end
end
end

function Mechanics.RemoveAllies ()
for i, Enemies in ipairs(workspace:GetChildren()) do
if Enemies:IsA(“Model”) and Enemies:FindFirstChildOfClass(“Humanoid”) and Enemies.Humanoid:GetAttribute(“Team”) == “Allies” then
if not Enemies:FindFirstChildOfClass(“LocalScript”) then
Enemies.Humanoid.Health = 0
end
end
end
end

function Mechanics.RemoveTracers ()
workspace.Tracers:ClearAllChildren()
end

function Mechanics.ResetGame (Status)
Mechanics.RemoveAllies()
Mechanics.RemoveEnemies()
Mechanics.RemoveTracers()

info.Message.Value = Status
workspace.Info.PlayingRound.Value = false
workspace.Map:FindFirstChildOfClass("Folder"):Destroy()
workspace.Lobby.Spawn.Enabled = true

for _, sounds in pairs(workspace["Music"]:GetChildren()) do
	if sounds:IsA("Folder") then
		for _, sound in pairs(sounds:GetChildren()) do
			if sound:IsA("Sound") then
				sound:Stop()
			end
		end
	end
end

for _, player in pairs(Players:GetPlayers()) do
	player.Character.Humanoid.Health = 0
	player:LoadCharacter()
end

workspace.Info.Running.Value = false

end

function Mechanics.Defect(model)
if model then
local Team = model.Humanoid:GetAttribute(“Team”)
local Player = Players:GetPlayerFromCharacter(model)
if Team == “Allies” then
if Player then
Player:LoadCharacter()
Player.CharacterAdded:Wait()
print(“Character added”)
end
model.Humanoid:SetAttribute(“Team”, “Enemies”)
print(“Change team”)
elseif Team == “Enemies” then
if Player then
Player:LoadCharacter()
Player.CharacterAdded:Wait()
end
model.Humanoid:SetAttribute(“Team”, “Allies”)

		local BodyColor = Instance.new("BodyColors", model)
		BodyColor.HeadColor = BrickColor.new("medium Medium stone grey")
		BodyColor.LeftArmColor = BrickColor.new("medium Medium stone grey")
		BodyColor.RightArmColor = BrickColor.new("medium Medium stone grey")
		BodyColor.LeftLegColor = BrickColor.new("medium Medium stone grey")
		BodyColor.RightLegColor = BrickColor.new("medium Medium stone grey")
		BodyColor.TorsoColor = BrickColor.new("dark Dark stone grey")
	end
end

end

return Mechanics

now how do i make the commands for it

2

You’re looking for TextChatCommands.

3

non worked bruh thats not the kind of commands i am looking for

4

You can use them to create text commands instead of coding them in all by yourself.

Example might be this: (Note this has to be in a local script as the server no longer has a way to tell when a player chats, the only work around to this is using a remove event when they trigger this)

local Chat = game:GetService('TextChatService')

local Command = Instance.new('TextChatCommand')
Command.PrimaryAlias = '/Command'
Command.SecondaryAlias = '/Command'
Command.Parent = Chat:WaitForChild('TextChatCommands')

Command.Triggered:Connect(function(_, Unfiltered)
	print(Unfiltered)
end)

Now this gives us the whole command they used, including any parameters they might have provided. To get some parameters we can do this.

So now if we do something like this, and type “/Command Test 53”, the Output will print a table with two items, the first one being “Test”, and the second being 53.

local Chat = game:GetService('TextChatService')

local Command = Instance.new('TextChatCommand')
Command.PrimaryAlias = '/Command'
Command.SecondaryAlias = '/Command'
Command.Parent = Chat:WaitForChild('TextChatCommands')

Command.Triggered:Connect(function(_, Unfiltered)
	local Parameters = string.split(Unfiltered, ' ') -- // To Find parameters we split the Command by every Space.
	table.remove(Parameters, 1) -- // Remove the Command.PrimaryAlias from the list as we already have it.
	
	print(Parameters)
	
end)

Now lets say you need the server to do what ever the command is supposed to do, what you can do is use a remove event and send the Command.PrimaryAlias and the Paremeters and then make the server figure out what the command does.

Client

local Chat = game:GetService('TextChatService')

local RemoveEvent = "Your Remote Event Here"
local Command = Instance.new('TextChatCommand')
Command.PrimaryAlias = '/Command'
Command.SecondaryAlias = '/Command'
Command.Parent = Chat:WaitForChild('TextChatCommands')

Command.Triggered:Connect(function(_, Unfiltered)
	local Parameters = string.split(Unfiltered, ' ') -- // To Find parameters we split the Command by every Space.
	table.remove(Parameters, 1) -- // Remove the Command.PrimaryAlias from the list as we already have it.
	
	RemoveEvent:FireServer(Command.PrimaryAlias, Parameters)
end)

Server

local RemoveEvent = "Your RemoteEvent Here."

RemoveEvent.OnServerEvent:Connect(function(Player:Player, CommandName:string, Paremeters)
	-- // Remove the / from the beggining of the command name
	CommandName = CommandName:gsub('/', '')
	
	-- // Main Server Code //
	
	if CommandName == 'Command' then
		print('Do Command!', Paremeters)
	end
end)

Now if you were to trigger the command, it would send an event to the server, where there the server would figure out what to do. So now you’d just have to put in the code to spawn in whatever based on the items in the Parameters table to spawn in the enemies or whatever. If you need more help just let me know!

If you wanted something else please specify, as I have no idea whats going on in your code, nor do I know what you are trying to achieve. More details would be nice.