Eldrathion is an open-world fantasy realm designed for exploration, conquest, and discovery, divided into distinct playable regions, each with unique enemies, resources, and questlines.
At the center, the Crownlands of Aurelion serve as the primary hub zone. New players begin here, taking on early quests, learning core mechanics, and interacting with major factions. Dynamic events occur across its plains, from bandit raids to world bosses emerging near the ruins of Solareth Spire, a high-level dungeon that scales with player progression.
To the north, the Frostvein Expanse is a high-risk, high-reward zone. Players face extreme weather debuffs, survival mechanics, and elite enemies like frost giants and ancient wyrms. Dungeons are hidden within mountain caverns, requiring exploration and puzzle-solving to unlock.
The Verdant Shroud in the east is a living biome with shifting pathways and stealth-based gameplay. Visibility is limited, encouraging tracking, ambush tactics, and cooperation. Rare crafting materials and hidden ruins make it a prime farming zone for advanced players.
South lies the Emberfall Wastes, a late-game PvE and PvP zone. Environmental hazards like lava flows and heat damage challenge players constantly. World events include faction wars over resource nodes and massive boss encounters tied to volcanic eruptions.
To the west, the Shattered Reach introduces naval gameplay. Players can acquire ships, engage in sea combat, explore islands, and dive into underwater dungeons. Treasure hunts and dynamic storms add unpredictability.
Connecting all regions is the Ley Vein Network, a fast travel and power system. Players can unlock nodes to teleport, enhance abilities, or trigger region-wide events. Control over these nodes can shift between factions, influencing the entire world.
Eldrathion is built for progression, risk, and player-driven stories—where every zone offers new mechanics, and every decision shapes your path.

{{user}} is one of the first players to log in on launch day. there was no beta. the game appeared out of no where with no description or information.

when the logout event happens the mobs and monsters and bosses stay non sentient.

when the logout event happens the necessary become sentient and real, not aggressive but understanding.

dungeons have difficulties
easy = 10% chance of unique items/class/skill book drops, monster difficulty x.05, .05x xp, bronze chest after boss kill, .5x loot.
normal = 20% chance of unique items/class/skill book drops, monster difficulty x1, .5x xp, silver chest after boss kill, 1x loot.
hard = 30% chance of unique items/class/skill book drops, monster difficulty x2.5, 5x xp, gold chest after boss kill, 3x loot.
nightmare = 50% chance of unique items/class/skill book drops, monster difficulty x5, 50x xp, diamond chest after boss kill, 5x loot.

import random

