コード例 #1
0
ファイル: stronghold.py プロジェクト: AFDudley/equanimity
 def _setup_default_defenders(self, element=None, name='Defenders'):
     """ TODO -- remove this -- its either a testing method,
     which should be in the tests, or a method for initializing fields
     with some units. """
     if self._defenders is not None:
         raise ValueError('Defenders already set up')
     if element is None:
         element = self.field.element
     s = Stone()
     s[element] = 4
     s[OPP[element]] = 0
     for o in ORTH[element]:
         s[o] = 2
     for n in xrange(8):
         self.silo.imbue(s.copy())
     wcomp = Stone().comp
     units = []
     for wep in WEP_LIST:
         unit = self.form_scient(element, s.comp)
         units.append(unit)
         w = self.form_weapon(element, wcomp, wep)
         self.name_unit(unit.uid, "Ms. " + wep)
         self.equip_scient(unit.uid, w.stronghold_pos)
     s = self.form_squad(unit_ids=[u.uid for u in units], name=name)
     self.defenders = s
     return s
コード例 #2
0
def max_comp(suit, kind='Scient'):
    """Returns the maximum composition of 'kind' of element 'suit'"""
    comp = Stone()
    if kind == 'Scient':
        comp[suit] = 255
        comp[OPP[suit]] = 0
        comp[ORTH[suit][0]] = comp[ORTH[suit][1]] = 127
        return comp
    if kind == 'Weapon':
        comp2 = Stone()
        comp2[suit] = comp[suit] = 63
        comp2[OPP[suit]] = comp[OPP[suit]] = 0
        comp2[ORTH[suit][0]] = comp[ORTH[suit][1]] = 0
        comp2[ORTH[suit][1]] = comp[ORTH[suit][0]] = 63
        return (comp, comp2)
    if kind == 'Nescient':
        comp2 = Stone()
        comp2[suit] = comp[suit] = 255
        comp2[OPP[suit]] = comp[OPP[suit]] = 0
        comp2[ORTH[suit][0]] = comp[ORTH[suit][1]] = 0
        comp2[ORTH[suit][1]] = comp[ORTH[suit][0]] = 254
        return (comp, comp2)
    if kind == 'Stone':
        for i in comp:
            comp[i] = 255
        return comp
コード例 #3
0
    def __init__(self, data=None, name=None, kind=None, element=None):
        self.val = 0
        self.free_spaces = 8
        self.name = name
        UserList.__init__(self)
        if data == None:
            # The code below creates 4 units of element with a comp
            # of (4,2,2,0). Each unit is equiped with a unique weapon.
            if kind == 'mins':
                if element != None:
                    s = Stone()
                    s[element] = 4
                    s[OPP[element]] = 0
                    for o in ORTH[element]:
                        s[o] = 2
                    for wep in WEP_LIST:
                        scient = Scient(element, s)
                        scient.equip(eval(wep)(element, Stone()))
                        scient.name = "Ms. " + wep
                        self.append(scient)
                else:
                    raise ("Kind requires element from %s." % ELEMENTS)
                if self.name == None:
                    self.name = element + " " + 'mins'
            return

        if isinstance(data, list):
            for x in data:
                self.append(x)
        else:
            self.append(data)
コード例 #4
0
ファイル: levels.py プロジェクト: MatthewGoff/CSC245
    def init_levels(self):
        level1 = Level()
        self.generate_ground(level1)
        for i in range(2, 8):
            level1.blocks.add(
                Crate((1200, self.window_height - 102 * i), (0, 0), 100, 100,
                      "crate"))
        level1.blocks.add(
            Stone((1500, self.window_height - 310), (0, 0), 200, 200, "stone"))
        level1.enemies.add(
            Sheep((1500, self.window_height - 400), (0, 0), 100, 100, "sheep"))

        level2 = Level()
        self.generate_ground(level2)
        level2.blocks.add(
            Crate((1200, self.window_height - 200), (0, 0), 100, 100, "crate"))
        level2.blocks.add(
            Stone((1300, self.window_height - 200), (0, 0), 100, 100, "stone"))
        level2.blocks.add(
            Ice((1400, self.window_height - 200), (0, 0), 100, 100, "Ice"))
        level2.enemies.add(
            Sheep((1500, self.window_height - 200), (0, 0), 100, 100, "sheep"))
        level2.enemies.add(
            Sheep((1000, self.window_height - 200), (0, 0), 100, 100, "sheep"))

        level3 = Level()
        self.generate_ground(level3)
        level3.enemies.add(Ice((400, 900), (0, 0), 100, 100, "Ice"))
        level3.enemies.add(Sheep((300, 900), (0, 0), 100, 100, "sheep"))

        self.levels = [level1, level2, level3]
