Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Flesh this out with an advanced economy system and more towns. #!/usr/bin/env python3 --…

  1. User

    Flesh this out with an advanced economy system and more towns.

    #!/usr/bin/env python3

    -- coding: utf-8 --

    import random import time import sys import os

    try: from colorama import init, Fore, Style except ImportError: print("Please install the 'colorama' module to run this game.") sys.exit()

    Initialize colorama

    init(autoreset=True)

    ASCII Art and Flourishes

    GAME_TITLE = r"""


    /
    | _______ _ _____ _ | | |__ | | | / | | | | | | | ___ ___ | | __ | | __ | | ___ | | | |/ _ \ / _ | |/ / | | / ` | |/ _ \ | | | | () | () | < | || (| | | / | | |_|_/ _/||_\ __,||_| | | | |______________________________________________________| """

    WELCOME_ART = r""" _____________________________________________________________ /
    | Welcome to the Text-Based Trading Game! | | Your goal is to accumulate wealth by trading goods | | across various towns. Beware of fluctuating prices and | | random events that may impact your journey. | |_____________________________________________________________| """

    GOOD_LUCK = r"""


    | __ \ | | | | ()
    | | | | ___ ___ | | __| | _ ___ _ __
    | | | |/ _ / |/ _ \ |/ _ \ _| |/ _ | ' \ | || | /_ \ __/ | __/ || | (
    ) | | | | |
    / _||/_||_|_||_/|| || """

    Game Data

    TOWNS = ['Eastvale', 'Westport', 'Northwich', 'Southvale', 'Central City'] GOODS = ['Spices', 'Gems', 'Food', 'Textiles', 'Metals'] EVENTS = ['Thieves', 'Bad Weather', 'Bandits', 'Market Crash', 'Steady Market', 'Nothing Happens']

    Player Class

    class Player: def init(self): self.gold = 100 self.inventory = {good: 0 for good in GOODS} self.current_town = random.choice(TOWNS) self.turns = 20 # Number of turns to play

    def show_status(self):
        print(Fore.CYAN + f"\nCurrent Gold: {self.gold} | Current Town: {self.current_town} | Turns Left: {self.turns}")
        print("Inventory:")
        for good, amount in self.inventory.items():
            print(Fore.YELLOW + f"{good}: {amount}")
        print(Style.RESET_ALL)
    

    Game Class

    class Game: def init(self): self.prices = {town: {good: self.generate_initial_price(good) for good in GOODS} for town in TOWNS} self.event_occurred = False

    def generate_initial_price(self, good):
        if good == 'Spices':
            return random.randint(20, 50)
        elif good == 'Gems':
            return random.randint(70, 150)
        elif good == 'Food':
            return random.randint(5, 15)
        elif good == 'Textiles':
            return random.randint(10, 30)
        elif good == 'Metals':
            return random.randint(25, 60)
        else:
            return 50  # default price
    
    def update_economy(self):
        # Update prices for each good in each town
        for town in TOWNS:
            for good in GOODS:
                # Simulate price changes
                price_change = random.randint(-5, 5)
                self.prices[town][good] += price_change
                # Ensure prices stay within reasonable bounds
                if self.prices[town][good] < 1:
                    self.prices[town][good] = 1
    
    def get_prices(self, town):
        return self.prices[town]
    
    def random_event(self, player):
        event = random.choice(EVENTS)
        if event == 'Nothing Happens':
            print(Fore.GREEN + "\nNothing happened this turn.")
            self.event_occurred = False
        else:
            self.event_occurred = True
            print(Fore.RED + f"\nEvent Triggered: {event}!")
            if event == 'Thieves':
                loss = random.randint(10, 30)
                player.gold = max(0, player.gold - loss)
                print(Fore.RED + f"You lost {loss} gold to thieves!")
            elif event == 'Bad Weather':
                print(Fore.RED + "Traveling to the next town took extra time.")
                player.turns -= 1
            elif event == 'Bandits':
                loss = random.randint(1, 3)
                good = random.choice(GOODS)
                player.inventory[good] = max(0, player.inventory[good] - loss)
                print(Fore.RED + f"Bandits stole {loss} units of {good}!")
            elif event == 'Market Crash':
                print(Fore.RED + "The market is unstable! Prices fluctuate wildly.")
                # Drastically change the economy
                for town in TOWNS:
                    for good in GOODS:
                        self.prices[town][good] = max(1, self.prices[town][good] + random.randint(-20, 20))
            elif event == 'Steady Market':
                print(Fore.GREEN + "The market is steady. No major events.")
        print(Style.RESET_ALL)
    

    Market Class

    class Market: def init(self, town, game): self.town = town self.prices = game.get_prices(town)

    def show_prices(self):
        print(Fore.GREEN + f"\nMarket Prices in {self.town}:")
        for good, price in self.prices.items():
            print(Fore.MAGENTA + f"{good}: {price} gold per unit")
        print(Style.RESET_ALL)
    
    def get_price(self, good):
        return self.prices[good]
    

    Game Functions

    def clear_screen(): # Do not clear the screen to preserve initial text pass # Do nothing to prevent clearing the initial text

    def slow_print(text, delay=0.05): for c in text: sys.stdout.write(c) sys.stdout.flush() time.sleep(delay) print()

    def main(): clear_screen() print(Fore.YELLOW + GAME_TITLE) time.sleep(1) print(Fore.CYAN + WELCOME_ART) time.sleep(2)

    player = Player()
    game = Game()
    
    while player.turns > 0:
        # Instead of clearing the screen, print a separator
        print("\n" + "=" * 60)
        player.show_status()
        market = Market(player.current_town, game)
        market.show_prices()
    
        # Buy or Sell Phase
        action = ''
        while action.lower() not in ['b', 's', 't', 'q']:
            print(Fore.GREEN + "\nWhat would you like to do?")
            print("B) Buy Goods")
            print("S) Sell Goods")
            print("T) Travel to Another Town")
            print("Q) Quit Game")
            action = input("Enter your choice: ").strip()
    
        if action.lower() == 'b':
            buy_goods(player, market)
        elif action.lower() == 's':
            sell_goods(player, market)
        elif action.lower() == 't':
            travel(player)
            player.turns -= 1
            game.update_economy()
            game.random_event(player)
            continue
        elif action.lower() == 'q':
            break
    
        # Post-action Events
        game.update_economy()
        game.random_event(player)
        time.sleep(2)
    
        input("\nPress Enter to continue...")
        player.turns -= 1
    
    # Game Over
    print(Fore.YELLOW + GOOD_LUCK)
    print(Fore.GREEN + f"\nGame Over! You ended with {player.gold} gold.")
    print("Thanks for playing!")
    print(Style.RESET_ALL)
    

    def buy_goods(player, market): print(Fore.BLUE + "\nAvailable Goods to Buy:") for index, good in enumerate(GOODS, start=1): price = market.get_price(good) print(Fore.MAGENTA + f"{index}) {good} - {price} gold per unit")

    try:
        choice = int(input(Fore.GREEN + "\nEnter the number of the good you want to buy: ").strip())
        if 1 <= choice <= len(GOODS):
            good = GOODS[choice - 1]
            price = market.get_price(good)
            max_units = player.gold // price
            if max_units == 0:
                print(Fore.RED + "You don't have enough gold to buy any units of this good.")
                return
            print(Fore.YELLOW + f"You can buy up to {max_units} units of {good}.")
            quantity = int(input("Enter the quantity you want to buy: ").strip())
            if 0 < quantity <= max_units:
                total_cost = price * quantity
                player.gold -= total_cost
                player.inventory[good] += quantity
                print(Fore.GREEN + f"Purchased {quantity} units of {good} for {total_cost} gold.")
            else:
                print(Fore.RED + "Invalid quantity.")
        else:
            print(Fore.RED + "Invalid choice.")
    except ValueError:
        print(Fore.RED + "Please enter a valid number.")
    print(Style.RESET_ALL)
    

    def sell_goods(player, market): print(Fore.BLUE + "\nYour Goods to Sell:") owned_goods = {good: qty for good, qty in player.inventory.items() if qty > 0} if not owned_goods: print(Fore.RED + "You have no goods to sell.") return

    for index, (good, qty) in enumerate(owned_goods.items(), start=1):
        price = market.get_price(good)
        print(Fore.MAGENTA + f"{index}) {good} - {qty} units available - {price} gold per unit")
    
    try:
        choice = int(input(Fore.GREEN + "\nEnter the number of the good you want to sell: ").strip())
        if 1 <= choice <= len(owned_goods):
            good = list(owned_goods.keys())[choice - 1]
            qty_owned = player.inventory[good]
            price = market.get_price(good)
            print(Fore.YELLOW + f"You have {qty_owned} units of {good}.")
            quantity = int(input("Enter the quantity you want to sell: ").strip())
            if 0 < quantity <= qty_owned:
                total_earnings = price * quantity
                player.gold += total_earnings
                player.inventory[good] -= quantity
                print(Fore.GREEN + f"Sold {quantity} units of {good} for {total_earnings} gold.")
            else:
                print(Fore.RED + "Invalid quantity.")
        else:
            print(Fore.RED + "Invalid choice.")
    except ValueError:
        print(Fore.RED + "Please enter a valid number.")
    print(Style.RESET_ALL)
    

    def travel(player): print(Fore.BLUE + "\nAvailable Towns to Travel:") other_towns = [town for town in TOWNS if town != player.current_town] for index, town in enumerate(other_towns, start=1): print(Fore.MAGENTA + f"{index}) {town}")

    try:
        choice = int(input(Fore.GREEN + "\nEnter the number of the town you want to travel to: ").strip())
        if 1 <= choice <= len(other_towns):
            player.current_town = other_towns[choice - 1]
            print(Fore.GREEN + f"Traveled to {player.current_town}.")
        else:
            print(Fore.RED + "Invalid choice.")
    except ValueError:
        print(Fore.RED + "Please enter a valid number.")
    print(Style.RESET_ALL)
    

    Run the Game

    if name == "main": main()

  2. Assistant

    Sure, let's enhance the game by introducing an advanced economy system and adding more towns. We'll implement supply and demand mechanics, where each town produces certain goods and demands others. Prices will fluctuate based on these factors, making trading more strategic.

    Below is the updated code:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    import random
    import time
    import sys
    
    try:
        from colorama import init, Fore, Style
    except ImportError:
        print("Please install the 'colorama' module to run this game.")
        sys.exit()
    
    # Initialize colorama
    init(autoreset=True)
    
    # ASCII Art and Flourishes
    GAME_TITLE = r"""
       ________________________________________________________
      /                                                        \
      |   _______          _          _____      _             |
      |  |__   __|        | |        / ____|    | |            |
      |     | | ___   ___ | | __    | |     __ _| | ___        |
      |     | |/ _ \ / _ \| |/ /    | |    / _` | |/ _ \       |
      |     | | (_) | (_) |   <     | |___| (_| | |  __/       |
      |     |_|\___/ \___/|_|\_\     \_____\__,_|_|\___|       |
      |                                                        |
      |________________________________________________________|
    """
    
    WELCOME_ART = r"""
        _____________________________________________________________
       /                                                             \
       |  Welcome to the Text-Based Trading Game!                    |
       |  Your goal is to accumulate wealth by trading goods         |
       |  across various towns. Beware of fluctuating prices and     |
       |  random events that may impact your journey.                |
       |_____________________________________________________________|
    """
    
    GOOD_LUCK = r"""
      _____                 _      _   _             
     |  __ \               | |    | | (_)            
     | |  | | ___  ___  ___| | ___| |_ _  ___  _ __  
     | |  | |/ _ \/ __|/ _ \ |/ _ \ __| |/ _ \| '_ \ 
     | |__| |  __/\__ \  __/ |  __/ |_| | (_) | | | |
     |_____/ \___||___/\___|_|\___|\__|_|\___/|_| |_|
    """
    
    # Game Data
    # Enhanced list of towns
    TOWN_NAMES = [
        'Eastvale', 'Westport', 'Northwich', 'Southvale', 'Central City',
        'Riverbend', 'Mountainside', 'Lakeside', 'Foresthaven', 'Desert Oasis',
        'Harborview', 'Sunset Village', 'Highland', 'Lowland', 'Crystal Bay'
    ]
    
    GOODS = [
        'Spices', 'Gems', 'Food', 'Textiles', 'Metals',
        'Herbs', 'Wood', 'Tools', 'Precious Metals', 'Artworks'
    ]
    
    EVENTS = [
        'Thieves', 'Bad Weather', 'Bandits', 'Market Crash',
        'Market Boom', 'Steady Market', 'Nothing Happens'
    ]
    
    # Player Class
    class Player:
        def __init__(self):
            self.gold = 500  # Increased starting gold
            self.inventory = {good: 0 for good in GOODS}
            self.current_town = random.choice(TOWN_NAMES)
            self.turns = 30  # Increased number of turns
    
        def show_status(self):
            print(Fore.CYAN + f"\nCurrent Gold: {self.gold} | Current Town: {self.current_town} | Turns Left: {self.turns}")
            print("Inventory:")
            for good, amount in self.inventory.items():
                if amount > 0:
                    print(Fore.YELLOW + f"{good}: {amount}")
            print(Style.RESET_ALL)
    
    # Town Class
    class Town:
        def __init__(self, name):
            self.name = name
            self.goods = {}
            self.init_goods()
    
        def init_goods(self):
            # Initialize supply, demand, and base price for each good
            for good in GOODS:
                if good in self.production_goods():
                    supply = random.randint(80, 120)
                    demand = random.randint(40, 60)
                elif good in self.consumption_goods():
                    supply = random.randint(40, 60)
                    demand = random.randint(80, 120)
                else:
                    supply = random.randint(60, 100)
                    demand = random.randint(60, 100)
                base_price = self.generate_base_price(good)
                self.goods[good] = {
                    'supply': supply,
                    'demand': demand,
                    'base_price': base_price,
                    'price': base_price
                }
    
        def production_goods(self):
            # Define goods that are produced in this town
            production = {
                'Eastvale': ['Food', 'Wood'],
                'Westport': ['Fish', 'Tools'],
                'Northwich': ['Metals', 'Precious Metals'],
                'Southvale': ['Textiles', 'Artworks'],
                'Central City': ['Gems', 'Spices'],
                'Riverbend': ['Herbs', 'Wood'],
                'Mountainside': ['Metals', 'Gems'],
                'Lakeside': ['Fish', 'Food'],
                'Foresthaven': ['Wood', 'Herbs'],
                'Desert Oasis': ['Spices', 'Gems'],
                'Harborview': ['Fish', 'Tools'],
                'Sunset Village': ['Textiles', 'Food'],
                'Highland': ['Metals', 'Herbs'],
                'Lowland': ['Food', 'Wood'],
                'Crystal Bay': ['Gems', 'Precious Metals']
            }
            return production.get(self.name, [])
    
        def consumption_goods(self):
            # Define goods that are in high demand in this town
            consumption = {
                'Eastvale': ['Metals', 'Tools'],
                'Westport': ['Wood', 'Metals'],
                'Northwich': ['Food', 'Textiles'],
                'Southvale': ['Spices', 'Gems'],
                'Central City': ['Food', 'Wood'],
                'Riverbend': ['Metals', 'Tools'],
                'Mountainside': ['Food', 'Wood'],
                'Lakeside': ['Metals', 'Precious Metals'],
                'Foresthaven': ['Tools', 'Artworks'],
                'Desert Oasis': ['Water', 'Food'],
                'Harborview': ['Metals', 'Textiles'],
                'Sunset Village': ['Spices', 'Tools'],
                'Highland': ['Textiles', 'Artworks'],
                'Lowland': ['Metals', 'Tools'],
                'Crystal Bay': ['Food', 'Textiles']
            }
            return consumption.get(self.name, [])
    
        def generate_base_price(self, good):
            # Set base prices for each good
            base_prices = {
                'Spices': 50,
                'Gems': 100,
                'Food': 20,
                'Textiles': 30,
                'Metals': 60,
                'Herbs': 25,
                'Wood': 15,
                'Tools': 40,
                'Precious Metals': 150,
                'Artworks': 80
            }
            return base_prices.get(good, 50)
    
        def update_prices(self):
            # Update prices based on supply and demand
            for good, data in self.goods.items():
                supply = data['supply']
                demand = data['demand']
                base_price = data['base_price']
                # Simple supply and demand price adjustment formula
                data['price'] = max(1, int(base_price * (demand / max(1, supply))))
                # Ensure price stays within reasonable bounds
                data['price'] = min(data['price'], base_price * 5)
    
    # Game Class
    class Game:
        def __init__(self):
            self.towns = {name: Town(name) for name in TOWN_NAMES}
            self.event_occurred = False
    
        def update_economy(self):
            # Update supply and demand for each good in each town
            for town in self.towns.values():
                for good, data in town.goods.items():
                    # Randomly adjust supply and demand
                    supply_change = random.randint(-10, 10)
                    demand_change = random.randint(-10, 10)
                    data['supply'] = max(10, data['supply'] + supply_change)
                    data['demand'] = max(10, data['demand'] + demand_change)
                # Update prices after adjusting supply and demand
                town.update_prices()
    
        def get_town(self, town_name):
            return self.towns[town_name]
    
        def random_event(self, player):
            event = random.choice(EVENTS)
            if event == 'Nothing Happens':
                print(Fore.GREEN + "\nNothing happened this turn.")
                self.event_occurred = False
            else:
                self.event_occurred = True
                print(Fore.RED + f"\nEvent Triggered: {event}!")
                if event == 'Thieves':
                    loss = random.randint(50, 150)
                    player.gold = max(0, player.gold - loss)
                    print(Fore.RED + f"You lost {loss} gold to thieves!")
                elif event == 'Bad Weather':
                    print(Fore.RED + "Traveling to the next town took extra time.")
                    player.turns -= 1
                elif event == 'Bandits':
                    loss = random.randint(1, 5)
                    good = random.choice(GOODS)
                    if player.inventory[good] > 0:
                        stolen = min(loss, player.inventory[good])
                        player.inventory[good] -= stolen
                        print(Fore.RED + f"Bandits stole {stolen} units of {good}!")
                    else:
                        print(Fore.RED + "Bandits tried to steal your goods but you had none!")
                elif event == 'Market Crash':
                    print(Fore.RED + "The market is crashing! Prices are dropping.")
                    # Decrease demand in all towns
                    for town in self.towns.values():
                        for data in town.goods.values():
                            data['demand'] = max(10, data['demand'] - random.randint(10, 30))
                        town.update_prices()
                elif event == 'Market Boom':
                    print(Fore.GREEN + "The market is booming! Prices are rising.")
                    # Increase demand in all towns
                    for town in self.towns.values():
                        for data in town.goods.values():
                            data['demand'] += random.randint(10, 30)
                        town.update_prices()
                elif event == 'Steady Market':
                    print(Fore.GREEN + "The market is steady. No major events.")
            print(Style.RESET_ALL)
    
    # Market Class
    class Market:
        def __init__(self, town):
            self.town = town
    
        def show_prices(self):
            print(Fore.GREEN + f"\nMarket Prices in {self.town.name}:")
            for good, data in self.town.goods.items():
                price = data['price']
                print(Fore.MAGENTA + f"{good}: {price} gold per unit | Supply: {data['supply']} | Demand: {data['demand']}")
            print(Style.RESET_ALL)
    
        def get_price(self, good):
            return self.town.goods[good]['price']
    
    # Game Functions
    def clear_screen():
        # Do not clear the screen to preserve initial text
        pass  # Do nothing to prevent clearing the initial text
    
    def main():
        clear_screen()
        print(Fore.YELLOW + GAME_TITLE)
        time.sleep(1)
        print(Fore.CYAN + WELCOME_ART)
        time.sleep(2)
    
        player = Player()
        game = Game()
    
        while player.turns > 0:
            # Instead of clearing the screen, print a separator
            print("\n" + "=" * 60)
            player.show_status()
            current_town_obj = game.get_town(player.current_town)
            market = Market(current_town_obj)
            market.show_prices()
    
            # Buy or Sell Phase
            action = ''
            while action.lower() not in ['b', 's', 't', 'q']:
                print(Fore.GREEN + "\nWhat would you like to do?")
                print("B) Buy Goods")
                print("S) Sell Goods")
                print("T) Travel to Another Town")
                print("Q) Quit Game")
                action = input("Enter your choice: ").strip()
    
            if action.lower() == 'b':
                buy_goods(player, market)
            elif action.lower() == 's':
                sell_goods(player, market)
            elif action.lower() == 't':
                travel(player, game)
                player.turns -= 1
                game.update_economy()
                game.random_event(player)
                continue
            elif action.lower() == 'q':
                break
    
            # Post-action Events
            game.update_economy()
            game.random_event(player)
            time.sleep(2)
    
            input("\nPress Enter to continue...")
            player.turns -= 1
    
        # Game Over
        print(Fore.YELLOW + GOOD_LUCK)
        print(Fore.GREEN + f"\nGame Over! You ended with {player.gold} gold.")
        print("Thanks for playing!")
        print(Style.RESET_ALL)
    
    def buy_goods(player, market):
        print(Fore.BLUE + "\nAvailable Goods to Buy:")
        for index, good in enumerate(GOODS, start=1):
            price = market.get_price(good)
            print(Fore.MAGENTA + f"{index}) {good} - {price} gold per unit")
    
        try:
            choice = int(input(Fore.GREEN + "\nEnter the number of the good you want to buy: ").strip())
            if 1 <= choice <= len(GOODS):
                good = GOODS[choice - 1]
                price = market.get_price(good)
                max_units = player.gold // price
                if max_units == 0:
                    print(Fore.RED + "You don't have enough gold to buy any units of this good.")
                    return
                print(Fore.YELLOW + f"You can buy up to {max_units} units of {good}.")
                quantity = int(input("Enter the quantity you want to buy: ").strip())
                if 0 < quantity <= max_units:
                    total_cost = price * quantity
                    player.gold -= total_cost
                    player.inventory[good] += quantity
                    # Update supply in the market
                    market.town.goods[good]['supply'] = max(0, market.town.goods[good]['supply'] - quantity)
                    print(Fore.GREEN + f"Purchased {quantity} units of {good} for {total_cost} gold.")
                else:
                    print(Fore.RED + "Invalid quantity.")
            else:
                print(Fore.RED + "Invalid choice.")
        except ValueError:
            print(Fore.RED + "Please enter a valid number.")
        print(Style.RESET_ALL)
    
    def sell_goods(player, market):
        print(Fore.BLUE + "\nYour Goods to Sell:")
        owned_goods = {good: qty for good, qty in player.inventory.items() if qty > 0}
        if not owned_goods:
            print(Fore.RED + "You have no goods to sell.")
            return
    
        for index, (good, qty) in enumerate(owned_goods.items(), start=1):
            price = market.get_price(good)
            print(Fore.MAGENTA + f"{index}) {good} - {qty} units available - {price} gold per unit")
    
        try:
            choice = int(input(Fore.GREEN + "\nEnter the number of the good you want to sell: ").strip())
            if 1 <= choice <= len(owned_goods):
                good = list(owned_goods.keys())[choice - 1]
                qty_owned = player.inventory[good]
                price = market.get_price(good)
                print(Fore.YELLOW + f"You have {qty_owned} units of {good}.")
                quantity = int(input("Enter the quantity you want to sell: ").strip())
                if 0 < quantity <= qty_owned:
                    total_earnings = price * quantity
                    player.gold += total_earnings
                    player.inventory[good] -= quantity
                    # Update demand in the market
                    market.town.goods[good]['demand'] = max(0, market.town.goods[good]['demand'] + quantity)
                    print(Fore.GREEN + f"Sold {quantity} units of {good} for {total_earnings} gold.")
                else:
                    print(Fore.RED + "Invalid quantity.")
            else:
                print(Fore.RED + "Invalid choice.")
        except ValueError:
            print(Fore.RED + "Please enter a valid number.")
        print(Style.RESET_ALL)
    
    def travel(player, game):
        print(Fore.BLUE + "\nAvailable Towns to Travel:")
        other_towns = [town for town in TOWN_NAMES if town != player.current_town]
        for index, town in enumerate(other_towns, start=1):
            print(Fore.MAGENTA + f"{index}) {town}")
    
        try:
            choice = int(input(Fore.GREEN + "\nEnter the number of the town you want to travel to: ").strip())
            if 1 <= choice <= len(other_towns):
                player.current_town = other_towns[choice - 1]
                print(Fore.GREEN + f"Traveled to {player.current_town}.")
            else:
                print(Fore.RED + "Invalid choice.")
        except ValueError:
            print(Fore.RED + "Please enter a valid number.")
        print(Style.RESET_ALL)
    
    # Run the Game
    if __name__ == "__main__":
        main()
    

    Key Enhancements:

    1. More Towns and Goods: Expanded the list of towns to 15 and goods to 10, providing more variety and trading opportunities.

    2. Advanced Economy System:

      • Town Class: Each town now has specific goods it produces and consumes, affecting supply and demand.
      • Supply and Demand Mechanics: Supply and demand for each good in each town change over time and affect prices.
      • Price Calculation: Prices are dynamically calculated based on the supply and demand ratios, making trading more strategic.
    3. Market Events:

      • Added a Market Boom event where demand increases, leading to higher prices.
      • Adjusted existing events to impact the new economy system appropriately.
    4. Gameplay Adjustments:

      • Increased starting gold and turns to balance the expanded game.
      • When buying and selling goods, the town's supply and demand are updated, influencing future prices.

    How the New Economy Works:

    • Production and Consumption:

      • Each town has goods it produces, resulting in higher supply and lower prices for those goods.
      • Towns also have goods they consume, leading to higher demand and higher prices for those goods.
    • Dynamic Prices:

      • Prices fluctuate based on the current supply and demand in the town.
      • As a player buys goods, the supply decreases, potentially increasing the price if demand remains high.
      • Selling goods increases the town's supply, which may decrease the price if demand doesn't keep up.
    • Strategic Trading:

      • Players can maximize profits by buying goods in towns where they are produced (low prices) and selling them in towns where they are consumed (high prices).
      • Monitoring market trends and events can lead to lucrative opportunities.

    Tips for Playing:

    • Plan Your Routes: Travel to towns that consume the goods you have in your inventory for better selling prices.
    • Monitor Supply and Demand: Keep an eye on the market to buy goods when supply is high and sell when demand is high.
    • Be Prepared for Events: Random events can impact your gold, inventory, or the market, so plan accordingly.

    Enjoy the enhanced trading experience!