[V0_FILE]typescriptreact:file="components/dashboard.tsx" isMerged="true" "use client" import { useState, useEffect } from "react" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Battery, Truck, Activity } from "lucide-react" import FleetMap from "@/components/fleet-map" import AGVControls from "@/components/agv-controls" import PerformanceMetrics from "@/components/performance-metrics" import RouteOptimization from "@/components/route-optimization" import { type AGV, fetchAGVs, updateAGVRoute } from "@/lib/api" export default function Dashboard() { const [agvs, setAGVs] = useState([]) const [loading, setLoading] = useState(true) const [selectedAGV, setSelectedAGV] = useState(null) useEffect(() => { const fetchData = async () => { try { const data = await fetchAGVs() setAGVs(data) if (data.length > 0) { setSelectedAGV(data[0].id) } } catch (error) { console.error("Failed to fetch AGVs:", error) } finally { setLoading(false) } } fetchData() // Set up polling for real-time updates const interval = setInterval(fetchData, 5000) return () => clearInterval(interval) }, []) const handleRouteUpdate = async (agvId: string, routePoints: [number, number][]) => { try { await updateAGVRoute(agvId, routePoints) // Update local state setAGVs(agvs.map((agv) => (agv.id === agvId ? { ...agv, route: routePoints } : agv))) } catch (error) { console.error("Failed to update route:", error) } } return (

AGV Fleet Management System

Monitor and control your automated guided vehicles

System Online

Active AGVs

{agvs.filter((agv) => agv.status === "active").length}

Out of {agvs.length} total vehicles

Fleet Battery

{agvs.length > 0 ? `${Math.round(agvs.reduce((acc, agv) => acc + agv.batteryLevel, 0) / agvs.length)}%` : "N/A"}

Average battery level

Efficiency Score

87%

Based on route optimization

Fleet Visualization Real-time AGV positions and routes

Control Metrics Routes AGV Controls Performance Route Planning

) } [V0_FILE]typescriptreact:file="components/fleet-map.tsx" isMerged="true" "use client" import type React from "react" import { useRef, useEffect, useState } from "react" import { Button } from "@/components/ui/button" import { ZoomIn, ZoomOut, Maximize, Truck } from "lucide-react" import type { AGV } from "@/lib/api" import { cn } from "@/lib/utils" interface FleetMapProps { agvs: AGV[] selectedAGV: string | null onSelectAGV: (id: string) => void onUpdateRoute: (agvId: string, route: [number, number][]) => void } export default function FleetMap({ agvs, selectedAGV, onSelectAGV, onUpdateRoute }: FleetMapProps) { const canvasRef = useRef(null) const containerRef = useRef(null) const [zoom, setZoom] = useState(1) const [isDragging, setIsDragging] = useState(false) const [dragStart, setDragStart] = useState<{ x: number; y: number } | null>(null) const [offset, setOffset] = useState({ x: 0, y: 0 }) const [mapImage, setMapImage] = useState(null) // Load the warehouse map image useEffect(() => { const img = new Image() img.src = "/placeholder.svg?height=1000&width=1000" img.crossOrigin = "anonymous" img.onload = () => { setMapImage(img) } }, []) // Draw the map and AGVs useEffect(() => { if (!canvasRef.current || !mapImage) return const canvas = canvasRef.current const ctx = canvas.getContext("2d") if (!ctx) return // Set canvas dimensions to match container if (containerRef.current) { canvas.width = containerRef.current.clientWidth canvas.height = containerRef.current.clientHeight } // Clear canvas ctx.clearRect(0, 0, canvas.width, canvas.height) // Apply zoom and pan transformations ctx.save() ctx.translate(offset.x, offset.y) ctx.scale(zoom, zoom) // Draw warehouse map ctx.drawImage(mapImage, 0, 0, canvas.width / zoom, canvas.height / zoom) // Draw routes for all AGVs agvs.forEach((agv) => { if (agv.route && agv.route.length > 1) { ctx.beginPath() ctx.moveTo(agv.route[0][0], agv.route[0][1]) for (let i = 1; i < agv.route.length; i++) { ctx.lineTo(agv.route[i][0], agv.route[i][1]) } ctx.strokeStyle = agv.id === selectedAGV ? "#3b82f6" : "#6b7280" ctx.lineWidth = agv.id === selectedAGV ? 3 : 1 ctx.stroke() } }) // Draw AGVs agvs.forEach((agv) => { const [x, y] = agv.position // Draw AGV circle ctx.beginPath() ctx.arc(x, y, 10, 0, Math.PI * 2) ctx.fillStyle = agv.id === selectedAGV ? "#3b82f6" : "#6b7280" ctx.fill() // Draw AGV ID ctx.fillStyle = "#ffffff" ctx.font = "10px Arial" ctx.textAlign = "center" ctx.textBaseline = "middle" ctx.fillText(agv.id.slice(0, 2), x, y) // Draw battery indicator const batteryWidth = 20 const batteryHeight = 5 const batteryX = x - batteryWidth / 2 const batteryY = y + 15 ctx.fillStyle = "#1f2937" ctx.fillRect(batteryX, batteryY, batteryWidth, batteryHeight) ctx.fillStyle = agv.batteryLevel > 20 ? "#10b981" : "#ef4444" ctx.fillRect(batteryX, batteryY, batteryWidth * (agv.batteryLevel / 100), batteryHeight) }) ctx.restore() }, [agvs, selectedAGV, zoom, offset, mapImage]) // Handle mouse events for panning const handleMouseDown = (e: React.MouseEvent) => { setIsDragging(true) setDragStart({ x: e.clientX - offset.x, y: e.clientY - offset.y }) } const handleMouseMove = (e: React.MouseEvent) => { if (isDragging && dragStart) { setOffset({ x: e.clientX - dragStart.x, y: e.clientY - dragStart.y, }) } } const handleMouseUp = () => { setIsDragging(false) } // Handle canvas click to select AGV const handleCanvasClick = (e: React.MouseEvent) => { if (!canvasRef.current) return // Get click position relative to canvas const rect = canvasRef.current.getBoundingClientRect() const x = (e.clientX - rect.left - offset.x) / zoom const y = (e.clientY - rect.top - offset.y) / zoom // Find if we clicked on an AGV for (const agv of agvs) { const [agvX, agvY] = agv.position const distance = Math.sqrt(Math.pow(x - agvX, 2) + Math.pow(y - agvY, 2)) if (distance <= 10) { onSelectAGV(agv.id) return } } } return (

) } [V0_FILE]typescriptreact:file="components/agv-controls.tsx" isMerged="true" "use client" import { useState } from "react" import { Button } from "@/components/ui/button" import { Slider } from "@/components/ui/slider" import { Battery, Package, Play, Pause, RotateCcw, AlertTriangle, ChevronRight } from "lucide-react" import { type AGV, updateAGVStatus } from "@/lib/api" import { Progress } from "@/components/ui/progress" interface AGVControlsProps { agvs: AGV[] selectedAGV: string | null onSelectAGV: (id: string) => void } export default function AGVControls({ agvs, selectedAGV, onSelectAGV }: AGVControlsProps) { const [speed, setSpeed] = useState(50) const [isUpdating, setIsUpdating] = useState(false) const selectedAGVData = agvs.find((agv) => agv.id === selectedAGV) const handleStatusChange = async (status: "active" | "paused" | "charging") => { if (!selectedAGV) return setIsUpdating(true) try { await updateAGVStatus(selectedAGV, status) } catch (error) { console.error("Failed to update AGV status:", error) } finally { setIsUpdating(false) } } if (!selectedAGVData) { return (

No AGV selected

Select an AGV from the map

) } return (

AGV #{selectedAGVData.id}

Status:{" "} {selectedAGVData.status.charAt(0).toUpperCase() + selectedAGVData.status.slice(1)}

Battery Level

{selectedAGVData.batteryLevel}%

Load Capacity

{selectedAGVData.loadCapacity}%

Speed Control {speed}%

setSpeed(value[0])} />

Current Mission

{selectedAGVData.currentMission ? (

{selectedAGVData.currentMission.title} {selectedAGVData.currentMission.priority}

{selectedAGVData.currentMission.description}

Progress: {selectedAGVData.currentMission.progress}% ETA: {selectedAGVData.currentMission.eta}

) : (

No active mission

)}

Next Waypoints

{selectedAGVData.waypoints && selectedAGVData.waypoints.length > 0 ? ( selectedAGVData.waypoints.map((waypoint, index) => (

{index + 1}

{waypoint.name}

)) ) : (

No waypoints set

)}

) } [V0_FILE]typescriptreact:file="components/performance-metrics.tsx" isMerged="true" "use client" import { useEffect, useRef } from "react" import { Card, CardContent } from "@/components/ui/card" import type { AGV } from "@/lib/api" interface PerformanceMetricsProps { agvs: AGV[] } export default function PerformanceMetrics({ agvs }: PerformanceMetricsProps) { const batteryChartRef = useRef(null) const efficiencyChartRef = useRef(null) // Draw battery chart useEffect(() => { if (!batteryChartRef.current || agvs.length === 0) return const canvas = batteryChartRef.current const ctx = canvas.getContext("2d") if (!ctx) return // Clear canvas ctx.clearRect(0, 0, canvas.width, canvas.height) const padding = 20 const chartWidth = canvas.width - padding * 2 const chartHeight = canvas.height - padding * 2 const barWidth = chartWidth / agvs.length - 10 // Draw axes ctx.beginPath() ctx.moveTo(padding, padding) ctx.lineTo(padding, canvas.height - padding) ctx.lineTo(canvas.width - padding, canvas.height - padding) ctx.strokeStyle = "#4b5563" ctx.stroke() // Draw battery levels agvs.forEach((agv, index) => { const barHeight = (chartHeight * agv.batteryLevel) / 100 const x = padding + index * (barWidth + 10) const y = canvas.height - padding - barHeight // Draw bar ctx.fillStyle = agv.batteryLevel > 20 ? "#10b981" : "#ef4444" ctx.fillRect(x, y, barWidth, barHeight) // Draw AGV ID ctx.fillStyle = "#ffffff" ctx.font = "10px Arial" ctx.textAlign = "center" ctx.fillText(agv.id.slice(0, 4), x + barWidth / 2, canvas.height - padding + 15) }) // Draw y-axis labels ctx.fillStyle = "#9ca3af" ctx.font = "10px Arial" ctx.textAlign = "right" for (let i = 0; i <= 100; i += 20) { const y = canvas.height - padding - (chartHeight * i) / 100 ctx.fillText(`${i}%`, padding - 5, y + 3) } }, [agvs]) // Draw efficiency chart useEffect(() => { if (!efficiencyChartRef.current || agvs.length === 0) return const canvas = efficiencyChartRef.current const ctx = canvas.getContext("2d") if (!ctx) return // Clear canvas ctx.clearRect(0, 0, canvas.width, canvas.height) const padding = 20 const chartWidth = canvas.width - padding * 2 const chartHeight = canvas.height - padding * 2 // Generate some sample efficiency data const efficiencyData = agvs.map((agv) => ({ id: agv.id, routeEfficiency: Math.random() * 30 + 70, // Random value between 70-100 timeEfficiency: Math.random() * 40 + 60, // Random value between 60-100 })) // Draw axes ctx.beginPath() ctx.moveTo(padding, padding) ctx.lineTo(padding, canvas.height - padding) ctx.lineTo(canvas.width - padding, canvas.height - padding) ctx.strokeStyle = "#4b5563" ctx.stroke() const barWidth = chartWidth / efficiencyData.length / 2 - 10 // Draw efficiency bars efficiencyData.forEach((data, index) => { const x1 = padding + index * (barWidth * 2 + 20) const x2 = x1 + barWidth + 5 const routeBarHeight = (chartHeight * data.routeEfficiency) / 100 const timeBarHeight = (chartHeight * data.timeEfficiency) / 100 const y1 = canvas.height - padding - routeBarHeight const y2 = canvas.height - padding - timeBarHeight // Draw route efficiency bar ctx.fillStyle = "#3b82f6" ctx.fillRect(x1, y1, barWidth, routeBarHeight) // Draw time efficiency bar ctx.fillStyle = "#8b5cf6" ctx.fillRect(x2, y2, barWidth, timeBarHeight) // Draw AGV ID ctx.fillStyle = "#ffffff" ctx.font = "10px Arial" ctx.textAlign = "center" ctx.fillText(data.id.slice(0, 4), x1 + barWidth + 2.5, canvas.height - padding + 15) }) // Draw legend ctx.fillStyle = "#3b82f6" ctx.fillRect(padding, padding, 10, 10) ctx.fillStyle = "#ffffff" ctx.textAlign = "left" ctx.fillText("Route Efficiency", padding + 15, padding + 8) ctx.fillStyle = "#8b5cf6" ctx.fillRect(padding, padding + 15, 10, 10) ctx.fillStyle = "#ffffff" ctx.fillText("Time Efficiency", padding + 15, padding + 23) // Draw y-axis labels ctx.fillStyle = "#9ca3af" ctx.font = "10px Arial" ctx.textAlign = "right" for (let i = 0; i <= 100; i += 20) { const y = canvas.height - padding - (chartHeight * i) / 100 ctx.fillText(`${i}%`, padding - 5, y + 3) } }, [agvs]) return (

Battery Levels

Efficiency Metrics

) } [V0_FILE]typescriptreact:file="components/route-optimization.tsx" isMerged="true" "use client" import { useState } from "react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { RotateCw, Zap, Battery, Package, Clock, Plus, Trash2 } from "lucide-react" import type { AGV } from "@/lib/api" import { Switch } from "@/components/ui/switch" import { Label } from "@/components/ui/label" interface RouteOptimizationProps { agvs: AGV[] selectedAGV: string | null onUpdateRoute: (agvId: string, route: [number, number][]) => void } export default function RouteOptimization({ agvs, selectedAGV, onUpdateRoute }: RouteOptimizationProps) { const [optimizationMethod, setOptimizationMethod] = useState("shortest") const [isOptimizing, setIsOptimizing] = useState(false) const [waypoints, setWaypoints] = useState<{ x: number; y: number; name: string }[]>([ { x: 100, y: 100, name: "Pickup Zone A" }, { x: 200, y: 150, name: "Assembly Line 1" }, { x: 300, y: 100, name: "Delivery Zone B" }, ]) const selectedAGVData = agvs.find((agv) => agv.id === selectedAGV) const handleOptimize = () => { if (!selectedAGV) return setIsOptimizing(true) // Simulate optimization delay setTimeout(() => { // Convert waypoints to route format const optimizedRoute: [number, number][] = waypoints.map((wp) => [wp.x, wp.y]) // Add current position as first point if (selectedAGVData) { optimizedRoute.unshift(selectedAGVData.position) } onUpdateRoute(selectedAGV, optimizedRoute) setIsOptimizing(false) }, 1500) } const addWaypoint = () => { setWaypoints([...waypoints, { x: 150, y: 150, name: `Waypoint ${waypoints.length + 1}` }]) } const removeWaypoint = (index: number) => { setWaypoints(waypoints.filter((_, i) => i !== index)) } const updateWaypoint = (index: number, field: "x" | "y" | "name", value: string | number) => { const newWaypoints = [...waypoints] newWaypoints[index] = { ...newWaypoints[index], [field]: field === "name" ? value : Number(value), } setWaypoints(newWaypoints) } if (!selectedAGVData) { return (