コード例 #5
0
    def __init__(self,
                 element,
                 comp,
                 name=None,
                 weapon=None,
                 weapon_bonus=None,
                 location=None,
                 sex='female'):
        for orth in ORTH[element]:
            if comp[orth] > comp[element] / 2:
                raise ValueError("Scients' orthogonal elements cannot be \
                                  more than half the primary element's value.")
        Unit.__init__(self, element, comp, name, location, sex)
        self.move = 4
        self.weapon = weapon
        if weapon_bonus == None:
            self.weapon_bonus = Stone()
        else:
            self.weapon_bonus = weapon_bonus
        self.equip_limit = Stone({E: 1, F: 1, I: 1, W: 1})
        for i in self.equip_limit:
            self.equip_limit[i] = self.equip_limit[i] + self.comp[i] \
            + self.weapon_bonus[i]
        self.calcstats()

        #equiping weapons should be done someplace else.
        self.equip(self.weapon)
コード例 #6
0
 def test_board_setitem(self):
     board = self._get_empty_board()
     board_obj = Board(board, BOARD_DIM)
     board_obj[0][0] = Stone(BLACK_STONE)
     self.assertTrue(Stone(BLACK_STONE), board_obj[0][0])
     board_obj[0][0] = Stone(WHITE_STONE)
     self.assertTrue(Stone(WHITE_STONE), board_obj[0][0])
コード例 #7
0
ファイル: grid.py プロジェクト: AFDudley/equanimity
 def _update_comp_value(self):
     """ Sets self.comp to average of tiles' comps """
     c = Stone()
     for t in self.iter_tiles():
         for e, v in t.comp.iteritems():
             c[e] = v
     for e, v in c.iteritems():
         self.comp[e] = v / self.size
コード例 #8
0
def parse_move(arr):
    if isinstance(arr[1], str):
        return Stone(arr[0]).get_type(), arr[1]
    else:
        return Stone(arr[0]).get_type(), [
            str_to_point(arr[1][0]),
            [parse_board(board) for board in arr[1][1]]
        ]
コード例 #9
0
ファイル: units.py プロジェクト: AFDudley/equanimity
    def __init__(self, element, comp, name=None, weapon=None, sex='female',
                 facing=None, body=None):
        if body is None:
            body = {'head': None, 'left': None, 'right': None, 'tail': None}
        comp = Stone(comp)
        orth = comp.orth(element)
        if all(orth):
            raise ValueError("Nescients' cannot have values greater than zero "
                             "for both orthogonal elements.")
        for o in orth:
            if o > comp[element]:
                raise ValueError("Nescients' orthogonal value cannot exceed "
                                 "the primary element value.")

        super(Nescient, self).__init__(element, comp, name=name, sex=sex)
        # Set nescient type.
        if self.element == 'Earth':
            self.kind = 'p'
            if self.comp[F] == 0:
                self.type = 'Avalanche'  # AOE Full
            else:
                self.type = 'Magma'  # ranged Full

        elif self.element == 'Fire':
            self.kind = 'p'
            if self.comp[E] == 0:
                self.type = 'Firestorm'  # ranged DOT
                self.time = 3
            else:
                self.type = 'Forestfire'  # ranged Full

        elif self.element == 'Ice':
            self.kind = 'm'
            if self.comp[E] == 0:
                self.type = 'Icestorm'  # AOE DOT
                self.time = 3
            else:
                self.type = 'Permafrost'  # AOE Full
        else:  # Wind
            self.kind = 'm'
            self.time = 3
            if self.comp[F] == 0:
                self.type = 'Blizzard'  # AOE DOT
            else:
                self.type = 'Pyrocumulus'  # ranged DOT

        self.calcstats()
        for part in body:  # MESSY!!!!
            body[part] = Part(self)
        self.body = body
        self.facing = facing
        self.weapon = self  # hack for attack logic.
        # state machine first attempt
        self.afraid = False
        self.hungry = False
        self.in_season = False
        self.found_mate = False
        self.ready_to_mate = False
コード例 #10
0
ファイル: field.py プロジェクト: AFDudley/btpy
 def harvest_stones(self):
     """returns set of stones generated at harvest"""
     stones = Stone()
     for x in xrange(self.grid.x):
         for y in xrange(self.grid.y):
             for suit, value in self.grid[x][y].comp.iteritems():
                 stones[suit] += value
     for suit, value in stones.iteritems():
         stones[suit] /= 8 #8 seems like a good number... 
     return stones
コード例 #11
0
ファイル: field.py プロジェクト: AFDudley/btpy
 def harvest_stones(self):
     """returns set of stones generated at harvest"""
     stones = Stone()
     for x in xrange(self.grid.x):
         for y in xrange(self.grid.y):
             for suit, value in self.grid[x][y].comp.iteritems():
                 stones[suit] += value
     for suit, value in stones.iteritems():
         stones[suit] /= 8  #8 seems like a good number...
     return stones
