コード例 #1
0
ファイル: ai.py プロジェクト: Naburimannu/beyaz-dag
def territorial_monster(monster, player, metadata):
    """
    Move randomly but near home until approached or hurt
    """
    _spotting(monster, metadata)

    if metadata.active_turns > 0:
        metadata.active_turns -= 1

        # In the grander scheme of things this should reset to territorial
        # after killing its prey, but that doesn't matter so long as we only
        # go hostile on the player.
        if monster.fighter.last_attacker:
            monster.ai = AI(hostile_monster,
                            hostile_monster_metadata(monster.fighter.last_attacker))
            monster.ai.set_owner(monster)
            return monster.ai.take_turn(player)
        if monster.distance_to_obj(player) < metadata.radius:
            log.message(monster.name.capitalize() + ' decides ' + player.name +
                ' is too close!', libtcod.red)
            monster.ai = AI(hostile_monster,
                            hostile_monster_metadata(player))
            monster.ai.set_owner(monster)
            return monster.ai.take_turn(player)
        while True:
            trial_dir = actions.random_direction()
            candidate = monster.pos + trial_dir
            cand_dist = candidate.distance(metadata.home)
            if ((cand_dist < metadata.radius or
                 cand_dist < monster.pos.distance(metadata.home)) and
                    not monster.current_map.is_blocked_at(candidate)):
                actions.move(monster, trial_dir)
                return
コード例 #2
0
def territorial_monster(monster, player, metadata):
    """
    Move randomly but near home until approached or hurt
    """
    _spotting(monster, metadata)

    if metadata.active_turns > 0:
        metadata.active_turns -= 1

        # In the grander scheme of things this should reset to territorial
        # after killing its prey, but that doesn't matter so long as we only
        # go hostile on the player.
        if monster.fighter.last_attacker:
            monster.ai = AI(
                hostile_monster,
                hostile_monster_metadata(monster.fighter.last_attacker))
            monster.ai.set_owner(monster)
            return monster.ai.take_turn(player)
        if monster.distance_to_obj(player) < metadata.radius:
            log.message(
                monster.name.capitalize() + ' decides ' + player.name +
                ' is too close!', libtcod.red)
            monster.ai = AI(hostile_monster, hostile_monster_metadata(player))
            monster.ai.set_owner(monster)
            return monster.ai.take_turn(player)
        while True:
            trial_dir = actions.random_direction()
            candidate = monster.pos + trial_dir
            cand_dist = candidate.distance(metadata.home)
            if ((cand_dist < metadata.radius
                 or cand_dist < monster.pos.distance(metadata.home))
                    and not monster.current_map.is_blocked_at(candidate)):
                actions.move(monster, trial_dir)
                return
コード例 #3
0
def ignoring_monster(monster, player, metadata):
    """
    A creature that moves randomly (q.v. confused_monster) and ignores
    the player unless hurt, in which case it becomes hostile or scared.
    """
    _spotting(monster, metadata)

    if metadata.active_turns > 0:
        metadata.active_turns -= 1
        if monster.fighter.last_attacker:
            if monster.fighter.unarmed_damage > 2:
                monster.ai = AI(
                    hostile_monster,
                    hostile_monster_metadata(monster.fighter.last_attacker))
            else:
                monster.old_ai = monster.ai
                monster.ai = AI(
                    fleeing_monster,
                    hostile_monster_metadata(monster.fighter.last_attacker))
            monster.ai.set_owner(monster)
            return monster.ai.take_turn(player)
        # TODO: this movement may fail, so the monster will appear to
        # move less when in constricted quarters.
        if metadata.on_idle and not metadata.on_idle(player):
            actions.move(monster, actions.random_direction())
コード例 #4
0
ファイル: ai.py プロジェクト: Naburimannu/libtcodpy-tutorial
def confused_monster(monster, player, metadata):
    if metadata.num_turns > 0:
        actions.move(monster, random_direction())
        metadata.num_turns -= 1
    else:
        # Restore the previous AI (this one will be deleted
        # because it's not referenced anymore)
        monster.ai = metadata.old_ai
        log.message(monster.name.capitalize() +
                    ' is no longer confused!', libtcod.red)
