code: def play(
      self,
      game_agent_class_name="GameAgent",
      frame_handler=None,
      **kwargs,
  ):
      if not self.is_launched:
          raise GameError(
              f"Game '{self.__class__.__name__}' is not running..."
          )
  
      self.start_crossbar()
      time.sleep(3)
  
      self.start_input_controller()
  
      game_agent_class = offshoot.discover(
          "GameAgent", selection=game_agent_class_name
      ).get(game_agent_class_name, GameAgent)
  
      if game_agent_class is None:
          raise GameError(
              "The provided Game Agent class name does not map to an existing class..."
          )
  
      game_agent = game_agent_class(
          game=self,
          input_controller=InputController(
              game=self, backend=self.input_controller
          ),
          **kwargs,
      )
  
      # Look if we need to auto-append PNG to frame transformation pipeline based on given frame_handler
      png_frame_handlers = ["RECORD"]
  
      if (
          frame_handler in png_frame_handlers
          and self.frame_transformation_pipeline_string is not None
      ):
          if not self.frame_transformation_pipeline_string.endswith(
              "|PNG"
          ):
              self.frame_transformation_pipeline_string += "|PNG"
  
      self.start_frame_grabber()
      self.redis_client.delete(config["frame_grabber"]["redis_key"])
  
      while (
          self.redis_client.llen(config["frame_grabber"]["redis_key"])
          == 0
      ):
          time.sleep(0.1)
  
      self.window_controller.focus_window(self.window_id)
  
      # Override FPS Config?
      if frame_handler == "RECORD":
          self.game_frame_limiter = GameFrameLimiter(fps=10)
  
      try:
          while True:
              self.game_frame_limiter.start()
  
              game_frame, game_frame_pipeline = self.grab_latest_frame()
  
              try:
                  if self.is_focused:
                      self.pause_callback_fired = False
                      game_agent.on_game_frame(
                          game_frame,
                          game_frame_pipeline,
                          frame_handler=frame_handler,
                          **kwargs,
                      )
                  else:
                      if not self.pause_callback_fired:
                          print("PAUSED\n")
  
                          game_agent.on_pause(
                              frame_handler=frame_handler, **kwargs
                          )
                          self.pause_callback_fired = True
  
                      time.sleep(1)
              except Exception as e:
                  raise e
                  # print(e)
                  # time.sleep(0.1)
  
              self.game_frame_limiter.stop_and_delay()
      except Exception as e:
          raise e
      finally:
          self.stop_frame_grabber()
          self.stop_input_controller()
          self.stop_crossbar()
  
imports: import warnings
  import offshoot
  import subprocess
  import signal
  import shlex
  import time
  import os, os.path
  import atexit
  from serpent.game_agent import GameAgent
  from serpent.game_launchers import *
  from serpent.window_controller import WindowController
  from serpent.input_controller import InputController, InputControllers
  from serpent.frame_grabber import FrameGrabber
  from serpent.game_frame_limiter import GameFrameLimiter
  from serpent.sprite import Sprite
  from serpent.utilities import clear_terminal, is_windows, SerpentError
  import skimage.io
  import skimage.color
  import numpy
  from redis import StrictRedis
  from serpent.config import config
label_desc: Use image node_id 12 for calling the Game obj's underlying member method code with example usage: obj.play(game_agent_class_name, frame_handler) without return types