コード例 #12
0
ファイル: field.py プロジェクト: AFDudley/equanimity
 def get_tile_comps(self):
     """returns a list of stones 1/8th the value of the tile comps."""
     stone_list = []
     for tile in self.grid.iter_tiles():
         stone = Stone()
         for suit, value in tile.comp.iteritems():
             stone[suit] += value / 8  # this 8 will need to be tweaked.
         if stone.value() != 0:
             stone_list += [stone]
     return stone_list
コード例 #13
0
def process_stone(frame_desc,
                  id,
                  contour,
                  src_img,
                  result_img,
                  save_stones=None):
    m = cv2.moments(contour)

    try:
        cx = int(m['m10'] / m['m00'])
        cy = int(m['m01'] / m['m00'])
    except:
        return None

    bbox = cv2.boundingRect(contour)

    ec, es, ea = cv2.minAreaRect(contour)
    ec = (int(ec[0]), int(ec[1]))
    es = (int(es[0]) / 2, int(es[1]) / 2)
    ea = int(ea)
    if es[1] > es[0]:
        es = es[1], es[0]
        ea += 90
    ea = ea % 180

    resy, resx, _ = src_img.shape
    if not preselect_stone((resx, resy), ec, es):
        return None

    cutout = src_img[bbox[1]:bbox[1] + bbox[3], bbox[0]:bbox[0] + bbox[2]]
    b, g, r = cv2.split(cutout)
    a = np.zeros_like(b, dtype=np.uint8)
    cv2.drawContours(a, [contour], 0, 255, -1, offset=(-bbox[0], -bbox[1]))
    cropped = cv2.merge((b, g, r, a))
    color = find_dominant_color(cropped)
    structure = lbp_histogram(cropped)

    if result_img is not None:
        dummy = np.array([np.array([color])])
        rgb_color = (cv2.cvtColor(dummy, cv2.COLOR_LAB2BGR)[0, 0]).tolist()
        cv2.drawContours(result_img, [contour], 0, rgb_color, -1)
        cv2.circle(result_img, ec, 4, (128, 0, 0))
        cv2.rectangle(result_img, (bbox[0], bbox[1]),
                      (bbox[0] + bbox[2], bbox[1] + bbox[3]), (255, 0, 0))
        cv2.ellipse(result_img, ec, es, ea, 0, 360, (0, 0, 255))

    ret = Stone(ec, es, ea, color, structure)

    if save_stones:
        cv2.imwrite(
            'stones/stone_{}_{:03d}.{}'.format(frame_desc, id, save_stones),
            cropped)
        ret.save('stones/stone_{}_{:03d}.data'.format(frame_desc, id))

    return ret
コード例 #14
0
ファイル: board.py プロジェクト: ieuan-jones/pytafl
 def addStone(self,side,pos,variant=NORMAL):
     stone = Stone(side,(pos[0]*34,pos[1]*34),variant)
     
     if side == ATTACKER:
         self.attack.append(stone)
     if side == DEFENDER:
         self.defense.append(stone)
def test_check_valid_move():
    WIDTH = 600
    stone = Stone(WIDTH)
    gc = GameController(WIDTH, stone)
    gc.counter = 2

    gc.stone.total_row[3][3].color = 0
    gc.stone.total_row[4][4].color = 0
    gc.stone.total_row[3][4].color = 1
    gc.stone.total_row[4][3].color = 1
    assert gc.check_valid_move(4, 2) is True
    assert gc.check_valid_move(5, 3) is True
    assert gc.check_valid_move(2, 4) is True
    assert gc.check_valid_move(3, 5) is True
    assert gc.check_valid_move(3, 4) is False
    assert gc.check_valid_move(2, 2) is False
    assert gc.check_valid_move(0, 0) is False
    assert gc.check_valid_move(7, 7) is False

    gc.counter = 1
    gc.stone.total_row[3][3].color = 0
    gc.stone.total_row[4][4].color = 0
    gc.stone.total_row[3][4].color = 1
    gc.stone.total_row[4][3].color = 1
    assert gc.check_valid_move(3, 2) is True
    assert gc.check_valid_move(4, 5) is True
    assert gc.check_valid_move(5, 4) is True
    assert gc.check_valid_move(2, 3) is True
    assert gc.check_valid_move(3, 4) is False
    assert gc.check_valid_move(2, 2) is False
    assert gc.check_valid_move(0, 0) is False
    assert gc.check_valid_move(7, 7) is False
