Example #1
0
def generate_geometry(surface, space):
    for s in space.shapes:
        if hasattr(s, 'generated') and s.generated:
            space.remove(s)

    def sample_func(point):
        try:
            p = int(point.x), int(point.y)
            color = surface.get_at(p)
            return color.hsla[2]  # use lightness
        except:
            return 0

    line_set = pymunk.autogeometry.PolylineSet()

    def segment_func(v0, v1):
        line_set.collect_segment(v0, v1)

    pymunk.autogeometry.march_soft(BB(0, 0, 599, 599), 60, 60, 90,
                                   segment_func, sample_func)

    for polyline in line_set:
        line = pymunk.autogeometry.simplify_curves(polyline, 1.)

        for i in range(len(line) - 1):
            p1 = line[i]
            p2 = line[i + 1]
            shape = pymunk.Segment(space.static_body, p1, p2, 1)
            shape.friction = .5
            shape.color = pygame.color.THECOLORS['red']
            shape.generated = True
            space.add(shape)
Example #2
0
def generate_geometry(surface, space):
    for s in space.shapes:
        if hasattr(s, "generated") and s.generated:
            space.remove(s)

    def sample_func(point):
        try:
            p = int(point.x), int(point.y)
            color = surface.get_at(p)
            return color.hsla[2] # use lightness
        except:
            return 0 

    line_set = pymunk.autogeometry.PolylineSet()
    def segment_func(v0, v1):
        line_set.collect_segment(v0, v1)
    
    pymunk.autogeometry.march_soft(
        BB(0,0,xSize - 1,ySize - 1), 250, 250, 92, segment_func, sample_func) #generateBounding

    for polyline in line_set:
        line = pymunk.autogeometry.simplify_curves(polyline, 0.8)
        for i in range(len(line)-1):
            p1 = line[i]
            p2 = line[i+1]
            shape = pymunk.Segment(space.static_body, p1, p2, 2)
            shape.friction = 10
            shape.color = THECOLORS["grey"]
            shape.generated = True
            shape.collision_type = COLLTYPE_TERRAIN
            space.add(shape) 
def handleInputs(events):
    global activeWeapon
    try:
        actors[aID[0]][aID[1]].handleActive()
    except:
        pass
    for event in events:
        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and not (
                pygame.key.get_mods() & KMOD_CTRL):
            actors[aID[0]][aID[1]].shoot()

        elif event.type == KEYDOWN and event.key == K_TAB:
            nextActor()

        elif event.type == KEYDOWN and event.key == K_q:
            nextTeam()

        elif event.type == KEYDOWN and event.key == K_k:
            createActor(pygame.mouse.get_pos(), 0)

        elif event.type == KEYDOWN and event.key == K_l:
            createActor(pygame.mouse.get_pos(), 1)

        elif event.type == pygame.MOUSEBUTTONUP and event.button == 1 and (
                pygame.key.get_mods() & KMOD_CTRL):
            update_geometry(terrain_surface, space,
                            BB(0, 0, xSize - 1, ySize - 1))

        elif event.type == KEYDOWN and event.key in weaponsDict:
            activeWeapon = weaponsDict[event.key]

    if pygame.mouse.get_pressed()[0] and (pygame.key.get_mods() & KMOD_CTRL):
        color = THECOLORS["green"]
        pos = pygame.mouse.get_pos()
        pygame.draw.circle(terrain_surface, color, pos, 20)
