Peake RPG — Current Project Rundown

• https://geocities.ws/peakecoin/games/peake_rpg/ - Play Here

With all my computers and servers packed up right now, I have been forced to learn a lot more about Render and hosted backend services.

That has actually pushed me back into some older GitHub projects I had walked away from before. A lot of those projects were not abandoned because the ideas were bad. They were abandoned because I could not fully figure out the backend side at the time.

Now that I am getting more comfortable with Render, I am starting to see a path forward for those older projects. Instead of needing all my own computers and servers running at home, I can keep the frontend lightweight, host the backend online, and slowly bring these ideas back to life.

I have been working on building out Peake RPG, a browser-based text RPG with live-world features, cloud saving, NPCs, shops, and backend storage.

The project has grown from a simple text-command game into a larger structure with a frontend, a Render-hosted backend, and FTP-based storage support.

What Peake RPG Is Right Now

Peake RPG is currently a browser-playable RPG where the player interacts through a game console.

The frontend runs from the web page, while the backend is hosted separately on Render. The game is being built in a way that keeps the browser side lightweight, while the backend handles things like account saves, live world features, and long-term storage.

The basic setup looks like this:

Frontend Game
    ↓
Browser-based HTML / JavaScript
    ↓
Render Backend
    ↓
Node.js server
    ↓
Python FTP helper
    ↓
Static/FTP save storage

Current Frontend

The frontend is the part the player actually sees and uses.

Right now, the game includes:

• A main game console
• Typed commands
• Character stats
• Inventory display
• Save and load buttons
• Cloud save login fields
• Live world controls
• Live chat
• Debug terminal
• NPC conversation window
• Shop support
• Room and map loading
• Character and NPC loading

The game is still text-based at the core, but the structure is moving toward a much bigger RPG system.

Main Frontend Files

index.html
game.js
games.js
maps.js
rooms.js
spawn_point.js
town_start.js
characters.js
animals.js
bad_npcs.js
neutral_npcs.js
shop.js
shop_items.js
banker.js

What The Main Files Do

index.html

This is the main game page.

It contains the layout for the game, including the console, character panel, inventory, save/load section, cloud save panel, live world panel, debug terminal, shop area, and NPC conversation window.

The page also loads the different JavaScript files that power the game.

game.js

This is the main game logic file.

This is where command handling, player interaction, movement, saving, loading, and general gameplay logic are controlled.

games.js

This file can be used for extra game modes, mini-games, or shared game definitions.

maps.js

This file is for the larger world map structure.

The idea is that the world can be separated from individual towns, buildings, caves, temples, and special locations.

rooms.js

This file handles room data.

Rooms are the individual locations the player can stand in, look around, move from, or interact with.

spawn_point.js

This file controls where the player starts.

The spawn point tells the game where the player appears when starting fresh or entering the world.

town_start.js

This file holds the starting town area.

The starting town can contain NPCs, shops, buildings, local descriptions, and early gameplay interactions.

characters.js

This file holds character-related data.

It can be used for player defaults, named NPCs, character templates, or shared character information.

animals.js

This file is for animals and creatures that can exist in the world.

These could eventually be used for hunting, combat, ambience, quests, or random encounters.

bad_npcs.js

This file is for hostile NPCs.

These would likely be enemies, bandits, monsters, criminals, or other dangerous characters the player can fight or avoid.

neutral_npcs.js

This file is for neutral NPCs.

These are characters that are not automatically friendly or hostile. They can be townsfolk, travelers, workers, guards, or random people in the world.

shop_items.js

This file stores the items available in shops.

It can include names, prices, descriptions, stats, and eventually PEK-based item values.

shop.js

This file controls shop behavior.

It can handle displaying items, buying, selling, and connecting shop actions to the game.

banker.js

This file is for the economy and banking side of the game.

This could eventually support player balances, deposits, withdrawals, in-game banking, or PeakeCoin-related economy features.

NPC Structure

The NPC system is being separated into different categories.

Good NPCs
Neutral NPCs
Bad NPCs
Animals / Creatures

That gives the game a cleaner structure.

Instead of throwing every character into one huge file, the world can be organized by behavior and purpose.

good_npcs    = helpers, quest givers, allies
neutral_npcs = townsfolk, workers, merchants, travelers
bad_npcs     = enemies, thieves, monsters, hostile factions
animals      = wildlife, pets, mounts, hunting creatures

This should make the game easier to expand later.

Python NPC Files

There are also some Python NPC files:

good_npcs.py
neutral_npcs.py

For the current browser version, these Python files cannot run directly in the frontend.

That means they are useful in one of two ways:

1. Convert them into JavaScript for the browser game
2. Keep them for backend tools or future server-side world generation

For now, the browser needs .js files, not .py files.

Current Backend

The backend is running on Render.

The backend files include:

server.js
package.json
ftp_store.py
README.md
.gitignore

server.js

This is the Node.js backend server.

This is the part that should handle requests from the frontend, such as:

Register account
Login
Cloud save
Cloud load
Live world status
Live chat
Backend health checks

package.json

