コード例 #1
0
ファイル: dungeon.py プロジェクト: 1160629/DoggoneWasteland
    def place(self):
        cox, coy = 13, 4
        cw, ch = 6, 6
        center_positions = []
        for x, y in product(range(cw), range(ch)):
            centerp = cox + x, coy + y
            center_positions.append(centerp)

        shuffle(center_positions)

        # place units
        assigned_positions = []

        room = self.room
        #print(sroom.grid_pos)
        gx, gy = room.grid_pos
        ox, oy = gx * self.rw, gy * self.rh
        for i in range(len(center_positions)):
            randw, randh = center_positions.pop(0)
            new_pos = ox + randw, oy + randh
            walkable = room.walkable_map[randw][randh]
            if walkable and (self.pos == (None, None)
                             or in_range(new_pos, self.pos, 3)):
                assigned_positions.append(new_pos)
                self.pos = assigned_positions[0]

        self.pos = assigned_positions.pop(0)
        self.available_spots = assigned_positions
コード例 #2
0
ファイル: ai.py プロジェクト: 1160629/DoggoneWasteland
def get_in_range_atks(unit, epos):
    ranges = []
    weps = []

    atkw = unit.attack_weapon
    unit.attack_weapon = None

    u_range = unit.get_range()

    weapons = unit.equipment.hand_one, unit.equipment.hand_two
    for w in weapons:
        if w == None:
            continue

        r = get_weapon_range(w) + u_range
        weps.append(w)
        ranges.append(r)

    can_swing_with = []
    for w, r in zip(weps, ranges):
        if w.weapon_class == "Brawler":
            real_range = one_tile_range
        else:
            real_range = r

        if in_range(unit.pos, epos, real_range):
            can_swing_with.append(w)

    unit.attack_weapon = atkw

    return can_swing_with
コード例 #3
0
ファイル: ai.py プロジェクト: 1160629/DoggoneWasteland
def get_units_list_at(units_, at):
    units = []
    for rad in range(1, 8):
        units.append([])
        for u in units_:
            if in_range(u.pos, at, rad):
                units[-1].append(u)

    return units
コード例 #4
0
ファイル: dungeon.py プロジェクト: 1160629/DoggoneWasteland
def should_be_open_tbt(self, lout, bx, by, roomx, roomy, ox, oy, tsw, tsh, m,
                       direction):
    if direction == "east":
        range_mod = 2
    else:
        range_mod = 2

    tw, th = self.tw, self.th

    cam = self.cam
    cx, cy = cam.get()
    # print(cx, cy)

    rw, rh = self.rw, self.rh

    rx = tw * roomx * rw
    ry = th * roomy * rh

    rsize = tw, th

    u = self.mc
    x, y = u.anim_pos
    rux, ruy = ox + x * tw, oy + y * th
    aox, aoy = 0, 0
    if (u.state == "attacking"
            and u.attack_weapon.attack_type == "melee") or u.dashing:
        aox, aoy = u.projectile_pos

    mc_pos = rux + aox + cx + tw / 2, ruy + aoy + cy + th / 2

    mpos = m

    mover = []
    inrange = []

    for dx, dy in product(range(tsw), range(tsh)):

        at = rx + (bx - ox + dx) * tw + cx, ry + (by - oy + dy) * th + cy
        # at = (bx+dx) * tw, (by+dy) * th
        # self.swin.blit(img, at)

        r = Rect(at, rsize)
        if r.collidepoint(mpos):
            mover.append(True)
        else:
            mover.append(False)
        if in_range(mc_pos, r.center, 3 + tw * range_mod):
            inrange.append(True)
        else:
            inrange.append(False)

    if any(inrange):  # and any(mover):
        return True
    else:
        return False
コード例 #5
0
ファイル: dungeon.py プロジェクト: 1160629/DoggoneWasteland
    def update(self, mc, mpos, mpress, ui, fighting):
        if fighting:
            return
        rad = 2
        if self.state == "closed":

            if in_range(mc.pos, self.pos, rad):
                self.loot_spawner = self.lootmgr.new_spawner(self.pos, self.available_spots, \
                self.rating, self.sound, self.weapons, use_cost = True, discount = self.discount)
                self.state = "opening"
                self.sound.play_sound_now("blahblah")
        elif self.state == "opening":

            if self.loot_spawner.done_spawning:
                self.state = "opened"
        elif self.state == "opened":
            if not in_range(mc.pos, self.pos, rad):
                if self.sound.is_sound_playing("blahblah"):
                    self.sound.stop_sound_now("blahblah")
            else:
                if not self.sound.is_sound_playing("blahblah"):
                    self.sound.play_sound_now("blahblah")
コード例 #6
0
ファイル: dungeon.py プロジェクト: 1160629/DoggoneWasteland
    def update(self, g_obj, mpos, mpress, ui):
        self.bubble_timer.update()

        if in_range(self.pos, g_obj.mc.pos, 2):
            if self.should_draw_bub == False:
                self.bubble_timer.reset()
                self.bubble_frame = 0
                self.should_draw_bub = True
        else:
            self.should_draw_bub = False

        if self.bubble_timer.ticked:
            self.bubble_timer.reset()
            self.bubble_frame += 1
            if self.bubble_frame >= len(self.bubbles_imgs.keys()):
                self.bubble_frame = 0
