mettagrid 0.2.0.15__tar.gz → 0.2.0.17__tar.gz

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/.gitignore

@@ -3,3 +3,5 @@
 /build-release
 /benchmark_output
 /Testing
+
+MODULE.bazel.lock

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.15
+Version: 0.2.0.17
 Summary: A fast grid-based open-ended MARL environment
 Author-email: David Bloomin <daveey@gmail.com>
 License-Expression: MIT

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/configs/maps/navigation_sequence/labyrinth.map

@@ -5,7 +5,7 @@
 #...#.....#.......#.........#
 #...#.....#.......#.........#
 #...#.....#.......#.........#
-#...#..... .......#.........#
+#...#.............#.........#
 #...#.........#####.........#
 #...#...#.....#.............#
 #...#...#.....#.............#

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/mettagrid.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.15
+Version: 0.2.0.17
 Summary: A fast grid-based open-ended MARL environment
 Author-email: David Bloomin <daveey@gmail.com>
 License-Expression: MIT

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/mettagrid.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ CPPLINT.cfg
 LICENSE
 MANIFEST.in
 MODULE.bazel
-MODULE.bazel.lock
 Makefile
 README.md
 bazel_build.py
@@ -352,6 +351,7 @@ nim/mettascope/src/mettascope/footer.nim
 nim/mettascope/src/mettascope/minimap.nim
 nim/mettascope/src/mettascope/objectinfo.nim
 nim/mettascope/src/mettascope/panels.nim
+nim/mettascope/src/mettascope/pathfinding.nim
 nim/mettascope/src/mettascope/replays.nim
 nim/mettascope/src/mettascope/settings.nim
 nim/mettascope/src/mettascope/shell.html
@@ -748,7 +748,6 @@ python/src/mettagrid/renderer/miniscope/buffer.py
 python/src/mettagrid/renderer/miniscope/info_panels.py
 python/src/mettagrid/renderer/miniscope/interactive.py
 python/src/mettagrid/renderer/miniscope/renderer.py
-python/src/mettagrid/renderer/miniscope/symbols.py
 python/src/mettagrid/test_support/__init__.py
 python/src/mettagrid/test_support/actions.py
 python/src/mettagrid/test_support/mapgen.py
@@ -756,7 +755,6 @@ python/src/mettagrid/test_support/observation_helper.py
 python/src/mettagrid/test_support/orientation.py
 python/src/mettagrid/test_support/token_types.py
 python/src/mettagrid/util/__init__.py
-python/src/mettagrid/util/char_encoder.py
 python/src/mettagrid/util/debug.py
 python/src/mettagrid/util/dict_utils.py
 python/src/mettagrid/util/diversity.py
@@ -769,7 +767,6 @@ scripts/test_leaks.sh
 tests/BUILD
 tests/__init__.py
 tests/cpplint.sh
-tests/diagnose.py
 tests/run_test.py
 tests/test_action_compatibility.py
 tests/test_actions.py
@@ -805,7 +802,6 @@ tests/test_rewards.py
 tests/test_rotate.py
 tests/test_set_inventory.py
 tests/test_stats_tracker.cpp
-tests/test_swap.py
 tests/test_tags.py
 tests/test_visitation_counts.py
 tests/map_builder/__init__.py

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/nim/mettascope/bindings/bindings.nim

@@ -4,15 +4,18 @@ import
   envconfig]
 
 type
-  RenderResponse* = object
+  ActionRequest* = object
+    agentId*: int
+    actionId*: int
+    argument*: int
+
+  RenderResponse* = ref object
     shouldClose*: bool
-    action*: bool
-    actionAgentId*: int
-    actionActionId*: int
-    actionArgument*: int
+    actions*: seq[ActionRequest]
 
 proc init(dataDir: string, replay: string): RenderResponse =
   try:
+    result = RenderResponse(shouldClose: false, actions: @[])
     #echo "Replay from python: ", replay
     echo "Data dir: ", dataDir
     playMode = Realtime
@@ -40,8 +43,10 @@ proc render(currentStep: int, replayStep: string): RenderResponse =
     common.replay.apply(replayStep)
     step = currentStep
     stepFloat = currentStep.float32
+    previousStep = currentStep
     onStepChanged()
     requestPython = false
+    result = RenderResponse(shouldClose: false, actions: @[])
     while true:
       if window.closeRequested:
         window.close()
@@ -49,18 +54,14 @@ proc render(currentStep: int, replayStep: string): RenderResponse =
         return
       mainLoop()
       if requestPython:
