def __init__(self, trigger):
State.__init__(self)
players = [p.PlayerLich(None), p.PlayerDemon(None), p.PlayerSmith(None), p.PlayerFungus(None)]
enemies = [Enemies.Goblin(), Enemies.Goblin(), Enemies.Goblin(), Enemies.Goblin()]
self.data = {
'battleStatus':'setup',
'battleComplete':False,
'elapsedTime':0,
'players_living':[x for x in players if x.Alive],
'players_dead':[x for x in players if not x.Alive],
'enemies_living':[x for x in enemies if x.Alive],# Enemies.Goblin(), Enemies.Goblin(), Enemies.Goblin(), Enemies.Goblin(), Enemies.Goblin()],
'enemies_dead':[x for x in enemies if not x.Alive],
'background': pg.transform.scale(pg.image.load(os.path.join('resources','battle','background.bmp')), (640,480))
}
self.data['players'] = self.data['players_living'] + self.data['players_dead']
self.data['enemies'] = self.data['enemies_living'] + self.data['enemies_dead']
self.observer = Observable()
self.observer.Subscribe(trigger)
#arrange players
for key, value in enumerate(self.data['players']):
value.Position.SetPos((500, 30 + (20+64)*key))
#arrange enemies
for key, value in enumerate(self.data['enemies']):
value.Position.SetPos((50 + 70*math.floor(key/3), 70 + (26+64)*(key%3)))
self.observer.Fire(self, type="loading", status="completed", battledata=self.data)
def __init__(self):
State.__init__(self)
self.image = pg.Surface((640,480))
self.stateMachine = StateMachine()
self.actions = [] #list of lists; contains [actor, action, target]
self.selectIndex = 0
self.battleData = None
SetupBattle(self)
def __init__(self, battleData, trigger):
State.__init__(self)
self.battleData = battleData
self.image = pg.Surface((640,480), pg.SRCALPHA, 32).convert_alpha()
labellist = [Menu.MenuItem("Fight", 15), Menu.MenuItem("Magic", 15), Menu.MenuItem("Item", 15), Menu.MenuItem('Run', 15)]
self.healthMenu = Menu.HealthDisplayMenu(battleData)
self.actionSelectMenu = Menu.Menu(labellist, (506, 340), (128, 140), True, c.images['action_select_pane.bmp'], 4, 1, (0,10,0,10))
self.actionsMenu = None
self.visibleMenus = [self.healthMenu, self.actionSelectMenu]
self.activeMenu = self.actionSelectMenu
self.observer = Observable()
self.observer.Subscribe(trigger)
self.currentMenu = 'selectAction'
def __init__(self, vk, peer):
self.state = State()
self.rooms = Data.getRooms()
self.locations = Data.getLocations()
self.peer = str(peer)
self.vk = vk
self.duty: Duty = None
self.new_duty: Duty = None
self.old_duty: Duty = None
# Remind Duty
self.CURRENT_LOCATION = ''
self.CURRENT_COMMENT = ''
# Update Duty
self.CURRENT_DUTY = []
self.CURRENT_ROOMS = []
self.CURRENT_LOCS = []
from numpy import sign
from rlbot.agents.base_agent import SimpleControllerState
from CowBotVector import Vec3
from GameState import Orientation
from Maneuvers import GroundTurn, NavigateTo
from StateMachine import State
import Strategy.TransitionBackFolder.MidBoost as MidBoost
import Strategy.TransitionBackFolder.BackBoost as BackBoost
import Strategy.TransitionBackFolder.BoostPad as BoostPad
import Strategy.TransitionBackFolder.Goal as Goal
MidBoostState = State(
lambda game_info, next_states, sub_sm: MidBoost.transition(
game_info, next_states, sub_sm),
lambda game_info: MidBoost.startup(game_info),
lambda game_info, sub_state_machine: MidBoost.get_controls(
game_info, sub_state_machine), "MidBoost", True)
BackBoostState = State(
lambda game_info, next_states, sub_sm: BackBoost.transition(
game_info, next_states, sub_sm),
lambda game_info: BackBoost.startup(game_info),
lambda game_info, sub_state_machine: BackBoost.get_controls(
game_info, sub_state_machine), "BackBoost", True)
BoostPadState = State(
lambda game_info, next_states, sub_sm: BoostPad.transition(
game_info, next_states, sub_sm),
lambda game_info: BoostPad.startup(game_info),
lambda game_info, sub_state_machine: BoostPad.get_controls(
game_info, sub_state_machine), "BoostPad", True)
GoalState = State(
from CowBotVector import Vec3
from StateMachine import State
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalLeft as DiagonalLeft
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalRight as DiagonalRight
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeft as OffcenterLeft
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterRight as OffcenterRight
import Strategy.KickoffFolder.DoKickoffFolder.FarBack as FarBack
########################################################################################################
#States for the next level down
########################################################################################################
DiagonalLeftState = State(
lambda game_info, next_states, sub_sm: DiagonalLeft.transition(
game_info, next_states, sub_sm),
lambda game_info: DiagonalLeft.startup(game_info),
lambda game_info, sub_state_machine: DiagonalLeft.get_controls(
game_info, sub_state_machine), "DiagonalLeft", False)
DiagonalRightState = State(
lambda game_info, next_states, sub_sm: DiagonalRight.transition(
game_info, next_states, sub_sm),
lambda game_info: DiagonalRight.startup(game_info),
lambda game_info, sub_state_machine: DiagonalRight.get_controls(
game_info, sub_state_machine), "DiagonalRight", False)
OffcenterLeftState = State(
lambda game_info, next_states, sub_sm: OffcenterLeft.transition(
game_info, next_states, sub_sm),
lambda game_info: OffcenterLeft.startup(game_info),
lambda game_info, sub_state_machine: OffcenterLeft.get_controls(
game_info, sub_state_machine), "OffcenterLeft", False)
OffcenterRightState = State(
class Bot:
def __init__(self, vk, peer):
self.state = State()
self.rooms = Data.getRooms()
self.locations = Data.getLocations()
self.peer = str(peer)
self.vk = vk
self.duty: Duty = None
self.new_duty: Duty = None
self.old_duty: Duty = None
# Remind Duty
self.CURRENT_LOCATION = ''
self.CURRENT_COMMENT = ''
# Update Duty
self.CURRENT_DUTY = []
self.CURRENT_ROOMS = []
self.CURRENT_LOCS = []
def updateDuty(self, duty: Duty):
self.duty = duty
@staticmethod
def createKeyboard(keyboard, list, elements_per_line=1):
if elements_per_line == 1:
for element in list[0:-1]:
keyboard.add_button(element)
keyboard.add_line()
keyboard.add_button(list[-1])
return keyboard
elif elements_per_line == 2:
i = 1
is_odd = len(list) % 2 == 0
end_point = -2
if not is_odd:
end_point = -1
for element in list[0:end_point]:
keyboard.add_button(element)
if i == 2:
keyboard.add_line()
i = 0
i += 1
if is_odd:
keyboard.add_button(list[-2])
keyboard.add_button(list[-1])
else:
keyboard.add_button(list[-1])
return keyboard
def getResponseData(self, args=None):
keyboard = VkKeyboard()
message = ''
# Main Menu State
if self.state.getType() == States.Menu:
keyboard = self.__startMenuKeyboard()
message = 'Выберите действие'
# Main Remind Duty State
elif self.state.getType() == States.RemindDuty:
if self.state.getState() == State.STATE[
States.RemindDuty]['ChoiceLocation']:
keyboard = Bot.createKeyboard(keyboard, self.locations)
message = 'Выберите локацию'
if self.state.getState() == State.STATE[
States.RemindDuty]['Comment']:
keyboard = Bot.createKeyboard(keyboard,
['Отправить без комментария'])
message = 'Введите комментарий и нажмите отправить'
self.CURRENT_LOCATION = args
elif self.state.getState() == State.STATE[
States.RemindDuty]['End']:
self.CURRENT_COMMENT = args
keyboard = self.__startMenuKeyboard()
message = self.__RemindDutyEndAction(self.CURRENT_LOCATION,
self.CURRENT_COMMENT)
self.CURRENT_LOCATION = ''
self.CURRENT_COMMENT = ''
# Main Show duty State
elif self.state.getType() == States.ShowDuty:
if self.state.getState() == State.STATE[States.ShowDuty]['End']:
keyboard = self.__startMenuKeyboard()
message = self.__ShowDutyEndAction()
# Main Update Duty State
elif self.state.getType() == States.UpdateDuty:
if self.state.getState() == State.STATE[
States.UpdateDuty]['SelectLocation']:
if not Data.isModerator(self.peer):
self.state.setStartState()
keyboard = Bot.createKeyboard(
keyboard, list(State.STATE_TYPES_NAMES.keys()))
message = 'У вас недостаточно прав доступа'
return {
'keyboard': keyboard.get_keyboard(),
'message': message
}
if args in State.STATE_TYPES_NAMES.keys():
self.CURRENT_ROOMS = [
room.rooms_name for room in self.rooms
]
self.CURRENT_LOCS = self.locations
else:
self.CURRENT_LOCS.remove(args)
self.CURRENT_DUTY.append(args)
message = 'Выберите место: '
keyboard = Bot.createKeyboard(keyboard,
self.CURRENT_ROOMS,
elements_per_line=2)
if self.state.getState() == State.STATE[
States.UpdateDuty]['SelectRoom']:
self.CURRENT_ROOMS.remove(args)
self.CURRENT_DUTY.append(args)
print(self.CURRENT_ROOMS)
message = 'Выберите дежурных: '
keyboard = Bot.createKeyboard(keyboard,
self.CURRENT_LOCS,
elements_per_line=2)
if len(self.CURRENT_LOCS) > 0:
self.state.currentState -= 2
else:
self.state.setStartState()
return self.getResponseData(args)
if self.state.isOnLastState():
self.state.next()
return {'keyboard': keyboard.get_keyboard(), 'message': message}
def send(self, args=None):
self.state.next(args)
self.logState(args)
responseData = self.getResponseData(args)
self.send_message(self.peer, responseData['message'],
responseData['keyboard'])
def logState(self, args=None):
print('Type: {}\n State: {}\n args: {}\n peer: {}\n\n'.format(
self.state.getType(), self.state.getState(), args, self.peer))
def send_message(self, peer, message, keyboard=None, name=None):
try:
if keyboard is not None:
if re.match(r'[\d]+', str(peer)) is not None:
self.vk.messages.send(user_id=peer,
random_id=get_random_id(),
message=message,
keyboard=keyboard)
else:
self.vk.messages.send(domain=peer,
random_id=get_random_id(),
message=message,
keyboard=keyboard)
else:
if re.match('[\d]+', str(peer)) is not None:
self.vk.messages.send(
user_id=peer,
random_id=get_random_id(),
message=message,
)
else:
self.vk.messages.send(
domain=peer,
random_id=get_random_id(),
message=message,
)
except ApiError as e:
print(e.args)
print(e.values)
self.send_message(
self.peer,
'Кажется, резидент {} с id: {} еще не зарегистрировался.'
' \n Пожалуйста, перешлите это сообщение @mistleet'.format(
str(name), str(peer)))
return False
return True
def __startMenuKeyboard(self):
keyboard = VkKeyboard()
if not Data.isModerator(self.peer):
keyboard = Bot.createKeyboard(
keyboard,
list(State.STATE_TYPES_NAMES.keys())[:-1])
else:
keyboard = Bot.createKeyboard(keyboard,
list(State.STATE_TYPES_NAMES.keys()))
return keyboard
def __RemindDutyEndAction(self, location, comment):
room: Room = self.duty.duty[location]
message = ''
for name, id in room.room.items():
result = self.send_message(
id,
'Привет, {}, кажется, {} стоит уделить внимание!'.format(
Helper.BuildPersonLink(id, name), location) + '\n' +
Helper.BuildComment(comment),
name=name)
if result:
message += '{} уведомлен(a) \n'.format(name)
if message == '':
message = '...'
return message
def __ShowDutyEndAction(self):
message = ''
for location, room in self.duty.duty.items():
message += '{} ------ {}\n'.format(room.rooms_name, location)
return message
def __init__(self, Lumberjack):
State.__init__(self, "Searching")
self.Lumberjack = Lumberjack
def __init__(self, Lumberjack):
State.__init__(self, "Chopping")
self.Lumberjack = Lumberjack
from rlbot.agents.base_agent import SimpleControllerState
from StateMachine import State
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalRightFolder.Boost as Boost
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalRightFolder.Jump as Jump
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalRightFolder.FastDodge as FastDodge
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalRightFolder.AerialRotation as AerialRotation
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalRightFolder.Turn as Turn
import Strategy.KickoffFolder.DoKickoffFolder.DiagonalRightFolder.Dodge as Dodge
##########################################################################
BoostState = State(
lambda game_info, next_states, sub_sm: Boost.transition(
game_info, next_states, sub_sm),
lambda game_info: Boost.startup(game_info),
lambda game_info, sub_state_machine: Boost.get_controls(
game_info, sub_state_machine), "Boost", True)
JumpState = State(
lambda game_info, next_states, sub_sm: Jump.transition(
game_info, next_states, sub_sm),
lambda game_info: Jump.startup(game_info),
lambda game_info, sub_state_machine: Jump.get_controls(
game_info, sub_state_machine), "Jump", True)
FastDodgeState = State(
lambda game_info, next_states, sub_sm: FastDodge.transition(
game_info, next_states, sub_sm),
lambda game_info: FastDodge.startup(game_info),
lambda game_info, sub_state_machine: FastDodge.get_controls(
game_info, sub_state_machine), "FastDodge", True)
AerialRotationState = State(
def __init__(self, Lumberjack):
State.__init__(self, "Delivering")
self.Lumberjack = Lumberjack
def __init__(self, Lumberjack):
State.__init__(self, "Searching")
self.Lumberjack = Lumberjack
from rlbot.agents.base_agent import SimpleControllerState
from CowBotVector import Vec3
from StateMachine import State
import Strategy.KickoffFolder.DoKickoff as DoKickoff
import Strategy.KickoffFolder.GetBoost as GetBoost
import Strategy.KickoffFolder.CoverNet as CoverNet
########################################################################################################
#States for the next level down
########################################################################################################
DoKickoffState = State(
lambda game_info, next_states, sub_sm: DoKickoff.transition(
game_info, next_states, sub_sm),
lambda game_info: DoKickoff.startup(game_info),
lambda game_info, sub_state_machine: DoKickoff.get_controls(
game_info, sub_state_machine), "DoKickoff", False)
GetBoostState = State(
lambda game_info, next_states, sub_sm: GetBoost.transition(
game_info, next_states, sub_sm),
lambda game_info: GetBoost.startup(game_info),
lambda game_info, sub_state_machine: GetBoost.get_controls(
game_info, sub_state_machine), "GetBoost", False)
CoverNetState = State(
lambda game_info, next_states, sub_sm: CoverNet.transition(
game_info, next_states, sub_sm),
lambda game_info: CoverNet.startup(game_info),
lambda game_info, sub_state_machine: CoverNet.get_controls(
game_info, sub_state_machine), "CoverNet", True)
s.release()
print("\nStopping")
for t in threads:
print("[THD]", t)
t.join()
print("Stopped\n")
### MAIN main
actionPreprocessing = ActionPreprocessing(["déroutement", "retour"])
# States and state machine
s = dict()
for kw in actionPreprocessing.keywords:
s[kw] = State(kw)
s['retour'].addNext(s['déroutement'])
airfields = ['LFCL', 'LFBO', 'LFBR']
for airfield in airfields:
s[airfield] = State(airfield)
s['déroutement'].addNext(s[airfield])
s[airfield].addNext(s['retour'])
stateMachine = StateMachine(s['retour'])
# TTS
talker = ThirstyTalker()
# Threads
fgfsListener = FGFS_Listener()
from rlbot.agents.base_agent import SimpleControllerState
from CowBotVector import Vec3
from StateMachine import State
import Strategy.KickoffFolder.GetBoostFolder.LeftBoost as LeftBoost
import Strategy.KickoffFolder.GetBoostFolder.RightBoost as RightBoost
##########################################################################
LeftBoostState = State(
lambda game_info, next_states, sub_sm: LeftBoost.transition(
game_info, next_states, sub_sm),
lambda game_info: LeftBoost.startup(game_info),
lambda game_info, sub_state_machine: LeftBoost.get_controls(
game_info, sub_state_machine), "LeftBoost", True)
RightBoostState = State(
lambda game_info, next_states, sub_sm: RightBoost.transition(
game_info, next_states, sub_sm),
lambda game_info: RightBoost.startup(game_info),
lambda game_info, sub_state_machine: RightBoost.get_controls(
game_info, sub_state_machine), "RightBoost", True)
##########################################################################
def transition(game_info, next_states, sub_state_machine):
def transition_to_do_kickoff(game_info):
should_transition = False
return should_transition, game_info.persistent
##########################
class Token(object):
""" Class for tokens, as well as the tokenizer.
This class consists of four parts: a set of class constants
representing different types of tokens, a static initializer for the
lexical analyzer's state machine, the constructor and instance methods
for the Token objects, and a class nethod that returns a generator
object which tokenizes a CharBuffer source, returning the next token
on each successive call.
"""
# Token types for the lexical analyzer - this type of group return is used
# as the Python equivalent of an Enum, setting each to a matching number in the
# returned range.
EOF, __WSPACE, \
SEMI, BRACKET, PAREN, COMMA, \
IDENT, CHARLIT, INTLIT, STRINGLIT, BOOLLIT, \
MULOP, ADDOP, RELOP, NOTTOK, ASSIGN, \
BASICTYPETOK, INTCONSTTOK, ARRAYTOK, PROCTOK, \
BEGINTOK, ENDTOK, \
IFTOK, THENTOK, ELSETOK, FITOK, \
WHILETOK, DOTOK, ODTOK, \
FORTOK, ROFTOK, UNTILTOK, STEPTOK, \
__COLON, __AND, __OR, __EQUAL, __NEQUAL, \
__SQUOTE, __DQUOTE, __CHAR, __STRING, __COMMENT = list(range(1, 44))
# lookup table matching a lexeme to a specific token type. When the state machine
# finds an identifier token, the tokenizer checks it against this table, and
# if it matches one of the values, changes the return type to the corresponding
# token type.
resWords = {"BEGIN": BEGINTOK, "END": ENDTOK, \
"INT": BASICTYPETOK, "CHAR": BASICTYPETOK, "INTCONST": INTCONSTTOK, \
"STRING": BASICTYPETOK, "BOOLEAN": BASICTYPETOK, \
"NOT": NOTTOK,
"IF": IFTOK, "THEN": THENTOK, "ELSE": ELSETOK, "FI": FITOK, \
"WHILE": WHILETOK, "DO": DOTOK, "OD": ODTOK, \
"FOR": FORTOK, "ROF": ROFTOK, "UNTIL": UNTILTOK, "STEP": STEPTOK, \
"PROC": PROCTOK, "ARRAY": ARRAYTOK, \
"TRUE": BOOLLIT, "FALSE":BOOLLIT }
# A simple lookup table for the names of the different token types. It is
# probably possible to merge this with the lookup table above, but this
# was the expedient solution given the long delays in completing the project.
# Note that these need to align correctly with the enumerated constants, which
# may cause maintanence problems later.
token_desc = ['START', 'EOF', 'WSPACE', \
'SEMI', 'BRACKET', 'PAREN', 'COMMA', \
'IDENT', 'CHARLIT', 'INTLIT', 'STRINGLIT', 'BOOLLIT', \
'MULOP', 'ADDOP', 'RELOP', 'NOTTOK', 'ASSIGN', \
'BASICTYPETOK', 'INTCONSTTOK', 'ARRAYTOK', 'PROCTOK', \
'BEGINTOK', 'ENDTOK', \
'IFTOK', 'THENTOK', 'ELSETOK', 'FITOK', \
'WHILETOK', 'DOTOK', 'ODTOK', \
'FORTOK', 'ROFTOK', 'UNTILTOK', 'STEPTOK' ]
# constant string representing the allowable characters in an identifier
id_chars = ascii_letters + digits + '_'
# class static initialization
# Initialize the FSM to the start state, including all transitions out of it.
fsm = StateMachine(
State({
'': EOF,
whitespace: __WSPACE,
'#': __COMMENT,
ascii_letters: IDENT,
digits: INTLIT,
"'": __SQUOTE,
'"': __STRING,
'()': PAREN,
'[]': BRACKET,
';': SEMI,
',': COMMA,
'+-': ADDOP,
'*/%': MULOP,
'<>': RELOP,
':': __COLON,
'&': __AND,
'|': __OR,
'=': __EQUAL,
'!': __NEQUAL,
State.OTHER: State.ERROR
}))
# add the list of states and their transitions to the FSM
# end of file -> always accept
fsm.add(EOF, State({State.OTHER: State.ACCEPT}, True, EOF, 0))
# whitespace -> eat until the next valid input, then push back
# one and return to start
fsm.add(__WSPACE,
State({whitespace: __WSPACE, State.OTHER: State.ACCEPT}, \
True, __WSPACE, 1))
# identifier -> eat until the last valid ID char, then accept and push back one
fsm.add(
IDENT,
State({
id_chars: IDENT,
State.OTHER: State.ACCEPT
}, True, IDENT, 1))
# intlit -> eat all numbers, then accept
fsm.add(
INTLIT,
State({
id_chars: INTLIT,
State.OTHER: State.ACCEPT
}, True, INTLIT, 1))
# + or - -> accept and push back one
fsm.add(ADDOP, State({State.OTHER: State.ACCEPT}, True, ADDOP, 1))
# *, / or % -> accept and push back one
fsm.add(MULOP, State({State.OTHER: State.ACCEPT}, True, MULOP, 1))
# > or < -> accept and push back one
fsm.add(RELOP, State({State.OTHER: State.ACCEPT}, True, RELOP, 1))
# semicolon -> accept and push back one
fsm.add(SEMI, State({State.OTHER: State.ACCEPT}, True, SEMI, 1))
# comma -> accept and push back one
fsm.add(COMMA, State({State.OTHER: State.ACCEPT}, True, COMMA, 1))
# parenthesis -> accept and push back one
fsm.add(PAREN, State({State.OTHER: State.ACCEPT}, True, PAREN, 1))
# bracket -> accept and push back one
fsm.add(BRACKET, State({State.OTHER: State.ACCEPT}, True, BRACKET, 1))
# The following represent intermediate states in compound operators.
# They are private to the class, unlike the others.
# colon -> accept of the next char is an equals sign, otherwise fail
fsm.add(__COLON, State({'=': State.ACCEPT}, True, ASSIGN, 0))
# ampersand -> accept of the next char is an ampersand, otherwise fail
fsm.add(__AND, State({'&': State.ACCEPT}, True, MULOP, 0))
# vertical bar -> accept of the next char is a vertical bar, otherwise fail
fsm.add(__OR, State({'|': State.ACCEPT}, True, ADDOP, 0))
# equals sign -> accept of the next char is an equals sign, otherwise fail
fsm.add(__EQUAL, State({'=': State.ACCEPT}, True, RELOP, 0))
# exclamation point -> accept if the next char is an equals sign,
# otherwise fail
fsm.add(__NEQUAL, State({'=': State.ACCEPT}, True, RELOP, 0))
# single quote -> continue for any following char except a single quote
fsm.add(__SQUOTE, State({State.OTHER: __CHAR}))
# character -> accept of the next char is an signle quote, otherwise fail
fsm.add(__CHAR, State({"'": State.ACCEPT}, True, CHARLIT, 0))
# double quote -> accept any number of characters until another double
# quote is reached
fsm.add(
__STRING,
State({
'"': State.ACCEPT,
State.OTHER: __STRING
}, True, STRINGLIT, 0))
# hash -> eat all inout to the end of the current line, then go back to start
fsm.add(
__COMMENT,
State({
'\n': State.ACCEPT,
State.OTHER: __COMMENT
}, True, __COMMENT, 0))
# lock state machine after adding all the states
fsm.lock()
def __init__(self, toktype, line, lexeme):
""" Constructor - create a new Token object.
Each Token consists of a token type, the line # on which it
was found, and the actual text of the lexeme.
"""
self.__toktype, self.__line, self.__lexeme = toktype, line, lexeme
@classmethod
def Tokenizer(cls, buffer, wrng):
""" Create generator for new tokens from the CharBuffer input.
The class method takes a CharBuffer object and returns a
generator function which iterates through the input source,
returning each successive token.
The generator itself begins each call by
"""
# continue until the end of the file
global warning
warning = wrng
while not buffer.eof():
final = False # clear the previous token state
lexeme = ''
# read the next character and, if it is not an end of file,
# feed it to the FSM. If it is an EOF, return an EOF token and
# break from the loop. Accumulate the read characters into the
# string 'lexeme'.
while not final:
ch = buffer.getChar()
if ch == '':
yield Token(cls.EOF, buffer.line(), '')
break
final, toktype, pb = cls.fsm.transition(ch)
lexeme += ch
# If the FSM returns an error, print a warning and
# go on to the mext token. Note that this has to check for the
# end of line, as identifiers can be mistakenly reported as
# errors if there is a newline in them.
if toktype == State.ERROR and '\n' not in lexeme:
warning(Token(State.ERROR, buffer.line(), lexeme),
"Invalid token " + lexeme + \
" on line " + str(buffer.line()))
buffer.pushback(pb)
lexeme = ''
continue
# if the FSM finds a comment or string of whitespace, push back
# the first good character and continue to the next token
if toktype == cls.__WSPACE or toktype == cls.__COMMENT:
lexeme = ''
buffer.pushback(pb)
continue
# if the token is a string literal, make sure it does not
# have a newline in it
if toktype == cls.STRINGLIT and '\n' in lexeme:
warning(Token(State.ERROR, buffer.line(), lexeme),
" incomplete string on line " + str(buffer.line()))
lexeme = ''
buffer.pushback(pb)
continue
# push back any characters not eaten in the current string
if (pb > 0):
lexeme = lexeme[0:-pb]
buffer.pushback(pb)
# if the token is recognized as an identifier, check to see if
# if is a keyword, and if it is, use the keyword token type
# instead of IDENT
if toktype == cls.IDENT:
if lexeme.upper() in cls.resWords:
toktype = cls.resWords[lexeme.upper()]
# return the completed token
yield Token(toktype, buffer.line(), lexeme)
# end of file reached - continue returning EOF tokens indefinitely
while (True):
yield Token(cls.EOF, buffer.line(), '')
def __repr__(self):
"""String representation of a Token object.
Just calls str()
"""
return str(self)
def __str__(self):
"""Simple string representation of a Token object.
If the token is an ERROR token, return "ERROR".
If it is a literal or an identifier, return type name and the lexeme,
Otherwise, return just the name of the type.
"""
if self.__toktype == State.ERROR:
return "ERROR"
elif self.__toktype in [self.CHARLIT, self.INTLIT, self.BOOLLIT, \
self.STRINGLIT, self.IDENT, self.BASICTYPETOK]:
return (self.token_desc[self.__toktype] + '(' + self.__lexeme +
')')
else:
return self.token_desc[self.__toktype]
def line(self):
"""Return the line on which the token was found."""
return self.__line
def type(self):
"""Return a string with the name of the token type."""
return self.__toktype
def value(self):
"""Return the token's lexeme."""
return self.__lexeme
from StateMachine import State
import Strategy.Kickoff as Kickoff
import Strategy.Attack as Attack
import Strategy.TransitionBack as TransitionBack
import Strategy.Defend as Defend
import Strategy.TransitionForward as TransitionForward
import Strategy.Initialize as Initialize
KickoffState = State(
lambda game_info, next_states, sub_sm: Kickoff.transition(
game_info, next_states, sub_sm),
lambda game_info: Kickoff.startup(game_info),
lambda game_info, sub_state_machine: Kickoff.get_controls(
game_info, sub_state_machine), "Kickoff", False)
AttackState = State(
lambda game_info, next_states, sub_sm: Attack.transition(
game_info, next_states, sub_sm),
lambda game_info: Attack.startup(game_info),
lambda game_info, sub_state_machine: Attack.get_controls(
game_info, sub_state_machine), "Attack", False)
TransitionBackState = State(
lambda game_info, next_states, sub_sm: TransitionBack.transition(
game_info, next_states, sub_sm),
lambda game_info: TransitionBack.startup(game_info),
lambda game_info, sub_state_machine: TransitionBack.get_controls(
game_info, sub_state_machine), "Transition Back", False)
DefendState = State(
lambda game_info, next_states, sub_sm: Defend.transition(
game_info, next_states, sub_sm),
lambda game_info: Defend.startup(game_info),
lambda game_info, sub_state_machine: Defend.get_controls(
def forceTransitionEmptyPartial(StateMachine): # add DataSet
StateMachine.guiWindow.DataSet_NewDataSet_button_function()
return transitionEmptyPartial(StateMachine)
def forceTransitionPartialRaw(StateMachine): # add DataFile
StateMachine.guiWindow.DataSet_AddFiles_button_function()
return transitionPartialRaw(StateMachine)
def forceTansitionRawConverted(StateMachine): # add DataFile
print(StateMachine.currentState.name)
StateMachine.guiWindow.convert()
return True#transitionRawConverted(StateMachine)
### States for state machine
# Allows plotting, fitting and all the fun
converted = State('Converted',nextState=None,enterStateFunction=ConvertedEnabled)
# Has DataSet, DataFiles but not converded yet
raw = State('Raw',enterStateFunction=RawEnabled,transitionRequirement=transitionRawConverted,
transitionFunction=forceTansitionRawConverted,nextState=converted)
# Has DataSet but no DataFiles
partial = State('Partial',enterStateFunction=PartialEnabled,transitionRequirement=transitionPartialRaw,
transitionFunction=forceTransitionPartialRaw,nextState=raw)
# Has no DataSet
empty = State('Empty',enterStateFunction=EmptyEnabled,transitionRequirement=transitionEmptyPartial,
transitionFunction=forceTransitionEmptyPartial,nextState=partial)
from GameState import Orientation
from Maneuvers import NavigateTo
from StateMachine import State
import Strategy.DefendFolder.InNet as InNet
import Strategy.DefendFolder.FarPost as FarPost
import Strategy.DefendFolder.FarBoost as FarBoost
import Strategy.DefendFolder.Clear as Clear
########################################################################################################
#States for the next level down
########################################################################################################
FarBoostState = State(
lambda game_info, next_states, sub_sm: FarBoost.transition(
game_info, next_states, sub_sm),
lambda game_info: FarBoost.startup(game_info),
lambda game_info, sub_state_machine: FarBoost.get_controls(
game_info, sub_state_machine), "FarBoost", True)
FarPostState = State(
lambda game_info, next_states, sub_sm: FarPost.transition(
game_info, next_states, sub_sm),
lambda game_info: FarPost.startup(game_info),
lambda game_info, sub_state_machine: FarPost.get_controls(
game_info, sub_state_machine), "FarPost", True)
InNetState = State(
lambda game_info, next_states, sub_sm: InNet.transition(
game_info, next_states, sub_sm),
lambda game_info: InNet.startup(game_info),
lambda game_info, sub_state_machine: InNet.get_controls(
game_info, sub_state_machine), "InNet", True)
ClearState = State(
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeftFolder.Start as Start
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeftFolder.Turn as Turn
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeftFolder.Jump as Jump
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeftFolder.FastDodge as FastDodge
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeftFolder.Land as Land
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeftFolder.PreDodge as PreDodge
import Strategy.KickoffFolder.DoKickoffFolder.OffcenterLeftFolder.Dodge as Dodge
########################################################################################################
#States for the next level down
########################################################################################################
StartState = State(lambda game_info, next_states, sub_sm: Start.transition(game_info,
next_states,
sub_sm),
lambda game_info: Start.startup(game_info),
lambda game_info, sub_state_machine: Start.get_controls(game_info, sub_state_machine),
"Start",
True)
TurnState = State(lambda game_info, next_states, sub_sm: Turn.transition(game_info,
next_states,
sub_sm),
lambda game_info: Turn.startup(game_info),
lambda game_info, sub_state_machine: Turn.get_controls(game_info, sub_state_machine),
"Turn",
True)
JumpState = State(lambda game_info, next_states, sub_sm: Jump.transition(game_info,
next_states,
sub_sm),
lambda game_info: Jump.startup(game_info),
lambda game_info, sub_state_machine: Jump.get_controls(game_info, sub_state_machine),
def __init__(self, Lumberjack):
State.__init__(self, "Delivering")
self.Lumberjack = Lumberjack
from BallPrediction import ball_contact_binary_search
from CowBotVector import Vec3
from Maneuvers import GroundTurn
from StateMachine import State
import Strategy.AttackFolder.Path as Path
import Strategy.AttackFolder.Challenge as Challenge
import Strategy.AttackFolder.Aerial as Aerial
########################################################################################################
#States for the next level down
########################################################################################################
PathState = State(
lambda game_info, next_states, sub_sm: Path.transition(
game_info, next_states, sub_sm),
lambda game_info: Path.startup(game_info),
lambda game_info, sub_state_machine: Path.get_controls(
game_info, sub_state_machine), "Path", True)
ChallengeState = State(
lambda game_info, next_states, sub_sm: Challenge.transition(
game_info, next_states, sub_sm),
lambda game_info: Challenge.startup(game_info),
lambda game_info, sub_state_machine: Challenge.get_controls(
game_info, sub_state_machine), "Challenge", True)
AerialState = State(
lambda game_info, next_states, sub_sm: Aerial.transition(
game_info, next_states, sub_sm),
lambda game_info: Aerial.startup(game_info),
lambda game_info, sub_state_machine: Aerial.get_controls(
game_info, sub_state_machine), "Aerial", False)
def __init__(self, Lumberjack):
State.__init__(self, "Chopping")
self.Lumberjack = Lumberjack
from rlbot.agents.base_agent import SimpleControllerState
from StateMachine import State
import Strategy.AttackFolder.AerialFolder.Ball as Ball
import Strategy.AttackFolder.AerialFolder.Recover as Recover
########################################################################################################
#States for the next level down
########################################################################################################
BallState = State(lambda game_info, next_states, sub_sm: Ball.transition(game_info,
next_states,
sub_sm),
lambda game_info: Ball.startup(game_info),
lambda game_info, sub_state_machine: Ball.get_controls(game_info, sub_state_machine),
"Ball",
True)
RecoverState = State(lambda game_info, next_states, sub_sm: Recover.transition(game_info,
next_states,
sub_sm),
lambda game_info: Recover.startup(game_info),
lambda game_info, sub_state_machine: Recover.get_controls(game_info, sub_state_machine),
"Recover",
True)
########################################################################################################
#Transition functions
########################################################################################################
