minigrid.py 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838
  1. import math
  2. import gym
  3. from enum import IntEnum
  4. import numpy as np
  5. from gym import error, spaces, utils
  6. from gym.utils import seeding
  7. from gym_minigrid.rendering import *
  8. # Size in pixels of a cell in the full-scale human view
  9. CELL_PIXELS = 32
  10. # Number of cells (width and height) in the agent view
  11. AGENT_VIEW_SIZE = 7
  12. # Size of the array given as an observation to the agent
  13. OBS_ARRAY_SIZE = (AGENT_VIEW_SIZE, AGENT_VIEW_SIZE, 3)
  14. # Map of color names to RGB values
  15. COLORS = {
  16. 'red' : (255, 0, 0),
  17. 'green' : (0, 255, 0),
  18. 'blue' : (0, 0, 255),
  19. 'purple': (112, 39, 195),
  20. 'yellow': (255, 255, 0),
  21. 'grey' : (100, 100, 100)
  22. }
  23. COLOR_NAMES = list(COLORS.keys())
  24. # Used to map colors to integers
  25. COLOR_TO_IDX = {
  26. 'red' : 0,
  27. 'green' : 1,
  28. 'blue' : 2,
  29. 'purple': 3,
  30. 'yellow': 4,
  31. 'grey' : 5
  32. }
  33. IDX_TO_COLOR = dict(zip(COLOR_TO_IDX.values(), COLOR_TO_IDX.keys()))
  34. # Map of object type to integers
  35. OBJECT_TO_IDX = {
  36. 'empty' : 0,
  37. 'wall' : 1,
  38. 'door' : 2,
  39. 'locked_door' : 3,
  40. 'key' : 4,
  41. 'ball' : 5,
  42. 'box' : 6,
  43. 'goal' : 7
  44. }
  45. IDX_TO_OBJECT = dict(zip(OBJECT_TO_IDX.values(), OBJECT_TO_IDX.keys()))
  46. class WorldObj:
  47. """
  48. Base class for grid world objects
  49. """
  50. def __init__(self, type, color):
  51. assert type in OBJECT_TO_IDX, type
  52. assert color in COLOR_TO_IDX, color
  53. self.type = type
  54. self.color = color
  55. self.contains = None
  56. def canOverlap(self):
  57. """Can the agent overlap with this?"""
  58. return False
  59. def canPickup(self):
  60. """Can the agent pick this up?"""
  61. return False
  62. def canContain(self):
  63. """Can this contain another object?"""
  64. return False
  65. def toggle(self, env, pos):
  66. """Method to trigger/toggle an action this object performs"""
  67. return False
  68. def render(self, r):
  69. assert False
  70. def _setColor(self, r):
  71. c = COLORS[self.color]
  72. r.setLineColor(c[0], c[1], c[2])
  73. r.setColor(c[0], c[1], c[2])
  74. class Goal(WorldObj):
  75. def __init__(self):
  76. super(Goal, self).__init__('goal', 'green')
  77. def render(self, r):
  78. self._setColor(r)
  79. r.drawPolygon([
  80. (0 , CELL_PIXELS),
  81. (CELL_PIXELS, CELL_PIXELS),
  82. (CELL_PIXELS, 0),
  83. (0 , 0)
  84. ])
  85. class Wall(WorldObj):
  86. def __init__(self, color='grey'):
  87. super(Wall, self).__init__('wall', color)
  88. def render(self, r):
  89. self._setColor(r)
  90. r.drawPolygon([
  91. (0 , CELL_PIXELS),
  92. (CELL_PIXELS, CELL_PIXELS),
  93. (CELL_PIXELS, 0),
  94. (0 , 0)
  95. ])
  96. class Door(WorldObj):
  97. def __init__(self, color, isOpen=False):
  98. super(Door, self).__init__('door', color)
  99. self.isOpen = isOpen
  100. def render(self, r):
  101. c = COLORS[self.color]
  102. r.setLineColor(c[0], c[1], c[2])
  103. r.setColor(0, 0, 0)
  104. if self.isOpen:
  105. r.drawPolygon([
  106. (CELL_PIXELS-2, CELL_PIXELS),
  107. (CELL_PIXELS , CELL_PIXELS),
  108. (CELL_PIXELS , 0),
  109. (CELL_PIXELS-2, 0)
  110. ])
  111. return
  112. r.drawPolygon([
  113. (0 , CELL_PIXELS),
  114. (CELL_PIXELS, CELL_PIXELS),
  115. (CELL_PIXELS, 0),
  116. (0 , 0)
  117. ])
  118. r.drawPolygon([
  119. (2 , CELL_PIXELS-2),
  120. (CELL_PIXELS-2, CELL_PIXELS-2),
  121. (CELL_PIXELS-2, 2),
  122. (2 , 2)
  123. ])
  124. r.drawCircle(CELL_PIXELS * 0.75, CELL_PIXELS * 0.5, 2)
  125. def toggle(self, env, pos):
  126. if not self.isOpen:
  127. self.isOpen = True
  128. return True
  129. return False
  130. def canOverlap(self):
  131. """The agent can only walk over this cell when the door is open"""
  132. return self.isOpen
  133. class LockedDoor(WorldObj):
  134. def __init__(self, color, isOpen=False):
  135. super(LockedDoor, self).__init__('locked_door', color)
  136. self.isOpen = isOpen
  137. def render(self, r):
  138. c = COLORS[self.color]
  139. r.setLineColor(c[0], c[1], c[2])
  140. r.setColor(c[0], c[1], c[2], 50)
  141. if self.isOpen:
  142. r.drawPolygon([
  143. (CELL_PIXELS-2, CELL_PIXELS),
  144. (CELL_PIXELS , CELL_PIXELS),
  145. (CELL_PIXELS , 0),
  146. (CELL_PIXELS-2, 0)
  147. ])
  148. return
  149. r.drawPolygon([
  150. (0 , CELL_PIXELS),
  151. (CELL_PIXELS, CELL_PIXELS),
  152. (CELL_PIXELS, 0),
  153. (0 , 0)
  154. ])
  155. r.drawPolygon([
  156. (2 , CELL_PIXELS-2),
  157. (CELL_PIXELS-2, CELL_PIXELS-2),
  158. (CELL_PIXELS-2, 2),
  159. (2 , 2)
  160. ])
  161. r.drawLine(
  162. CELL_PIXELS * 0.55,
  163. CELL_PIXELS * 0.5,
  164. CELL_PIXELS * 0.75,
  165. CELL_PIXELS * 0.5
  166. )
  167. def toggle(self, env, pos):
  168. # If the player has the right key to open the door
  169. if isinstance(env.carrying, Key) and env.carrying.color == self.color:
  170. self.isOpen = True
  171. # The key has been used, remove it from the agent
  172. env.carrying = None
  173. return True
  174. return False
  175. def canOverlap(self):
  176. """The agent can only walk over this cell when the door is open"""
  177. return self.isOpen
  178. class Key(WorldObj):
  179. def __init__(self, color='blue'):
  180. super(Key, self).__init__('key', color)
  181. def canPickup(self):
  182. return True
  183. def render(self, r):
  184. self._setColor(r)
  185. # Vertical quad
  186. r.drawPolygon([
  187. (16, 10),
  188. (20, 10),
  189. (20, 28),
  190. (16, 28)
  191. ])
  192. # Teeth
  193. r.drawPolygon([
  194. (12, 19),
  195. (16, 19),
  196. (16, 21),
  197. (12, 21)
  198. ])
  199. r.drawPolygon([
  200. (12, 26),
  201. (16, 26),
  202. (16, 28),
  203. (12, 28)
  204. ])
  205. r.drawCircle(18, 9, 6)
  206. r.setLineColor(0, 0, 0)
  207. r.setColor(0, 0, 0)
  208. r.drawCircle(18, 9, 2)
  209. class Ball(WorldObj):
  210. def __init__(self, color='blue'):
  211. super(Ball, self).__init__('ball', color)
  212. def canPickup(self):
  213. return True
  214. def render(self, r):
  215. self._setColor(r)
  216. r.drawCircle(CELL_PIXELS * 0.5, CELL_PIXELS * 0.5, 10)
  217. class Box(WorldObj):
  218. def __init__(self, color, contains=None):
  219. super(Box, self).__init__('box', color)
  220. self.contains = contains
  221. def render(self, r):
  222. c = COLORS[self.color]
  223. r.setLineColor(c[0], c[1], c[2])
  224. r.setColor(0, 0, 0)
  225. r.setLineWidth(2)
  226. r.drawPolygon([
  227. (4 , CELL_PIXELS-4),
  228. (CELL_PIXELS-4, CELL_PIXELS-4),
  229. (CELL_PIXELS-4, 4),
  230. (4 , 4)
  231. ])
  232. r.drawLine(
  233. 4,
  234. CELL_PIXELS / 2,
  235. CELL_PIXELS - 4,
  236. CELL_PIXELS / 2
  237. )
  238. r.setLineWidth(1)
  239. def toggle(self, env, pos):
  240. # Replace the box by its contents
  241. env.grid.set(*pos, self.contains)
  242. return True
  243. class Grid:
  244. """
  245. Represent a grid and operations on it
  246. """
  247. def __init__(self, width, height):
  248. assert width >= 4
  249. assert height >= 4
  250. self.width = width
  251. self.height = height
  252. self.grid = [None] * width * height
  253. def copy(self):
  254. from copy import deepcopy
  255. return deepcopy(self)
  256. def set(self, i, j, v):
  257. assert i >= 0 and i < self.width
  258. assert j >= 0 and j < self.height
  259. self.grid[j * self.width + i] = v
  260. def get(self, i, j):
  261. assert i >= 0 and i < self.width
  262. assert j >= 0 and j < self.height
  263. return self.grid[j * self.width + i]
  264. def rotateLeft(self):
  265. """
  266. Rotate the grid to the left (counter-clockwise)
  267. """
  268. grid = Grid(self.width, self.height)
  269. for j in range(0, self.height):
  270. for i in range(0, self.width):
  271. v = self.get(self.width - 1 - j, i)
  272. grid.set(i, j, v)
  273. return grid
  274. def slice(self, topX, topY, width, height):
  275. """
  276. Get a subset of the grid
  277. """
  278. grid = Grid(width, height)
  279. for j in range(0, height):
  280. for i in range(0, width):
  281. x = topX + i
  282. y = topY + j
  283. if x >= 0 and x < self.width and \
  284. y >= 0 and y < self.height:
  285. v = self.get(x, y)
  286. else:
  287. v = Wall()
  288. grid.set(i, j, v)
  289. return grid
  290. def render(self, r, tileSize):
  291. """
  292. Render this grid at a given scale
  293. :param r: target renderer object
  294. :param tileSize: tile size in pixels
  295. """
  296. assert r.width == self.width * tileSize
  297. assert r.height == self.height * tileSize
  298. # Total grid size at native scale
  299. widthPx = self.width * CELL_PIXELS
  300. heightPx = self.height * CELL_PIXELS
  301. # Draw background (out-of-world) tiles the same colors as walls
  302. # so the agent understands these areas are not reachable
  303. c = COLORS['grey']
  304. r.setLineColor(c[0], c[1], c[2])
  305. r.setColor(c[0], c[1], c[2])
  306. r.drawPolygon([
  307. (0 , heightPx),
  308. (widthPx, heightPx),
  309. (widthPx, 0),
  310. (0 , 0)
  311. ])
  312. r.push()
  313. # Internally, we draw at the "large" full-grid resolution, but we
  314. # use the renderer to scale back to the desired size
  315. r.scale(tileSize / CELL_PIXELS, tileSize / CELL_PIXELS)
  316. # Draw the background of the in-world cells black
  317. r.fillRect(
  318. 0,
  319. 0,
  320. widthPx,
  321. heightPx,
  322. 0, 0, 0
  323. )
  324. # Draw grid lines
  325. r.setLineColor(100, 100, 100)
  326. for rowIdx in range(0, self.height):
  327. y = CELL_PIXELS * rowIdx
  328. r.drawLine(0, y, widthPx, y)
  329. for colIdx in range(0, self.width):
  330. x = CELL_PIXELS * colIdx
  331. r.drawLine(x, 0, x, heightPx)
  332. # Render the grid
  333. for j in range(0, self.height):
  334. for i in range(0, self.width):
  335. cell = self.get(i, j)
  336. if cell == None:
  337. continue
  338. r.push()
  339. r.translate(i * CELL_PIXELS, j * CELL_PIXELS)
  340. cell.render(r)
  341. r.pop()
  342. r.pop()
  343. def encode(self):
  344. """
  345. Produce a compact numpy encoding of the grid
  346. """
  347. codeSize = self.width * self.height * 3
  348. array = np.zeros(shape=(self.width, self.height, 3), dtype='uint8')
  349. for j in range(0, self.height):
  350. for i in range(0, self.width):
  351. v = self.get(i, j)
  352. if v == None:
  353. continue
  354. array[i, j, 0] = OBJECT_TO_IDX[v.type]
  355. array[i, j, 1] = COLOR_TO_IDX[v.color]
  356. if hasattr(v, 'isOpen') and v.isOpen:
  357. array[i, j, 2] = 1
  358. return array
  359. def decode(array):
  360. """
  361. Decode an array grid encoding back into a grid
  362. """
  363. width = array.shape[0]
  364. height = array.shape[1]
  365. assert array.shape[2] == 3
  366. grid = Grid(width, height)
  367. for j in range(0, height):
  368. for i in range(0, width):
  369. typeIdx = array[i, j, 0]
  370. colorIdx = array[i, j, 1]
  371. openIdx = array[i, j, 2]
  372. if typeIdx == 0:
  373. continue
  374. objType = IDX_TO_OBJECT[typeIdx]
  375. color = IDX_TO_COLOR[colorIdx]
  376. isOpen = True if openIdx == 1 else 0
  377. if objType == 'wall':
  378. v = Wall(color)
  379. elif objType == 'ball':
  380. v = Ball(color)
  381. elif objType == 'key':
  382. v = Key(color)
  383. elif objType == 'box':
  384. v = Box(color)
  385. elif objType == 'door':
  386. v = Door(color, isOpen)
  387. elif objType == 'locked_door':
  388. v = LockedDoor(color, isOpen)
  389. elif objType == 'goal':
  390. v = Goal()
  391. else:
  392. assert False, "unknown obj type in decode '%s'" % objType
  393. grid.set(i, j, v)
  394. return grid
  395. class MiniGridEnv(gym.Env):
  396. """
  397. 2D grid world game environment
  398. """
  399. metadata = {
  400. 'render.modes': ['human', 'rgb_array', 'pixmap'],
  401. 'video.frames_per_second' : 10
  402. }
  403. # Enumeration of possible actions
  404. class Actions(IntEnum):
  405. left = 0
  406. right = 1
  407. forward = 2
  408. # Toggle/pick up/activate object
  409. toggle = 3
  410. # Wait/stay put/do nothing
  411. wait = 4
  412. def __init__(self, gridSize=16, maxSteps=100):
  413. # Action enumeration for this environment
  414. self.actions = MiniGridEnv.Actions
  415. # Actions are discrete integer values
  416. self.action_space = spaces.Discrete(len(self.actions))
  417. # The observations are RGB images
  418. self.observation_space = spaces.Box(
  419. low=0,
  420. high=255,
  421. shape=OBS_ARRAY_SIZE,
  422. dtype='uint8'
  423. )
  424. # Range of possible rewards
  425. self.reward_range = (-1, 1000)
  426. # Renderer object used to render the whole grid (full-scale)
  427. self.gridRender = None
  428. # Renderer used to render observations (small-scale agent view)
  429. self.obsRender = None
  430. # Environment configuration
  431. self.gridSize = gridSize
  432. self.maxSteps = maxSteps
  433. self.startPos = (1, 1)
  434. self.startDir = 0
  435. # Initialize the state
  436. self.seed()
  437. self.reset()
  438. def _genGrid(self, width, height):
  439. assert False, "_genGrid needs to be implemented by each environment"
  440. def reset(self):
  441. # Generate a new random grid at the start of each episode
  442. # To keep the same grid for each episode, call env.seed() with
  443. # the same seed before calling env.reset()
  444. self.grid = self._genGrid(self.gridSize, self.gridSize)
  445. # Place the agent in the starting position and direction
  446. self.agentPos = self.startPos
  447. self.agentDir = self.startDir
  448. # Item picked up, being carried, initially nothing
  449. self.carrying = None
  450. # Step count since episode start
  451. self.stepCount = 0
  452. # Return first observation
  453. obs = self._genObs()
  454. return obs
  455. def seed(self, seed=1337):
  456. # Seed the random number generator
  457. self.np_random, _ = seeding.np_random(seed)
  458. return [seed]
  459. def _randInt(self, low, high):
  460. """
  461. Generate random integer in [low,high[
  462. """
  463. return self.np_random.randint(low, high)
  464. def _randPos(self, xLow, xHigh, yLow, yHigh):
  465. """
  466. Generate a random (x,y) position tuple
  467. """
  468. return (
  469. self.np_random.randint(xLow, xHigh),
  470. self.np_random.randint(yLow, yHigh)
  471. )
  472. def _randElem(self, iterable):
  473. lst = list(iterable)
  474. idx = self._randInt(0, len(lst))
  475. return lst[idx]
  476. def getStepsRemaining(self):
  477. return self.maxSteps - self.stepCount
  478. def getDirVec(self):
  479. """
  480. Get the direction vector for the agent, pointing in the direction
  481. of forward movement.
  482. """
  483. # Pointing right
  484. if self.agentDir == 0:
  485. return (1, 0)
  486. # Down (positive Y)
  487. elif self.agentDir == 1:
  488. return (0, 1)
  489. # Pointing left
  490. elif self.agentDir == 2:
  491. return (-1, 0)
  492. # Up (negative Y)
  493. elif self.agentDir == 3:
  494. return (0, -1)
  495. else:
  496. assert False
  497. def getViewExts(self):
  498. """
  499. Get the extents of the square set of tiles visible to the agent
  500. Note: the bottom extent indices are not included in the set
  501. """
  502. # Facing right
  503. if self.agentDir == 0:
  504. topX = self.agentPos[0]
  505. topY = self.agentPos[1] - AGENT_VIEW_SIZE // 2
  506. # Facing down
  507. elif self.agentDir == 1:
  508. topX = self.agentPos[0] - AGENT_VIEW_SIZE // 2
  509. topY = self.agentPos[1]
  510. # Facing right
  511. elif self.agentDir == 2:
  512. topX = self.agentPos[0] - AGENT_VIEW_SIZE + 1
  513. topY = self.agentPos[1] - AGENT_VIEW_SIZE // 2
  514. # Facing up
  515. elif self.agentDir == 3:
  516. topX = self.agentPos[0] - AGENT_VIEW_SIZE // 2
  517. topY = self.agentPos[1] - AGENT_VIEW_SIZE + 1
  518. else:
  519. assert False, "invalid agent direction"
  520. botX = topX + AGENT_VIEW_SIZE
  521. botY = topY + AGENT_VIEW_SIZE
  522. return (topX, topY, botX, botY)
  523. def agentSees(self, x, y):
  524. """
  525. Check if a grid position is visible to the agent
  526. """
  527. topX, topY, botX, botY = self.getViewExts()
  528. return (x >= topX and x < botX and y >= topY and y < botY)
  529. def step(self, action):
  530. self.stepCount += 1
  531. reward = 0
  532. done = False
  533. # Rotate left
  534. if action == self.actions.left:
  535. self.agentDir -= 1
  536. if self.agentDir < 0:
  537. self.agentDir += 4
  538. # Rotate right
  539. elif action == self.actions.right:
  540. self.agentDir = (self.agentDir + 1) % 4
  541. # Move forward
  542. elif action == self.actions.forward:
  543. u, v = self.getDirVec()
  544. newPos = (self.agentPos[0] + u, self.agentPos[1] + v)
  545. targetCell = self.grid.get(newPos[0], newPos[1])
  546. if targetCell == None or targetCell.canOverlap():
  547. self.agentPos = newPos
  548. elif targetCell.type == 'goal':
  549. done = True
  550. reward = 1000 - self.stepCount
  551. # Pick up or trigger/activate an item
  552. elif action == self.actions.toggle:
  553. u, v = self.getDirVec()
  554. objPos = (self.agentPos[0] + u, self.agentPos[1] + v)
  555. cell = self.grid.get(*objPos)
  556. if cell and cell.canPickup():
  557. if self.carrying is None:
  558. self.carrying = cell
  559. self.grid.set(*objPos, None)
  560. elif cell:
  561. cell.toggle(self, objPos)
  562. elif self.carrying:
  563. self.grid.set(*objPos, self.carrying)
  564. self.carrying = None
  565. # Wait/do nothing
  566. elif action == self.actions.wait:
  567. pass
  568. else:
  569. assert False, "unknown action"
  570. if self.stepCount >= self.maxSteps:
  571. done = True
  572. obs = self._genObs()
  573. return obs, reward, done, {}
  574. def _genObs(self):
  575. """
  576. Generate the agent's view (partially observable, low-resolution encoding)
  577. """
  578. topX, topY, botX, botY = self.getViewExts()
  579. grid = self.grid.slice(topX, topY, AGENT_VIEW_SIZE, AGENT_VIEW_SIZE)
  580. for i in range(self.agentDir + 1):
  581. grid = grid.rotateLeft()
  582. # Make it so the agent sees what it's carrying
  583. # We do this by placing the carried object at the agent's position
  584. # in the agent's partially observable view
  585. agentPos = grid.width // 2, grid.height - 1
  586. if self.carrying:
  587. grid.set(*agentPos, self.carrying)
  588. else:
  589. grid.set(*agentPos, None)
  590. # Encode the partially observable view into a numpy array
  591. obs = grid.encode()
  592. return obs
  593. def getObsRender(self, obs):
  594. """
  595. Render an agent observation for visualization
  596. """
  597. if self.obsRender == None:
  598. self.obsRender = Renderer(
  599. AGENT_VIEW_SIZE * CELL_PIXELS // 2,
  600. AGENT_VIEW_SIZE * CELL_PIXELS // 2
  601. )
  602. r = self.obsRender
  603. r.beginFrame()
  604. grid = Grid.decode(obs)
  605. # Render the whole grid
  606. grid.render(r, CELL_PIXELS // 2)
  607. # Draw the agent
  608. r.push()
  609. r.scale(0.5, 0.5)
  610. r.translate(
  611. CELL_PIXELS * (0.5 + AGENT_VIEW_SIZE // 2),
  612. CELL_PIXELS * (AGENT_VIEW_SIZE - 0.5)
  613. )
  614. r.rotate(3 * 90)
  615. r.setLineColor(255, 0, 0)
  616. r.setColor(255, 0, 0)
  617. r.drawPolygon([
  618. (-12, 10),
  619. ( 12, 0),
  620. (-12, -10)
  621. ])
  622. r.pop()
  623. r.endFrame()
  624. return r.getPixmap()
  625. def render(self, mode='human', close=False):
  626. """
  627. Render the whole-grid human view
  628. """
  629. if close:
  630. if self.gridRender:
  631. self.gridRender.close()
  632. return
  633. if self.gridRender is None:
  634. self.gridRender = Renderer(
  635. self.gridSize * CELL_PIXELS,
  636. self.gridSize * CELL_PIXELS,
  637. True if mode == 'human' else False
  638. )
  639. r = self.gridRender
  640. r.beginFrame()
  641. # Render the whole grid
  642. self.grid.render(r, CELL_PIXELS)
  643. # Draw the agent
  644. r.push()
  645. r.translate(
  646. CELL_PIXELS * (self.agentPos[0] + 0.5),
  647. CELL_PIXELS * (self.agentPos[1] + 0.5)
  648. )
  649. r.rotate(self.agentDir * 90)
  650. r.setLineColor(255, 0, 0)
  651. r.setColor(255, 0, 0)
  652. r.drawPolygon([
  653. (-12, 10),
  654. ( 12, 0),
  655. (-12, -10)
  656. ])
  657. r.pop()
  658. # Highlight what the agent can see
  659. topX, topY, botX, botY = self.getViewExts()
  660. r.fillRect(
  661. topX * CELL_PIXELS,
  662. topY * CELL_PIXELS,
  663. AGENT_VIEW_SIZE * CELL_PIXELS,
  664. AGENT_VIEW_SIZE * CELL_PIXELS,
  665. 200, 200, 200, 75
  666. )
  667. r.endFrame()
  668. if mode == 'rgb_array':
  669. return r.getArray()
  670. elif mode == 'pixmap':
  671. return r.getPixmap()
  672. return r