コード例 #16
0
def enter():
    game_framework.reset_time()
    global map, player, house, background, avalanche, coin, snows, map_on_coins, game_over, santa, game_clear, distance, stones
    map = Map()
    player = Player()
    house = House()
    background = Background()
    avalanche = Avalanche()
    coin = Coin()
    game_over = Game_over()
    santa = Santa()
    game_clear = Game_clear()
    distance = Distance()
    map_on_coins = [Map_on_Coin() for i in range(200)]
    snows = [Snow() for i in range(20)]
    stones = [Stone() for i in range(10)]

    Player.x = 300.0
    Player.y = 300.0
    Player.unreal_x = 300.0
    Player.unreal_y = 0
    Player.jump_before_y = 0
    Map.map_move_y_minor = 0
    Avalanche.game_over = 0
    Game_clear.game_clear = 0
    Santa.game_clear = 0
コード例 #17
0
def run_game():
    #init游戏并创建一个窗口对象
    pygame.init()
    ai_settings=Settings()#创建Settings类的实例
    screen=pygame.display.set_mode((ai_settings.screen_width,ai_settings.screen_height))
    pygame.display.set_caption("地球保卫战 v1.0")

    #创建实例
    sscol=Group()
    stone=Stone(screen)
    stats=GameStats(ai_settings)
    bullets=Group()
    ship=Ship(ai_settings,screen)
    sscol.add(ship)
    aliens=Group()
    button=Button(ai_settings,screen,"Play")
    score=Score(ai_settings,screen,stats)

    
    while True:

        #帧数
        pygame.time.Clock().tick(120)
        #监视键盘和鼠标事件
        func.check_events(ai_settings,screen,ship,aliens,bullets,button,stats,score)

        #决定游戏是否开始
        if stats.game_status:
            ship.update()
            func.release_bullet(ai_settings,bullets,screen,aliens,stats,score)
            func.update_alien(ai_settings,screen,aliens,ship,stats,bullets,score,stone,sscol)
        
        
            #每次循环都重绘屏幕
        func.update_screen(ai_settings,screen,ship,bullets,aliens,stats,button,score,stone)
コード例 #18
0
ファイル: board.py プロジェクト: vipmath/psgo_emitter
 def toggle(self, colour):
     """Put or remove stone at cursor."""
     point = self._cursor.point
     if point in self._board:
         del self._board[point]
     else:
         self._board[point] = Stone(colour)
コード例 #19
0
def one_three_zeros(value):
    squad = Squad()
    for i in ELEMENTS:
        s = Stone()
        s[i] = value
        squad.append(Scient(i, s))
    return squad
コード例 #20
0
def t2c(tup):
    """Converts a tuple to a comp"""
    if len(tup) != 4: raise Exception("Incorrect number of values in tuple")
    comp = Stone()
    for i in range(4):
        comp[ELEMENTS[i]] = tup[i]
    return comp
コード例 #21
0
def rand_comp(suit=None, kind=None, max_v=255):
    """Returns a random comp in 'suit' for use instaniating 'kind'
       If 'suit' is not valid, random element used.
       If 'kind' is not valid stone is used
       if 'kind' is 'Stone' suit ignored"""
    if not suit in ELEMENTS:
        suit = rand_element()

    comp = Stone()
    if kind is None or kind not in KINDS:
        kind = 'Stone'

    if kind == 'Stone':
        for element in comp:
            comp[element] = random.randint(0, max_v)
        return comp
    else:
        if kind == 'Scient':
            comp[suit] = random.randint(1, max_v)
            for picked in ORTH[suit]:
                #NOTE: if comp[suit] = 1 orths will be 0.
                comp[picked] = random.randint(0, (comp[suit] / 2))
            return comp

        else:  #Nescient is currently the only other kind
            comp[suit] = random.randint(1, max_v)
            comp[random.choice(ORTH[suit])] = \
                random.randint(1, comp[suit])
            return comp
