Ejemplo n.º 1
0
    def make_frozen_sprite(self, ship):
        outline_mask = pygame.mask.from_surface(ship.image, 127)
        surf = outline_mask.to_surface(setcolor=(*PICO_WHITE,255), unsetcolor=(0,0,0,0))      

        color_mask = pygame.mask.from_threshold(ship.image, (*PICO_GREEN,255), (2,2,2,255))
        surf2 = color_mask.to_surface(setcolor=(*PICO_BLUE,255), unsetcolor=(0,0,0,0))
        surf.blit(surf2,(0,0))
        s = SimpleSprite(ship.pos, surf)
        s.offset = (0.5,0.5)
        return s
Ejemplo n.º 2
0
    def start(self):
        self.group = pygame.sprite.LayeredDirty()
        self.game_group = pygame.sprite.LayeredDirty()
        self.ui_group = pygame.sprite.LayeredDirty()
        
        self.time = 0

        galaxy = self.game.run_info.get_current_level_galaxy()
        self.galaxy = galaxy
        alien_code = galaxy['alien']
        alien_obj = alien.ALIENS[alien_code]
        self.nametext = typewriter.Typewriter(alien_obj.title, "huge", V2(50, 31) + self.game.game_offset, multiline_width=500, center=False, time_offset = -1)
        self.group.add(self.nametext)
        self.group.add(typewriter.Typewriter("ALIEN FORCES", "big", V2(50, 15) + self.game.game_offset, PICO_LIGHTGRAY, multiline_width=300, center=False))
        self.loading_text = Text("Loading...", "small", V2(game.RES[0] - 70, 326) + self.game.game_offset, center=False)
        self.loading_text.offset = (0.5, 0)
        self.group.add(self.loading_text)

        self.portrait = SimpleSprite(V2(50, 65) + self.game.game_offset, "assets/%sgraphic.png" % alien_code)
        pygame.draw.rect(self.portrait.image, PICO_BLACK, (0,0,self.portrait.width, self.portrait.height), 1)
        self.group.add(self.portrait)
        self.portrait.pos = (0,-1000)
        #self.portrait.visible = False

        self.tips = []
        self.quote = None

        difficulty_width = 150
        difficulty_pos = V2(game.RES[0] / 2 - difficulty_width / 2, 175) + self.game.game_offset

        if galaxy['difficulty'] > 1:
            difficulty_pos = V2(game.RES[0] * 0.3 - difficulty_width / 2, 215) + self.game.game_offset       

        labels = ['Mining Rate', 'Attack Power', 'Tech Level']
        images = ['econ', 'attack', 'tech']
        elements = []
        for i in range(3):
            pos = difficulty_pos + V2(0, i * 20)
            t = Text(labels[i], "small", pos + V2(60, 0), PICO_ORANGE)
            t.offset = (1,0)
            self.group.add(t)
            t.visible = False
            elements.append(t)
            maxelem = 5
            if i == 2: maxelem = 3
            for z in range(maxelem):
                f = FrameSprite(pos + V2(70 + z * 14, -3), "assets/enemystrength-%s.png" % images[i], 11)
                if z >= DIFFICULTY_VALUES[galaxy['difficulty']][i]:
                    f.frame = 1
                else:
                    f.frame = 0
                self.group.add(f)
                f.visible = False
                elements.append(f)

        self.tips.append(elements)

        if galaxy['difficulty'] > 1:
            tw = 150
            if galaxy['difficulty'] < 3: i = 0
            elif galaxy['difficulty'] < 6: i = 1
            else: i = 2
            tip = alien_obj.tips[i]
            x = game.RES[0] * 0.7
            img = pygame.image.load(resource_path(tip[0]))
            s = SimpleSprite(V2(x, 165) + self.game.game_offset, img)
            s.offset = (0.5, 0)
            self.group.add(s)
            t = Text(tip[1], "small", V2(x - tw / 2, 240) + self.game.game_offset, multiline_width=tw, center=False)
            self.group.add(t)
            s.visible = False
            t.visible = False
            r = rectangle.Rectangle(V2(x - tw / 2, 169) + self.game.game_offset, (19, 11), PICO_YELLOW)
            t2 = Text("TIP", "small", V2(x - tw / 2 + 2, 171) + self.game.game_offset, PICO_BLACK)
            r.visible = False
            t2.visible = False
            self.group.add(r)
            self.group.add(t2)
            self.tips.append((r, t2))
            self.tips.append((s, t))
        else:
            self.quote = Text(alien_obj.get_quote(), "pixolde", V2(game.RES[0] / 2, 270) + self.game.game_offset, PICO_YELLOW, multiline_width=400)
            self.quote.offset = (0.5, 0)
            self.group.add(self.quote)
            self.quote.visible = False


        if galaxy['mods']:
            self.group.add(SimpleSprite(V2(61, 322) + self.game.game_offset, "assets/exclamation.png"))
            self.group.add(Text("DANGER", "small", V2(79, 320) + self.game.game_offset, PICO_YELLOW, multiline_width=400, center=False))
            self.group.add(Text(MOD_STRINGS[galaxy['mods'][0]], "small", V2(79, 330) + self.game.game_offset, PICO_WHITE, multiline_width=400, center=False))
            self.warnings = self.group.sprites()[-3:]
            for warning in self.warnings:
                warning.visible = False

        self.sm = Machine(UIEnabledState(self))
        self.game.load_in_thread(self.load_level, self.on_loaded_level)
