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.
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
The frontend is the part the player actually sees and uses.
Right now, the game includes:
The game is still text-based at the core, but the structure is moving toward a much bigger RPG system.
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
index.htmlThis 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.jsThis is the main game logic file.
This is where command handling, player interaction, movement, saving, loading, and general gameplay logic are controlled.
games.jsThis file can be used for extra game modes, mini-games, or shared game definitions.
maps.jsThis 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.jsThis file handles room data.
Rooms are the individual locations the player can stand in, look around, move from, or interact with.
spawn_point.jsThis 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.jsThis file holds the starting town area.
The starting town can contain NPCs, shops, buildings, local descriptions, and early gameplay interactions.
characters.jsThis file holds character-related data.
It can be used for player defaults, named NPCs, character templates, or shared character information.
animals.jsThis 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.jsThis 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.jsThis 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.jsThis file stores the items available in shops.
It can include names, prices, descriptions, stats, and eventually PEK-based item values.
shop.jsThis file controls shop behavior.
It can handle displaying items, buying, selling, and connecting shop actions to the game.
banker.jsThis 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.
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.
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.
The backend is running on Render.
The backend files include:
server.js
package.json
ftp_store.py
README.md
.gitignore
server.jsThis 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.jsonThis 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.pyThis 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.
.gitignoreThis 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.mdThis 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.
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.
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.
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
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.
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.
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
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.
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 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
For their continued support, guidance, and help expanding the PeakeCoin ecosystem.