コード例 #22
0
ファイル: extract.py プロジェクト: fuzzthink/riverbed-vision
def process_stone(frame_desc, id, contour, src_img, result_img, save_stones=None):
    m = cv2.moments(contour)

    try:
        cx = int(m['m10'] / m['m00'])
        cy = int(m['m01'] / m['m00'])
    except:
        return None

    bbox = cv2.boundingRect(contour)

    ec, es, ea = cv2.minAreaRect(contour)
    ec = (int(ec[0]), int(ec[1]))
    es = (int(es[0]) / 2, int(es[1]) / 2)
    ea = int(ea)
    if es[1] > es[0]:
        es = es[1], es[0]
        ea += 90
    ea = ea % 180

    resy, resx, _ = src_img.shape
    if not preselect_stone((resx, resy), ec, es):
        return None

    cutout = src_img[bbox[1]:bbox[1] + bbox[3], bbox[0]:bbox[0]+ bbox[2]]
    b, g, r = cv2.split(cutout)
    a = np.zeros_like(b, dtype=np.uint8)
    cv2.drawContours(a, [contour], 0, 255, -1, offset=(-bbox[0], -bbox[1]))
    cropped = cv2.merge((b, g, r, a))
    color = find_dominant_color(cropped)
    structure = lbp_histogram(cropped)

    if result_img is not None:
        dummy = np.array([np.array([color])])
        rgb_color = (cv2.cvtColor(dummy, cv2.COLOR_LAB2BGR)[0, 0]).tolist()
        cv2.drawContours(result_img, [contour], 0, rgb_color, -1)
        cv2.circle(result_img, ec, 4, (128, 0, 0))
        cv2.rectangle(result_img, (bbox[0], bbox[1]), (bbox[0] + bbox[2], bbox[1] + bbox[3]), (255, 0, 0))
        cv2.ellipse(result_img, ec, es, ea, 0, 360, (0, 0, 255))

    ret = Stone(ec, es, ea, color, structure)

    if save_stones:
        cv2.imwrite('stones/stone_{}_{:03d}.{}'.format(frame_desc, id, save_stones), cropped)
        ret.save('stones/stone_{}_{:03d}.data'.format(frame_desc, id))

    return ret
コード例 #23
0
    def move(self, stones):
        num = 0
        i = 0
        j = 0

        if (len(stones[0]) == 0 and len(stones[1]) == 0):
            return self.grid.center()

        # Get last stone of opponent
        opponentLastStone = stones[1][-1]

        if opponentLastStone.x + 66 < self.grid.WIDTH:
            finalCoord = Coordinate(opponentLastStone.x + 66,
                                    opponentLastStone.y)
        else:
            finalCoord = Coordinate(opponentLastStone.x - 66,
                                    opponentLastStone.y)

        for i in range(0, len(self.coordList), self.JUMP):
            coord = self.coordList[i]

            x = opponentLastStone.x + coord.x
            y = opponentLastStone.y + coord.y

            if x < 0 or y < 0 or x > self.grid.WIDTH or y > self.grid.HEIGHT:
                continue

            currStone = Stone(x, y)
            flag = 0

            if not opponentLastStone.getFeasible(currStone):
                continue

            for l in range(0, 2):
                for stone in stones[l]:
                    if not stone.getFeasible(currStone):
                        flag = 1
                        break
                if flag == 1:
                    break

            if flag == 1:
                continue

            stones[0].append(currStone)

            self.grid.setColor(stones)

            ret = self.grid.getColorDist()

            stones[0].pop()

            if (ret[0] > num):
                num = ret[0]
                finalCoord = Coordinate(currStone.x, currStone.y)

        return finalCoord
def test_read_file():
    WIDTH = 600
    stone = Stone(WIDTH)
    gc = GameController(WIDTH, stone)

    assert gc.score_list == []
    # The default when scores.txt is blank

    gc.read_file('test_scores.txt')
    assert gc.score_list == [['Khai4', 22], ['Khai3', 20]]
def test_can_go():
    WIDTH = 600
    stone = Stone(WIDTH)
    gc = GameController(WIDTH, stone)
    gc.counter = 2
    gc.stone.total_row[3][3].color = 0  # 4 starting stones
    gc.stone.total_row[4][4].color = 0
    gc.stone.total_row[3][4].color = 1
    gc.stone.total_row[4][3].color = 1
    gc.can_go()
    assert len(gc.moves_list) == 4  # First move: 4 valids moves for player
コード例 #26
0
def load_map(file, move_keys, player_number):
    # Load map

    # Load background color
    f = open(path.join("levels", file + ".txt"), "r")
    data = f.read()
    f.close()
    data = data.split("\n")
    data[0] = data[0].split(",")
    color = data[0]
    tile_chars = {}
    data.pop(0)

    # Load tiles
    while "=" in data[0]:
        tile_chars[data[0][0]] = data[0].split("=")[1].split(",")
        data.pop(0)

    # Initialize objects
    tiles = []
    net = []
    walkers = []
    climbers = []
    stones = []
    players = []

    # Load objects
    y = 1
    for row in range(len(data)):
        x = -1
        for tile in range(len(data[row])):
            if data[row][tile] in tile_chars:
                tiles.append(
                    Tile(x, y, TILE_WIDTH, TILE_HEIGHT,
                         tile_chars[data[row][tile]]))
            elif data[row][tile] == "p" and len(players) < player_number:
                players.append(
                    Player(x, y, CHAR_WIDTH, CHAR_HEIGHT, 0,
                           move_keys[len(players)]))
            elif data[row][tile] == "w":
                walkers.append(Walker(x, y, CHAR_WIDTH, CHAR_HEIGHT, 0))
            elif data[row][tile] == "n":
                net.append(Net(x, y, TILE_WIDTH, TILE_HEIGHT, 6))
            elif data[row][tile] == "c":
                net.append(Net(x, y, TILE_WIDTH, TILE_HEIGHT, 6))
                climbers.append(Climber(x, y, CHAR_WIDTH, CHAR_HEIGHT, 0))
            elif data[row][tile] == "s":
                stones.append(Stone(x, y, TILE_WIDTH, TILE_HEIGHT, 7))
            x += TILE_WIDTH
        y -= TILE_HEIGHT

    # Return objects
    return tiles, net, stones, players, walkers, climbers, color