コード例 #7
0
ファイル: ai.py プロジェクト: 1160629/DoggoneWasteland
def get_in_range_abis(a_abis, unit, epos):
    abis = []

    atkw = unit.attack_weapon
    unit.attack_weapon = None

    u_range = unit.get_range()

    for a in unit.memory.get_abilities():
        r = a.ability_range + u_range
        if in_range(unit.pos, epos, r):
            abis.append(a)

    unit.attack_weapon = atkw

    #return abis
    return []
コード例 #8
0
ファイル: dungeon.py プロジェクト: 1160629/DoggoneWasteland
 def update(self, mc, mpos, mpress, ui, fighting):
     if fighting:
         return
     if self.state == "closed":
         self.frame = self.frames[self.rating]["closed"]
         rad = 2
         if in_range(mc.pos, self.pos, rad):
             self.loot_spawner = self.lootmgr.new_spawner(self.pos, self.available_spots, \
             self.rating, self.sound, self.weapons)
             self.state = "opening"
             self.sound.play_sound_now("chest open")
     elif self.state == "opening":
         self.frame = self.frames[self.rating]["spawning"]
         if self.loot_spawner.done_spawning:
             self.state = "opened"
     elif self.state == "opened":
         self.frame = self.frames[self.rating]["spawned"]
コード例 #9
0
def prerender_torch(g_obj, actual_intensity):
    t = 3, 3
    tw, th = g_obj.tw, g_obj.th

    new_surf = pygame.Surface((t[0] * 2 * tw, t[1] * 2 * th),
                              flags=pygame.HWSURFACE)
    new_surf.fill((0, 0, 0))
    new_surf.set_colorkey((0, 0, 0))

    td = 5

    wtr = td
    htr = td

    tcx, tcy = 2.5, 2.5

    color = 255, 200, 200

    for xtr, ytr in product(range(wtr), range(htr)):
        if not in_range((tcx, tcy), (xtr, ytr), int(td / 2)):
            continue
        dist = get_distance((tcx, tcy), (xtr, ytr))
        xt, yt = t[0] + (xtr) * tw, t[1] + (ytr) * th
        intensity = 0
        for i in range(4):
            if i > dist:
                break
            intensity += 1

        tintensity = (1 - actual_intensity * (intensity / 3)) * 0.7 + 0.3
        # print(tintensity)

        col = list(map(lambda x: x * tintensity, color))

        torch_img = g_obj.lighttile
        torch_img.fill(col)
        torch_img.set_alpha(255)

        new_surf.blit(torch_img, (xt, yt))
        # new_surf.set_alpha(actual_intensity)

    new_surf.set_alpha(80)

    return new_surf
コード例 #10
0
ファイル: ui.py プロジェクト: 1160629/DoggoneWasteland
def get_mouse_hover(g_obj, mpos):
    at_mouse = {}

    # map the mouse position to a tile
    # and see if it's inside the room
    mpos_mapped = map_mpos(g_obj, mpos)
    at_mouse["mapped"] = mpos_mapped

    at_mouse["room"] = get_room_at_mouse(g_obj, mpos_mapped)

    # get unit at the tile
    at_mouse["unit"] = None
    for u in g_obj.units:
        if u.pos == mpos_mapped:
            at_mouse["unit"] = u

    # create a list of units within various ranges
    # from the tile
    units = []
    for rad in range(1, 8):
        units.append([])
        for u in g_obj.units:
            if in_range(u.pos, mpos_mapped, rad):
                units[-1].append(u)

    at_mouse["units"] = units

    # get the tile index, from each layer
    # and whether it is walkable or not
    tiles, walkable = get_tiles_at_and_walkable(g_obj, at_mouse)

    # if there is a unit occupying the tile
    # then it is not walkable
    if at_mouse["unit"] != None:
        walkable = False

    at_mouse["tiles"] = tiles
    at_mouse["walkable"] = walkable

    at_mouse["loot"] = get_loot_at_mouse(g_obj, at_mouse)

    at_mouse["mouse ui item"] = get_mouse_ui_item(g_obj, at_mouse)

    return at_mouse