コード例 #5
0
ファイル: ai.py プロジェクト: willismonroe/libtcodpy-tutorial
def confused_monster(monster, player, metadata):
    if metadata.num_turns > 0:
        actions.move(monster, random_direction())
        metadata.num_turns -= 1
    else:
        # Restore the previous AI (this one will be deleted
        # because it's not referenced anymore)
        monster.ai = metadata.old_ai
        log.message(monster.name.capitalize() + ' is no longer confused!',
                    libtcod.red)
コード例 #6
0
ファイル: roguelike.py プロジェクト: Naburimannu/beyaz-dag
def player_move_or_attack(player, direction, try_running):
    """
    Returns true if the player makes an attack or moves successfully;
    false if the attempt to move fails.
    """
    goal = player.pos + direction
    if (goal.x < 0 or goal.y < 0 or goal.x >= player.current_map.width
            or goal.y >= player.current_map.height):
        log.message(player.current_map.out_of_bounds(goal))
        return False

    # Is there an attackable object?
    target_obj = None
    for obj in player.current_map.objects:
        if obj.fighter and obj.pos == goal:
            target_obj = obj
            break
    if target_obj is not None:
        # Make sure we're not going up or down a cliff
        if not player.current_map.is_blocked_from(
                player.pos, target_obj.pos, ignore=target_obj):
            actions.attack(player.fighter, target_obj)
            return True
        return False

    # Is there an interactable object?
    target_obj = None
    for obj in player.current_map.objects:
        if obj.interactable and obj.pos == goal:
            target_obj = obj
            break
    if target_obj is not None:
        target_obj.interactable.use_function(player, target_obj)
        return True

    elevation_before_moving = player.current_map.elevation(
        player.pos.x, player.pos.y)
    if actions.move(player, direction):
        player.current_map.fov_needs_recompute = True
        if player.current_map.xp_visit:
            player.current_map.xp_visit(player.current_map, player)
        if player.current_map.is_outdoors:
            new_region = player.current_map.region[player.pos.x][player.pos.y]
            new_elevation = player.current_map.region_elevations[new_region]
            if new_elevation != elevation_before_moving:
                player.current_map.fov_elevation_changed = True
                player.fighter.exhaustion += actions.CLIMB_EXHAUSTION
        if try_running:
            player.game_state = 'running'
            player.run_direction = direction
        # Automatically sweep up ammunition after a shooting spree
        ammo_eq = actions.get_equipped_in_slot(player, 'quiver')
        if ammo_eq:
            for obj in player.current_map.objects:
                if (obj.pos == player.pos and obj.item
                        and obj.item.can_combine(ammo_eq.owner)):
                    actions.pick_up(player, obj)
        return True

    return False
コード例 #7
0
def player_move_or_attack(player, direction, try_running):
    """
    Returns true if the player makes an attack or moves successfully;
    false if the attempt to move fails.
    """
    goal = player.pos + direction
    if (goal.x < 0 or goal.y < 0 or
            goal.x >= player.current_map.width or
            goal.y >= player.current_map.height):
        log.message(player.current_map.out_of_bounds(goal))
        return False

    # Is there an attackable object?
    target = None
    for object in player.current_map.objects:
        if object.fighter and object.pos == goal:
            target = object
            break

    if target is not None:
        actions.attack(player.fighter, target)
        return True
    else:
        if actions.move(player, direction):
            player.current_map.fov_needs_recompute = True
            if try_running:
                player.game_state = 'running'
                player.run_direction = direction
            return True

    return False
コード例 #8
0
def move_into() -> Parser:
    """
    :return: a parser that parses going to a location and then through the door, e.g. 'go into the second room'.
    """
    return non_consuming(move()) \
          .then_ignore(through_door()) \
          .map_parsed(lambda move: Composite([move, ThroughDoor(ObjectRelativeDirection.VICINITY)]))