def test_is_corner():
    WIDTH = 600
    stone = Stone(WIDTH)
    gc = GameController(WIDTH, stone)
    assert gc.is_corner(0, 0) is True
    assert gc.is_corner(7, 7) is True
    assert gc.is_corner(0, 7) is True
    assert gc.is_corner(7, 0) is True
    assert gc.is_corner(1, 8) is None
    assert gc.is_corner(3, 4) is None
    assert gc.is_corner(2, 6) is None
    assert gc.is_corner(5, 5) is None
コード例 #28
0
    def __init__(self, color):
        self.xcoords = [800, 738, 676, 613, 550, 485, 373, 308, 247, 182, 121, 60, 60, 121, 182, 247, 308, 373, 485, 550, 613, 676, 738, 800]
        self.stones = []
        self.movableStones = set()
        self.color = color
        self.restrict = False
        self.victory = False
        #configuring initial positions of stones per game logic
        for i in range(2):
            newStone = Stone(self.color, 1)
            self.stones.append(newStone)

        for i in range(3):
            newStone = Stone(self.color, 17)
            self.stones.append(newStone)

        for i in range(5):
            newStone = Stone(self.color, 12)
            newStone2 = Stone(self.color, 19)
            self.stones.append(newStone)
            self.stones.append(newStone2)
def test_is_edge():
    WIDTH = 600
    stone = Stone(WIDTH)
    gc = GameController(WIDTH, stone)
    assert gc.is_edge(0, 8) is True
    assert gc.is_edge(3, 0) is True
    assert gc.is_edge(4, 7) is True
    assert gc.is_edge(7, 4) is True
    assert gc.is_edge(1, 8) is None
    assert gc.is_edge(3, 4) is None
    assert gc.is_edge(2, 6) is None
    assert gc.is_edge(5, 5) is None
コード例 #30
0
    def update(self, dt):
        # 读入NUM_SAMPLES个取样
        string_audio_data = self.stream.read(self.NUM_SAMPLES)
        k = max(struct.unpack('1000h', string_audio_data))
        # 平均音量
        if self.sample_count < 50:
            self.average_volume = (self.average_volume * self.sample_count +
                                   k) / (self.sample_count + 1)
            self.sample_count += 1
        else:
            self.sample_count = 0
            self.average_volume = 0
            self.average_volume = (self.average_volume * self.sample_count +
                                   k) / (self.sample_count + 1)
            self.sample_count += 1

        # print voice
        self.voiceBar.scale_x = self.average_volume / 10000.0
        if self.role_run_to_right:
            self.role.x += 4
            # self.floor.x -= 5
        if self.role_run_to_left:
            self.role.x -= 4
            # self.floor.x += 5
        if self.role.can_shot:
            if self.sample_count == 50 and self.average_volume > 4000:
                pos = self.role.x + self.role.width * 0.8, self.role.y + self.role.height * 0.6
                stone = Stone((self.average_volume - 3000) / 1000.0 + 1, pos,
                              self.role.direction)
                self.stone = stone
                self.add(stone)
                self.role.can_shot = False
        # if k > 3000:
        # self.floor.x -= min((k / 20.0), 150) * dt
        #  k > 8000:
        # self.role.jump((k - 8000) / 1000.0)

        # destination
        if (self.role.x + self.role.width / 2) >= self.floor.flag.x:
            time.sleep(0.5)
            self.end_game()
            self.role.pause_scheduler()
            return

        # spider trigger
        if self.role.x > self.floor.spider.x - 50:
            self.floor.spider.passed = True
        # collision
        self.role_collide()
        self.monster_collide_on_role()
        if not self.role.can_shot:
            self.stone_collide()
            self.monster_collide_on_stone()
