run_simple_stdin_bot.py

import sys
import json
import random

# The communication is done over stdin. Every line received is a json. Every message read requires a reply. Example:
# {
#   "type": "commands",
#   "command": "ld"
# }

pressed = set()

def reply():
  print(json.dumps({
    "type":"commands",
    "command": ''.join(pressed)
  }))
  # Always flush after you are done.
  sys.stdout.flush()
  pressed.clear()

def press(b):
  pressed.add(b)

state_init = None
state_scenario = None
state_update = None

# When communicating over stdio, make sure logging goes to stderr
sys.stderr.write('I started')
sys.stderr.flush()

while True:
  # Read the state of the game in a loop.
  game_state = json.loads(sys.stdin.readline())

  # There are three main types to handle, 'init', 'scenario' and 'update'.
  # Check 'type' to handle each accordingly.
  if game_state['type'] == 'init':
    # 'init' is sent every time a match series starts. It contains information about the players and teams.
    # The seed is based on the bot index so each bots acts differently.
    state_init = game_state
    random.seed(state_init['index'])
    reply()
    continue

  if game_state['type'] == 'scenario':
    # 'scenario' informs your bot about the current state of the ground. Store this information
    # to use in all subsequent loops. (This example bot doesn't use the shape of the scenario)
    state_scenario = game_state
    reply()
    continue

  if game_state['type'] == 'update':
    # 'update' informs the state of entities in the map (players, arrows, enemies, etc).
    state_update = game_state

  # After receiving an 'update', your bot is expected to output string with the pressed buttons.
  # Each button is represented by a character:
  # r = right
  # l = left
  # u = up
  # d = down
  # j = jump
  # z = dash
  # s = shoot
  # The order of the characters are irrelevant. Any other character is ignored. Repeated characters are ignored.

  # This bot acts based on the position of the other player only. It
  # has a very random playstyle:
  #  - Runs to the enemy when they are below.
  #  - Runs away from the enemy when they are above.
  #  - Shoots when in the same horizontal line.
  #  - Dashes randomly.
  #  - Jumps randomly.

  my_state = None
  enemy_state = None

  players = []

  if not state_init:
    raise Exception('No state_init')
  if not state_update:
    raise Exception('No state_update')

  for state in state_update['entities']:
    if state['type'] == 'archer':
      players.append(state)
      if state['playerIndex'] == state_init['index']:
        my_state = state

  # Bot only does anything if player is in game.
  if my_state == None:
    reply()
    continue

  for state in players:
    if state['team'] != my_state['team']:
      enemy_state = state

  # Bot only does anything if there is a player.
  if enemy_state == None:
    reply()
    continue

  my_pos = my_state['pos']
  enemy_pos = enemy_state['pos']
  if enemy_pos['y'] >= my_pos['y']:
    # Runs away if enemy is above
    if my_pos['x'] < enemy_pos['x']:
      press('l')
    else:
      press('r')
  else:
    # Runs to enemy if they are below
    if my_pos['x'] < enemy_pos['x']:
      press('r')
    else:
      press('l')

    # If in the same line shoots,
    if abs(my_pos['y'] - enemy_pos['y']) < enemy_state['size']['y']:
      press('s')

  # Presses dash in 1/10 of the loops.
  if random.randint(0, 9) == 0:
    press('z')

  # Presses jump in 1/20 of the loops.
  if random.randint(0, 19) == 0:
    press('j')

  # Issue the command back to the game.
  reply()