コード例 #9
0
ファイル: roguelike.py プロジェクト: Naburimannu/beyaz-dag
def player_move_or_attack(player, direction, try_running):
    """
    Returns true if the player makes an attack or moves successfully;
    false if the attempt to move fails.
    """
    goal = player.pos + direction
    if (goal.x < 0 or goal.y < 0 or
            goal.x >= player.current_map.width or
            goal.y >= player.current_map.height):
        log.message(player.current_map.out_of_bounds(goal))
        return False

    # Is there an attackable object?
    target_obj = None
    for obj in player.current_map.objects:
        if obj.fighter and obj.pos == goal:
            target_obj = obj
            break
    if target_obj is not None:
        # Make sure we're not going up or down a cliff
        if not player.current_map.is_blocked_from(player.pos, target_obj.pos, ignore=target_obj):
            actions.attack(player.fighter, target_obj)
            return True
        return False

    # Is there an interactable object?
    target_obj = None
    for obj in player.current_map.objects:
        if obj.interactable and obj.pos == goal:
            target_obj = obj
            break
    if target_obj is not None:
        target_obj.interactable.use_function(player, target_obj)
        return True

    elevation_before_moving = player.current_map.elevation(player.pos.x, player.pos.y)
    if actions.move(player, direction):
        player.current_map.fov_needs_recompute = True
        if player.current_map.xp_visit:
            player.current_map.xp_visit(player.current_map, player)
        if player.current_map.is_outdoors:
            new_region = player.current_map.region[player.pos.x][player.pos.y]
            new_elevation = player.current_map.region_elevations[new_region]
            if new_elevation != elevation_before_moving:
                player.current_map.fov_elevation_changed = True
                player.fighter.exhaustion += actions.CLIMB_EXHAUSTION
        if try_running:
            player.game_state = 'running'
            player.run_direction = direction
        # Automatically sweep up ammunition after a shooting spree
        ammo_eq = actions.get_equipped_in_slot(player, 'quiver')
        if ammo_eq:
            for obj in player.current_map.objects:
                if (obj.pos == player.pos and obj.item and 
                        obj.item.can_combine(ammo_eq.owner)):
                    actions.pick_up(player, obj)
        return True

    return False
コード例 #10
0
ファイル: userinput.py プロジェクト: jnmaster/simplegame
def userinput(player, room):

    do = input("What do I want to do?")

    if do == "move":
        actions.move(player, room)

    elif do == "break":
        actions.destroy(player, room)
    
    elif do == "status":
        actions.status(player)
    
    elif do == "quit":
        actions.quit(player)
        
    else:
        print("I don't know how to do that.")
コード例 #11
0
ファイル: ai.py プロジェクト: Naburimannu/beyaz-dag
def ignoring_monster(monster, player, metadata):
    """
    A creature that moves randomly (q.v. confused_monster) and ignores
    the player unless hurt, in which case it becomes hostile or scared.
    """
    _spotting(monster, metadata)

    if metadata.active_turns > 0:
        metadata.active_turns -= 1
        if monster.fighter.last_attacker:
            if monster.fighter.unarmed_damage > 2:
                monster.ai = AI(hostile_monster,
                                hostile_monster_metadata(monster.fighter.last_attacker))
            else:
                monster.old_ai = monster.ai
                monster.ai = AI(fleeing_monster,
                                hostile_monster_metadata(monster.fighter.last_attacker))
            monster.ai.set_owner(monster)
            return monster.ai.take_turn(player)
        # TODO: this movement may fail, so the monster will appear to
        # move less when in constricted quarters.
        if metadata.on_idle and not metadata.on_idle(player):
            actions.move(monster, actions.random_direction())
コード例 #12
0
ファイル: vault.py プロジェクト: brewerdave/vault
def player_move_or_attack(player, dx, dy):
    x = player.x_pos + dx
    y = player.y_pos + dy

    target = None
    for entity in player.current_map.map_entities:
        if entity.fighter and entity.x_pos == x and entity.y_pos == y:
            target = entity
            break

    if target is not None:
        actions.attack(player.fighter, target)
    else:
        if actions.move(player, dx, dy):
            player.current_map.fov_needs_recompute = True
