/// <summary>
        /// 指定の座標にあるノードをオープンする
        /// </summary>
        /// <param name="x"     >オープンするノードの座標</param>
        /// <param name="y"     >オープンするノードの座標</param>
        /// <param name="cost"  >オープンするノードのコスト</param>
        /// <param name="parent">親ノード</param>
        /// <returns>オープンしたノード</returns>
        public A_Node Open_Node(int x, int y, int cost, A_Node parent)
        {
            // 座標をチェック
            if (layer.Is_Out_Of_Range(x, y))
            {
                // 領域外
                return(null);
            }
            if (layer.Get(x, y) > 1)
            {
                // 通過できない
                return(null);
            }
            // ノードを取得する
            A_Node node = Get_Node(x, y);

            if (node.Is_None() == false)
            {
                // 既にOpenしているので何もしない
                return(null);
            }

            // Openする
            node.Open(parent, cost);

            Add_Open_List(node);

            return(node);
        }
Exemple #2
0
    /// <summary>
    /// プレイヤーが隣接したマスにいるかどうか
    /// </summary>
    /// <returns>プレイヤーがいた場合はtrue</returns>
    bool Search_Player(int index)
    {
        var enemy = Enemy_Manager.Instance.enemies[index].GetComponent <Enemy>();
        // 長くなるので1時変数に格納
        int enemy_x = enemy_manager.enemies[index].GetComponent <Enemy>().position.x;
        int enemy_y = enemy_manager.enemies[index].GetComponent <Enemy>().position.y;
        // 移動量
        int move_value = Define_Value.MOVE_VAULE;

        // 上方向から時計回りに検索
        if (map_layer.Get(enemy_x, enemy_y + Define_Value.TILE_SCALE) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            enemy.direction = eDirection.Up;
            return(true);
        }
        // 右上
        else if (map_layer.Get(enemy_x + Define_Value.TILE_SCALE, enemy_y + Define_Value.TILE_SCALE) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            if (Actor_Action.Slant_Check(map_layer.Get(enemy_x + move_value, enemy_y),
                                         map_layer.Get(enemy_x, enemy_y + move_value)))
            {
                return(false);
            }
            enemy.direction = eDirection.Upright;
            return(true);
        }
        // 右
        else if (map_layer.Get(enemy_x + Define_Value.TILE_SCALE, enemy_y) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            enemy.direction = eDirection.Right;
            return(true);
        }
        // 右下
        else if (map_layer.Get(enemy_x + Define_Value.TILE_SCALE, enemy_y - Define_Value.TILE_SCALE) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            if (Actor_Action.Slant_Check(map_layer.Get(enemy_x + move_value, enemy_y),
                                         map_layer.Get(enemy_x, enemy_y - move_value)))
            {
                return(false);
            }
            enemy.direction = eDirection.Downright;
            return(true);
        }
        // 下
        else if (map_layer.Get(enemy_x, enemy_y - Define_Value.TILE_SCALE) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            enemy.direction = eDirection.Down;
            return(true);
        }
        // 左下
        else if (map_layer.Get(enemy_x - Define_Value.TILE_SCALE, enemy_y - Define_Value.TILE_SCALE) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            if (Actor_Action.Slant_Check(map_layer.Get(enemy_x - move_value, enemy_y),
                                         map_layer.Get(enemy_x, enemy_y - move_value)))
            {
                return(false);
            }
            enemy.direction = eDirection.Downleft;
            return(true);
        }
        // 左
        else if (map_layer.Get(enemy_x - Define_Value.TILE_SCALE, enemy_y) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            enemy.direction = eDirection.Left;
            return(true);
        }
        // 左上
        else if (map_layer.Get(enemy_x - Define_Value.TILE_SCALE, enemy_y + Define_Value.TILE_SCALE) == Define_Value.PLAYER_LAYER_NUMBER)
        {
            if (Actor_Action.Slant_Check(map_layer.Get(enemy_x - move_value, enemy_y),
                                         map_layer.Get(enemy_x, enemy_y + move_value)))
            {
                return(false);
            }
            enemy.direction = eDirection.Upleft;
            return(true);
        }
        return(false);
        //TODO:次にパートナーを探す
    }