-        if requestAction:
-          result.action = true
-          result.actionAgentId = requestActionAgentId
-          result.actionActionId = requestActionActionId
-          result.actionArgument = requestActionArgument
-          requestAction = false
-          requestActionAgentId = 0
-          requestActionActionId = 0
-          requestActionArgument = 0
-          return
-        else:
-          return
+        for action in requestActions:
+          result.actions.add(ActionRequest(
+            agentId: action.agentId,
+            actionId: action.actionId,
+            argument: action.argument
+          ))
+        requestActions.setLen(0)
+        return
   except Exception:
     echo "############## Error rendering Mettascope ##################"
     echo getCurrentException().getStackTrace()
@@ -69,9 +70,14 @@ proc render(currentStep: int, replayStep: string): RenderResponse =
     result.shouldClose = true
     return
 
-exportObject RenderResponse:
+exportObject ActionRequest:
   discard
 
+exportRefObject RenderResponse:
+  fields:
+    shouldClose
+    actions
+
 exportProcs:
   init
   render

mettagrid-0.2.0.17/nim/mettascope/src/mettascope/actions.nim

@@ -0,0 +1,127 @@
+import
+  std/[tables],
+  windy, fidget2, vmath,
+  common, replays, pathfinding
+
+type
+  Orientation* = enum
+    N = 0
+    S = 1
+    W = 2
+    E = 3
+  
+  QueuedAction = object
+    agentId: int
+    actionId: int
+    argument: int
+
+var
+  ## Action queue for each agent. Only one action per step.
+  actionQueue = initTable[int, QueuedAction]()
+
+proc queueAction(agentId, actionId, argument: int) =
+  ## Queue an action for the agent. Will be sent on next step.
+  actionQueue[agentId] = QueuedAction(
+    agentId: agentId,
+    actionId: actionId,
+    argument: argument
+  )
+
+proc sendAction*(agentId, actionId, argument: int) =
+  ## Send an action to the Python from the user.
+  requestActions.add(ActionRequest(
+    agentId: agentId,
+    actionId: actionId,
+    argument: argument
+  ))
+  requestPython = true
+
+proc getOrientationFromDelta(dx, dy: int): Orientation =
+  ## Get the orientation from a movement delta.
+  if dx == 0 and dy == -1:
+    return N
+  elif dx == 0 and dy == 1:
+    return S
+  elif dx == -1 and dy == 0:
+    return W
+  elif dx == 1 and dy == 0:
+    return E
+  else:
+    return N
+
+proc processActions*() =
+  ## Process pathfinding and action queue. Called on step change.
+  if not (play or requestPython):
+    return
+  
+  for agentId, path in agentPaths:
+    if path.len > 1:
+      var agent: Entity = nil
+      for obj in replay.objects:
+        if obj.isAgent and obj.agentId == agentId:
+          agent = obj
+          break
+      
+      if agent != nil:
+        let currentPos = agent.location.at(step).xy
+        
+        if path[0] == currentPos:
+          if path.len > 1:
+            let nextPos = path[1]
+            let dx = nextPos.x - currentPos.x
+            let dy = nextPos.y - currentPos.y
+            let orientation = getOrientationFromDelta(dx.int, dy.int)
+            queueAction(agentId, replay.moveActionId, orientation.int)
+            agentPaths[agentId].delete(0)
+          else:
+            recomputePath(agentId, currentPos)
+        else:
+          recomputePath(agentId, currentPos)
+  
+  if actionQueue.len > 0:
+    for agentId, action in actionQueue:
+      requestActions.add(ActionRequest(
+        agentId: action.agentId,
+        actionId: action.actionId,
+        argument: action.argument
+      ))
+    actionQueue.clear()
+
+proc agentControls*() =
+  ## Manual controls with WASD for selected agent.
+  if selection != nil and selection.isAgent:
+    let agent = selection
+    
+    # Move
+    if window.buttonPressed[KeyW] or window.buttonPressed[KeyUp]:
+      sendAction(agent.agentId, replay.moveActionId, N.int)
+      clearPath(agent.agentId)
+
+    elif window.buttonPressed[KeyS] or window.buttonPressed[KeyDown]:
+      sendAction(agent.agentId, replay.moveActionId, S.int)
+      clearPath(agent.agentId)
+
+    elif window.buttonPressed[KeyD] or window.buttonPressed[KeyRight]:
+      sendAction(agent.agentId, replay.moveActionId, E.int)
+      clearPath(agent.agentId)
+
+    elif window.buttonPressed[KeyA] or window.buttonPressed[KeyLeft]:
+      sendAction(agent.agentId, replay.moveActionId, W.int)
+      clearPath(agent.agentId)
+
+    # Put items
+    elif window.buttonPressed[KeyQ]:
+      sendAction(agent.agentId, replay.putItemsActionId, 0)
+
+    # Get items
+    elif window.buttonPressed[KeyE]:
+      sendAction(agent.agentId, replay.getItemsActionId, 0)
+
+    # Attack
+    elif window.buttonPressed[KeyZ]:
+      # TODO: Get implementation attack selection ui.
+      sendAction(agent.agentId, replay.attackActionId, 0)
+
+    # Noop
+    elif window.buttonPressed[KeyX]:
+      sendAction(agent.agentId, replay.noopActionId, 0)

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/nim/mettascope/src/mettascope/common.nim

