ENV 2D dynamic (simulated noise).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pygame\n",
    "import random\n",
    "import math\n",
    "\n",
    "pygame.init()\n",
    "\n",
    "# Constants\n",
    "WINDOW_SIZE = (600, 600)  # Window size for 2D environment\n",
    "WHITE = (255, 255, 255)\n",
    "BLACK = (0, 0, 0)\n",
    "RED = (255, 0, 0)\n",
    "GREEN = (0, 255, 0)\n",
    "BLUE = (0, 0, 255)\n",
    "YELLOW = (255, 255, 0)  # New color for the target\n",
    "FONT_COLOR = (0, 0, 0)\n",
    "FONT_SIZE = 24\n",
    "step_size = 10\n",
    "tolerance = 10  # How close the agent needs to be to a goal to trigger the end\n",
    "noise_level = 15  # Noise level for second agent's movement\n",
    "\n",
    "# Set up display\n",
    "screen = pygame.display.set_mode(WINDOW_SIZE)\n",
    "pygame.display.set_caption(\"2D Environment with Moving Target\")\n",
    "\n",
    "# Load font for rendering text\n",
    "font = pygame.font.Font(None, FONT_SIZE)\n",
    "\n",
    "# Agent positions and goal flags\n",
    "agent1_pos = [300, 300]\n",
    "agent2_pos = [300, 300]\n",
    "agent3_pos = [300, 300]\n",
    "reached_goal1 = False\n",
    "reached_goal2 = False\n",
    "\n",
    "# Target (goal) is placed randomly in the 2D space\n",
    "target_pos = [random.randint(0, WINDOW_SIZE[0]), random.randint(0, WINDOW_SIZE[1])]\n",
    "\n",
    "# Function to calculate distance between two points\n",
    "def distance(pos1, pos2):\n",
    "    return math.sqrt((pos1[0] - pos2[0])**2 + (pos1[1] - pos2[1])**2)\n",
    "\n",
    "# Function to calculate dynamic gamma\n",
    "def calculate_gamma():\n",
    "    max_distance = math.sqrt(WINDOW_SIZE[0]**2 + WINDOW_SIZE[1]**2)\n",
    "    current_distance = distance(agent3_pos, target_pos)\n",
    "    # Normalize distance to [0, 1] and invert it\n",
    "    normalized_distance = 1 - (current_distance / max_distance)\n",
    "    # Apply a non-linear transformation to make the transition more pronounced\n",
    "    return normalized_distance ** 2\n",
    "\n",
    "# Function to move agent 1 (controlled by the user)\n",
    "def move_agent1(direction):\n",
    "    global agent1_pos, reached_goal1\n",
    "    # Move based on direction\n",
    "    if direction == \"LEFT\":\n",
    "        new_pos = [agent1_pos[0] - step_size, agent1_pos[1]]\n",
    "    elif direction == \"RIGHT\":\n",
    "        new_pos = [agent1_pos[0] + step_size, agent1_pos[1]]\n",
    "    elif direction == \"UP\":\n",
    "        new_pos = [agent1_pos[0], agent1_pos[1] - step_size]\n",
    "    elif direction == \"DOWN\":\n",
    "        new_pos = [agent1_pos[0], agent1_pos[1] + step_size]\n",
    "\n",
    "    # Ensure the agent stays within the window bounds\n",
    "    if 0 <= new_pos[0] <= WINDOW_SIZE[0] and 0 <= new_pos[1] <= WINDOW_SIZE[1]:\n",
    "        agent1_pos = new_pos  # Update agent position if within bounds\n",
    "\n",
    "    # Check if agent 1 has reached the target\n",
    "    reached_goal1 = (abs(agent1_pos[0] - target_pos[0]) < tolerance and\n",
    "                     abs(agent1_pos[1] - target_pos[1]) < tolerance)\n",
    "\n",
    "# Function to move agent 2 (autonomously following the target with noise)\n",
    "def move_agent2():\n",
    "    global agent2_pos, reached_goal2\n",
    "    # Calculate the difference between agent 2 and the target\n",
    "    diff_x = target_pos[0] - agent2_pos[0]\n",
    "    diff_y = target_pos[1] - agent2_pos[1]\n",
    "\n",
    "    # Move in the direction of the target with added noise\n",
    "    if diff_x > 0:\n",
    "        new_x = agent2_pos[0] + step_size + random.uniform(-noise_level, noise_level)\n",
    "    elif diff_x < 0:\n",
    "        new_x = agent2_pos[0] - step_size + random.uniform(-noise_level, noise_level)\n",
    "    else:\n",
    "        new_x = agent2_pos[0]\n",
    "\n",
    "    if diff_y > 0:\n",
    "        new_y = agent2_pos[1] + step_size + random.uniform(-noise_level, noise_level)\n",
    "    elif diff_y < 0:\n",
    "        new_y = agent2_pos[1] - step_size + random.uniform(-noise_level, noise_level)\n",
    "    else:\n",
    "        new_y = agent2_pos[1]\n",
    "\n",
    "    # Ensure the agent stays within the window bounds\n",
    "    if 0 <= new_x <= WINDOW_SIZE[0]:\n",
    "        agent2_pos[0] = new_x\n",
    "    if 0 <= new_y <= WINDOW_SIZE[1]:\n",
    "        agent2_pos[1] = new_y\n",
    "\n",
    "    # Check if agent 2 has reached the target\n",
    "    reached_goal2 = (abs(agent2_pos[0] - target_pos[0]) < tolerance and\n",
    "                     abs(agent2_pos[1] - target_pos[1]) < tolerance)\n",
    "\n",
    "# Function to calculate the weighted average position of agent 1 and agent 2\n",
    "def update_agent3():\n",
    "    global agent3_pos\n",
    "    gamma = calculate_gamma()\n",
    "    agent3_pos[0] = gamma * agent1_pos[0] + (1 - gamma) * agent2_pos[0]\n",
    "    agent3_pos[1] = gamma * agent1_pos[1] + (1 - gamma) * agent2_pos[1]\n",
    "    return gamma\n",
    "\n",
    "# Function to reset the environment\n",
    "def reset():\n",
    "    global agent1_pos, agent2_pos, agent3_pos, reached_goal1, reached_goal2, target_pos\n",
    "    agent1_pos = [300, 300]  # Reset agent 1 to the center\n",
    "    agent2_pos = [300, 300]  # Reset agent 2 to the center\n",
    "    agent3_pos = [300, 300]  # Reset agent 3 to the center\n",
    "    reached_goal1 = False  # Reset goal flag for agent 1\n",
    "    reached_goal2 = False  # Reset goal flag for agent 2\n",
    "    target_pos = [random.randint(0, WINDOW_SIZE[0]), random.randint(0, WINDOW_SIZE[1])]  # New random target position\n",
    "\n",
    "# Function to render the environment and GUI\n",
    "def render(gamma):\n",
    "    # Clear the screen\n",
    "    screen.fill(WHITE)\n",
    "\n",
    "    # Draw agents with updated colors\n",
    "    pygame.draw.circle(screen, GREEN, (int(agent1_pos[0]), int(agent1_pos[1])), 10)\n",
    "    pygame.draw.circle(screen, BLUE, (int(agent2_pos[0]), int(agent2_pos[1])), 10)\n",
    "    pygame.draw.circle(screen, RED, (int(agent3_pos[0]), int(agent3_pos[1])), 10)\n",
    "    pygame.draw.circle(screen, YELLOW, (int(target_pos[0]), int(target_pos[1])), 10)\n",
    "\n",
    "    # Draw labels for agents\n",
    "    screen.blit(font.render(\"W\", True, BLACK), (agent1_pos[0] - 5, agent1_pos[1] - 12))\n",
    "    screen.blit(font.render(\"H\", True, BLACK), (agent2_pos[0] - 5, agent2_pos[1] - 12))\n",
    "    screen.blit(font.render(\"X\", True, BLACK), (agent3_pos[0] - 5, agent3_pos[1] - 12))\n",
    "\n",
    "    # Display gamma value\n",
    "    gamma_text = font.render(f\"Gamma: {gamma:.2f}\", True, FONT_COLOR)\n",
    "    screen.blit(gamma_text, (10, 10))\n",
    "\n",
    "    # Display arbitration formula\n",
    "    formula_text = font.render(f\"X = {gamma:.2f}W + {1-gamma:.2f}H\", True, FONT_COLOR)\n",
    "    screen.blit(formula_text, (10, 40))\n",
    "\n",
    "    # Display reset instruction\n",
    "    if reached_goal1 or reached_goal2:\n",
    "        reset_text = font.render(\"Target Reached! Press R to reset\", True, FONT_COLOR)\n",
    "        screen.blit(reset_text, (150, 70))\n",
    "\n",
    "    pygame.display.update()\n",
    "\n",
    "# Main loop\n",
    "running = True\n",
    "while running:\n",
    "    moved = False\n",
    "    for event in pygame.event.get():\n",
    "        if event.type == pygame.QUIT:\n",
    "            running = False\n",
    "        if event.type == pygame.KEYDOWN:\n",
    "            if event.key == pygame.K_r:  # Reset the game if 'R' is pressed\n",
    "                reset()\n",
    "\n",
    "    # Check if agent 1 has reached a goal\n",
    "    if not reached_goal1:  # Only allow movement if goal hasn't been reached\n",
    "        # Get keys pressed\n",
    "        keys = pygame.key.get_pressed()\n",
    "\n",
    "        # Move based on keys\n",
    "        if keys[pygame.K_LEFT]:      # Move left\n",
    "            move_agent1(\"LEFT\")\n",
    "            moved = True\n",
    "        if keys[pygame.K_RIGHT]:     # Move right\n",
    "            move_agent1(\"RIGHT\")\n",
    "            moved = True\n",
    "        if keys[pygame.K_UP]:        # Move up\n",
    "            move_agent1(\"UP\")\n",
    "            moved = True\n",
    "        if keys[pygame.K_DOWN]:      # Move down\n",
    "            move_agent1(\"DOWN\")\n",
    "            moved = True\n",
    "\n",
    "        # Only move agent 2 when agent 1 moves\n",
    "        if moved and not reached_goal2:\n",
    "            move_agent2()\n",
    "\n",
    "        # Update the position of agent 3 (averaged agent)\n",
    "        gamma = update_agent3()\n",
    "\n",
    "    # Render the environment\n",
    "    render(gamma)\n",
    "\n",
    "    pygame.time.wait(100)  # Slow down for visibility\n",
    "\n",
    "# Quit Pygame\n",
    "pygame.quit()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}