Open77.cyberware

Open77.cyberware.approveLegJump(request, sequence, allowed)

Answer the owned native second-jump intent with the server's decision.

Requires player.cyberware.project and a running resource. request is the owned native request; sequence is the positive uint32 of the pending action reported by legsActivity; allowed is a boolean. true means the matching pending native intent accepted the decision, not that a jump was consumed, displaced or rendered. Open77 buffers an eligible press for at most 750 ms, so a late grant still has to pass the native timeout and the original native predicates. Stamina is charged on server admission and is not refunded when native execution later expires. This is a trusted projection primitive, not a public server-side jump command or a security boundary against a modified client.

local ok, reason = Open77.cyberware.approveLegJump(request, activity.sequence, true)
if not ok then print(reason) end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareApproveLegJump (line 24842).

Open77.cyberware.attackState()

Read local native Gorilla melee activity.

Requires player.cyberware.read. Trusted native projection primitive used by open77_cyberware; it does not install a durable implant or authorize damage. Returns {sequence,holding,variant,record,chargeExpired} when a usable native Gorilla weapon is observed; unavailable/unarmed states return nil, reason. This is client observation, not authoritative charge, damage or cooldown. The platform forwards bounded intent and the server validates it.

local state = Open77.cyberware.attackState()
if state then print(state.sequence, state.holding, state.chargeExpired) end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareAttackState (line 24838).

Open77.cyberware.captureArms()

Capture the local native Gorilla Arms posture profiles.

Requires player.cyberware.read. Trusted native projection primitive used by open77_cyberware; it does not install a durable implant or authorize damage. Returns {family,groups}; groups contain part/name hashes and key pairs. The validated adapter supplies matching holstered and drawn alternatives for male or female, not arbitrary replacement assets. Native readiness and equipment readback do not prove rendered geometry.