@@ -1,4 +1,5 @@
-import std/[times],
+import
+  std/[times, tables],
   boxy, windy, vmath, fidget2,
   replays
 
@@ -81,6 +82,7 @@ var
 
   step*: int = 0
   stepFloat*: float32 = 0
+  previousStep*: int = -1
   replay*: Replay
   play*: bool
   playSpeed*: float32 = 0.1
@@ -89,15 +91,26 @@ var
 
   ## Signals when we want to give control back to Python (DLL mode only).
   requestPython*: bool = false
-  requestAction*: bool = false
-  requestActionAgentId*: int
-  requestActionActionId*: int
-  requestActionArgument*: int
+
+type
+  ActionRequest* = object
+    agentId*: int
+    actionId*: int
+    argument*: int
+
+var
+  requestActions*: seq[ActionRequest]
 
   followSelection*: bool = false
   mouseCaptured*: bool = false
   mouseCapturedPanel*: Panel = nil
 
+var
+  ## Path queue for each agent. Maps agentId to a sequence of grid positions.
+  agentPaths* = initTable[int, seq[IVec2]]()
+  ## Destination queue for each agent. Maps agentId to a sequence of destinations.
+  agentDestinations* = initTable[int, seq[IVec2]]()
+
 proc at*[T](sequence: seq[T], step: int): T =
   # Get the value at the given step.
   if sequence.len == 0:

mettagrid-0.2.0.17/nim/mettascope/src/mettascope/pathfinding.nim

@@ -0,0 +1,113 @@
+import
+  std/[algorithm, tables],
+  vmath,
+  common, replays
+
+type
+  PathNode = object
+    pos: IVec2
+    gCost: int
+    hCost: int
+    parent: int
+
+proc fCost(node: PathNode): int =
+  ## Calculate the total cost of a node.
+  node.gCost + node.hCost
+
+proc heuristic(a, b: IVec2): int =
+  ## Calculate the Manhattan distance heuristic.
+  abs(a.x - b.x) + abs(a.y - b.y)
+
+proc isWalkablePos*(pos: IVec2): bool =
+  ## Check if a position is walkable.
+  if pos.x < 0 or pos.x >= replay.mapSize[0] or pos.y < 0 or pos.y >= replay.mapSize[1]:
+    return false
+  for obj in replay.objects:
+    if obj.location.at(step).xy == pos:
+      let typeName = replay.typeNames[obj.typeId]
+      if typeName != "agent":
+        return false
+  return true
+
+proc findPath*(start, goal: IVec2): seq[IVec2] =
+  ## Find a path from start to goal using A* pathfinding.
+  if start == goal:
+    return @[]
+  if not isWalkablePos(goal):
+    return @[]
+  var openList: seq[PathNode] = @[PathNode(pos: start, gCost: 0, hCost: heuristic(start, goal), parent: -1)]
+  var closedSet: seq[IVec2] = @[]
+  var allNodes: seq[PathNode] = @[]
+  while openList.len > 0:
+    var currentIdx = 0
+    for i in 1 ..< openList.len:
+      if openList[i].fCost < openList[currentIdx].fCost:
+        currentIdx = i
+    let current = openList[currentIdx]
+    openList.delete(currentIdx)
+    closedSet.add(current.pos)
+    let currentNodeIdx = allNodes.len
+    allNodes.add(current)
+    if current.pos == goal:
+      var path: seq[IVec2] = @[]
+      var node = current
+      var nodeIdx = currentNodeIdx
+      while nodeIdx >= 0 and node.parent >= 0:
+        path.add(node.pos)
+        nodeIdx = node.parent
+        if nodeIdx >= 0:
+          node = allNodes[nodeIdx]
+        else:
+          break
+      path.add(start)
+      path.reverse()
+      return path
+    const directions = [ivec2(0, -1), ivec2(0, 1), ivec2(-1, 0), ivec2(1, 0)]
+    for dir in directions:
+      let neighborPos = ivec2(current.pos.x + dir.x, current.pos.y + dir.y)
+      if neighborPos.x < 0 or neighborPos.x >= replay.mapSize[0] or neighborPos.y < 0 or neighborPos.y >= replay.mapSize[1]:
+        continue
+      if neighborPos in closedSet:
+        continue
+      if not isWalkablePos(neighborPos):
+        continue
+      let newGCost = current.gCost + 1
+      var foundInOpen = false
+      for i in 0 ..< openList.len:
+        if openList[i].pos == neighborPos:
+          foundInOpen = true
+          if newGCost < openList[i].gCost:
+            openList[i].gCost = newGCost
+            openList[i].parent = currentNodeIdx
+          break
+      if not foundInOpen:
+        openList.add(PathNode(
+          pos: neighborPos,
+          gCost: newGCost,
+          hCost: heuristic(neighborPos, goal),
+          parent: currentNodeIdx
+        ))
+  return @[]
+
+proc clearPath*(agentId: int) =
+  ## Clear the path and destination for an agent.
+  agentPaths.del(agentId)
+  agentDestinations.del(agentId)
+
+proc recomputePath*(agentId: int, currentPos: IVec2) =
+  ## Recompute the path for an agent to their current destination.
+  if not agentDestinations.hasKey(agentId) or agentDestinations[agentId].len == 0:
+    return
+  let destination = agentDestinations[agentId][0]
+  if currentPos == destination:
+    agentDestinations[agentId].delete(0)
+    agentPaths.del(agentId)
+    if agentDestinations[agentId].len > 0:
+      recomputePath(agentId, currentPos)
+    return
+  let newPath = findPath(currentPos, destination)
+  if newPath.len > 0:
+    agentPaths[agentId] = newPath
+  else:
+    clearPath(agentId)
+

