Combat systems
Hit detection, timing windows, knockback, and readable PvP loops built for real gameplay use.
I'm William North. I build combat, networking, tooling, and maintainable Luau systems for production Roblox games. As nsawill, I focus on clear architecture, reliable handoff, and shipping under live constraints.
Luau gameplay, live-game maintenance, and developer tooling shaped for production teams.
Shipped projects where player load changes the engineering bar.
Public work across live games, Wally-ready libraries, and Roblox Studio tooling.
Game feel, authority boundaries, predictable multiplayer behavior, and team-friendly Luau structure.
Hit detection, timing windows, knockback, and readable PvP loops built for real gameplay use.
Clear authority boundaries that keep responsive feel without giving up server trust.
RemoteEvent contracts shaped around latency, replication behavior, and predictable multiplayer outcomes.
Planner, navigator, and coordination patterns for NPC movement that stay stable under crowd pressure.
DataStore-facing state thinking that treats recovery and failure modes as part of production quality.
Delivery shaped by compute budgets, repeated systems use, and avoiding avoidable runtime churn.
Reusable components, explicit APIs, and code paths teams can tune without rewriting core behavior.
Studio workflow improvements that remove repetitive work and raise iteration speed for teams.
Live games, real players, release pressure, and measurable scale.
Shipped combat work for a live Roblox game with 7.4M+ visits and about 1.5k peak CCU.
Verified peak concurrency range.
Public production scale.
Small-server combat tuning context.
Live obby production work for a Roblox experience with 20M+ visits and about 1k peak CCU.
Verified peak concurrency range.
Public production scale.
Fast release cadence across live obby work.
These public repos show how the work is structured: authoritative systems, reusable Luau modules, and developer-facing tooling that is meant to survive real project use.
Spatial query hit detection with server/client split, validation helpers, and lag compensation hooks.
Crowd-aware pathfinding with planner, navigator, and coordinator roles split by responsibility.
Event and messaging library focused on cleanup, priorities, middleware, replay, and debugging.
Public snippets showing naming, API design, and engineering boundaries.
Hitbox-Plus server excerpt for authoritative combat validation.
Server validation rule: distance + cooldown gatingif request.attackerPosition ~= nil then
local distance = SpatialMath.distance(
request.attackerPosition,
candidate.position
)
if distance > self.maxDistance then
return false, Types.RejectReason.MaxDistance, {
distance = distance,
}
end
end
if self.targetCooldownSeconds > 0 then
local key = string.format(
'%s::%s',
tostring(request.attackerId),
tostring(candidate.id)
)
local lastAcceptedAt = self.targetHitTimes[key]
if lastAcceptedAt ~= nil
and request.serverTime - lastAcceptedAt <= self.targetCooldownSeconds
then
return false,
Types.RejectReason.TargetCooldown,
{ lastAcceptedAt = lastAcceptedAt }
end
end
Source file ↗
Pathfinding-Plus excerpt for throttled NPC path requests across registered navigators.
Coordinator loop with request throttlingfunction Coordinator:_ensureLoop()
if self._loopRunning or self._destroyed then
return
end
self._loopRunning = true
task.spawn(function()
while not self._destroyed do
local now = os.clock()
if now >= self._nextGlobalIssueAt then
local request = self._queue:PopReady(now)
if request ~= nil then
self._nextGlobalIssueAt = now + self._requestInterval
local ok, result = pcall(request.execute)
request.callback(ok, result)
elseif self._queue:GetSize() == 0 then
self._loopRunning = false
return
end
end
task.wait(self._pollInterval)
end
end)
end
Source file ↗
Shows how responsive client input becomes a server-owned combat result without trusting raw client state.
Authority boundary enforcementBuild attack intent and local timing data close to player input.
Check latency, distance, duplicate attacks, teams, cooldowns, and optional line-of-sight.
Resolve the hit against stored state instead of trusting the latest frame blindly.
Return accepted hits and rejections in a structure gameplay code can use and debug.
Tooling, playable showcases, and applied gameplay work behind the core code proof.
GitHub-style workflow tooling for Roblox Studio, built to keep common project actions inside the editor.
Find project state, switch tools, then repeat the same workflow by hand.
Common GitHub-style actions happen from one plugin surface inside Roblox Studio.
Estimated reduction from keeping repeated actions inside the editor.
EstimatedPlayable Roblox showcase for rendering, mesh, and technical systems experiments.
Vehicle systems focused on driving feel, rewards, and progression feedback.
The clearest single example of how I think about combat design, system boundaries, and multiplayer trust.
Maps a ragdoll PvP prototype into tunable layers so input, validation, and feedback stay separate.
Combat flow: state, attacks, validation, feedbackSprinting and stability values define pressure and vulnerability.
Left/right punches, kicks, and headbutts use explicit startup, active, and recovery windows.
Responsive input feeds bounded server damage and knockback checks.
Damage, stance loss, and ragdoll states produce readable swings.
Movement, attack input, hit response, and feedback shared one tuning surface.
Movement state, attack windows, validation, and feedback tune independently.
Startup, active, and recovery windows stay responsive while force remains bounded.
Limited move set: sprint, left punch, right punch, kick, headbutt. Spacing and timing come before move count.
Movement, attack input, hit resolution, and feedback each own separate state.
Local input stays responsive. Server code bounds damage, force, hit zones, and state transitions.
Exposes tuning values for phase timing, knockback force, stance loss, and ragdoll thresholds.
Architecture is meant to survive updates, handoffs, and the reality of live Roblox production.
Doomed 2 Die and STO shaped how I design for concurrency, release pressure, and maintainable handoff.
Reusable tools, explicit APIs, and system boundaries reduce rewrite risk during handoff.
Available for Roblox gameplay, systems, and tooling work. Message me on Discord for team roles, contract work, or project delivery. Use the GitHub section above for public code proof.