local profile, err = Open77.cyberware.captureArms()
if not profile then print(err); return end
print(profile.family, #profile.groups)

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareCaptureArms (line 24833).

Open77.cyberware.configureLegs(request, staminaManaged, maxAirborneMs, maxFallSpeed)

Configure the owned ready legs adapter's admission limits.

Requires player.cyberware.project and a running resource. request must be a ready owned request. staminaManaged=true selects suppression of the native second-jump stamina debit and requires the server pricing path; it is not a stamina cost argument. maxAirborneMs is an integer 100-10000 and maxFallSpeed a finite 0.1-30 m/s, matching the grade table. These limits only narrow native eligibility: they never change jump height, trajectory, gravity, fall damage or native collision response. Support sets them from the installed grade snapshot.

local ok, reason = Open77.cyberware.configureLegs(request, true, 10000, 30.0)
if not ok then print(reason) end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareConfigureLegs (line 24841).

Open77.cyberware.configureLocal(request, options)

Configure native charge limits and stamina-override presence.

Requires player.cyberware.project. Trusted native projection primitive used by open77_cyberware; it does not install a durable implant or authorize damage. Requires the same owned ready request. options accepts nullable normalStaminaCost/chargedStaminaCost (0..300) and maxChargeMs (100..60000, default10000). Native code uses cost presence to suppress supported native attack prices; the server owns the actual costs and debits. It does not grant stamina or suppress unrelated movement costs.

local ok, err = Open77.cyberware.configureLocal(request, {
    normalStaminaCost=10, chargedStaminaCost=20, maxChargeMs=3000
})
if not ok then print(err) end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareConfigureLocal (line 24837).

Open77.cyberware.grantLegLease(lease, epoch, budget, ttlMs)

Hold the server's double-jump activation lease on the local body.

Requires player.cyberware.project and a running resource. Trusted projection primitive used by the shipped open77_cyberware client: with a lease held, a second-jump press is spent locally and the jump happens on the frame the player pressed; the server is told afterwards and reconciles at the stamp. lease is the server's lease id, epoch its uint32 epoch, budget the activations it allows (1-64) and ttlMs how much longer it is valid (1-30000) -- a remaining lifetime, never an absolute deadline, so no clock domain is mixed. Returns true when the lease is held; nil, reason otherwise (invalid_lease, cyberware_backend_unavailable). Without a lease the ask-and-wait path still runs.

-- Mirror the server's lease grant onto the body (open77_cyberware does this for you)
RegisterNetEvent("open77:leases:grant", function(value)
    if value.kind ~= "double_jump" then return end
    local ttl = value.deadlineMs - serverNowMs()
    local ok, err = Open77.cyberware.grantLegLease(value.leaseId, value.epoch or 0, value.budget or 1, ttl)
    if not ok then print(err) end
end)

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareGrantLegLease (line 24843).

Open77.cyberware.legReportSent(reportSequence)

Mark the pending leased jump report as sent.

Requires player.cyberware.project. After a leased press the activity reported by legsActivity carries reportSequence; once the resource has sent that report to the server, this returns the activation to idle. The lease keeps whatever budget it has left.

local activity = Open77.cyberware.legsActivity()
if activity and activity.reportSequence > 0 then
    TriggerServerEvent("open77:cyberware:legReport", { sequence = activity.reportSequence, ageMs = activity.ageMs })
    Open77.cyberware.legReportSent(activity.reportSequence)
end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareLegReportSent (line 24846).

Open77.cyberware.legsActivity()

Read fresh native legs action and airborne state.

Requires player.cyberware.read. Returns {request,sequence,phase,grounded,airborneMs,verticalSpeed}. Phases are idle, pending, granted, consumed and rejected; sequence is a positive uint32 while an action is pending and can report zero when idle. This is local native observation, not an authorization and not rendered proof. A resource that does not own the native adapter should use open77_cyberware's read-only legsActivity export instead: the core method inspects only the calling VM's own owner.

local activity, reason = Open77.cyberware.legsActivity()
if activity then print(activity.phase, activity.airborneMs) else print(reason) end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareLegsActivity (line 24847).

Open77.cyberware.legsState(request)

Read the owned native legs projection phase.

Requires player.cyberware.project. request is the positive ID returned by projectLegs. Returns "pending", "ready" or "failed" plus a reason string for a validly shaped query; a malformed request returns nil, reason. "ready" means the native equipment readback matched across three bridge polls, not that a second jump was performed or rendered. Another resource cannot read this owner's private request by guessing its numeric ID.

local phase, reason = Open77.cyberware.legsState(request)
if phase ~= 'ready' then print(phase, reason) end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareLegsState (line 24840).

Open77.cyberware.localState(request)

Read the native equipment projection state for an owned request.

Requires player.cyberware.project. Trusted native projection primitive used by open77_cyberware; it does not install a durable implant or authorize damage. Returns a phase string and a reason string: pending, ready or failed for the matching native request. Invalid/foreign native requests may return an empty phase plus reason; Lua permission/argument failures return nil, reason. ready describes native equipment readback, not SQL commit or visible confirmation.

local phase, reason = Open77.cyberware.localState(request)
if phase == "failed" or not phase or phase == "" then print(reason) end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareLocalState (line 24836).

Open77.cyberware.presentArms(playerId, profile)

Project or clear an owned Gorilla Arms appearance overlay.

Requires player.cyberware.project. Trusted native projection primitive used by open77_cyberware; it does not install a durable implant or authorize damage. playerId is the network player ID, including the local player for its self-view. Pass a validated captured {family,groups} profile, or false to clear. Overlay ownership survives identical replays; conflicting owners fail. Native attachment/posture work is asynchronous; true is acceptance, not visible completion.

local profile, err = Open77.cyberware.captureArms()
if profile then
    local ok, reason = Open77.cyberware.presentArms(playerId, profile)
    if not ok then print(reason) end
end

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwarePresentArms (line 24834).

Open77.cyberware.projectLegs(enabled)

Queue native local double-jump legs installation or removal.

Requires player.cyberware.project and a running resource. Trusted native projection primitive used by open77_cyberware; it does not install a durable implant, grant a jump or authorize damage. enabled=true equips the supported native legs cyberware (Items.BoostedTendonsRare through the native LegsCW area); false releases it. Returns an owned positive integer request ID; poll legsState(request). Readiness requires matching owned item and HasDoubleJump readback and is not rendered proof. Arms and legs have distinct native owners, requests and equipment areas, so a legs request never disturbs an installed Gorilla Arms projection. Resource stop invokes owned cleanup, which unequips only the item this adapter created.

local request, reason = Open77.cyberware.projectLegs(true)
if not request then print(reason); return end
print(Open77.cyberware.legsState(request))

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareProjectLegs (line 24839).

Open77.cyberware.projectLocal(enabled)

Queue native local Gorilla equipment installation or removal.

Requires player.cyberware.project. Trusted native projection primitive used by open77_cyberware; it does not install a durable implant or authorize damage. enabled=true equips the supported native arms; false restores bare arms. Returns an owned positive integer request ID. Poll localState(request); queued work is neither a committed purchase nor visual proof. Resource stop releases the native owner.

local request, err = Open77.cyberware.projectLocal(true)
if not request then print(err); return end
-- The platform projector correlates native readiness with the server ticket.
print(Open77.cyberware.localState(request))

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareProjectLocal (line 24835).

Open77.cyberware.refreshLegLease(epoch, remaining, ttlMs)

Refresh the held double-jump lease with the server's latest budget and lifetime.

Requires player.cyberware.project. Applies the 20 Hz refresh the server sends on its snapshot stream: epoch must match the held lease, remaining is the activations still allowed, ttlMs the remaining lifetime. A refresh for another epoch is ignored. Trusted projection primitive; not a public API.

RegisterNetEvent("open77:leases:refresh", function(value)
    if value.kind ~= "double_jump" then return end
    Open77.cyberware.refreshLegLease(value.epoch, value.remaining or 0, value.deadlineMs - serverNowMs())
end)

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareRefreshLegLease (line 24844).

Open77.cyberware.releaseLegLease()

Drop the held double-jump lease; presses go back to ask-and-wait.

Requires player.cyberware.project. Called on a server revoke, on a session change and on resource stop. Idempotent.

RegisterNetEvent("open77:leases:revoke", function(value)
    if value.kind == "double_jump" then Open77.cyberware.releaseLegLease() end
end)

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareReleaseLegLease (line 24845).

Open77.cyberware.releaseLegs()

Request owned native legs cleanup.

Requires player.cyberware.project and a running resource. Releases only the calling resource's own native legs projection and is harmless when it owns none. true acknowledges the request; completion is asynchronous. Cleanup unequips this adapter's owned item and removes an inventory copy only when this adapter created it, so a pre-existing unowned double-jump capability is left alone. Resource teardown invokes the same owned cleanup even after Lua callbacks have ended.

-- The double-jump trial ended: release this resource's legs projection
AddEventHandler("trial:ended", function()
    Open77.cyberware.releaseLegs()
end)

Gorilla Arms implementation guide · Registered in ResourceHost.cpp as LuaCyberwareReleaseLegs (line 24848).