Esempio n. 1
0
 def __init__( self, settings ):
         self.window = settings[WINDOW]
         Controller.__init__( self, GameScreen( self.window.screenDimensions ) )
         
         self.level = 1
         self.type = GAME
         self.nextLevel = None
         self.playerCount = settings[PLAYERS] + 1
         self.mapper = MapBuilder( self.window.brickDimensions, [self.window.brickZone, self.window.brickZoneDimensions])
         self.score = MODES[settings[MODE]]( "black", (self.window.screenDimensions[X]/2, SCORE_BUFFER/2), self.playerCount, self )
         
         '''
         for p in range( self.playerCount ):
                 axis = racketDetails[p]['axis']
                 self.rackets.append( Racket( axis, racketDetails[p]['color'], racketDetails[p]['position'], self.window.racketDimensions[axis], self.window.screenSize ) ) #racketDetails[p]['axis']( racketDetails[p]['color'], racketDetails[p]['position'], self.window. ) )
                 self.players.append( Player( p, self.rackets[p] ) )
                 self.walls[p] = False
         '''
         
         self.racketMover = RacketController( self.window.racketPosition, self.window.ballPosition )
         results = self.racketMover.buildRackets( self.playerCount, self.window.racketDimensions, self.window.screenSize )
         
         self.bricks = []
         self.walls = results[WALLS]
         self.rackets = results[RACKETS]
         self.players = results[PLAYERS]
         self.balls = [ Ball( self.racketMover.racketDetails[p]['ballposition'], self.players[p], self, self.window.ballDimensions, self.window.screenSize ) for p in range( self.playerCount ) ]
 
 
         self.gameOver = False
         self.start()
Esempio n. 2
0
    def __init__(self, joints, kp=None, kd=None, gpos_des=None, 
                 gvel_des=None, name=None):
        Controller.__init__(self, name=name)
        self._cndof = 0
        dof_map = []
        for j in joints:
            if not isinstance(j, LinearConfigurationSpaceJoint):
                raise ValueError('Joints must be LinearConfigurationSpaceJoint instances')
            else:
                self._cndof += j.ndof
                dof_map.extend(range(j.dof.start, j.dof.stop))
        self._dof_map = array(dof_map)
        self.joints = joints

        if kp is None:
            self.kp = zeros((self._cndof, self._cndof))
        else :
            self.kp = array(kp).reshape((self._cndof, self._cndof))

        if kd is None:
            self.kd = zeros((self._cndof, self._cndof))
        else :
            self.kd = array(kd).reshape((self._cndof, self._cndof))

        if gpos_des is None:
            self.gpos_des = zeros(self._cndof)
        else:
            self.gpos_des = array(gpos_des).reshape(self._cndof)

        if gvel_des is None:
            self.gvel_des = zeros(self._cndof)
        else:
            self.gvel_des = array(gvel_des).reshape(self._cndof)
Esempio n. 3
0
class Game:
    running = True

    def __init__(self, resolution):
        pygame.init()
        self.resolution = resolution
        self.screen = pygame.display.set_mode(resolution)
        pygame.display.set_caption("2DMaze Game")
        self.controller = Controller(resolution, self.screen)

    def main(self):
        clock = pygame.time.Clock()
        self.screen.fill(Drawer.white)
        while self.running:
            #handle the events
            should_quit = self.controller.handle_events()
            if should_quit:
                break
            #Run calculations to determine where objects move,
            #what happens when objects colli6de, etc.
            self.controller.update_game_status()

            #Clear the screen
            self.screen.fill(Drawer.white)

            #Draw everything
            self.controller.draw()

            pygame.display.flip()
            # Limit to 15 frames per second
            clock.tick(15)
Esempio n. 4
0
class Game:
    running = True

    def __init__(self, resolution):
        pygame.init()
        self.resolution = resolution
        self.screen = pygame.display.set_mode(resolution)
        pygame.display.set_caption("2DMaze Game")
        self.controller = Controller(resolution, self.screen)

    def main(self):
        clock = pygame.time.Clock()
        self.screen.fill(Drawer.white)
        while self.running:
            #handle the events
            should_quit = self.controller.handle_events()
            if should_quit:
                break
            #Run calculations to determine where objects move,
            #what happens when objects colli6de, etc.
            self.controller.update_game_status()

            #Clear the screen
            self.screen.fill(Drawer.white)

            #Draw everything
            self.controller.draw()

            pygame.display.flip()
            # Limit to 15 frames per second
            clock.tick(15)