コード例 #13
0
def action_detail(request):
    if request.method == 'POST':
        serializer = ActionSerializer(data=request.data)

        if serializer.is_valid():
            tile_acting = serializer.validated_data['tile_acting']
            tile_effected = serializer.validated_data['tile_effected']
            map = serializer.validated_data['map']
            action_type = serializer.validated_data['action_type']
            # Validation rules for suspicious calls
            if tile_acting.owner != request.user:
                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
            if tile_acting.map != map or tile_effected.map != map:
                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
            if action_type == "ATT":
                tile_acting, tile_effected = attack(map, tile_acting, tile_effected)
                # if tile_effected.tiles == 0, prompt for movement action details on UI
            if action_type == "MOVE":
                units_to_move = serializer.validated_data['units']
                tile_acting, tile_effected = move(map, tile_acting, tile_effected, units_to_move)

            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
コード例 #14
0
ファイル: parser.py プロジェクト: SHawkeye77/game_1
def parse_args(user_input, player):
    """
    Args:
        user_input (string): raw string of user input
        player (Player object): object of active player
    """
    # Accounting for null input
    if user_input.strip() == "":
        print(random.choice(CONFUSED_RESPONSES))
        return

    # Split string into list of strings (separated by spaces)
    list_of_input = user_input.split()
    # Splitting command into a verb and its following argument
    command = list_of_input[0].lower()
    if len(list_of_input) > 1:
        arguments = [x.lower() for x in list_of_input[1:]]  # Formatting each argument
        if command == "pick" and arguments[0] == "up":
            if len(arguments) > 1:
                actions.pick_up(player, "".join(arguments[1:]), " ".join(arguments[1:]))
            else:
                print("What do you want to pick up?")
            return
        elif command == "use" and ("on" in arguments):
            # Deals with "use ___ on ___ " input
            actions.use_on(arguments, player)
            return
        elif command == "interact" and (arguments[0] == "with"):
            # Deals with "interact with _____ " input
            if len(arguments) < 2:  # If user just says "interact with"
                print("Specify what you'd like to interact with.")
            else:
                actions.interact_with(arguments[1:], player)
            return
        raw_argument = " ".join(list_of_input[1:])  # Here's the raw argument
        argument = (" ".join(arguments))  # Turning into name format.
    else:
        argument = ""
        raw_argument = ""

    if command == "go" or command == "move":
        actions.move(argument, player)
    elif command in ["east", "west", "north", "south"]:
        actions.move(command, player)
    elif command == "observe" and argument == "" or command == "look" and (argument == "around" or argument == ""):
        actions.examine_surroundings(player)
    elif command == "inventory" or (command == "view" and argument == "inventory") or (command == "i" and argument==""):
        actions.print_inventory(player)
    elif command == "where" and argument == "am i" or (command == "location" and argument == ""):
        actions.where(player)
    elif command == "drop":
        actions.drop(player, argument, raw_argument)
    elif command == "grab" or command == "take" or command == "get":
        actions.pick_up(player, argument, raw_argument)
    elif command == "examine":
        actions.examine(player, arguments, raw_argument)
    elif command == "enter":
        actions.enter(player, argument, raw_argument)
    elif (command == "kill" and argument == "myself") or (command == "kms"):
        actions.kill_player(player)
    elif command == "drink":
        actions.drink(player, argument, raw_argument)
    elif command == "eat":
        actions.eat(player, argument, raw_argument)
    elif command == "uuddlrlrbastart":  # Konami code
        print("Nice try, bud.")
    else:
        print(random.choice(CONFUSED_RESPONSES))

    return