This file defines the backend project dependencies and start commands.

Render uses this file to know how to install and run the Node.js backend.

ftp_store.py

This is the Python helper script for FTP storage.

The idea is that the Node.js backend can call or work with this Python script to save and load data from FTP/static storage.

The browser should not touch this file directly.

.gitignore

This file keeps private or unnecessary files out of the public GitHub repository.

This is important for protecting things like:

.env
passwords
API keys
private keys
node_modules
temporary files
save dumps

README.md

This is the project explanation file.

It can be used to explain what the backend does, how to run it, what the routes are, and how the frontend connects to it.

Current Backend Flow

The current backend idea looks like this:

Player opens the game
    ↓
Frontend loads in browser
    ↓
Player logs in or saves game
    ↓
Frontend sends request to Render backend
    ↓
Render backend processes the request
    ↓
Backend stores or loads data using FTP helper
    ↓
Frontend receives the result

That makes the project more powerful than a normal static website.

The static frontend can stay simple, while Render handles the parts that need a server.

Cloud Save System

The game currently has a cloud save panel built into the frontend.

It includes:

Backend API URL
Username
Password
Register button
Login button
Cloud Save button
Cloud Load button
Status display

The current backend URL is set up as:

https://peakerpg-backend.onrender.com

The goal is to let players save their progress without only relying on local save codes.

Live World System

There is also a live world panel.

It includes:

Join World
Leave World
Live world status
Online player display
World chat log
Chat input
Send chat button

This is an early step toward making the RPG feel more alive.

Even if the game starts as mostly text-based, the live world system could eventually allow:

Players seeing who else is online
Basic multiplayer chat
Shared world events
Player locations
Party systems
Trading
PvP or co-op features

Debug Terminal

The frontend also includes a debug terminal.

This is useful because the project has a frontend, backend, and storage system all working together.

The debug terminal can help test things like:

Is the backend online?
Is Render responding?
Can the frontend reach the API?
Is the live world connection working?
Are save/load routes working?

This is a smart addition because it gives the game its own built-in troubleshooting window.

Economy System

The game now has early pieces of an economy system.

The current economy-related files are:

shop.js
shop_items.js
banker.js

This opens the door for:

Buying items
Selling items
Banking currency
Storing balances
Creating item markets
Adding PeakeCoin utility
Using PEK as in-game currency

Since this project is connected to the larger PeakeCoin ecosystem, the economy system could eventually become one of the most important parts of the game.

Current Project Structure

Peake RPG
│
├── Frontend
│   ├── index.html
│   ├── game.js
│   ├── games.js
│   ├── maps.js
│   ├── rooms.js
│   ├── spawn_point.js
│   ├── town_start.js
│   ├── characters.js
│   ├── animals.js
│   ├── bad_npcs.js
│   ├── neutral_npcs.js
│   ├── shop.js
│   ├── shop_items.js
│   └── banker.js
│
├── NPC / Data Helpers
│   ├── good_npcs.py
│   └── neutral_npcs.py
│
└── Backend
    ├── server.js
    ├── package.json
    ├── ftp_store.py
    ├── README.md
    └── .gitignore

What This Means

At this point, Peake RPG is no longer just a simple text game.

It now has the bones of:

A browser RPG
A cloud save system
A live world system
A shop economy
A banking system
NPC categories
Creature files
Room-based world design
Backend API support
FTP-based storage
Render deployment

That is a strong foundation.

The project is still early, but the structure is starting to look like something that can grow into a real online RPG.

What Still Needs Work

The next major steps are:

Clean up the file load order
Make sure every JavaScript file attaches data to the browser correctly
Convert Python NPC files into JavaScript if they are needed on the frontend
Make sure frontend API routes match the Render backend routes
Protect all backend secrets
Test cloud save and cloud load
Test live world connection
Connect NPCs to rooms
Connect shops to actual items
Connect banker logic to the player economy
Eventually connect PEK / PeakeCoin utility

The Big Picture

The long-term vision is to build a lightweight RPG that can run from a simple frontend but still have online features through a backend.

That means the game can stay cheap to host while still supporting features like saves, accounts, shops, NPCs, and maybe even multiplayer-style interaction.

It is a poor man’s MMO foundation.

Not flashy yet.

Not finished yet.

But the bones are there.

And that is the important part.

Peake RPG is now moving from a simple browser experiment into a real game system.

🤖 PeakeBot — Autonomous Trading System (RC-AWARE)

Independent multi-token trading bot featuring:
RC-aware execution, adaptive delay logic, and self-regulating trade cycles.

🌐 Live PeakeBot Interface:
👉 https://peakebot.onrender.com/

📊 Trading bot details:
👉 https://geocities.ws/p/e/peakecoin/trading-bot/peakebot_v0_01.html

💻 Open-source repositories:
👉 https://github.com/paulmoon410

🙏 Acknowledgements

Thanks to and please follow:
@enginewitty @ecoinstant @neoxian @txracer @thecrazygm @holdonia @aggroed

For their continued support, guidance, and help expanding the PeakeCoin ecosystem.