def __init__(self):
log.debug('Starting Client')
#open a window... but first set all the needed props
wp = self.loadWindoProperites()
#open the window
base.openMainWindow(props=wp)
#base.setBackgroundColor(0.06, 0.1, 0.12, 1)
base.setBackgroundColor(0.0, 0.0, 0.0, 1)
base.disableMouse()
base.enableParticles()
#needed to determine what window event fired
self.window_focused = base.win.getProperties().getForeground()
self.window_x = base.win.getXSize()
self.window_y = base.win.getYSize()
self.window_minimized = base.win.getProperties().getMinimized()
#filter manager, post process
self.filters = Filters()
#audio sound effects (sfx) + music
self.audio = Audio()
self.audio.setMusic('background')
self.audio.playMusic()
#light manager
self.lights = LightManager()
#setup the user interface (gui+key/mouse bind)
self.ui = UserInterface()
#skybox
self.sun_and_sky = Skybox(self.lights)
#player (character) droid
self.droid = PCDroid(self.ui)
#some vars used later
self.map_name = None
self.loading_status = set()
self.level_root = render.attachNewNode('level_root')
self.level_root.hide()
self.is_in_game = False
#events
base.win.setCloseRequestEvent('exit-event')
self.accept('exit-event', self.onClientExit)
self.accept('window-event', self.onWindowEvent)
self.accept('window-reset', self.onWindowReset)
self.accept('client-mouselock', self.setMouseLock)
self.accept('load-level', self.onLevelLoad)
self.accept('loading-done', self.onLoadingDone)
self.accept('reload-shaders', self.onShaderReload)
self.accept('client-set-team', self.onTeamCahnge)
self.accept('client-quit', self.onQuit)
# Task
taskMgr.add(self.update, 'client_update')
log.debug('Client started')
def __init__(self):
self.ui = UserInterface(self)
self.svg = None
self.geojson = None
self.layer_output = []
self.bounds = [0.0, 0.0, 0.0, 0.0]
self.rotation = 0.0
self.last_click = None
self.ui.run()
def __init__(self):
# Game Objects
self.pl = Player()
self.map = Map()
self.ph = PlayerHandler()
self.eh = EnemyHandler()
self.game_name = "test"
self.ui = UserInterface(ph=self.ph,
eh=self.eh,
defDir=str("~/rtgm/games/" + self.game_name))
def getAll():
conn = sqlite3.connect('savedPasswords.db')
c = conn.cursor()
ui.clearScreen()
print(ui.Screen['viewAllPasswordsScreen']['header'])
for row in c.execute("SELECT * FROM passwords ORDER BY date"):
print(row)
c.close()
conn.close()
input("Hit any Key to proceed...")
def save(password):
today = time.strftime("%m/%d/%Y")
conn = sqlite3.connect('savedPasswords.db')
c = conn.cursor()
ui.clearScreen()
name = input("What Name would you like to store this password as?\n\n")
ui.clearScreen()
username = input(
"What Username (if any), would you like to save with this password?\n\n"
)
ui.clearScreen()
print(ui.Screen['verifySaveScreen']['header'])
ui.innerSpace(8)
print("Date: " + today)
print("Name: " + name)
print("Username: "******"Password: "******"CREATE TABLE IF NOT EXISTS passwords (date TEXT, name TEXT, username TEXT, password TEXT)"
)
c.execute(
"INSERT INTO passwords (date,name,username,password) VALUES (?,?,?,?)",
(today, name, username, password))
conn.commit()
c.close()
conn.close()
elif (choice == 2):
Database.save(password)
else:
c.close()
conn.close()
quit()
def main():
def gracefulExit():
ui.killAllThreads()
root.destroy()
settings = Settings()
settings.writeSettings()
root = Tk()
root.geometry("{0}x{1}+0+0".format(root.winfo_screenwidth(), root.winfo_screenheight()))
root.wm_overrideredirect(True)
root.wm_overrideredirect(1)
root.wm_attributes("-topmost", True)
root.wm_attributes("-transparentcolor", "white")
root.config(bg='white')
api = API(settings)
log = ReadLogFile(root, settings)
log.reopenLogfile()
inv = Inventory(settings, api)
chaos = Chaos(settings, inv, log)
ui = UserInterface(root, settings, inv, api, chaos, log)
Button(root, text="Quit", command = gracefulExit, anchor=N).place(x=root.winfo_screenwidth()/2, y=root.winfo_screenheight()-30)
root.mainloop()
def main(wnd):
global terminate
if len(sys.argv) > 1:
tag = sys.argv[1]
else:
tag = 'activity/work-background'
ui = UserInterface(wnd)
yar = YandexRadio(tag, ui)
pl = Player()
lastplayed = None
queue = []
while not pl.terminate:
if len(queue) == 0:
queue = yar.gettracks(lastplayed)
curtrack = queue[0]
queue = queue[1:]
info = curtrack[2]
# dur = curtrack[3]
batch = curtrack[4]
curtrack = curtrack[:2]
pl.play(yar, curtrack, info, batch)
lastplayed = curtrack
yar.save_cookies()
def __init__(self):
log.debug('Starting Client')
#open a window... but first set all the needed props
wp=self.loadWindoProperites()
#open the window
base.openMainWindow(props = wp)
#base.setBackgroundColor(0.06, 0.1, 0.12, 1)
base.setBackgroundColor(0.0, 0.0, 0.0, 1)
base.disableMouse()
base.enableParticles()
#needed to determine what window event fired
self.window_focused=base.win.getProperties().getForeground()
self.window_x=base.win.getXSize()
self.window_y=base.win.getYSize()
self.window_minimized=base.win.getProperties().getMinimized()
#filter manager, post process
self.filters=Filters()
#audio sound effects (sfx) + music
self.audio=Audio()
self.audio.setMusic('background')
self.audio.playMusic()
#light manager
self.lights=LightManager()
#setup the user interface (gui+key/mouse bind)
self.ui=UserInterface()
#skybox
self.sun_and_sky=Skybox(self.lights)
#player (character) droid
self.droid=PCDroid(self.ui)
#some vars used later
self.map_name=None
self.loading_status=set()
self.level_root=render.attachNewNode('level_root')
self.level_root.hide()
self.is_in_game=False
#events
base.win.setCloseRequestEvent('exit-event')
self.accept('exit-event',self.onClientExit)
self.accept( 'window-event', self.onWindowEvent)
self.accept( 'window-reset', self.onWindowReset)
self.accept( 'client-mouselock', self.setMouseLock)
self.accept( 'load-level', self.onLevelLoad)
self.accept( 'loading-done', self.onLoadingDone)
self.accept( 'reload-shaders', self.onShaderReload)
self.accept( 'client-set-team', self.onTeamCahnge)
self.accept( 'client-quit', self.onQuit)
# Task
taskMgr.add(self.update, 'client_update')
log.debug('Client started')
def __init__(self, money, health, morale):
# Initialize renderer first because it starts SDL
self.renderer = Renderer()
self.textures = Textures()
self.textures.load(self.renderer.sdl_renderer)
self.user_interface = UserInterface(self.textures)
self.controller = Controller()
self.entities = Entities()
self.entities.init_player(0, 0, self.textures.get(TextureType.PLAYER),
money, health, morale)
world_creator = WorldCreator(2)
self.entities.map_rectangle = world_creator.create(
self.entities, self.textures)
def __init__(self):
self.ui = UserInterface()
self.cryp = Al(self.ui)
self.addCommandForUI()
self.isThread = False
self.stop_event = threading.Event()
self.algThread = None
self.ui.root.protocol("WM_DELETE_WINDOW", self.stopProgram)
def __init__(self):
# Create the QApplication first so that QThread, QTimer, etc. can be used
self.qt_app = QApplication()
self.qt_app.aboutToQuit.connect(self.quit)
self.database_connection = DatabaseConnection(self)
self.user_interface = UserInterface(self)
self.qt_app.exec_()
def __init__(self, fileinfo, n_connections = 30):
self.fileinfo = fileinfo
self.n_connections = n_connections
self.pieces = [FilePiece(idx, sha1, fileinfo) for idx, sha1 in enumerate(fileinfo.pieces)]
self.peers = []
self.queue = Queue()
self.ui = UserInterface(self.fileinfo.total_size)
self.server = peer.PeerServer(6880, self.fileinfo)
self.filesystem_manager = FilesystemManager(self.fileinfo)
#start with wrong estimate
self.piece_freq = [1] * len(self.pieces)
def searchDB(name):
conn = sqlite3.connect('savedPasswords.db')
c = conn.cursor()
ui.clearScreen()
print(ui.Screen['findPasswordScreen']['header'])
ui.innerSpace(2)
for row in c.execute("SELECT * FROM passwords WHERE name=?", (name, )):
print(row)
ui.innerSpace(15)
c.close()
conn.close()
input("Hit any Key to proceed...")
def uiTest(self):
# self.plSetup()
self.ui = UserInterface(ph=self.ph, eh=self.eh)
self.ui.UILoop()
def main(filename="", new_database=False, echo=False):
"""Connects to database and insert dummy data."""
if new_database:
db = UserInterface(filename, new_db=True, echo=echo)
print("Making new database file and inserting dummy data...")
countries = [{
"name": "Poland"
}, {
"name": "France"
}, {
"name": "Germany"
}]
[db.add_object(Country, country) for country in countries]
locations = [{
"street": "Wielka",
"postal_code": "50-100",
"city": "Lublin",
"country_name": "Poland"
}, {
"street": "Angielska",
"postal_code": "50-101",
"city": "Lublin",
"country_name": "Poland"
}]
[db.add_object(Location, location) for location in locations]
jobs = [{
"title": "Manager",
"min_salary": "3000",
"max_salary": "5000"
}, {
"title": "Driver",
"min_salary": "1000",
"max_salary": "4000"
}]
[db.add_object(Job, job) for job in jobs]
employees = [{
"first_name": "Jan",
"last_name": "Nowak",
"email": "*****@*****.**",
"phone_number": "60 825 23 38",
"hire_date": "12.12.12",
"job_id": "1",
"salary": "2000",
"department_id": "1"
}, {
"first_name": "Andrzej",
"last_name": "Lisiecki",
"email": "*****@*****.**",
"phone_number": "512 650 222",
"hire_date": "13.12.12",
"job_id": "2",
"manager_id": "1",
"salary": "1500",
"department_id": "2"
}]
[db.add_object(Employee, employee) for employee in employees]
departments = [{
"name": "Office",
"manager_id": "1",
"location_id": 1
}, {
"name": "Warehouse",
"manager_id": "1",
"location_id": 2
}, {
"name": "Shop",
"manager_id": "1",
"location_id": 2
}]
[db.add_object(Department, department) for department in departments]
db.ui_loop()
else:
db = UserInterface("employees.db")
db.ui_loop()
class Game:
def __init__(self):
# Game Objects
self.pl = Player()
self.map = Map()
self.ph = PlayerHandler()
self.eh = EnemyHandler()
self.game_name = "test"
self.ui = UserInterface(ph=self.ph,
eh=self.eh,
defDir=str("~/rtgm/games/" + self.game_name))
# def __del__(self):
# self.pl = None
# self.map = None
# self.mh = None
# self.ph = None
# self.ui = None
def mapSetup(self):
self.map.setV("name", "earth")
self.map.setV(
"msg",
"This planet is named Earth. There are many mysteries that lie inside of this planet. "
)
# self.ph.mh.map = self.map
self.ph.mh.loadMap("earth.json")
def plSetup(self):
from pc import PlayerCreator
plc = PlayerCreator()
plc.createLoop()
self.pl = plc.pl
self.ph = PlayerHandler(self.pl)
def createEnemy(self):
return Enemy(name="goblin", mhp=100, atk=8, pdef=4, spd=10)
def uiTest(self):
# self.plSetup()
self.ui = UserInterface(ph=self.ph, eh=self.eh)
self.ui.UILoop()
def enemySetup(self):
enemy = self.createEnemy()
self.eh = EnemyHandler(enemy)
def battleTest(self):
battle = Battle(self.ph, self.eh)
battle.battleLoop()
def storeSetup(self):
store = Store(name="Shop", des="Just an average shop")
store.get("inventory")["items"].append(
Item(name="testitem", des="This item is test item."))
sh = StoreHandler(self.ph, store)
sh.storeLoop()
def inventorySetup(self):
inventory = InventoryHandler(self.ph)
inventory.inventoryLoop()
from devices import SENSOR
from ui import UserInterface
from machine import RTC
from utime import localtime
from themes import *
rtc = RTC()
print("Synchronize time from NTP server ...")
rtc.ntp_sync(server="0.ua.pool.ntp.org", tz="Europe/Kiev")
while not rtc.synced():
sleep_ms(100)
break
collect()
theme = indigo
ui = UserInterface(theme)
sensor = SENSOR()
while KeyboardInterrupt:
_raw_time = localtime()
_date = str(_raw_time[2]) + '/' + str(_raw_time[1]) + '/' + str(
_raw_time[0])
_time = "{:0>2}".format(_raw_time[3] + 2) + ":{:0>2}".format(_raw_time[4])
ui.mem_free_label(mem_free())
ui.temp_label(sensor.temperature)
ui.humi_label(sensor.humidity)
ui.pres_label(sensor.pressure)
ui.time_label(_time)
collect()
sleep(0.5)
def main():
r1 = Receptionist(id=1)
r2 = Receptionist(id=2)
ch1 = Chair(_id=1)
ch2 = Chair(_id=2)
statistics = Statistics()
r_list = [r1, r2]
ch_list = [ch1, ch2]
p1 = Patient(id=1,
hp=85,
name="Patric",
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
p2 = Patient(id=2,
hp=93,
name="Danil",
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
p3 = Patient(id=3,
hp=30,
name="Bernard",
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
p4 = Patient(id=4,
hp=41,
name="Stefan",
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
p5 = Patient(id=5,
hp=12,
name="Carl",
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
p6 = Patient(id=6,
hp=92,
name="Joe",
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
p7 = Patient(id=7,
hp=55,
name="Anna",
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
p_list = [p1, p2, p3, p4, p5, p6, p7]
coffee1 = CoffeeMachine(id=1)
coffee2 = CoffeeMachine(id=2)
surgeryRoom1 = SurgeryRoom(id=1)
surgeryRoom2 = SurgeryRoom(id=2)
coffee_list = [coffee1, coffee2]
surgery_rooms = [surgeryRoom1, surgeryRoom2]
d1 = Doctor(id=1,
name="Dr Nowacka",
energy_points=35,
chairs=ch_list,
location=Location.CORRIDOR,
coffee_machines=coffee_list,
surgery_rooms=surgery_rooms)
d2 = Doctor(id=2,
name="Dr Kowalski",
energy_points=15,
chairs=ch_list,
location=Location.CORRIDOR,
coffee_machines=coffee_list,
surgery_rooms=surgery_rooms)
d3 = Doctor(id=3,
name="Dr Wozniak",
energy_points=5,
chairs=ch_list,
location=Location.CORRIDOR,
coffee_machines=coffee_list,
surgery_rooms=surgery_rooms)
d4 = Doctor(id=4,
name="Profesor Kowalczyk",
energy_points=45,
chairs=ch_list,
location=Location.CORRIDOR,
coffee_machines=coffee_list,
surgery_rooms=surgery_rooms)
d5 = Doctor(id=5,
name="Dr Wojtasik",
energy_points=65,
chairs=ch_list,
location=Location.CORRIDOR,
coffee_machines=coffee_list,
surgery_rooms=surgery_rooms)
doctor_list = [d1, d2, d3, d4, d5]
interface = UserInterface(chairs=ch_list,
coffee_machines=coffee_list,
doctors=doctor_list,
patients=p_list,
receptionists=r_list,
surgery_rooms=surgery_rooms)
patient_manager = Patient_Finished(patients=p_list,
receptionists=r_list,
chairs=ch_list,
statistics=statistics)
for doctor in doctor_list:
doctor.start()
for patient in p_list:
patient.start()
patient_manager.start()
interface.start()
killer = threading.Thread(target=killer_run,
args=(p_list, doctor_list, patient_manager,
interface))
killer.start()
killer.join()
for doctor in doctor_list:
doctor.join()
for patient in p_list:
patient.join()
patient_manager.join()
interface.join()
def main():
chosen_menu = 'q'
ui = UserInterface()
ui.clear_sreen()
while chosen_menu != '0':
ui.show_main_menu()
chosen_menu = ui.choose_menu_number()
if chosen_menu == "1":
# Create the necessary instances
create_and_upload_table = CreateTable()
generate_applicants = ApplicantGenerator(
"example_data/applicant.txt")
ui.clear_sreen()
chosen_administrator_menu = 'q'
while chosen_administrator_menu != "0":
ui.show_administrator_menu()
chosen_administrator_menu = ui.choose_submenu_number(
"Administrator")
if chosen_administrator_menu == "1":
try:
create_and_upload_table.create_table()
ui.show_generetad_data("Tables", False)
except:
ui.show_cant_generate_data("tables")
elif chosen_administrator_menu == "2":
try:
create_and_upload_table.generate_example_data()
ui.show_generetad_data("Example data")
except:
ui.show_cant_generate_data("example data")
elif chosen_administrator_menu == "3":
try:
generate_applicants.generate_applicant()
ui.show_generetad_data("Applicants data")
except:
ui.show_cant_generate_data("applicants data")
elif chosen_administrator_menu == "4":
try:
generate_applicants.generate_nearest_school()
generate_applicants.generate_interview_for_applicants()
ui.show_generetad_data("Interview dates")
except:
ui.show_cant_generate_data("interviews date")
elif chosen_administrator_menu == "0":
ui.clear_sreen()
break
else:
ui.show_wrong_number()
elif chosen_menu == "2":
mentor_details = MentorDetails()
ui.clear_sreen()
chosen_mentor_menu = 'q'
while chosen_mentor_menu != "0":
ui.show_mentor_menu()
chosen_mentor_menu = ui.choose_submenu_number("Mentor")
if chosen_mentor_menu == '1':
try:
mentor_details.mentor_date_time()
except:
ui.show_cant_found("mentor id")
elif chosen_mentor_menu == '0':
ui.clear_sreen()
break
else:
ui.show_wrong_number()
elif chosen_menu == '3':
# Create instances
applicant_detail = ApplicantDetails()
ui.clear_sreen()
chosen_applicant_menu = 'q'
while chosen_applicant_menu != '0':
ui.show_applicant_menu()
chosen_applicant_menu = ui.choose_submenu_number("Applicant")
if chosen_applicant_menu == '1':
try:
applicant_detail.interview_details()
except:
ui.show_cant_found("applicant code")
elif chosen_applicant_menu == '2':
try:
applicant_detail.status_details()
except:
ui.show_cant_found("applicant code")
elif chosen_applicant_menu == '3':
try:
applicant_detail.school_details()
except:
ui.show_cant_found("applicant code")
elif chosen_applicant_menu == '0':
ui.clear_sreen()
break
else:
ui.show_wrong_number()
elif chosen_menu == '0':
ui.show_say_hello()
else:
ui.show_wrong_number()
from board import Board
from ui import UserInterface
from game import Game
from tests import Test as TestClass
if __name__ == "__main__":
TranslationTable = {0: " ", 1: "E", 2: "*", 3: "X", 4:"-"}
Test = TestClass()
Test.TestFire()
Grid = Board(TranslationTable)
_Game = Game(Grid)
_Game.GridSetup()
UI = UserInterface(Grid, _Game)
UI.Start()
class TorrentDownloader(object):
def __init__(self, fileinfo, n_connections = 30):
self.fileinfo = fileinfo
self.n_connections = n_connections
self.pieces = [FilePiece(idx, sha1, fileinfo) for idx, sha1 in enumerate(fileinfo.pieces)]
self.peers = []
self.queue = Queue()
self.ui = UserInterface(self.fileinfo.total_size)
self.server = peer.PeerServer(6880, self.fileinfo)
self.filesystem_manager = FilesystemManager(self.fileinfo)
#start with wrong estimate
self.piece_freq = [1] * len(self.pieces)
def connect_to_peers(self):
for p in self.fileinfo.get_all_peers():
if len(self.peers) == self.n_connections:
break
if any(other.host == p.ip and other.port == p.port for other in self.peers):
continue
try:
self.ui.update_log('connect ' + str(p))
self.fileinfo.used_peer(p)
self.ui.peer_connected()
self.peers += [peer.PeerConn(self.fileinfo, self, hostport=(p.ip, p.port))]
except socket.error as e:
self.ui.update_log(str(e))
def update_piece_freq(self):
self.piece_freq = [0] * len(self.pieces)
for otherpeer in self.peers:
for idx, has in enumerate(otherpeer.bitfield):
self.piece_freq[idx] += has
def get_rarest_piece_had_by(self, peer):
if random.randint(0, 50) == 0:
self.update_piece_freq() #only do this occasionally to save time
piece_id, freq = min(enumerate(self.piece_freq),
key=lambda (i, f): f if peer.bitfield[i] and not self.pieces[i].is_fully_requested() else 99999)
if self.pieces[piece_id].is_fully_requested():
return None
else:
return self.pieces[piece_id]
def update_choking_status(self, new_unchoke):
if new_unchoke:
self.ui.peer_unchoked()
else:
self.ui.peer_choked()
def got_piece(self, piece_id, block_begin, data):
self.ui.got_block(len(data))
block_id = block_begin / BLOCK_SIZE
piece = self.pieces[piece_id]
piece.add_block(block_id, data)
if piece.is_fully_downloaded():
[p.have(piece.piece_index) for p in self.peers]
piece.verify_and_write(self.filesystem_manager)
self.ui.got_piece()
if all(piece.is_fully_downloaded() for piece in self.pieces):
self.close_all_peers()
def got_request(self, peer, req):
piece_index, block_offset, block_len = req
piece = self.filesystem_manager.get_piece(FilePiece(piece_index, 0, self.fileinfo))
if hasattr(piece, 'data'):
block = piece.data[block_offset : block_offset + block_len]
peer.piece(piece_index, block_offset, block)
else:
peer.close()
#this algorithm is extremely simple. but it should work reasonably well.
def interest_state(self, peer):
if peer.peer_interested:
if sum([not p.am_choking for p in self.peers]) < 4:
peer.choke(False) #unchoke this peer if it's okay
elif random.randint(0, 9) == 0:
#sometimes, randomly choke someone else and unchoke anyway
random.choice([p for p in self.peers if not p.am_choking]).choke(True)
peer.choke(False)
else:
peer.choke(True)
#optomistically unchoke
random.choice([p for p in self.peers if p.am_choking]).choke(False)
def close_all_peers(self):
for peer in self.peers:
peer.close()
self.peers = []
def get_request_to_make(self, peer):
piece_to_get = self.get_rarest_piece_had_by(peer)
if not piece_to_get:
return None
block_idx = piece_to_get.get_next_block_id()
return piece_to_get.piece_index, block_idx * BLOCK_SIZE, BLOCK_SIZE
def peer_closed(self, peer):
self.ui.lost_peer(not peer.peer_choking)
self.peers.remove(peer)
self.connect_to_peers()
def start(self):
self.connect_to_peers()
asyncore.loop()
class Client(DirectObject):
"""
Client class handels gui/input audio and rendering
"""
def __init__(self):
log.debug('Starting Client')
#open a window... but first set all the needed props
wp = self.loadWindoProperites()
#open the window
base.openMainWindow(props=wp)
#base.setBackgroundColor(0.06, 0.1, 0.12, 1)
base.setBackgroundColor(0.0, 0.0, 0.0, 1)
base.disableMouse()
base.enableParticles()
#needed to determine what window event fired
self.window_focused = base.win.getProperties().getForeground()
self.window_x = base.win.getXSize()
self.window_y = base.win.getYSize()
self.window_minimized = base.win.getProperties().getMinimized()
#filter manager, post process
self.filters = Filters()
#audio sound effects (sfx) + music
self.audio = Audio()
self.audio.setMusic('background')
self.audio.playMusic()
#light manager
self.lights = LightManager()
#setup the user interface (gui+key/mouse bind)
self.ui = UserInterface()
#skybox
self.sun_and_sky = Skybox(self.lights)
#player (character) droid
self.droid = PCDroid(self.ui)
#some vars used later
self.map_name = None
self.loading_status = set()
self.level_root = render.attachNewNode('level_root')
self.level_root.hide()
self.is_in_game = False
#events
base.win.setCloseRequestEvent('exit-event')
self.accept('exit-event', self.onClientExit)
self.accept('window-event', self.onWindowEvent)
self.accept('window-reset', self.onWindowReset)
self.accept('client-mouselock', self.setMouseLock)
self.accept('load-level', self.onLevelLoad)
self.accept('loading-done', self.onLoadingDone)
self.accept('reload-shaders', self.onShaderReload)
self.accept('client-set-team', self.onTeamCahnge)
self.accept('client-quit', self.onQuit)
# Task
taskMgr.add(self.update, 'client_update')
log.debug('Client started')
def doSomeStuffTsk(self, task):
x = deque(range(5000))
for i in xrange(999):
random.shuffle(x)
#print i, x[0]
#print 'done'
return task.done
def setMouseLock(self, lock):
wp = WindowProperties.getDefault()
if lock:
wp.setMouseMode(WindowProperties.M_confined)
else:
wp.setMouseMode(WindowProperties.M_relative)
if not cfg['use-os-cursor']:
wp.setCursorHidden(True)
base.win.requestProperties(wp)
def loadWindoProperites(self):
#check if we can open a fullscreen window at the requested size
if cfg['fullscreen']:
mods = []
for mode in base.pipe.getDisplayInformation().getDisplayModes():
mods.append([mode.width, mode.height])
if list(cfg['win-size']) not in mods:
cfg['fullscreen'] = False
log.warning('Can not open fullscreen window at ' +
str(cfg['win-size']))
#the window props should be set by this time, but make sure
wp = WindowProperties.getDefault()
try:
wp.setUndecorated(cfg['undecorated'])
wp.setFullscreen(cfg['fullscreen'])
wp.setSize(cfg['win-size'][0], cfg['win-size'][1])
wp.setFixedSize(cfg['win-fixed-size'])
except:
log.warning('Failed to set window properties, Traceback:')
for error in traceback.format_exc().splitlines()[1:]:
log.warning(error.strip())
#these probably won't be in the config (?)
wp.setOrigin(-2, -2)
wp.setTitle('A4P')
if not cfg['use-os-cursor']:
wp.setCursorHidden(True)
return wp
def loadLevel(self, task):
log.debug('Client loading level...')
with open(path + 'maps/' + self.map_name + '.json') as f:
values = json.load(f)
#set the time
self.sun_and_sky.setTime(values['level']['time'])
#self.sun_and_sky.show()
#load visible objects
for id, obj in enumerate(values['objects']):
mesh = loader.loadModel(path + obj['model'])
mesh.reparentTo(self.level_root)
mesh.setPosHpr(tuple(obj['pos']), tuple(obj['hpr']))
mesh.setTag(
'id_' + str(id), str(id)
) #we may need to find this mesh later to link it to a Bullet object
for name, value in obj['shader_inputs'].items():
if isinstance(value, basestring):
mesh.setShaderInput(str(name),
loader.loadTexture(path + value))
if isinstance(value, float):
mesh.setShaderInput(str(name), value)
if isinstance(value, list):
if len(value) == 2:
mesh.setShaderInput(str(name),
Vec2(value[0], value[1]))
elif len(value) == 3:
mesh.setShaderInput(str(name),
Vec3(value[0], value[1], value[2]))
elif len(value) == 3:
mesh.setShaderInput(
str(name),
Vec4(value[0], value[1], value[2], value[3]))
mesh.setShader(
Shader.load(Shader.SLGLSL, obj['vertex_shader'],
obj['fragment_shader']))
#set the music
self.audio.setMusic(values['level']['music'])
#self.level_root.prepareScene(base.win.getGsg())
messenger.send('loading-done', ['client'])
return task.done
#events
def onQuit(self):
self.level_root.removeNode()
self.level_root = render.attachNewNode('level_root')
self.level_root.hide()
if self.ui.is_zoomed:
self.ui.zoom()
self.sun_and_sky.hide()
self.droid.disable()
self.ui.unbindKeys()
self.ui.in_game_menu.hide()
self.ui.main_menu.show()
self.audio.setMusic('background')
self.loading_status = set()
self.is_in_game = False
messenger.send('world-clear-level')
def onTeamCahnge(self, team):
self.droid.setTeam(team)
def onShaderReload(self):
log.debug('Client: Reloading shaders')
for mesh in self.level_root.getChildren():
shader = mesh.getShader()
v_shader = shader.getFilename(Shader.ST_vertex)
f_shader = shader.getFilename(Shader.ST_fragment)
mesh.setShader(Shader.load(Shader.SLGLSL, v_shader, f_shader))
self.ui.main_menu.setShader(path + 'shaders/gui_v.glsl',
path + 'shaders/gui_f.glsl')
self.filters.reset()
def onLoadingDone(self, target):
log.debug(str(target) + ' loading done')
self.loading_status.add(target)
if self.loading_status == set(['client', 'server', 'world']):
self.ui.main_menu.hide()
self.level_root.show()
self.sun_and_sky.show()
self.ui.bindKeys()
self.droid.node.setPos(render, 20, 0, 2)
self.droid.lockCamera()
self.droid.model.show()
self.droid.rig.show()
self.droid.gun.show()
self.ui.in_game_menu.showElements('hud_')
self.ui.hideSoftCursor()
self.ui.is_main_menu = False
self.is_in_game = True
messenger.send('world-link-objects',
[self.droid.node, 'pc_droid_node'])
def onLevelLoad(self, map_name):
self.map_name = map_name
#we wait 1.0 sec for the loading animation to finish just in case if loading takes < 1.0 sec.
taskMgr.doMethodLater(1.0,
self.loadLevel,
'client_loadLevel_task',
taskChain='background_chain')
#taskMgr.add(self.loadLevel, 'client_loadLevel_task', taskChain = 'background_chain')
#the client needs to load/setup:
# -visible geometry
# -enviroment (skybox/dome + sunlight diection + fog + ???)
# -water plane
# -unmovable (point)light sources
# -unmovable vfx
# -the player droid
def onClientExit(self):
log.debug('Client exit')
self.audio.cleanup()
app.exit()
def onWindowReset(self):
wp = self.loadWindoProperites()
base.win.requestProperties(wp)
def onWindowMinimize(self):
self.window_minimized = base.win.getProperties().getMinimized()
log.debug('window-event: Minimize is ' + str(self.window_minimized))
def onWindowFocus(self):
self.window_focused = base.win.getProperties().getForeground()
log.debug('window-event: Focus set to ' + str(self.window_focused))
if self.is_in_game:
self.ui.in_game_menu.showMenu(self.window_focused)
if not self.window_focused:
self.ui.cursor_pos = (0, 0, 0)
if cfg['pause-on-focus-lost']:
if not self.window_focused:
self.audio.pauseMusic()
base.win.setActive(False)
else:
self.audio.resumeMusic()
base.win.setActive(True)
def onWindowResize(self):
self.window_x = base.win.getXSize()
self.window_y = base.win.getYSize()
log.debug('window-event: Resize')
self.filters.update()
self.ui.updateGuiNodes()
def onWindowEvent(self, window=None):
if window is not None: # window is none if panda3d is not started
if self.window_x != base.win.getXSize(
) or self.window_y != base.win.getYSize():
self.onWindowResize()
elif window.getProperties().getMinimized(
) != self.window_minimized:
self.onWindowMinimize()
elif window.getProperties().getForeground() != self.window_focused:
self.onWindowFocus()
#tasks
def update(self, task):
dt = globalClock.getDt()
render.setShaderInput('camera_pos', base.cam.getPos(render))
return task.cont
def main_menu():
ui = UserInterface()
while True:
choice = input("""
--------------------------------------------------
Press 1 To Add New Stock\n
Press 2 To Check the Current Stock\n
Press 3 To Add Item to Cart\n
Press 4 To Make a Purchase\n
Press 5 To Display a Cart\n
Press 6 To Empty a Cart\n
Press 7 To Display all Reports\n
Press Q to quit\n
--------------------------------------------------
Please enter your choice: """)
if choice == "1":
model = input("Please enter model")
price = input("Please enter price")
colour = input("Please enter colour")
size = input("Please enter size")
gender = input("Please enter gender")
quantity = input("Please enter quantity")
ui.add_new_bike(model, price, colour, size, gender,
quantity) # sends arguments to the method
print("Successfully added to stock!")
elif choice == "2":
ui.display_stock()
elif choice == "3":
ui.add_to_cart()
elif choice == '4':
ui.make_purchase()
elif choice == '5':
ui.display_cart()
elif choice == '6':
ui.empty_the_cart()
elif choice == '7':
ui.display_reports()
elif choice == "Q" or choice == "q":
break
else:
print("You must only select either 1, 2 or Q.")
print("Please try again")
from question_model import Question
from data import question_data
from quiz_brain import QuizBrain
from ui import UserInterface
question_bank = []
for question in question_data:
question_text = question["question"]
question_answer = question["correct_answer"]
new_question = Question(question_text, question_answer)
question_bank.append(new_question)
quiz = QuizBrain(question_bank)
quiz_ui = UserInterface(quiz)
# while quiz.still_has_questions():
# quiz.next_question()
print("You've completed the quiz")
print(f"Your final score was: {quiz.score}/{quiz.question_number}")
from time import sleep
from gc import collect, mem_free
from devices import SENSOR
from ui import UserInterface
from rgb565color import *
collect()
ui = UserInterface()
sensor = SENSOR()
while KeyboardInterrupt:
ui.mem_free_label(mem_free(), CORAL)
ui.temp_label(sensor.temperature, MAGENTA)
ui.humi_label(sensor.humidity, LIME)
ui.pres_label(sensor.pressure, GAINSBORO)
collect()
sleep(0.5)
class Controller:
def __init__(self):
self.ui = UserInterface(self)
self.svg = None
self.geojson = None
self.layer_output = []
self.bounds = [0.0, 0.0, 0.0, 0.0]
self.rotation = 0.0
self.last_click = None
self.ui.run()
def load_svg(self, path):
with open(path) as file:
svg = SVG(file.read())
self.svg = svg
self.geojson = GeoJSON(self.svg)
self.layer_output = list(self.svg.get_layers())
self.update_result()
self.ui.load_preview(path)
layers = self.svg.get_layers()
self.ui.load_layers(layers)
def set_layer_output(self, layer: str, enable: bool):
if enable:
self.layer_output.append(layer)
else:
self.layer_output.remove(layer)
def update_boundaries(self, direction: chr, value, update_ui=True):
if direction == 'N':
self.bounds[0] = value
elif direction == 'S':
self.bounds[1] = value
elif direction == 'E':
self.bounds[2] = value
elif direction == 'W':
self.bounds[3] = value
if update_ui:
self.ui.set_boundaries(self.bounds)
self.update_result()
def update_rotation(self, rotation):
self.rotation = rotation
self.update_result()
def update_result(self):
print(
f'Updating to match the bounds {self.bounds} with {self.rotation}º of rotation.'
)
geojson = self.geojson.calculate(self.layer_output, self.bounds,
self.rotation)
self.ui.set_output(geojson)
self.ui.draw_polygons(self.geojson.polygons)
def record_click(self, lon: float, lat: float):
self.last_click = lon, lat
self.ui.set_last_click(lon, lat)
def replace_lim(self, direction: chr):
if direction in ('N', 'S'):
self.update_boundaries(direction, self.last_click[1])
else:
self.update_boundaries(direction, self.last_click[0])
from ui import UserInterface
from controller import Controller
from domain import Map
if __name__ == "__main__":
ctrl = Controller()
ui = UserInterface(ctrl)
ui.main()
class Game:
# Parameters: starting values for money, health, and morale
def __init__(self, money, health, morale):
# Initialize renderer first because it starts SDL
self.renderer = Renderer()
self.textures = Textures()
self.textures.load(self.renderer.sdl_renderer)
self.user_interface = UserInterface(self.textures)
self.controller = Controller()
self.entities = Entities()
self.entities.init_player(0, 0, self.textures.get(TextureType.PLAYER),
money, health, morale)
world_creator = WorldCreator(2)
self.entities.map_rectangle = world_creator.create(
self.entities, self.textures)
def run(self):
running = True
# For average FPS calculation
frames = 0
last_frame = sdl2.SDL_GetTicks()
# Display splash screen
while sdl2.SDL_GetTicks() < last_frame\
+ Renderer.splash_screen_display_time:
self.renderer.render_splash_screen(self.textures)
# Game loop:
while running:
# 1. Handle input from the user interface
screen_dimensions = [
self.renderer.screen_width, self.renderer.screen_height
]
running = self.user_interface.handle_input(self.controller,
screen_dimensions)
# 2. Update entities from the controller
self.controller.update_entities(self.entities)
self.controller.generate_NPCs(self.entities, self.textures)
# if not self.controller.check_player_meters(self.entities):
if self.controller.current_health <= 0 or self.controller.current_morale <= 0:
# Display splash screen
last_frame = sdl2.SDL_GetTicks()
while sdl2.SDL_GetTicks() < last_frame\
+ Renderer.splash_screen_display_time:
self.renderer.render_lose_screen(self.textures)
running = False
# 3. Update screen from the renderer
self.renderer.render(self.entities, self.textures,
self.user_interface, screen_dimensions)
# For debugging:
# Average FPS for performance profiling, prints every 5 seconds
frames += 1
if sdl2.SDL_GetTicks() - last_frame > 5000:
print('Average FPS: ' + str(frames / 5.0))
frames = 0
last_frame = sdl2.SDL_GetTicks()
self.close()
def get_renderer(self):
"""Returns the game renderer that was instantiated by the game class
so that it can be used in other components that need to borrow from it.
"""
return self.renderer
def get_textures(self):
"""Returns the game textures that were instantiated by the game class
so that they can be used by other components.
"""
return self.textures
# Closes the game renderer
def close(self):
self.textures.unload()
self.renderer.close()
class Client(DirectObject):
"""
Client class handels gui/input audio and rendering
"""
def __init__(self):
log.debug('Starting Client')
#open a window... but first set all the needed props
wp=self.loadWindoProperites()
#open the window
base.openMainWindow(props = wp)
#base.setBackgroundColor(0.06, 0.1, 0.12, 1)
base.setBackgroundColor(0.0, 0.0, 0.0, 1)
base.disableMouse()
base.enableParticles()
#needed to determine what window event fired
self.window_focused=base.win.getProperties().getForeground()
self.window_x=base.win.getXSize()
self.window_y=base.win.getYSize()
self.window_minimized=base.win.getProperties().getMinimized()
#filter manager, post process
self.filters=Filters()
#audio sound effects (sfx) + music
self.audio=Audio()
self.audio.setMusic('background')
self.audio.playMusic()
#light manager
self.lights=LightManager()
#setup the user interface (gui+key/mouse bind)
self.ui=UserInterface()
#skybox
self.sun_and_sky=Skybox(self.lights)
#player (character) droid
self.droid=PCDroid(self.ui)
#some vars used later
self.map_name=None
self.loading_status=set()
self.level_root=render.attachNewNode('level_root')
self.level_root.hide()
self.is_in_game=False
#events
base.win.setCloseRequestEvent('exit-event')
self.accept('exit-event',self.onClientExit)
self.accept( 'window-event', self.onWindowEvent)
self.accept( 'window-reset', self.onWindowReset)
self.accept( 'client-mouselock', self.setMouseLock)
self.accept( 'load-level', self.onLevelLoad)
self.accept( 'loading-done', self.onLoadingDone)
self.accept( 'reload-shaders', self.onShaderReload)
self.accept( 'client-set-team', self.onTeamCahnge)
self.accept( 'client-quit', self.onQuit)
# Task
taskMgr.add(self.update, 'client_update')
log.debug('Client started')
def doSomeStuffTsk(self, task):
x=deque(range(5000))
for i in xrange(999):
random.shuffle(x)
#print i, x[0]
#print 'done'
return task.done
def setMouseLock(self, lock):
wp = WindowProperties.getDefault()
if lock:
wp.setMouseMode(WindowProperties.M_confined)
else:
wp.setMouseMode(WindowProperties.M_relative)
if not cfg['use-os-cursor']:
wp.setCursorHidden(True)
base.win.requestProperties(wp)
def loadWindoProperites(self):
#check if we can open a fullscreen window at the requested size
if cfg['fullscreen']:
mods=[]
for mode in base.pipe.getDisplayInformation().getDisplayModes():
mods.append([mode.width, mode.height])
if list(cfg['win-size']) not in mods:
cfg['fullscreen']=False
log.warning('Can not open fullscreen window at '+str(cfg['win-size']))
#the window props should be set by this time, but make sure
wp = WindowProperties.getDefault()
try:
wp.setUndecorated(cfg['undecorated'])
wp.setFullscreen(cfg['fullscreen'])
wp.setSize(cfg['win-size'][0],cfg['win-size'][1])
wp.setFixedSize(cfg['win-fixed-size'])
except:
log.warning('Failed to set window properties, Traceback:')
for error in traceback.format_exc().splitlines()[1:]:
log.warning(error.strip())
#these probably won't be in the config (?)
wp.setOrigin(-2,-2)
wp.setTitle('A4P')
if not cfg['use-os-cursor']:
wp.setCursorHidden(True)
return wp
def loadLevel(self, task):
log.debug('Client loading level...')
with open(path+'maps/'+self.map_name+'.json') as f:
values=json.load(f)
#set the time
self.sun_and_sky.setTime(values['level']['time'])
#self.sun_and_sky.show()
#load visible objects
for id, obj in enumerate(values['objects']):
mesh=loader.loadModel(path+obj['model'])
mesh.reparentTo(self.level_root)
mesh.setPosHpr(tuple(obj['pos']), tuple(obj['hpr']))
mesh.setTag('id_'+str(id), str(id)) #we may need to find this mesh later to link it to a Bullet object
for name, value in obj['shader_inputs'].items():
if isinstance(value, basestring):
mesh.setShaderInput(str(name), loader.loadTexture(path+value))
if isinstance(value, float):
mesh.setShaderInput(str(name), value)
if isinstance(value, list):
if len(value) == 2:
mesh.setShaderInput(str(name), Vec2(value[0], value[1]))
elif len(value) == 3:
mesh.setShaderInput(str(name), Vec3(value[0], value[1], value[2]))
elif len(value) == 3:
mesh.setShaderInput(str(name), Vec4(value[0], value[1], value[2], value[3]))
mesh.setShader(Shader.load(Shader.SLGLSL, obj['vertex_shader'],obj['fragment_shader']))
#set the music
self.audio.setMusic(values['level']['music'])
#self.level_root.prepareScene(base.win.getGsg())
messenger.send('loading-done', ['client'])
return task.done
#events
def onQuit(self):
self.level_root.removeNode()
self.level_root=render.attachNewNode('level_root')
self.level_root.hide()
if self.ui.is_zoomed:
self.ui.zoom()
self.sun_and_sky.hide()
self.droid.disable()
self.ui.unbindKeys()
self.ui.in_game_menu.hide()
self.ui.main_menu.show()
self.audio.setMusic('background')
self.loading_status=set()
self.is_in_game=False
messenger.send('world-clear-level')
def onTeamCahnge(self, team):
self.droid.setTeam(team)
def onShaderReload(self):
log.debug('Client: Reloading shaders')
for mesh in self.level_root.getChildren():
shader=mesh.getShader()
v_shader=shader.getFilename(Shader.ST_vertex)
f_shader=shader.getFilename(Shader.ST_fragment)
mesh.setShader(Shader.load(Shader.SLGLSL, v_shader,f_shader))
self.ui.main_menu.setShader(path+'shaders/gui_v.glsl', path+'shaders/gui_f.glsl')
self.filters.reset()
def onLoadingDone(self, target):
log.debug(str(target)+' loading done')
self.loading_status.add(target)
if self.loading_status == set(['client', 'server', 'world']):
self.ui.main_menu.hide()
self.level_root.show()
self.sun_and_sky.show()
self.ui.bindKeys()
self.droid.node.setPos(render, 20,0,2)
self.droid.lockCamera()
self.droid.model.show()
self.droid.rig.show()
self.droid.gun.show()
self.ui.in_game_menu.showElements('hud_')
self.ui.hideSoftCursor()
self.ui.is_main_menu=False
self.is_in_game=True
messenger.send('world-link-objects', [self.droid.node, 'pc_droid_node'])
def onLevelLoad(self, map_name):
self.map_name=map_name
#we wait 1.0 sec for the loading animation to finish just in case if loading takes < 1.0 sec.
taskMgr.doMethodLater(1.0, self.loadLevel, 'client_loadLevel_task', taskChain = 'background_chain')
#taskMgr.add(self.loadLevel, 'client_loadLevel_task', taskChain = 'background_chain')
#the client needs to load/setup:
# -visible geometry
# -enviroment (skybox/dome + sunlight diection + fog + ???)
# -water plane
# -unmovable (point)light sources
# -unmovable vfx
# -the player droid
def onClientExit(self):
log.debug('Client exit')
self.audio.cleanup()
app.exit()
def onWindowReset(self):
wp=self.loadWindoProperites()
base.win.requestProperties(wp)
def onWindowMinimize(self):
self.window_minimized=base.win.getProperties().getMinimized()
log.debug('window-event: Minimize is '+str(self.window_minimized))
def onWindowFocus(self):
self.window_focused=base.win.getProperties().getForeground()
log.debug('window-event: Focus set to '+str(self.window_focused))
if self.is_in_game:
self.ui.in_game_menu.showMenu(self.window_focused)
if not self.window_focused:
self.ui.cursor_pos=(0,0,0)
if cfg['pause-on-focus-lost']:
if not self.window_focused:
self.audio.pauseMusic()
base.win.setActive(False)
else:
self.audio.resumeMusic()
base.win.setActive(True)
def onWindowResize(self):
self.window_x=base.win.getXSize()
self.window_y=base.win.getYSize()
log.debug('window-event: Resize')
self.filters.update()
self.ui.updateGuiNodes()
def onWindowEvent(self,window=None):
if window is not None: # window is none if panda3d is not started
if self.window_x!=base.win.getXSize() or self.window_y!=base.win.getYSize():
self.onWindowResize()
elif window.getProperties().getMinimized() != self.window_minimized:
self.onWindowMinimize()
elif window.getProperties().getForeground() != self.window_focused:
self.onWindowFocus()
#tasks
def update(self, task):
dt = globalClock.getDt()
render.setShaderInput('camera_pos', base.cam.getPos(render))
return task.cont
from ui import UserInterface uI = UserInterface() uI.run()
from ui import UserInterface
if __name__ == "__main__":
gui = UserInterface()
def drawScreen(SCREEN, option=None):
ui.clearScreen()
print(ui.Screen[SCREEN]['header'])
if (option != None):
print("New Password: "******"welcomeScreen")
elif (choice == 3):
drawScreen('findPasswordScreen')
else:
quit()
elif (SCREEN == 'newPasswordScreen'):
if (choice == 1):
newPassword = gen.GenerateBasic()
elif (choice == 2):
newPassword = gen.GenerateSpecial()
elif (choice == 3):
newPassword = gen.GeneratePhrase()
else:
quit()
drawScreen('savePasswordScreen', newPassword)
elif (SCREEN == 'savePasswordScreen'):
if (choice == 1):
db.save(option)
elif (choice == 2):
newPassword = gen.GenerateBasic()
drawScreen('savePasswordScreen', newPassword)
elif (choice == 3):
newPassword = gen.GenerateSpecial()
drawScreen('savePasswordScreen', newPassword)
elif (choice == 4):
newPassword = gen.GeneratePhrase()
drawScreen('savePasswordScreen', newPassword)
elif (choice == 5):
drawScreen('newPasswordScreen')
else:
quit()
elif (SCREEN == 'findPasswordScreen'):
db.searchDB(choice)
drawScreen("welcomeScreen")
return parser.parse_args()
if __name__ == '__main__':
options, args = parse_options()
if options.patterns_file == None:
options.patterns_file = os.path.join(options.directory, '.dojoignore')
try:
print 'Monitoring files in %s' % options.directory
print 'ignoring files in %s' % (options.patterns_file)
print 'press ^C to quit'
timer = Timer(options.round_time)
ui = UserInterface(timer)
monitor = Monitor(
ui=ui,
directory=options.directory,
commands=args,
patterns_file=options.patterns_file,
commit=options.commit,
)
gtk.main()
except KeyboardInterrupt:
print '\nleaving...'
sys.exit(0)