コード例 #15
0
def on_press(key):
    # this is the input function of the program
    # we give them the "pointer" and concat what they are typing onto it
    pointer = ("%s>%s" % (fg('white'), attr('reset')))
    world = utils.Variables.world

    global currentlyTyping

    try:
        key = "{0}".format(key.char)
        if (key == "T" or key == "t" or currentlyTyping):
            if (currentlyTyping):
                # after pressing chat key it starts adding characters
                utils.Variables.currentlyTyping += key
            currentlyTyping = True
            print("\033[A                             \033[A")
            print(pointer + " {0}".format(utils.Variables.currentlyTyping))
        elif (key == "Q" or key == "q"):
            action = actions.destroy()
            return False
        elif (key == "E" or key == "e"):
            action = actions.place()
            return False
        elif (key == "W" or key == "w"):
            command = ["move", "forward"]
            actions.move(command, world)
            return False
        elif (key == "S" or key == "s"):
            command = ["move", "down"]
            actions.move(command, world)
            return False
        elif (key == "A" or key == "a"):
            command = ["move", "left"]
            actions.move(command, world)
            return False
        elif (key == "D" or key == "d"):
            command = ["move", "right"]
            actions.move(command, world)
            return False

    except AttributeError:
        # key pressed was nonalphanumeric, check for movement.
        key = "{0}".format(key)
        if (key == "Key.ctrl_l" or key == "key.ctrl_r"):
            # control key, exit program
            sys.exit()
        if (key == "Key.enter"):
            # execute whatever command is in terminal currently
            currentlyTyping = False
            command = utils.Variables.currentlyTyping.split(" ")
            utils.Variables.currentlyTyping = ""
            if (command[0] == "move"):
                # inputted command is move
                # it default updates the player in the variables so no reassign needed.
                worked = actions.move(command, world)
                if (not worked):
                    print("\nEror executing command %s." % command[0])
                    time.sleep(3)
                    print("\033[A                             \033[A")
                    print("\033[A                             \033[A")
                    return True
                else:
                    return False
            elif (command[0] == "chop"):
                worked = actions.chop(world)
                if (not worked):
                    print("\nEror executing command %s." % command[0])
                    time.sleep(3)
                    print("\033[A                             \033[A")
                    print("\033[A                             \033[A")
                    return True
                else:
                    return False
            elif (command[0] == "save"):
                worked = actions.save(world)
                if (not worked):
                    print("\nEror executing command %s." % command[0])
                    time.sleep(3)
                    print("\033[A                             \033[A")
                    print("\033[A                             \033[A")
                    return True
                else:
                    return False
            elif (command[0] == "exit" or command[0] == "quit"):
                actions.save(world)
                os._exit(1)
        elif (key == "Key.space"):
            utils.Variables.currentlyTyping += ' '
        elif (key == "Key.backspace"):
            utils.Variables.currentlyTyping = utils.Variables.currentlyTyping[:
                                                                              -1]
            print("\033[A                             \033[A")
            print(pointer + " {0}".format(utils.Variables.currentlyTyping))
        elif (key == "Key.up"):
            if (utils.Variables.currentlyUsing == 0): return
            utils.Variables.currentlyUsing -= 1
            return False
        elif (key == "Key.down"):
            if (utils.Variables.currentlyUsing == 5): return
            utils.Variables.currentlyUsing += 1
            return False
コード例 #16
0
 def move(self, name_obj, to_location):
     actions.move(self, name_obj, to_location)
コード例 #17
0
ファイル: universe.py プロジェクト: bok/AI-with-Pyke
 def move(self, name_obj, to_location):
     actions.move(self, name_obj, to_location)