Example #4
0
    def generate_geometry(self,surface, space):
        for s in space.shapes:
            if hasattr(s, "generated") and s.generated:
                space.remove(s)

        def sample_func(point):
            try:
                p = int(point.x), int(point.y)
                color = surface.get_at(p)
                return color.hsla[2] # use lightness
            except:
                return 0

        line_set = pymunk.autogeometry.PolylineSet()
        def segment_func(v0, v1):
            line_set.collect_segment(v0, v1)

        pymunk.autogeometry.march_soft(BB(0,0,1280,960), 60, 60, 80, segment_func, sample_func)
        filter = pymunk.ShapeFilter(categories=0x2)
        for polyline in line_set:
            line = pymunk.autogeometry.simplify_curves(polyline, 1.)
            for i in range(len(line)-1):
                p1 = line[i]
                p2 = line[i+1]
                shape = pymunk.Segment(space.static_body, p1, p2, 5)
                shape.friction = 1
                shape.elasticity =1
                shape.color = pygame.color.THECOLORS["black"]
                shape.filter = filter
                shape.generated = True
                space.add(shape)
 def explode(self):
     self.exploded = True
     position = self._get_body()._get_position()
     expl = Explosion(position, self.explosionSize)
     all_sprites.add(expl)
     pygame.draw.circle(
         terrain_surface, THECOLORS["white"],
         [int(position[0]), int(position[1])], self.explosionSize)
     update_geometry(
         terrain_surface, space,
         BB(position[0] - self.explosionSize * 4,
            position[1] - self.explosionSize * 4,
            position[0] + self.explosionSize * 4,
            position[1] + self.explosionSize * 4))
     if self in bombs:
         bombs.remove(self)
     if (self.cluster):
         self.clusterSpawn()
     try:
         space.remove(self.body, self)
     except:
         pass
     for t in actors:
         for a in t:
             a.modHP(-clip(
                 int(self.explosionSize * 200000.0 / (clip(
                     a.getDistance(position) - self.explosionSize /
                     1.5, 1, 200000))**4), 0, self.explosionSize * 2.5))
    def shoot(self):
        global turnRemaining
        mouseOffset = pygame.mouse.get_pos() - self.getPosition()
        mouseVector = unitVector(mouseOffset)
        if activeWeapon != 4:
            turnRemaining = min(turnRemaining, 4)
        if activeWeapon == 1 and self.shot == 0:
            velocity = mouseVector * clip(
                self.getDistance(pygame.mouse.get_pos()), 0, 350) * 3
            body = makeMissileR(self.getPosition(), 20, 4, velocity)
        elif activeWeapon == 2 and self.shot == 0:
            velocity = mouseVector * 800
            body = makeGrenadeR(self.getPosition() - [0, 2], 50, 5, 5,
                                velocity)
        elif activeWeapon == 3 and self.shot == 0:
            velocity = mouseVector * 500
            body = makeGrenadeR(self.getPosition() - [0, 2], 20, 2, 5,
                                velocity, True)
        elif activeWeapon == 4 and self.shot < 15:
            torchPos = self.getPosition() + mouseVector * 10
            pygame.draw.circle(
                terrain_surface, THECOLORS["white"],
                [int(torchPos[0]), int(torchPos[1])], 15)
            update_geometry(
                terrain_surface, space,
                BB(torchPos[0] - 50, torchPos[1] - 50, torchPos[0] + 50,
                   torchPos[1] + 50))

        self.shot += 1
