def initialize_agent(self):
# This runs once before the bot starts up
self.controllerState = SimpleControllerState()
self.stateMachine = StateMachine(self)
self.spikeWatcher = SpikeWatcher()
self.lastTime = 0
self.realLastTime = 0
self.doneTicks = 0
self.skippedTicks = 0
self.ticksThisPacket = 0
self.FPS = 120
self.lastQuickChatTime = 0
self.secondMessage = None
self.currentTick = 0
self.firstTpsReport = True
self.game = Game()
self.game.set_mode("soccar")
self.car = self.game.cars[self.index]
self.reorientML = ReorientML(self.car)
self.lastJumpTick = -math.inf
self.maxDodgeTick = 0
self.jumpReleased = True
self.lastDodgeTick = -math.inf
self.lastController = SimpleControllerState()
class ai(subsystem):
"""Main statemachine ai process"""
def __init__(self, default_state_subs=[], loop_time=0.5):
self.state_subs = default_state_subs
self.loop_time = loop_time
self.last_face_number = 0
super().__init__("ai", "id_only")
def _run(self):
self.robot = StateMachine()
t1 = time()
self.status = "Idle()"
self.last_state = "Idle()"
while True:
slp = self.loop_time - (time() - t1)
if slp > 0:
sleep(slp)
t1 = time()
self.check_messages()
self.robot.event()
new_state = self.robot.state
if self.last_state != new_state:
#print("state update:", new_state)
self.last_state = new_state
self.send_state_update(new_state)
def check_messages(self):
#Update flags:
#Receive most recent number of faces in frame.
num_faces = self.get_messages(ref="num_faces")
num_faces = num_faces[0] if len(num_faces) else []
if num_faces and self.last_face_number != num_faces.message:
#print("Number of faces:", num_faces.message)
self.last_face_number = num_faces.message
self.robot.flags.person = bool(num_faces)
#Add processing for the rest of the flags here...
#Handle remaining messages
messages = self.get_messages()
#Subscriber updates
for m in messages:
if m.ref == "state_update_subscribe":
self.state_subs.append(m.sender_id)
if m.ref == "state_update_unsubscribe" and m.sender_id in self.state_subs:
self.state_subs.remove(m.sender_id)
def send_state_update(self, state):
self.status = state
for s in self.state_subs:
self.send_message(s, "ai_state_update", state)
def initialize_agent(self):
# This runs once before the bot starts up
self.controllerState = SimpleControllerState()
self.stateMachine = StateMachine(self)
self.lastTime = 0
self.realLastTime = 0
self.doneTicks = 0
self.skippedTicks = 0
self.ticksThisPacket = 0
self.FPS = 120
self.lastQuickChatTime = 0
self.secondMessage = None
self.tick = 0
self.firstTpsReport = True
class Chatbot(object):
SM = StateMachine()
def run(self, chat_in):
chat_out = self.SM.event(make_lower(chat_in))
return chat_out
def _run(self):
self.robot = StateMachine()
t1 = time()
self.status = "Idle()"
self.last_state = "Idle()"
while True:
slp = self.loop_time - (time() - t1)
if slp > 0:
sleep(slp)
t1 = time()
self.check_messages()
self.robot.event()
new_state = self.robot.state
if self.last_state != new_state:
#print("state update:", new_state)
self.last_state = new_state
self.send_state_update(new_state)
def __init__(self, settings, myid, everyone, loop):
StateMachine.__init__(self)
self.state = Init(self)
self.settings = settings
self.id = myid
self.everyone = everyone
self.loop = loop
self.ledger = [{
MINTED: 0,
NEIGHBOURS: {},
FINE: 0,
PAID: 0,
START: self.loop,
END: self.loop
}]
self.ledgerIndex = [0]
self.diedMessages = []
self.deadNotifiers = {}
def __init__(self):
"""
Initialise finite state machine
"""
RunExp.__init__(self)
self.fsm = StateMachine()
self.fsm.add_state('start', self.start_handler, end_state=False)
self.fsm.add_state('habituation',
self.habituation_handler,
end_state=False)
self.fsm.add_state('pause', self.pause_handler, end_state=False)
self.fsm.add_state('init_trial',
self.init_trial_handler,
end_state=False)
self.fsm.add_state('iti', self.iti_handler, end_state=False)
self.fsm.add_state('pre_probe',
self.pre_probe_handler,
end_state=False)
self.fsm.add_state('probe', self.probe_handler, end_state=False)
self.fsm.add_state('response', self.response_handler, end_state=False)
self.fsm.add_state('end', self.end_handler, end_state=True)
self.fsm.set_start('start')
self.go_next = False
def Run(host="0.0.0.0", port="99", config_path=None):
'''
Run the web server for the site specified by the routes in this module.
:param config_path: Optional additional or alternate configuration file.
'''
Api.SetMyUri(":".join([host, port]))
#Initialize the instance that the API supports.
api.stateMachineInstance = StateMachine()
try:
with open("./state_graph.temp", "r") as f:
api.stateMachineInstance.FromStateGraph(json.loads(f.read()))
except (IOError, ValueError):
pass
webapp.run(host=host, port=port)
with open("./state_graph.temp", "w") as f:
f.write(json.dumps(api.stateMachineInstance.GetStateGraph()))
class Puffy(BaseAgent):
def initialize_agent(self):
# This runs once before the bot starts up
self.controllerState = SimpleControllerState()
self.stateMachine = StateMachine(self)
self.spikeWatcher = SpikeWatcher()
self.lastTime = 0
self.realLastTime = 0
self.doneTicks = 0
self.skippedTicks = 0
self.ticksThisPacket = 0
self.FPS = 120
self.lastQuickChatTime = 0
self.secondMessage = None
self.currentTick = 0
self.firstTpsReport = True
self.game = Game()
self.game.set_mode("soccar")
self.car = self.game.cars[self.index]
self.reorientML = ReorientML(self.car)
self.lastJumpTick = -math.inf
self.maxDodgeTick = 0
self.jumpReleased = True
self.lastDodgeTick = -math.inf
self.lastController = SimpleControllerState()
def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
# self.renderer.begin_rendering()
self.packet = packet
self.handleTime()
self.game.read_game_information(packet, self.get_field_info())
self.spikeWatcher.read_packet(packet)
ballY = packet.game_ball.physics.location.y
if abs(
ballY
) > 5120 + 60 and packet.game_info.seconds_elapsed - self.lastQuickChatTime > 15:
teamDirection = 1 if packet.game_ball.latest_touch.team == 0 else -1
firstByToucher = True
if ballY * teamDirection > 0:
if packet.game_ball.latest_touch.team == packet.game_cars[
self.index].team:
firstMessage, secondMessage = QuickChats.Compliments_NiceShot, QuickChats.Compliments_Thanks
firstByToucher = False
else:
firstMessage, secondMessage = QuickChats.Apologies_Whoops, QuickChats.Apologies_NoProblem
else:
if packet.game_ball.latest_touch.team == packet.game_cars[
self.index].team:
firstMessage, secondMessage = QuickChats.Compliments_WhatASave, QuickChats.Apologies_NoProblem
firstByToucher = False
else:
firstMessage, secondMessage = QuickChats.Compliments_WhatASave, QuickChats.Reactions_Savage
bribbleBots = []
latestTouchIsBribble = False
for carIndex in range(packet.num_cars):
car = packet.game_cars[carIndex]
if car.team == self.team and "Puffy" in car.name:
bribbleBots.append(carIndex)
if packet.game_ball.latest_touch.player_index == carIndex:
latestTouchIsBribble = True
if len(bribbleBots) == 1:
self.send_quick_chat(QuickChats.CHAT_EVERYONE, firstMessage)
self.secondMessage = secondMessage
else:
sendFirst = packet.game_ball.latest_touch.player_index == self.index or (
not latestTouchIsBribble
and self.index == min(bribbleBots))
if not sendFirst ^ firstByToucher:
self.send_quick_chat(QuickChats.CHAT_EVERYONE,
firstMessage)
else:
self.secondMessage = secondMessage
self.lastQuickChatTime = packet.game_info.seconds_elapsed
elif packet.game_info.seconds_elapsed - self.lastQuickChatTime > 0.2 and self.secondMessage != None:
self.send_quick_chat(QuickChats.CHAT_EVERYONE, self.secondMessage)
self.secondMessage = None
self.stateMachine.tick(packet)
self.trackJump(self.stateMachine.currentState.controller)
# self.renderer.end_rendering()
return self.stateMachine.currentState.controller
def trackJump(self, controller: SimpleControllerState):
if controller.jump and not self.lastController.jump and self.car.on_ground and self.currentTick - self.lastJumpTick > 28:
self.lastJumpTick = self.currentTick
self.jumpReleased = False
if self.car.on_ground:
self.maxDodgeTick = math.inf
self.lastJumpTick = -math.inf
self.lastDodgeTick = -math.inf
elif self.lastController.jump and self.currentTick - self.lastJumpTick > 28:
if not controller.jump:
self.maxDodgeTick = self.currentTick + 1.25 * 120
elif self.lastJumpTick == -math.inf:
self.maxDodgeTick = math.inf
else:
self.maxDodgeTick = self.lastJumpTick + 1.45 * 120
if not self.car.on_ground and controller.jump and not self.car.double_jumped and self.currentTick <= self.maxDodgeTick:
self.lastDodgeTick = self.currentTick
if not self.jumpReleased and not controller.jump:
self.jumpReleased = True
self.lastController = controller
def handleTime(self):
# this is the most conservative possible approach, but it could lead to having a "backlog" of ticks if seconds_elapsed
# isnt perfectly accurate.
if not self.lastTime:
self.lastTime = self.packet.game_info.seconds_elapsed
else:
if self.realLastTime == self.packet.game_info.seconds_elapsed:
return
if int(self.lastTime) != int(
self.packet.game_info.seconds_elapsed):
# if self.skippedTicks > 0:
print(f"did {self.doneTicks}, skipped {self.skippedTicks}")
if self.firstTpsReport or self.packet.game_ball.physics.location.x == 0 and self.packet.game_ball.physics.location.y == 0:
self.firstTpsReport = False
elif self.doneTicks < 110:
self.send_quick_chat(QuickChats.CHAT_EVERYONE,
QuickChats.Custom_Excuses_Lag)
self.skippedTicks = self.doneTicks = 0
ticksPassed = round(
max(1,
(self.packet.game_info.seconds_elapsed - self.lastTime) *
self.FPS))
self.lastTime = min(self.packet.game_info.seconds_elapsed,
self.lastTime + ticksPassed)
self.realLastTime = self.packet.game_info.seconds_elapsed
self.currentTick += ticksPassed
if ticksPassed > 1:
# print(f"Skipped {ticksPassed - 1} ticks!")
self.skippedTicks += ticksPassed - 1
self.doneTicks += 1
# setup as a station
#battery.volts()
#print("Battery volts: {0:.2f}v".format(battery.volts()))
#if battery.alarm():
# print('Battery Needs a charge')
#else:
# print('Battery okay')
# roughly works ...
vin = Vin('P16', 'P10')
led = Led('P11')
battery = Battery(py)
# still need work
stateMachine = StateMachine()
bilgeSwitch = BilgeSwitch('P13')
temp = Temp('P9')
button = Button('P14')
check = Checks(led, vin, bilgeSwitch, battery, temp, stateMachine)
check.whichToDo()
# https://forum.pycom.io/topic/1626/pytrack-gps-api/12
# to sleep with GPS VBACKUP on
# should go down to 17ua
# https://forum.pycom.io/topic/2525/power-consumption/16
#
# py.go_to_sleep(True)
def __init__(self, incr):
StateMachine.__init__(self)
self.results = []
self._incr = incr
def __init__(self):
StateMachine.__init__(self)
self._trigger = False
class BribbleBot(BaseAgent):
def initialize_agent(self):
# This runs once before the bot starts up
self.controllerState = SimpleControllerState()
self.stateMachine = StateMachine(self)
self.lastTime = 0
self.realLastTime = 0
self.doneTicks = 0
self.skippedTicks = 0
self.ticksThisPacket = 0
self.FPS = 120
self.lastQuickChatTime = 0
self.secondMessage = None
self.tick = 0
self.firstTpsReport = True
def get_output(self, packet: GameTickPacket) -> SimpleControllerState:
self.packet = packet
self.handleTime()
ballY = packet.game_ball.physics.location.y
if abs(
ballY
) > 5120 + 60 and packet.game_info.seconds_elapsed - self.lastQuickChatTime > 15:
teamDirection = 1 if packet.game_ball.latest_touch.team == 0 else -1
firstByToucher = True
if ballY * teamDirection > 0:
if packet.game_ball.latest_touch.team == packet.game_cars[
self.index].team:
firstMessage, secondMessage = QuickChats.Compliments_NiceShot, QuickChats.Compliments_Thanks
firstByToucher = False
else:
firstMessage, secondMessage = QuickChats.Apologies_Whoops, QuickChats.Apologies_NoProblem
else:
firstMessage, secondMessage = QuickChats.Compliments_WhatASave, QuickChats.Reactions_Savage
bribbleBots = []
latestTouchIsBribble = False
for carIndex in range(packet.num_cars):
car = packet.game_cars[carIndex]
if car.team == self.team and "Bribblebot" in car.name:
bribbleBots.append(carIndex)
if packet.game_ball.latest_touch.player_index == carIndex:
latestTouchIsBribble = True
if len(bribbleBots) == 1:
self.send_quick_chat(QuickChats.CHAT_EVERYONE, firstMessage)
self.secondMessage = secondMessage
else:
sendFirst = packet.game_ball.latest_touch.player_index == self.index or (
not latestTouchIsBribble
and self.index == min(bribbleBots))
if not sendFirst ^ firstByToucher:
self.send_quick_chat(QuickChats.CHAT_EVERYONE,
firstMessage)
else:
self.secondMessage = secondMessage
self.lastQuickChatTime = packet.game_info.seconds_elapsed
elif packet.game_info.seconds_elapsed - self.lastQuickChatTime > 0.2 and self.secondMessage != None:
self.send_quick_chat(QuickChats.CHAT_EVERYONE, self.secondMessage)
self.secondMessage = None
return self.stateMachine.tick(packet)
def handleTime(self):
# this is the most conservative possible approach, but it could lead to having a "backlog" of ticks if seconds_elapsed
# isnt perfectly accurate.
if not self.lastTime:
self.lastTime = self.packet.game_info.seconds_elapsed
else:
if self.realLastTime == self.packet.game_info.seconds_elapsed:
return
if int(self.lastTime) != int(
self.packet.game_info.seconds_elapsed):
# if self.skippedTicks > 0:
print(f"did {self.doneTicks}, skipped {self.skippedTicks}")
if self.firstTpsReport:
self.firstTpsReport = False
elif self.doneTicks < 110:
self.send_quick_chat(QuickChats.CHAT_EVERYONE,
QuickChats.Custom_Excuses_Lag)
self.skippedTicks = self.doneTicks = 0
ticksPassed = round(
max(1,
(self.packet.game_info.seconds_elapsed - self.lastTime) *
self.FPS))
self.lastTime = min(self.packet.game_info.seconds_elapsed,
self.lastTime + ticksPassed)
self.realLastTime = self.packet.game_info.seconds_elapsed
self.tick += ticksPassed
if ticksPassed > 1:
# print(f"Skipped {ticksPassed - 1} ticks!")
self.skippedTicks += ticksPassed - 1
self.doneTicks += 1
GPIO.cleanup()
try:
logger.info('Terminated root process - PID: %s', os.getpid())
unmountGluster()
except Exception:
logger.critical(traceback.format_exc())
def sigtermHandler(signum, stackFrame):
excStopper.set()
logger.info('Caught SIGTERM')
raise SystemExit
if __name__ == '__main__':
try:
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
signal.signal(signal.SIGTERM, sigtermHandler)
with StateMachine() as stateMachine:
excChildListener()
except Exception:
logger.critical(traceback.format_exc())
finally:
clean()
" ",
printCycle(cycle - 2),
": ",
s(log[cycle + 5]),
"\n ",
printCycle(cycle - 1),
": ",
s(log[cycle + 6]),
"\n name = ",
flag.name,
"\n question = ",
flag.question,
end="")
cuteRobot = StateMachine()
# Keep track of states
log = [" ", " ", " ", " ", " ", " ", " "]
for i in range(3000):
cuteRobot.event("")
t_end = time.time() + 2
while time.time() < t_end:
if keyboard.is_pressed('1'):
flag.person = not flag.person
if keyboard.is_pressed('2'):
def __init__(self, incr):
StateMachine.__init__(self)
self.results = [ ]
self._incr = incr
def __init__(self):
StateMachine.__init__(self)
self._trigger = False
class RunStates(RunExp):
"""
Defines and runs the experiment phases as states, with the experiment class
RunExp as an argument.
"""
def __init__(self):
"""
Initialise finite state machine
"""
RunExp.__init__(self)
self.fsm = StateMachine()
self.fsm.add_state('start', self.start_handler, end_state=False)
self.fsm.add_state('habituation',
self.habituation_handler,
end_state=False)
self.fsm.add_state('pause', self.pause_handler, end_state=False)
self.fsm.add_state('init_trial',
self.init_trial_handler,
end_state=False)
self.fsm.add_state('iti', self.iti_handler, end_state=False)
self.fsm.add_state('pre_probe',
self.pre_probe_handler,
end_state=False)
self.fsm.add_state('probe', self.probe_handler, end_state=False)
self.fsm.add_state('response', self.response_handler, end_state=False)
self.fsm.add_state('end', self.end_handler, end_state=True)
self.fsm.set_start('start')
self.go_next = False
def start_handler(self):
"""
start psi process and instantiate all psi marginal objects
"""
self.psiProcess.start()
for frame_ang in self.frame_angles:
self.psi_queue.put({'condition': frame_ang})
self.work_done_queue.get()
# triggers for timers
self.timer_triggers = {}
self.statenames = [
'start', 'habituation', 'init_trial', 'iti', 'pre_probe', 'probe',
'response'
]
for state in self.statenames:
self.timer_triggers[state] = True
self.start_time = time.time()
self.trial_count = 0
self.newState = 'habituation'
self.go_next = True
return (self.newState, self.go_next)
def pause_handler(self):
for stim in self.triggers:
self.triggers[stim] = False
self.pause_screen(self.trial_count)
event.waitKeys(maxWait=float('inf'), keyList=['space'])
# restart habituation and replay interrupted trial
self.trial_count -= 1
self.timer_triggers['habituation'] = True
self.newState = 'habituation'
self.go_next = True
return (self.newState, self.go_next)
def habituation_handler(self):
if self.timer_triggers['habituation']:
self.habituation_timer = time.time()
self.timer_triggers['habituation'] = False
self.triggers['dotsBackground'] = True
self.triggers['circlePatch'] = True
self.display_stimuli()
self.newState = self.check_keys()
if self.newState == 'pause':
self.go_next = True
elif self.newState == 'end':
self.go_next = True
else:
self.newState = 'init_trial'
if (time.time() -
self.habituation_timer) > self.durations['habituation']:
self.go_next = True
else:
self.go_next = False
return (self.newState, self.go_next)
def init_trial_handler(self):
self.data = {}
self.data['trialNr'] = self.trial_count
self.trial_count += 1
# check if this is a break trial
if self.trial_count in self.break_trials:
# increment count because this trial doesn't need to be repeated
self.trial_count += 1
self.newState = 'pause'
self.go_next = True
return (self.newState, self.go_next)
# trial settings
self.rodAngle = None
self.data['trialOnset'] = time.time()
self.data['frameAngle'] = self.trials[self.trial_count]
self.psi_queue.put({'condition': self.data['frameAngle']})
if self.data['frameAngle'] != 'noframe':
self.stimuli['squareFrame'].ori = self.data['frameAngle']
self.triggers['dotsBackground'] = True
self.triggers['circlePatch'] = True
self.display_stimuli()
# reset timer triggers
for state in self.statenames:
self.timer_triggers[state] = True
self.newState = 'iti'
self.go_next = True
return (self.newState, self.go_next)
def iti_handler(self):
if self.timer_triggers['iti']:
self.iti_timer = time.time()
self.timer_triggers['iti'] = False
# attempt to retrieve optimal probe rod angle from psi marginal procedure
if self.rodAngle is None:
try:
self.rodAngle = self.work_done_queue.get(
block=False)['stimValue']
except:
pass
else:
self.data['rodAngle'] = self.rodAngle
self.stimuli['rodStim'].ori = self.rodAngle
self.triggers['dotsBackground'] = True
self.triggers['circlePatch'] = True
self.display_stimuli()
self.newState = self.check_keys()
if self.newState == 'pause':
self.go_next = True
elif self.newState == 'end':
self.go_next = True
else:
self.newState = 'pre_probe'
if (time.time() - self.iti_timer
) > self.durations['iti'] and self.rodAngle is not None:
self.go_next = True
else:
self.go_next = False
return (self.newState, self.go_next)
def pre_probe_handler(self):
if self.timer_triggers['pre_probe']:
self.pre_probe_timer = time.time()
self.timer_triggers['pre_probe'] = False
self.triggers['dotsBackground'] = True
self.triggers['circlePatch'] = True
if self.data['frameAngle'] != 'noframe':
self.triggers['squareFrame'] = True
self.display_stimuli()
self.newState = self.check_keys()
if self.newState == 'pause':
self.go_next = True
elif self.newState == 'end':
self.go_next = True
else:
self.newState = 'probe'
if (time.time() -
self.pre_probe_timer) > self.durations['pre_probe']:
self.go_next = True
else:
self.go_next = False
return (self.newState, self.go_next)
def probe_handler(self):
if self.timer_triggers['probe']:
self.probe_timer = time.time()
self.timer_triggers['probe'] = False
self.triggers['dotsBackground'] = True
self.triggers['circlePatch'] = True
if self.data['frameAngle'] != 'noframe':
self.triggers['squareFrame'] = True
self.triggers['rodStim'] = True
self.display_stimuli()
self.newState = self.check_keys()
if self.newState == 'pause':
self.go_next = True
elif self.newState == 'end':
self.go_next = True
else:
self.newState = 'response'
if (time.time() - self.probe_timer) > self.durations['probe']:
self.go_next = True
else:
self.go_next = False
return (self.newState, self.go_next)
def response_handler(self):
if self.timer_triggers['response']:
self.response_timer = time.time()
self.timer_triggers['response'] = False
self.triggers['dotsBackground'] = True
self.triggers['circlePatch'] = True
if self.data['frameAngle'] != 'noframe':
self.triggers['squareFrame'] = True
self.triggers['rodStim'] = False
self.display_stimuli()
# if response is given, save data and go to next trial
self.newState = self.check_response()
if self.newState == 'init_trial':
self.triggers['squareFrame'] = False
self.psi_queue.put({
'condition': self.data['frameAngle'],
'response': self.data['response']
})
self.save_data()
if self.trial_count == (len(self.trials) - 1):
self.newState = 'end'
self.go_next = True
return self.newState, self.go_next
elif self.newState == 'pause':
self.go_next = True
elif self.newState == 'end':
self.go_next = True
elif (time.time() - self.response_timer) > self.durations['response']:
# when a trial times out, rerun that trial
self.trial_count -= 1
self.triggers['squareFrame'] = False
self.newState = 'init_trial'
self.go_next = True
else:
self.newState = 'init_trial'
self.go_next = False
return (self.newState, self.go_next)
def end_handler(self):
self.newState = None
self.go_next = True
return (self.newState, self.go_next)
from states import flag
from stateMachine import StateMachine
import os
robot = StateMachine()
prompt = "\n> "
while True:
os.system('clear')
print("")
robot.event("")
print("\nCurrent State:", robot.state)
flag.printFlags()
x = input(prompt)
if x == "person appears":
flag.person = True
prompt = "\n> person "
elif x == "disappears" or x == "(person disappears)":
flag.person = False
prompt = "\n> "
elif x == "asks question":
flag.processing = True
prompt = "\n> their question is "
elif x == "invalid":
flag.processing = False
flag.question = -1
