Gamms Game Record: Hot fix for v1

[bridgesign]

Quick PR for merging recording functionality of agents for Gamms v0.1

The API stability is not guaranteed and as such subject to change.

The example has been modified to show how recording and replaying works.

Quick API reference:

Context has a property called record referring to the recorder. Below is the API definition for recorder:

class Recorder:
    def record(self) -> bool:
        """
        Boolean to inform whether game is being recorded or not and ctx is alive
        """
        pass
   
    def start(self, path: str) -> None:
        """
        Start recording to the path. Raise error if file already exists
        """
        pass

    def stop(self, path: str) -> None:
        """
        Stop recording to the path and close the file handler.
        """
        pass

    def pause(self) -> None:
        """
        Pause the recording process. `self.record()` should return false if paused.  If not started or stopped, give warning.
        """
        pass

    def play(self) -> None:
        """
        Resume recording if paused. If not started or stopped, give warning.
        """
        pass

    def replay(self, path: str) -> Iterator:
        """
        Checks validity of the file and output an iterator.
        """
        pass

    def time(self) -> int64:
        """
        Return record time if replaying else return the Nanosecond time on user clock
        """
        pass

    def write(self, opCode, data) -> None:
        """
        Write to record buffer if recording. If not recording raise error as it should not happen.
        """
        pass

The replay iterator yields a record of the format {"timestamp": Int64, "opCode": opCode, "data": Optional[JsonType]}

The Opcodes are defined at gamms.typing.opcodes for reference.

Other details:

• A requirement for py-ubjson is added for recording serialization. This is unlikely to change for some time.
• Documentation is deferred as it is likely that API might change
• No forward compatibility guarantees