redm-cores

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

★ 9 Open GitHub ↗

RedM cores library — percentage-based inner and outer core management for health, stamina, and dead-eye. Works with VORP, RedEM:RP, and standalone RedM scripts.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# RedM Cores — Percentage-Based Inner & Outer Core Library for RedM Scripts

> A lightweight Lua library for **RedM scripts** that manages health, stamina, and dead-eye cores using **percentage values** (0–100) for both **inner** and **outer** cores — independent of in-game tank levels, so your math stays portable across servers and configurations.

**Looking for premium RedM scripts?** Browse the full Luman Studio catalog at **[lumanstudio.com](https://lumanstudio.com)** — production-ready RedM and FiveM scripts with active support, documentation, and regular updates.

![redm-cores preview](https://github.com/draobrehtom/redm-cores/assets/6503721/97f84374-e9aa-47c0-a6ac-bbdc65321610)

---

## Table of Contents

- [About](#about)
- [Inner vs Outer Cores — Why They Matter](#inner-vs-outer-cores--why-they-matter)
- [Why Percentage-Based Management](#why-percentage-based-management)
- [Features](#features)
- [Requirements](#requirements)
- [Installation](#installation)
- [Configuration](#configuration)
- [Usage Example](#usage-example)
- [API Reference](#api-reference)
- [Core Math Reference](#core-math-reference)
- [Framework Integration](#framework-integration)
- [Performance](#performance)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Compatibility](#compatibility)
- [Related RedM Scripts](#related-redm-scripts)
- [Support](#support)
- [License](#license)

## About

In RedM every player has three cores that govern survival and combat:

- **Health core** — physical condition
- **Stamina core** — sprinting, swimming, and exertion
- **Dead-eye core** — precision-aim mechanic

Each of those cores is actually **two** values: an **inner core** (the solid center circle) and an **outer core** (the ring around it). The inner core has a fixed maximum; the outer core scales with the player's *tank level* (1–10), which changes the raw in-game maximum.

`redm-cores` hides that complexity behind a single percentage API. You write `setInnerCoreHealth(75)` and the library handles the native math, regardless of what the player's outer core level happens to be.

This is the library most RedM scripts wish existed on day one.

## Inner vs Outer Cores — Why They Matter

Under the hood, RedM computes maximum core values like this:

| Core | Max Inner (constant) | Max Outer (per tank level) |
|---|---|---|
| Health | 100.0 | 50.0 × `HEALTH_TANK_1` |
| Stamina | 22.4 | 11.2 × `STAMINA_TANK_1` |
| Dead-eye | 28.0 | 14.0 × `STAMINA_TANK_1` |

So a player with `HEALTH_TANK_1 = 10` has a max health of **600.0**, but a player with `HEALTH_TANK_1 = 1` has a max of **150.0**.

If your **RedM script** hard-codes "subtract 50 health per hit", it behaves completely differently on those two players. Percentage math fixes this: 10% of max always means 10% of max.

`redm-cores` does that conversion for you on every read and write.

## Why Percentage-Based Management

**Relative configuration.** A metabolism script that drains stamina by 5% per minute is portable between servers. A script that subtracts a fixed raw value is not.

**Framework independence.** VORP, RedEM:RP, and standalone servers all expose cores slightly differently. Percentages are a common, stable unit.

**Readable code.** `setOuterCoreHealth(100)` is obvious. Raw native calls with hard-coded floats are not.

**Safer math.** No off-by-one bugs from misunderstanding native value ranges, and no divergence when a player levels up their outer core.

**Inner and outer, separately.** Most helpers only expose one of the two. `redm-cores` lets you address each independently — critical for correct survival, bonding, and metabolism systems.

## Features

- Unified percentage API (0–100) for health, stamina, and dead-eye cores
- **Separate control of inner and outer cores** for each of the three
- Client-side exports, callable from any RedM script
- Config-driven outer core level on first connect (1–10)
- Zero external dependencies (ships its own `dataview.lua` helper)
- Tested against VORP Core, RedEM:RP, and standalone RedM servers
- Minimal performance footprint — no per-frame polling
- Clean Lua 5.4 codebase, MIT-style reuse

## Requirements

- RedM server (build 1311 or newer)
- CFX server artifacts up to date
- Lua 5.4 enabled on the resource (already set in `fxmanifest.lua`)
- Optional: VORP Core, RedEM:RP, or any framework (works standalone too)

## Installation

```bash
cd resources
git clone https://github.com/draobrehtom/redm-cores.git
```

Add to `server.cfg`:

```cfg
ensure redm-cores
```

Start your server. The library exposes its exports immediately. No framework bridge required.

## Configuration

Edit `config.lua`:

```lua
Config = {}

Config.DevMode = true

-- Initial player outer core levels (range: 1–10).
-- Applied on first player connection.
-- Changing these at runtime may result in unexpected behavior;
-- players must reconnect to see reverted values.
Config.PlayerHealthOuterCoreLevel  = 5
Config.PlayerStaminaOuterCoreLevel = 5
Config.PlayerDeadEyeOuterCoreLevel = 5
```

**What each field does**

- `Config.DevMode` — enables extra logging during development. Turn off in production.
- `Config.Player*OuterCoreLevel` — the tank level (1–10) the library upgrades the player's outer core to on first connection. Level 10 gives the full raw maximum; level 1 gives the smallest.

## Usage Example

From any client-side RedM script:

```lua
-- Health core
exports['redm-cores']:setInnerCoreHealth(50)
exports['redm-cores']:setOuterCoreHealth(50)
local innerH = exports['redm-cores']:getInnerCoreHealth() -- 50
local outerH = exports['redm-cores']:getOuterCoreHealth() -- 50

-- Stamina core
exports['redm-cores']:setInnerCoreStamina(50)
exports['redm-cores']:setOuterCoreStamina(50)
local innerS = exports['redm-cores']:getInnerCoreStamina() -- 50
local outerS = exports['redm-cores']:getOuterCoreStamina() -- 50

-- Dead-eye core
exports['redm-cores']:setInnerCoreDeadEye(50)
exports['redm-cores']:setOuterCoreDeadEye(50)
local innerD = exports['redm-cores']:getInnerCoreDeadEye() -- 50
local outerD = exports['redm-cores']:getOuterCoreDeadEye() -- 50
```

That is the entire surface area. No framework boilerplate, no event gymnastics.

### Real-world snippet: slow stamina drain

```lua
CreateThread(function()
    while true do
        Wait(5000)
        local current = exports['redm-cores']:getOuterCoreStamina()
        exports['redm-cores']:setOuterCoreStamina(math.max(0, current - 2))
    end
end)
```

### Real-world snippet: full reset on respawn

```lua
AddEventHandler('playerSpawned', function()
    exports['redm-cores']:setInnerCoreHealth(100)
    exports['redm-cores']:setOuterCoreHealth(100)
    exports['redm-cores']:setInnerCoreStamina(100)
    exports['redm-cores']:setOuterCoreStamina(100)
    exports['redm-cores']:setInnerCoreDeadEye(100)
    exports['redm-cores']:setOuterCoreDeadEye(100)
end)
```

## API Reference

All values are percentages from `0` to `100`. Setters clamp input; getters return the current percentage relative to the current tank-level maximum.

### Health

- `setInnerCoreHealth(percent)` — set health inner core
- `getInnerCoreHealth() -> number` — read health inner core
- `setOuterCoreHealth(percent)` — set health outer core
- `getOuterCoreHealth() -> number` — read health outer core

### Stamina

- `setInnerCoreStamina(percent)` — set stamina inner core
- `getInnerCoreStamina() -> number` — read stamina inner core
- `setOuterCoreStamina(percent)` — set stamina outer core
- `getOuterCoreStamina() -> number` — read stamina outer core

### Dead-eye

- `setInnerCoreDeadEye(percent)` — set dead-eye inner core
- `getInnerCoreDeadEye() -> number` — read dead-eye inner core
- `setOuterCoreDeadEye(percent)` — set dead-eye outer core
- `getOuterCoreDeadEye() -> number` — read dead-eye outer core

## Core Math Reference

If you are curious about what the percentages map to internally, the `docs/` folder contains derivations for each core. Summary:

**Health** — `GetEntityMaxHealth(PlayerPedId())` returns `100 + 50 × HEALTH_TANK_1`.
- Tank 10 → max 600
- Tank 5 → max 350
- Tank 1 → max 150

**Stamina** — `GetPedMaxStamina(PlayerPedId())` returns `22.4 + 11.2 × STAMINA_TANK_1`.
- Tank 10 → max 134.4
- Tank 5 → max 78.4
- Tank 1 → max 33.6

**Dead-eye** — `GetPlayerMaxDeadEye(PlayerId())` returns `28 + 14 × STAMINA_TANK_1`.
- Tank 10 → max 168
- Tank 5 → max 98
- Tank 1 → max 42

`redm-cores` normalizes all three to a uniform 0–100 scale so your RedM scripts do not have to care about tank levels at all.

## Framework Integration

**VORP Core.** `redm-cores` sits on top of VORP cleanly. Use it for core math while VORP handles inventory, characters, and persistence. A typical pattern:

```lua
RegisterNetEvent('vorp:SelectedCharacter', function()
    exports['redm-cores']:setInnerCoreHealth(100)
    exports['redm-cores']:setOuterCoreHealth(100)
end)
```

**RedEM:RP.** Same layering. RedEM:RP's character system owns persistence; `redm-cores` owns the live percentages. Hook `redem:playerSpawn` or your equivalent event.

**Standalone.** Works with zero framework. Ideal for minimal RedM scripts or custom stacks — many of the smaller production servers do exactly this.

## Performance

- No per-frame loops
- Exports are thin wrappers around clamped native calls
- Outer core level upgrades happen **once**, on first player connection
- Safe for high-population RedM servers

## Troubleshooting

**Export returns nil.** The library is **client-side**. Calling exports from server-side RedM scripts will not work — bridge through a net event.

**Values do not match what I set.** Some other RedM script on your server is writing to the same cores in the same frame. Disable the conflicting script, or coordinate writes.

**Outer core level seems "stuck" at 10.** Runtime changes to `Config.Player*OuterCoreLevel` are not reversible without a reconnect — this is a game-engine limitation, not a bug. Reconnecting resets to the config value.

**Cores appear full but stats feel low.** You may be reading percentages while some other system writes raw values. Pick one layer of truth and keep `redm-cores` as the gateway.

**`getInner*` returns an unexpected number.** Inner cores drain faster than outer cores in native gameplay — check that nothing ambient (cold, hunger, damage) is draining them between your set and get.

## FAQ

**Does this replace VORP's core system?**
No. It complements it. VORP handles persistence and character data; `redm-cores` gives you a clean percentage API for live values.

**Can I use it in paid RedM scripts?**
Yes. Commercial use is permitted.

**Why both inner and outer cores?**
Because RedM natively exposes both, and a lot of gameplay mechanics (survival, bonding, hunger) only make sense when you can address them separately. Most competing helpers collapse them into one value and lose fidelity.

**Does it work with the latest RedM build?**
Yes. Core natives are stable across recent RedM versions.

**Does it work server-side?**
Exports are client-only. For server-authoritative logic, bridge with a net event.

**Where can I get more polished RedM scripts built like this?**
**[Luman Studio](https://lumanstudio.com)** ships production RedM and FiveM scripts — metabolism, inventory, HUDs, full RP systems, and more.

## Compatibility

- RedM server build 1311+
- Lua 5.4
- VORP Core (latest)
- RedEM:RP (latest)
- Standalone RedM servers
- Compatible with other Luman Studio RedM scripts out of the box

## Related RedM Scripts

- **[redm-uiapps](https://github.com/draobrehtom/redm-uiapps)** — collection of native UIAPPS examples and DataBinding patterns for RedM scripts
- **[Luman Studio catalog](https://lumanstudio.com)** — premium FiveM and RedM scripts
- **[Luman Studio Tebex](https://lumanstudio.tebex.io)** — direct store

## Support

- Website: **[lumanstudio.com](https://lumanstudio.com)**
- Store: **[lumanstudio.tebex.io](https://lumanstudio.tebex.io)**
- YouTube: **[@lumanstudio](https://www.youtube.com/@lumanstudio)**

[![Luman Studio](https://github.com/draobrehtom/redm-cores/assets/6503721/8a01ef9e-802a-4ad1-9162-5dd62de5bf94)](https://lumanstudio.tebex.io/)

Bug reports and feature requests are welcome — open an issue.

## License

Free to use, modify, and redistribute in any RedM scripts, RedM servers, or commercial resources.

redm-cores

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README