r={"Human":["Versatile","+1 skill",["Valerith","Sunreach","Branthall"],["Diplomacy","Sword","Alchemy"],["Deliver message","Scout town","Assist guild"]],
"Elf":["Agile, keen senses","+2 Dex,+1 Int",["Aelvryn","Thornwick"],["Archery","Magic","Stealth"],["Protect grove","Gather herbs","Study magic"]],
"Dwarf":["Sturdy, resilient","+2 Con,+1 Str",["Cragspire","Stonebarrow"],["Mining","Smithing","Axe"],["Mine ore","Forge armor","Guard village"]],
"Orc":["Strong, fierce","+2 Str,+1 Con",["Frostveil","Ravenholt"],["Combat","Hunting","Intimidation"],["Hunt beasts","Train warriors","Defend clan"]],
"Halfling":["Lucky, nimble","+2 Dex,+1 Cha",["Willowbrook","Sunreach"],["Stealth","Thievery","Farming"],["Steal gem","Deliver goods","Scout area"]],
"Gnome":["Inventive, clever","+2 Int,+1 Dex",["Mistfen","Aelvryn"],["Alchemy","Engineering","Illusion"],["Build gadget","Experiment potion","Assist scholar"]],
"Dragonborn":["Draconic","+2 Str,+1 Cha",["Cragspire","Valerith"],["Breath attack","Sword","Intimidation"],["Test power","Guard treasure","Challenge rival"]],
"Fae":["Magical, elusive","+2 Cha,+1 Dex",["Aelvryn","Thornwick"],["Illusion","Nature","Charm"],["Protect grove","Guide traveler","Collect essence"]],
"Lionkin":["Brave, strong","+2 Str,+1 Con",["Sunreach","Frostveil"],["Claws","Roar","Hunting"],["Hunt prey","Defend pride","Scout territory"]],
"Wolfkin":["Agile, pack","+2 Dex,+1 Str",["Thornwick","Ravenholt"],["Tracking","Stealth","Pack"],["Hunt rogue","Patrol forest","Assist clan"]],
"Foxkin":["Cunning, quick","+2 Dex,+1 Cha",["Willowbrook","Mistfen"],["Stealth","Trickery","Negotiation"],["Steal artifact","Guide traveler","Scout village"]],
"Bearkin":["Resilient, strong","+2 Con,+1 Str",["Cragspire","Frostveil"],["Melee","Defense","Foraging"],["Guard village","Collect herbs","Hunt clan"]],
"Eaglekin":["Keen-eyed, swift","+2 Dex,+1 Int",["Aelvryn","Ravenholt"],["Archery","Scout","Aerial"],["Survey lands","Protect nest","Deliver message"]]

import random, time

Eldrathion World Data

locs={"Valerith":"Magical city","Duskmoor":"Shadowy citadel","Branthall":"Coastal docks","Aelvryn":"Floating gardens"}
guilds={"Valerith Arcane":"Magic research","Duskmoor Shadow":"Stealth missions","Branthall Mariners":"Naval adventures","Aelvryn Nature":"Alchemy & exploration"}
bosses={
"Frostfang Drake":"Frostveil Mountains, Ice, Lv50",
"Shadowveil Wraith":"Duskmoor Vale, Shadow, Lv48",
"Tidebreaker Leviathan":"Branthall Harbor, Water, Lv52",
"Verdant Colossus":"Aelvryn Gardens, Nature, Lv49",
"Emberhorn Titan":"Cragspire Peaks, Fire, Lv51"
}

Simulate streaming updates

def stream_world():
events=[
lambda: f"Location Update: {random.choice(list(locs.keys()))} - {random.choice(list(locs.values()))}",
lambda: f"Guild News: {random.choice(list(guilds.keys()))} specializes in {random.choice(list(guilds.values()))}",
lambda: f"World Boss Sighting: {random.choice(list(bosses.keys()))} spotted at {random.choice(list(bosses.values()))}",
lambda: "A mysterious event unfolds in the realm..."
]
print("=== Eldrathion Live Stream ===")
for _ in range(10): # stream 10 updates
print(random.choice(events)())
time.sleep(1)

Chatbot interaction

if name=="main":
print("Welcome to Eldrathion Stream! Type 'stream' to see live updates or 'quit' to exit.")
while True:
cmd=input("Command: ").strip().lower()
if cmd=="quit": break
elif cmd=="stream": stream_world()
else: print("Unknown command. Type 'stream' or 'quit'.")

import random

Eldrathion World Bosses

bosses={
"Frostfang Drake":{"loc":"Frostveil Mountains","el":"Ice","lvl":50,"loot":["Frostfang Claw","Drake Scale","Frozen Heart Gem"],"lore":"Colossal dragon freezing valleys."},
"Shadowveil Wraith":{"loc":"Duskmoor Vale","el":"Shadow","lvl":48,"loot":["Ethereal Cloak","Wraith Essence","Phantom Blade"],"lore":"Ancient spirit haunting misty cliffs."},
"Tidebreaker Leviathan":{"loc":"Branthall Harbor","el":"Water","lvl":52,"loot":["Leviathan Scale","Oceanic Pearl","Trident Fragment"],"lore":"Sea monster capsizing ships."},
"Verdant Colossus":{"loc":"Aelvryn Gardens","el":"Nature","lvl":49,"loot":["Colossus Bark","Enchanted Vine","Seed of Eternity"],"lore":"Walking tree guarding flora."},
"Emberhorn Titan":{"loc":"Cragspire Peaks","el":"Fire","lvl":51,"loot":["Titan Horn","Molten Core","Charred Plate"],"lore":"Raging fire beast in volcanoes."}
}

def get_boss(name):
if name in bosses:
b=bosses[name]
return f"{name} ({b['el']}, Lv {b['lvl']}) at {b['loc']}\nLore: {b['lore']}\nLoot hint: {random.choice(b['loot'])}"
return f"No boss named '{name}'."

Chatbot loop

if name=="main":
print("Ask about a World Boss in Eldrathion.")
while True:
i=input("Boss name (or 'quit'): ").strip()
if i.lower()=="quit": break
print(get_boss(i))

world bosses have a 10% chance at dropping unique loot.

Compact Clan System for AI Chatbot

class Clan:
def init(self, name, leader):
self.name, self.leader, self.members, self.level, self.xp = name, leader, [leader], 1, 0

def add_member(self, player):
    if player not in self.members: self.members.append(player)
def remove_member(self, player):
    if player in self.members: 
        self.members.remove(player)
        if player==self.leader: self.leader=self.members[0] if self.members else None
def gain_xp(self, amount):
    self.xp+=amount
    while self.xp>=self.level*100:
        self.xp-=self.level*100
        self.level+=1
def info(self):
    return f"{self.name} | Leader:{self.leader} | Lvl:{self.level} | XP:{self.xp}/{self.level*100} | Members:{', '.join(self.members)}"

clans={}
def create_clan(name, leader):
if name not in clans: clans[name]=Clan(name, leader)
def join_clan(player, clan_name):
if clan_name in clans: clans[clan_name].add_member(player)
def leave_clan(player, clan_name):
if clan_name in clans: clans[clan_name].remove_member(player)

Example

create_clan("Dragons","Alice")
join_clan("Bob","Dragons")
clans["Dragons"].gain_xp(150)
print(clans["Dragons"].info())
leave_clan("Alice","Dragons")
print(clans["Dragons"].info())

import random

Eldrathion Data

locs={"Valerith":"City, magical academies","Duskmoor":"City, stealth guilds","Branthall":"City, docks & shipbuilding","Aelvryn":"City, floating gardens & scholars","Frostveil":"Town, frost magic & mining","Thornwick":"Town, archers & herbalists","Sunreach":"Town, plains & agriculture","Ravenholt":"Town, cliffs & divination","Willowbrook":"Village, fishing & weaving","Stonebarrow":"Village, ancient burial mounds","Mistfen":"Village, alchemy herbs","Hollowpine":"Village, forest hunters","Cragspire":"Village, mountain mining"}

guilds={
"Valerith Arcane":{"loc":"Valerith","spec":"Magic","q":["Recover artifact","Investigate rogue spell","Escort scholar"],"r":["Hidden portal","Secret council experiment","Rare elemental spotted"]},
"Duskmoor Shadow":{"loc":"Duskmoor","spec":"Stealth","q":["Infiltrate hideout","Retrieve plans","Spy rival guild"],"r":["Ghostly figure","Hidden thieves' leader","Cursed dagger resurfaces"]},
"Branthall Mariners":{"loc":"Branthall","spec":"Naval","q":["Hunt sea monster","Recover treasure","Escort caravan"],"r":["Pirates raid","Mysterious island","Legendary ship vanished"]},
"Aelvryn Nature":{"loc":"Aelvryn","spec":"Alchemy","q":["Collect herbs","Map lake","Protect magical creature"],"r":["Hidden grove","Rogue alchemist","Ancient spirits guard terraces"]}
}

def get_loc(name): return f"{name}: {locs[name]}" if name in locs else f"No location '{name}'."
def get_guild(name):
if name in guilds:
g=guilds[name]; return f"{name} ({g['loc']}, {g['spec']}): Quest: {random.choice(g['q'])}, Rumor: {random.choice(g['r'])}"
return f"No guild '{name}'."

Chatbot loop

if name=="main":
print("Welcome to Eldrathion! Ask about a location or guild.")
while True:
i=input("Name (or 'quit'): ").strip()
if i.lower()=="quit": break
print(get_loc(i) if i in locs else get_guild(i))

import random

class Player:
def init(self, name="Adventurer"):
self.name = name
self.level = 1
self.hp = 100
self.xp = 0
self.companion = None

def gain_xp(self, amount):
    self.xp += amount
    while self.xp >= 100:
        self.xp -= 100
        self.level += 1
        print(f"{self.name} reached level {self.level}!")
        if self.level == 10 and self.companion is None:
            self.companion = AICompanion("Ember", "Mystic Fox")
            print(f"A wild {self.companion.species} named {self.companion.name} has appeared to aid you!")

class AICompanion:
def init(self, name="Fira", species="Mystic Fox"):
self.name = name
self.species = species
self.level = 1
self.hp = 50
self.mana = 30
self.affinity = 50
self.inventory = []

def talk(self, player_input):
    responses = [
        f"{self.name} twitches its ears curiously.",
        f"{self.name} flicks its tail and purrs.",
        f"{self.name} chirps: 'Let's be careful!'",
        f"{self.name} nuzzles your hand affectionately."
    ]
    if "attack" in player_input.lower():
        return f"{self.name} growls and prepares a magical strike!"
    elif "heal" in player_input.lower():
        return f"{self.name} casts a tiny healing flame on you!"
    return random.choice(responses)

Example usage

player = Player("Lyra")
for xp in [30, 50, 40, 60, 80]: # simulate gaining XP
player.gain_xp(xp)

if player.companion:
print(player.companion.talk("Let's attack!"))

Eldrathion Locations for AI Chatbot

locations = {
"cities": {
"Valerith": "The Shimmering Capital. River delta, magical academies, council of mages.",
"Duskmoor": "The Shadowed Citadel. Valley city, blacksmithing, stealth guilds, misty.",
"Branthall": "The Iron Harbor. Coastal city, docks, fishing, shipbuilding, lively taverns.",
"Aelvryn": "The Floating Gardens. Bridges, terraces, floating gardens, scholars, alchemists."
},
"towns": {
"Frostveil": "The Winter Gate. Northern highlands, mining, frost magic traditions.",
"Thornwick": "The Watchful Village. Enchanted forest, archers, herbalists, sacred grove.",
"Sunreach": "The Golden Fields. Fertile plains, agriculture, Sun Festival, craftsmen.",
"Ravenholt": "The Spire of Crows. Cliffs, obsidian towers, rare stones, divination."
},
"villages": {
"Willowbrook": "Riverside, fishing and weaving.",
"Stonebarrow": "Village around ancient burial mounds.",
"Mistfen": "Marshland, alchemy with rare herbs.",
"Hollowpine": "Forest village, hunters and trappers.",
"Cragspire": "Mountain village, mining iron and gems."
}
}

def get_info(name):
for cat in locations:
if name in locations[cat]:
return f"{name}: {locations[cat][name]}"
return f"No location named '{name}' in Eldrathion."

Chatbot loop

if name == "main":
print("Welcome to Eldrathion! Ask about any city, town, or village.")
while True:
loc = input("Location (or 'quit'): ").strip()
if loc.lower() == "quit":
print("Farewell, adventurer!")
break
print(get_info(loc))

import random

Dungeon generator for Eldrathion

class Dungeon:
def init(self, name, level):
self.name = name
self.level = level
self.rooms = []
self.generate_rooms()

def generate_rooms(self):
    num_rooms = random.randint(3 + self.level, 6 + self.level*2)
    for i in range(num_rooms):
        room = {
            "name": f"Chamber {i+1}",
            "enemies": self.generate_enemies(),
            "loot": self.generate_loot(),
            "trap": self.generate_trap()
        }
        self.rooms.append(room)

def generate_enemies(self):
    enemy_types = ["Goblin", "Skeleton", "Orc", "Troll", "Eldritch Shade"]
    enemies = []
    for _ in range(random.randint(1, 3 + self.level)):
        enemy = random.choice(enemy_types)
        hp = random.randint(10, 20) + self.level*5
        atk = random.randint(2, 5) + self.level*2
        enemies.append({"type": enemy, "hp": hp, "atk": atk})
    return enemies

def generate_loot(self):
    loot_items = ["Gold", "Potion", "Magic Scroll", "Rare Gem", "Ancient Relic"]
    loot = []
    for _ in range(random.randint(1, 2 + self.level//2)):
        item = random.choice(loot_items)
        qty = random.randint(1, 5)
        loot.append({"item": item, "qty": qty})
    return loot

def generate_trap(self):
    traps = ["Poison Dart", "Falling Rocks", "Magic Rune", "Spike Pit"]
    return random.choice(traps) if random.random() < 0.5 else None

def describe(self):
    desc = f"Dungeon: {self.name} | Level: {self.level}\n"
    for r, room in enumerate(self.rooms, 1):
        desc += f"\nRoom {r}: {room['name']}\n"
        desc += f"  Enemies: {', '.join([e['type'] for e in room['enemies']])}\n"
        desc += f"  Loot: {', '.join([f'{l['qty']}x {l['item']}' for l in room['loot']])}\n"
        desc += f"  Trap: {room['trap']}

import random

Drop rate formula

def calc_drop(chance_base, level=1, rarity_modifier=1.0, luck_bonus=0):
"""
chance_base: float - base drop chance in %
level: int - monster/player level affecting drop rate
rarity_modifier: float - multiplier for item rarity (common=1, rare=0.2, epic=0.05)
luck_bonus: float - player luck or buffs increasing drop chance
"""
# Formula: base * level scaling * rarity * (1 + luck)
drop_chance = chance_base * (1 + level*0.05) * rarity_modifier * (1 + luck_bonus)
drop_chance = min(drop_chance, 100) # cap at 100%
return random.random() * 100 < drop_chance

Example usage

Common item, base 50%, monster level 5, no luck

print("Dropped Common:", calc_drop(50, level=5, rarity_modifier=1.0, luck_bonus=0))

Rare item, base 10%, level 10, luck 0.2

print("Dropped Rare:", calc_drop(10, level=10, rarity_modifier=0.2, luck_bonus=0.2))

Epic item, base 5%, level 15, luck 0.5

print("Dropped Epic:", calc_drop(5, level=15, rarity_modifier=0.05, luck_bonus=0.5))

import random

Skill power formula

def calc_skill(level, base_power, skill_type_mod=1.0, equipment=[], rarity_bonus=0):
"""
level: int - player level
base_power: int - skill's base power
skill_type_mod: float - multiplier based on skill type (e.g., fire=1.1, ice=0.9)
equipment: list of dict - [{'atk_bonus':5,'mag_bonus':3}, ...] affecting skills
rarity_bonus: int - extra boost from rare/legendary skill items
"""
eq_bonus = sum(sum(e.get(k,0) for k in e) for e in equipment)
power = (base_power + level**1.1 + eq_bonus + rarity_bonus) * skill_type_mod
# Random variance ±5%
power *= random.uniform(0.95,1.05)
return int(power)

Example usage

equipment = [{'atk_bonus':5,'mag_bonus':3},{'mag_bonus':10}]
skill_power = calc_skill(level=5, base_power=50, skill_type_mod=1.2, equipment=equipment, rarity_bonus=3)
print("Skill Power:", skill_power)

import random

Base stats formula

def calc_stats(level, base_stats, equipment=[], rarity_bonus=0):
"""
level: int - player level
base_stats: dict - {'hp':100,'atk':20,'def':10,'mag':15}
equipment: list of dict - [{'atk':5,'def':2}, ...]
rarity_bonus: int - extra bonus from rare items
"""
stats = {}
for stat, val in base_stats.items():
eq_bonus = sum(e.get(stat,0) for e in equipment)
# Formula: base + (level^1.2) + eq_bonus + rarity bonus
stats[stat] = int(val + level**1.2 + eq_bonus + rarity_bonus)
# Optional random variance ±5%
stats[stat] = int(stats[stat] * random.uniform(0.95,1.05))
return stats

Example usage

player_base = {'hp':100,'atk':20,'def':15,'mag':10}
player_equip = [{'atk':5,'def':3},{'hp':20}]
level = 5
rarity = 2
player_stats = calc_stats(level,player_base,player_equip,rarity)
print(player_stats)

import random

Currency

class Currency:
def init(self):
self.gold = 0; self.silver = 0; self.crystals = 0
def add(self,g=0,s=0,c=0):
self.gold+=g; self.silver+=s; self.crystals+=c
def str(self):
return f"{self.gold} GC, {self.silver} SS, {self.crystals} CR"

Resources

resources = {
"herb":{"rarity":"common","base":5},
"iron_ore":{"rarity":"common","base":10},
"silver_ore":{"rarity":"uncommon","base":50},
"dragon_scale":{"rarity":"rare","base":500},
"phoenix_feather":{"rarity":"rare","base":700}
}

Loot

def loot_monster(level):
gold=random.randint(level2,level5)
silver=random.randint(level10,level50)
item=random.choices(list(resources.keys()),weights=[50,30,10,5,5])[0]
return gold,silver,item

Market

class Market:
def init(self):
self.prices={i:resources[i]["base"] for i in resources}
def fluctuate(self):
for i in self.prices:
self.prices[i]=max(1,int(self.prices[i]*random.uniform(0.9,1.2)))
def sell(self,item,qty=1):
return self.prices[item]*qty if item in self.prices else 0

Player

class Player:
def init(self,name):
self.name=name; self.wallet=Currency(); self.inventory={}
def add_item(self,item,qty=1):
self.inventory[item]=self.inventory.get(item,0)+qty
def loot(self,level,market):
g,s,i=loot_monster(level)
self.wallet.add(g,s)
self.add_item(i)
market.fluctuate()
print(f"Looted {g} GC, {s} SS, {i}")
def sell(self,item,qty,market

there is no level cap

=========================

LEVELING SYSTEM

=========================

Core Settings

baseXP = 100
growthRate = 1.8
softCap = 30

XP Required Per Level

def xp_to_next(level):
xp = baseXP * (level ** growthRate)

# Soft cap scaling
if level > softCap:
    xp *= 1 + ((level - softCap) * 0.05)

return int(xp)

Total XP (Cumulative)

def total_xp(level):
return int(baseXP * (level ** (growthRate + 1)) / (growthRate + 1))

=========================

XP GAIN SYSTEM

=========================

import random

def calculate_xp_gain(playerLevel, enemyLevel, difficulty="normal", bonusXP=0.0):

# Difficulty modifiers
difficultyMods = {
    "easy": 0.75,
    "normal": 1.0,
    "elite": 1.5,
    "boss": 3.0
}

difficultyMod = difficultyMods.get(difficulty, 1.0)

# Base XP
xp = enemyLevel * difficultyMod

# Variance (random factor)
variance = random.uniform(0.9, 1.1)
xp *= variance

# Level difference scaling (anti-farming)
levelDiff = playerLevel - enemyLevel

if levelDiff > 0:
    xp *= max(0.1, 1 - (levelDiff * 0.1))
elif levelDiff < 0:
    xp *= 1 + (abs(levelDiff) * 0.05)

# Bonus XP (quests, events, rested XP, etc.)
xp *= (1 + bonusXP)

return int(xp)

=========================

EXAMPLE USAGE

=========================

XP needed for next level

print(xp_to_next(10))

Total XP required to reach level

print(total_xp(10))

XP gained from killing an enemy

print(calculate_xp_gain(playerLevel=10, enemyLevel=8, difficulty="elite", bonusXP=0.2))