def murder(self, player, list_of_players):
if len(list_of_players) == 1:
print("SORRY there are no other players with influences to murder")
return 0
player.coins = -3
choose_person = []
counter = 0
for person in (list_of_players):
if person.status != "Playing":
choose_person.append(person)
print(
"You can MURDER an INFLUENCE of {} by pressing {}".format(
person, counter))
counter += 1
print(
"Enter the number of the person's influence you want to murder: ")
murder_person = Console.cast(0, counter)
print("PASS the computer to {}".format(
choose_person[murder_person].name))
input("PRESS ANY KEY to continue")
Console.clear()
choose_person[murder_person].resign_card()
print("Player {} now has {} coins".format(player.name, player.coins))
def __set_players(cls):
for i in range(1, cls.NUMBER_OF_PLAYERS + 1):
name = Console.get_str_input_with_args(
'\nWrite player\'s {} name: ', [i])
cls.__players.append(Player(name, i))
cls.__actual_player = cls.__players[0]
Console.clear()
def __ask_players_to_challenge(cls):
challenge = [False,0]
if cls.__actual_player.choosen_action in [
'Tax', 'Exchange', 'Steal', 'Assassinate'
]:
Console.print_str(' * CHALLENGING PHASE * ')
for i in range(len(cls.__players)):
if cls.__players[i] != cls.__actual_player and challenge[
0] == False:
while True:
answer = Console.get_str_input_with_args(
'\n* {}, you wanna challenge player {} * [ Yes / No ] \n',
[cls.__players[i].name, cls.__actual_player.name])
if answer == 'Yes' or answer == 'No':
if answer == 'Yes':
challenge[0] = True
challenge[1] = i
break
else:
Console.print_str(
'\n * You answer isn´t valid * \n')
Console.clear()
return challenge
def play(cls):
cls.__set_players()
cls.__set_deck()
for player in cls.__players:
cls.__table_deck.assign_cards_player(player, 2,
cls.__table_deck.deck)
cls.__number_of_players = len(cls.__players)
#We let everybody see their cards by turns
print(
"\nOn this first round every player will get to SEE THEIR CARDS.")
for player in cls.__players:
player.status = "Playing"
print("PASS computer to {}".format(player))
input("PLAYER {} PRESS ANY KEY to see your cards".format(player))
player.see_cards()
input("PRESS ANY KEY to continue")
Console.clear()
player.status = None
#To not begin first round inmediately:
print("Pass the computer to {}".format(cls.__players[0]))
input("NOW THE GAME BEGINS: press enter ")
while len(cls.__players) > 1:
for player in cls.__players:
if (player == cls.__current_player):
continue
cls.__current_player = player
cls.__player_play()
cls.__remove_player()
print("{} there are NO MORE PLAYERS left, YOU WON!!".format(
cls.__players[0]))
class Walk(object):
KeyMap = {
"h": Coord(-1, 0), "j": Coord(0, 1), "k": Coord(0, -1), "l": Coord(1, 0),
"y": Coord(-1, -1), "u": Coord(1, -1), "b": Coord(-1, 1), "n": Coord(1, 1)
}
def __init__(self):
self._coord = Coord(1, 1)
self._console = Console().colorOn().nonBlocking()
def run(self):
self.render()
interval = int(1000/30)
while True:
self.update()
self._console.sleep(interval)
def update(self):
key = self._console.getKey()
self._coord += Walk.KeyMap.get(key, Coord(0, 0))
self.render()
def render(self):
self._console.clear()
self._console.move(Coord(1, 2)).write("+", Color.LIGHT_YELLOW)
self._console.move(Coord(3, 4)).write("T", Color.GREEN, Color.BLUE)
self._console.move(Coord(5, 6)).write("*", Color.LIGHT_YELLOW, Color.GREEN)
self._console.move(Coord(7, 8)).write("&", random.choice(list(Color.LIST)))
self._console.move(self._coord).write("@", Color.LIGHT_YELLOW).move(self._coord)
def resign_card(self):
print("{} you ought to resign a card".format(self.__name))
self.status = "Playing"
self.see_cards()
print("Press the NUMBER of the card you want to resign: ")
card_resigned = Console.cast(0, len(self.cards))
self.cards[card_resigned - 1].out_of_game = True
self.status = None
Console.clear()
def see_cards_option(self):
print("=======================")
print("PRESS 1 if you wish to SEE YOUR CARDS AGAIN. 0 if you don't.")
print("You get this choice ONCE before choosing your action!")
print("=======================")
number = Console.cast(0, 1)
if number == 1:
self.see_cards()
input("To continue: press enter")
Console.clear()
else:
return
def money_to_play(self, choice):
if (self.__coins >= 10 and choice != 3):
print("You have 10 COINS. You MUST CHOOSE HIT")
return 0
if (self.__coins < 7 and choice == 3):
Console.clear()
print("\n==== NOT ENOUGH COINS for Hit. Try again. =====")
return 0
if (self.__coins < 3 and choice == 5):
Console.clear()
print("\n==== NOT ENOUGH COINS for Murder. Try again. =====")
return 0
return 1
def __challenge(cls, player, action):
print("• Does anybody want to DEFY this action? •")
challengers = []
for other_player in cls.__players:
if other_player.status != "Playing":
add = input(
"-> {} press 1 if you want to CHALLENGE, press enter otherwise "
.format(other_player))
if add == "1":
challengers.append(other_player)
if len(challengers) == 0:
print("\n– NOBODY CHALLENGED YOU! –\n")
return 0
shuffle(challengers)
challenger = challengers[0]
action.activity_log.append("{} CHALLENGED {}".format(
challenger, player))
print("• {} you have been CHALLENGED by {} •".format(
player, challenger))
win = False
influence = cls.__dic_of_influences[action.action_status]
#when winning a challenge your card gets inmediatly replaced wit one on the deck
for card in player.cards:
if (card.out_of_game == False):
if card.influence == influence:
win = True
cls.__table_deck.deck.append(card)
player.cards.remove(card)
cls.__table_deck.assign_cards_player(
player, 1, cls.__table_deck.deck)
if win == True:
print("!! {} you have WON the challenge !!".format(player))
input("press ANY KEY to see your new card")
player.see_cards()
input("press ANY KEY to continue AND PASS computer to {}".format(
challenger))
Console.clear()
challenger.resign_card()
action.activity_log.append(
"{} lost the challenge".format(challenger))
action.action_succes = True
else:
print("• {} you have LOST the challenge •".format(player))
action.action_succes = False
action.activity_log.append("{} lost the challenge".format(player))
input("press ANY KEY to CONTINUE")
Console.clear()
player.resign_card()
def __ask_actual_player_to_challenge(cls):
Console.print_str(' * CHALLENGING PHASE * \n ')
challenge = False
while True:
answer = Console.get_str_input_with_args(
'\n* {}, want you to challenge?* [ Yes / No ] \n',
[cls.__actual_player.name])
if answer == 'Yes' or answer == 'No':
if answer == 'Yes':
challenge = True
break
else:
Console.print_str('\n * You answer isn´t valid * \n')
return challenge
Console.clear()
def __player_play(cls):
Console.clear()
Console.print_str_with_args('Turn of player {}\n\n',
[cls.__current_player.name])
Console.print_str(str(cls.__board))
Console.print_str('\n\nPoints:')
Console.print_str_with_args('{}: {} | {}: {}\n', [
cls.__players[0].name, cls.__players[0].score,
cls.__players[1].name, cls.__players[1].score
])
if len(cls.__current_player.selected_coords) < 2:
cls.__current_player.selected_coords.append([
int(number) for number in Console.get_str_input(
'Select a card entering the '
'coords separeted by comma: ').split(',')
])
cls.__board.show_card(cls.__current_player.selected_coords[-1])
else:
Console.get_str_input('Press any key to continue...')
class FovDemo(object):
KeyMap = {
"h": direction.W,
"j": direction.S,
"k": direction.N,
"l": direction.E,
"y": direction.NW,
"u": direction.NE,
"b": direction.SW,
"n": direction.SE
}
def __init__(self):
self._hero = (1, 1)
self._console = Console()
self._map = Map()
self._fov = Fov(self._map.isFloor, 5)
def run(self):
while True:
self.update()
def update(self):
self.render()
key = self._console.getKey()
self.moveHero(self.KeyMap.get(key, (0, 0)))
def moveHero(self, dir):
nextCoord = coord.sum(self._hero, dir)
if self._map.isWall(nextCoord): return
self._hero = nextCoord
def render(self):
self._console.clear()
self._map.render(self._console)
self.renderFov()
self._console.move(self._hero).write("@").move(self._hero)
def renderFov(self):
for c in self._fov.compute(self._hero):
if self._map.isFloor(c) and self._map.isInBound(c):
self._console.move(c).write('.')
def hit(self, player, list_of_players):
if len(list_of_players) == 1:
print("SORRY there are no other players to HIT")
return 0
player.coins = -7
choose_person = []
counter = 0
for person in (list_of_players):
if person.status != "Playing":
choose_person.append(person)
print("You can take a HIT on {} by pressing {}".format(
person, counter))
counter += 1
print("Enter the NUMBER of the person you want to hit: ")
hit_person = Console.cast(0, counter)
print("PASS the computer to {}".format(choose_person[hit_person].name))
input("PRESS ANY KEY to continue")
Console.clear()
choose_person[hit_person].resign_card()
class AStarDemo(object):
KeyMap = {
"h": direction.W, "j": direction.S, "k": direction.N, "l": direction.E,
"y": direction.NW, "u": direction.NE, "b": direction.SW, "n": direction.SE
}
def __init__(self):
self._cursor = (1, 1)
self._start = (1, 1)
self._goal = (33, 8)
self._console = Console()
self._map = Map()
self._astar = AStar(self._map.cost)
def run(self):
while True:
self.update()
def update(self):
self.render()
key = self._console.getKey()
if key in self.KeyMap:
self._cursor = coord.sum(self._cursor, self.KeyMap.get(key))
else:
self.putTerrain(key)
def putTerrain(self, key):
if key not in (' ', '"', '=', '#') : return
self._map.put(self._cursor, key)
def render(self):
self._console.clear()
self._map.render(self._console)
self._renderRoute()
self._console.move(self._cursor)
def _renderRoute(self):
for c in self._astar.compute(self._start, self._goal):
self._console.move(c).write('*')
def __check_actual_player(cls):
NUMBER = 0
Elimination_list = []
for i in range(cls.NUMBER_OF_PLAYERS):
if len(cls.__players[i].hand_of_cards) == 0:
Console.clear()
Console.print_str_with_args("{}, has been eliminated",[cls.__players[i]])
Elimination_list.append(i)
Console.clear()
if cls.__players[i].number == cls.__actual_player.number:
NUMBER = i
if NUMBER == (cls.NUMBER_OF_PLAYERS - 1):
cls.__actual_player = cls.__players[0]
else:
cls.__actual_player = cls.__players[NUMBER + 1]
if len(Elimination_list) > 0:
for number in Elimination_list:
cls.__players.remove(cls.__players[number])
cls.NUMBER_OF_PLAYERS -= 1
def __choose_the_action(cls):
Console.print_str_with_args(
'* TURN OF PLAYER {} *\n\n\n* Your influences are: *\n ',
[cls.__actual_player.name])
Console.print_list(cls.__actual_player.hand_of_cards)
all_actions = ['Income', 'Foreign Aid', 'Tax', 'Exchange', 'Steal']
if cls.__actual_player.coins >= 10:
cls.__actual_player.choosen_action = 'Coup'
else:
if cls.__actual_player.coins >= 7:
all_actions.append('Coup')
if cls.__actual_player.coins >= 3:
all_actions.append('Assassinate')
Console.print_str('\n* Take one action: * \n ')
Console.print_list(all_actions)
while True:
action = Console.get_str_input('\n* Select your action *\n')
if action in all_actions:
break
else:
Console.print_str(
'* Wrong action, please choose again * \n')
Console.print_str_with_args('\n* {} took the action: {} *\n',
[cls.__actual_player.name, action])
cls.__actual_player.choosen_action = action
Console.clear()
def __counter_action(cls):
counteratackking = [False, 0]
counter_actions = [
'Block-Foreign Aid', 'Block-Stealing', 'Block-Assassination'
]
Console.clear()
Console.print_str(" * COUNTERING PHASE * \n")
for i in range(len(cls.__players)):
if cls.__players[i] != cls.__actual_player:
while True:
answer = Console.get_str_input_with_args(
'\n* {}, do you want to counter {} * [ Yes / No ] \n',
[cls.__players[i].name, cls.__actual_player.name])
if answer == 'Yes' or answer == 'No':
if answer == 'Yes':
while True:
Console.print_str('\n * SELECT YOU COUNTER *\n ')
Console.print_list(counter_actions)
counteraction = Console.get_str_input('')
if counteraction in counter_actions:
cls.__players[
i].choosen_action = counteraction
counteratackking[0] = True
counteratackking[1] = i
break
else:
Console.print_str(
'* Wrong counter, please choose again * \n'
)
break
elif answer == 'No':
break
else:
Console.print_str('\n * You answer isn´t valid * \n')
return counteratackking
class LineDemo(object):
KeyMap = {
"h": direction.W,
"j": direction.S,
"k": direction.N,
"l": direction.E,
"y": direction.NW,
"u": direction.NE,
"b": direction.SW,
"n": direction.SE
}
def __init__(self):
self._target = (1, 1)
self._center = (10, 10)
self._console = Console()
def run(self):
while True:
self.update()
def update(self):
self.render()
key = self._console.getKey()
self.moveTarget(self.KeyMap.get(key, (0, 0)))
def moveTarget(self, dir):
self._target = coord.sum(self._target, dir)
def render(self):
self._console.clear()
self._console.move(self._center).write('@')
self._console.move(self._target).write('X')
for c in coord.line(self._center, self._target):
self._console.move(c).write('.')
self._console.move(self._target)
def defy_counterattack(self,list_of_players,player,action,table_deck):
print("\nDoes anybody want to DEFY this COUNTERATTACK?")
challengers=[]
for other_player in list_of_players:
if other_player.status!="Challenging":
add=input("{} PRESS 1 if you want to CHALLENGE, press any other key otherwise ".format(other_player))
if add=="1":
challengers.append(other_player)
if len(challengers)==0:
action.action_succes=False
print("Nobody challenged you")
self.master_of_counterattack(player,self.__adversary,action.action_status)
return 0
shuffle(challengers)
challenger=challengers[0]
action.activity_log.append("{} challenged {}'s counterattack".format(challenger,self.__adversary))
print("{} you have been CHALLENGED by {}".format(self.__adversary,challenger))
win=False
for card in self.adversary.cards:
if (card.out_of_game==False and card.influence==self.__character):
win=True
print("{} you have WON the CHALLENGE and get to complete the counterattack".format(self.__adversary))
action.activity_log.append("{} won challenge and got to complete counterattack".format(self.__adversary))
table_deck.deck.append(card)
self.__adversary.cards.remove(card)
table_deck.assign_cards_player(self.__adversary,1,table_deck.deck)
input("{} press ANY KEY to see your new card".format(self.__adversary))
self.__adversary.see_cards()
input("PASS computer to {} AND PRESS ANY KEY to continue".format(challenger))
Console.clear()
challenger.resign_card()
Console.clear()
action.action_succes=False
self.master_of_counterattack(player,self.__adversary,action.action_status)
if win==False:
print("{} you have LOST the CHALLENGE".format(self.__adversary))
action.activity_log.append("{} won the challenge and got to stop the counterattack".format(challenger))
input("PASS computer to {} AND PRESS ANY KEY to continue".format(self.__adversary))
Console.clear()
self.__adversary.resign_card()
Console.clear()
self.__adversary.status=None
def __player_play(cls):
Console.clear()
print("It's {}'s turn!".format(cls.__current_player))
cls.__current_player.status = "Playing"
cls.__current_player.see_cards_option()
flag = 0
while (flag == 0):
cls.__see_coins_and_cards()
choice = Console.player_menu(cls.__current_player.name)
flag = cls.__current_player.money_to_play(choice)
action = Action()
action.action_status = cls.__list_of_actions[choice - 1]
action.action_succes = True
action.activity_log = []
input("PRESS ANY KEY and PASS the computer to the other players")
Console.clear()
Console.show_last_action(cls.__current_player.name,
action.action_status)
action.activity_log.append("{} chose the action {}".format(
cls.__current_player, action.action_status))
if (choice != 1 and choice != 2 and choice != 3):
cls.__challenge(cls.__current_player, action)
cls.__remove_player()
if action.action_succes == True:
if (choice == 2 or choice == 5 or choice == 6):
result = cls.__counterattack(cls.__current_player,
action.action_status)
if result != 0:
action.activity_log.append("{} counterattacked {}".format(
result[0], cls.__current_player))
new_counterattack = Counterattack(result[0], result[1])
new_counterattack.defy_counterattack(
cls.__players, cls.__current_player, action,
cls.__table_deck)
cls.__remove_player()
if (action.action_succes == True):
print(". : Now {} gets to complete their action : .".format(
cls.__current_player))
action.activity_log.append(
"{} got to complete the action {}".format(
cls.__current_player, action.action_status))
action.master_of_actions(choice, cls.__current_player,
cls.__players, cls.__table_deck.deck)
cls.__current_player.status = None
input("Press ENTER to continue")
Console.clear()
Console.show_log(cls.__current_player, action.activity_log)
input("END OF TURN, PRESS ENTER to continue")
def take_pictures(self):
Console.clear()
print('Preparing ...')
sleep(2)
# flushes input buffer to prevent user input concatenation with previously pressed keys
stdout.flush()
tcflush(stdin, TCIOFLUSH)
Console.clear()
# Q1
email = input("What's email address?\n")
# password loop to make sure user is entering the correct one.
while True:
password1 = getpass.getpass(
"Set up your password (min 6 chars).\n")
password2 = getpass.getpass("Repeat your password.\n")
if password1 == password2:
break
# create firebase credentials
self._fb.create_user(email, password1)
# time countdown before take the picture (5s)
ct = 5
Console.clear()
while ct > 0:
print(
'Please look at the camera now. We will take a few pictures in: %s'
% ct)
sleep(1)
ct = ct - 1
os.system('clear')
# check if folder already exists
if os.path.exists('user') is False:
os.mkdir('user')
# get random id and if exists re-randomize again
user_id = random.SystemRandom().randint(10000, 99999)
while True:
if os.path.exists('user/%s' % user_id) is False:
os.mkdir('user/%s' % user_id)
self._fb.update_data({"users/%s" % user_id: email})
break
else:
user_id = random.SystemRandom().randint(10000, 99999)
counter = 0 # will count pictures which were taken
# taking user's pictures
while True:
ret, frame = self._video.read(
) # ret - bool, frame - current camera frame
gray = self._convert_to_grey(frame) # convert picture to greyscale
faces = self._cascade.detectMultiScale(gray, 1.3,
5) # detect faces
# iterate through detected
for (x, y, w, h) in faces:
cv2.imwrite("user/%s/%s.jpg" % (user_id, counter),
gray[y:y + h, x:x + w])
counter = counter + 1
if counter == 10: # at the 10th picture stop
self.train_faces() # run train algorithm
# print successful message
Console.clear()
print('Your profile was created! Thanks!')
sleep(3)
# update broker and system with the information on registration
self._fb.update_data({"registration_on_progress": False})
self.is_registration_on = False
# show a regular message on the display
Console.show_reg_msg()
break
class ConsoleOutput:
PENDING = 0
INPROGRESS = 1
COMPLETE = 2
start = None
fp = None
console = None
pos = 0
tier = None
dirs = None
export_counts = None
libs_counts = None
failed = False
lines = []
throbber = ['-', '\\', '|', '/']
throbpos = 0
def __init__(self, fp):
self.console = Console(fp)
self.fp = fp
# Reset the display
self.console.clear_title()
self.console.reset_color()
self.console.clear()
# Clear the screen and go to the top left
self.start = datetime.now()
self.fp.write("Build started at %s\n" %
self.start.strftime("%H:%M:%S"))
self.console.go_right(79)
def destroy(self):
now = datetime.now()
delta = (now - self.start).seconds
delta, seconds = divmod(delta, 60)
hours, minutes = divmod(delta, 60)
if not self.failed:
self._go_to_end()
self.console.clear_title()
self.console.reset_color()
self.fp.write("\nBuild completed at %s taking %d:%02d:%02d\n\n" %
(now.strftime("%H:%M:%S"), hours, minutes, seconds))
else:
self.fp.write("\nBuild failed at %s taking %d:%02d:%02d\n\n" %
(now.strftime("%H:%M:%S"), hours, minutes, seconds))
def _go_to_pos(self, pos):
self._clear_throbber()
self.console.go_to_pos(pos)
self.console.go_linehome()
def _go_to_end(self):
self._go_to_pos(0)
def _color_for_state(self, state, count=0):
if state == self.COMPLETE:
return self.console.GREEN
if state == self.INPROGRESS or count > 0:
return self.console.YELLOW
return self.console.RED
def _print_tier_line(self, export_state, export_count, libs_state,
libs_count, name):
self.console.set_color(
self._color_for_state(export_state, export_count))
self.fp.write(" export ")
if export_count > 0:
self.fp.write("[%2s] " % export_count)
else:
self.fp.write(" ")
self.console.set_color(self._color_for_state(libs_state, libs_count))
self.fp.write("libs ")
if libs_count > 0:
self.fp.write("[%2s] " % libs_count)
else:
self.fp.write(" ")
self.console.reset_color()
self.fp.write("%-45s" % name)
self._draw_throbber()
def _print_tools_line(self, state, count, name):
self.console.set_color(self._color_for_state(state, count))
self.fp.write(" %s " % name)
if count > 0:
self.fp.write("[%2s]" % count)
else:
self.fp.write(" ")
self.console.reset_color()
self.console.go_right(79 - (7 + len(name)))
self._draw_throbber()
def _draw_throbber(self):
self.console.go_left(1)
self.fp.write(self.throbber[self.throbpos])
self.throbpos = (self.throbpos + 1) % len(self.throbber)
def _clear_throbber(self):
self.console.go_left(1)
self.fp.write(" ")
def start_prebuild(self):
self._go_to_end()
self.console.reset_color()
self.fp.write("\nprebuild:\n")
def start_configure(self, name):
self._go_to_end()
self.console.set_title("prebuild %s" % name)
self.console.set_color(self._color_for_state(self.INPROGRESS, 0))
self.fp.write(" %s\n" % name)
self.console.reset_color()
self.console.go_up(1)
self.console.go_right(79)
self._draw_throbber()
def finish_configure(self, name):
self.console.go_linehome()
self.console.set_color(self._color_for_state(self.COMPLETE))
self.fp.write(" %-77s" % name)
self.console.reset_color()
self._draw_throbber()
def start_tier(self, name, dirs):
self._go_to_end()
self.console.reset_color()
self.fp.write("\ntier %s - %s dirs:\n" % (name, len(dirs)))
self.tier = name
self.dirs = dirs
self.export_counts = dict()
self.libs_counts = dict()
for dir in dirs:
self.export_counts[dir] = 0
self.libs_counts[dir] = 0
self._print_tier_line(self.PENDING, 0, self.PENDING, 0, dir)
self._clear_throbber()
self.fp.write("\n")
self.console.go_up(len(dirs))
self.console.go_right(79)
def start_exports(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self.console.set_title("%s export [%d/%d] %s" %
(self.tier, pos + 1, len(self.dirs), dir))
self._print_tier_line(self.INPROGRESS, self.export_counts[dir],
self.PENDING, self.libs_counts[dir], dir)
def start_export_subdir(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self.export_counts[dir] += 1
self._print_tier_line(self.INPROGRESS, self.export_counts[dir],
self.PENDING, self.libs_counts[dir], dir)
def finish_exports(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self._print_tier_line(self.COMPLETE, self.export_counts[dir],
self.PENDING, self.libs_counts[dir], dir)
def start_libs(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self.console.set_title("%s libs [%d/%d] %s" %
(self.tier, pos + 1, len(self.dirs), dir))
self._print_tier_line(self.COMPLETE, self.export_counts[dir],
self.INPROGRESS, self.libs_counts[dir], dir)
def start_libs_subdir(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self.libs_counts[dir] += 1
self._print_tier_line(self.COMPLETE, self.export_counts[dir],
self.INPROGRESS, self.libs_counts[dir], dir)
def finish_libs(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self._print_tier_line(self.COMPLETE, self.export_counts[dir],
self.COMPLETE, self.libs_counts[dir], dir)
def start_tools(self, name, dirs):
self._go_to_end()
self.console.reset_color()
self.fp.write("\ntools tier %s - %s dirs:\n" % (name, len(dirs)))
self.tier = name
self.dirs = dirs
self.libs_counts = dict()
for dir in dirs:
self.libs_counts[dir] = 0
self._print_tools_line(self.PENDING, 0, dir)
self._clear_throbber()
self.fp.write("\n")
self.console.go_up(len(dirs))
self.console.go_right(79)
self._draw_throbber()
def start_tools_dir(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self.console.set_title("%s tools [%d/%d] %s" %
(self.tier, pos + 1, len(self.dirs), dir))
self._print_tools_line(self.INPROGRESS, self.libs_counts[dir], dir)
def start_tools_subdir(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self.libs_counts[dir] += 1
self._print_tools_line(self.INPROGRESS, self.libs_counts[dir], dir)
def finish_tools_dir(self, dir):
pos = self.dirs.index(dir)
self._go_to_pos(pos - len(self.dirs))
self._print_tools_line(self.COMPLETE, self.libs_counts[dir], dir)
def error(self):
if self.failed:
return
self.failed = True
self._go_to_end()
self.console.clear_title()
self.console.reset_color()
self.fp.write("\n")
for line in self.lines:
self.fp.write(line)
def build_log(self, line):
self.fp.flush()
#time.sleep(0.005)
if self.failed:
self.fp.write(line)
else:
self._draw_throbber()
if len(self.lines) == 5:
self.lines.pop(0)
self.lines.append(line)
def __execute_action(cls):
if cls.__actual_player.choosen_action != '':
Console.print_str_with_args(' *{} Effect* \n ',
[cls.__actual_player.choosen_action])
if cls.__actual_player.choosen_action == 'Income': # INCOME
cls.__Income(cls.__actual_player)
Console.print_str_with_args(
'\n*{} has {} coins now *\n',
[cls.__actual_player, cls.__actual_player.coins])
elif cls.__actual_player.choosen_action == 'Foreign Aid': # FOREIGN AID
counter = cls.__counter_action()
if counter[0] == True:
Console.print_str_with_args(
'\n*{} counter-atack with {} *\n', [
cls.__players[counter[1]],
cls.__players[counter[1]].choosen_action
])
challenge = cls.__ask_actual_player_to_challenge()
if challenge == True:
cls.__challenge(cls.__players[counter[1]],
cls.__actual_player)
else:
cls.__Foreign_aid(cls.__actual_player)
Console.print_str_with_args(
'\n*{} has {} coins now *\n',
[cls.__actual_player, cls.__actual_player.coins])
else:
cls.__Foreign_aid(cls.__actual_player)
Console.print_str_with_args(
'\n*{} has {} coins now *\n',
[cls.__actual_player, cls.__actual_player.coins])
elif cls.__actual_player.choosen_action == 'Coup': ### COUP
Target_number = cls.__choosen_player_to_attack()
cls.__Coup(cls.__actual_player, cls.__players[Target_number], cls.__deck)
Console.print_str_with_args(
'\n*{} made a Coup, he has {} coins now *\n',
[cls.__actual_player.name, cls.__actual_player.coins])
elif cls.__actual_player.choosen_action == 'Tax': ### TAX
cls.__Duke_act(cls.__actual_player)
Console.print_str_with_args(
'\n*{} has {} coins now *\n',
[cls.__actual_player, cls.__actual_player.coins])
elif cls.__actual_player.choosen_action == 'Assassinate': ### ASSASSINATE
Target_number = cls.__choosen_player_to_attack()
counter = cls.__counter_action()
if counter[0] == True:
Console.print_str_with_args(
'\n*{} counter-atack with {} *\n', [
cls.__players[counter[1]],
cls.__players[counter[1]].choosen_action
])
challenge = cls.__ask_actual_player_to_challenge()
if challenge == True:
cls.__challenge(cls.__players[counter[1]],
cls.__actual_player)
else:
cls.__Assassin_act(cls.__actual_player,
cls.__players[Target_number], cls.__deck)
Console.print_str_with_args(
'\n*{} has murder a influence of {} *\n',
[cls.__actual_player, cls.__players[Target_number]])
else:
cls.__Assassin_act(cls.__actual_player,
cls.__players[Target_number], cls.__deck)
Console.print_str_with_args(
'\n*{} has murder a influence of {} *\n',
[cls.__actual_player, cls.__players[Target_number]])
elif cls.__actual_player.choosen_action == 'Exchange': ### EXCHANGE
cls.__Ambassador_act(cls.__actual_player, cls.__deck)
Console.print_str_with_args(
'\n*{} hand of card: *\n',
[cls.__actual_player])
Console.print_list(cls.__actual_player.hand_of_cards)
elif cls.__actual_player.choosen_action == 'Steal': ## STEAL
Target_number = cls.__choosen_player_to_attack()
counter = cls.__counter_action()
if counter[0] == True:
Console.print_str_with_args(
'\n*{} counter-atack with {} *\n', [
cls.__players[counter[1]],
cls.__players[counter[1]].choosen_action
])
challenge = cls.__ask_actual_player_to_challenge()
if challenge == True:
cls.__challenge(cls.__players[counter[1]],
cls.__actual_player)
else:
cls.__Captain_act(cls.__actual_player, cls.__players[Target_number])
Console.print_str_with_args(
'\n*{} steal some coins, he has {} coins now *\n',
[cls.__actual_player, cls.__actual_player.coins])
else:
cls.__Captain_act(cls.__actual_player,cls.__players[Target_number])
Console.print_str_with_args(
'\n*{} steal some coins, he has {} coins now *\n',
[cls.__actual_player, cls.__actual_player.coins])
Console.clear()
def __challenge(cls, player_challenged,challenger):
possible_actions = ['Income', 'Foreign Aid']
for card in player_challenged.hand_of_cards:
if card == 'Duke':
possible_actions.append('Tax')
possible_actions.append('Block-Foreign Aid')
elif card == 'Ambassador':
possible_actions.append('Exchange')
possible_actions.append('Block-Stealing')
elif card == 'Captain':
possible_actions.append('Steal')
possible_actions.append('Block-Stealing')
elif card == 'Assassin' and player_challenged.coins >= 3:
possible_actions.append('Assasinate')
elif card == 'Contessa':
possible_actions.append('Block-Assassination')
if player_challenged.choosen_action in possible_actions:
if player_challenged.choosen_action == 'Tax':
cls.__deck.return_to_deck('Duke')
player_challenged.hand_of_cards.remove('Duke')
elif player_challenged.choosen_action == 'Exchange':
cls.__deck.return_to_deck('Ambassador')
player_challenged.hand_of_cards.remove('Ambassador')
elif player_challenged.choosen_action == 'Steal':
cls.__deck.return_to_deck('Captain')
player_challenged.hand_of_cards.remove('Captain')
elif player_challenged.choosen_action == 'Assassinate':
cls.__deck.return_to_deck('Assassin')
player_challenged.hand_of_cards.remove('Assassin')
elif player_challenged.choosen_action == 'Block-Assasinate':
cls.__deck.return_to_deck('Contessa')
player_challenged.hand_of_cards.remove('Contessa')
player_challenged.hand_of_cards.append(
cls.__deck.pick_card_and_remove())
Console.print_str_with_args(
'\n* {} loosed the challenge. {} can use {} *\n', [
challenger, player_challenged,
player_challenged.choosen_action
])
challenger_cards = []
for card in challenger.hand_of_cards:
challenger_cards.append(card)
Console.print_list(challenger_cards)
if len(challenger_cards) == 2:
while True:
discard = Console.get_str_input_with_args(
' * {}: Select the card that do you want to discard *\n',[challenger.name])
if discard in challenger_cards:
break
else:
Console.print_str(
'* Wrong selection, please choose again * \n')
else:
discard = challenger_cards[0]
challenger.hand_of_cards.remove(discard)
cls.__Table.append(discard)
Console.print_str_with_args('* {}, your cards left are: *',[challenger.name])
Console.print_list(challenger.hand_of_cards)
else:
Console.print_str_with_args(
'\n* {} loosed the challenge. He can´t use {} *\n',
[player_challenged, player_challenged.choosen_action])
challenged_cards = []
for card in player_challenged.hand_of_cards:
challenged_cards.append(card)
Console.print_list(challenged_cards)
if len(challenged_cards) == 2:
while True:
discard = Console.get_str_input_with_args(
'* {} : Select the card that do you want to discard *\n\n',
[player_challenged])
if discard in challenged_cards:
break
else:
Console.print_str(
'* Wrong selection, please choose again * \n')
else:
discard = challenged_cards[0]
cls.__Table.append(discard)
player_challenged.hand_of_cards.remove(discard)
Console.print_str_with_args('\n* {}, your cards left are: *\n',[player_challenged.name])
Console.print_list(player_challenged.hand_of_cards)
player_challenged.choosen_action = ''
Console.clear()
class Game:
def __init__(self):
self.rng = RNG()
self.entities = []
self.active_entities = []
self.dungeon = None
self.message_log = None
self.menu = None
self.overlay = None
self.tile_types = {}
self.materials = {}
self.words = {}
self.status_effects = {}
self.traits = {}
self.abilities = {}
self.breeds = {}
self.prefabs = {}
self.active_region = []
self.player = None
self.fps=0
self.map_con = Console("Dungeon Map",MAP_X,MAP_Y,MAP_W,MAP_H)
self.panel_con = Console("Side Panel",PANEL_X,PANEL_Y,PANEL_W,PANEL_H)
self.log_con = Console("Message Log",LOG_X,LOG_Y,LOG_W,LOG_H)
self.state = STATE_PLAYING
self.input_state = INPUT_NORMAL
self.key = libtcod.Key()
self.mouse = libtcod.Mouse()
@property
def depth(self):
return self.player.depth
@property
def cur_level(self):
return self.player.level
@property
def living_entities(self):
return filter(lambda entity: entity.creature and entity.creature.alive, self.entities)
def add_entity(self,entity):
self.entities.append(entity)
def next_id(self):
next_id = 0
id_list = [entity.entity_id for entity in self.entities]
while True:
if next_id not in id_list:
return next_id
else:
next_id += 1
def load_yaml(self):
load_file = open('data/load.yaml')
load_data = yaml.load(load_file)
load_file.close()
load_order = [('tiles',self.load_tile_types),
('materials',self.load_materials),
('words',self.load_words),
('statuseffects',self.load_status_effects),
('traits',self.load_traits),
('abilities',self.load_abilities),
('breeds',self.load_breeds),
('prefabs',self.load_prefabs),
('player',self.load_player)]
for category in load_order:
files = []
if 'directories' in load_data[category[0]]:
for directory in load_data[category[0]]['directories']:
for file_name in os.listdir(directory):
if file_name.endswith('.yaml'):
files.append(directory.strip('/')+'/'+file_name)
if 'files' in load_data[category[0]]:
for file_name in load_data[category[0]]['files']:
files.append(file_name)
category[1](files)
def load_tile_types(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.tile_types)
for tile_type_id in self.tile_types:
tile_type = self.tile_types[tile_type_id]
tile_type = TileType(tile_type_id,**tile_type)
self.tile_types[tile_type_id] = tile_type
if type(tile_type.color)==list:
tile_type.color = [yamlhelp.load_color(c)
for c in tile_type.color]
else:
tile_type.color = yamlhelp.load_color(tile_type.color)
tile_type.color_not_visible = yamlhelp.load_color(tile_type.color_not_visible)
def load_materials(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.materials)
for material_id in self.materials:
material = self.materials[material_id]
material = Material(material_id, **material)
self.materials[material_id] = material
material.color = yamlhelp.load_color(material.color)
def load_status_effects(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.status_effects)
for status_effect_id in self.status_effects:
status_effect = self.status_effects[status_effect_id]
status_effect = StatusEffect(status_effect_id, **status_effect)
self.status_effects[status_effect_id] = status_effect
def load_traits(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.traits)
for trait_id in self.traits:
trait = self.traits[trait_id]
trait = Trait(trait_id,**self.traits[trait_id])
self.traits[trait_id] = trait
for trait_id in self.traits:
#second pass needed since traits defs include other traits
trait = self.traits[trait_id]
if trait.replaces:
trait.replaces = self.traits[trait.replaces]
if not trait.cancels: trait.cancels=[]
for i in range(len(trait.cancels)):
trait.cancels[i] = self.traits[trait.cancels[i]]
trait.effect = StatusEffect(trait_id,**trait.effect)
if trait.cost:
yamlhelp.convert_keys(trait.cost,self.materials)
if trait.removal_cost:
yamlhelp.convert_keys(trait.removal_cost,self.materials)
def load_words(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.words)
for word_id in self.words:
word = self.words[word_id]
word = Word(word_id, **word)
self.words[word_id] = word
word.color = yamlhelp.load_color(word.color)
def load_abilities(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.abilities)
for ability_id in self.abilities:
ability = self.abilities[ability_id]
ability = Ability(self, ability_id, **ability)
self.abilities[ability_id] = ability
ability.trigger = eval('abilityfunctions.%s'%ability.trigger)
ability.effect = eval('abilityfunctions.%s'%ability.effect)
if ability.color:
ability.color = yamlhelp.load_color(ability.color)
def load_breeds(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.breeds)
for breed_id in self.breeds:
breed = self.breeds[breed_id]
breed = Breed(self, breed_id, **breed)
self.breeds[breed_id] = breed
breed.color = yamlhelp.load_color(breed.color)
yamlhelp.convert_keys(breed.materials,self.materials)
if breed.death_func:
breed.death_func = eval('deathfunctions.%s' % \
breed.death_func)
def load_prefabs(self,files):
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,self.prefabs)
for prefab_id in self.prefabs:
prefab = self.prefabs[prefab_id]
prefab = Prefab(prefab_id,**prefab)
self.prefabs[prefab_id] = prefab
for char in prefab.char_to_tile:
if type(prefab.char_to_tile[char])==list:
prefab.char_to_tile[char] = [self.tile_types[t] for t in prefab.char_to_tile[char]]
else:
prefab.char_to_tile[char] = self.tile_types[prefab.char_to_tile[char]]
def load_player(self,files):
player_data = {}
for file_name in files:
f = open(file_name)
data = yaml.load(f)
f.close()
yamlhelp.merge(data,player_data)
player_name = player_data.keys()[0]
player_data = player_data[player_name]
if 'abilities' in player_data:
starting_abilities = player_data['abilities']
del player_data['abilities']
else:
starting_abilities = []
player_creature = Golem(self,player_name,**player_data)
player_creature.raw_color = yamlhelp.load_color(player_creature.raw_color)
for ability in starting_abilities:
player_creature.add_ability(ability)
for bp_name in player_creature.body_parts:
bp = player_creature.body_parts[bp_name]
bp = BodyPart(player_creature,bp_name,**bp)
player_creature.body_parts[bp_name] = bp
starting_trait_ids = bp.traits
bp.traits = []
for trait_id in starting_trait_ids:
bp.add_trait(self.traits[trait_id],force=True)
self.player = Player(self, self.next_id(),
0, 0, 0, False, True,
input_handler = InputHandler(),
creature = player_creature)
self.add_entity(self.player)
for name in self.materials:
self.player.materials[self.materials[name]] = 0
for ability in self.abilities.values():
self.player.add_observer(ability)
ability.add_observer(self.player.input_handler)
for word_id in self.words:
self.player.words.append(self.words[word_id])
def clear_all(self):
for entity in self.entities:
entity.clear(self.player.x,
self.player.y,
self.map_con)
def get_entity(self,entity_id):
for entity in self.entities:
if entity.entity_id == entity_id:
return entity
def get_creature_at(self,x,y):
return self.cur_level.get_tile(x,y).creature
def get_item_at(self,x,y):
return self.cur_level.get_tile(x,y).item
def render_panel(self):
self.panel_con.clear()
self.panel_con.draw_border(True,C_BORDER,C_BORDER_BKGND)
y = 2
if SHOW_FPS:
x=2
self.panel_con.set_default_foreground(C_MENU)
self.panel_con.print_string(x,y,'FPS: %i'%self.fps)
y += 1
y += 1
for part_name in ['Head','Torso','L Arm','R Arm','L Leg','R Leg']:
part = self.player.creature.body_parts[part_name]
part_name = '%s:'%part.name
part_health = '%i/%i'%(part.health,part.max_health)
x = 2
self.panel_con.set_default_foreground(C_MENU)
self.panel_con.print_string(x,y,part_name)
x = 9
self.panel_con.set_default_foreground(libtcod.light_red)
self.panel_con.print_string(x,y,part_health)
y += 1
status_effects = []
for bp in self.player.creature.body_parts.values():
status_effects += bp.status_effects
if status_effects:
y += 1
for se in status_effects:
if se.name:
x = 2
self.panel_con.set_default_foreground(C_MENU)
self.panel_con.print_string(x,y,se.name)
y += 1
y += 1
for material in sorted(self.player.materials):
x = 2
s = '%s: %i'%(material,self.player.materials[material])
self.panel_con.set_default_foreground(material.color)
self.panel_con.print_string(x,y,s)
y += 1
"""y += 1
for word in sorted(self.player.words):
color = word.color
x = 2
self.panel_con.set_default_foreground(word.color)
self.panel_con.print_string(x,y,word.name)
y += 1"""
y += 1
self.panel_con.set_default_foreground(C_MENU)
for stat in (('Size',self.player.creature.size),
('Agility',self.player.creature.agility),
('Perception',self.player.creature.perception),
('Strength',self.player.creature.strength),
('Speed',self.player.creature.speed)):
x = 2
self.panel_con.print_string(x,y,'%s: %i'%stat)
y += 1
def render_all(self):
player_x = self.player.x
player_y = self.player.y
if FOCUS == FOCUS_PLAYER:
focus_x = player_x
focus_y = player_y
elif FOCUS == FOCUS_FIXED:
focus_x = LEVEL_W//2
focus_y = LEVEL_H//2
self.dungeon.render(focus_x, focus_y, self.map_con,
overlay=self.overlay)
for entity in self.entities:
if entity != self.player:
entity.render(focus_x, focus_y, self.map_con)
for entity in self.living_entities: #draw living creatures on top
if entity != self.player:
entity.render(focus_x, focus_y, self.map_con)
self.player.render(focus_x, focus_y, self.map_con)
self.map_con.draw_border(True,C_BORDER,C_BORDER_BKGND)
if self.menu:
self.menu.render(self.map_con)
self.map_con.blit()
self.message_log.render(self.log_con)
self.log_con.blit()
self.render_panel()
self.panel_con.blit()
def play(self):
self.dungeon.update()
self.render_all()
libtcod.console_flush()
t = time.time()
while not libtcod.console_is_window_closed():
#libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS|libtcod.EVENT_MOUSE, self.key, self.mouse)
#self.state = self.player.input_handler(key,mouse,
# self.input_state,
# self.menu)
#if self.menu and self.state != STATE_MENU:
# self.menu = None
#if self.state == STATE_PLAYING:
# self.player.creature.energy -= ENERGY_THRESHOLD
#while self.state == STATE_PLAYING:
player_room = self.cur_level.get_room_at(*self.player.pos)
if player_room:
active_rooms = [player_room]
self.active_region = []
for room in player_room.connections:
if room not in active_rooms:
active_rooms.append(room)
for r in room.connections:
if r not in active_rooms:
active_rooms.append(room)
for room in active_rooms:
self.active_region += room.tile_positions
else:
self.active_region = [self.player.pos]
self.active_entities=[]
for entity in self.entities:
if entity.pos in self.active_region:
self.active_entities.append(entity)
self.clear_all()
for entity in self.active_entities:
entity.update()
#self.player.creature.energy += self.player.creature.speed
#print self.player.creature.energy
#if self.player.creature.energy >= ENERGY_THRESHOLD:
#self.state = STATE_PAUSED
self.dungeon.update()
self.render_all()
libtcod.console_flush()
self.fps = 1.0/(time.time()-t)
t=time.time()
# Ryan Dawkins
# October 9th, 2014
# Programming Assignment 1
from storage import Storage
from console import Console
from structconsole import StructConsole
from arrayconsole import ArrayConsole
if __name__ == "__main__":
Console.clear()
Console.greet()
# We give storage the None object because we want
# to abstract what kind of class it is later
storage = None
arraysOrStructs = raw_input(
"Would you rather use structs or arrays? (enter s or a)\n> ")
if arraysOrStructs == "a":
storage = ArrayConsole()
elif arraysOrStructs == "s":
storage = StructConsole()
else:
print "Incorrect input you must enter s or a"
sys.exit()
while True:
command = raw_input("user:<storage>$ ")
storage.execute(command)
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
#icon = QIcon("logo.png")
#self.setWindowIcon(icon)
self.setWindowTitle("LiveHack by nAkoustix v0.1")
#pal = self.palette()
#pal.setColor(QPalette.Base, Qt.black)
#pal.setColor(QPalette.Text, Qt.green)
#self.setPalette(pal)
#self.setAutoFillBackground(True)
self.console = Console(self)
self.lay = QGridLayout()
self.lay.addWidget(self.console, 0, 0)
cw = QWidget(self)
cw.setLayout(self.lay)
self.setCentralWidget(cw)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.setblocking(0)
self.localAddr = ("localhost", 9001)
self.socket.bind(self.localAddr)
self.socksend = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.remoteAddr = ("localhost", 9000)
self.buffer = []
self.indentation = 0
self.readTimer = QTimer(self)
self.readTimer.timeout.connect(self.readData)
self.console.newLine.connect(self.interpretLine)
self.console.indentationPlus.connect(self.indentPlus)
self.console.indentationMinus.connect(self.indentMinus)
self.readTimer.start(50)
self.console.makePrompt()
def indentPlus(self):
print("indent +")
self.indentation += 1
def indentMinus(self):
print("indent -")
self.indentation -= 1
def interpretLine(self, line):
if line[:3] != ">>>" and line[:3] != "...":
self.console.putData("\n")
self.console.makePrompt()
return
line = line[4:]
if line[:1] == "!":
line = line[1:]
#-- Escape chars ----------------------
print("Escape char!")
if line == "knock":
print("knock, knock, knocking on Liiives door...")
self.console.putData(
"\n\\0/ - Client says:\t\"Knock knock.. Hi Live! may I come in?\""
)
self.socksend.sendto("!knock".encode("utf-8"), self.remoteAddr)
elif line == "clear":
self.socksend.sendto("!clear".encode("utf-8"), self.remoteAddr)
self.clear()
self.console.clear()
elif line == "exit":
print("Bye!!")
self.exitTimer = QTimer(self)
self.console.putData("\nBye!!")
#self.exitTimer.timeout.connect(QCoreApplication.instance.quit)
self.exitTimer.timeout.connect(self.close)
self.exitTimer.start(800)
#QCoreApplication.instance().quit()
else:
self.console.putData("\nUnknown escape sequence!")
self.makePrompt()
self.clear()
return
self.buffer += [line]
#self.console.addToCmdHistory(line)
#-- Editor behaviour ------------------
if line[-1:] == ":":
self.console.putData("\n")
self.indentation += 1
self.console.makeExtendedPrompt(self.indentation)
print(": found")
print("line")
#debug("1");
else:
self.console.putData("\n")
if self.indentation == 0:
self.execute()
self.console.makePrompt()
#debug("2");
else:
#self.indentation = 0
stripped = line.replace(" ", "")
if len(stripped) == 0:
self.indentation = 0
self.execute()
self.console.makePrompt()
#debug("3");
else:
#debug("4");
self.console.makeExtendedPrompt(self.indentation)
def clear(self):
self.indentation = 0
self.buffer = []
def execute(self):
print("execute")
print(self.indentation)
s = ""
for line in self.buffer:
s += line + "\n"
# check if there is anything
if len(s.replace("\n", "")) == 0:
print("execution aborted")
else:
print(s)
self.socksend.sendto(bytes(s, "utf-8"), self.remoteAddr)
self.socksend.sendto("!execute".encode("utf-8"), self.remoteAddr)
self.clear()
def readData(self):
try:
while 1:
self.data, self.addr = self.socket.recvfrom(65536)
decoded = self.data.decode()
#print(decoded)
if decoded != "" and decoded != "\n":
self.console.putData("\n")
self.console.putData(decoded)
except Exception as e:
pass
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
#icon = QIcon("logo.png")
#self.setWindowIcon(icon)
self.setWindowTitle("LiveHack by nAkoustix v0.1")
#pal = self.palette()
#pal.setColor(QPalette.Base, Qt.black)
#pal.setColor(QPalette.Text, Qt.green)
#self.setPalette(pal)
#self.setAutoFillBackground(True)
self.console = Console(self)
self.lay = QGridLayout()
self.lay.addWidget(self.console, 0,0)
cw = QWidget(self)
cw.setLayout(self.lay)
self.setCentralWidget(cw)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.setblocking(0)
self.localAddr = ("localhost", 9001)
self.socket.bind(self.localAddr)
self.socksend = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.remoteAddr = ("localhost", 9000)
self.buffer = []
self.indentation = 0
self.readTimer = QTimer(self)
self.readTimer.timeout.connect(self.readData)
self.console.newLine.connect(self.interpretLine)
self.console.indentationPlus.connect(self.indentPlus)
self.console.indentationMinus.connect(self.indentMinus)
self.readTimer.start(50)
self.console.makePrompt()
def indentPlus(self):
print("indent +")
self.indentation += 1
def indentMinus(self):
print("indent -")
self.indentation -= 1
def interpretLine(self, line):
if line[:3] != ">>>" and line[:3] != "...":
self.console.putData("\n")
self.console.makePrompt()
return
line = line[4:]
if line[:1] == "!":
line = line[1:]
#-- Escape chars ----------------------
print("Escape char!")
if line == "knock":
print("knock, knock, knocking on Liiives door...")
self.console.putData("\n\\0/ - Client says:\t\"Knock knock.. Hi Live! may I come in?\"")
self.socksend.sendto("!knock".encode("utf-8"), self.remoteAddr)
elif line == "clear":
self.socksend.sendto("!clear".encode("utf-8"), self.remoteAddr)
self.clear()
self.console.clear()
elif line == "exit":
print("Bye!!")
self.exitTimer = QTimer(self)
self.console.putData("\nBye!!")
#self.exitTimer.timeout.connect(QCoreApplication.instance.quit)
self.exitTimer.timeout.connect(self.close)
self.exitTimer.start(800)
#QCoreApplication.instance().quit()
else:
self.console.putData("\nUnknown escape sequence!")
self.makePrompt()
self.clear()
return
self.buffer += [line]
#self.console.addToCmdHistory(line)
#-- Editor behaviour ------------------
if line[-1:] == ":":
self.console.putData("\n")
self.indentation += 1
self.console.makeExtendedPrompt(self.indentation)
print(": found")
print("line")
#debug("1");
else:
self.console.putData("\n")
if self.indentation == 0:
self.execute()
self.console.makePrompt()
#debug("2");
else:
#self.indentation = 0
stripped = line.replace(" ", "")
if len(stripped) == 0:
self.indentation = 0
self.execute()
self.console.makePrompt()
#debug("3");
else:
#debug("4");
self.console.makeExtendedPrompt(self.indentation)
def clear(self):
self.indentation = 0;
self.buffer = []
def execute(self):
print("execute")
print(self.indentation)
s = ""
for line in self.buffer:
s += line + "\n"
# check if there is anything
if len(s.replace("\n", "")) == 0:
print("execution aborted")
else:
print(s)
self.socksend.sendto(bytes(s, "utf-8"), self.remoteAddr)
self.socksend.sendto("!execute".encode("utf-8"), self.remoteAddr)
self.clear()
def readData(self):
try:
while 1:
self.data, self.addr = self.socket.recvfrom(65536)
decoded = self.data.decode()
#print(decoded)
if decoded != "" and decoded != "\n":
self.console.putData("\n")
self.console.putData(decoded)
except Exception as e:
pass
