def __init__(self, app=None, direction=VERTICAL):
Overlay.__init__(self, OVERLAY_SPLITTER)
EventHandler.__init__(self, app)
self.direction = direction
self.__enlarged = False
self.__scaleMultiplier = 4.0
self._canScale = False
self.mouseOverScale = 1.0
self.setTransparency(255)
self.z = BOTTOM_Z - 10
self.relPos = 0.5 # relative to the section it splits
self._preCollapsedPos = self.relPos
self.__buffer = int(20 * getGlobalScale())
self._collapsed = False
self.registerForEvent(EVT_DRAG, self.__onDrag)
self.registerForEvent(EVT_CLICK, self.__onClick)
self.registerForEvent(EVT_MOVE, self.__onMove)
self.registerForEvent(EVT_LEFT_WINDOW, self._onLeftWindow)
self.registerForEvent(EVT_ENTERED_WINDOW, self._onEnteredWindow)
if direction == VERTICAL:
self.__image = opj("images", "vertical_divider.png")
else:
self.__image = opj("images", "horizontal_divider.png")
def __init__(self, overlayId, app):
Overlay.__init__(self, OVERLAY_APP, overlayId)
EventHandler.__init__(self)
self.app = app # which app is this overlay tied to
self.bounds.setAll(app.left, app.right, app.top, app.bottom)
self.displayId = app.getDisplayId()
self.aspectRatio = self.bounds.getWidth() / float(self.bounds.getHeight())
self.minAppSize = 300 # min app size in either direction
self.z = self.app.getZvalue()
self.__resetOverlay()
self.capturedCorner = APP
self.lastClickPos = (0,0)
self.lastClickDeviceId = None
self.overCorner = APP
# register for the events that are fired when an app changes
self.registerForEvent(EVT_APP_INFO, self.__onAppChanged)
self.registerForEvent(EVT_Z_CHANGE, self.__onZChanged)
# register for the events that are fired by devices
self.registerForEvent(EVT_MOVE, self.__onOver)
self.registerForEvent(EVT_CLICK, self.__onClick)
self.registerForEvent(EVT_DRAG, self.__onDrag)
self.registerForEvent(EVT_ROTATE, self.__onRotate)
self.registerForEvent(EVT_ZOOM, self.__onZoom)
self.registerForEvent(EVT_ARROW, self.__onArrow)
self.registerForEvent(EVT_LEFT_WINDOW, self.__onLeftWindow)
# register for the events from the special devices
self.registerForEvent(EVT_MOVE_SPECIAL, self.__onSpecialMove)
self.registerForEvent(EVT_ENTERED_WINDOW_SPECIAL, self.__onEnteredWindowSpecial)
self.registerForEvent(EVT_LEFT_WINDOW_SPECIAL, self.__onLeftWindowSpecial)
def __init__(self):
self.eventHandler = EventHandler()
super(UIMainMenu, self).__init__(9, self.eventHandler)
#We tell the button to draw to a dummy screen so it does not appear
self.winScreen.primary_button.screen = pygame.Surface((0, 0))
self.nineByNine = UIMessage(self.screen, self.screen, "9x9", self.FONT,
self.BASELINE_GRID, self.MESSAGE_FONTSIZE,
pygame.color.Color(0, 0, 0,
60), self.WHITESTONE,
0.3, 0.25, self.BUTTON_FONTSIZE,
self.BUTTON_FONT_COLOUR,
self.PASS_BUTTON_COLOUR,
self.PASS_BUTTON_HOVER_COLOUR, "Select",
None, 0.35, 0.05, self.eventHandler)
self.thirteenByThirteen = UIMessage(
self.screen, self.screen, "13x13", self.FONT,
self.BASELINE_GRID, self.MESSAGE_FONTSIZE,
pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25,
self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR,
self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select",
None, 0.35, 0.35, self.eventHandler)
self.nineteenByNineteen = UIMessage(
self.screen, self.screen, "19x19", self.FONT,
self.BASELINE_GRID, self.MESSAGE_FONTSIZE,
pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25,
self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR,
self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select",
None, 0.35, 0.65, self.eventHandler)
def __init__(self, app=None):
Overlay.__init__(self, OVERLAY_BUTTON)
EventHandler.__init__(self, app)
# register for the events that are fired by devices
self.registerForEvent(EVT_CLICK, self._onClick)
self.registerForEvent(EVT_MOVE, self._onMove)
self.registerForEvent(EVT_LEFT_WINDOW, self._onLeftWindow)
self.registerForEvent(EVT_ENTERED_WINDOW, self._onEnteredWindow)
# paths to images drawn for different button states
self.__upImage = "images/default_button_up.png"
self.__downImage = ""
self.__overImage = ""
self.__doPlaySound = True
# button can be a toggle
self._isToggle = False
self.__radioFunc = True
self.__clicked = False
self._manual = False
self._radio = False
# current state of the button
self.__state = UP_STATE
# callbacks you can register
self.__onDown = None
self.__onUp = None
self._lastDevice = None
self.__minTimeBetweenClicks = 0.5 # by default, allow rapid successive clicks
self.__lastUp = 0.0
self.__lastDown = 0.0
def __init__(self, displayId):
EventHandler.__init__(self)
self.displayId = displayId
#self.registerForEvent(EVT_MOVE, self.__onMove)
self.registerForEvent(EVT_DISPLAY_INFO, self.__onDispInfo)
self.registerForEvent(EVT_ENTERED_WINDOW, self.__onEnteredWindow)
self.registerForEvent(EVT_LEFT_WINDOW, self.__onLeftWindow)
self.z = BOTTOM_Z
def __init__(self, app=None, label="", fontSize=NORMAL):
""" If you pass in None for app, the widget will reside on the top layer
above all apps but below pointers.
"""
Overlay.__init__(self, OVERLAY_LABEL)
EventHandler.__init__(self, app)
self.setLabel(label, fontSize)
self.__drawBackground = True
def __init__(self, app):
Overlay.__init__(self, OVERLAY_APP)
EventHandler.__init__(self, app)
# must set size and pos first
self._canScale = False
self.setSize(1.0, 1.0) # same size as the app
self.setPos(0.0, 0.0) # right over the app
self._zOffset = APP_OVERLAY_Z
self._allowSelection = True
# some initial params
self.minAppSize = 250 # min app size in either direction
self.capturedCorner = APP
self.lastClickPos = (0,0)
self.lastClickDeviceId = None
self.overCorner = APP
self.bounds = self.getBounds() # from EventHandler base class
self._clickDownTime = 0.0
self.__startedDrag = False # for accidental touches...
# if less than X seconds has passed between two double clicks,
# maximize to the whole display, otherwise, just within the section
self._lastDoubleClick = 0.0
self.__maximizeThreshold = 1.3 # seconds between two double clicks...
# for closing apps
self.__multiTouchStartTime = -1
self.org = getLayoutOrganization()
# get the filename from appLauncher
if "imageviewer" in app.getName().lower() or \
"mplayer" in app.getName().lower() or \
"stereo3d" in app.getName().lower() or \
"pdf" in app.getName().lower():
# get the config info from the right appLauncher
if app.getLauncherId() != "none":
appLauncher = xmlrpclib.ServerProxy("http://" + app.getLauncherId())
try:
res = appLauncher.getAppConfigInfo( app.getAppId() )
except:
print "\nUnable to connect to appLauncher on", app.getLauncherId(), "so not saving this app: ", app.getName()
else:
print "appLauncher.getAppConfigInfo : ", res
if res != -1:
configName, optionalArgs = res
if "imageviewer" in app.getName().lower():
# filename at the beginning of the command line for images
self.fullpathname = optionalArgs.split()[0].strip('"')
self.filename = os.path.basename( self.fullpathname )
else:
# filename at the end of the command line for movies
self.fullpathname = optionalArgs.split()[-1].strip('"')
self.filename = os.path.basename( self.fullpathname )
if getShowWindowTitleBar():
self.setTooltip(self.filename, LARGER)
def __init__(self, app=None, direction=HORIZONTAL):
""" If you pass in None for app, the widget will reside on the top layer
above all apps but below pointers.
"""
Overlay.__init__(self, OVERLAY_SIZER)
EventHandler.__init__(self, app)
self.__direction = direction
# let the events pass through since we are transparent
self._eventTransparent = True
def __init__(self, size=9):
self.players = [Player('B', 300), Player('W', 300)]
self.currentPlayer = 0
self.board = Board(size)
self.territories = Board(size)
self.previousBoard = self.board.getMatrix()
self.currentBoard = self.board.getMatrix()
self.cursor = Cursor(self.board)
self.attemptedPlace = False
self.handler = EventHandler()
self.UI = UIMatch(size, self.handler)
self.newGame = False
self.exit = False
def __init__(self, width, height):
# initialize variables
self.__interfaceWidth = width
self.__interfaceHeight = height
self.__header_bg = 'silver'
self.__ListBoxLabel_bg = 'gainsboro'
# Create Interface Window Template
self.root = Tk()
self.root.title("My Analytic Solver")
self.root.geometry('{}x{}'.format(
self.__interfaceWidth,
self.__interfaceHeight)) # set size to fit iphone size
self.root.resizable(0, 0) # this prevents from resizing the window
# Create EventHandler object
self.eh = EventHandler(self)
def __init__(self):
pygame.init()
pygame.display.set_caption('enemy invasion')
self.main_clock = pygame.time.Clock()
self.background_color = ss.screen_background_color
self.screen = pygame.display.set_mode(ss.screen_size)
self.ship: Ship = Ship(self.screen)
self.enemyFleet = EnemyFleet(self.screen, self.ship)
self.eventHandler = EventHandler()
self.add_events()
def main():
model = init_model(
os.path.dirname(os.path.abspath(__file__)),
getpass.getuser(),
os.uname().nodename
)
def resize(signum, frame):
Render(model)
# Re-renders Terminal in case of SIGWINCH(resize) event
signal.signal(signal.SIGWINCH, resize)
while not model.exit:
try:
Render(model)
try:
model = EventHandler(model, blesses.get_key())
except KeyboardInterrupt:
model = replace(model, exit=1)
except Exception as e:
with open("crash.json", "w+") as f:
f.write(json.dumps(asdict(model),indent=4))
raise e
def setRelPos(self, rp):
self.relPos = rp
sec = self.getUserData()
# now calculate the absolute x,y in SAGE coords based on the section-relative position
if self.direction == HORIZONTAL:
x = sec.getX()
y = int(sec.bounds.bottom + sec.bounds.getHeight()*rp)
else:
y = sec.getY()
x = int(sec.bounds.left + sec.bounds.getWidth()*rp)
newSpace = abs(x-self.getX()), abs(y-self.getY())
EventHandler.setPos(self, x, y)
return newSpace
def main():
# watch manager
wm = pyinotify.WatchManager()
# watched events
mask = \
pyinotify.IN_MODIFY | \
pyinotify.IN_ACCESS | \
pyinotify.IN_CLOSE_WRITE | \
pyinotify.IN_CLOSE_NOWRITE
# Exclude patterns from file
excl_file = os.path.join(os.getcwd(), 'exclude.lst')
excl = pyinotify.ExcludeFilter(excl_file)
watch_path_list = [
# '/var/log/mosquitto/mosquitto.log',
'/var/log/syslog',
# '/var/log/postgresql/postgresql-9.6-main.log'
]
# Add watches
wdd = wm.add_watch(watch_path_list, mask, rec=True, exclude_filter=excl)
# event handler
eh = EventHandler()
# notifier
notifier = pyinotify.ThreadedNotifier(wm, eh)
notifier.start()
def __init__(self, playerNames):
self.logicHandler = LogicHandler()
self.eventHandler = EventHandler()
self.players = []
self.turns = 0
self.jsonResponse = {}
for playerName in playerNames:
objective = self.logicHandler.get_random_objective()
self.players.append(Player(playerName, objective))
def __init__(self, app=None):
""" If you pass in None for app, the widget will reside on the top layer
above all apps but below pointers.
"""
Overlay.__init__(self, OVERLAY_PANEL)
EventHandler.__init__(self, app)
self.registerForEvent(EVT_DRAG, self.__onDrag)
self.registerForEvent(EVT_CLICK, self._onClick)
self._allowDrag = False # ONLY USE WITH ABSOLUTE POSITION!!! (wont work when aligned)
self.__fitInWidth = True
self.__fitInHeight = True
self.__borderWidth = 0
self._zOffset -= 0.01 # just below the other widgets
self.px = self.py = 0
def __init__(self, x=0, y=0):
Overlay.__init__(self, OVERLAY_POINTER)
EventHandler.__init__(self)
self.setSize(50,75)
self.setPos(x,y)
self.setDrawOrder(POST_DRAW)
self.state = RESET
self.lastOrientation = 0
self.inApp = False
self.__savedState = [self.state, self.lastOrientation, self.inApp]
# some devices only produce one analog event so set it here if so
# (e.g. a zoom-only puck)
# this is used when the device enters an application in order to show
# the correct pointer shape describing what the device can do
self.onlyAnalogEvent = None
self._eventTransparent = True # so that we dont receive our own clicks...
self.__image = ""
def main() -> None:
"""The main function loads all the required variables, instantiates the tcod console, tcod context and the game engine.
It then continuously executes the game loop by calling the engine"""
title = "Roachlife"
console_width = 80
console_height = 50
map_width = 80
map_height = 45
max_room_size = 10
min_room_size = 5
max_rooms = 20
max_enemies_per_room = 2
tileset = tcod.tileset.load_tilesheet("dejavu10x10_gs_tc.png", 32, 8,
tcod.tileset.CHARMAP_TCOD)
### Instantiating the objects to use for testing ###
player = copy.deepcopy(definedEntities.player)
### Instantiating the objects to use for testing ###
game_map = generate_game_map(map_width=map_width,
map_height=map_height,
max_rooms=max_rooms,
min_room_size=min_room_size,
max_room_size=max_room_size,
max_enemies_per_room=max_enemies_per_room,
player=player)
event_handler = EventHandler(
) # We initialize the eventHandler object to be inputted into the engine.
engine = Engine(
event_handler=event_handler, game_map=game_map, player=player
) # We initialize the engine with the EventHandler object and a player object representing the player character.
# The tcod context
with tcod.context.new_terminal(console_width,
console_height,
tileset=tileset,
title=title,
vsync=True) as context:
console = tcod.Console(console_width, console_height, order="F")
while True:
engine.render(console, context)
events = tcod.event.wait()
engine.handle_events(events)
def start(self):
# Controls Physics and other engine related Things
# Init Input
self.inputHandler = InputHandler(self)
self.inputHandler.start()
# Event HAndler
self.eventHandler = EventHandler(self)
self.eventHandler.start()
# Init Camera
self.cameraHandler = CameraHandler(self, "TPS")
# Start Engine Loop
taskMgr.add(self.engineLoop, "Engine_Loop")
class GraphicsInterface:
def __init__(self, width, height):
# initialize variables
self.__interfaceWidth = width
self.__interfaceHeight = height
self.__header_bg = 'silver'
self.__ListBoxLabel_bg = 'gainsboro'
# Create Interface Window Template
self.root = Tk()
self.root.title("My Analytic Solver")
self.root.geometry('{}x{}'.format(
self.__interfaceWidth,
self.__interfaceHeight)) # set size to fit iphone size
self.root.resizable(0, 0) # this prevents from resizing the window
# Create EventHandler object
self.eh = EventHandler(self)
def createMenu(self):
# Creating a root menu to insert all the sub menus
root_menu = Menu(self.root)
self.root.config(menu=root_menu)
# Creating sub menus in the root menu
file_menu = Menu(
root_menu) # it intializes a new sub menu in the root menu
root_menu.add_cascade(
label="File",
menu=file_menu) # it creates the name of the sub menu
file_menu.add_command(label="Open .csv file",
command=self.eh.askOpenFileName)
file_menu.add_separator(
) # it adds a line after the 'Open files' option
file_menu.add_command(label="Exit", command=self.root.destroy)
# creting another sub menu
predict_menu = Menu(root_menu)
root_menu.add_cascade(label="Predict", menu=predict_menu)
predict_menu.add_command(label="Linear Regression",
command=self.eh.linearRegression)
predict_menu.add_command(label="Neural Network",
command=self.eh.function)
def createTemplate(self):
# create all of the main containers
header_frame = Frame(self.root,
bg=self.__header_bg,
width=self.__interfaceWidth,
height=40,
pady=3)
content_frame = Frame(self.root,
width=self.__interfaceWidth,
height=60,
pady=3)
footer_frame = Frame(self.root,
width=self.__interfaceWidth,
height=40,
pady=3)
footer_frame2 = Frame(self.root,
width=self.__interfaceWidth,
height=40,
pady=3)
footer_frame3 = Frame(self.root,
width=self.__interfaceWidth,
height=40,
pady=3)
# layout all of the main containers
self.root.grid_rowconfigure(1, weight=1)
self.root.grid_columnconfigure(0, weight=1)
header_frame.grid(row=0, sticky="ew")
content_frame.grid(row=1, sticky="nsew")
footer_frame.grid(row=3, sticky="ew")
footer_frame2.grid(row=4, sticky="ew")
footer_frame3.grid(row=5, sticky="ew")
# create the content widgets
content_frame.grid_rowconfigure(0, weight=1)
content_frame.grid_columnconfigure(0, weight=1)
self.cnt_left_frame = Frame(content_frame,
width=int(self.__interfaceWidth * 0.4),
padx=2,
pady=2)
self.cnt_mid_frame = Frame(content_frame,
width=int(self.__interfaceWidth * 0.2),
padx=2,
pady=2)
self.cnt_right_frame = Frame(content_frame,
width=int(self.__interfaceWidth * 0.4),
padx=2,
pady=2)
self.cnt_left_frame.grid(row=0, column=0, sticky="nsew")
self.cnt_mid_frame.grid(row=0, column=1, sticky="nsew")
self.cnt_right_frame.grid(row=0, column=2, sticky="nsew")
self.cnt_left_frame.grid_propagate(False)
self.cnt_mid_frame.grid_propagate(False)
self.cnt_right_frame.grid_propagate(False)
# Create Labels in Header
intro_label = Label(header_frame,
text="Welcome to My Analytic Solver!",
bg=self.__header_bg)
intro_label.grid(row=0, sticky='nw')
intro_label2 = Label(
header_frame,
text="Please open CSV file, then choose method to run",
bg=self.__header_bg)
intro_label2.grid(row=1, sticky='nw')
# create the widgets for the footer3 frame
file_label = Label(footer_frame3, text='File: ')
self.filename_label = Label(footer_frame3, text=None, wraplength=300)
running_label = Label(footer_frame3, text='Running: ')
self.runningname_label = Label(footer_frame3, text=None)
# layout the widgets in the footer3 frame
file_label.grid(row=0, column=0, sticky='nw')
self.filename_label.grid(row=0, column=1, sticky='nw')
running_label.grid(row=1, column=0, sticky='nw')
self.runningname_label.grid(row=1, column=1, sticky='nw')
def promptAlertForCSV(self):
mb.showinfo("Alert Message", "Please select a .CSV file")
self.eh.askOpenFileName()
def setFileName(self, fileName):
# take .csv file only
if (fileName):
if fileName[-4:] == '.csv':
self.filename_label.config(
text=fileName) # assign .csv file into fileName Label
else:
# Wrong file, redo
self.promptAlertForCSV()
else:
pass # Cancel selected
def getFileName(self):
return self.filename_label['text']
def setRunningName(self, running):
self.runningname_label.config(text=running)
def getRunningName(self):
return self.runningname_label['text']
def checkRequirements(self):
# Check to make sure .CSV is selected
# currently, just need .csv filename else returns default None=False
return self.getFileName()
def createLinearRegression(self, variables_list):
# Weight template
self.cnt_left_frame.grid_columnconfigure(0, weight=1)
self.cnt_mid_frame.grid_columnconfigure(0, weight=1)
self.cnt_right_frame.grid_columnconfigure(0, weight=1)
self.cnt_left_frame.grid_rowconfigure(1, weight=1)
self.cnt_mid_frame.grid_rowconfigure(0, weight=7)
self.cnt_mid_frame.grid_rowconfigure(3, weight=14)
self.cnt_mid_frame.grid_rowconfigure(6, weight=9)
self.cnt_right_frame.grid_rowconfigure(1, weight=1)
self.cnt_right_frame.grid_rowconfigure(3, weight=1)
# Create Variables List
__variable_label = Label(self.cnt_left_frame,
text="Variables",
bg=self.__ListBoxLabel_bg)
__variable_label.grid(row=0, sticky='nwe')
self.variables_lb = Listbox(self.cnt_left_frame, selectmode='extended')
for variable in variables_list:
self.variables_lb.insert('end', variable)
self.variables_lb.grid(row=1, sticky='nwe')
# Create Add Selected Button
self.addSelected_btn = Button(self.cnt_mid_frame,
text=">>>",
command=self.eh.addSelectedVariables)
self.addSelected_btn.grid(row=1)
# Create Remove Selected Button
self.removeSelected_btn = Button(
self.cnt_mid_frame,
text="<<<",
command=self.eh.removeSelectedVariables)
self.removeSelected_btn.grid(row=2)
# Create Selected Variables List
__selected_label = Label(self.cnt_right_frame,
text="Selected",
bg=self.__ListBoxLabel_bg)
__selected_label.grid(row=0, sticky='nwe')
self.selectedVariables_lb = Listbox(self.cnt_right_frame,
selectmode='extended')
self.selectedVariables_lb.grid(row=1, sticky='nwe')
# Create Add Categorical Button
self.addCategorical_btn = Button(
self.cnt_mid_frame,
text=">>>",
command=self.eh.addCategoricalVariables)
self.addCategorical_btn.grid(row=4)
# Create Remove Categorical Button
self.removeCategorical_btn = Button(
self.cnt_mid_frame,
text="<<<",
command=self.eh.removeCategoricalVariables)
self.removeCategorical_btn.grid(row=5)
# Create Categorical Variables List
__categorical_label = Label(self.cnt_right_frame,
text="Categorical",
bg=self.__ListBoxLabel_bg)
__categorical_label.grid(row=2, sticky='nwe')
self.categoricalVariables_lb = Listbox(self.cnt_right_frame,
selectmode='extended')
self.categoricalVariables_lb.grid(row=3, sticky='nwe')
# Create Add Output Button
self.addOutput_btn = Button(
self.cnt_mid_frame,
text=">>>",
command=lambda: self.eh.addOutputVariables(True))
self.addOutput_btn.grid(row=7)
# Create Remove Output Button
self.removeOutput_btn = Button(
self.cnt_mid_frame,
text="<<<",
command=lambda: self.eh.removeOutputVariables(True))
self.removeOutput_btn.grid(row=8)
# Create Output Entry
__output_label = Label(self.cnt_right_frame,
text="Output",
bg=self.__ListBoxLabel_bg)
__output_label.grid(row=4, sticky='nwe')
self.outputVariables_lb = Listbox(self.cnt_right_frame, height=10)
self.outputVariables_lb.config(height=0)
self.outputVariables_lb.grid(row=5, sticky='nwe')
def getVariablesLB(self):
return self.variables_lb
def appendVariablesLB(self, variable):
self.variables_lb.insert('end', variable)
def refreshVariablesLB(self, variables_list):
# Clear List Box
self.variables_lb.delete(0, 'end')
# Add variables_list
for variable in variables_list:
self.variables_lb.insert('end', variable)
def getSelectedVariablesLB(self):
return self.selectedVariables_lb
def appendSelectedVariablesLB(self, selected):
self.selectedVariables_lb.insert('end', selected)
def refreshSelectedVariablesLB(self, selected_list):
# Clear List Box
self.selectedVariables_lb.delete(0, 'end')
# Add selected_list
for selected in selected_list:
self.selectedVariables_lb.insert('end', selected)
def getCategoricalVariablesLB(self):
return self.categoricalVariables_lb
def appendCategoricalVariablesLB(self, categorical):
self.categoricalVariables_lb.insert('end', categorical)
def refreshCategoricalVariablesLB(self, categorical_list):
# Clear List Box
self.categoricalVariables_lb.delete(0, 'end')
# Add selected_list
for categorical in categorical_list:
self.categoricalVariables_lb.insert('end', categorical)
def getOutputVariablesLB(self):
return self.outputVariables_lb
def appendOutputVariablesLB(self, output):
self.outputVariables_lb.insert('end', output)
def refreshOutputVariablesLB(self, output_list):
# Clear List Box
self.outputVariables_lb.delete(0, 'end')
# Add selected_list
for output in output_list:
self.outputVariables_lb.insert('end', output)
def close(self):
self.root.destroy()
def run(self):
# Create Menu + Template
self.createMenu()
self.createTemplate()
# Run listening for events
self.root.mainloop()
import psycopg2
from eventHandler import EventHandler
import sys
import json
handler = EventHandler()
for line in sys.stdin:
try:
if line == '' or line == '\n':
break
inp = json.loads(line)
handler.Event(inp)
except (Exception) as error:
print({"status": "ERROR", 'debug': error})
class UIMainMenu(UIMatch):
def __init__(self):
self.eventHandler = EventHandler()
super(UIMainMenu, self).__init__(9, self.eventHandler)
#We tell the button to draw to a dummy screen so it does not appear
self.winScreen.primary_button.screen = pygame.Surface((0, 0))
self.nineByNine = UIMessage(self.screen, self.screen, "9x9", self.FONT,
self.BASELINE_GRID, self.MESSAGE_FONTSIZE,
pygame.color.Color(0, 0, 0,
60), self.WHITESTONE,
0.3, 0.25, self.BUTTON_FONTSIZE,
self.BUTTON_FONT_COLOUR,
self.PASS_BUTTON_COLOUR,
self.PASS_BUTTON_HOVER_COLOUR, "Select",
None, 0.35, 0.05, self.eventHandler)
self.thirteenByThirteen = UIMessage(
self.screen, self.screen, "13x13", self.FONT,
self.BASELINE_GRID, self.MESSAGE_FONTSIZE,
pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25,
self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR,
self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select",
None, 0.35, 0.35, self.eventHandler)
self.nineteenByNineteen = UIMessage(
self.screen, self.screen, "19x19", self.FONT,
self.BASELINE_GRID, self.MESSAGE_FONTSIZE,
pygame.color.Color(0, 0, 0, 60), self.WHITESTONE, 0.3, 0.25,
self.BUTTON_FONTSIZE, self.BUTTON_FONT_COLOUR,
self.PASS_BUTTON_COLOUR, self.PASS_BUTTON_HOVER_COLOUR, "Select",
None, 0.35, 0.65, self.eventHandler)
def draw(self):
self.update([[]], 0, 300, 300, 0, 0, (0, 0))
self.nineByNine.update()
self.thirteenByThirteen.update()
self.nineteenByNineteen.update()
pygame.display.update()
def mainLoop(self):
self.draw()
self.exit = False
while self.exit == False:
self.lookForInput()
def lookForInput(self):
self.eventHandler.update()
if self.eventHandler.hasQuit():
self.exit = True
self.quit()
if self.nineByNine.primary_button.wasPressed():
self.quit()
self.match = Match(9)
self.match.matchLoop()
self.exit = True
elif self.thirteenByThirteen.primary_button.wasPressed():
self.quit()
self.match = Match(13)
self.match.matchLoop()
self.exit = True
elif self.nineteenByNineteen.primary_button.wasPressed():
self.quit()
self.match = Match(19)
self.match.matchLoop()
self.exit = True
class Engine(DirectObject):
"""The engine class sets up the holders for game GameObjects
and starts the parser that runs through the [name].egg
"""
def __init__(self, _main):
print "Engine - init >>>"
log.info("Engine - init >>>")
# Main ref
self.main = _main
self.settings = Settings()
self.graphicMgr = GraphicManager(self.settings)
self.audioMgr = AudioManager()
self.lng = Language(self.settings)
self.lng.setup(self.settings)
### Bools ###
# Gets set if we have a player character to work with.
self.hasPlayer = False
### Bools END ###
### Setup Engine Holders ###
self.__resetObjects()
### Engine Holders END ###
# Setup Bullet Physics
#? We could save this somewhere else i guess?
self.bulletWorld = BulletWorld()
self.bulletWorld.setGravity(
Vec3(self.settings.gravity_x,
self.settings.gravity_y,
self.settings.gravity_z))
# Init Factory
self.factory = Factory(self)
# Debug node
self.debugNP = None
def start(self):
# Controls Physics and other engine related Things
# Init Input
self.inputHandler = InputHandler(self)
self.inputHandler.start()
# Event HAndler
self.eventHandler = EventHandler(self)
self.eventHandler.start()
# Init Camera
self.cameraHandler = CameraHandler(self, "TPS")
# Start Engine Loop
taskMgr.add(self.engineLoop, "Engine_Loop")
def stop(self):
taskMgr.remove("Engine_Loop")
self.unloadLevel()
self.__resetObjects()
self.inputHandler.stop()
del(self.inputHandler)
self.eventHandler.stop()
del(self.eventHandler)
self.cameraHandler.stop()
del(self.cameraHandler)
render.clearLight()
base.messenger.send("Quit")
def unloadLevel(self):
self.__removeObjects()
def loadLevel(self, levelName):
# Parse the .egg file
self.factory.parseLevelFile(levelName)
def __resetObjects(self):
# Create Game ObjectType Holders these hold the instances
self.GameObjects = {}
self.GameObjects["player"] = None
self.GameObjects["level"] = {}
self.GameObjects["object"] = {}
self.GameObjects["light"] = {}
self.GameObjects["sensor"] = {}
# Create Render Object Holders for sorting stuff in sceneG.
# nodepaths
self.RenderObjects = {}
self.BulletObjects = {}
# none visual
self.BulletObjects["main"] = render.attachNewNode("Bullet_main")
self.BulletObjects["player"] = self.BulletObjects["main"].attachNewNode("Bullet_player")
self.BulletObjects["level"] = self.BulletObjects["main"].attachNewNode("Bullet_level")
self.BulletObjects["object"] = self.BulletObjects["main"].attachNewNode("Bullet_object")
self.BulletObjects["sensor"] = self.BulletObjects["main"].attachNewNode("Bullet_sensor")
# Visuals
self.RenderObjects["player"] = render.attachNewNode("Render_player")
self.RenderObjects["level"] = render.attachNewNode("Render_level")
self.RenderObjects["object"] = render.attachNewNode("Render_object")
self.RenderObjects["light"] = render.attachNewNode("Render_light")
def __removeObjects(self):
for name, objects in self.GameObjects.items():
if name == "player":
objects.remove()
continue
for name, obj in objects.items():
obj.remove()
def showBulletDebug(self):
"""Show bullet Debug"""
# Bullet DEBUG
debugNode = BulletDebugNode('Debug')
debugNode.showWireframe(True)
debugNode.showConstraints(False)
debugNode.showBoundingBoxes(False)
debugNode.showNormals(False)
self.debugNP = render.attachNewNode(debugNode)
self.debugNP.show()
self.bulletWorld.setDebugNode(self.debugNP.node())
def hideBulletDebug(self):
"""Hide the debug stuff"""
self.debugNP.hide()
def engineLoop(self, task):
"""Handle Engine Related Tasks"""
dt = globalClock.getDt()
# Handle Physics
self.bulletWorld.doPhysics(dt)
if self.hasPlayer:
self.inputHandler.update(dt)
self.cameraHandler.update(dt)
self.GameObjects["player"].setBasicMovement(dt)
self.GameObjects["player"].startGhostContactTester(dt)
self.GameObjects["player"].startContactTester(dt)
return task.cont
def main(self):
# init game and graphic
pygame.init()
pygame.display.init()
# init menu and event taken
self.menu = MenuHandler()
handler = EventHandler(self.menu)
while True:
# handle all the user inputs...
for event in pygame.event.get():
if event.type == QUIT:
raise SystemExit
if event.type == MOUSEBUTTONUP:
if handler.mode == self.MENU:
handler.processMenuClick(pygame.mouse.get_pos())
# handle back to menu event
elif handler.game.back['rect'].collidepoint(pygame.mouse.get_pos()):
self.menu = MenuHandler()
handler = EventHandler(self.menu)
elif handler.game.done:
if handler.game.again['rect'].collidepoint(pygame.mouse.get_pos()):
handler.game.done = False
handler.game=Game(handler.mode)
elif handler.mode ==self.AUTO1:
if handler.game.dialog['rect'].collidepoint(pygame.mouse.get_pos()):
handler.moreInput = True
handler.trials = True
else:
pass
elif handler.mode ==self.AUTO2:
if handler.game.dialog['rect'].collidepoint(pygame.mouse.get_pos()):
handler.moreInput = True
handler.trials = True
elif handler.game.dialog2['rect'].collidepoint(pygame.mouse.get_pos()):
handler.moreInput = True
handler.trials = False
else:
pass
if event.type == KEYDOWN and handler.moreInput:
if handler.mode == self.AUTO1 or handler.mode ==self.AUTO2:
if handler.trials == True:
handler.processKeyEvent(event.key,0)
elif handler.trials == False:
handler.processKeyEvent(event.key,1)
else:
pass
class TCPClient(object):
def __init__(self):
from messages import Messages
messages = Messages()
self.s = socket(AF_INET, SOCK_STREAM)
self.s.connect((messages.getValue("socket", "host"),
int(messages.getValue("socket", "port"))))
def __del__(self):
self.s.close()
'''
result = TCPClient().send(([DBUtils.method_name], 元祖类型作为sql参数))
'''
def send(self, params, callback=None):
self.s.send(dumps(params))
result = loads(self.s.recv(1024))
if callback:
# callback(result)
t = Thread(target=callback, args=(result, ))
t.start()
return result
if __name__ == '__main__':
from eventHandler import EventHandler
eventHandler = EventHandler()
eventHandler.openMainWindow()
from pathlib import Path
from time import sleep
from watchdog.observers import Observer
from eventHandler import EventHandler
watch_path = Path.home() / 'Desktop'
organised_path = Path.home() / 'Desktop/Organiser'
event_handler = EventHandler(watch_path=watch_path, organised_path=organised_path)
observer = Observer()
observer.schedule(event_handler, f'{watch_path}', recursive=True)
observer.start()
try:
while True:
sleep(60)
except KeyboardInterrupt:
observer.stop()
observer.join()
def _refresh(self):
EventHandler._refresh(self)
self.__calculateRelPos()
def setPos(self, x, y):
EventHandler.setPos(self, x, y)
def _destroy(self):
#self.getUserData().slideHide()
EventHandler._destroy(self)
import pygame as pg
from player import Player
from eventHandler import EventHandler
menu_running = True
game_running = False
width = 1280
height = 720
FPS = 60
pg.init()
pg.display.set_caption("Name of game")
sc = pg.display.set_mode((width, height))
eventHandle = EventHandler(game_running, menu_running)
clock = pg.time.Clock()
pg.display.update()
player = Player(20, 20, pg)
pg.mixer.init()
# light shade of the button
color_light = (170, 170, 170)
# dark shade of the button
color_dark = (100, 100, 100)
# defining a font
smallfont = pg.font.SysFont('Corbel', 35)
# this font
text = smallfont.render('start game', True, (255, 255, 255))
while True:
while eventHandle.menu:
clock.tick(FPS)
mouse = pg.mouse.get_pos()
eventHandle.setInputs(events=pg.event.get(), pg=pg, mouse=mouse)
class Game(object):
def __init__(self, playerNames):
self.logicHandler = LogicHandler()
self.eventHandler = EventHandler()
self.players = []
self.turns = 0
self.jsonResponse = {}
for playerName in playerNames:
objective = self.logicHandler.get_random_objective()
self.players.append(Player(playerName, objective))
def handleAction(self, playerName, action, options):
if self.getCurrentTurnPlayerName() != playerName:
print "Not your turn! Player's " + str(self.getTurns()/2) + " turn."
return False
self.affectedPlayers = []
player = self.getPlayerWithName(playerName)
if player == None:
print "Cannot find player!"
return False
self.jsonResponse = None
if action is Action.TradeRequest:
print "trade offer"
#options contains targetPlayerNames, resourceOffer, resourceRequest
targetPlayerNames = options["targetPlayerNames"]
resourcesOffer = options["offer"]
resourcesRequest = options["want"]
if not targetPlayerNames or not resourcesOffer or not resourcesRequest:
return False
targetPlayers = []
for name in targetPlayerNames:
targetPlayer = self.getPlayerWithName(name)
targetPlayers.append(targetPlayer)
if self.logicHandler.ingredient_suffice_to_trade(player, resourcesOffer):
self.currentTrade = Trade(player, resourcesOffer, resourcesRequest, targetPlayers)
self.affectedPlayers.append(player)
for playerName in targetPlayerNames:
targetPlayer = self.getPlayerWithName(playerName)
self.affectedPlayers.append(targetPlayer)
makeTradeTemplateJson(self.currentTrade)
return True
else:
return False
if action is Action.TradeAccept:
print "Trade accept"
#options contains tradeId
tradeId = options["tradeId"]
if not self.isTradeValidWithIdAndName(tradeId, player.get_name()):
return False
if self.logicHandler.accept_trade(player, self.currentTrade):
self.currentTrade.set_player_responded(player.get_name())
self.affectedPlayers.append(player) #player who accept the trade
self.affectedPlayers.append(self.currentTrade.get_initiator())
self.makeUpdateTemplateJson()
return True
else:
return False
elif action is Action.TradeDeny:
print "trade deny"
#options contains tradeId
tradeId = options["tradeId"]
if not self.isTradeValidWithIdAndName(tradeId, player.get_name()):
return False
self.currentTrade.set_player_responded(player.get_name())
return True
elif action is Action.TradeWithBank:
print "trade with bank"
#options contains resourcesOffer, resourcesRequest
bankMultiplier = self.eventHandler.getBankMultiplier()
if self.logicHandler.trade_with_bank(player, options["offer"], options["want"], bankMultiplier):
self.affectedPlayers.append(player)
self.makeUpdateTemplateJson()
return True
else:
return False
elif action is Action.Build or action is Action.UpgradeResourceGenerator:
print "Build or upgrade resouce generator"
#options contains generatorName
if self.logicHandler.build(player, options["target"]):
self.affectedPlayers.append(player)
self.makeUpdateTemplateJson()
return True
else:
return False
elif action is Action.Gather:
print "gather"
multipliers = self.eventHandler.getGeneratorMultipliers()
if self.logicHandler.gather(player, multipliers):
self.affectedPlayers.append(player)
self.makeUpdateTemplateJson()
return True
else:
return False
elif action is Action.Destroy:
#options contains targetPlayerName , buildingName
print "destroy"
targetPlayer = self.getPlayerWithName(options["to"])
if self.logicHandler.destroy(player, targetPlayer, options["target"]):
self.affectedPlayers.append(player)
self.affectedPlayers.append(targetPlayer)
self.makeUpdateTemplateJson()
return True
else:
return False
elif action is Action.UpgradeResource:
print "upgrade resource"
#options contains resourceType
if self.logicHandler.upgrade_resource(player, options["target"]):
self.affectedPlayers.append(player)
self.makeUpdateTemplateJson()
return True
else:
return False
else:
print("error action")
return False
def isTradeValidWithIdAndName(self, tradeId, playerName):
if not tradeId or tradeId != self.currentTrade.get_id() or \
playerName not in self.currentTrade.get_target_players_name():
return False
if self.currentTrade.get_is_trade_over():
print("trade is over")
return False
return True
def updateEventAndGetUpcomingEvents(self):
self.eventHandler.randomUpcomingEvent()
currentEvents = self.eventHandler.getUpcomingEvents()
def getPlayerWithName(self, name):
for player in self.players:
if player.get_name() == name:
return player
print "player not found"
return None
def playerLeft(self, player_name):
for player in self.players:
if (player_name == player.get_name()):
self.players.remove(player)
break;
def getAffectedPlayersSummaries(self):
affectedPlayerSummaries = {}
for player in self.affectedPlayers:
playerSummary = {}
resources = player.get_resources()
for res, count in resources.items():
playerSummary[res.name] = count
generator = player.get_generators()
for gen, count in generator.items():
playerSummary[gen.name] = count
affectedPlayerSummaries[player.get_name()] = playerSummary
return affectedPlayerSummaries
def getAllPlayersSummaries(self):
allPlayerSummaries = {}
for player in self.players:
playerSummary = {}
resources = player.get_resources()
for res, count in resources.items():
playerSummary[res.name] = count
generator = player.get_generators()
for gen, count in generator.items():
playerSummary[gen.name] = count
allPlayerSummaries[player.get_name()] = playerSummary
return allPlayerSummaries
def getGeneratorsAndBankMultipliers(self):
multipliers = {}
for key, mutliplier in self.eventHandler.getGeneratorMultipliers.items():
mutliplier[key.name] = multipliers
multipliers["bank"] = self.eventHandler.getBankMultiplier()
return multipliers
def getTradeId(self):
return self.currentTrade.get_id()
def getIsTradeOver(self):
return self.currentTrade.get_is_trade_over()
def getTurns(self):
return self.turns
def increaseTurns(self):
self.turns += 1
def setTurns(self, turns):
self.turns = turns
def getCurrentTurnPlayerName(self):
return self.players[(self.getTurns()/2)].get_name()
def makeUpdateTemplateJson(self):
json = {}
json['action'] = "Update"
json['update_res'] = self.getAffectedPlayersSummaries()
self.jsonResponse = json
def makeTradeTemplateJson(self, trade):
json = {}
json['action'] = "TradeRequest"
json['from'] = trade.get_initiator()
json['to'] = trade.get_target_players_name()
json['want'] = trade.get_resources_request()
json['offer'] = trade.get_resources_offer()
json['tid'] = trade.get_id()
self.jsonResponse = json
def getJsonResponse(self):
return self.jsonResponse
class EnemyInvasion:
def __init__(self):
pygame.init()
pygame.display.set_caption('enemy invasion')
self.main_clock = pygame.time.Clock()
self.background_color = ss.screen_background_color
self.screen = pygame.display.set_mode(ss.screen_size)
self.ship: Ship = Ship(self.screen)
self.enemyFleet = EnemyFleet(self.screen, self.ship)
self.eventHandler = EventHandler()
self.add_events()
def add_events(self):
self.eventHandler.add_event(pygame.QUIT, lambda event: sys.exit(0))
move = {
pygame.K_q: sys.exit,
pygame.K_LEFT: self.ship.move_left,
pygame.K_RIGHT: self.ship.move_right,
pygame.K_SPACE: self.ship.shot
}
self.eventHandler.add_event(
pygame.KEYDOWN, lambda event: move.get(event.key, lambda: None)())
stop_move = {
pygame.K_LEFT: self.ship.stop_move_left,
pygame.K_RIGHT: self.ship.stop_move_right
}
self.eventHandler.add_event(
pygame.KEYUP, lambda event: stop_move.get(event.key, lambda: None)
())
def check_collision(self):
# #pygame.sprite.groupcollide(self.ship.bullets_group, self.enemyFleet, lambda i: i.set_ready(), True)
for bullet, enemy in pygame.sprite.groupcollide(
self.ship.bullets_group, self.enemyFleet, False,
False).items():
# only first enemy has been shot will die.
enemy[0].die()
bullet.set_ready()
def update_screen(self):
# redraw the screen.
self.screen.fill(self.background_color)
# draw bullets.
self.ship.draw_bullets()
self.ship.bullets_group.update()
# draw ship in screen.
self.ship.draw()
# #self.enemyFleet.draw(self.screen)
self.enemyFleet.draw_enemies()
self.enemyFleet.update()
self.check_collision()
self.enemyFleet.schedule()
# make the most recently drawn screen visible.
pygame.display.flip()
def start(self):
while True:
self.eventHandler.check_events(pygame.event.get())
self.update_screen()
# control the game speed by 40 iteration per second.
self.main_clock.tick(170)
class Match:
def __init__(self, size=9):
self.players = [Player('B', 300), Player('W', 300)]
self.currentPlayer = 0
self.board = Board(size)
self.territories = Board(size)
self.previousBoard = self.board.getMatrix()
self.currentBoard = self.board.getMatrix()
self.cursor = Cursor(self.board)
self.attemptedPlace = False
self.handler = EventHandler()
self.UI = UIMatch(size, self.handler)
self.newGame = False
self.exit = False
'''
Evaulates one turn, the return value indictates if the match should end
'''
def playTurn(self):
stonePlaced = False
self.players[self.currentPlayer].passed = False
if self.board.noPlayableMoves(self.players[self.currentPlayer].colour):
print("No possible moves, passing...")
self.players[self.currentPlayer].passed = True
while (not stonePlaced):
if self.end == True:
break
if self.players[self.currentPlayer].time <= 0:
self.players[self.currentPlayer].passed = True
self.attemptedPlace = False
self.lookForInput()
self.UI.update(self.currentBoard, self.currentPlayer,
self.players[0].time, self.players[1].time,
self.players[0].prisoners,
self.players[1].prisoners, self.cursor.coordinates)
if self.players[self.currentPlayer].passed == True:
break
if self.players[self.currentPlayer].resigned == True:
break
if self.attemptedPlace == True:
if self.players[self.currentPlayer].placeStone(
self.board, self.cursor.coordinates,
self.previousBoard) == True:
break
self.currentPlayer = (self.currentPlayer + 1) % len(self.players)
self.previousBoard = self.currentBoard
self.currentBoard = self.board.getMatrix()
'''
The main loop of the match
'''
def matchLoop(self):
self.UI.update(self.currentBoard, self.currentPlayer,
self.players[0].time, self.players[1].time,
self.players[0].prisoners, self.players[1].prisoners,
self.cursor.coordinates)
self.end = False
lastTurnPassed = False
while (not self.end):
self.playTurn()
if self.players[0].passed == True and\
self.players[1].passed ==True:
blackScore = self.findScore(self.players[0])
whiteScore = self.findScore(self.players[1])
if whiteScore == blackScore:
text = "Scores tied at {}".format(whiteScore)
self.UI.drawEnd(text)
self.end = True
if whiteScore > blackScore:
text = "White beats black with {} to {}.".format(
whiteScore, blackScore)
self.UI.drawEnd(text)
if whiteScore < blackScore:
text = "Black beats white with {} to {}.".format(
blackScore, whiteScore)
self.UI.drawEnd(text)
self.end = True
if self.players[0].resigned == True:
self.UI.drawEnd("Black quit, white wins")
self.end = True
if self.players[1].resigned == True:
self.UI.drawEnd("White quit, black wins")
self.end = True
while self.newGame == False and self.exit == False:
self.lookForInput()
self.UI.quit()
if self.newGame == True:
newMenu = UIMainMenu()
newMenu.mainLoop()
'''
Gives the current score of a player
'''
def findScore(self, player):
self.updateTerritory()
score = player.prisoners
for group in self.territories.groups:
if group.colour == player.colour:
score = score + len(group.coordinates)
return score
'''
updates self.territories to represent the current state of board
'''
def updateTerritory(self):
for x in range(self.board.size):
for y in range(self.board.size):
if self.board.isEmpty((x,y)) and \
self.territories.isEmpty((x,y)):
newGroup = Group("u", {(x, y)})
self.territories.addToGroups(newGroup)
self.evaluateTerritory((x, y), newGroup)
'''
called recursively by updateTerritory() to evaluate a territory group
'''
def evaluateTerritory(self, position, group):
for neighbour in self.territories.neighbours(position):
if self.territories.isEmpty(neighbour):
if self.board.isEmpty(neighbour):
newGroup = Group(group.colour, {neighbour})
self.territories.addToGroups(newGroup)
group.mergeGroup(newGroup, self.territories)
self.evaluateTerritory(neighbour, group)
elif self.board.getGroup(neighbour).colour != group.colour:
if group.colour == "u":
group.colour = self.board.getGroup(neighbour).colour
else:
group.colour = "n"
'''
Looks for any of the allowed inputs to any resolves the relvent action
'''
def lookForInput(self):
self.handler.update()
if self.players[self.currentPlayer].time > 0:
self.players[
self.currentPlayer].time -= self.handler.getTimePassed()
if self.handler.hasQuit():
self.end = True
self.exit = True
if self.UI.winScreen.primary_button.wasPressed() and\
self.end == True:
self.newGame = True
if self.currentPlayer == 0:
if self.UI.blackPlayer.quitButton.wasPressed():
self.players[0].resigned = True
if self.UI.blackPlayer.passButton.wasPressed():
self.players[0].passed = True
if self.handler.keyWasPressed(pygame.K_SPACE):
self.attemptedPlace = True
if self.handler.keyWasPressed(pygame.K_a):
self.cursor.moveBy((-1, 0))
if self.handler.keyWasPressed(pygame.K_d):
self.cursor.moveBy((1, 0))
if self.handler.keyWasPressed(pygame.K_w):
self.cursor.moveBy((0, -1))
if self.handler.keyWasPressed(pygame.K_s):
self.cursor.moveBy((0, 1))
if self.currentPlayer == 1:
if self.UI.whitePlayer.quitButton.wasPressed():
self.players[1].resigned = True
if self.UI.whitePlayer.passButton.wasPressed():
self.players[1].passed = True
if self.handler.keyWasPressed(pygame.K_BACKSPACE):
self.attemptedPlace = True
if self.handler.keyWasPressed(pygame.K_LEFT):
self.cursor.moveBy((-1, 0))
if self.handler.keyWasPressed(pygame.K_RIGHT):
self.cursor.moveBy((1, 0))
if self.handler.keyWasPressed(pygame.K_UP):
self.cursor.moveBy((0, -1))
if self.handler.keyWasPressed(pygame.K_DOWN):
self.cursor.moveBy((0, 1))
def _onAppChanged(self, event):
if self.app == event.app:
EventHandler._onAppChanged(self, event) # updates the bounds in the base class' method
self._updateAppOverlays()
self._resetOverlay()
# Deal with sync'ed layout
al,ar,at,ab = self.app.getBounds()
ratio = self.app.getAspectRatio()
ax,ay = self.app.getCenterX(),self.app.getCenterY()
aw,ah = self.app.getWidth(),self.app.getHeight()
print("_onAppChanged: something changed: ", self.app.isShared, al,ar,at,ab)
if self.app.isShared and self.app.section and self.app.section.isShared and getMasterSiteMode():
localw = float ( self.app.section.getWidth() )
localh = float ( self.app.section.getHeight() )
localx = float ( self.app.section.getX() )
localy = float ( self.app.section.getY() )
ll = al / localw
lr = ar / localw
lt = at / localh
lb = ab / localh
lx = (ax-localx) / localw
ly = (ay-localy) / localh
lw = aw / localh
lh = ah / localh
# Get handlers on the remote site
rgate, rdata = getGate( getMasterSite() )
# Get the remote display dimensions
dremote = rdata.getDisplayInfo()
remotew = float ( dremote.sageW )
remoteh = float ( dremote.sageH * 0.97)
offsetx = 0.0
offsety = 0.0
# adjust remote dimensions to match local aspect ratio
if (remotew/remoteh) >= (localw/localh):
remotew = remoteh * localw / localh
offsetx = ( float ( dremote.sageW ) - remotew ) / 2.0
else:
remoteh = remotew * localh / localw
offsety = ( float ( dremote.sageH * 0.97 ) - remoteh ) / 2.0
# Calculate the remote size
rl = ll * remotew
rr = lr * remotew
rt = lt * remoteh
rb = lb * remoteh
rx = lx * remotew
ry = ly * remoteh
rw = lw * remoteh
rh = lh * remoteh
rl = rx - rw/2
rr = rx + rw/2
rt = ry + rh/2
rb = ry - rh/2
# center the remote windows
if offsetx > 0.0:
rl += offsetx
rr += offsetx
if offsety > 0.0:
rb += offsety
rt += offsety
rb += float ( dremote.sageH * 0.03 )
rt += float ( dremote.sageH * 0.03 )
print("Remote position should be:", int(rl), int(rr), int(rb), int(rt))
# Get local information
local_apps = getSageGate().getAppStatus()
local_params = local_apps[str(event.app.appId)][1].split()
directory, local_filename = os.path.split( local_params[-1] )
remote_apps = rgate.getAppStatus()
running_apps = rdata.getRunningApps()
winner = None
for k in remote_apps:
ra = remote_apps[k]
rparams = ra[1].split()
rdir, rfile = os.path.split( rparams[-1] )
if rfile == local_filename:
winner = int(k)
for v in running_apps.values():
remote_filename = v.title
# print("One remote app", v.sailID, v.appName, v.title, v.windowId, v.appId, v.launcherId, v.zValue, v.configNum)
if v.appName == event.app.appName:
if v.appId == winner:
print (" Remote app to control>", v.sailID)
#rgate.sendAppEvent(APP_QUIT, v.sailID)
rgate.resizeWindow(v.windowId, int(rl), int(rr), int(rb), int(rt))