コード例 #18
0
def main():
    player_number = input("How many players(2-6)? ")
    if (player_number == "quit"):
        print("Thankyou for playing, Goodbye!")
        exit(0)
    PLAYER_NUMBER = int(player_number)
    while (PLAYER_NUMBER < 2 or PLAYER_NUMBER > 6):
        PLAYER_NUMBER = int(input("Invalid input: "))
    #Enter how much money each player will have
    player_money = input("How much money will each player start out with? ")
    if (player_money == "quit"):
        print("Thankyou for playing, Goodbye!")
        exit(0)
    player_money = int(player_money)
    while (player_money < 1 or player_money > 1000000):
        player_number = int(
            input(
                "Invalid input, please choose positive number from 1 to 1000000: "
            ))
    print("Then let's get started!")

    #DONE
    #Player vector
    player_vector = {}
    #Declare number of players(loop through if you want after finished)
    if (PLAYER_NUMBER == 2):
        Player1 = player.Player(player_money, "Player1", 0)
        player_vector[0] = Player1
        Player2 = player.Player(player_money, "Player2", 0)
        player_vector[1] = Player2
    elif (PLAYER_NUMBER == 3):
        Player1 = player.Player(player_money, "Player1", 0)
        player_vector[0] = Player1
        Player2 = player.Player(player_money, "Player2", 0)
        player_vector[1] = Player2
        Player3 = player.Player(player_money, "Player3", 0)
        player_vector[2] = Player3
    elif (PLAYER_NUMBER == 4):
        Player1 = player.Player(player_money, "Player1", 0)
        player_vector[0] = Player1
        Player2 = player.Player(player_money, "Player2", 0)
        player_vector[1] = Player2
        Player3 = player.Player(player_money, "Player3", 0)
        player_vector[2] = Player3
        Player4 = player.Player(player_money, "Player4", 0)
        player_vector[3] = Player4
    elif (PLAYER_NUMBER == 5):
        Player1 = player.Player(player_money, "Player1", 0)
        player_vector[0] = Player1
        Player2 = player.Player(player_money, "Player2", 0)
        player_vector[1] = Player2
        Player3 = player.Player(player_money, "Player3", 0)
        player_vector[2] = Player3
        Player4 = player.Player(player_money, "Player4", 0)
        player_vector[3] = Player4
        Player5 = player.Player(player_money, "Player5", 0)
        player_vector[4] = Player5
    elif (PLAYER_NUMBER == 6):
        Player1 = player.Player(player_money, "Player1", 0)
        player_vector[0] = Player1
        Player2 = player.Player(player_money, "Player2", 0)
        player_vector[1] = Player2
        Player3 = player.Player(player_money, "Player3", 0)
        player_vector[2] = Player3
        Player4 = player.Player(player_money, "Player4", 0)
        player_vector[3] = Player4
        Player5 = player.Player(player_money, "Player5", 0)
        player_vector[4] = Player5
        Player6 = player.Player(player_money, "Player6", 0)
        player_vector[5] = Player6
    user_input = ""

    #Set game counter
    game_counter = 0
    while (user_input != "quit"):
        pot = 0
        player_vector_index = 0
        if (game_counter == 0):
            #Draws the hands of Players, puts them into a (player_number * 2) matrix
            #Later try to consolidate the 3 loops into 2
            hands = [["", ""], ["", ""], ["", ""], ["", ""], ["", ""],
                     ["", ""]]
            card_index = 0
            i = 0
            while (i < 2):
                card_index = 0
                while (card_index < PLAYER_NUMBER):
                    hands[card_index][i] = cards.draw(deck, cards_dealt)
                    card_index = card_index + 1
                i = i + 1

            #Sets the hands of all players using hands matrix
            #Sets the initial status to 1
            hand_index = 0
            while (hand_index < PLAYER_NUMBER):
                player_vector[player_vector_index].setHand(
                    hands[hand_index][0], hands[hand_index][1])
                player_vector[player_vector_index].setStatus(1)
                hand_index = hand_index + 1
                player_vector_index = player_vector_index + 1

            #Starts game play
            #Initial round of betting before the flop
            players_moved = 0
            previous = -2
            player_vector_index = 0
            player_round_number = PLAYER_NUMBER
            while (players_moved != player_round_number):
                print(player_vector[player_vector_index].getName())
                round_bet = actions.move(player_vector[player_vector_index],
                                         previous)
                if (round_bet > 0):
                    pot = pot + round_bet
                    previous = round_bet
                    players_moved = 1
                elif (round_bet == 0):
                    previous = round_bet
                    players_moved = players_moved + 1
                elif (round_bet == -1):
                    previous = round_bet
                    player_round_number = player_round_number - 1
            if (player_round_number == 1):
                actions.endRound(player_vector, False)
                continue