Select an AGV to optimize routes

) } return (

Optimization Method

Avoid known obstacles

Dynamic re-routing

Waypoints

{waypoints.map((waypoint, index) => (

updateWaypoint(index, "name", e.target.value)} className="h-8 text-xs" placeholder="Waypoint name" /> updateWaypoint(index, "x", e.target.value)} className="h-8 text-xs" placeholder="X" /> updateWaypoint(index, "y", e.target.value)} className="h-8 text-xs" placeholder="Y" />

))}

) } [V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true" import AGVSimulation from "@/components/agv-simulation" export default function Home() { return (

) } [V0_FILE]typescriptreact:file="components/agv-simulation.tsx" "use client" import { useState, useEffect } from "react" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Battery, Truck, Activity, Play, Pause, RotateCcw } from "lucide-react" import { Button } from "@/components/ui/button" import RouteMap from "@/components/route-map" import AGVStatus from "@/components/agv-status" import PayloadSchedule from "@/components/payload-schedule" import SimulationResults from "@/components/simulation-results" import ExecutionLogs from "@/components/execution-logs" import { fetchRouteMap, fetchPayloads, startSimulation, pauseSimulation, resetSimulation } from "@/lib/api" import type { AGV, Payload, SimulationState, RouteNode, ExecutionLog } from "@/lib/types" export default function AGVSimulation() { const [routeMap, setRouteMap] = useState([]) const [payloads, setPayloads] = useState([]) const [agvs, setAGVs] = useState([]) const [simulationState, setSimulationState] = useState("idle") const [currentTime, setCurrentTime] = useState(0) const [executionLogs, setExecutionLogs] = useState([]) const [simulationResults, setSimulationResults] = useState(null) const [loading, setLoading] = useState(true) // Fetch initial data useEffect(() => { const fetchData = async () => { try { const [mapData, payloadData] = await Promise.all([fetchRouteMap(), fetchPayloads()]) setRouteMap(mapData.nodes) setPayloads(payloadData) // Initialize AGVs based on problem statement setAGVs([ { id: "agv_1", position: 1, // Station 1 batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, { id: "agv_2", position: 3, // Station 3 batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, { id: "agv_3", position: 7, // Station 7 batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, ]) } catch (error) { console.error("Failed to fetch initial data:", error) } finally { setLoading(false) } } fetchData() }, []) // Handle simulation control const handleStartSimulation = async () => { try { const response = await startSimulation() setSimulationState("running") // Start the simulation loop const intervalId = setInterval(async () => { try { const { agvs: updatedAGVs, currentTime: updatedTime, logs: newLogs, state: newState, results, } = await fetchSimulationUpdate() setAGVs(updatedAGVs) setCurrentTime(updatedTime) if (newLogs && newLogs.length > 0) { setExecutionLogs((prev) => [...prev, ...newLogs]) } if (newState === "completed") { setSimulationState("completed") setSimulationResults(results) clearInterval(intervalId) } } catch (error) { console.error("Error updating simulation:", error) clearInterval(intervalId) } }, 1000) // Update every second // Cleanup interval on component unmount return () => clearInterval(intervalId) } catch (error) { console.error("Failed to start simulation:", error) } } const handlePauseSimulation = async () => { try { await pauseSimulation() setSimulationState("paused") } catch (error) { console.error("Failed to pause simulation:", error) } } const handleResetSimulation = async () => { try { await resetSimulation() setSimulationState("idle") setCurrentTime(0) setExecutionLogs([]) setSimulationResults(null) // Reset AGVs to initial state setAGVs([ { id: "agv_1", position: 1, batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, { id: "agv_2", position: 3, batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, { id: "agv_3", position: 7, batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, ]) } catch (error) { console.error("Failed to reset simulation:", error) } } // Mock function to fetch simulation updates const fetchSimulationUpdate = async () => { // In a real implementation, this would be an API call // For now, we'll simulate some movement and battery drain const updatedAGVs = agvs.map((agv) => { // Simulate AGV movement and battery drain if (agv.status === "moving" && agv.path.length > 0) { const nextPosition = agv.path[0] const updatedPath = agv.path.slice(1) // Calculate battery drain based on load const batteryDrain = agv.currentLoad === 0 ? 2 : 2 + (agv.currentLoad / 10) * 3 return { ...agv, position: nextPosition, path: updatedPath, batteryLevel: Math.max(0, agv.batteryLevel - batteryDrain), status: updatedPath.length === 0 ? "idle" : "moving", } } else if (agv.status === "charging") { // Simulate charging return { ...agv, batteryLevel: Math.min(100, agv.batteryLevel + 6.67), // 15 minutes to fully charge = ~6.67% per minute status: agv.batteryLevel >= 99 ? "idle" : "charging", } } return agv }) // Generate some mock logs const newLogs = [] if (Math.random() > 0.7) { const randomAGV = updatedAGVs[Math.floor(Math.random() * updatedAGVs.length)] if (randomAGV.status === "moving") { newLogs.push({ id: `log-${Date.now()}`, timestamp: formatTime(currentTime + 1), message: `${randomAGV.id}-${randomAGV.position}-${randomAGV.path[0] || randomAGV.position}-${formatTime(currentTime + 1)}-${randomAGV.currentLoad}-payload_${Math.floor(Math.random() * 10) + 1}`, }) } } // Check if simulation is complete (for demo purposes, end after 60 minutes) const isCompleted = currentTime >= 60 // Generate results if simulation is complete const results = isCompleted ? { totalExecutionTime: 60, averageDeliveryTimes: { priority1: 12, priority2: 18, priority3: 25, }, chargeCounts: { agv_1: 2, agv_2: 1, agv_3: 3, }, } : null return { agvs: updatedAGVs, currentTime: currentTime + 1, logs: newLogs, state: isCompleted ? "completed" : "running", results, } } // Format time as HH:MM const formatTime = (minutes: number) => { const hours = Math.floor(minutes / 60) const mins = minutes % 60 return `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}` } if (loading) { return (

) } return (

AGV Fleet Management Simulation

Optimize AGV scheduling for efficient payload delivery

{simulationState === "running" ? "Simulation Running" : simulationState === "paused" ? "Simulation Paused" : simulationState === "completed" ? "Simulation Completed" : "Simulation Ready"}

Time: {formatTime(currentTime)}

AGVs in Operation

{agvs.filter((agv) => agv.status === "moving").length}

Out of {agvs.length} total vehicles

Fleet Battery

{Math.round(agvs.reduce((acc, agv) => acc + agv.batteryLevel, 0) / agvs.length)}%

Average battery level

Payloads Delivered

{executionLogs.length}

Out of {payloads.length} total payloads

Route Map Visualization Real-time AGV positions and routes

AGVs Payloads Results AGV Status Payload Schedule Simulation Results

Execution Logs Real-time logs of AGV operations

) } [V0_FILE]typescriptreact:file="components/route-map.tsx" "use client" import type React from "react" import { useRef, useEffect, useState } from "react" import { Button } from "@/components/ui/button" import { ZoomIn, ZoomOut, Maximize } from "lucide-react" import type { AGV, RouteNode } from "@/lib/types" interface RouteMapProps { nodes: RouteNode[] agvs: AGV[] chargingStation: number } export default function RouteMap({ nodes, agvs, chargingStation }: RouteMapProps) { const canvasRef = useRef(null) const containerRef = useRef(null) const [zoom, setZoom] = useState(1) const [isDragging, setIsDragging] = useState(false) const [dragStart, setDragStart] = useState<{ x: number; y: number } | null>(null) const [offset, setOffset] = useState({ x: 0, y: 0 }) // Draw the map and AGVs useEffect(() => { if (!canvasRef.current || nodes.length === 0) return const canvas = canvasRef.current const ctx = canvas.getContext("2d") if (!ctx) return // Set canvas dimensions to match container if (containerRef.current) { canvas.width = containerRef.current.clientWidth canvas.height = containerRef.current.clientHeight } // Clear canvas ctx.clearRect(0, 0, canvas.width, canvas.height) // Apply zoom and pan transformations ctx.save() ctx.translate(offset.x, offset.y) ctx.scale(zoom, zoom) // Calculate node positions (for a circular layout) const centerX = canvas.width / (2 * zoom) const centerY = canvas.height / (2 * zoom) const radius = Math.min(centerX, centerY) * 0.7 const nodePositions = nodes.map((node, index) => { const angle = (2 * Math.PI * index) / nodes.length - Math.PI / 2 return { id: node.id, x: centerX + radius * Math.cos(angle), y: centerY + radius * Math.sin(angle), connections: node.connections, } }) // Draw connections between nodes ctx.strokeStyle = "#4b5563" ctx.lineWidth = 2 nodePositions.forEach((node) => { node.connections.forEach((connectionId) => { const connectedNode = nodePositions.find((n) => n.id === connectionId) if (connectedNode) { ctx.beginPath() ctx.moveTo(node.x, node.y) ctx.lineTo(connectedNode.x, connectedNode.y) ctx.stroke() } }) }) // Draw nodes nodePositions.forEach((node) => { ctx.beginPath() ctx.arc(node.x, node.y, 20, 0, Math.PI * 2) // Highlight charging station if (node.id === chargingStation) { ctx.fillStyle = "#10b981" // Green for charging station } else { ctx.fillStyle = "#1f2937" // Dark gray for regular stations } ctx.fill() ctx.strokeStyle = "#6b7280" ctx.lineWidth = 2 ctx.stroke() // Draw node ID ctx.fillStyle = "#ffffff" ctx.font = "14px Arial" ctx.textAlign = "center" ctx.textBaseline = "middle" ctx.fillText(node.id.toString(), node.x, node.y) }) // Draw AGVs agvs.forEach((agv) => { const agvNode = nodePositions.find((node) => node.id === agv.position) if (!agvNode) return // Draw AGV ctx.beginPath() // Draw AGV as a triangle pointing in the direction of movement if (agv.path && agv.path.length > 0) { const nextNode = nodePositions.find((node) => node.id === agv.path[0]) if (nextNode) { // Calculate angle between current and next node const angle = Math.atan2(nextNode.y - agvNode.y, nextNode.x - agvNode.x) // Draw triangle const size = 15 ctx.moveTo(agvNode.x + size * Math.cos(angle), agvNode.y + size * Math.sin(angle)) ctx.lineTo( agvNode.x + size * Math.cos(angle + (2 * Math.PI) / 3), agvNode.y + size * Math.sin(angle + (2 * Math.PI) / 3), ) ctx.lineTo( agvNode.x + size * Math.cos(angle + (4 * Math.PI) / 3), agvNode.y + size * Math.sin(angle + (4 * Math.PI) / 3), ) } else { // Fallback to circle if next node not found ctx.arc(agvNode.x, agvNode.y, 15, 0, Math.PI * 2) } } else { // Draw as circle if not moving ctx.arc(agvNode.x, agvNode.y, 15, 0, Math.PI * 2) } // Color based on status if (agv.status === "moving") { ctx.fillStyle = "#3b82f6" // Blue for moving } else if (agv.status === "charging") { ctx.fillStyle = "#10b981" // Green for charging } else { ctx.fillStyle = "#6b7280" // Gray for idle } ctx.fill() // Draw AGV ID ctx.fillStyle = "#ffffff" ctx.font = "10px Arial" ctx.textAlign = "center" ctx.textBaseline = "middle" ctx.fillText(agv.id.replace("agv_", ""), agvNode.x, agvNode.y) // Draw battery indicator const batteryWidth = 20 const batteryHeight = 5 const batteryX = agvNode.x - batteryWidth / 2 const batteryY = agvNode.y + 20 ctx.fillStyle = "#1f2937" ctx.fillRect(batteryX, batteryY, batteryWidth, batteryHeight) ctx.fillStyle = agv.batteryLevel > 20 ? "#10b981" : "#ef4444" ctx.fillRect(batteryX, batteryY, batteryWidth * (agv.batteryLevel / 100), batteryHeight) // Draw load indicator if carrying payload if (agv.currentLoad > 0) { const loadWidth = 20 const loadHeight = 5 const loadX = agvNode.x - loadWidth / 2 const loadY = agvNode.y + 30 ctx.fillStyle = "#1f2937" ctx.fillRect(loadX, loadY, loadWidth, loadHeight) ctx.fillStyle = "#f59e0b" ctx.fillRect( loadX, loadY, loadWidth * (agv.currentLoad / 10), // Max load is 10 loadHeight, ) } // Draw path if AGV is moving if (agv.path && agv.path.length > 0) { ctx.beginPath() ctx.moveTo(agvNode.x, agvNode.y) let currentNodeId = agv.position for (const nextNodeId of agv.path) { const nextNode = nodePositions.find((node) => node.id === nextNodeId) if (nextNode) { ctx.lineTo(nextNode.x, nextNode.y) currentNodeId = nextNodeId } } ctx.strokeStyle = "#3b82f6" ctx.lineWidth = 2 ctx.setLineDash([5, 3]) ctx.stroke() ctx.setLineDash([]) } }) ctx.restore() }, [nodes, agvs, chargingStation, zoom, offset]) // Handle mouse events for panning const handleMouseDown = (e: React.MouseEvent) => { setIsDragging(true) setDragStart({ x: e.clientX - offset.x, y: e.clientY - offset.y }) } const handleMouseMove = (e: React.MouseEvent) => { if (isDragging && dragStart) { setOffset({ x: e.clientX - dragStart.x, y: e.clientY - dragStart.y, }) } } const handleMouseUp = () => { setIsDragging(false) } return (

) } [V0_FILE]typescriptreact:file="components/agv-status.tsx" "use client" import { Progress } from "@/components/ui/progress" import { Battery, Package, Truck } from "lucide-react" import type { AGV } from "@/lib/types" interface AGVStatusProps { agvs: AGV[] } export default function AGVStatus({ agvs }: AGVStatusProps) { return (

{agvs.map((agv) => (

{agv.id}

{agv.status.charAt(0).toUpperCase() + agv.status.slice(1)}

Battery Level

{agv.batteryLevel}%

20 ? "bg-green-500" : "bg-red-500"} />

Current Load

{agv.currentLoad}/10

Current Position: Station {agv.position}

{agv.path && agv.path.length > 0 && (

Next: {agv.path.map((station) => `Station ${station}`).join(" → ")}

)}

))}

) } [V0_FILE]typescriptreact:file="components/payload-schedule.tsx" "use client" import { Badge } from "@/components/ui/badge" import type { Payload } from "@/lib/types" interface PayloadScheduleProps { payloads: Payload[] } export default function PayloadSchedule({ payloads }: PayloadScheduleProps) { // Sort payloads by priority (1 is highest) const sortedPayloads = [...payloads].sort((a, b) => a.priority - b.priority) return (

{sortedPayloads.map((payload) => (

{payload.id}

From Station {payload.source} to Station {payload.destination}

Weight: {payload.weight} units

Priority {payload.priority}

{payload.status === "pending" ? "Pending" : payload.status === "in_progress" ? "In Progress" : payload.status === "completed" ? "Completed" : "Unknown"}

))} {payloads.length === 0 &&

No payloads available

}

) } [V0_FILE]typescriptreact:file="components/execution-logs.tsx" "use client" import { useEffect, useRef } from "react" import type { ExecutionLog } from "@/lib/types" interface ExecutionLogsProps { logs: ExecutionLog[] } export default function ExecutionLogs({ logs }: ExecutionLogsProps) { const logsEndRef = useRef(null) // Auto-scroll to bottom when new logs are added useEffect(() => { if (logsEndRef.current) { logsEndRef.current.scrollIntoView({ behavior: "smooth" }) } }, [logs]) return (

{logs.length === 0 ? (

No execution logs yet. Start the simulation to see logs.

) : ( logs.map((log) => (

[{log.timestamp}]{" "} {log.message}

)) )}

) } [V0_FILE]typescriptreact:file="components/simulation-results.tsx" "use client" import { Card, CardContent } from "@/components/ui/card" import { ChartContainer, ChartTooltip, ChartTooltipContent } from "@/components/ui/chart" import { Bar, BarChart, CartesianGrid, XAxis, YAxis } from "recharts" interface SimulationResultsProps { results: { totalExecutionTime: number averageDeliveryTimes: { priority1: number priority2: number priority3: number } chargeCounts: { agv_1: number agv_2: number agv_3: number } } | null } export default function SimulationResults({ results }: SimulationResultsProps) { if (!results) { return (

Simulation results will appear here once the simulation is completed.

) } const deliveryTimeData = [ { priority: "Priority 1", time: results.averageDeliveryTimes.priority1 }, { priority: "Priority 2", time: results.averageDeliveryTimes.priority2 }, { priority: "Priority 3", time: results.averageDeliveryTimes.priority3 }, ] const chargeCountData = [ { agv: "AGV 1", count: results.chargeCounts.agv_1 }, { agv: "AGV 2", count: results.chargeCounts.agv_2 }, { agv: "AGV 3", count: results.chargeCounts.agv_3 }, ] return (

Total Execution Time

{results.totalExecutionTime} minutes

Average Delivery Time by Priority

} />

Charging Count by AGV

} />

) } [V0_FILE]typescriptreact:file="lib/types.ts" // AGV Types export interface AGV { id: string position: number batteryLevel: number currentLoad: number status: "idle" | "moving" | "charging" path: number[] payloads: string[] } // Payload Types export interface Payload { id: string source: number destination: number weight: number priority: 1 | 2 | 3 status: "pending" | "in_progress" | "completed" } // Route Map Types export interface RouteNode { id: number connections: number[] } // Simulation Types export type SimulationState = "idle" | "running" | "paused" | "completed" // Execution Log Types export interface ExecutionLog { id: string timestamp: string message: string } [V0_FILE]typescriptreact:file="app/globals.css" isEdit="true" @tailwind base; @tailwind components; @tailwind utilities; @layer base { :root { --background: 0 0% 100%; --foreground: 222.2 84% 4.9%; --card: 0 0% 100%; --card-foreground: 222.2 84% 4.9%; --popover: 0 0% 100%; --popover-foreground: 222.2 84% 4.9%; --primary: 221.2 83.2% 53.3%; --primary-foreground: 210 40% 98%; --secondary: 210 40% 96.1%; --secondary-foreground: 222.2 47.4% 11.2%; --muted: 210 40% 96.1%; --muted-foreground: 215.4 16.3% 46.9%; --accent: 210 40% 96.1%; --accent-foreground: 222.2 47.4% 11.2%; --destructive: 0 84.2% 60.2%; --destructive-foreground: 210 40% 98%; --border: 214.3 31.8% 91.4%; --input: 214.3 31.8% 91.4%; --ring: 222.2 84% 4.9%; --radius: 0.5rem; --chart-1: 221.2 83.2% 53.3%; --chart-2: 142.1 76.2% 36.3%; } .dark { --background: 222.2 84% 4.9%; --foreground: 210 40% 98%; --card: 222.2 84% 4.9%; --card-foreground: 210 40% 98%; --popover: 222.2 84% 4.9%; --popover-foreground: 210 40% 98%; --primary: 217.2 91.2% 59.8%; --primary-foreground: 222.2 47.4% 11.2%; --secondary: 217.2 32.6% 17.5%; --secondary-foreground: 210 40% 98%; --muted: 217.2 32.6% 17.5%; --muted-foreground: 215 20.2% 65.1%; --accent: 217.2 32.6% 17.5%; --accent-foreground: 210 40% 98%; --destructive: 0 62.8% 30.6%; --destructive-foreground: 210 40% 98%; --border: 217.2 32.6% 17.5%; --input: 217.2 32.6% 17.5%; --ring: 212.7 26.8% 83.9%; } } @layer base { * { @apply border-border; } body { @apply bg-background text-foreground; } } [V0_FILE]typescriptreact:file="tailwind.config.js" isEdit="true" /** @type {import('tailwindcss').Config} */ module.exports = { darkMode: ["class"], content: [ "./pages/**/*.{ts,tsx}", "./components/**/*.{ts,tsx}", "./app/**/*.{ts,tsx}", "./src/**/*.{ts,tsx}", "*.{js,ts,jsx,tsx,mdx}", ], theme: { container: { center: true, padding: "2rem", screens: { "2xl": "1400px", }, }, extend: { colors: { border: "hsl(var(--border))", input: "hsl(var(--input))", ring: "hsl(var(--ring))", background: "hsl(var(--background))", foreground: "hsl(var(--foreground))", primary: { DEFAULT: "hsl(var(--primary))", foreground: "hsl(var(--primary-foreground))", }, secondary: { DEFAULT: "hsl(var(--secondary))", foreground: "hsl(var(--secondary-foreground))", }, destructive: { DEFAULT: "hsl(var(--destructive))", foreground: "hsl(var(--destructive-foreground))", }, muted: { DEFAULT: "hsl(var(--muted))", foreground: "hsl(var(--muted-foreground))", }, accent: { DEFAULT: "hsl(var(--accent))", foreground: "hsl(var(--accent-foreground))", }, popover: { DEFAULT: "hsl(var(--popover))", foreground: "hsl(var(--popover-foreground))", }, card: { DEFAULT: "hsl(var(--card))", foreground: "hsl(var(--card-foreground))", }, }, borderRadius: { lg: "var(--radius)", md: "calc(var(--radius) - 2px)", sm: "calc(var(--radius) - 4px)", }, keyframes: { "accordion-down": { from: { height: 0 }, to: { height: "var(--radix-accordion-content-height)" }, }, "accordion-up": { from: { height: "var(--radix-accordion-content-height)" }, to: { height: 0 }, }, }, animation: { "accordion-down": "accordion-down 0.2s ease-out", "accordion-up": "accordion-up 0.2s ease-out", }, }, }, plugins: [require("tailwindcss-animate")], } [V0_FILE]javascript:file="server/index.js" type="nodejs" import express from "express" import cors from "cors" import mongoose from "mongoose" import { createServer } from "http" import { Server } from "socket.io" import { dijkstra } from "./algorithms/pathfinding.js" import { AGVModel } from "./models/agv.js" import { PayloadModel } from "./models/payload.js" import { RouteMapModel } from "./models/routeMap.js" import { LogModel } from "./models/log.js" import { simulationRoutes } from "./routes/simulation.js" import { agvRoutes } from "./routes/agv.js" import { payloadRoutes } from "./routes/payload.js" import { routeMapRoutes } from "./routes/routeMap.js" import { logRoutes } from "./routes/log.js" // Initialize Express app const app = express() const PORT = process.env.PORT || 5000 // Middleware app.use(cors()) app.use(express.json()) // Create HTTP server const server = createServer(app) // Initialize Socket.io const io = new Server(server, { cors: { origin: "*", methods: ["GET", "POST"], }, }) // Connect to MongoDB mongoose .connect("mongodb://localhost:27017/agv_fleet_management", { useNewUrlParser: true, useUnifiedTopology: true, }) .then(() => console.log("Connected to MongoDB")) .catch((err) => console.error("MongoDB connection error:", err)) // Routes app.use("/api/simulation", simulationRoutes) app.use("/api/agvs", agvRoutes) app.use("/api/payloads", payloadRoutes) app.use("/api/route-map", routeMapRoutes) app.use("/api/logs", logRoutes) // Simulation state let simulationRunning = false let simulationTime = 0 let simulationInterval = null // Initialize route map const initializeRouteMap = async () => { const existingMap = await RouteMapModel.findOne() if (!existingMap) { const routeMap = new RouteMapModel({ nodes: [ { id: 1, connections: [2, 3, 4], x: 200, y: 100 }, { id: 2, connections: [1, 5], x: 100, y: 200 }, { id: 3, connections: [1, 5, 6], x: 200, y: 200 }, { id: 4, connections: [1, 7], x: 300, y: 200 }, { id: 5, connections: [2, 3, 8], x: 200, y: 300 }, { id: 6, connections: [3, 9], x: 100, y: 300 }, { id: 7, connections: [4, 8], x: 300, y: 300 }, { id: 8, connections: [5, 7, 9], x: 200, y: 400 }, { id: 9, connections: [6, 8], x: 300, y: 400 }, // Charging station ], }) await routeMap.save() console.log("Route map initialized") } } // Initialize AGVs const initializeAGVs = async () => { const existingAGVs = await AGVModel.find() if (existingAGVs.length === 0) { const agvs = [ { id: "agv_1", position: 1, // Station 1 batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, { id: "agv_2", position: 3, // Station 3 batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, { id: "agv_3", position: 7, // Station 7 batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, ] await AGVModel.insertMany(agvs) console.log("AGVs initialized") } } // Initialize payloads const initializePayloads = async () => { const existingPayloads = await PayloadModel.find() if (existingPayloads.length === 0) { const payloads = [ { id: "payload_1", source: 7, destination: 1, weight: 10, priority: 1, status: "pending" }, { id: "payload_2", source: 3, destination: 9, weight: 5, priority: 2, status: "pending" }, { id: "payload_3", source: 1, destination: 5, weight: 8, priority: 1, status: "pending" }, { id: "payload_4", source: 4, destination: 2, weight: 3, priority: 3, status: "pending" }, { id: "payload_5", source: 6, destination: 8, weight: 7, priority: 2, status: "pending" }, { id: "payload_6", source: 9, destination: 3, weight: 4, priority: 3, status: "pending" }, { id: "payload_7", source: 2, destination: 7, weight: 9, priority: 1, status: "pending" }, { id: "payload_8", source: 5, destination: 4, weight: 6, priority: 2, status: "pending" }, { id: "payload_9", source: 8, destination: 6, weight: 2, priority: 3, status: "pending" }, { id: "payload_10", source: 3, destination: 1, weight: 5, priority: 1, status: "pending" }, ] await PayloadModel.insertMany(payloads) console.log("Payloads initialized") } } // Initialize data const initializeData = async () => { await initializeRouteMap() await initializeAGVs() await initializePayloads() } // Calculate time to travel between nodes const calculateTravelTime = (load) => { // Time taken by an AGV to cross 1 unit distance with 0 load = 5 minutes // Time taken by an AGV to cross 1 unit distance with 10 load = 10 minutes // Linear interpolation for loads between 0 and 10 return 5 + (load / 10) * 5 } // Update AGV positions and status const updateAGVs = async () => { const agvs = await AGVModel.find() const routeMap = await RouteMapModel.findOne() for (const agv of agvs) { if (agv.status === "moving" && agv.path.length > 0) { // Get current and next node const currentNode = agv.position const nextNode = agv.path[0] // Check if there's a direct connection between current and next node const currentNodeData = routeMap.nodes.find((node) => node.id === currentNode) if (!currentNodeData || !currentNodeData.connections.includes(nextNode)) { console.error(`Invalid path: No direct connection from ${currentNode} to ${nextNode}`) continue } // Calculate travel time based on load const travelTime = calculateTravelTime(agv.currentLoad) // Decrease battery based on load and distance // Battery drain is proportional to load const batteryDrain = agv.currentLoad === 0 ? 2 : 2 + (agv.currentLoad / 10) * 3 agv.batteryLevel = Math.max(0, agv.batteryLevel - batteryDrain) // Move to next node agv.position = nextNode agv.path.shift() // Log the movement const timestamp = formatTime(simulationTime) const log = new LogModel({ timestamp, message: `${agv.id}-${currentNode}-${nextNode}-${timestamp}-${agv.currentLoad}-${agv.payloads.join(",")}`, }) await log.save() // Check if AGV has reached destination for any payload for (const payloadId of [...agv.payloads]) { const payload = await PayloadModel.findOne({ id: payloadId }) if (payload && payload.destination === agv.position) { // Remove payload from AGV agv.payloads = agv.payloads.filter((id) => id !== payloadId) agv.currentLoad -= payload.weight // Update payload status payload.status = "completed" await payload.save() // Log payload delivery const deliveryLog = new LogModel({ timestamp: formatTime(simulationTime), message: `Payload ${payloadId} delivered to Station ${agv.position}`, }) await deliveryLog.save() } } // Check if AGV needs charging if (agv.batteryLevel < 20 && agv.position !== 9) { // Find path to charging station const graph = createGraphFromRouteMap(routeMap) const path = dijkstra(graph, agv.position, 9) if (path.length > 0) { agv.path = path agv.status = "moving" // Log charging decision const chargingLog = new LogModel({ timestamp: formatTime(simulationTime), message: `${agv.id} is heading to charging station due to low battery (${agv.batteryLevel}%)`, }) await chargingLog.save() } } // If AGV is at charging station and battery is low, start charging if (agv.position === 9 && agv.batteryLevel < 100 && agv.status !== "charging") { agv.status = "charging" // Log charging start const chargingStartLog = new LogModel({ timestamp: formatTime(simulationTime), message: `${agv.id} started charging at Station 9`, }) await chargingStartLog.save() } // If path is empty, set status to idle if (agv.path.length === 0 && agv.status === "moving") { agv.status = "idle" } } else if (agv.status === "charging") { // Charging increases battery by 6.67% per minute (15 minutes to fully charge) agv.batteryLevel = Math.min(100, agv.batteryLevel + 6.67) // If fully charged, set status to idle if (agv.batteryLevel >= 100) { agv.batteryLevel = 100 agv.status = "idle" // Log charging complete const chargingCompleteLog = new LogModel({ timestamp: formatTime(simulationTime), message: `${agv.id} completed charging at Station 9`, }) await chargingCompleteLog.save() } } await agv.save() } // Assign pending payloads to idle AGVs await assignPayloads() } // Assign payloads to AGVs const assignPayloads = async () => { const pendingPayloads = await PayloadModel.find({ status: "pending" }).sort({ priority: 1 }) const agvs = await AGVModel.find({ status: "idle" }) const routeMap = await RouteMapModel.findOne() if (pendingPayloads.length === 0 || agvs.length === 0) { return } // Create graph for pathfinding const graph = createGraphFromRouteMap(routeMap) // Try to assign payloads to AGVs for (const payload of pendingPayloads) { // Find the best AGV for this payload let bestAGV = null let shortestPathLength = Number.POSITIVE_INFINITY for (const agv of agvs) { // Skip AGVs that can't carry the payload if (agv.currentLoad + payload.weight > 10) { continue } // Skip AGVs with low battery if (agv.batteryLevel < 30) { continue } // Find path from AGV to payload source const pathToSource = dijkstra(graph, agv.position, payload.source) // Find path from source to destination const pathToDestination = dijkstra(graph, payload.source, payload.destination) // Calculate total path length const totalPathLength = pathToSource.length + pathToDestination.length // Update best AGV if this one has a shorter path if (totalPathLength < shortestPathLength) { bestAGV = agv shortestPathLength = totalPathLength } } // If we found a suitable AGV, assign the payload if (bestAGV) { // Find path from AGV to payload source const pathToSource = dijkstra(graph, bestAGV.position, payload.source) // Set AGV path to payload source bestAGV.path = pathToSource bestAGV.status = "moving" // Update payload status payload.status = "in_progress" await payload.save() // Log payload assignment const assignmentLog = new LogModel({ timestamp: formatTime(simulationTime), message: `Assigned ${payload.id} to ${bestAGV.id}`, }) await assignmentLog.save() // Remove AGV from available list agvs.splice(agvs.indexOf(bestAGV), 1) await bestAGV.save() // If no more AGVs available, break if (agvs.length === 0) { break } } } } // Create graph from route map for pathfinding const createGraphFromRouteMap = (routeMap) => { const graph = {} for (const node of routeMap.nodes) { graph[node.id] = {} for (const connection of node.connections) { // Assume all connections have weight 1 for simplicity graph[node.id][connection] = 1 } } return graph } // Format time as HH:MM const formatTime = (minutes) => { const hours = Math.floor(minutes / 60) const mins = minutes % 60 return `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}` } // Start simulation const startSimulation = () => { if (simulationRunning) { return } simulationRunning = true // Update simulation every second (representing 1 minute in simulation time) simulationInterval = setInterval(async () => { simulationTime++ // Update AGVs await updateAGVs() // Emit updated data to clients const agvs = await AGVModel.find() const payloads = await PayloadModel.find() const logs = await LogModel.find().sort({ timestamp: -1 }).limit(20) io.emit("simulation_update", { time: simulationTime, agvs, payloads, logs, }) // Check if all payloads are completed const pendingPayloads = await PayloadModel.find({ status: { $ne: "completed" } }) if (pendingPayloads.length === 0) { // Generate simulation results const results = await generateResults() io.emit("simulation_completed", results) // Stop simulation clearInterval(simulationInterval) simulationRunning = false } }, 1000) } // Pause simulation const pauseSimulation = () => { if (!simulationRunning) { return } clearInterval(simulationInterval) simulationRunning = false io.emit("simulation_paused", { time: simulationTime }) } // Reset simulation const resetSimulation = async () => { clearInterval(simulationInterval) simulationRunning = false simulationTime = 0 // Reset AGVs await AGVModel.updateMany( {}, { batteryLevel: 100, currentLoad: 0, status: "idle", path: [], payloads: [], }, ) // Reset AGV positions await AGVModel.findOneAndUpdate({ id: "agv_1" }, { position: 1 }) await AGVModel.findOneAndUpdate({ id: "agv_2" }, { position: 3 }) await AGVModel.findOneAndUpdate({ id: "agv_3" }, { position: 7 }) // Reset payloads await PayloadModel.updateMany({}, { status: "pending" }) // Clear logs await LogModel.deleteMany({}) io.emit("simulation_reset") } // Generate simulation results const generateResults = async () => { const logs = await LogModel.find() const payloads = await PayloadModel.find() // Calculate total execution time const totalExecutionTime = simulationTime // Calculate average delivery time for each priority const deliveryTimes = { priority1: [], priority2: [], priority3: [], } // Count charges for each AGV const chargeCounts = { agv_1: 0, agv_2: 0, agv_3: 0, } // Process logs to extract data for (const log of logs) { // Count charging events if (log.message.includes("started charging")) { const agvId = log.message.split(" ")[0] chargeCounts[agvId]++ } } // Calculate average delivery times (mock data for now) deliveryTimes.priority1 = [12, 15, 10, 11] deliveryTimes.priority2 = [18, 20, 16] deliveryTimes.priority3 = [25, 22, 28] const averageDeliveryTimes = { priority1: deliveryTimes.priority1.reduce((a, b) => a + b, 0) / deliveryTimes.priority1.length, priority2: deliveryTimes.priority2.reduce((a, b) => a + b, 0) / deliveryTimes.priority2.length, priority3: deliveryTimes.priority3.reduce((a, b) => a + b, 0) / deliveryTimes.priority3.length, } return { totalExecutionTime, averageDeliveryTimes, chargeCounts, } } // Socket.io connection io.on("connection", (socket) => { console.log("Client connected") socket.on("start_simulation", () => { startSimulation() socket.emit("simulation_started") }) socket.on("pause_simulation", () => { pauseSimulation() socket.emit("simulation_paused", { time: simulationTime }) }) socket.on("reset_simulation", async () => { await resetSimulation() socket.emit("simulation_reset") }) socket.on("disconnect", () => { console.log("Client disconnected") }) }) // Initialize data and start server initializeData().then(() => { server.listen(PORT, () => { console.log(`Server running on port ${PORT}`) }) }) console.log("AGV Fleet Management Server is starting...") [V0_FILE]javascript:file="server/models/agv.js" type="nodejs" import mongoose from "mongoose" const AGVSchema = new mongoose.Schema({ id: { type: String, required: true, unique: true, }, position: { type: Number, required: true, }, batteryLevel: { type: Number, required: true, min: 0, max: 100, }, currentLoad: { type: Number, required: true, min: 0, max: 10, }, status: { type: String, enum: ["idle", "moving", "charging"], required: true, }, path: { type: [Number], default: [], }, payloads: { type: [String], default: [], }, }) export const AGVModel = mongoose.model("AGV", AGVSchema) [V0_FILE]javascript:file="server/models/payload.js" type="nodejs" import mongoose from "mongoose" const PayloadSchema = new mongoose.Schema({ id: { type: String, required: true, unique: true, }, source: { type: Number, required: true, }, destination: { type: Number, required: true, }, weight: { type: Number, required: true, min: 1, max: 10, }, priority: { type: Number, required: true, min: 1, max: 3, }, status: { type: String, enum: ["pending", "in_progress", "completed"], required: true, }, }) export const PayloadModel = mongoose.model("Payload", PayloadSchema) [V0_FILE]javascript:file="server/models/routeMap.js" type="nodejs" import mongoose from "mongoose" const NodeSchema = new mongoose.Schema({ id: { type: Number, required: true, }, connections: { type: [Number], required: true, }, x: { type: Number, required: true, }, y: { type: Number, required: true, }, }) const RouteMapSchema = new mongoose.Schema({ nodes: { type: [NodeSchema], required: true, }, }) export const RouteMapModel = mongoose.model("RouteMap", RouteMapSchema) [V0_FILE]javascript:file="server/models/log.js" type="nodejs" import mongoose from "mongoose" const LogSchema = new mongoose.Schema( { timestamp: { type: String, required: true, }, message: { type: String, required: true, }, }, { timestamps: true }, ) export const LogModel = mongoose.model("Log", LogSchema) [V0_FILE]javascript:file="server/algorithms/pathfinding.js" type="nodejs" // Dijkstra's algorithm for finding shortest path export function dijkstra(graph, start, end) { // Create distance object const distances = {} const previous = {} const nodes = new Set() // Initialize distances for (const node in graph) { if (node === start) { distances[node] = 0 } else { distances[node] = Number.POSITIVE_INFINITY } previous[node] = null nodes.add(node) } // Find shortest path while (nodes.size > 0) { // Find node with smallest distance let smallest = null for (const node of nodes) { if (smallest === null || distances[node] < distances[smallest]) { smallest = node } } // If smallest node is the end node, we're done if (smallest === end.toString()) { break } // If smallest distance is Infinity, there's no path if (distances[smallest] === Number.POSITIVE_INFINITY) { break } // Remove smallest node from unvisited set nodes.delete(smallest) // Update distances to neighbors for (const neighbor in graph[smallest]) { const alt = distances[smallest] + graph[smallest][neighbor] if (alt < distances[neighbor]) { distances[neighbor] = alt previous[neighbor] = smallest } } } // Build path const path = [] let current = end.toString() // If there's no path to end, return empty array if (previous[current] === null && current !== start.toString()) { return [] } // Build path from end to start while (current !== start.toString()) { path.unshift(Number.parseInt(current)) current = previous[current] } return path } [V0_FILE]javascript:file="server/algorithms/scheduler.js" type="nodejs" import { dijkstra } from "./pathfinding.js" // Schedule payloads to AGVs export function schedulePayloads(payloads, agvs, routeMap) { // Sort payloads by priority (1 is highest) const sortedPayloads = [...payloads].sort((a, b) => a.priority - b.priority) // Create graph for pathfinding const graph = createGraphFromRouteMap(routeMap) // Assign payloads to AGVs const assignments = [] for (const payload of sortedPayloads) { if (payload.status !== "pending") { continue } // Find best AGV for this payload let bestAGV = null let shortestPathLength = Number.POSITIVE_INFINITY for (const agv of agvs) { // Skip AGVs that are not idle if (agv.status !== "idle") { continue } // Skip AGVs that can't carry the payload if (agv.currentLoad + payload.weight > 10) { continue } // Skip AGVs with low battery if (agv.batteryLevel < 30) { continue } // Find path from AGV to payload source const pathToSource = dijkstra(graph, agv.position, payload.source) // Find path from source to destination const pathToDestination = dijkstra(graph, payload.source, payload.destination) // Calculate total path length const totalPathLength = pathToSource.length + pathToDestination.length // Update best AGV if this one has a shorter path if (totalPathLength < shortestPathLength) { bestAGV = agv shortestPathLength = totalPathLength } } // If we found a suitable AGV, assign the payload if (bestAGV) { assignments.push({ agvId: bestAGV.id, payloadId: payload.id, path: dijkstra(graph, bestAGV.position, payload.source), }) // Update AGV status bestAGV.status = "assigned" bestAGV.currentLoad += payload.weight } } return assignments } // Create graph from route map for pathfinding function createGraphFromRouteMap(routeMap) { const graph = {} for (const node of routeMap.nodes) { graph[node.id] = {} for (const connection of node.connections) { // Assume all connections have weight 1 for simplicity graph[node.id][connection] = 1 } } return graph } [V0_FILE]javascript:file="server/routes/simulation.js" type="nodejs" import express from "express" const router = express.Router() // Start simulation router.post("/start", (req, res) => { // This will be handled by socket.io res.status(200).json({ message: "Simulation started" }) }) // Pause simulation router.post("/pause", (req, res) => { // This will be handled by socket.io res.status(200).json({ message: "Simulation paused" }) }) // Reset simulation router.post("/reset", (req, res) => { // This will be handled by socket.io res.status(200).json({ message: "Simulation reset" }) }) export const simulationRoutes = router [V0_FILE]javascript:file="server/routes/agv.js" type="nodejs" import express from "express" import { AGVModel } from "../models/agv.js" const router = express.Router() // Get all AGVs router.get("/", async (req, res) => { try { const agvs = await AGVModel.find() res.status(200).json(agvs) } catch (error) { res.status(500).json({ message: error.message }) } }) // Get AGV by ID router.get("/:id", async (req, res) => { try { const agv = await AGVModel.findOne({ id: req.params.id }) if (!agv) { return res.status(404).json({ message: "AGV not found" }) } res.status(200).json(agv) } catch (error) { res.status(500).json({ message: error.message }) } }) // Update AGV router.patch("/:id", async (req, res) => { try { const agv = await AGVModel.findOneAndUpdate({ id: req.params.id }, req.body, { new: true }) if (!agv) { return res.status(404).json({ message: "AGV not found" }) } res.status(200).json(agv) } catch (error) { res.status(500).json({ message: error.message }) } }) export const agvRoutes = router [V0_FILE]javascript:file="server/routes/payload.js" type="nodejs" import express from "express" import { PayloadModel } from "../models/payload.js" const router = express.Router() // Get all payloads router.get("/", async (req, res) => { try { const payloads = await PayloadModel.find() res.status(200).json(payloads) } catch (error) { res.status(500).json({ message: error.message }) } }) // Get payload by ID router.get("/:id", async (req, res) => { try { const payload = await PayloadModel.findOne({ id: req.params.id }) if (!payload) { return res.status(404).json({ message: "Payload not found" }) } res.status(200).json(payload) } catch (error) { res.status(500).json({ message: error.message }) } }) // Update payload router.patch("/:id", async (req, res) => { try { const payload = await PayloadModel.findOneAndUpdate({ id: req.params.id }, req.body, { new: true }) if (!payload) { return res.status(404).json({ message: "Payload not found" }) } res.status(200).json(payload) } catch (error) { res.status(500).json({ message: error.message }) } }) export const payloadRoutes = router [V0_FILE]javascript:file="server/routes/routeMap.js" type="nodejs" import express from "express" import { RouteMapModel } from "../models/routeMap.js" const router = express.Router() // Get route map router.get("/", async (req, res) => { try { const routeMap = await RouteMapModel.findOne() res.status(200).json(routeMap) } catch (error) { res.status(500).json({ message: error.message }) } }) export const routeMapRoutes = router [V0_FILE]javascript:file="server/routes/log.js" type="nodejs" import express from "express" import { LogModel } from "../models/log.js" const router = express.Router() // Get all logs router.get("/", async (req, res) => { try { const logs = await LogModel.find().sort({ createdAt: -1 }).limit(100) res.status(200).json(logs) } catch (error) { res.status(500).json({ message: error.message }) } }) export const logRoutes = router [V0_FILE]typescript:file="lib/api.ts" isEdit="true" isQuickEdit="true" import type { AGV } from "./types" // Mock data for AGVs const mockAGVs: AGV[] = [ { id: "agv-1", position: [50, 50], batteryLevel: 80, status: "active", route: [ [100, 50], [100, 100], ], loadCapacity: 75, currentMission: { title: "Deliver to Station A", priority: "High", description: "Transporting goods to assembly line", progress: 60, eta: "00:15", }, waypoints: [ { name: "Station A", x: 100, y: 50 }, { name: "Station B", x: 100, y: 100 }, ], }, { id: "agv-2", position: [150, 150], batteryLevel: 50, status: "paused", route: [ [200, 150], [200, 200], ], loadCapacity: 25, currentMission: { title: "Pickup from Warehouse", priority: "Medium", description: "Retrieving raw materials", progress: 30, eta: "00:20", }, waypoints: [ { name: "Warehouse Entrance", x: 200, y: 150 }, { name: "Loading Dock", x: 200, y: 200 }, ], }, { id: "agv-3", position: [250, 250], batteryLevel: 95, status: "active", route: [ [300, 250], [300, 300], ], loadCapacity: 90, currentMission: { title: "Maintenance Check", priority: "Low", description: "Routine inspection and servicing", progress: 80, eta: "00:10", }, waypoints: [ { name: "Service Bay 1", x: 300, y: 250 }, { name: "Service Bay 2", x: 300, y: 300 }, ], }, ] export async function fetchAGVs(): Promise { return new Promise((resolve) => { setTimeout(() => { resolve(mockAGVs) }, 500) }) } export async function updateAGVStatus(id: string, status: "active" | "paused" | "charging"): Promise { return new Promise((resolve) => { setTimeout(() => { const agvIndex = mockAGVs.findIndex((agv) => agv.id === id) if (agvIndex !== -1) { mockAGVs[agvIndex] = { ...mockAGVs[agvIndex], status } } resolve() }, 500) }) } export async function updateAGVRoute(id: string, route: [number, number][]): Promise { return new Promise((resolve) => { setTimeout(() => { const agvIndex = mockAGVs.findIndex((agv) => agv.id === id) if (agvIndex !== -1) { mockAGVs[agvIndex] = { ...mockAGVs[agvIndex], route } } resolve() }, 500) }) }