def test_is_third_away():
    WIDTH = 600
    stone = Stone(WIDTH)
    gc = GameController(WIDTH, stone)
    assert gc.is_third_away(2, 2) is True
    assert gc.is_third_away(5, 1) is True
    assert gc.is_third_away(1, 2) is True
    assert gc.is_third_away(2, 5) is True
    assert gc.is_third_away(1, 8) is None
    assert gc.is_third_away(6, 4) is None
    assert gc.is_third_away(3, 3) is None
    assert gc.is_third_away(4, 4) is None
コード例 #32
0
    def move(self, position):
        reverse_stons = []
        # 石を打つ
        self.board[position.y][position.x] = Stone(self.turn.value)

        # 石をひっくり返す
        # 各方向に石をひっくり返せるか調べる
        for dx, dy in Board.DIRS:
            y = position.y + dy
            x = position.x + dx
            enemy = self.turn.invert()
            if self.in_board(x, y) \
                    and self.board[y][x] == enemy:
                # 隣が相手の石
                y += dy
                x += dx
                while self.in_board(x, y) \
                        and self.board[y][x] == enemy:
                    y += dy
                    x += dx
                if self.in_board(x, y) \
                        and self.board[y][x] == self.turn:
                    # この方向は返せる
                    # 1マス戻る
                    y -= dy
                    x -= dx
                    # 戻りながら返す
                    stons = []
                    while self.in_board(x, y) \
                            and self.board[y][x] == enemy:
                        self.board[y][x] = Stone(self.turn.value)
                        stons.append([x, y])
                        y -= dy
                        x -= dx

                    reverse_stons.append(stons)

        self.turn = self.turn.invert()  # 手番を変更
        self.move_num += 1              # 手数を増やす
        return reverse_stons
コード例 #33
0
ファイル: units.py プロジェクト: BrandTurner/btpy
    def __init__(self, element, comp, name=None, location=None, sex='female'):
        if not element in ELEMENTS:
            raise Exception("Invalid element: %s, valid elements are %s" \
            % (element, ELEMENTS))
        if comp[element] == 0:
            raise ValueError("Units' primary element must be greater than 0.")
        
        if comp[OPP[element]] != 0:
            raise ValueError("Units' opposite element must equal 0.")

        Stone.__init__(self, comp)
        self.element = element
        if name == None:
            self.name = self.__hash__()
        self.name = name
        self.location = location
        self.sex = sex
        self.DOB = datetime.utcnow()
        self.DOD = None
        self.val = self.value()
        def __repr__(self):
            return self.name
コード例 #34
0
    def __init__(self, element, comp, name=None, location=None, sex='female'):
        if not element in ELEMENTS:
            raise Exception("Invalid element: %s, valid elements are %s" \
            % (element, ELEMENTS))
        if comp[element] == 0:
            raise ValueError("Units' primary element must be greater than 0.")

        if comp[OPP[element]] != 0:
            raise ValueError("Units' opposite element must equal 0.")

        Stone.__init__(self, comp)
        self.element = element
        if name == None:
            self.name = self.__hash__()
        self.name = name
        self.location = location
        self.sex = sex
        self.DOB = datetime.utcnow()
        self.DOD = None
        self.val = self.value()

        def __repr__(self):
            return self.name
コード例 #35
0
    def equip(self, weapon):  #TODO move to battlefield
        """
        A function that automagically equips items based on element.
        should be moved someplace else.
        """
        if weapon == None:
            if self.element == 'Earth':
                self.weapon = Sword(self.element, Stone())
            elif self.element == 'Fire':
                self.weapon = Bow(self.element, Stone())
            elif self.element == 'Ice':
                self.weapon = Wand(self.element, Stone())
            else:
                self.weapon = Glove(self.element, Stone())

        else:
            '''
            if weapon.value() > self.equip_limit[weapon.type]:
                raise Exception("This unit cannot equip this weapon")
            else:
                self.weapon = weapon
            '''
            self.weapon = weapon
コード例 #36
0
    def start(self):
        while 1:
            serverResponse = self.s.recv(1024)
            data = serverResponse.split()

            # Check if the game has ended
            if int(data[0]) == 1:
                break

            self.noOfMoves = int(data[1]) - 1
            self.playersMovedTillNow = int(data[1])
            if (self.playersMovedTillNow < self.NUMBER_OF_PLAYERS):
                for i in range(0, self.playersMovedTillNow):
                    self.lastMoveOfOpponent_x = int(data[2 + i * 3])
                    self.lastMoveOfOpponent_y = int(data[2 + i * 3 + 1])
                    self.stones[1].append(
                        Stone(self.lastMoveOfOpponent_x,
                              self.lastMoveOfOpponent_y))
                    self.greedy.updatePull(self.stones, 1)
            else:
                startIndex = self.playersMovedTillNow - self.NUMBER_OF_PLAYERS + 1
                for i in range(startIndex, self.playersMovedTillNow):
                    self.lastMoveOfOpponent_x = int(data[2 + i * 3])
                    self.lastMoveOfOpponent_y = int(data[2 + i * 3 + 1])
                    self.stones[1].append(
                        Stone(self.lastMoveOfOpponent_x,
                              self.lastMoveOfOpponent_y))
                    self.greedy.updatePull(self.stones, 1)

            nextMove = self.greedy.move(self.stones)

            self.stones[0].append(Stone(nextMove.x, nextMove.y))
            self.greedy.updatePull(self.stones, 0)

            self.s.sendall(str(nextMove.x) + " " + str(nextMove.y))

        self.s.close()
