crosswalk-env 0.0.1__tar.gz

crosswalk_env-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Crosswalk Task
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crosswalk_env-0.0.1/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: crosswalk-env
+Version: 0.0.1
+Summary: A Gymnasium environment for risky decision-making
+Author-email: Jinwoo Jeong <jwjeong96@gmail.com>
+License: MIT
+Project-URL: Homepage, https://crosswalk-task.github.io
+Project-URL: Repository, https://github.com/crosswalk-task/CrosswalkEnv
+Project-URL: Issues, https://github.com/crosswalk-task/CrosswalkEnv/issues
+Requires-Python: <3.13,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pygame>=2.1
+Requires-Dist: numpy<3,>=1.21
+Requires-Dist: gymnasium<2,>=0.28
+Dynamic: license-file
+
+# CrosswalkEnv
+
+[![PyPI version](https://img.shields.io/pypi/v/crosswalk-env.svg)](https://pypi.org/project/crosswalk-env/)
+
+A [Gymnasium](https://gymnasium.farama.org/index.html) environment for risky decision-making.
+
+## Requirements
+
+* Python 3.9–3.12
+
+## Installation
+
+```bash
+pip install crosswalk-env
+```
+
+## Documentation
+
+For guides, API references, and examples, see the [Crosswalk Task documentation](https://crosswalk-task.github.io/).
+
+* [Getting Started](https://crosswalk-task.github.io/crosswalkenv/getting_started.html)
+* [Running Crosswalk Tasks](https://crosswalk-task.github.io/crosswalkenv/task.html)
+* [CrosswalkEnv API](https://crosswalk-task.github.io/crosswalkenv/environment.html)
+* [Training RL Agents](https://crosswalk-task.github.io/crosswalkenv/training_agents.html)
+* [Observation Space](https://crosswalk-task.github.io/crosswalkenv/obs_space.html)
+
+## Live Web Demo
+
+For the web version, see [CrosswalkWebEnv](https://github.com/crosswalk-task/CrosswalkWebEnv).
+
+Try the [Crosswalk Task Web Demo](https://crosswalk-task.github.io/demo).

crosswalk_env-0.0.1/README.md

@@ -0,0 +1,31 @@
+# CrosswalkEnv
+
+[![PyPI version](https://img.shields.io/pypi/v/crosswalk-env.svg)](https://pypi.org/project/crosswalk-env/)
+
+A [Gymnasium](https://gymnasium.farama.org/index.html) environment for risky decision-making.
+
+## Requirements
+
+* Python 3.9–3.12
+
+## Installation
+
+```bash
+pip install crosswalk-env
+```
+
+## Documentation
+
+For guides, API references, and examples, see the [Crosswalk Task documentation](https://crosswalk-task.github.io/).
+
+* [Getting Started](https://crosswalk-task.github.io/crosswalkenv/getting_started.html)
+* [Running Crosswalk Tasks](https://crosswalk-task.github.io/crosswalkenv/task.html)
+* [CrosswalkEnv API](https://crosswalk-task.github.io/crosswalkenv/environment.html)
+* [Training RL Agents](https://crosswalk-task.github.io/crosswalkenv/training_agents.html)
+* [Observation Space](https://crosswalk-task.github.io/crosswalkenv/obs_space.html)
+
+## Live Web Demo
+
+For the web version, see [CrosswalkWebEnv](https://github.com/crosswalk-task/CrosswalkWebEnv).
+
+Try the [Crosswalk Task Web Demo](https://crosswalk-task.github.io/demo).

crosswalk_env-0.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "crosswalk-env"
+version = "0.0.1"
+description = "A Gymnasium environment for risky decision-making"
+readme = "README.md"
+requires-python = ">=3.9,<3.13"
+license = { text = "MIT" }
+authors = [
+    { name = "Jinwoo Jeong", email = "jwjeong96@gmail.com" }
+]
+
+dependencies = [
+    "pygame>=2.1",
+    "numpy>=1.21,<3",
+    "gymnasium>=0.28,<2",
+]
+
+[project.urls]
+Homepage = "https://crosswalk-task.github.io"
+Repository = "https://github.com/crosswalk-task/CrosswalkEnv"
+Issues = "https://github.com/crosswalk-task/CrosswalkEnv/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+crosswalk_env = [
+    "sprites/**/*",
+]

crosswalk_env-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

crosswalk_env-0.0.1/src/crosswalk_env/__init__.py

@@ -0,0 +1,10 @@
+from crosswalk_env.environment import CrosswalkEnv
+from gymnasium.envs.registration import register
+
+__version__ = "0.0.1"
+__all__ = ["CrosswalkEnv"]
+
+register(
+    id="crosswalk-v1",
+    entry_point="crosswalk_env:CrosswalkEnv",
+)

crosswalk_env-0.0.1/src/crosswalk_env/common/__init__.py

@@ -0,0 +1,8 @@
+from crosswalk_env.common.action import *
+from crosswalk_env.common.road import *
+from crosswalk_env.common.utils import *
+
+from crosswalk_env.common.gameobject.game_object import *
+from crosswalk_env.common.gameobject.agent import *
+from crosswalk_env.common.gameobject.car import *
+from crosswalk_env.common.gameobject.car_details import *

crosswalk_env-0.0.1/src/crosswalk_env/common/action.py

@@ -0,0 +1,45 @@
+from enum import Enum
+
+import numpy as np
+
+class Action(Enum):
+    NOTHING = 0
+    UP = 1
+    DOWN = 2
+    RIGHT = 3
+    LEFT = 4
+
+    def __str__(self):
+        string_map = {
+            Action.NOTHING: "Nothing",
+            Action.UP: "UP",
+            Action.DOWN: "DOWN",
+            Action.RIGHT: "RIGHT",
+            Action.LEFT: "LEFT",
+        }
+        return string_map[self]
+
+ACTION_TO_DELTA = {
+    Action.NOTHING.value: np.array([0, 0]),
+    Action.UP.value: np.array([0, -1]),
+    Action.DOWN.value: np.array([0, 1]),
+    Action.RIGHT.value: np.array([1, 0]),
+    Action.LEFT.value: np.array([-1, 0]),
+}
+
+ACTION_DURATION = {
+    Action.NOTHING.value: 1,
+    Action.UP.value: 4,
+    Action.DOWN.value: 4,
+    Action.RIGHT.value: 4,
+    Action.LEFT.value: 4,
+}
+
+# NOTE: extra latency for human perception + increased time overs
+ACTION_LATENCY = {
+    Action.NOTHING.value: 1,
+    Action.UP.value: 1,
+    Action.DOWN.value: 1,
+    Action.RIGHT.value: 1,
+    Action.LEFT.value: 1,
+}

crosswalk_env-0.0.1/src/crosswalk_env/common/gameobject/agent.py

@@ -0,0 +1,124 @@
+import os
+
+import pygame
+import numpy as np
+
+from crosswalk_env.common import Action, ACTION_TO_DELTA, ACTION_DURATION
+from crosswalk_env.common.gameobject.game_object import GameObject
+
+AGENT_STATUS_ALIVE = "alive"
+AGENT_STATUS_DEAD = "dead"
+
+class Agent(GameObject):
+    TARGET_LANE = 0
+
+    def __init__(self, agent_x_range, map_grid_width, map_grid_height, pix_square_size, steps_per_second, player_asset_info):
+        fixed_speed = 2.5
+        self.init_pos = (int(map_grid_width / 2), map_grid_height - 1)
+        cur_location = np.array([self.init_pos[0], self.init_pos[1]], dtype=float)
+        super().__init__(fixed_speed, cur_location, pix_square_size, steps_per_second)
+        self.map_grid_width = map_grid_width
+        self.map_grid_height = map_grid_height
+        self.is_dead = False
+        self.MIN_X = agent_x_range[0]
+        self.MAX_X = agent_x_range[1]
+        self.last_direction = Action.DOWN.value
+        self.images = player_asset_info["images"]
+        self.sizes = player_asset_info["sizes"]
+        self.mini_step_count = 0
+
+    def get_hitbox(self):
+        center_x = self.cur_location[0]
+        center_y = self.cur_location[1]
+        sub_dir = AGENT_STATUS_DEAD if self.is_dead else AGENT_STATUS_ALIVE
+        direction = self.mini_step_count % ACTION_DURATION[self.last_direction]
+        [player_width, player_height] = self.sizes[self.last_direction][sub_dir][direction]
+        top_y = center_y - player_height/2
+        bottom_y = top_y + player_height
+        left_x = center_x - player_width/2
+        right_x = left_x + player_width
+        return [top_y, bottom_y, left_x, right_x]
+
+    def get_cur_location_grid(self):
+        return int(round(self.cur_location[0])), int(round(self.cur_location[1]))
+
+    def get_cur_location_rounded(self):
+        return round(self.cur_location[0], 2), round(self.cur_location[1], 2)
+
+    def get_target_y(self):
+        return round(self.target_location[1], 2)
+
+    def update_target(self, action_value):
+        if action_value != Action.NOTHING.value:
+            self.last_direction = action_value
+        delta = ACTION_TO_DELTA[action_value] * (self.default_speed / self.steps_per_second) * ACTION_DURATION[action_value]
+        self.target_location = np.clip(self.cur_location + delta,
+                                       [self.MIN_X, self.TARGET_LANE],
+                                       [self.MAX_X, self.map_grid_height - 1])
+
+    def set_dead(self):
+        self.is_dead = True
+        self.stop()
+
+    def render(self, background):
+        adjustment = 0.5 * self.pix_square_size
+        agent_center_x = self.cur_location[0] * self.pix_square_size
+        agent_center_y = self.cur_location[1] * self.pix_square_size + adjustment
+        agent_position = (agent_center_x, agent_center_y)
+        if self.images is not None:
+            sub_dir = AGENT_STATUS_DEAD if self.is_dead else AGENT_STATUS_ALIVE
+            direction = self.mini_step_count % ACTION_DURATION[self.last_direction]
+            image = self.images[self.last_direction][sub_dir][direction]
+            [agent_grid_width, agent_grid_height] = self.sizes[self.last_direction][sub_dir][direction]
+            left_x_pix = agent_center_x - (agent_grid_width * self.pix_square_size / 2)
+            top_y_pix = agent_center_y - (agent_grid_height * self.pix_square_size / 2)
+            background.blit(image, (left_x_pix, top_y_pix))
+        return agent_position
+
+def load_player_asset_info(pix_square_size, render_sprite):
+    directions = [Action.UP, Action.DOWN, Action.RIGHT, Action.LEFT]
+    size_ratio = {
+        "player_UP_0_cropped.png": [57,73],
+        "player_UP_1_cropped.png": [53,69],
+        "player_UP_2_cropped.png": [57,73],
+        "player_UP_3_cropped.png": [53,69],
+
+        "player_DOWN_0_cropped.png": [57,73],
+        "player_DOWN_1_cropped.png": [53,69],
+        "player_DOWN_2_cropped.png": [57,73],
+        "player_DOWN_3_cropped.png": [53,69],
+
+        "player_RIGHT_0_cropped.png": [49,69],
+        "player_RIGHT_1_cropped.png": [49,65],
+        "player_RIGHT_2_cropped.png": [49,69],
+        "player_RIGHT_3_cropped.png": [49,65],
+
+        "player_LEFT_0_cropped.png": [49,69],
+        "player_LEFT_1_cropped.png": [49,65],
+        "player_LEFT_2_cropped.png": [49,69],
+        "player_LEFT_3_cropped.png": [49,65],
+    }
+    images = {} if render_sprite else None
+    sizes = {}
+    for d in directions:
+        if render_sprite:
+            images[d.value] = {}
+            images[d.value][AGENT_STATUS_ALIVE] = []
+            images[d.value][AGENT_STATUS_DEAD] = []
+        sizes[d.value] = {}
+        sizes[d.value][AGENT_STATUS_ALIVE] = []
+        sizes[d.value][AGENT_STATUS_DEAD] = []
+        for i in range(4):
+            for status in [AGENT_STATUS_ALIVE, AGENT_STATUS_DEAD]:
+                file_name = f"player_{str(d)}_{i}_cropped.png"
+                current_dir = os.path.dirname(os.path.abspath(__file__))
+                image_path = os.path.join(current_dir, "../..", f"sprites/player_color/", file_name)
+                [width_ratio, height_ratio] = size_ratio[file_name]
+                agent_grid_height = (height_ratio / 140) * (0.4 if status == AGENT_STATUS_DEAD else 1)
+                agent_grid_width = (width_ratio / 140) * (2.4 if status == AGENT_STATUS_DEAD else 1)
+                if render_sprite:
+                    object_image = pygame.image.load(image_path)
+                    image = pygame.transform.scale(object_image, (agent_grid_width * pix_square_size, agent_grid_height * pix_square_size))
+                    images[d.value][status].append(image)
+                sizes[d.value][status].append([agent_grid_width, agent_grid_height])
+    return {"images": images, "sizes": sizes}

crosswalk_env-0.0.1/src/crosswalk_env/common/gameobject/car.py

@@ -0,0 +1,114 @@
+import numpy as np
+
+from crosswalk_env.common.gameobject.game_object import GameObject
+from crosswalk_env.common.utils import is_overlapping
+from crosswalk_env.common.road import CrossWalk
+
+class Car(GameObject):
+    CAR_SPEEDS = [3.0, 3.5, 4.0, 4.5]  # NOTE: 2 is slightly faster than the player
+
+    def __init__(self, uid, initial_x, start_row_idx, car_grid_height, road, map_grid_width, pix_square_size, steps_per_second, car_details, random):
+        row_indices = []
+        for i in range(car_grid_height):
+            row_indices.append(start_row_idx + i)
+        initial_y = np.mean(row_indices)
+        cur_location = np.array([initial_x, initial_y], dtype=float)
+        super().__init__(0, cur_location, pix_square_size, steps_per_second)
+        self.uid = uid
+        self.rows = row_indices
+        self.map_grid_width = map_grid_width
+        self.car_details = car_details
+        self.random = random
+        self.set_random_speed()
+        self.road = road
+        self.nearby_cars = [] # all the cars in the overlapping lane
+
+    def get_cur_speed(self):
+        return self.default_speed if self.is_moving else 0
+
+    def get_hitbox(self):
+        left_x, right_x = self.get_cur_x_pos()
+        top_y, bottom_y = self.get_cur_y_pos()
+        return [top_y, bottom_y, left_x, right_x]
+
+    def get_cur_x_pos(self):
+        left_x = self.cur_location[0] - (self.car_details.car_grid_width/2)
+        right_x = self.cur_location[0] + (self.car_details.car_grid_width/2)
+        return left_x, right_x
+
+    def get_cur_y_pos(self):
+        top_y = self.cur_location[1] - (self.car_details.car_grid_height/2)
+        bottom_y = self.cur_location[1] + (self.car_details.car_grid_height/2)
+        return top_y, bottom_y
+
+    def set_random_speed(self):
+        self.default_speed = self.random.choice(self.CAR_SPEEDS)
+        if not self.car_details.go_right:
+            self.default_speed *= -1
+
+    def restart_if_needed(self):
+        # teleport to start of the lane when reaching the end
+        if self.car_details.go_right and self.cur_location[0] >= self.map_grid_width:
+            self.cur_location[0] = 0
+            self.set_random_speed()
+        if not self.car_details.go_right and self.cur_location[0] <= 0:
+            self.cur_location[0] = self.map_grid_width - 1
+            self.set_random_speed()
+
+    def update_target(self, dt):
+        self.restart_if_needed()
+        # stop in the current location when another car is in front of the car
+        if len(self.nearby_cars) > 0:
+            threshold = 0.1
+            my_left, my_right = self.get_cur_x_pos()
+            for other_car in self.nearby_cars:
+                other_left, other_right = other_car.get_cur_x_pos()
+                # stop when another car is in front of me
+                if self.car_details.go_right:
+                    front_dist = other_left - my_right
+                else:
+                    front_dist = my_left - other_right
+                if 0 < front_dist <= threshold:
+                    self.stop()
+                    return
+
+                # make the one in the back stop if the both cars are overlapping
+                # make the one with lower uid stop if the front positions are the same
+                if self.car_details.go_right:
+                    front_diff = other_right - my_right
+                else:
+                    front_diff = my_left - other_left
+                if front_diff > 0 or (front_diff == 0 and self.uid < other_car.uid):
+                    if is_overlapping(my_left, my_right, other_left, other_right):
+                        self.stop()
+                        return
+
+        # stop in front of the crosswalk when it is activated
+        crosswalk = self.road.crosswalk
+        if crosswalk is not None and crosswalk.is_active:
+            car_left, car_right = self.get_cur_x_pos()
+            cw_left, cw_right = crosswalk.get_activation_left_right()
+            if self.car_details.go_right:
+                front_dist = abs(cw_left - car_right)
+            else:
+                front_dist = abs(cw_right - car_left)
+            if front_dist < CrossWalk.THRESHOLD_DISTANCE:
+                if is_overlapping(car_left, car_right, cw_left, cw_right):
+                    pass # keep going to clear up the crosswalk
+                else:
+                    self.stop()
+                    return
+        self.target_location[0] = self.cur_location[0] + (self.default_speed * dt / 1000)
+        self.is_moving = True # moving unless stopped
+
+    def render(self, background):
+        left_x, _ = self.get_cur_x_pos()
+        top_y, _ = self.get_cur_y_pos()
+        left_x_pix = left_x * self.pix_square_size
+        top_y_pix = top_y * self.pix_square_size
+        adjustment = 0.5 * self.pix_square_size
+        if self.car_details.image is not None:
+            background.blit(self.car_details.image, (left_x_pix, top_y_pix + adjustment))
+
+    def __str__(self):
+        return f"Car(cur_pos=({self.cur_location[0], self.cur_location[1]}), crosswalk=({self.road.crosswalk}))"

crosswalk_env-0.0.1/src/crosswalk_env/common/gameobject/car_details.py

@@ -0,0 +1,126 @@
+import os
+
+from enum import Enum
+
+import pygame
+
+class Penalty(Enum):
+    LOW = 100
+    MEDIUM = 500
+    HIGH = 1000
+
+class CarColorType(Enum):
+    GREEN = 0
+    YELLOW = 1
+    RED = 2
+
+    def __str__(self):
+        string_map = {
+            CarColorType.GREEN: "GREEN",
+            CarColorType.YELLOW: "YELLOW",
+            CarColorType.RED: "RED",
+        }
+        return string_map[self]
+
+class RiskDetail:
+    def __init__(self, color_name, color, penalty):
+        self.color_name = color_name
+        self.color = color
+        self.penalty = penalty
+
+RiskDetails = {
+    CarColorType.RED: RiskDetail(color_name="Red", color=(255, 0, 0), penalty=Penalty.HIGH),
+    CarColorType.YELLOW: RiskDetail(color_name="Yellow", color=(255, 255, 0), penalty=Penalty.MEDIUM),
+    CarColorType.GREEN: RiskDetail(color_name="Green", color=(0, 255, 0), penalty=Penalty.LOW),
+}
+
+# key = start_row_idx, value = car_heights 
+CARS_PER_LANE_PAIR_COMPOSITION = [
+    # 2 small cars
+    {0: [1], 1: [1]},
+    {0: [1], 1: [1]},
+    # 3 small cars
+    {0: [1], 1: [1, 1]},
+    {0: [1, 1], 1: [1]},
+    # 1 big car, 1 small car
+    {0: [2, 1], 1: []},
+    {0: [2], 1: [1]},
+    # 1 big car, 2 small cars
+    {0: [2, 1], 1: [1]},
+    {0: [2, 1], 1: [1]},
+]
+
+# key=height, value=(car_type, height:width ratio)
+CAR_CANDIDATES = {
+    1: [
+        ("MICRO", 1.1875),
+        ("JEEP", 1.3043),
+        ("CIVIC", 1.5556),
+        ("VAN", 1.6136),
+        ("SUV", 1.8333),
+        ("MINIVAN", 1.9070),
+        ("WAGON", 1.9545),
+        ("HatchBack", 1.9750),
+        ("SPORT", 1.9756),
+        ("COUPE", 2.0238),
+        ("MUSCLECAR", 2.0244),
+        ("LUXURY", 2.0698),
+        ("SEDAN", 2.0750),
+        ("SUPERCAR", 2.2895),
+        ("LIMO", 3.2250),
+    ],
+    2: [
+        ("CAMPER", 1.8868),
+        ("MEDIUMTRUCK", 1.8983),
+        ("BOXTRUCK", 2.0600),
+        ("PICKUP", 2.1250),
+        # ("BUS", 2.2540), # Too white
+    ]
+}
+
+def get_max_car_grid_width():
+    max_width = 0
+    for height in CAR_CANDIDATES:
+        for candidate in CAR_CANDIDATES[height]:
+            max_width = max(max_width, candidate[1] * height)
+    return max_width
+
+def get_max_car_grid_height():
+    max_height = 0
+    for height in CAR_CANDIDATES:
+        max_height = max(max_height, height)
+    return max_height
+
+class CarDetails:
+    def __init__(self, car_type, color_type, go_right, pix_square_size, car_grid_height, ratio, render_sprite, height_buffer = 0.1):
+        self.car_type = car_type
+        risk_detail = RiskDetails[color_type]
+        self.color = color_type
+        self.penalty = risk_detail.penalty
+        self.go_right = go_right
+
+        self.car_grid_height = car_grid_height - height_buffer # NOTE: needed to handle the overlap between the lanes
+        self.car_grid_width = self.car_grid_height * float(ratio)
+        self.car_width = self.car_grid_width * pix_square_size
+        self.car_height = self.car_grid_height * pix_square_size
+
+        self.image = None
+        if render_sprite:
+            direction = "EAST" if go_right else "WEST"
+            file_name = f"{risk_detail.color_name}_{car_type}_CLEAN_{direction}_000_cropped.png"
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            image_path = os.path.join(current_dir, "../..", "sprites/cars/", file_name)
+            object_image = pygame.image.load(image_path)
+            self.image = pygame.transform.scale(object_image, (self.car_width, self.car_height))
+
+def load_car_details_dict(pix_square_size, render_sprite):
+    car_details_dict = {}
+    for height in [1, 2]:
+        for i in range(len(CAR_CANDIDATES[height])):
+            (car_type, ratio) = CAR_CANDIDATES[height][i]
+            car_details_dict[car_type] = {}
+            for color_type in RiskDetails.keys():
+                car_details_dict[car_type][color_type] = {}
+                for go_right in [False, True]:
+                    car_details_dict[car_type][color_type][go_right] = CarDetails(car_type, color_type, go_right, pix_square_size, height, ratio, render_sprite)
+    return car_details_dict

crosswalk_env-0.0.1/src/crosswalk_env/common/gameobject/game_object.py

@@ -0,0 +1,43 @@
+class GameObject:
+
+    def __init__(self, default_speed, cur_location, pix_square_size, steps_per_second):
+        self.default_speed = default_speed
+        self.cur_location = cur_location
+        self.target_location = self.cur_location
+        self.pix_square_size = pix_square_size
+        self.steps_per_second = steps_per_second
+        self.is_moving = False
+
+    def update_position(self, dt):
+        tx, ty = self.target_location
+        cx, cy = self.cur_location
+
+        dx = tx - cx
+        dy = ty - cy
+        if abs(dx) < 0.1:
+            self.cur_location[0] = tx
+            dx = 0
+        if abs(dy) < 0.1:
+            self.cur_location[1] = ty
+            dy = 0
+        if dx == 0 and dy == 0: return
+
+        if dx != 0 and dy != 0: # diagonal move
+            dist = (dx ** 2 + dy ** 2) ** 0.5
+        else: # straight move
+            dist = max(abs(dx), abs(dy))
+        step = abs(self.default_speed) * (dt / 1000.0)
+        move = min(step, dist)
+        ux = dx / dist
+        uy = dy / dist
+
+        self.cur_location[0] += ux * move
+        self.cur_location[1] += uy * move
+        self.is_moving = True
+
+    def stop(self):
+        self.target_location = self.cur_location
+        self.is_moving = False
+
+    def render(self, background):
+        pass

crosswalk_env-0.0.1/src/crosswalk_env/common/road.py

@@ -0,0 +1,34 @@
+from crosswalk_env.common.gameobject.car_details import CarColorType, RiskDetails
+
+class Road:
+    COMPOSITION_SIZE = 2
+
+    def __init__(self, uid, top_y, bottom_y, going_right_rows, random, crosswalk = None):
+        self.uid = uid
+        self.top_y = top_y
+        self.bottom_y = bottom_y
+        self.going_right = going_right_rows
+        self.car_color_type = random.choice([CarColorType.RED, CarColorType.YELLOW, CarColorType.GREEN])
+        self.risk_detail = RiskDetails[self.car_color_type]
+        self.crosswalk = crosswalk
+
+class CrossWalk:
+    RATIO = 0.6
+    THRESHOLD_DISTANCE = 0.3
+
+    def __init__(self, uid, col, top_row, end_row):
+        self.uid = uid
+        self.col = col
+        self.left_end = col - 1
+        self.right_end = col + 1
+        self.top_row = top_row
+        self.end_row = end_row
+        self.is_active = False
+
+    def get_activation_left_right(self):
+        left = self.left_end - self.THRESHOLD_DISTANCE
+        right = self.right_end + self.THRESHOLD_DISTANCE
+        return left, right
+
+    def __str__(self):
+        return f"CrossWalk(active={self.is_active}, x=({self.left_end}, {self.right_end}), y=({self.top_row}, {self.end_row}))"

crosswalk_env-0.0.1/src/crosswalk_env/common/utils.py

@@ -0,0 +1,12 @@
+def is_overlapping(left1, right1, left2, right2):
+    if right1 < left2 or right2 < left1:
+        return False
+    return True
+
+def is_overlapping_rectangles(rect1, rect2):
+    (t1, b1, l1, r1) = rect1
+    (t2, b2, l2, r2) = rect2
+    
+    if r1 < l2 or r2 < l1: return False
+    if b1 < t2 or b2 < t1: return False
+    return True