mirror of
https://github.com/firestar5683/StarPilot.git
synced 2026-07-17 15:22:10 +08:00
firestarsdog
429 lines
20 KiB
Python
429 lines
20 KiB
Python
from __future__ import annotations
|
|
import math
|
|
import pyray as rl
|
|
|
|
|
|
def draw_custom_icon(key: str, x: float, y: float, s: float, color: rl.Color):
|
|
|
|
# Helper for drawing quadratic Bezier curves
|
|
def draw_bezier(p0: rl.Vector2, p1: rl.Vector2, p2: rl.Vector2, thick: float):
|
|
segments = 128
|
|
for i in range(segments):
|
|
t1 = i / segments
|
|
t2 = (i + 1) / segments
|
|
x1_val = (1 - t1)**2 * p0.x + 2 * (1 - t1) * t1 * p1.x + t1**2 * p2.x
|
|
y1_val = (1 - t1)**2 * p0.y + 2 * (1 - t1) * t1 * p1.y + t1**2 * p2.y
|
|
x2_val = (1 - t2)**2 * p0.x + 2 * (1 - t2) * t2 * p1.x + t2**2 * p2.x
|
|
y2_val = (1 - t2)**2 * p0.y + 2 * (1 - t2) * t2 * p1.y + t2**2 * p2.y
|
|
rl.draw_line_ex(rl.Vector2(x1_val, y1_val), rl.Vector2(x2_val, y2_val), thick, color)
|
|
|
|
# Helper for drawing tilted ellipse arcs
|
|
def draw_ellipse_arc(cx: float, cy: float, a: float, b: float, tilt_deg: float, start_deg: float, end_deg: float, thick: float):
|
|
tilt = math.radians(tilt_deg)
|
|
segments = 128
|
|
step = (end_deg - start_deg) / segments
|
|
for i in range(segments):
|
|
p1 = math.radians(start_deg + i * step)
|
|
p2 = math.radians(start_deg + (i + 1) * step)
|
|
|
|
x1_val = a * math.cos(p1)
|
|
y1_val = b * math.sin(p1)
|
|
rx1 = x1_val * math.cos(tilt) - y1_val * math.sin(tilt)
|
|
ry1 = x1_val * math.sin(tilt) + y1_val * math.cos(tilt)
|
|
|
|
x2_val = a * math.cos(p2)
|
|
y2_val = b * math.sin(p2)
|
|
rx2 = x2_val * math.cos(tilt) - y2_val * math.sin(tilt)
|
|
ry2 = x2_val * math.sin(tilt) + y2_val * math.cos(tilt)
|
|
|
|
rl.draw_line_ex(rl.Vector2(cx + rx1, cy + ry1), rl.Vector2(cx + rx2, cy + ry2), thick, color)
|
|
|
|
# Helper for drawing 4-pointed stars
|
|
def draw_star(cx: float, cy: float, R: float, r: float):
|
|
v1a = rl.Vector2(cx - r, cy - r)
|
|
v1b = rl.Vector2(cx + r, cy - r)
|
|
v1c = rl.Vector2(cx, cy - R)
|
|
|
|
v2a = rl.Vector2(cx + r, cy - r)
|
|
v2b = rl.Vector2(cx + r, cy + r)
|
|
v2c = rl.Vector2(cx + R, cy)
|
|
|
|
v3a = rl.Vector2(cx + r, cy + r)
|
|
v3b = rl.Vector2(cx - r, cy + r)
|
|
v3c = rl.Vector2(cx, cy + R)
|
|
|
|
v4a = rl.Vector2(cx - r, cy + r)
|
|
v4b = rl.Vector2(cx - r, cy - r)
|
|
v4c = rl.Vector2(cx - R, cy)
|
|
|
|
rl.draw_triangle(v1a, v1b, v1c, color)
|
|
rl.draw_triangle(v2a, v2b, v2c, color)
|
|
rl.draw_triangle(v3a, v3b, v3c, color)
|
|
rl.draw_triangle(v4a, v4b, v4c, color)
|
|
rl.draw_circle_v(rl.Vector2(cx, cy), r, color)
|
|
|
|
if key == "sound":
|
|
# Sounds & Alerts: Speaker icon on the left, sound waves on the right (proportionate weight & scale)
|
|
x_c = x + 30.0 * s
|
|
y_c = y + 30.0 * s
|
|
|
|
thick = 3.0 * s
|
|
r_cap = thick / 2.0
|
|
|
|
# Draw speaker body outline (Driver on the left, mouth opening to the right)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 3.0 * s, y_c - 18.0 * s), rl.Vector2(x_c - 3.0 * s, y_c + 18.0 * s), thick, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 3.0 * s, y_c - 18.0 * s), rl.Vector2(x_c - 12.0 * s, y_c - 7.0 * s), thick, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 3.0 * s, y_c + 18.0 * s), rl.Vector2(x_c - 12.0 * s, y_c + 7.0 * s), thick, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 12.0 * s, y_c - 7.0 * s), rl.Vector2(x_c - 22.0 * s, y_c - 7.0 * s), thick, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 12.0 * s, y_c + 7.0 * s), rl.Vector2(x_c - 22.0 * s, y_c + 7.0 * s), thick, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 22.0 * s, y_c - 7.0 * s), rl.Vector2(x_c - 22.0 * s, y_c + 7.0 * s), thick, color)
|
|
|
|
# Draw circles at speaker body vertices to round the corners beautifully
|
|
rl.draw_circle_v(rl.Vector2(x_c - 3.0 * s, y_c - 18.0 * s), r_cap, color)
|
|
rl.draw_circle_v(rl.Vector2(x_c - 3.0 * s, y_c + 18.0 * s), r_cap, color)
|
|
rl.draw_circle_v(rl.Vector2(x_c - 12.0 * s, y_c - 7.0 * s), r_cap, color)
|
|
rl.draw_circle_v(rl.Vector2(x_c - 12.0 * s, y_c + 7.0 * s), r_cap, color)
|
|
rl.draw_circle_v(rl.Vector2(x_c - 22.0 * s, y_c - 7.0 * s), r_cap, color)
|
|
rl.draw_circle_v(rl.Vector2(x_c - 22.0 * s, y_c + 7.0 * s), r_cap, color)
|
|
|
|
# Helper to draw rounded concentric sound wave arcs
|
|
def draw_rounded_arc(cx: float, cy: float, r: float, start_deg: float, end_deg: float):
|
|
draw_ellipse_arc(cx, cy, r, r, 0.0, start_deg, end_deg, thick)
|
|
rad_start = math.radians(start_deg)
|
|
rad_end = math.radians(end_deg)
|
|
rl.draw_circle_v(rl.Vector2(cx + r * math.cos(rad_start), cy + r * math.sin(rad_start)), r_cap, color)
|
|
rl.draw_circle_v(rl.Vector2(cx + r * math.cos(rad_end), cy + r * math.sin(rad_end)), r_cap, color)
|
|
|
|
# Draw three concentric sound wave arcs (curving on the right side)
|
|
draw_rounded_arc(x_c - 3.0 * s, y_c, 8.0 * s, -25.0, 25.0)
|
|
draw_rounded_arc(x_c - 3.0 * s, y_c, 15.0 * s, -37.5, 37.5)
|
|
draw_rounded_arc(x_c - 3.0 * s, y_c, 22.0 * s, -50.0, 50.0)
|
|
|
|
elif key == "steering":
|
|
# Driving Controls: Minimalist 3-spoke steering wheel
|
|
x_c = x + 30.0 * s
|
|
y_c = y + 30.0 * s
|
|
|
|
# Outer rim
|
|
rl.draw_ring(rl.Vector2(x_c, y_c), 19.5 * s, 22.5 * s, 0.0, 360.0, 96, color)
|
|
|
|
# Center hub
|
|
rl.draw_circle_v(rl.Vector2(x_c, y_c), 4.5 * s, color)
|
|
|
|
# Three clean, single-line spokes
|
|
rl.draw_line_ex(rl.Vector2(x_c - 4.5 * s, y_c), rl.Vector2(x_c - 19.5 * s, y_c), 2.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 4.5 * s, y_c), rl.Vector2(x_c + 19.5 * s, y_c), 2.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c, y_c + 4.5 * s), rl.Vector2(x_c, y_c + 19.5 * s), 2.5 * s, color)
|
|
|
|
elif key == "navigate":
|
|
# Map Data: Clean location pin with single base shadow ellipse
|
|
x_c = x + 30.0 * s
|
|
y_c = y + 21.0 * s
|
|
|
|
# Teardrop head outline
|
|
draw_ellipse_arc(x_c, y_c, 10.0 * s, 10.0 * s, 0.0, 150.0, 390.0, 3.0 * s)
|
|
|
|
# Tapered sides to tip
|
|
rl.draw_line_ex(rl.Vector2(x_c - 8.66 * s, y_c + 5.0 * s), rl.Vector2(x_c, y_c + 19.5 * s), 3.0 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 8.66 * s, y_c + 5.0 * s), rl.Vector2(x_c, y_c + 19.5 * s), 3.0 * s, color)
|
|
|
|
# Inner core dot
|
|
rl.draw_circle_v(rl.Vector2(x_c, y_c), 3.0 * s, color)
|
|
|
|
# Perspective base shadow
|
|
draw_ellipse_arc(x_c, y_c + 24.0 * s, 14.0 * s, 4.5 * s, 0.0, 0.0, 360.0, 2.0 * s)
|
|
|
|
elif key == "system":
|
|
# System Settings: Interlocking minimalist gears (Large & Small)
|
|
cx1, cy1 = x + 24.0 * s, y + 24.0 * s
|
|
cx2, cy2 = x + 38.5 * s, y + 38.5 * s
|
|
|
|
# Gear 1 (Large - 6 cogs)
|
|
rl.draw_ring(rl.Vector2(cx1, cy1), 5.0 * s, 9.0 * s, 0.0, 360.0, 48, color)
|
|
for i in range(6):
|
|
angle_rad = math.radians(i * 60.0)
|
|
cos_a = math.cos(angle_rad)
|
|
sin_a = math.sin(angle_rad)
|
|
rl.draw_line_ex(
|
|
rl.Vector2(cx1 + cos_a * 9.0 * s, cy1 + sin_a * 9.0 * s),
|
|
rl.Vector2(cx1 + cos_a * 13.0 * s, cy1 + sin_a * 13.0 * s),
|
|
4.5 * s,
|
|
color
|
|
)
|
|
|
|
# Gear 2 (Small - 5 cogs)
|
|
rl.draw_ring(rl.Vector2(cx2, cy2), 3.0 * s, 6.0 * s, 0.0, 360.0, 48, color)
|
|
for j in range(5):
|
|
angle_rad = math.radians(36.0 + j * 72.0)
|
|
cos_a = math.cos(angle_rad)
|
|
sin_a = math.sin(angle_rad)
|
|
rl.draw_line_ex(
|
|
rl.Vector2(cx2 + cos_a * 6.0 * s, cy2 + sin_a * 6.0 * s),
|
|
rl.Vector2(cx2 + cos_a * 9.5 * s, cy2 + sin_a * 9.5 * s),
|
|
3.5 * s,
|
|
color
|
|
)
|
|
|
|
elif key == "display":
|
|
# Appearance Settings: A horizontal control panel rectangle with 4 vertical slider tracks and thumbs at various levels
|
|
x_c = x + 30.0 * s
|
|
y_c = y + 30.0 * s
|
|
|
|
thick = 2.5 * s
|
|
inner_thick = 1.5 * s
|
|
thumb_r = 2.5 * s
|
|
|
|
# 1. Draw outer rounded rectangle outline manually for perfect geometry and scaling
|
|
# Top and bottom horizontal lines
|
|
rl.draw_line_ex(rl.Vector2(x_c - 17.0 * s, y_c - 16.0 * s), rl.Vector2(x_c + 17.0 * s, y_c - 16.0 * s), thick, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 17.0 * s, y_c + 16.0 * s), rl.Vector2(x_c + 17.0 * s, y_c + 16.0 * s), thick, color)
|
|
# Left and right vertical lines
|
|
rl.draw_line_ex(rl.Vector2(x_c - 22.0 * s, y_c - 11.0 * s), rl.Vector2(x_c - 22.0 * s, y_c + 11.0 * s), thick, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 22.0 * s, y_c - 11.0 * s), rl.Vector2(x_c + 22.0 * s, y_c + 11.0 * s), thick, color)
|
|
# Four corner arcs
|
|
draw_ellipse_arc(x_c - 17.0 * s, y_c - 11.0 * s, 5.0 * s, 5.0 * s, 0.0, 180.0, 270.0, thick)
|
|
draw_ellipse_arc(x_c + 17.0 * s, y_c - 11.0 * s, 5.0 * s, 5.0 * s, 0.0, 270.0, 360.0, thick)
|
|
draw_ellipse_arc(x_c + 17.0 * s, y_c + 11.0 * s, 5.0 * s, 5.0 * s, 0.0, 0.0, 90.0, thick)
|
|
draw_ellipse_arc(x_c - 17.0 * s, y_c + 11.0 * s, 5.0 * s, 5.0 * s, 0.0, 90.0, 180.0, thick)
|
|
|
|
# 2. Draw 4 vertical slider tracks
|
|
x_positions = [x_c - 12.0 * s, x_c - 4.0 * s, x_c + 4.0 * s, x_c + 12.0 * s]
|
|
for px in x_positions:
|
|
rl.draw_line_ex(rl.Vector2(px, y_c - 9.0 * s), rl.Vector2(px, y_c + 9.0 * s), inner_thick, color)
|
|
|
|
# 3. Draw slider thumbs (solid circles at different vertical levels)
|
|
# Track 1 (left): low level
|
|
rl.draw_circle_v(rl.Vector2(x_positions[0], y_c + 3.0 * s), thumb_r, color)
|
|
# Track 2 (mid-left): center level
|
|
rl.draw_circle_v(rl.Vector2(x_positions[1], y_c - 2.0 * s), thumb_r, color)
|
|
# Track 3 (mid-right): low level
|
|
rl.draw_circle_v(rl.Vector2(x_positions[2], y_c + 3.0 * s), thumb_r, color)
|
|
# Track 4 (right): high level
|
|
rl.draw_circle_v(rl.Vector2(x_positions[3], y_c - 6.0 * s), thumb_r, color)
|
|
|
|
elif key == "vehicle":
|
|
# Vehicle Settings: Little Car
|
|
v_front = rl.Vector2(x + 5.0 * s, y + 34.0 * s)
|
|
v_hood_end = rl.Vector2(x + 15.0 * s, y + 27.0 * s)
|
|
v_cabin_end = rl.Vector2(x + 37.0 * s, y + 17.0 * s)
|
|
v_rear = rl.Vector2(x + 55.0 * s, y + 33.0 * s)
|
|
|
|
# Car body panels (continuous Bezier curve profile)
|
|
rl.draw_line_ex(rl.Vector2(x + 5.0 * s, y + 38.0 * s), v_front, 2.0 * s, color)
|
|
draw_bezier(v_front, rl.Vector2(x + 9.0 * s, y + 32.0 * s), v_hood_end, 2.0 * s)
|
|
draw_bezier(v_hood_end, rl.Vector2(x + 25.0 * s, y + 17.0 * s), v_cabin_end, 2.0 * s)
|
|
draw_bezier(v_cabin_end, rl.Vector2(x + 48.0 * s, y + 20.0 * s), v_rear, 2.0 * s)
|
|
rl.draw_line_ex(v_rear, rl.Vector2(x + 55.0 * s, y + 38.0 * s), 2.0 * s, color)
|
|
|
|
# Underbody frame
|
|
rl.draw_line_ex(rl.Vector2(x + 5.0 * s, y + 38.0 * s), rl.Vector2(x + 11.5 * s, y + 38.0 * s), 2.0 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x + 21.5 * s, y + 38.0 * s), rl.Vector2(x + 38.5 * s, y + 38.0 * s), 2.0 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x + 48.5 * s, y + 38.0 * s), rl.Vector2(x + 55.0 * s, y + 38.0 * s), 2.0 * s, color)
|
|
|
|
# Wheels (clean hollow rings with high segment counts)
|
|
rl.draw_ring(rl.Vector2(x + 16.5 * s, y + 38.0 * s), 2.5 * s, 5.0 * s, 0.0, 360.0, 48, color)
|
|
rl.draw_ring(rl.Vector2(x + 43.5 * s, y + 38.0 * s), 2.5 * s, 5.0 * s, 0.0, 360.0, 48, color)
|
|
|
|
# Window cutout details
|
|
rl.draw_line_ex(rl.Vector2(x + 18.0 * s, y + 25.0 * s), rl.Vector2(x + 36.0 * s, y + 25.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x + 36.0 * s, y + 25.0 * s), rl.Vector2(x + 34.0 * s, y + 20.0 * s), 1.5 * s, color)
|
|
|
|
elif key == "road":
|
|
# Curvy Road: Vertical perspective road with dashed center line
|
|
x_c = x + 30.0 * s
|
|
y_c = y + 30.0 * s
|
|
|
|
def draw_cubic_bezier(p0: rl.Vector2, p1: rl.Vector2, p2: rl.Vector2, p3: rl.Vector2, thick: float):
|
|
segments = 64
|
|
for i in range(segments):
|
|
t1 = i / segments
|
|
t2 = (i + 1) / segments
|
|
|
|
t1_3 = (1 - t1)**3
|
|
t1_2_t = 3 * (1 - t1)**2 * t1
|
|
t_t1_2 = 3 * (1 - t1) * t1**2
|
|
t1_cube = t1**3
|
|
|
|
x1_val = t1_3 * p0.x + t1_2_t * p1.x + t_t1_2 * p2.x + t1_cube * p3.x
|
|
y1_val = t1_3 * p0.y + t1_2_t * p1.y + t_t1_2 * p2.y + t1_cube * p3.y
|
|
|
|
t2_3 = (1 - t2)**3
|
|
t2_2_t = 3 * (1 - t2)**2 * t2
|
|
t_t2_2 = 3 * (1 - t2) * t2**2
|
|
t2_cube = t2**3
|
|
|
|
x2_val = t2_3 * p0.x + t2_2_t * p1.x + t_t2_2 * p2.x + t2_cube * p3.x
|
|
y2_val = t2_3 * p0.y + t2_2_t * p1.y + t_t2_2 * p2.y + t2_cube * p3.y
|
|
|
|
rl.draw_line_ex(rl.Vector2(x1_val, y1_val), rl.Vector2(x2_val, y2_val), thick, color)
|
|
|
|
# Center reference points for S-curve
|
|
p0_c = rl.Vector2(x_c, y_c + 24.0 * s)
|
|
p1_c = rl.Vector2(x_c - 16.0 * s, y_c + 9.0 * s)
|
|
p2_c = rl.Vector2(x_c + 16.0 * s, y_c - 5.0 * s)
|
|
p3_c = rl.Vector2(x_c, y_c - 19.0 * s)
|
|
|
|
# Left edge points (widest at bottom, tapering at top)
|
|
p0_l = rl.Vector2(p0_c.x - 17.0 * s, p0_c.y)
|
|
p1_l = rl.Vector2(p1_c.x - 12.0 * s, p1_c.y)
|
|
p2_l = rl.Vector2(p2_c.x - 8.0 * s, p2_c.y)
|
|
p3_l = rl.Vector2(p3_c.x - 5.0 * s, p3_c.y)
|
|
draw_cubic_bezier(p0_l, p1_l, p2_l, p3_l, 3.0 * s)
|
|
|
|
# Right edge points (widest at bottom, tapering at top)
|
|
p0_r = rl.Vector2(p0_c.x + 17.0 * s, p0_c.y)
|
|
p1_r = rl.Vector2(p1_c.x + 12.0 * s, p1_c.y)
|
|
p2_r = rl.Vector2(p2_c.x + 8.0 * s, p2_c.y)
|
|
p3_r = rl.Vector2(p3_c.x + 5.0 * s, p3_c.y)
|
|
draw_cubic_bezier(p0_r, p1_r, p2_r, p3_r, 3.0 * s)
|
|
|
|
# Center dashed line
|
|
dash_count = 4
|
|
for i in range(dash_count):
|
|
t1 = (i + 0.15) / dash_count
|
|
t2 = (i + 0.65) / dash_count
|
|
|
|
t1_3 = (1 - t1)**3
|
|
t1_2_t = 3 * (1 - t1)**2 * t1
|
|
t_t1_2 = 3 * (1 - t1) * t1**2
|
|
t1_cube = t1**3
|
|
|
|
x1_val = t1_3 * p0_c.x + t1_2_t * p1_c.x + t_t1_2 * p2_c.x + t1_cube * p3_c.x
|
|
y1_val = t1_3 * p0_c.y + t1_2_t * p1_c.y + t_t1_2 * p2_c.y + t1_cube * p3_c.y
|
|
|
|
t2_3 = (1 - t2)**3
|
|
t2_2_t = 3 * (1 - t2)**2 * t2
|
|
t_t2_2 = 3 * (1 - t2) * t2**2
|
|
t2_cube = t2**3
|
|
|
|
x2_val = t2_3 * p0_c.x + t2_2_t * p1_c.x + t_t2_2 * p2_c.x + t2_cube * p3_c.x
|
|
y2_val = t2_3 * p0_c.y + t2_2_t * p1_c.y + t_t2_2 * p2_c.y + t2_cube * p3_c.y
|
|
|
|
rl.draw_line_ex(rl.Vector2(x1_val, y1_val), rl.Vector2(x2_val, y2_val), 2.5 * s, color)
|
|
|
|
elif key == "aicar":
|
|
# AI Car: Half car silhouette on the left (Sedan), circuit traces with contact pads on the right
|
|
x_c = x + 30.0 * s
|
|
y_c = y + 30.0 * s
|
|
|
|
def draw_pad(cx: float, cy: float, size: float):
|
|
half = size / 2.0
|
|
rl.draw_line_ex(rl.Vector2(cx - half, cy - half), rl.Vector2(cx + half, cy - half), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(cx + half, cy - half), rl.Vector2(cx + half, cy + half), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(cx + half, cy + half), rl.Vector2(cx - half, cy + half), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(cx - half, cy + half), rl.Vector2(cx - half, cy - half), 1.5 * s, color)
|
|
dot_half = size / 4.0
|
|
rl.draw_rectangle_rec(rl.Rectangle(cx - dot_half, cy - dot_half, size / 2.0, size / 2.0), color)
|
|
|
|
# 1. Soft Dashed Vertical Splitter (Blending/Transition Effect)
|
|
r = color.r if hasattr(color, "r") else color[0]
|
|
g = color.g if hasattr(color, "g") else color[1]
|
|
b = color.b if hasattr(color, "b") else color[2]
|
|
divider_color = rl.Color(r, g, b, 60) # ~24% opacity
|
|
dash_len = 1.0 * s
|
|
gap_len = 2.0 * s
|
|
curr_y = y_c - 16.0 * s
|
|
end_y = y_c + 12.0 * s
|
|
while curr_y < end_y:
|
|
rl.draw_line_ex(rl.Vector2(x_c, curr_y), rl.Vector2(x_c, min(curr_y + dash_len, end_y)), 1.5 * s, divider_color)
|
|
curr_y += dash_len + gap_len
|
|
|
|
# 2. Right Side (AI Circuit Traces & Pads)
|
|
# Trace 1 (Top - Aligned with roofline)
|
|
rl.draw_line_ex(rl.Vector2(x_c, y_c - 16.0 * s), rl.Vector2(x_c + 8.0 * s, y_c - 16.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 8.0 * s, y_c - 16.0 * s), rl.Vector2(x_c + 14.0 * s, y_c - 20.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 14.0 * s, y_c - 20.0 * s), rl.Vector2(x_c + 22.0 * s, y_c - 20.0 * s), 1.5 * s, color)
|
|
draw_pad(x_c + 24.0 * s, y_c - 20.0 * s, 3.5 * s)
|
|
|
|
# Trace 2 (Aligned with window bottom / beltline)
|
|
rl.draw_line_ex(rl.Vector2(x_c, y_c - 5.0 * s), rl.Vector2(x_c + 8.0 * s, y_c - 5.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 8.0 * s, y_c - 5.0 * s), rl.Vector2(x_c + 13.0 * s, y_c - 9.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 13.0 * s, y_c - 9.0 * s), rl.Vector2(x_c + 18.0 * s, y_c - 9.0 * s), 1.5 * s, color)
|
|
draw_pad(x_c + 20.0 * s, y_c - 9.0 * s, 3.5 * s)
|
|
|
|
# Trace 3 (Forked - Centered on door)
|
|
rl.draw_line_ex(rl.Vector2(x_c, y_c + 1.0 * s), rl.Vector2(x_c + 6.0 * s, y_c + 1.0 * s), 1.5 * s, color)
|
|
# Fork 3A (Up)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 6.0 * s, y_c + 1.0 * s), rl.Vector2(x_c + 10.0 * s, y_c - 2.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 10.0 * s, y_c - 2.0 * s), rl.Vector2(x_c + 16.0 * s, y_c - 2.0 * s), 1.5 * s, color)
|
|
draw_pad(x_c + 18.0 * s, y_c - 2.0 * s, 3.5 * s)
|
|
# Fork 3B (Down)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 6.0 * s, y_c + 1.0 * s), rl.Vector2(x_c + 10.0 * s, y_c + 4.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 10.0 * s, y_c + 4.0 * s), rl.Vector2(x_c + 16.0 * s, y_c + 4.0 * s), 1.5 * s, color)
|
|
draw_pad(x_c + 18.0 * s, y_c + 4.0 * s, 3.5 * s)
|
|
|
|
# Trace 4 (Lower door)
|
|
rl.draw_line_ex(rl.Vector2(x_c, y_c + 7.0 * s), rl.Vector2(x_c + 7.0 * s, y_c + 7.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 7.0 * s, y_c + 7.0 * s), rl.Vector2(x_c + 11.0 * s, y_c + 10.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 11.0 * s, y_c + 10.0 * s), rl.Vector2(x_c + 15.0 * s, y_c + 10.0 * s), 1.5 * s, color)
|
|
draw_pad(x_c + 17.0 * s, y_c + 10.0 * s, 3.5 * s)
|
|
|
|
# Trace 5 (Bottom - Aligned with rocker panel)
|
|
rl.draw_line_ex(rl.Vector2(x_c, y_c + 12.0 * s), rl.Vector2(x_c + 8.0 * s, y_c + 12.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 8.0 * s, y_c + 12.0 * s), rl.Vector2(x_c + 14.0 * s, y_c + 18.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 14.0 * s, y_c + 18.0 * s), rl.Vector2(x_c + 22.0 * s, y_c + 18.0 * s), 1.5 * s, color)
|
|
draw_pad(x_c + 24.0 * s, y_c + 18.0 * s, 3.5 * s)
|
|
|
|
# 3. Left Side (Car Front silhouette - Sleek modern profile with long sweeping windshield)
|
|
# Roof & Windshield (continuous Bezier curve profile)
|
|
p0_roof = rl.Vector2(x_c, y_c - 16.0 * s)
|
|
p1_roof = rl.Vector2(x_c - 12.0 * s, y_c - 16.0 * s)
|
|
p2_roof = rl.Vector2(x_c - 22.0 * s, y_c - 5.0 * s)
|
|
draw_bezier(p0_roof, p1_roof, p2_roof, 2.0 * s)
|
|
|
|
# Hood (short, streamlined)
|
|
p0_hood = rl.Vector2(x_c - 22.0 * s, y_c - 5.0 * s)
|
|
p1_hood = rl.Vector2(x_c - 25.0 * s, y_c - 4.5 * s)
|
|
p2_hood = rl.Vector2(x_c - 28.0 * s, y_c - 2.5 * s)
|
|
draw_bezier(p0_hood, p1_hood, p2_hood, 2.0 * s)
|
|
|
|
# Nose & Bumper Curve
|
|
p0_nose = rl.Vector2(x_c - 28.0 * s, y_c - 2.5 * s)
|
|
p1_nose = rl.Vector2(x_c - 31.0 * s, y_c + 1.0 * s)
|
|
p2_nose = rl.Vector2(x_c - 28.0 * s, y_c + 12.0 * s)
|
|
draw_bezier(p0_nose, p1_nose, p2_nose, 2.0 * s)
|
|
|
|
# Wheel Arch
|
|
draw_ellipse_arc(x_c - 21.0 * s, y_c + 12.0 * s, 7.0 * s, 7.0 * s, 0.0, 180.0, 360.0, 2.0 * s)
|
|
|
|
# Underbody / Rocker panel (aligned with Trace 5)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 14.0 * s, y_c + 12.0 * s), rl.Vector2(x_c, y_c + 12.0 * s), 2.0 * s, color)
|
|
|
|
# Wheel (hollow ring matching the arch)
|
|
rl.draw_ring(rl.Vector2(x_c - 21.0 * s, y_c + 12.0 * s), 3.5 * s, 5.0 * s, 0.0, 360.0, 24, color)
|
|
|
|
# Side Window Details (Parallel sloped wedge, open to the dashed divider at the rear to blend perfectly)
|
|
p0_win = rl.Vector2(x_c, y_c - 13.0 * s)
|
|
p1_win = rl.Vector2(x_c - 10.0 * s, y_c - 13.0 * s)
|
|
p2_win = rl.Vector2(x_c - 18.0 * s, y_c - 5.0 * s)
|
|
draw_bezier(p0_win, p1_win, p2_win, 1.5 * s)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 18.0 * s, y_c - 5.0 * s), rl.Vector2(x_c, y_c - 5.0 * s), 1.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 9.0 * s, y_c - 11.4 * s), rl.Vector2(x_c - 9.0 * s, y_c - 5.0 * s), 1.5 * s, color)
|
|
|
|
elif key == "first_aid":
|
|
# First Aid Kit Symbol
|
|
x_c = x + 30.0 * s
|
|
y_c = y + 30.0 * s
|
|
|
|
# Handle on top of the kit
|
|
draw_ellipse_arc(x_c, y_c - 10.0 * s, 6.0 * s, 4.0 * s, 0.0, 180.0, 360.0, 2.5 * s)
|
|
|
|
# Box outline with rounded corners
|
|
draw_ellipse_arc(x_c - 15.0 * s, y_c - 7.0 * s, 3.0 * s, 3.0 * s, 0.0, 180.0, 270.0, 2.5 * s)
|
|
draw_ellipse_arc(x_c + 15.0 * s, y_c - 7.0 * s, 3.0 * s, 3.0 * s, 0.0, 270.0, 360.0, 2.5 * s)
|
|
draw_ellipse_arc(x_c + 15.0 * s, y_c + 12.0 * s, 3.0 * s, 3.0 * s, 0.0, 0.0, 90.0, 2.5 * s)
|
|
draw_ellipse_arc(x_c - 15.0 * s, y_c + 12.0 * s, 3.0 * s, 3.0 * s, 0.0, 90.0, 180.0, 2.5 * s)
|
|
|
|
# Connecting lines for the box outline
|
|
rl.draw_line_ex(rl.Vector2(x_c - 15.0 * s, y_c - 10.0 * s), rl.Vector2(x_c + 15.0 * s, y_c - 10.0 * s), 2.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 15.0 * s, y_c + 15.0 * s), rl.Vector2(x_c + 15.0 * s, y_c + 15.0 * s), 2.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 18.0 * s, y_c - 7.0 * s), rl.Vector2(x_c - 18.0 * s, y_c + 12.0 * s), 2.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c + 18.0 * s, y_c - 7.0 * s), rl.Vector2(x_c + 18.0 * s, y_c + 12.0 * s), 2.5 * s, color)
|
|
|
|
# Cross in the center (centered at y_c + 2.5)
|
|
rl.draw_line_ex(rl.Vector2(x_c, y_c - 4.0 * s), rl.Vector2(x_c, y_c + 9.0 * s), 3.5 * s, color)
|
|
rl.draw_line_ex(rl.Vector2(x_c - 6.5 * s, y_c + 2.5 * s), rl.Vector2(x_c + 6.5 * s, y_c + 2.5 * s), 3.5 * s, color)
|
|
|
|
|
|
|