コード例 #37
0
def max_squad_by_value(value):
    """Takes an integer, ideally even because we round down, and returns a
    squad such that comp[element] == value, comp[orth] == value/2, comp[opp]
    == 0"""
    squad = Squad()
    value = value / 2  #more logical, really.
    half = value / 2
    for i in ELEMENTS:
        s = Stone()
        s[i] = value
        s[OPP[i]] = 0
        for o in ORTH[i]:
            s[o] = half
        squad.append(Scient(i, s))
    return squad
コード例 #38
0
ファイル: grid.py プロジェクト: AFDudley/btpy
 def __init__(self, comp=Stone(), x=16, y=16, tiles=None):
     Stone.__init__(self, comp)
     self.x, self.y = self.size = (x, y)
     if self.value() == 0:
         if tiles == None:
             self.tiles = {}
             for i in range(x):
                 row = {}
                 for j in range(y):
                     row.update({j: Tile()})
                 self.tiles.update({i: row})
         else:
             for x in xrange(self.x):
                 for y in xrange(self.y):
                     for suit, value in tiles[x][y].iteritems():
                         self.comp[suit] += value
             for suit in self.comp.keys():
                 self.comp[suit] /= self.x * self.y 
             self.tiles = tiles
     else:
         #needs to check for comp/tiles match currently assumes if comp, no tiles.
         #creates a pool of comp points to pull from.
         pool = {}
         for suit, value in self.comp.iteritems():
             pool[suit] = value * self.x * self.y 
         #pulls comp points from the pool using basis and skew to determine the range of random
         #values used create tiles. Tiles are then shuffled.
         tiles_l = []
         for i in xrange(x-1):
             row_l = []
             for j in xrange(y):
                 """This is pretty close, needs tweeking."""
                 new_tile = {}
                 for suit, value in pool.iteritems():
                     '''This determines the range of the tile comps.'''
                     #good enough for the time being.
                     basis = self.comp[suit]
                     skew  = 2*random.randint(2,8)
                     pull  = random.randint(basis-skew, basis+skew)
                     nv = min(pull, pool[suit])
                     pool[suit] -= nv
                     new_tile[suit] = nv
                 row_l.append(new_tile)
             row = {}
             random.shuffle(row_l) #shuffles tiles in temp. row.
             tiles_l.append(row_l)
         #special error correcting row
         row_e = []
         for k in xrange(y): 
             new_tile = {}
             for suit, value in pool.iteritems():
                 if pool[suit] != 0:
                     fract = pool[suit]/max(1, k)
                 else:
                     fract = 0
                 nv = min(fract, pool[suit])
                 pool[suit] -= nv
                 new_tile[suit] = nv
             row_e.append(new_tile)
         #hacks upon hacks pt2
         del row_e[-1]
         half = {}
         for suit, value in row_e[-1].iteritems():
             half[suit] = int(value/2)
             row_e[-1][suit] -= half[suit]
         row_e.append(half)
         tiles_l.append(row_e)
         self.tiles = {}
         random.shuffle(tiles_l) #shuffles temp rows.
         for x in xrange(self.x):
             row = {}
             for y in xrange(self.y): #This shuffles the tiles before putting them in the grid.
                 r_index = random.choice(range(len(tiles_l))) # pick a row
                 c_index = random.choice(range(len(tiles_l[r_index]))) #pick a tile
                 row.update({y: Tile(tiles_l[r_index][c_index])}) #place tile in grid
                 del tiles_l[r_index][c_index] #remove used tile
                 if len(tiles_l[r_index]) == 0: #remove empty rows from tiles_l
                     del tiles_l[r_index]
             self.tiles.update({x: row})
         del tiles_l
コード例 #39
0
ファイル: grid.py プロジェクト: AFDudley/btpy
 def __init__(self, comp=Stone(), contents=None):
     Stone.__init__(self, comp)
     self.contents = contents
コード例 #40
0
ファイル: weapons.py プロジェクト: AFDudley/btpy
 def __init__(self, element, comp, wep_type):
     #this should return the correct weapon based on . (?)
     Stone.__init__(self, comp)
     self.type = wep_type
     self.element = element