コード例 #11
0
ファイル: drawing.py プロジェクト: 1160629/DoggoneWasteland
def lighting_pass_old(g_obj):
    dung = g_obj.dungeon

    for room in dung.get_rooms():
        gx, gy = room.grid_pos

        tw, th = room.tilesets.tw, room.tilesets.th

        rw, rh = g_obj.rw, g_obj.rh
        raw, rah = rw * tw, rh * th

        rx, ry = gx * raw, gy * rah

        sw, sh = g_obj.w, g_obj.h

        buffer = max((2 * tw, 2 * th))
        screen_rect = Rect(-buffer, -buffer, sw + buffer * 2, sh + buffer * 2)

        ox, oy = g_obj.cam.get()

        room_rect = Rect(rx + ox, ry + oy, raw, rah)
        # print(room_rect.topleft)

        if not (screen_rect.colliderect(room_rect)):
            continue

        in_this_room = dung.get_room().room_id == room.room_id

        x, y = ox, oy
        nx, ny = 0, 0

        mw, mh = room.layout.w, room.layout.h

        tindx_x_l = [8, 9, 10, 11, 12, 13, 14, 15]
        tindx_y = 9

        torches = []

        for tx, ty, n in product(range(mw), range(mh),
                                 room.layout.layers.keys()):
            add_torch = False
            if n == "Torches":
                tile_index = room.layout.get_tile_index(n, tx, ty)
                if tile_index != None:  # transparent tile
                    tile = room.tilesets.get_tile(*tile_index)
                    tilex, tiley = tile_index[1:]
                    # print(tilex, tiley)
                    if tindx_y == tiley and tilex in tindx_x_l:
                        add_torch = True

            x, y = tx * tw + ox + rx, ty * th + oy + ry
            cr = Rect(x, y, tw, th)
            if not screen_rect.colliderect(cr):
                continue
            if not in_this_room:
                g_obj.swin.blit(g_obj.darktile, (x, y))

            if add_torch:
                torches.append((x, y))

        td = 6

        wtr = td
        htr = td

        tcx, tcy = 2.5, 2.5

        for t in torches:
            for xtr, ytr in product(range(wtr), range(htr)):
                if not in_range((tcx, tcy), (xtr, ytr), int(td / 2)):
                    continue
                dist = get_distance((tcx, tcy), (xtr, ytr))
                xt, yt = t[0] + (xtr - tcx) * tw, t[1] + (ytr - tcy) * th
                intensity = 0
                for i in range(3):
                    if i > dist:
                        break
                    intensity += 1
                tseed = (t[0], t[1])
                tintensity = g_obj.renderlogic.torches.get_torch_intensity(
                    tseed)
                g_obj.lighttile.set_alpha(
                    int((60 - intensity * 20) * tintensity))
                g_obj.swin.blit(g_obj.lighttile, (xt, yt))
コード例 #12
0
ファイル: ai.py プロジェクト: 1160629/DoggoneWasteland
    def action(self, c_ap, c_hp_self, m_hp_self, c_pos_enemy, c_hp_enemy,
               u_state, c_state, l_action, c_type):
        if u_state in ("dying", "dead") or u_state != "idle":
            return "wait", c_state, {}

        flee_per = 0.3
        if c_hp_self / m_hp_self < flee_per:
            c_state = "fleeing"
        else:
            pass

        if c_ap < 1 and c_state != "fleeing":
            return "pass", c_state, {}

        if c_state == "fleeing":
            available_abis = get_available_abis(
                self.unit, c_ap,
                ["heal", "buff"])  # returns a list of cast-able abilities
            if len(available_abis) == 0:
                return "walk", c_state, {"walk_command": "away_from_enemy"}
            else:
                abi_choice = choice(available_abis)
                return "cast", c_state, {"cast_ability": abi_choice}
            pass  # check if we have heal/buff available, then go into that state
            # otherwise stay in this state and keep running away.

        elif c_state == "idling":
            if in_range(self.unit.pos, c_pos_enemy, self.spot_range):
                c_state = "approaching"
                return "wait", c_state, {}
            else:
                return "pass", c_state, {}
            pass  # check if enemy is within range, if so- go out of idle state.

        elif c_state == "approaching":
            cur_max_range_self = get_max_range_of(self.unit)
            if in_range(self.unit.pos, c_pos_enemy, cur_max_range_self):
                c_state = "attacking"
                return "wait", c_state, {}
            else:
                return "walk", c_state, {"walk_command": "toward_enemy"}
            pass  # if you're too far away from enemy to attack - approach; walk toward
            # otherwise; go into attack state.

        elif c_state == "kiting":
            pass  # if you're ranged and your range is greater than the enemies, then
            # move a little back, otherwise go into a state of attacking.

        elif c_state == "attacking":
            available_abis = get_available_abis(self.unit, c_ap,
                                                ["ranged", "melee"])
            in_range_abis = get_in_range_abis(available_abis, self.unit,
                                              c_pos_enemy)
            in_range_attacks = get_in_range_atks(self.unit, c_pos_enemy)

            if len(in_range_abis) != 0 and False:  # ignore abilites for now
                use_abi = choice(in_range_abis)
                return "cast", c_state, {"use_ability": use_abi}
            elif len(in_range_attacks) != 0:
                use_weapon = choice(in_range_attacks)
                return "smack", c_state, {"use_weapon": use_weapon}
            else:
                c_state = "approaching"
                return "wait", c_state, {}
            pass  # here we can use a ranged or melee ability, or ranged or melee basic attack.

        return "wait", c_state, {}
コード例 #13
0
ファイル: dungeon.py プロジェクト: 1160629/DoggoneWasteland
 def close_to_bed(self, g_obj, mpos):
     return in_range(self.pos, g_obj.mc.pos, 2)