Exemple #3
0
    /// <summary>
    /// プレイヤーの攻撃処理
    /// </summary>
    public void Action_Attack()
    {
        // プレイヤーの座標
        var player_x = (int)player_script.position.x;
        var player_y = (int)player_script.position.y;
        // タイルの大きさ
        int tile_scale = Define_Value.TILE_SCALE;
        // 調整用変数 4方向は斜めがいらないので0
        int adjust_value_zero = 0;
        // 調整用変数 1マス先
        int adjust_value_add = Define_Value.TILE_SCALE;

        switch (player_script.direction)
        {
        case eDirection.Up:
            // 自分の向いている方向の1マス先に敵がいるか判断 上から順に時計回りに検索
            if (map_layer.Get(player_x, player_y + tile_scale) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(adjust_value_zero, adjust_value_add);
            break;

        case eDirection.Upright:
            if (map_layer.Get(player_x + tile_scale, player_y + tile_scale) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(adjust_value_add, adjust_value_add);
            break;

        case eDirection.Right:
            if (map_layer.Get(player_x + tile_scale, player_y) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(adjust_value_add, adjust_value_zero);
            break;

        case eDirection.Downright:
            if (map_layer.Get(player_x + tile_scale, player_y - tile_scale) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(adjust_value_add, -adjust_value_add);
            break;

        case eDirection.Down:
            if (map_layer.Get(player_x, player_y - tile_scale) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(adjust_value_zero, -adjust_value_add);
            break;

        case eDirection.Downleft:
            if (map_layer.Get(player_x - tile_scale, player_y - tile_scale) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(-adjust_value_add, -adjust_value_add);
            break;

        case eDirection.Left:
            if (map_layer.Get(player_x - tile_scale, player_y) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(-adjust_value_add, adjust_value_zero);
            break;

        case eDirection.Upleft:
            if (map_layer.Get(player_x - tile_scale, player_y + tile_scale) !=
                Define_Value.ENEMY_LAYER_NUMBER)
            {
                player_action.Set_Action(ePlayer_State.Move);
                return;
            }
            Attack_Process(-adjust_value_add, adjust_value_add);
            break;
        }
    }
    /// <summary>
    /// 新しくダンジョンを作る。開始時、フロア移動時に呼ばれる。
    /// </summary>
    /// <param name="level">どの難易度のダンジョンが呼ばれたか</param>
    public void Load_Dungeon(int level)
    {
        // ダンジョンの横幅
        int dungeon_width = 0;
        // ダンジョンの縦幅
        int dungeon_height = 0;

        // 敵の出現数をリセット
        Enemy_Manager.Instance.Enemy_Counter = 1;

        // レベルに合った大きさのダンジョンの生成する
        switch (level)
        {
        case Define_Value.EASY:
            dungeon_width  = Define_Value.EASY_DUNGEON_WIDTH;
            dungeon_height = Define_Value.EASY_DUNGEON_HEIGHT;
            break;

        case Define_Value.NOMAL:
            dungeon_width  = Define_Value.NOMAL_DUNGEON_WIDTH;
            dungeon_height = Define_Value.NOMAL_DUNGEON_HEIGHT;
            break;

        case Define_Value.HARD:
            dungeon_width  = Define_Value.HARD_DUNGEON_WIDTH;
            dungeon_height = Define_Value.HARD_DUNGEON_HEIGHT;
            break;
        }

        // 初期化
        map_layer.Initialise(dungeon_width, dungeon_height);// 区画リスト作成
        division_list = new List <Dungeon_Division>();

        // すべてを壁にする
        map_layer.Fill(Define_Value.WALL_LAYER_NUMBER);

        // 最初の区画を作る // 0から作っているので-1する
        Create_Division(0, 0, dungeon_width - 1, dungeon_height - 1);

        // 区画を分割する
        // 垂直 or 水平分割フラグの決定
        bool bVertical = (Random.Range(0, 2) == 0);

        Split_Divison(bVertical);

        // 区画に部屋を作る
        Create_Room();

        // 部屋同士をつなぐ
        Connect_Rooms();

        // 入口(出口)となる部分に専用のレイヤーを貼る
        Set_Entrance_Position();

        // プレイヤー、敵、アイテム、階段の位置を決定
        Random_Actor(Define_Value.PLAYER_LAYER_NUMBER);
        //TODO:中身を作り終えたらスポーンさせる
        // 引数に入れたオブジェクトをランダムで複数個配置する
        Random_Object(Define_Value.ENEMY_LAYER_NUMBER);
        //Random_Object(Define_Value.ITEM_LAYER_NUMBER);
        //Random_Object(Define_Value.TRAP_LAYER_NUMBER);
        // 階段を配置。 階段は1つのみなので、↑とは別口で
        Create_Stair();

        Vector3 instance_position = Vector3.zero;

        // タイルを配置
        for (int x = 0; x < map_layer.GetWidth(); ++x)
        {
            for (int y = 0; y < map_layer.GetHeight(); ++y)
            {
                // 壁以外であれば床用の画像を配置
                if (map_layer.Get(x, y) != Define_Value.WALL_LAYER_NUMBER)
                {
                    GameObject instance_tile = Instantiate(tile_object, instance_position, Quaternion.identity);
                }

                // 壁であれば壁用の画像を配置
                if (map_layer.Get(x, y) == Define_Value.WALL_LAYER_NUMBER)
                {
                    GameObject instance_wall = Instantiate(wall_object, instance_position, Quaternion.identity);
                }
                // プレイヤーであればプレイヤーを配置
                else if (map_layer.Get(x, y) == Define_Value.PLAYER_LAYER_NUMBER)
                {
                    Vector2Int player_position = new Vector2Int(x, y);
                    map_layer.Set(x, y, Define_Value.PLAYER_LAYER_NUMBER);
                    // TODO:足元のものを取って来たい
                    player.Set_Feet(Define_Value.TILE_LAYER_NUMBER);
                    player.Set_Position(player_position);
                    var player_status = Player_Manager.Instance.player_status;
                    player_status.Where_Floor(x, y);
                }
                // 階段であれば階段用の画像を配置
                else if (map_layer.Get(x, y) == Define_Value.STAIR_LAYER_NUMBER)
                {
                    GameObject instance_stair = Instantiate(stair_object, instance_position, Quaternion.identity);
                }
                // アイテムであればアイテム用の画像を配置
                //TODO: アイテムはレイヤーではなく、落ちてる落ちてないでのboolか何かにするか
                else if (map_layer.Get(x, y) == Define_Value.ITEM_LAYER_NUMBER)
                {
                    GameObject instance_item = Instantiate(item_object, instance_position, Quaternion.identity);
                }
                // エネミーであればエネミーを生成
                else if (map_layer.Get(x, y) == Define_Value.ENEMY_LAYER_NUMBER)
                {
                    enemy_manager.Create_Enemy(x, y);
                }
                // 罠であれば罠用の画像を配置
                else if (map_layer.Get(x, y) == Define_Value.TRAP_LAYER_NUMBER)
                {
                    GameObject instance_cell = Instantiate(trap_object, instance_position, Quaternion.identity);
                }
                instance_position.y += tile_object.GetComponent <SpriteRenderer>().bounds.size.y;
            }
            instance_position.y  = 0.0f;
            instance_position.x += tile_object.GetComponent <SpriteRenderer>().bounds.size.x;
            instance_position.z -= Define_Value.CAMERA_DISTANCE;
        }
    }
    /// <summary>
    /// キー入力に合わせた方向に移動する
    /// </summary>
    void Move()
    {
        // 現在の座標を取得
        player_position = player.GetPosition();
        // プレイヤーのx座標
        int player_x = player_position.x;
        // プレイヤーのy座標
        int player_y = player_position.y;

        // 移動量
        int move_value = Define_Value.MOVE_VAULE;
        // 移動しないときは0
        int not_move = 0;

        // Wキーが押されたとき
        if (Input.GetKeyDown(KeyCode.W))
        {
            player.direction = eDirection.Up;
            // 進行方向が移動可能かを判断
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x, player_y + move_value)))
            {
                return;
            }
            Move_Process(not_move, move_value);
        }
        // Eキーが押されたとき
        else if (Input.GetKeyDown(KeyCode.E))
        {
            player.direction = eDirection.Upright;
            // 進行方向が移動可能かを判断
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x + move_value, player_y + move_value)))
            {
                return;
            }
            // 右方向か上方向に壁があるとき(移動不可になる)
            if (Actor_Action.Slant_Check(map_layer.Get(player_x + move_value, player_y),
                                         map_layer.Get(player_x, player_y + move_value)))
            {
                return;
            }
            Move_Process(move_value, move_value);
        }
        // Dキーが押されたとき
        else if (Input.GetKeyDown(KeyCode.D))
        {
            player.direction = eDirection.Right;
            // 進行方向が移動可能かを判断
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x + move_value, player_y)))
            {
                return;
            }
            Move_Process(move_value, not_move);
        }
        // Cキーが押されたとき
        else if (Input.GetKeyDown(KeyCode.C))
        {
            player.direction = eDirection.Downright;
            // 進行方向が移動可能かを判断
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x + move_value, player_y - move_value)))
            {
                return;
            }
            // 右方向か下方向に壁があるかを判断(移動不可になる)
            if (Actor_Action.Slant_Check(map_layer.Get(player_x + move_value, player_y),
                                         map_layer.Get(player_x, player_y - move_value)))
            {
                return;
            }
            Move_Process(move_value, -move_value);
        }
        // Xキーが押されたとき
        else if (Input.GetKeyDown(KeyCode.X))
        {
            player.direction = eDirection.Down;
            // 進行方向が移動可能かを判断
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x, player_y - move_value)))
            {
                return;
            }
            Move_Process(not_move, -move_value);
        }
        // Zキーが押されたとき
        else if (Input.GetKeyDown(KeyCode.Z))
        {
            player.direction = eDirection.Downleft;
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x - move_value, player_y - move_value)))
            {
                return;
            }
            // 左方向か下方向に壁があるとき(移動不可になる)
            if (Actor_Action.Slant_Check(map_layer.Get(player_x - move_value, player_y),
                                         map_layer.Get(player_x, player_y - move_value)))
            {
                return;
            }
            Move_Process(-move_value, -move_value);
        }
        // Aキーが押されたとき
        else if (Input.GetKeyDown(KeyCode.A))
        {
            player.direction = eDirection.Left;
            // 進行方向が移動可能かを判断
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x - move_value, player_y)))
            {
                return;
            }
            Move_Process(-move_value, not_move);
        }
        // Qキーが押されたとき
        else if (Input.GetKeyDown(KeyCode.Q))
        {
            player.direction = eDirection.Upleft;
            if (Actor_Action.Move_Check(map_layer.Get(player_x, player_y),
                                        map_layer.Get(player_x - move_value, player_y + move_value)))
            {
                return;
            }
            // 左方向か上方向に壁があるとき(移動不可になる)
            if (Actor_Action.Slant_Check(map_layer.Get(player_x - move_value, player_y),
                                         map_layer.Get(player_x, player_y + move_value)))
            {
                return;
            }
            Move_Process(-move_value, move_value);
        }
    }