Example #7
0
    def generate(self):
        def segment_func(v0, v1):
            line_set.collect_segment(v0, v1)

        def sample_func(point):
            try:
                p = round(point.x), round(point.y)
                color = self.__track.get_at(p)
                return 255 if color == self.__track_color else 0
            except:
                return 0

        self.__window.instant_message("Generating Track...", (1100, 200), "white")
        for s in self.__window.space.shapes:
            if hasattr(s, "generated") and s.generated:
                self.__window.space.remove(s)
        line_set = pymunk.autogeometry.PolylineSet()
        pymunk.autogeometry.march_soft(
            BB(0, 0, self.__window.width - 1, self.__window.height - 1),
            self.__window.width // 4, self.__window.height // 4, 1, segment_func, sample_func)
        for polyline in line_set:
            line = pymunk.autogeometry.simplify_curves(polyline, 1)
            for i in range(len(line) - 1):
                p1 = line[i]
                p2 = line[i + 1]
                shape = pymunk.Segment(self.__window.space.static_body, p1, p2, 0)
                shape.color = pygame.color.THECOLORS["black"]
                shape.generated = True
                self.__window.space.add(shape)
Example #8
0
def generate_geometry(surface, space):
    for s in space.shapes:
        if hasattr(s, "generated") and s.generated:
            space.remove(s)

    def sample_func(point):
        try:
            p = int(point[0]), int(point[1])
            color = surface.get_at(p)
            return color.hsla[2]  # use lightness
        except Exception as e:
            print(e)
            return 0

    line_set = pymunk.autogeometry.march_soft(
        BB(0, 0, 599, 599), 60, 60, 90, sample_func
    )

    for polyline in line_set:
        line = pymunk.autogeometry.simplify_curves(polyline, 1.0)

        for i in range(len(line) - 1):
            p1 = line[i]
            p2 = line[i + 1]
            shape = pymunk.Segment(space.static_body, p1, p2, 1)
            shape.friction = 0.5
            shape.color = pygame.Color("red")
            shape.generated = True
            space.add(shape)
def generateTerrain():
    color = THECOLORS["green"]
    terrain_surface.fill(THECOLORS["white"])
    pygame.draw.line(terrain_surface, color, (0, ySize - 10),
                     (xSize, ySize - 10), 20)
    pygame.draw.line(terrain_surface, color, (0, 0), (0, ySize), 5)
    pygame.draw.line(terrain_surface, color, (xSize, 0), (xSize, ySize), 5)
    for i in range(random.randint(3, 5)):
        cSize = random.randint(7, 15)
        coords = [
            random.randint(0, xSize),
            random.randint(ySize / 3, ySize * 2 / 5)
        ]
        while coords[1] < ySize + 100:
            pygame.draw.circle(terrain_surface, color, coords, cSize)
            coords = [
                coords[0] + random.randint(int(-xSize / 16), int(xSize / 16)),
                coords[1] + random.randint(cSize // 4, cSize // 2)
            ]
            cSize += random.randint(1, 3)
    for i in range(random.randint(6, 10)):
        cSize = random.randint(4, 10)
        coords = [
            random.randint(0, xSize),
            random.randint(ySize * 2 / 3, ySize)
        ]
        while coords[1] < ySize + 100:
            pygame.draw.circle(terrain_surface, color, coords, cSize)
            coords = [
                coords[0] + random.randint(int(-xSize / 16), int(xSize / 16)),
                coords[1] + random.randint(cSize // 2, cSize)
            ]
            cSize += random.randint(2, 5)
    for i in range(random.randint(50, 70)):
        cSize = random.randint(8, 13)
        coords = [
            random.randint(0, xSize),
            random.randint(ySize * 7 / 8, ySize)
        ]
        while coords[1] < ySize + 100:
            pygame.draw.circle(terrain_surface, color, coords, cSize)
            coords = [
                coords[0] + random.randint(int(-xSize / 16), int(xSize / 16)),
                coords[1] + random.randint(cSize // 2, cSize)
            ]
            cSize += random.randint(3, 5)
    update_geometry(terrain_surface, space, BB(0, 0, xSize - 1, ySize - 1))
Example #10
0
	def load(self):
		self.world_size = Size(3000, 3000)

		self.camera = Camera(self.size, self.world_size, 1000, 10)

		self._tool = None
		self.tool = None

		self.batch = graphics.Batch()
		self.background = CameraGroup(graphics.OrderedGroup(0), self.camera)
		self.foreground = CameraGroup(graphics.OrderedGroup(1), self.camera)
		self.playerg = CameraGroup(graphics.OrderedGroup(2), self.camera)
		self.world_ui = CameraGroup(graphics.OrderedGroup(3), self.camera)
		self.ui = graphics.OrderedGroup(2)

		self.space = Space()
		self.space.gravity = (0.0, 0.0)
		buffer = 100
		borders = Body()
		borders.position = (0, 0)
		left = Segment(borders, (-buffer, -buffer), (-buffer, self.world_size.height+buffer), buffer)
		bottom = Segment(borders, (-buffer, -buffer), (self.world_size.width+buffer, -buffer), buffer)
		right = Segment(borders, (self.world_size.width+buffer, self.world_size.height+buffer),
			(self.world_size.width+buffer, -buffer), buffer)
		top = Segment(borders, (self.world_size.width+buffer, self.world_size.height+buffer),
			(-buffer, self.world_size.height+buffer), buffer)
		self.space.add_static(left, bottom, right, top)

		self.stars = Stars(self.world_size, self.batch, self.background)

		self.asteroids = Asteroid.populate(50, 100, self.world_size, self.batch, self.foreground, self.space)

		if not self.asteroids:
			print("None of a particular resource on this asteroid belt, that'd be unfair. Trying again.")
			self.end(Main())
			return

		self.home_world = choice([asteroid for asteroid in self.asteroids if asteroid.position.y > self.world_size.height/4*3])
		self.home_world.type = "home"
		self.home_world.populated = True

		x, y = self.home_world.position
		self.camera.move(Vector(x-self.size.width/2, y-self.size.height/2))

		# Let's make stuff a bit more interesting.
		for asteroid in self.asteroids:
			if not asteroid.type == "home":
				asteroid.body.apply_impulse((triangular(-20000, 20000, 0), triangular(-20000, 20000, 0)))

		x, y = self.home_world.position
		self.player = Person(x+150, y+150, self.batch, self.playerg, self.space)
		self.mouse = x+150, y+150

		centre = Vector(self.size.width/2, self.size.height/2)
		image = centre_image(resource.image("logo.png"))
		self.logo = sprite.Sprite(image, centre.x, centre.y, batch=self.batch, group=self.ui)
		self.logo.opacity = 255
		self.fade = True
		self.faded = False

		planet = centre_image(resource.image("planet.png"))
		x = self.world_size.width/2
		y = planet.height/2
		self.planet_sprite = sprite.Sprite(planet, x, y, batch=self.batch, group=self.world_ui)
		self.win_box = BB(x-200, y-200, x+200, y+200)

		#self.tools = sorted([tool(self.space) for tool in Tool.__subclasses__()], key=attrgetter("order"), reverse=True)
		#self.buttons = {tool: Button(30, 30+number*50, tool.image, tool.description, self.use_tool(tool), self.ui, self.batch) for number, tool in enumerate(self.tools)}

		self.constraints = set()
Example #11
0
class Main(Scene):

	FADE_SPEED = 75

	def load(self):
		self.world_size = Size(3000, 3000)

		self.camera = Camera(self.size, self.world_size, 1000, 10)

		self._tool = None
		self.tool = None

		self.batch = graphics.Batch()
		self.background = CameraGroup(graphics.OrderedGroup(0), self.camera)
		self.foreground = CameraGroup(graphics.OrderedGroup(1), self.camera)
		self.playerg = CameraGroup(graphics.OrderedGroup(2), self.camera)
		self.world_ui = CameraGroup(graphics.OrderedGroup(3), self.camera)
		self.ui = graphics.OrderedGroup(2)

		self.space = Space()
		self.space.gravity = (0.0, 0.0)
		buffer = 100
		borders = Body()
		borders.position = (0, 0)
		left = Segment(borders, (-buffer, -buffer), (-buffer, self.world_size.height+buffer), buffer)
		bottom = Segment(borders, (-buffer, -buffer), (self.world_size.width+buffer, -buffer), buffer)
		right = Segment(borders, (self.world_size.width+buffer, self.world_size.height+buffer),
			(self.world_size.width+buffer, -buffer), buffer)
		top = Segment(borders, (self.world_size.width+buffer, self.world_size.height+buffer),
			(-buffer, self.world_size.height+buffer), buffer)
		self.space.add_static(left, bottom, right, top)

		self.stars = Stars(self.world_size, self.batch, self.background)

		self.asteroids = Asteroid.populate(50, 100, self.world_size, self.batch, self.foreground, self.space)

		if not self.asteroids:
			print("None of a particular resource on this asteroid belt, that'd be unfair. Trying again.")
			self.end(Main())
			return

		self.home_world = choice([asteroid for asteroid in self.asteroids if asteroid.position.y > self.world_size.height/4*3])
		self.home_world.type = "home"
		self.home_world.populated = True

		x, y = self.home_world.position
		self.camera.move(Vector(x-self.size.width/2, y-self.size.height/2))

		# Let's make stuff a bit more interesting.
		for asteroid in self.asteroids:
			if not asteroid.type == "home":
				asteroid.body.apply_impulse((triangular(-20000, 20000, 0), triangular(-20000, 20000, 0)))

		x, y = self.home_world.position
		self.player = Person(x+150, y+150, self.batch, self.playerg, self.space)
		self.mouse = x+150, y+150

		centre = Vector(self.size.width/2, self.size.height/2)
		image = centre_image(resource.image("logo.png"))
		self.logo = sprite.Sprite(image, centre.x, centre.y, batch=self.batch, group=self.ui)
		self.logo.opacity = 255
		self.fade = True
		self.faded = False

		planet = centre_image(resource.image("planet.png"))
		x = self.world_size.width/2
		y = planet.height/2
		self.planet_sprite = sprite.Sprite(planet, x, y, batch=self.batch, group=self.world_ui)
		self.win_box = BB(x-200, y-200, x+200, y+200)

		#self.tools = sorted([tool(self.space) for tool in Tool.__subclasses__()], key=attrgetter("order"), reverse=True)
		#self.buttons = {tool: Button(30, 30+number*50, tool.image, tool.description, self.use_tool(tool), self.ui, self.batch) for number, tool in enumerate(self.tools)}

		self.constraints = set()

	def use_tool(self, tool):
		"""For callback usage."""
		def f():
		  self.tool = tool
		return f

	@property
	def tool(self):
		return self._tool

	@tool.setter
	def tool(self, tool):
		if tool:
			if self._tool and not self._tool == tool:
				self._tool.end_selecting()
				self.buttons[self._tool].normal()
				self.window.set_mouse_cursor(self.window.get_system_mouse_cursor(self.window.CURSOR_DEFAULT))
				self.selecting = False
				self.selection = []
			self.window.set_mouse_cursor(self.window.get_system_mouse_cursor(self.window.CURSOR_CROSSHAIR))
			self.selecting = True
			self.buttons[tool].using()
		else:
			if self._tool:
				self._tool.end_selecting()
				self.buttons[self._tool].normal()
			self.window.set_mouse_cursor(self.window.get_system_mouse_cursor(self.window.CURSOR_DEFAULT))
			self.selecting = False
			self.selection = []
		self._tool = tool

	def key_pressed(self, symbol, modifiers):
		self.fade = True
		#self.camera.key_pressed(symbol)

	def key_released(self, symbol, modifiers):
		pass
		#self.camera.key_released(symbol)

	def mouse_pressed(self, x, y, key, modifiers):
		self.fade = True
		#for button in self.buttons.values():
		#	if button.point_over(x, y):
		#		button.callback()
		#		return
		if self.selecting:
			for asteroid in self.asteroids:
				clicked = self.camera.translate(x, y)
				if asteroid.point_over(*clicked):
					self.selection.append((asteroid, clicked))
					self.tool = self.tool.selection(self.selection, self.constraints)
					return
			self.tool = None
			return

	def mouse_motion(self, x, y, dx, dy):
		self.mouse = self.camera.translate(x, y)
		#for button in self.buttons.values():
	#		if button.point_over(x, y):
	#			button.on_mouse_over()
	#		else:
	#			button.on_mouse_leave()

	def mouse_drag(self, x, y, dx, dy, buttons, modifiers):
		if buttons & window.mouse.RIGHT:
			self.camera.mouse_dragged(dx, dy)

	def update(self, frame_time):
		self.constraints = {constraint for constraint in self.constraints if not constraint.update(self.batch, self.foreground)}
		if self.fade and not self.faded:
			self.logo.opacity -= Main.FADE_SPEED*frame_time
			if self.logo.opacity < 0:
				self.logo.opacity = 0
				del self.logo
				self.faded = True
		self.player.target = self.mouse
		self.player.update()
		x, y = self.player.body.position
		self.camera.x, self.camera.y = x-self.size.width/2, y-self.size.height/2
		self.camera.update(frame_time)
		self.space.step(1/60)
		if self.win_box.contains_vect(self.player.body.position):
			self.end(Win())

	def draw(self):
		self.batch.draw()