Ejemplo n.º 3
0
    def start(self):
        self.time = 0
        self.game.save.set_run_state(self.game.run_info)
        self.game.save.save()

        self.background_group = pygame.sprite.Group()
        self.game_group = pygame.sprite.LayeredDirty()
        self.ui_group = pygame.sprite.LayeredDirty()
        self.display_group = pygame.sprite.LayeredDirty()
        self.tutorial_group = pygame.sprite.Group()

        if self.game.run_info.reward_list:
            rewards_width = len(self.game.run_info.reward_list) * 23 + 200
        else:
            rewards_width = 160

        self.background = starmapbackground.StarmapBackground(
            V2(0, 0), rewards_width)
        self.background_group.add(self.background)

        backtext = "BACK"
        if self.game.input_mode == "joystick": backtext = "[*circle*] BACK"
        self.back = button.Button(V2(5, 5),
                                  backtext,
                                  "big",
                                  self.on_back,
                                  color=PICO_WHITE)
        self.ui_group.add(self.back)

        run_path = self.game.run_info.path
        res = self.game.game_resolution

        self.grid = []
        self.nodes = []
        x = 30 + self.game.game_offset.x
        base_y = self.background.center_y / 2
        max_per_row = max([len(row) for row in self.game.run_info.data])
        for r, row in enumerate(self.game.run_info.data):
            self.grid.append([])
            for i, column in enumerate(row):
                scaling = 54 - (max_per_row * 8)
                y = base_y - scaling * (len(row) - 1) + (scaling * 2) * i
                obj = None
                reward = None
                if column['node_type'] == 'galaxy':
                    alien = ALIENS[column['alien']]
                    img = "assets/si-alien.png"
                    if column['mods']:
                        img = "assets/si-alien-mod.png"
                    if r == len(self.game.run_info.data) - 1:
                        img = "assets/si-signal.png"
                    obj = NodeSprite(self.game.run_info, (r, i), V2(x, y), img)
                    obj.offset = (0.5, 0.5)
                    rdx = 0
                    if len(column['rewards']) > 1:
                        rdx = -13
                    rewards = []
                    for rew in column['rewards']:
                        reward = FrameSprite(V2(x + 7 + rdx, y + 15),
                                             "assets/reward_icons.png", 23)
                        reward.frame = REWARD_ICONS_ORDER[rew]
                        reward.offset = (0.5, 0.5)
                        rdx += 16
                        rewards.append(reward)

                elif column['node_type'] == 'store':
                    obj = NodeSprite(self.game.run_info, (r, i), V2(x, y),
                                     "assets/si-shop.png")
                    obj.offset = (0.5, 0.5)

                self.grid[-1].append(obj)
                for j in column['links']:
                    p2 = obj.pos
                    p1 = self.grid[-2][j].pos
                    prev_obj = self.grid[-2][j]
                    path = StarPath(
                        p1, p2,
                        obj.is_travelled() and prev_obj.is_travelled(),
                        obj.is_pickable() and prev_obj.is_travelled())
                    self.game_group.add(path)
                if obj.is_travelled():
                    if r < len(run_path) - 1:
                        o = SimpleSprite(obj.pos, "assets/si-traveled.png")
                        o.offset = (0.5, 0.5)
                        self.game_group.add(o)
                else:
                    self.nodes.append(obj)
                    self.game_group.add(obj)
                    if rewards:
                        for reward in rewards:
                            self.ui_group.add(reward)

            x += 60

        p = self.grid[run_path[-1][0]][run_path[-1][1]].pos
        self.colonist = SimpleSprite(p, 'assets/si-player.png')
        self.colonist.offset = (0.5, 0.5)
        self.game_group.add(self.colonist)
        ry = self.background.center_y
        t1 = text.Text("Credits | [>%d]" % self.game.run_info.credits,
                       "small",
                       V2(res.x / 2 + rewards_width / 2 - 64, ry - 3),
                       PICO_DARKBLUE,
                       multiline_width=150)
        t1.offset = (1, 0)
        self.ui_group.add(t1)

        t2 = text.Text("O2 | [>%s]" %
                       helper.get_time_string(self.game.run_info.o2),
                       "small",
                       V2(res.x / 2 + rewards_width / 2 - 5, ry - 3),
                       PICO_DARKBLUE,
                       multiline_width=150)
        t2.offset = (1, 0)
        self.ui_group.add(t2)

        if self.game.run_info.reward_list:
            t3 = text.Text("Acquired |", "small",
                           V2(res.x / 2 - rewards_width / 2 + 8, ry - 3),
                           PICO_BLACK)
            self.ui_group.add(t3)
            rx = t3.x + 61
            for r in self.game.run_info.reward_list:
                reward = RewardWithBackground(V2(rx, ry + 1), r['name'])
                reward.offset = (0.5, 0.5)
                self.game_group.add(reward)
                rx += 23
        else:
            t1.offset = (0.5, 0)
            t1.x = res.x / 2 - 30
            t2.offset = (0.5, 0)
            t2.x = res.x / 2 + 30

        self.sm = states.Machine(StarMapState(self))