{mettagrid-0.2.0.15 → mettagrid-0.2.0.17}/nim/mettascope/src/mettascope/timeline.nim

@@ -1,7 +1,7 @@
 import
   std/[times, math],
   boxy, vmath, windy, fidget2, fidget2/[hybridrender, common],
-  common, panels, objectinfo
+  common, panels, actions, objectinfo
 
 const
   BgColor = parseHtmlColor("#1D1D1D")
@@ -29,6 +29,7 @@ proc onStepChanged*() =
   ## Must be called when the step changes so that UI is updated.
   echo "step: ", step
   updateObjectInfo()
+  processActions()
 
 proc bindTimelineNodes() =
   if nodesBound or globalTimelinePanel.isNil or globalTimelinePanel.node.isNil:
@@ -67,17 +68,22 @@ proc playControls*() =
         stepFloat = replay.maxSteps.float32 - 1
     step = stepFloat.int
     step = step.clamp(0, replay.maxSteps - 1)
-    onStepChanged()
 
   if window.buttonPressed[KeyLeftBracket]:
     step -= 1
     step = clamp(step, 0, replay.maxSteps - 1)
     stepFloat = step.float32
-    onStepChanged()
   if window.buttonPressed[KeyRightBracket]:
     step += 1
+    if playMode == Realtime and step >= replay.maxSteps:
+      requestPython = true
+      step = replay.maxSteps - 1
     step = clamp(step, 0, replay.maxSteps - 1)
     stepFloat = step.float32
+  
+  # Fire onStepChanged once and only once when step changes.
+  if step != previousStep:
+    previousStep = step
     onStepChanged()
 
 proc getStepFromX(localX, panelWidth: float32): int =
@@ -95,8 +101,11 @@ proc getStepFromX(localX, panelWidth: float32): int =
 proc onScrubberChange(localX, panelWidth: float32) =
   ## Updates global step based on local X.
   let s = getStepFromX(localX, panelWidth)
-  step = s
-  stepFloat = step.float32
+  if s != step:
+    step = s
+    stepFloat = step.float32
+    previousStep = step
+    onStepChanged()
 
 proc centerTracesOnStep(targetStep: int) =
   ## Recenters the Agent Traces panel on the given step.

mettagrid-0.2.0.17/nim/mettascope/src/mettascope/utils.nim