Esempio n. 5
0
def main():
    """ Run the server """

    DB_URL = "sqlite:///todo.db"
    controller = Controller(DB_URL)
    controller.bootstrap()
    app = create_app(controller)
    waitress.serve(app, host='0.0.0.0', port=8080)
Esempio n. 6
0
 def __init__( self, settings ):
         self.window = settings[WINDOW]
         Controller.__init__( self, EditorScreen( self.window.screenDimensions, [self.window.brickZone, self.window.brickZoneDimensions] ) )
         self.type = EDITOR
         
         self.bricks = []
         self.mapper = MapBuilder( self.window.brickDimensions, [self.window.brickZone, self.window.brickZoneDimensions])
         self.mapper.newTemplate()
         self.score = EditorMode( "black", (self.window.screenDimensions[0]/2, SCORE_BUFFER/2), 0, self )
Esempio n. 7
0
def showUI():
    if chimera.nogui:
        tk.Tk().withdraw()
    global ui
    if not ui:
        ui = PropKaDialog()
    model = ViewModel(gui=ui)
    controller = Controller(gui=ui, model=model)
    ui.enter()
    controller.set_mvc()
Esempio n. 8
0
def showUI(*args, **kwargs):
    if chimera.nogui:
        tk.Tk().withdraw()
    ui = QMSetupDialog(*args, **kwargs)
    model = Model(gui=ui)
    controller = Controller(gui=ui, model=model)
    ui.enter()
Esempio n. 9
0
def showUI():
    if chimera.nogui:
        tk.Tk().withdraw()
    global ui
    if not ui:
        ui = PLIPInputDialog()
    _ = Controller(gui=ui)
    ui.enter()
Esempio n. 10
0
def showUI():
    if chimera.nogui:
        tk.Tk().withdraw()
    global ui
    if not ui:
        ui = PoPMuSiCExtension()
    model = Model(gui=ui)
    controller = Controller(gui=ui, model=model)
    ui.enter()
Esempio n. 11
0
def showUI(*args, **kwargs):
    if chimera.nogui:
        tk.Tk().withdraw()
    model = Model()
    global ui
    if not ui:
        ui = DummyDialog(*args, **kwargs)
    model.gui = ui
    controller = Controller(gui=ui, model=model)
    ui.enter()
Esempio n. 12
0
 def __init__( self, settings ): #display='main', dimensions=MENU_DIMENSIONS ):
         Controller.__init__( self, MenuScreen( settings[DIMENSIONS] ))
         self.type = MENU
         
         if len( settings ) == 3: self.scores = settings[SCORES]
         else: self.scores = None
         
         self.menuStack = []
         self.menuList = {'main':menu1, 'settings':menu2, 'scores':menu3}
         self.menu = Menu( settings[DISPLAY], self.menuList[ settings[DISPLAY] ] )
         self.screen.screen.blit( self.menu.image, MENU_POSITION )
         
         self.initGame = 0
         self.currentOption = 0
         self.onSubOption = False #Selecting a suboption? (As opposed to a main option)
         
         
         
         self.pointer = Pointer( "images/pointer.gif", self.menu.positionMap, self.currentOption )
         self.subPointer = Pointer( "images/subpointer.gif", self.menu.subPositionMap, self.currentOption, visible=False ) #change to "images/subpointer.gif"
         
         self.selected = None
Esempio n. 13
0
def showUI(callback=None, *args, **kwargs):
    """
    Requested by Chimera way-of-doing-things
    """
    if chimera.nogui:
        tk.Tk().withdraw()
    global ui
    if not ui:  # Edit this to reflect the name of the class!
        ui = MMSetupDialog(*args, **kwargs)
    model = Model(gui=ui)
    controller = Controller(gui=ui, model=model)
    ui.enter()
    if callback:
        ui.addCallback(callback)
Esempio n. 14
0
 def __init__(self, resolution):
     pygame.init()
     self.resolution = resolution
     self.screen = pygame.display.set_mode(resolution)
     pygame.display.set_caption("2DMaze Game")
     self.controller = Controller(resolution, self.screen)
