Exemplo n.º 1
0
def onMouseMotion(listenerFunction):
    def mouse_motion_handler(event, world):
        dx, dy = event.rel
        if dx != 0 or dy != 0:
            listenerFunction(world, event.pos[0], event.pos[1], dx, dy, event.buttons[0] == 1,
                             event.buttons[1] == 1, event.buttons[2] == 1)

    events.handler(pygame.MOUSEMOTION, mouse_motion_handler)
Exemplo n.º 2
0
 def initGraphics(self):
     if not self.graphicsInited:
         assert sdl2.SDL_Init(sdl2.SDL_INIT_EVERYTHING) == 0, "Could not init: %s" % sdl2.SDL_GetError()
         self.display.initialize()
         self.joyinfo.initialize()
         self.keys.initialize()
         events.handler(sdl2.SDL_QUIT, self.check_quit_event)
         events.handler(sdl2.SDL_KEYDOWN, self.check_quit_key)
         self.graphicsInited = True
Exemplo n.º 3
0
def onTimer(listenerFunction, interval):
    eventType = sdl2.SDL_RegisterEvents(1)
    assert eventType != 0xFFFFFFFF, "Out of timers!"

    def timer_handler(event, world):
        listenerFunction(world)

    def raw_callback(interval, param):
        event = sdl2.SDL_Event()
        event.type = eventType
        event.user = sdl2.SDL_UserEvent()
        assert sdl2.SDL_PushEvent(event) > 0, "Could not push event: %s" % sdl2.SDL_GetError()
        return interval

    events.handler(eventType, timer_handler)
    assert sdl2.SDL_AddTimer(interval, raw_callback, None) != 0, "Could not create timer: %s" % sdl2.SDL_GetError()
Exemplo n.º 4
0
    def onMessage(self, messageProtocolEntity):

        if messageProtocolEntity.getType() == 'text':
            self.onTextMessage(messageProtocolEntity)
            msgfunc = lambda body: (self.toLower(
                TextMessageProtocolEntity(body,
                                          to=messageProtocolEntity.getFrom())))
            self.toLower(messageProtocolEntity.ack()), self.toLower(
                messageProtocolEntity.ack(True))
            sender, gid = (messageProtocolEntity.getFrom(),
                           messageProtocolEntity.getParticipant())
            msgbody = messageProtocolEntity.getBody()
            #self.toLower(receipt)
            events.handler(sender, msgbody, gid, msgfunc)

        else:  # messageProtocolEntity.getType() == 'media':
            self.onMediaMessage(messageProtocolEntity)
            self.toLower(
                messageProtocolEntity.forward(messageProtocolEntity.getFrom()))
            self.toLower(messageProtocolEntity.ack())
            self.toLower(messageProtocolEntity.ack(True))
Exemplo n.º 5
0
def onWheelBackward(listenerFunction):
    def wheel_backward_handler(event, world):
        if event.button == 5:
            listenerFunction(world, event.pos[0], event.pos[1])

    events.handler(pygame.MOUSEBUTTONDOWN, wheel_backward_handler)
Exemplo n.º 6
0
def onMouseRelease(listenerFunction):
    def mouse_release_handler(event, world):
        if event.button <= 3:
            listenerFunction(world, event.pos[0], event.pos[1], event.button)

    events.handler(pygame.MOUSEBUTTONUP, mouse_release_handler)
Exemplo n.º 7
0
def onMousePress(listenerFunction):
    def mouse_press_handler(event, world):
        if event.button <= 3:
            listenerFunction(world, event.pos[0], event.pos[1], event.button)

    events.handler(pygame.MOUSEBUTTONDOWN, mouse_press_handler)
Exemplo n.º 8
0
def main():
	exp = 100
	level = 0
	levelCap = 100
	display = screen.Window(RESOLUTION, IMAGEFOLDER, FILES)
	player = organism.Player(display)


	seed()
	neutrals = []
	for i in range(0, 100):
		randomPosition = organism.Position(int(random()*2*display.width - display.width), int(random()*2*display.height - 11*display.height/12))
		randomModifier = 0.1 + 0.6*random()
		newSize = int(randomModifier*(display.width/16))
		positionValid = True
		if sqrt((player.position.x - randomPosition.x)**2 + (player.position.y - randomPosition.y)**2) <= player.size + newSize:
				positionValid = False
		for neutral in neutrals:
			if sqrt((neutral.position.x - randomPosition.x)**2 + (neutral.position.y - randomPosition.y)**2) <= neutral.size + newSize:
				positionValid = False
				break
		if positionValid:
			neutrals.append(organism.Neutral(display, randomModifier, newSize, randomPosition))
	
	gameState = [player, neutrals, display]
	frameCounter = -1
	flowPeriod = 0

	while True:
		if exp >= levelCap:
			level += 1
			display.levelUp(player, level)
			events.levelUp(level, gameState)
			levelCap += 2*levelCap
			exp = 0

		# ACCELERATION

		frameCounter += 1
		if frameCounter > flowPeriod:
			seed()
			flowPeriod = display.clock.get_fps()*(0.2 + 0.8*random())
			direction = int(round(4*random()-0.5))
			flowModifier = random()
			events.changeFlow(gameState, direction, flowModifier)
			frameCounter = 0

		events.handler('movement', gameState)
			
		# VELOCITY

		player.newVelocity()
		for neutral in neutrals:
			neutral.newVelocity()

		# POSITION

		player.checkCollisions(gameState)
		player.newPosition(gameState)
		for neutral in neutrals:
			neutral.checkCollisions(gameState)
			neutral.newPosition(gameState)


		display.terrain(player, neutrals, level)
		display.clock.tick(120)
Exemplo n.º 9
0
    def onGameControllerButtonRelease(self, listenerFunction):
        def joystick_button_release_handler(event, world):
            listenerFunction(world, event.joy, event.button + 1)

        events.handler(sdl2.SDL_JOYBUTTONUP, joystick_button_release_handler)
Exemplo n.º 10
0
    def onGameControllerButtonPress(self, listenerFunction):
        def joystick_button_press_handler(event, world):
            listenerFunction(world, event.joy, event.button + 1)

        events.handler(sdl2.SDL_JOYBUTTONDOWN, joystick_button_press_handler)
Exemplo n.º 11
0
    def onGameControllerDPad(self, listenerFunction):
        def dpad_motion_handler(event, world):
            dx, dy = self.convertHat(event.value)
            listenerFunction(world, event.joy, event.hat, dx, dy)

        events.handler(sdl2.SDL_JOYHATMOTION, dpad_motion_handler)
Exemplo n.º 12
0
    def onGameControllerStick(self, listenerFunction):
        def joystick_motion_handler(event, world):
            listenerFunction(world, event.joy, event.axis, self.convertRaw(event.value))

        events.handler(sdl2.SDL_JOYAXISMOTION, joystick_motion_handler)