@@ -0,0 +1,150 @@
+import
+  std/[algorithm],
+  boxy, vmath, windy, fidget2/hybridrender
+
+var
+  typeface*: Typeface
+
+proc drawText*(
+  bxy: Boxy,
+  imageKey: string,
+  transform: Mat3,
+  typeface: Typeface,
+  text: string,
+  size: float32,
+  color: Color
+) =
+  ## Draw text on the screen.
+  var font = newFont(typeface)
+  font.size = size
+  font.paint = color
+  let
+    arrangement = typeset(@[newSpan(text, font)], bounds = vec2(1280, 800))
+    globalBounds = arrangement.computeBounds(transform).snapToPixels()
+    textImage = newImage(globalBounds.w.int, globalBounds.h.int)
+    imageSpace = translate(-globalBounds.xy) * transform
+  textImage.fillText(arrangement, imageSpace)
+
+  bxy.addImage(imageKey, textImage)
+  bxy.drawImage(imageKey, globalBounds.xy)
+
+proc measureText*(
+  text: string,
+  size: float32,
+  typeface: Typeface
+): Vec2 =
+  var font = newFont(typeface)
+  font.size = size
+  let arrangement = typeset(@[newSpan(text, font)], bounds = vec2(1280, 800))
+  let transform = translate(vec2(0, 0))
+  let bounds = arrangement.computeBounds(transform).snapToPixels()
+  return vec2(bounds.w, bounds.h)
+
+proc drawBubbleLine*(bxy: Boxy, start: Vec2, stop: Vec2, color: Color) =
+  ## Draw a line with circles.
+  let
+    dir = (stop - start).normalize
+  for i in 0 ..< int(dist(start, stop) / 5):
+    let pos = start + dir * i.float32 * 5
+    # bxy.drawImage(
+    #   "bubble",
+    #   pos,
+    #   angle = 0,
+    #   scale = 0.25,
+    #   tint = color
+    # )
+
+proc newSeq2D*[T](width: int, height: int): seq[seq[T]] =
+  result = newSeq[seq[T]](width)
+  for i in 0 ..< width:
+    result[i] = newSeq[T](height)
+
+type
+  PathNode* = object
+    pos*: IVec2
+    gCost*: int
+    hCost*: int
+    parent*: int
+
+proc fCost(node: PathNode): int =
+  ## Calculate the total cost of a node.
+  node.gCost + node.hCost
+
+proc heuristic(a, b: IVec2): int =
+  ## Calculate the Manhattan distance heuristic.
+  abs(a.x - b.x) + abs(a.y - b.y)
+
+proc findPath*(start, goal: IVec2, mapWidth, mapHeight: int, isWalkable: proc(pos: IVec2): bool): seq[IVec2] =
+  ## Find a path from start to goal using A* pathfinding.
+  if start == goal:
+    return @[]
+  
+  if not isWalkable(goal):
+    return @[]
+  
+  var openList: seq[PathNode] = @[PathNode(pos: start, gCost: 0, hCost: heuristic(start, goal), parent: -1)]
+  var closedSet: seq[IVec2] = @[]
+  var allNodes: seq[PathNode] = @[]
+  
+  while openList.len > 0:
+    var currentIdx = 0
+    for i in 1 ..< openList.len:
+      if openList[i].fCost < openList[currentIdx].fCost:
+        currentIdx = i
+    
+    let current = openList[currentIdx]
+    openList.delete(currentIdx)
+    closedSet.add(current.pos)
+    
+    let currentNodeIdx = allNodes.len
+    allNodes.add(current)
+    
+    if current.pos == goal:
+      var path: seq[IVec2] = @[]
+      var node = current
+      var nodeIdx = currentNodeIdx
+      while nodeIdx >= 0 and node.parent >= 0:
+        path.add(node.pos)
+        nodeIdx = node.parent
+        if nodeIdx >= 0:
+          node = allNodes[nodeIdx]
+        else:
+          break
+      path.add(start)
+      path.reverse()
+      return path
+    
+    const directions = [ivec2(0, -1), ivec2(0, 1), ivec2(-1, 0), ivec2(1, 0)]
+    
+    for dir in directions:
+      let neighborPos = ivec2(current.pos.x + dir.x, current.pos.y + dir.y)
+      
+      if neighborPos.x < 0 or neighborPos.x >= mapWidth or neighborPos.y < 0 or neighborPos.y >= mapHeight:
+        continue
+      
+      if neighborPos in closedSet:
+        continue
+      
+      if not isWalkable(neighborPos):
+        continue
+      
+      let newGCost = current.gCost + 1
+      
+      var foundInOpen = false
+      for i in 0 ..< openList.len:
+        if openList[i].pos == neighborPos:
+          foundInOpen = true
+          if newGCost < openList[i].gCost:
+            openList[i].gCost = newGCost
+            openList[i].parent = currentNodeIdx
+          break
+      
+      if not foundInOpen:
+        openList.add(PathNode(
+          pos: neighborPos,
+          gCost: newGCost,
+          hCost: heuristic(neighborPos, goal),
+          parent: currentNodeIdx
+        ))
+  
+  return @[]