Esempio n. 15
0
 def __init__(self, world, gravity=-9.81, name=None):
     assert isinstance(world, World)
     self._bodies = world.ground.iter_descendant_bodies
     self.gravity = float(gravity)
     Controller.__init__(self, name=name)
Esempio n. 16
0
 def Apply(self):
     self.controller = Controller(self)
     self.vibrations = self.controller.run()
Esempio n. 17
0
def main():
    db_url = "sqlite:///fos2.db"
    print("Connecting to {}".format(db_url))
    fos = Controller(db_url)
    fos.bootstrap()
    main_user_interface(fos)
Esempio n. 18
0
 def __init__(self, resolution):
     pygame.init()
     self.resolution = resolution
     self.screen = pygame.display.set_mode(resolution)
     pygame.display.set_caption("2DMaze Game")
     self.controller = Controller(resolution, self.screen)
Esempio n. 19
0
from core import Controller

controller = Controller()


def start():
    controller.autodiscover_modules()
    controller.start()


def stop():
    controller.stop()


if __name__ == '__main__':
    start()
Esempio n. 20
0
 def __init__(self, gravity=-9.81, name=None):
     self.gravity = float(gravity)
     Controller.__init__(self, name=name)
Esempio n. 21
0
 def load_controller(self):
     binary, dat = prefs.get_preferences()
     return Controller(gui=self, nciplot_binary=binary, nciplot_dat=dat)
