class Wife(BaseGameEntity):
def __init__(self, name='wife', wid=None, location=Location.shack):
super().__init__()
if wid != None:
#override the assigned id
self.id = wid
self.name = name
self.location = location
self.cooking = False
self.state_machine = StateMachine(self)
self.state_machine.current_state = DoHouseWork.instance()
self.state_machine.global_state = WifeGlobalState.instance()
def change_location(self, new_location):
self.location = new_location
def update(self):
self.state_machine.update()
def handle_message(self, msg):
return self.state_machine.handle_message(msg)
def __repr__(self):
return self.name
def __init__(self, username):
self.username = username
self._server_protocol = None
self._print_buffer = ''
self._game_list = []
self._waiting_for_list = False
self._waiting_for_join = False
self._waiting_for_start = False
self._in_game = False
self.client = client.Client()
self.game_id = None
self._update_interval = 15
self.pump_return = None
self.fsm = StateMachine()
self.fsm.add_state('START', None, lambda _: 'MAINMENU')
self.fsm.add_state('MAINMENU', self._main_menu_arrival,
self._main_menu_transition)
self.fsm.add_state('SELECTGAME', self._select_game_arrival,
self._select_game_transition)
self.fsm.add_state('END', None, None, True)
self.fsm.set_start('START')
self.fsm.pump(None)
def __init__(self, username):
self.username = username
self._server_protocol = None
self._print_buffer = ''
self._game_list = []
self._waiting_for_list = False
self._waiting_for_join = False
self._waiting_for_start = False
self._in_game = False
self.client = client.Client()
self.game_id = None
self.pump_return = None
self._gui = CursesGUI()
self._gui.choice_callback = self.handle_choice_input
self._gui.command_callback = self.handle_command_input
self._gui.help_callback = self.print_help
self.fsm = StateMachine()
self.fsm.add_state('START', None, lambda _ : 'MAINMENU')
self.fsm.add_state('MAINMENU',
self._main_menu_arrival, self._main_menu_transition)
self.fsm.add_state('SELECTGAME',
self._select_game_arrival, self._select_game_transition)
self.fsm.add_state('END', None, None, True)
self.fsm.set_start('START')
self.fsm.pump(None)
def __init__(self,name='wife',location=Location.shack):
super().__init__()
self.name = name
self.location = location
self.state_machine = StateMachine(self)
self.state_machine.current_state = DoHouseWork.instance()
self.state_machine.global_state = WifeGlobalState.instance()
def __init__(self,name='anonymous'):
super().__init__()
self.location = Location.shack
self.gold_carried = 0
self.money_in_bank = 0
self.thirst = 0
self.fatigue = 0
## self.current_state = GoHomeAndSleepTilRested.instance()
self.name = name
self.state_machine = StateMachine(self)
self.state_machine.current_state = GoHomeAndSleepTilRested.instance()
def find_strings(char_stream):
fsm = StateMachine(TRANSITIONS, State.DEFAULT, State.LOOK_FOR_STRING)
for state, action, ch in fsm.process(char_stream):
if action == State.IGNORE:
continue
elif action == State.START_NEW_STRING:
result = []
elif action == State.ADD_CURRENT_TO_STRING:
result.append(ch)
elif action == State.FINISH_CURRENT_STRING:
yield "".join(result)
def __init__(self, name='wife', wid=None, location=Location.shack):
super().__init__()
if wid != None:
#override the assigned id
self.id = wid
self.name = name
self.location = location
self.cooking = False
self.state_machine = StateMachine(self)
self.state_machine.current_state = DoHouseWork.instance()
self.state_machine.global_state = WifeGlobalState.instance()
def __init__(self, name='anonymous', mid=None):
super().__init__()
if mid != None:
#override the assigned id if the user passes one in
self.id = mid
self.name = name
self.location = Location.saloon
self.gold_carried = 0
self.money_in_bank = 0
self.thirst = 0
self.fatigue = 0
self.state_machine = StateMachine(self)
self.state_machine.current_state = GoHomeAndSleepTilRested.instance()
def __init__(self,
image,
pitch,
team,
home,
heading,
model=model.initial_model,
**kwargs):
super().__init__('redshirt0') #image, **kwargs)
self.max_turn_rate = model.player_max_turn_rate
self.max_force = model.player_max_force
self.max_speed = model.player_max_speed
#register with the entity_manager
model.entity_manager.register(self)
self.home = Vector2(home)
self.pos = Vector2(home)
self.mass = model.player_mass
# self.velocity = Vector2()
# self.heading = Vector2(heading)
_, self.angle = Vector2(heading).as_polar()
print('...creating player{}: @ position {}, angle {}'.format(
self.id, self.pos, self.angle))
# in case the velocity is zero
if self.speed < 0.00001:
self.angle = 0.0
# self.set_orientation(Vector2(heading))
self.model = model
self.max_speed_with_ball = model.player_max_speed_with_ball
self.receiving_range = model.ball_within_receiving_range
self.role = None
self.pitch = pitch
self.team = team
self.steering = SteeringBehaviors(self)
self.steering.separation_on()
self.state = PState.wait
self.fsm = StateMachine(self)
self.fsm.current_state = self.state
self.fsm.previous_state = self.state
self.fsm.global_state = PState.global_player
self.fsm.current_state.enter(self)
def __init__(self,
side,
pitch,
display_model=model.initial_model,
entity_manager=model.initial_model.entity_manager,
dispatcher=model.initial_model.dispatcher):
# self.model = model
self.pitch = pitch
self.view = View(display_model)
self.view.model = self
self.side = side
self._entity_manager = entity_manager
self._dispatcher = dispatcher
if side == HOME:
self.color = pg.Color('red')
self.goal = self.pitch.home_goal
self.opponent_goal = self.pitch.away_goal
self.init_heading = Vector2(-1, 0)
elif side == AWAY:
self.color = pg.Color('blue')
self.goal = self.pitch.away_goal
self.opponent_goal = self.pitch.home_goal
self.init_heading = Vector2(1, 0)
else:
raise ValueError("side must be either 'HOME' or 'AWAY' ")
self.players = self.create_players()
self.opponent = None
self._controlling_player = None
self._supporting_player = None
self._receiving_player = None
self.player_closest_to_ball = None
self.dist_sq_to_ball_from_closest_player = sys.float_info.max
self.support_spot_calculator = SupportSpotCalculator()
self.fsm = StateMachine(self)
self.fsm.current_state = TeamState.defending
self.fsm.previous_state = TeamState.defending
self.fsm.global_state = None
class Wife(BaseGameEntity):
def __init__(self,name='wife',location=Location.shack):
super().__init__()
self.name = name
self.location = location
self.state_machine = StateMachine(self)
self.state_machine.current_state = DoHouseWork.instance()
self.state_machine.global_state = WifeGlobalState.instance()
def change_location(self, new_location):
self.location = new_location
def update(self):
self.state_machine.update()
def __repr__(self):
return self.name
def main():
global encodedLine, insCounter, lineCounter, repeatFlag, isC
global repeatBuffer, writeRepeat, writeLineFlag, repetitions
F = open("asm.txt", "r")
try:
os.remove("instructionsOut.txt")
except:
pass
F2 = open("instructionsOut.txt", "a+")
FLines = F.readlines()
#Initializing the state machine
m = StateMachine()
m.add_state("Start", startState)
m.add_state("OperandState", OperandState)
m.add_state("regDestState", regDestState)
m.add_state("regSrc1State", regSrc1State)
m.add_state("immSrc1State", immSrc1State)
m.add_state("regSrc2State", regSrc2State)
m.add_state("immSrc2State", immSrc2State)
m.add_state("doneState", None, end_state=1)
m.add_state("ErrorState", ErrorState)
m.set_start("Start")
print(FLines)
line = 1
lineCounter = 1
for l in FLines:
print("Instruction")
print(lineCounter)
print("Line")
print(line)
print(l)
if m.run(l):
if writeLineFlag:
F2.write(encodedLine + "\r")
if repeatFlag:
repeatBuffer = repeatBuffer + encodedLine + "\r"
if writeRepeat:
while repetitions > 0:
F2.write(repeatBuffer)
repetitions -= 1
writeRepeat = False
repeatBuffer = ""
encodedLine = "0000000000000000"
insCounter = 0
lineCounter += 1
line += 1
writeLineFlag = True
isC = False
if repeatFlag:
print("Repeate cycle not closed")
F.close()
class TerminalGUI(object):
def __init__(self, username):
self.username = username
self._server_protocol = None
self._print_buffer = ''
self._game_list = []
self._waiting_for_list = False
self._waiting_for_join = False
self._waiting_for_start = False
self._in_game = False
self.client = client.Client()
self.game_id = None
self.pump_return = None
self._gui = CursesGUI()
self._gui.choice_callback = self.handle_choice_input
self._gui.command_callback = self.handle_command_input
self._gui.help_callback = self.print_help
self.fsm = StateMachine()
self.fsm.add_state('START', None, lambda _ : 'MAINMENU')
self.fsm.add_state('MAINMENU',
self._main_menu_arrival, self._main_menu_transition)
self.fsm.add_state('SELECTGAME',
self._select_game_arrival, self._select_game_transition)
self.fsm.add_state('END', None, None, True)
self.fsm.set_start('START')
self.fsm.pump(None)
def set_log_level(self, level):
"""Set the log level as per the standard library logging module.
Default is logging.INFO.
"""
self._gui.set_log_level(level)
logging.getLogger('gtr.game').setLevel(level)
logging.getLogger('gtr').setLevel(level)
def set_server_protocol(self, p):
"""Set the protocol interface to the server. This should be a
NetstringReceiver object.
"""
self._server_protocol = p
def _input_choice(self, choice):
"""Provides an input for the state machine. This function
potentially returns a GameAction object, which is a command
to be sent to the server.
"""
# Convert from 1-indexed in the UI to the 0-indexed choices_list
self.fsm.pump(int(choice)-1)
return self.pump_return
def print_help(self):
lg.warn('Help! (q to quit)')
def handle_command_input(self, command):
lg.debug('Handling command input : ' + str(command))
if command in ['help', 'h', '?']:
self.print_help()
return
elif command in ['restart', 'r']:
self.client.restart_command()
return
elif command in ['refresh', 'f']:
self.send_command(GameAction(message.REQGAMESTATE))
return
elif command in ['quit', 'q']:
lg.error('Quitting game')
self._server_protocol.loseConnection()
self._gui.quit()
return
if self._in_game and not self.client.builder:
lg.error("It's not your turn")
return
def handle_choice_input(self, choice):
"""Handles an input choice (integer, 1-indexed).
"""
try:
choice = int(choice)
except ValueError:
lg.warn('Invalid choice: {0}\n'.format(choice))
return
lg.debug('Selection is ' + str(choice))
if self._in_game:
self.client.make_choice(choice)
action = self.client.check_action_builder()
if action is None:
lg.debug('More input is required, updating choices list')
self.update_choices()
else:
lg.debug('Sending to server: ' + str(action))
self.client.builder = None
self.send_command(action)
else:
game_action = self._input_choice(choice)
if game_action:
lg.debug('Sending to server: ' + str(game_action))
self.send_command(game_action)
def _main_menu_arrival(self):
choices = ['List games', 'Join game', 'Create game', 'Start game']
self.choices = [Choice(desc, desc) for desc in choices]
def _main_menu_transition(self, choice):
choice = self.choices[choice].item
if choice == 'List games':
self.pump_return = GameAction(message.REQGAMELIST)
self._waiting_for_list = True
return 'MAINMENU'
elif choice == 'Join game':
if len(self._game_list) == 0:
lg.info('No games listed. Getting game list first.')
self.pump_return = GameAction(message.REQGAMELIST)
self._waiting_for_list = True
return 'MAINMENU'
else:
return 'SELECTGAME'
elif choice == 'Create game':
lg.info('Creating new game.')
self.pump_return = GameAction(message.REQCREATEGAME)
self._waiting_for_join = True
return 'MAINMENU'
elif choice == 'Start game':
lg.info('Requesting game start.')
self.pump_return = GameAction(message.REQSTARTGAME)
self._waiting_for_start = True
return 'MAINMENU'
else:
return 'END'
def _select_game_arrival(self):
# we only get here if the game list is populated
self.choices = [Choice(i, str(game)) for i, game in enumerate(self._game_list)]
self._show_choices()
def _select_game_transition(self, choice):
game_id = self.choices[choice].item
self._waiting_for_join = True
self.pump_return = GameAction(message.REQJOINGAME, game_id)
return 'MAINMENU'
def _show_choices(self, prompt=None):
"""Returns the index in the choices_list selected by the user or
raises a StartOverException or a CancelDialogExeption.
The choices_list is a list of Choices.
"""
i_choice = 1
choices_list = []
if not self.choices:
self.choices.append(Choice(None, "(none)"))
for c in self.choices:
line = ''
if c.selectable:
line = ' [{0:2d}] {1}'.format(i_choice, c.description)
i_choice+=1
else:
line = ' {0}'.format(c.description)
choices_list.append(line)
self._gui.update_choices(choices_list)
if prompt is None:
prompt = 'Please make a selection: '
self._gui.update_prompt(prompt)
def send_command(self, game_action):
self._server_protocol.send_command(self.username, self.game_id, game_action)
def update_game_list(self, game_list):
self._game_list = game_list
if self._waiting_for_list:
self._waiting_for_list = False
game_list = ['Available games']
for record in self._game_list:
game_list.append(' ' + str(record))
self._gui.update_state('\n'.join(game_list))
self._show_choices()
def update_game_state(self, game_state):
if game_state is None:
return
player_index = None
for p in game_state.players:
if p.name == self.username:
player_index = game_state.players.index(p)
self.client.player_id = player_index
break
if self._waiting_for_start or game_state.is_started:
self._waiting_for_start = False
self._in_game = True
old_gs = self.client.game.game_state
old_game_id = old_gs.game_id if old_gs else None
new_game_id = game_state.game_id
if old_game_id is None or old_game_id != new_game_id:
self.client.update_game_state(game_state)
action = self.client.check_action_builder()
if action:
lg.debug('Action is complete without requiring a choice.')
self.send_command(action)
else:
lg.debug('Action requires user input. Displaying game state.')
display = GameStateTextDisplay(game_state, game_state.players[player_index])
self._gui.update_state('\n'.join(display.public_text_string()))
self._gui.update_game_log('\n'.join(game_state.game_log))
self.update_choices()
def update_choices(self):
choices = self.client.get_choices()
if choices is None:
lg.error('Choices list is empty')
import pdb; pdb.set_trace()
lines = [' [1] ERROR! Choices list is empty']
else:
lines = []
i_choice = 1
for c in choices:
if c.selectable:
lines.append(' [{0:2d}] {1}'.format(i_choice, c.description))
i_choice+=1
else:
lines.append(' {0}'.format(c.description))
self._gui.update_choices(lines)
def set_player_id(self, i):
self.client.player_id = i
def join_game(self, game_id):
lg.info('Joined game {0:d}.'.format(game_id))
self.game_id = game_id
self._waiting_for_join = False
self._show_choices()
class Miner(BaseGameEntity):
COMFORT_LEVEL = 5
MAX_NUGGETS = 3
THIRST_LEVEL = 5
TIREDNESS_THRESHOLD = 5
def __init__(self, name='anonymous', mid=None):
super().__init__()
if mid != None:
#override the assigned id if the user passes one in
self.id = mid
self.name = name
self.location = Location.saloon
self.gold_carried = 0
self.money_in_bank = 0
self.thirst = 0
self.fatigue = 0
self.state_machine = StateMachine(self)
self.state_machine.current_state = GoHomeAndSleepTilRested.instance()
def change_state(self, new_state):
self.current_state.exit(self)
self.current_state = new_state
self.current_state.enter(self)
def add_to_gold_carried(self, val):
self.gold_carried += val
self.gold_carried = max(0, self.gold_carried)
def add_to_wealth(self, val):
self.money_in_bank += val
self.money_in_bank = max(0, self.money_in_bank)
def thirsty(self):
return self.thirst >= self.THIRST_LEVEL
def fatigued(self):
return self.fatigue >= self.TIREDNESS_THRESHOLD
def pockets_full(self):
return self.gold_carried >= self.MAX_NUGGETS
def buy_and_drink_whiskey(self):
self.thirst = 0
self.money_in_bank -= 2
def change_location(self, new_location):
self.location = new_location
def increase_fatigue(self):
self.fatigue += 1
def decrease_fatigue(self):
self.fatigue -= 1
def wealth(self):
return self.money_in_bank
def update(self):
self.thirst += 1
self.state_machine.update()
def handle_message(self, msg):
return self.state_machine.handle_message(msg)
def __repr__(self):
return self.name
class BasePlayer(MovingEntity):
# max_speed_with_ball = None
# receiving_range = None
# @classmethod
# def initialize_class_parameters(cls,**kwargs):
# cls.max_speed_with_ball = kwargs['max_speed_with_ball']
# cls.receiving_range = kwargs['receiving_range']
def __init__(self,
image,
pitch,
team,
home,
heading,
model=model.initial_model,
**kwargs):
super().__init__('redshirt0') #image, **kwargs)
self.max_turn_rate = model.player_max_turn_rate
self.max_force = model.player_max_force
self.max_speed = model.player_max_speed
#register with the entity_manager
model.entity_manager.register(self)
self.home = Vector2(home)
self.pos = Vector2(home)
self.mass = model.player_mass
# self.velocity = Vector2()
# self.heading = Vector2(heading)
_, self.angle = Vector2(heading).as_polar()
print('...creating player{}: @ position {}, angle {}'.format(
self.id, self.pos, self.angle))
# in case the velocity is zero
if self.speed < 0.00001:
self.angle = 0.0
# self.set_orientation(Vector2(heading))
self.model = model
self.max_speed_with_ball = model.player_max_speed_with_ball
self.receiving_range = model.ball_within_receiving_range
self.role = None
self.pitch = pitch
self.team = team
self.steering = SteeringBehaviors(self)
self.steering.separation_on()
self.state = PState.wait
self.fsm = StateMachine(self)
self.fsm.current_state = self.state
self.fsm.previous_state = self.state
self.fsm.global_state = PState.global_player
self.fsm.current_state.enter(self)
# TODO: implement and test regulator
# self.kick_limiter = Regulator(self.model.player_kick_frequency)
def update(self, dt):
self.fsm.update()
self.steering.calculate()
#apply braking if there is no steering force but there is velocity
if self.steering.steering_force.length() < 0.0001 and (
self.velocity.length_squared() > 0.001):
braking_rate = 0.8
self.velocity *= braking_rate
# first calculate the speed change due to the force
#FORWARD COMPONENT CALC
# get the components now because updating the angle and
# velocity will change the computations
forward_component = self.steering.forward_component()
side_component = self.steering.side_component()
# first calculate the velocity change due to turning
dAngle = (side_component * self.max_turn_rate)
# this will adjust the heading...
self.angle -= dAngle
speed = abs(forward_component) * self.max_speed
self.velocity = (speed / self.mass) * self.heading
#FORWARD COMPONENT CALC
# accel = self.heading * forward_component/ self.mass
# self.velocity += accel
# self.exact_pos += self.velocity
# self.exact_pos += speed * self.heading #self.velocity
self.exact_pos = self.exact_pos + self.velocity
# if debug_output:
# print(' prevPos = {} position={}'.format(self.prev_pos, self.exact_pos))
# print('---END UPDATE\n\n')
def draw(self, screen):
super().draw()
#
# Show Rendering Aids - Steering_Force
#
#DEBUG
screen.draw.circle(self.home, 10, (255, 0, 0))
# if self.at_home():
#print ID
screen.draw.text(str(self.id), self.exact_pos + Vector2(0, -20))
if self.model.show_steering_force:
screen.draw.line(
self.exact_pos,
self.exact_pos + self.model.steering_force_display_length *
self.steering.steering_force, (200, 0, 0))
if self.model.show_player_states:
states = ""
if self.steering.is_seek_on():
states += "S"
if self.steering.is_arrive_on():
states += "A"
if self.steering.is_separation_on():
states += "Sp"
if self.steering.is_pursuit_on():
states += "P"
if self.steering.is_interpose_on():
states += "I"
if len(states) > 0:
offset = self.exact_pos + (self.heading * 5) + Vector2(0, 5)
screen.draw.text(states, offset)
if self.model.show_heading:
screen.draw.line(self.exact_pos,
self.exact_pos + 50 * self.heading, (0, 255, 0))
screen.draw.line(self.exact_pos, self.exact_pos + 50 * self.side,
(0, 0, 255))
def ball_within_receiving_range(self):
return self.exact_pos.distance_to(self.ball()) < self.receiving_range
def track_ball(self):
return self.rotate_heading_to_face_position(self.ball())
def is_controlling_player(self):
return False
def at_home(self):
return self.at_target(self.home)
# return self.exact_pos.distance_to(self.home) < 0.001
def at_target(self, target):
if self.id == 1:
print('[FieldPlayer.at_target] pos: {}, target: {}, dist: {} '.
format(self.exact_pos, target,
self.exact_pos.distance_to(Vector2(target))))
print(' vel= {}, speed= '.format(self.velocity, self.speed))
return self.exact_pos.distance_to(Vector2(target)) < 1.0
def arrive_on(self):
self.steering.on(BehaviorType.ARRIVE)
def arrive_off(self):
self.steering.off(BehaviorType.ARRIVE)
@property
def tagged(self):
return self.steering.tagged
@property
def ball(self):
return self.pitch.ball
def __repr__(self):
if 'GoalKeeper' in str(type(self)):
position = '*'
else:
position = ''
return '{{[player{}{}] {}}}'.format(self.id, position, self.exact_pos)
newState = "error_state"
return (newState, txt)
def not_state_transitions(txt):
splitted_txt = txt.split(None,1)
word, txt = splitted_txt if len(splitted_txt) > 1 else (txt,"")
if word in positive_adjectives:
newState = "neg_state"
elif word in negative_adjectives:
newState = "pos_state"
else:
newState = "error_state"
return (newState, txt)
def neg_state(txt):
print("Hallo")
return ("neg_state", "")
if __name__== "__main__":
m = StateMachine()
m.add_state("Start", start_transitions)
m.add_state("Python_state", python_state_transitions)
m.add_state("is_state", is_state_transitions)
m.add_state("not_state", not_state_transitions)
m.add_state("neg_state", None, end_state=1)
m.add_state("pos_state", None, end_state=1)
m.add_state("error_state", None, end_state=1)
m.set_start("Start")
m.run("Python is great")
m.run("Python is difficult")
m.run("Perl is ugly")
def __init__(self, initial, states=[]): StateMachine.__init__(self, initial, states)
from fsm import StateMachine, State
import time
traffic_light = StateMachine("LIGHT_GREEN")
light_green = State()
light_yellow = State()
light_red = State()
traffic_light["LIGHT_GREEN"] = light_green
traffic_light["LIGHT_YELLOW"] = light_yellow
traffic_light["LIGHT_RED"] = light_red
@light_green.transition
def switch():
return "LIGHT_YELLOW"
@light_yellow.transition
def switch():
return "LIGHT_RED"
@light_red.transition
def switch():
return "LIGHT_GREEN"
if __name__ == "__main__":
while True:
print("Current State: " + traffic_light.state)
from signals import SignalProcessing
from timer_class import TimerClass
from comm import USBCommunication
from fsm import StateMachine
import time
# signal_interval, signal_history_window, state_interval, state_history_window in sec
timer_class = TimerClass(0.05, 10.0, 1.0, 100) # for timer data
fsm_class = StateMachine(timer_class) # for updating the stage of sleep
# create the comm class and start it to read values from the COM port
# set fake to false if you want to connect to the microcontroller
comm_class = USBCommunication('/dev/cu.usbmodem146131',
115200,
fake=False,
write_to_csv=True,
delay=0.001)
# create the signal processing class to manage the comm data
# USBCommunication() class, SignalTimer() class
signal_class = SignalProcessing(comm_class, timer_class)
# updates for both the raw sensor readings and the fsm
sensor_update_last_time = timer_class.get_time()
fsm_update_last_time = timer_class.get_time()
# plotting help
import matplotlib.pyplot as plt
def first_window_attempt():
"""
The first attempt at creating a gui.
:return None:
"""
class InitialState(BaseState):
"""
Initial state for the SimpleGUI.
"""
def _on_enter(self, gui):
"""
Construct the buttons upon entering the state.
:return:
"""
print("In initial state.")
'''Create label'''
self.label = tk.Label(gui.root, text="First GUI")
self.label.pack()
'''Create buttons'''
gui.pack_button = tk.Button(gui.root,
text="Buttons",
command=self.adjust_buttons(gui),
font=Font(size=50))
gui.pack_button.pack()
gui.greet_button = tk.Button(gui.root,
text="Greet",
command=self._greet,
font=Font(size=50))
gui.close_button = tk.Button(gui.root,
text="Close",
command=gui.root.quit,
font=Font(size=50))
gui.update()
def adjust_buttons(self, gui):
"""
Adjust the buttons.
:return:
"""
def _adjust_buttons():
print("\tButton clicked.")
if gui.buttons_on.get():
print("\t\tDetected buttons are on.")
self._remove_buttons(gui)
else:
print("\t\tDetected buttons are off.")
self._add_buttons(gui)
return _adjust_buttons
def _add_buttons(self, gui):
"""
Add buttons to the view.
:return:
"""
gui.greet_button.pack()
gui.close_button.pack()
gui.buttons_on.set(True)
def _remove_buttons(self, gui):
"""
Remove buttons from the view.
:return:
"""
gui.greet_button.pack_forget()
gui.close_button.pack_forget()
gui.buttons_on.set(False)
def _greet(self, gui):
"""
:param gui:
:return:
"""
def _on_exit(self, gui):
"""
Return the next state.
:param gui:
:return:
"""
gui.update()
return ButtonsOff()
class ButtonsOn(BaseState):
"""
State for having buttons on.
"""
def _on_enter(self, gui):
"""
:param gui:
:return:
"""
print("In buttons on state.")
def _state_main(self, gui):
"""
The main code for the ButtonsOn state.
:param gui:
:return:
"""
gui.pack_button.wait_variable(gui.buttons_on)
def _on_exit(self, gui):
if gui.program_running:
gui.update()
return ButtonsOff()
else:
return None
class ButtonsOff(BaseState):
"""
State for having buttons off.
"""
def _on_enter(self, gui):
"""
:param gui:
:return:
"""
print("In buttons off state.")
def _state_main(self, gui):
"""
The main code for the ButtonsOn state.
:param gui:
:return:
"""
gui.pack_button.wait_variable(gui.buttons_on)
def _on_exit(self, gui):
if gui.program_running:
gui.update()
return ButtonsOn()
else:
return None
class SimpleGUI:
"""
Object for a simple gui.
"""
def __init__(self, root):
"""
Initializing the SimpleGUI object.
"""
self.root = root
w, h = root.winfo_screenwidth(), self.root.winfo_screenheight()
self.root.geometry("%dx%d+0+0" % (w, h))
self.root.protocol("WM_DELETE_WINDOW", self.end_program)
self.buttons_on = tk.BooleanVar()
self.buttons_on.set(False)
self.program_running = True
def update(self):
"""
Update the GUI.
:return:
"""
self.root.update_idletasks()
self.root.update()
return self.root
def end_program(self):
"""
Ends the program.
:return:
"""
self.buttons_on.set(not self.buttons_on.get())
self.root.destroy()
self.program_running = False
'''Initialize and run GUI object'''
root = tk.Tk()
# Maximize window while maintaining title bar
gui = SimpleGUI(root)
state_machine = StateMachine(initial_state=InitialState())
state_machine.run(gui)
class TerminalGUI(object):
def __init__(self, username):
self.username = username
self._server_protocol = None
self._print_buffer = ''
self._game_list = []
self._waiting_for_list = False
self._waiting_for_join = False
self._waiting_for_start = False
self._in_game = False
self.client = client.Client()
self.game_id = None
self._update_interval = 15
self.pump_return = None
self.fsm = StateMachine()
self.fsm.add_state('START', None, lambda _: 'MAINMENU')
self.fsm.add_state('MAINMENU', self._main_menu_arrival,
self._main_menu_transition)
self.fsm.add_state('SELECTGAME', self._select_game_arrival,
self._select_game_transition)
self.fsm.add_state('END', None, None, True)
self.fsm.set_start('START')
self.fsm.pump(None)
def set_server_protocol(self, p):
"""Set the protocol interface to the server. This should be a
NetstringReceiver object.
"""
self._server_protocol = p
def _input_choice(self, choice):
"""Provides an input for the state machine. This function
potentially returns a GameAction object, which is a command
to be sent to the server.
"""
# Convert from 1-indexed in the UI to the 0-indexed choices_list
self.fsm.pump(int(choice) - 1)
return self.pump_return
def handle_client_input(self, command):
"""Handle input from client.
"""
if command in ['help', 'h', '?']:
self.print_help()
return
elif command in ['restart', 'r']:
self.client.restart_command()
return
elif command in ['refresh', 'f']:
self.send_command(GameAction(message.REQGAMESTATE))
return
elif command in ['quit', 'q']:
lg.info('Quitting game')
self._server_protocol.loseConnection()
from twisted.internet import reactor
reactor.stop()
return
if self._in_game and not self.client.builder:
lg.info("It's not your turn")
return
try:
choice = int(command)
except ValueError:
sys.stderr.write('Invalid choice: {0}\n'.format(command))
self.print_help()
return
if self._in_game:
action = self.client.make_choice(choice)
if action is not None:
print 'doing action ' + repr(action)
self.send_command(action)
else:
game_action = self._input_choice(choice)
if game_action:
self.send_command(game_action)
def _main_menu_arrival(self):
choices = ['List games', 'Join game', 'Create game', 'Start game']
self.choices = [Choice(desc, desc) for desc in choices]
def _main_menu_transition(self, choice):
choice = self.choices[choice].item
if choice == 'List games':
self.pump_return = GameAction(message.REQGAMELIST)
self._waiting_for_list = True
return 'MAINMENU'
elif choice == 'Join game':
if len(self._game_list) == 0:
lg.info('No games listed. Getting game list first.')
self.pump_return = GameAction(message.REQGAMELIST)
self._waiting_for_list = True
return 'MAINMENU'
else:
return 'SELECTGAME'
elif choice == 'Create game':
lg.info('Creating new game...')
self.pump_return = GameAction(message.REQCREATEGAME)
self._waiting_for_join = True
return 'MAINMENU'
elif choice == 'Start game':
lg.info('Requesting game start...')
self.pump_return = GameAction(message.REQSTARTGAME)
self._waiting_for_start = True
return 'MAINMENU'
else:
return 'END'
def _select_game_arrival(self):
# we only get here if the game list is populated
self.choices = [
Choice(i, str(game)) for i, game in enumerate(self._game_list)
]
self._show_choices()
def _select_game_transition(self, choice):
game_id = self.choices[choice].item
self._waiting_for_join = True
self.pump_return = GameAction(message.REQJOINGAME, game_id)
return 'MAINMENU'
def _show_choices(self, prompt=None):
"""Returns the index in the choices_list selected by the user or
raises a StartOverException or a CancelDialogExeption.
The choices_list is a list of Choices.
"""
i_choice = 1
for c in self.choices:
if c.selectable:
lg.info(' [{0:2d}] {1}'.format(i_choice, c.description))
i_choice += 1
else:
lg.info(' {0}'.format(c.description))
if prompt is not None:
lg.info(prompt)
else:
lg.info('Please make a selection:')
def send_command(self, game_action):
self._server_protocol.send_command(self.username, self.game_id,
game_action)
def update_game_list(self, game_list):
self._game_list = game_list
if self._waiting_for_list:
self._waiting_for_list = False
print 'List of games:'
for record in self._game_list:
print ' ' + str(record)
print
self._show_choices()
def update_game_state(self, game_state):
if game_state is None:
return
for p in game_state.players:
if p.name == self.username:
player_index = game_state.players.index(p)
self.client.player_id = player_index
if self._waiting_for_start or game_state.is_started:
lg.info('Starting game ...')
self._waiting_for_start = False
self._in_game = True
old_gs = self.client.game.game_state
old_game_id = old_gs.game_id if old_gs else None
new_game_id = game_state.game_id
if old_game_id is None or old_game_id != new_game_id:
self.client.update_game_state(game_state)
def set_player_id(self, i):
self.client.player_id = i
def join_game(self, game_id):
lg.info('Joined game {0:d}, waiting to start...'.format(game_id))
self.game_id = game_id
self._waiting_for_join = False
self._show_choices()
#self.routine_update()
def routine_update(self):
"""Updates the game state routinely.
"""
self.send_command(GameAction(message.REQGAMESTATE))
from twisted.internet import reactor
reactor.callLater(self._update_interval, self.routine_update)
l = Luring()
t = Trapping()
h = Holding()
q = Quit()
wTable = {"appear":l, "quit": q}
lTable = {"enter":t, "runaway":w, "quit":q}
tTable = {"trapped":h, "escape":w, "quit":q}
hTable = {"removed":w, "quit":q}
w.tableRegister(wTable)
l.tableRegister(lTable)
t.tableRegister(tTable)
h.tableRegister(hTable)
sm = StateMachine(w)
def main():
clearScreen()
while True:
printInfo(sm)
newEvent = getUserInput(sm)
clearScreen()
sm.eventHandler(newEvent)
input("hit a key..")
clearScreen()
if __name__ == "__main__":
main()
def __init__(self, nfa):
# stores a map of states-key -> state while we build the DFA
known_states = {}
initial = self.__processNFAState([nfa.initial], known_states)
StateMachine.__init__(self, initial, known_states.values())
class SoccerTeam:
def __init__(self,
side,
pitch,
display_model=model.initial_model,
entity_manager=model.initial_model.entity_manager,
dispatcher=model.initial_model.dispatcher):
# self.model = model
self.pitch = pitch
self.view = View(display_model)
self.view.model = self
self.side = side
self._entity_manager = entity_manager
self._dispatcher = dispatcher
if side == HOME:
self.color = pg.Color('red')
self.goal = self.pitch.home_goal
self.opponent_goal = self.pitch.away_goal
self.init_heading = Vector2(-1, 0)
elif side == AWAY:
self.color = pg.Color('blue')
self.goal = self.pitch.away_goal
self.opponent_goal = self.pitch.home_goal
self.init_heading = Vector2(1, 0)
else:
raise ValueError("side must be either 'HOME' or 'AWAY' ")
self.players = self.create_players()
self.opponent = None
self._controlling_player = None
self._supporting_player = None
self._receiving_player = None
self.player_closest_to_ball = None
self.dist_sq_to_ball_from_closest_player = sys.float_info.max
self.support_spot_calculator = SupportSpotCalculator()
self.fsm = StateMachine(self)
self.fsm.current_state = TeamState.defending
self.fsm.previous_state = TeamState.defending
self.fsm.global_state = None
#force the state enter logic to run for initial state
# self.fsm.current_state.enter(self)
def __call__(self):
return self.players
def create_players(self):
players = []
if self.home_team:
regions = [
self.pitch.pos_from_region(region)
for region in [11, 16, 15, 4, 2]
]
else:
regions = [
self.pitch.pos_from_region(region)
for region in [1, 6, 8, 3, 5]
]
# goal keeper
if self.side == HOME:
image_file = 'redshirt'
else:
image_file = 'blueshirt'
print('create_players(): image_file, pitch = ', image_file, self.pitch,
self, regions[0], self.init_heading)
goalkeeper = GoalKeeper(image_file + '0',
self.pitch,
team=self,
home=regions[0],
heading=self.init_heading)
print(' goalkeeper velocity = ', goalkeeper.velocity)
players.append(goalkeeper)
# rest of the team
for idx, region in enumerate(regions[1:]):
player = FieldPlayer(image_file + str(idx),
self.pitch,
team=self,
home=region,
heading=self.init_heading)
players.append(player)
return players
def calculate_closest_player_to_ball(self):
closest_so_far = sys.float_info.max
distances = [
p.exact_pos.distance_to(self.pitch.ball()) for p in self.players
]
return min(distances)
def draw(self, screen):
for player in self.players:
player.draw(screen)
# self.view.draw(screen)
def update(self, dt):
#calculate this once per frame
self.calculate_closest_player_to_ball()
#the team state machine switches between attack/defense behavior. It
#also handles the 'kick off' state where a team must return to their
#kick off positions before the whistle is blown
self.fsm.update()
for player in self.players:
player.update(dt)
def return_all_field_players_home(self):
for player in self.players:
dispatcher.dispatch_message(Message.SEND_MSG_IMMEDIATELY, -1,
player.id, Message.GO_HOME, None)
def can_shoot(self, ball_pos, power, shot_target=Vector2()):
pass
def find_pass(self, passer, receiver, pass_target, power,
min_passing_distance):
pass
def get_best_pass_to_receiver(self, passer, receiver, pass_target, power):
pass
def is_pass_safe_from_opponent(self, phrom, target, receiver, opp,
passing_force):
pass
def is_pass_safe_from_all_opponents(self, phrom, target, receiver,
passing_force):
pass
def is_opponent_within_radius(self, pos, radius):
pass
def request_pass(self, requester):
pass
def determine_best_supporting_attacker(self):
pass
def get_support_spot(self):
## return self.support_spot_calculater.get_best_spot()
pass
def get_player_from_id(self, player_id):
pass
def set_player_home_region(self, player, region):
pass
def determine_best_supporting_position(self):
return self.support_spot_calculator.determine_best_supportin
pass
def update_targets_of_waiting_players(self):
pass
def all_players_at_home(self):
return all([p.at_home for p in self.players])
def change_state(self, nextState):
self.fsm.change_state(nextState)
@property
def home_team(self):
return self.side == HOME
@property
def away_team(self):
return self.side == AWAY
@property
def in_control(self):
return self.controlling_player != None
@property
def receiving_player(self):
return self._receiving_player
@receiving_player.setter
def receiving_player(self, player):
self._receiving_player = player
@property
def controlling_player(self):
return self._controlling_player
@controlling_player.setter
def controlling_player(self, player):
self._controlling_player = player
@property
def supporting_player(self):
return self._supporting_player
@supporting_player.setter
def supporting_player(self, player):
self._supporting_player = player
self.opponent.lost_control()
def __repr__(self):
if self.color == 'red':
return 'Red'
else:
return 'Blue'
class Miner(BaseGameEntity):
COMFORT_LEVEL = 5
MAX_NUGGETS = 3
THIRST_LEVEL = 5
TIREDNESS_THRESHOLD = 5
def __init__(self,name='anonymous'):
super().__init__()
self.location = Location.shack
self.gold_carried = 0
self.money_in_bank = 0
self.thirst = 0
self.fatigue = 0
## self.current_state = GoHomeAndSleepTilRested.instance()
self.name = name
self.state_machine = StateMachine(self)
self.state_machine.current_state = GoHomeAndSleepTilRested.instance()
## def change_state(self, new_state):
## self.current_state.exit( self )
## self.current_state = new_state
## self.current_state.enter(self)
def add_to_gold_carried(self, val):
self.gold_carried += val
self.gold_carried = max(0, self.gold_carried)
def add_to_wealth(self, val):
self.money_in_bank += val
self.money_in_bank = max(0, self.money_in_bank)
def thirsty(self):
return self.thirst >= self.THIRST_LEVEL
def fatigued(self):
return self.fatigue >= self.TIREDNESS_THRESHOLD
def pockets_full(self):
return self.gold_carried >= self.MAX_NUGGETS
def buy_and_drink_whiskey(self):
self.thirst = 0
self.money_in_bank -= 2
def change_location(self,new_location):
self.location = new_location
def increase_fatigue(self):
self.fatigue += 1
def decrease_fatigue(self):
self.fatigue -= 1
def wealth(self):
return self.money_in_bank
def update(self):
self.thirst += 1
self.state_machine.update()
## if self.current_state:
## self.current_state.execute(self)
def __repr__(self):
return self.name
def drag_and_drop_attempt():
"""
The first attempt at creating a gui.
:return None:
"""
class InitialState(BaseState):
"""
Initial state for the SimpleGUI.
"""
def _on_enter(self, gui):
"""
Construct the buttons upon entering the state.
:return:
"""
print("In initial state.")
'''Create drag and drop window'''
gui.entry_sv = tk.StringVar()
gui.drop_box_list = []
gui.drop_box_items = tk.Listbox(master=gui.root,
listvariable=gui.drop_box_list)
gui.drop_box_text = tk.StringVar()
gui.drop_box_text.set("Drop images here")
gui.entry = tk.Entry(gui.root,
textvar=gui.drop_box_text,
justify='center')
gui.entry.config(font=("Courier", 44))
gui.entry.place(x=200, y=200, width=800, height=800)
#gui.entry.pack()
gui.entry.drop_target_register(DND_FILES)
gui.entry.dnd_bind('<<Drop>>', self.drop(gui))
gui.update()
def _on_exit(self, gui):
"""
Return the next state.
:param gui:
:return:
"""
gui.update()
return WaitForDrop()
def drop(self, gui):
def _drop(event):
files = root.tk.splitlist(event.data)
gui.entry_sv.set(files)
return _drop
class WaitForDrop(BaseState):
"""
State for having buttons on.
"""
def _on_enter(self, gui):
"""
:param gui:
:return:
"""
print("In wait for drop state.")
def _state_main(self, gui):
"""
The main code for the ButtonsOn state.
:param gui:
:return:
"""
gui.entry.wait_variable(gui.entry_sv)
'''Clean string'''
files = literal_eval(gui.entry_sv.get())
'''Remove previous images'''
if hasattr(gui, "panel"):
gui.panel.destroy()
'''Load each image'''
for file_name in files:
file_name = file_name.replace("{", "").replace("}", "")
# image = tk.PhotoImage(file=file_name)
if ".CR2" in file_name:
'''Rawpy implementation'''
file_image = rawpy.imread(file_name)
file_image = file_image.postprocess()
'''Rawkit implementation'''
'''file_image = Raw(file_name)
file_image = np.array(file_image.to_buffer())'''
'''OpenCV implementation'''
'''file_image = cv2.imread(file_name)'''
else:
file_image = Image.open(file_name)
'''image = file_image.resize((500, 500), Image.ANTIALIAS)
image = ImageTk.PhotoImage(image)
gui.panel = tk.Label(gui.root, image=image)
gui.panel.image = image
gui.panel.pack()'''
# panel.grid(row=2)
image_data = np.array(file_image)
image_data = cv2.cvtColor(image_data, cv2.COLOR_RGB2GRAY)
'''print(image_data.shape)
print(image_data)
print(len(image_data))
print(len(image_data[0]))'''
returned_image = Image.fromarray(image_data)
'''cv2.imshow("Gray", image_data)
cv2.waitKey()
cv2.destroyWindow("Gray")'''
'''enhanced_contrast = ImageEnhance.Contrast(Image.fromarray(file_image))
enhanced_image = enhanced_contrast.enhance(255)
enhanced_data = np.array(enhanced_image)
plot_functions.imshow(enhanced_image)
plot_functions.show()'''
# color_space = cv2.cvtColor(image_data, cv2.COLOR_RGB2HSV)
# print(color_space)
'''Create mask for white-ish pixels'''
'''lower_background = np.array([150, 150, 150])
upper_background = np.array([255, 255, 255])
print(image_data)
white_mask = cv2.inRange(image_data, lower_background, upper_background)
white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_OPEN, np.ones((3,3),np.uint8))
white_mask = cv2.morphologyEx(white_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))
white_mask = white_mask / 255'''
'''Create mask for black-ish pixels'''
'''lower_background = np.array([0, 0, 0])
upper_background = np.array([25, 25, 25])
black_mask = cv2.inRange(image_data, lower_background, upper_background)
black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))
black_mask = cv2.morphologyEx(black_mask, cv2.MORPH_DILATE, np.ones((3, 3), np.uint8))
black_mask = black_mask / 255'''
'''Add masks together'''
'''background_mask = white_mask
# Ensure no value is above 1
background_mask = np.clip(background_mask, 0, 1)'''
copied_image_data = np.asarray(returned_image).copy()
# background_mask = np.logical_not(background_mask)
'''for row_index, [mask_row, image_row] in enumerate(zip(background_mask, copied_image_data)):
# place black pixel on corresponding masked pixels
# copied_image_data[row_index] = np.array([image_row[pixel] * int(mask_row[pixel]) for pixel in range(len(mask_row))])
# make pixel fully white on corresponding masked pixels
copied_image_data[row_index] = np.array([np.array([255, 255, 255]) if int(mask_row[pixel]) else image_row[pixel] for pixel in range(len(mask_row))])'''
'''Turn removed pixels red'''
'''mask_image = Image.fromarray(copied_image_data)
plot_functions.imshow(mask_image)
plot_functions.show()'''
trapezoid_data = copied_image_data.copy()
enhanced_contrast = ImageEnhance.Contrast(
Image.fromarray(trapezoid_data))
enhanced_image = enhanced_contrast.enhance(255)
trapezoid_data = np.array(enhanced_image)
'''Detect lines'''
edges = cv2.Canny(trapezoid_data, 75, 150)
lines = cv2.HoughLinesP(edges,
1,
np.pi / 180,
100,
maxLineGap=1000)
# print(lines)
for line in lines:
x1, y1, x2, y2 = line[0]
if y1 == y2:
cv2.line(copied_image_data, (x1, y1), (x2, y2),
(255, 255, 255), 1)
'''Trapezoid attempt'''
# filters image bilaterally and displays it
bilatImg = cv2.bilateralFilter(trapezoid_data, 5, 175, 175)
# finds edges of bilaterally filtered image and displays it
edgeImg = cv2.Canny(bilatImg, 75, 200)
# gets contours (outlines) for shapes and sorts from largest area to smallest area
contours, hierarchy = cv2.findContours(edgeImg, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(contours, key=cv2.contourArea, reverse=True)
# drawing red contours on the image
for con in contours:
cv2.drawContours(trapezoid_data, con, -1, (255, 255, 255), 3)
'''Detect corners'''
dst = cv2.cornerHarris(edges, 30, 31, 0.001)
dst = cv2.dilate(dst, None)
ret, dst = cv2.threshold(dst, 0.01 * dst.max(), 255, 0)
dst = np.uint8(dst)
# find centroids
ret, labels, stats, centroids = cv2.connectedComponentsWithStats(
dst)
# define the criteria to stop and refine the corners
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER,
100, 0.001)
corners = cv2.cornerSubPix(edges, np.float32(centroids), (5, 5),
(-1, -1), criteria)
good_corners = []
for corner in corners:
if (corner[1] < 1000) & (corner[1] > 650) & (
corner[0] > 250) & (corner[0] < 2250):
good_corners.append(corner)
cv2.circle(edges, (corner[0], corner[1]), 10,
(255, 255, 255))
print(good_corners)
if len(good_corners) >= 3:
corner_combos = itertools.combinations(good_corners, 3)
elif len(good_corners) > 1:
corner_combos = itertools.combinations(good_corners, 2)
best_corner_combo = None
best_coef = np.inf
for corner_combo in corner_combos:
regression = LinearRegression().fit(
np.array([corner[0]
for corner in corner_combo]).reshape(-1, 1),
np.array([corner[1] for corner in corner_combo]))
if np.abs(regression.coef_) < best_coef:
best_coef = np.abs(regression.coef_)
best_corner_combo = np.array(
[corner[1] for corner in corner_combo])
y_edge = int(round(np.mean(best_corner_combo)))
edges = edges[y_edge:3000, 200:2200]
copied_image_data = copied_image_data[y_edge:2500, 200:2200]
trapezoid_data = trapezoid_data[y_edge:2500, 200:2200]
# and double-checking the outcome
cv2.imshow("linesEdges", edges)
cv2.imshow("linesDetected", copied_image_data)
cv2.imshow("Contours check", trapezoid_data)
cv2.waitKey()
cv2.destroyWindow("Contours check")
# find the perimeter of the first closed contour
perim = cv2.arcLength(contours[0], True)
# setting the precision
epsilon = 0.02 * perim
# approximating the contour with a polygon
approxCorners = cv2.approxPolyDP(contours[0], epsilon, True)
# check how many vertices has the approximate polygon
approxCornersNumber = len(approxCorners)
for corners in approxCorners:
cv2.circle(trapezoid_data, (corners[0], corners[1]),
radius=10,
color=(255, 255, 255),
thickness=-1)
cv2.imshow("Vertex position", trapezoid_data)
cv2.waitKey()
cv2.destroyWindow("Vertex position")
cv2.imshow("linesEdges", edges)
cv2.imshow("linesDetected", copied_image_data)
cv2.waitKey(0)
cv2.destroyAllWindows()
def _on_exit(self, gui):
if gui.program_running:
gui.update()
return WaitForDrop()
else:
return None
class DragAndDropGUI:
"""
Object for a simple gui.
"""
def __init__(self, root):
"""
Initializing the SimpleGUI object.
"""
self.root = root
w, h = root.winfo_screenwidth(), self.root.winfo_screenheight()
self.root.geometry("%dx%d+0+0" % (w, h))
self.root.protocol("WM_DELETE_WINDOW", self.end_program)
self.program_running = True
def update(self):
"""
Update the GUI.
:return:
"""
self.root.update_idletasks()
self.root.update()
return self.root
def end_program(self):
"""
Ends the program.
:return:
"""
if self.entry_sv.get() != " ":
self.entry_sv.set(" ")
else:
self.entry_sv.set("!")
self.root.destroy()
self.program_running = False
'''Initialize and run GUI object'''
root = tkinterdnd2.Tk()
# Maximize window while maintaining title bar
gui = DragAndDropGUI(root)
state_machine = StateMachine(initial_state=InitialState())
state_machine.run(gui)