Esempio n. 22
0
class NormalModesConfigDialog(TangramBaseDialog):

    buttons = ('Run', 'Close')
    help = "https://github.com/insilichem/tangram_normalmodes"
    VERSION = '0.0.1'
    VERSION_URL = "https://api.github.com/repos/insilichem/tangram_normalmodes/releases/latest"

    def __init__(self, parent=None, engine='prody', *args, **kwargs):
        # GUI init
        self.title = 'Calculate Normal Modes with ' + engine.title()
        self.parent = parent
        self.engine = engine

        if engine == 'prody':
            self.fill_in_ui = self._fillInUI_Prody
        else:
            self.fill_in_ui = self._fillInUI_Gaussian

        self.lennard_jones = False
        self.mass_weighted = False

        super(NormalModesConfigDialog, self).__init__(resizable=False,
                                                      *args,
                                                      **kwargs)

    def _fillInUI_Prody(self, parent):
        #
        # Algorithm selection
        #
        self.canvas.columnconfigure(1, weight=1)
        row = 0
        self.ui_algorithms_menu_lbl = tk.Label(self.canvas,
                                               text='Algorithm:',
                                               anchor='e')
        self.ui_algorithms_menu = Pmw.OptionMenu(
            self.canvas,
            items=[
                'Full atom', 'Extend from C-alpha', 'Group by residues',
                'Group by mass', 'Group by graph'
            ],
            command=self._algorithms_menu_cb)

        self.ui_algorithms_param = Pmw.EntryField(self.canvas,
                                                  entry_width=3,
                                                  validate={
                                                      'validator': 'integer',
                                                      'min': 1
                                                  },
                                                  labelpos='w',
                                                  label_text='#:')
        self.ui_algorithms_param.setvalue(1)
        self.ui_algorithms_menu_lbl.grid(row=row,
                                         column=0,
                                         sticky='we',
                                         padx=3,
                                         pady=3)
        self.ui_algorithms_menu.grid(row=row,
                                     column=1,
                                     sticky='we',
                                     padx=3,
                                     pady=3,
                                     columnspan=2)

        #
        # Number of modes & Molecule Minimization
        #
        row += 1
        self.ui_n_modes_lbl = tk.Label(self.canvas,
                                       text='# Modes:',
                                       anchor='e')
        self.ui_n_modes = Pmw.EntryField(self.canvas,
                                         entry_width=3,
                                         validate={
                                             'validator': 'integer',
                                             'min': 1
                                         })
        self.ui_n_modes.setvalue(20)
        self.ui_n_modes_lbl.grid(column=0,
                                 row=row,
                                 sticky='we',
                                 padx=3,
                                 pady=3)
        self.ui_n_modes.grid(column=1, row=row, sticky='news', padx=3)
        self.ui_minimize_btn = tk.Button(
            self.canvas,
            text="Minimize",
        )  #command=lambda: chimera.dialogs.display(mmmdDialog.name))
        self.ui_minimize_btn.grid(column=2,
                                  row=row,
                                  sticky='we',
                                  padx=3,
                                  pady=3)

        #
        # Cutoff
        #
        row += 1
        self.ui_cutoff_lbl = tk.Label(self.canvas, text='Cutoff:', anchor='e')
        self.ui_cutoff = Pmw.EntryField(self.canvas,
                                        entry_width=3,
                                        validate={
                                            'validator': 'real',
                                            'min': 4.0
                                        })
        self.ui_cutoff.setvalue(15.0)
        self.ui_cutoff_lbl.grid(column=0, row=row, sticky='we', padx=3, pady=3)
        self.ui_cutoff.grid(column=1, row=row, sticky='news', padx=3)

        #
        # Cutoff
        #
        row += 1
        self.ui_gamma_lbl = tk.Label(self.canvas, text='Gamma LJ:', anchor='e')
        self.ui_gamma = Pmw.EntryField(self.canvas,
                                       entry_width=3,
                                       validate={
                                           'validator': 'real',
                                           'min': 0.0
                                       })
        self.ui_gamma.setvalue(1.0)
        self.ui_gamma_lbl.grid(column=0, row=row, sticky='we', padx=3, pady=3)
        self.ui_gamma.grid(column=1, row=row, sticky='news', padx=3)
        #
        # Optional Selections: Lennard-Jones and mass-weighted hessian
        #
        row += 1
        self.ui_extra_options = Pmw.Group(self.canvas, tag_text='Options')
        self.ui_extra_options.grid(column=0,
                                   row=row,
                                   columnspan=3,
                                   sticky='nsew',
                                   padx=5,
                                   pady=5)

        self.ui_extra_options_chk = Pmw.RadioSelect(
            self.ui_extra_options.interior(), buttontype='checkbutton')
        self.ui_extra_options_chk.add('Mass-Weighted')
        self.ui_extra_options_chk.grid(column=0, row=0, sticky='we')

        #
        # Model selection
        #
        row += 1
        self.ui_molecules_lbl = tk.Label(self.canvas,
                                         text="Select model:",
                                         anchor='e')
        self.ui_molecules_lbl.grid(column=0, row=row, padx=3)
        self.ui_molecules = MoleculeScrolledListBox(
            self.canvas, listbox_selectmode="single")
        self.ui_molecules.grid(column=1,
                               row=row,
                               columnspan=3,
                               sticky='nsew',
                               padx=3,
                               pady=3)

    def _fillInUI_Gaussian(self, parent):
        row = 0
        parent.columnconfigure(0, weight=1)
        self.ui_gaussian_grp = Pmw.Group(self.canvas,
                                         tag_text='Open Gaussian output file')
        self.ui_gaussian_grp.grid(column=0,
                                  row=row,
                                  columnspan=2,
                                  sticky='nsew',
                                  padx=5,
                                  pady=5)
        self.ui_gaussian_grp.columnconfigure(0, weight=1)
        self.ui_gaussian_grp.columnconfigure(1, weight=0)
        self.ui_gaussian_file_entry = Pmw.EntryField(
            self.ui_gaussian_grp.interior())
        self.ui_gaussian_file_entry.pack(side='left',
                                         expand=True,
                                         fill='both',
                                         padx=5,
                                         pady=5)

        self.ui_gaussian_btn = tk.Button(self.ui_gaussian_grp.interior(),
                                         text='...',
                                         command=self._load_file)
        self.ui_gaussian_btn.pack(side='right', padx=5, pady=5)

    def Apply(self):
        self.controller = Controller(self)
        self.vibrations = self.controller.run()

    def Run(self):
        self.Apply()
        self.Close()

    def _load_file(self, *a, **kw):
        path = askopenfilename()
        if path:
            self.ui_gaussian_file_entry.setvalue(path)

    def _algorithms_menu_cb(self, *a, **kw):
        value = self.ui_algorithms_menu.getvalue()
        if value.startswith('Group by'):
            self.ui_algorithms_param.grid(row=0, column=2, sticky='ew', padx=5)
            if value == 'Group by residues':
                self.ui_algorithms_param.configure(label_text='# residues:')
            elif value == 'Group by mass':
                self.ui_algorithms_param.configure(label_text='# groups:')
        else:
            self.ui_algorithms_param.grid_forget()