コード例 #1
0
 public void endRound()
 {
     this.getCurrentRoundChar().updateActionPoint(0);
     eventController.excuteStayRoomEvent(roomContraller.findRoomByXYZ(this.getCurrentRoundChar().getCurrentRoom()), this.getCurrentRoundChar());
     this.getCurrentRoundChar().endRound();
     this.guangBoListener.cleanQuere();
 }
コード例 #2
0
    public bool excuteFallRoomEvent(EventInterface eventI, Character chara)
    {
        this.eventI = eventI;
        if (this.eventI != null)
        {
            if (chara.isPlayer())
            {
                fallRoomExecuted = false;
                this.chara       = chara;
                phase            = 1;
                messageUI.getResult().setDone(false);
                showMessageUi(eventI.getEventBeginInfo(), eventI.getSelectItem());
            }
            else
            {
                result = eventI.excute(chara, messageUI.getResult().getResult(), 0);

                if (result.getResultCode() == EventConstant.FALL_DOWN__EVENT_GOOD)
                {
                }
                else if (result.getResultCode() == EventConstant.FALL_DOWN__EVENT_NORMAL)
                {
                    roomContraller.findRoomByXYZ(chara.getCurrentRoom()).removeChara(chara);
                    this.roomContraller.setCharaInMiniMap(chara.getCurrentRoom(), chara, false);
                    RoomInterface ri = roomContraller.getRandomDownRoom();
                    ri.setChara(chara);
                    chara.setCurrentRoom(ri.getXYZ());
                    this.roomContraller.setCharaInMiniMap(ri.getXYZ(), chara, true);
                    //  camCtrl.setTargetPos(upStairRoom.getXYZ(), RoomConstant.ROOM_Y_DOWN, true);
                }
                else
                {
                    RollDiceParam param = new RollDiceParam(this.eventI.getBadDiceNum());
                    rollVaue = uiManager.showRollDiceImmediately(param);
                    chara.getAbilityInfo()[0] = chara.getAbilityInfo()[0] - rollVaue;
                    roomContraller.findRoomByXYZ(chara.getCurrentRoom()).removeChara(chara);
                    this.roomContraller.setCharaInMiniMap(chara.getCurrentRoom(), chara, false);
                    RoomInterface ri = roomContraller.getRandomDownRoom();
                    ri.setChara(chara);
                    chara.setCurrentRoom(ri.getXYZ());
                    this.roomContraller.setCharaInMiniMap(ri.getXYZ(), chara, true);
                }
            }
        }
        return(true);
    }
コード例 #3
0
    private void P5Move(Character chara, RoomContraller roomContraller, EventController eventController, DiceRollCtrl diceRoll, APathManager aPathManager,
                        RoundController roundController, BattleController battleController)
    {
        Character monster = roundController.getCharaByName(SystemConstant.MONSTER1_NAME);
        string    roomType;
        NPC       npc = (NPC)chara;

        if (this.P5TargetRooms.Count >= 1)
        {
            roomType = this.P5TargetRooms.Peek();
            if (P5Message.Count > 0)
            {
                npc.sendMessageToPlayer(P5Message.Dequeue());
            }
        }
        else
        {
            if (P5Message.Count > 0)
            {
                npc.sendMessageToPlayer(P5Message.Dequeue());
            }

            if (monster.isDead())
            {
                if (P5Message.Count > 0)
                {
                    npc.sendMessageToPlayer(P5Message.Dequeue());
                }
                roomType = roomContraller.getRandomRoom().getRoomType();
            }
            else
            {
                roomType = roomContraller.findRoomByXYZ(monster.getCurrentRoom()).getRoomType();
            }
            this.P5TargetRooms.Enqueue(roomType);
        }
        if (AutoMoveManager.move(chara, roomContraller,
                                 eventController, diceRoll, aPathManager, roomContraller.findRoomByRoomType(roomType).getXYZ()))
        {
            this.P5TargetRooms.Dequeue();

            if (roomType == RoomConstant.ROOM_TYPE_HOSPITAIL_MINITOR)
            {
                npc.sendMessageToPlayer(new string[] { "我在监控室了,这个有台电脑。", "我破解了文件夹,里面有很多照片,有一张很奇怪,大家来看看。" });
            }
            else
            {
                if (!monster.isDead())
                {
                    battleController.fighte(chara, monster);
                    if (monster.isDead())
                    {
                        P1Message.Enqueue(new string[] { "那个蜘蛛怪已经死了!。", "那个萝莉侦探还管不管了啊?" });
                    }
                }
            }
        }
    }
コード例 #4
0
ファイル: UpStairOuter.cs プロジェクト: dachongqing/Assets0.2
    /**
     * void OnCollisionEnter2D(Collision2D coll)
     * {
     *  Debug.Log(coll.gameObject.name);
     *  doClick();
     *
     * }
     * void OnMouseDown()
     *
     * {
     *
     *  if (!SystemUtil.IsTouchedUI())
     *  {
     *
     *      doClick();
     *
     *  }
     *
     *
     * }**/

    public override void doClick()
    {
        // 载入上楼图片...
        RoomInterface upStairBackRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_UPSTAIR);
        Character     chara           = roundController.getCurrentRoundChar();

        roomContraller.findRoomByXYZ(chara.getCurrentRoom()).removeChara(chara);
        this.roomContraller.setCharaInMiniMap(chara.getCurrentRoom(), this.roundController.getCurrentRoundChar(), false);
        upStairBackRoom.setChara(chara);
        chara.setCurrentRoom(upStairBackRoom.getXYZ());
        camCtrl.setTargetPos(upStairBackRoom.getXYZ(), RoomConstant.ROOM_Y_GROUND, true);
        this.roomContraller.setCharaInMiniMap(upStairBackRoom.getXYZ(), this.roundController.getCurrentRoundChar(), true);

        // 载入上楼图片结束。。。
    }
コード例 #5
0
    public void doNow(string gbCode)
    {
        GuangBoAction gb = eventGuangBoMap[gbCode];

        if (gb.getGuangBoType() == GuangBoConstant.GUANGBO_TYPE_MOVE_ROOM)
        {
            RoomInterface targetRoom = roomContraller.findRoomByRoomType(gb.getGuangBoTargetVaule());
            //targetRoom.getXYZ();
            camCtrl.setTargetPos(targetRoom.getXYZ(), targetRoom.getXYZ()[2], true);
            foreach (string name in gb.getWhiteList())
            {
                Character npc = roundController.getCharaByName(name);
                roomContraller.findRoomByXYZ(npc.getCurrentRoom()).removeChara(npc);
                this.roomContraller.setCharaInMiniMap(npc.getCurrentRoom(), npc, false);
                npc.setCurrentRoom(targetRoom.getXYZ());
                this.roomContraller.setCharaInMiniMap(targetRoom.getXYZ(), npc, true);
            }
            Character chara = roundController.getPlayerChara();
            roomContraller.findRoomByXYZ(chara.getCurrentRoom()).removeChara(chara);
            this.roomContraller.setCharaInMiniMap(chara.getCurrentRoom(), this.roundController.getCurrentRoundChar(), false);
            foreach (string name in gb.getWhiteList())
            {
                Character npc = roundController.getCharaByName(name);
                roomContraller.findRoomByXYZ(npc.getCurrentRoom()).removeChara(npc);
                this.roomContraller.setCharaInMiniMap(npc.getCurrentRoom(), npc, false);

                npc.setCurrentRoom(targetRoom.getXYZ());
                this.roomContraller.setCharaInMiniMap(targetRoom.getXYZ(), npc, true);
            }
            chara.setCurrentRoom(targetRoom.getXYZ());
            this.roomContraller.setCharaInMiniMap(targetRoom.getXYZ(), chara, true);
            Debug.Log("loading。。。ready to move room");

            //
        }
    }
コード例 #6
0
ファイル: WoodDoor.cs プロジェクト: dachongqing/Assets
    void OnMouseDown()
    {
        if (showFlag)
        {
            Debug.Log("WoodDoor.cs OnMouseDown");
            //检查玩家的行动力
            bool opened = openDoor(roundController.getCurrentRoundChar());

            //这里有bug,玩家应该是只能点击 所在房间的几个门,其余房间的门都是不能点击的.
            //生成门时,门启用,但加锁;玩家进入房间,门解锁可点击;玩家离开房间,门加锁不可点击

            if (opened)
            {
                // 调用事件处理器处理事情

//				bool result = eventController.excuteLeaveRoomEvent (getRoom (), roundController.getCurrentRoundChar ()); 暂时禁用 运行时有异常,对象未被实例化

                //非正式测试用,只考虑行动力足够
                bool result = true;

                if (result == true)
                {
                    //离开门成功
                    int[] te = getNextRoomXYZ();
                    Debug.Log("点门移动!目标房间 " + te[0] + "," + te[1] + "," + te[2]);
                    //进入下一个房间
                    RoomInterface nextRoom = roomContraller.findRoomByXYZ(getNextRoomXYZ());

                    //摄像机移动到下一个房间坐标
                    camCtrl.setTargetPos(getNextRoomXYZ());

                    //当前人物坐标移动到下一个房间
                    roundController.getCurrentRoundChar().setCurrentRoom(getNextRoomXYZ());

                    //触发进门事件
//					eventController.excuteEnterRoomEvent (nextRoom, roundController.getCurrentRoundChar ());  暂时禁用 运行时有异常
                }
                else
                {
                    //离开失败
                    Debug.Log("WoodDoor.cs OnMouseDown 离开房间失败");
                }
            }
        }
    }
コード例 #7
0
 // Update is called once per frame
 void Update()
 {
     roomName.text = roomContraller.findRoomByXYZ(player.getCurrentRoom()).getRoomName();
 }
コード例 #8
0
ファイル: Kate.cs プロジェクト: dachongqing/Assets0.2
    public new void defaultAction()
    {
        //  Debug.Log("run default aciont");
        if (waitPlan)
        {
            if (this.getGuangBoAction().isPlanSuccess())
            {
                this.sendMessageToPlayer(new string[] { "我这里有新线索发现,都来听我分析。" });
                if (this.getGuangBoAction().isGuangBoActionEnd())
                {
                    waitPlan = false;
                }
            }
            else
            {
                this.sendMessageToPlayer(new string[] { "你们这群呆逼,都不来算了。" });
                waitPlan = false;
            }
        }
        else
        {
            if (this.getTargetRoomList().Count <= 0)
            {
                NPC ben = (NPC)FindObjectOfType <Ben>();
                if (ben.isDead())
                {
                    Debug.Log("随便找个房间看看");
                    this.getTargetRoomList().Enqueue(roomContraller.getRandomRoom());
                }
                else
                {
                    if (AutoMoveManager.move(this, roomContraller, eventController, diceRoll, aPathManager, ben.getCurrentRoom()))
                    {
                        Debug.Log("kate 开始跟踪冒险家");
                        if (this.getAbilityInfo()[3] <= 1)
                        {
                            Debug.Log("kate 疯了, 准备杀人了");
                            ben.sendMessageToPlayer(new string[] { "侦探疯了,他要杀死所有人!", " 大家快跑。。。", "啊。。。" });
                            ben.getAbilityInfo()[0]  = 0;
                            this.getAbilityInfo()[3] = 1;

                            if (storyController.checkStoryStartBySPEvnet(bss, this, roundController, roomContraller.findRoomByXYZ(this.getCurrentRoom())))
                            {
                                Debug.Log(" 黑色征兆 剧本开启");
                                this.sendMessageToPlayer(new string[] { "啊!啊!啊!。。。", "冒险家被我杀死了。。。" });
                                this.getAbilityInfo()[3] = 3;
                            }
                            else
                            {
                                Debug.Log(" 剧本开启失败");
                            }
                        }
                        else
                        {
                            Debug.Log("kate 没疯,暗中观察");
                            //this.setClickMessage(new string[] { SystemConstant.P2_NAME + ", 让我看一下你当年手术的地方吧?" });
                        }
                    }
                }
            }
            else
            {
                RoomInterface target = this.getTargetRoomList().Peek();
                if (target == null)
                {
                    Debug.Log("target is null !!!!error");
                }
                if (target.getRoomType() == RoomConstant.ROOM_TYPE_HOSPITAIL_TRI_OPERATION && isTargetRoomLocked())
                {
                    Debug.Log("NPC发现手术室被锁着 去保安室找钥匙");

                    if (AutoMoveManager.move(this, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_HOSPITAIL_SECURITY))
                    {
                        Debug.Log("达到保安室");
                        H_securityRoom surgeryRoom = (H_securityRoom)roomContraller.findRoomByXYZ(this.getCurrentRoom());
                        Item           item        = surgeryRoom.getKeysCabinet().GetComponent <KeysCabinet>().getItem(this);
                        if (item != null)
                        {
                            this.getBag().insertItem(item);
                            this.setTargetRoomLocked(false);
                        }
                        else
                        {
                            //没有找到钥匙, 直接判断手术室有没有被打开
                            H_tridOperationRoom tridOperationRoom = (H_tridOperationRoom)roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_HOSPITAIL_TRI_OPERATION);
                            if (tridOperationRoom.isLock())
                            {
                                Debug.Log("第3手术室锁着, 我又没钥匙,暂定瞎逛");
                                AutoMoveManager.move(this, roomContraller, eventController, diceRoll, aPathManager, roomContraller.getRandomRoom().getRoomType());
                            }
                            else
                            {
                                this.setTargetRoomLocked(false);
                            }
                        }
                    }
                }
                else
                {
                    // Debug.Log("targetRoom is " + target.getXYZ()[0] + "," + target.getXYZ()[1] + "," + target.getXYZ()[2]);
                    if (AutoMoveManager.move(this, roomContraller, eventController, diceRoll, aPathManager, target.getXYZ()))
                    {
                        //  Debug.Log("reached the targetRoom is " + target.getXYZ()[0] + "," + target.getXYZ()[1] + "," + target.getXYZ()[2]);
                        this.getTargetRoomList().Dequeue();
                        if (target.getRoomType() == RoomConstant.ROOM_TYPE_HOSPITAIL_SURGERY)
                        {
                            Debug.Log("达到外科室");
                            H_surgeryRoom surgeryRoom = (H_surgeryRoom)roomContraller.findRoomByXYZ(this.getCurrentRoom());
                            Item          item        = surgeryRoom.getBookTable().GetComponent <BookTable>().getItem(this);
                            if (item != null)
                            {
                                string guangBoCode = this.getName() + "_" + RoomConstant.ROOM_TYPE_HOSPITAIL_SURGERY + "_gb";
                                getTargetChara().Add(SystemConstant.P2_NAME);
                                setGuangBoAction(new EveryoneGoTargetRoom(this.getName(), RoomConstant.ROOM_TYPE_HOSPITAIL_SURGERY, getTargetChara(), 8, guangBoCode));
                                guangBoController.insertGuangBo(this.getGuangBoAction());
                                waitPlan = true;
                                this.sendMessageToPlayer(new string[] { SystemConstant.P2_NAME + ", 这个病例上有你的名字", " 你最好来看看" }, guangBoCode);
                                this.getBag().insertItem(item);
                            }
                        }
                        else if (target.getRoomType() == RoomConstant.ROOM_TYPE_HOSPITAIL_TRI_OPERATION)
                        {
                            Debug.Log("到达第3手术室");
                            H_tridOperationRoom tridOperationRoom = (H_tridOperationRoom)roomContraller.findRoomByXYZ(this.getCurrentRoom());
                            Item item = tridOperationRoom.getOperatingTable().GetComponent <OperatingTable>().getItem(this);
                            if (item != null)
                            {
                                this.getBag().insertItem(item);
                                this.sendMessageToPlayer(new string[] { SystemConstant.P1_NAME + ", 你最好解释下这个解剖样本,这个是什么病?" });
                            }
                            else
                            {
                                Debug.Log("这个解剖手术太奇怪了,我一定错过了什么。我要好好检查下。");
                                this.sendMessageToPlayer(new string[] { "这个解剖手术太奇怪了,我一定错过了什么。", "我要好好检查下。" });
                            }
                            //  this.setClickMessage(tridOperationRoom.findSomethingNews(this).ToArray());
                        }
                        else if (target.getRoomType() == RoomConstant.ROOM_TYPE_HOSPITAIL_MORGUE)
                        {
                            Debug.Log("到达停尸房");
                            this.sendMessageToPlayer(new string[] { "这里有好多尸体都标明了实验失败的标签", "而且实验人全是写的你医生的名字", "大家把医生抓住啊,他有重大嫌疑!" });
                        }
                        else if (target.getRoomType() == RoomConstant.ROOM_TYPE_HOSPITAIL_STORE)
                        {
                            Debug.Log("到达储藏室");
                            H_storeRoom storeRoom = (H_storeRoom)roomContraller.findRoomByXYZ(this.getCurrentRoom());
                            Item        item      = storeRoom.getSafeCabinet().GetComponent <SafeCabinet>().getItem(this);
                            if (item != null)
                            {
                                this.getBag().insertItem(item);
                                this.getAbilityInfo()[3] = 1;
                                //发疯后行动力加强
                                this.getAbilityInfo()[0] = this.getAbilityInfo()[0] + 3;
                                this.getAbilityInfo()[1] = this.getAbilityInfo()[1] + 4;
                            }
                            else
                            {
                                if (!isCrazy())
                                {
                                    //this.sendMessageToPlayer(target.findSomethingNews(this.getName()).ToArray());
                                    // this.setClickMessage(target.findSomethingNews(this).ToArray());
                                }
                            }
                        }
                        else
                        {
                            Debug.Log("找路失败了");
                        }
                    }
                }
                //this.setClickMessage(this.roomContraller.findRoomByXYZ(this.getCurrentRoom()).findSomethingNews(this).ToArray());
            }
        }
        endRound();
    }
コード例 #9
0
ファイル: APathManager.cs プロジェクト: dachongqing/Assets0.2
    public Stack <Node> findPath(RoomInterface intiRoom, RoomInterface targetNode, RoomContraller roundController)
    {
        openList.Clear();
        closeList.Clear();
        //   Debug.Log(" intiRoom Room is " + intiRoom.getXYZ()[0] + "," + intiRoom.getXYZ()[1]);
        //   Debug.Log(" targetNode Room is " + targetNode.getXYZ()[0] + "," + targetNode.getXYZ()[1]);
        bool finded   = false;
        Node initNode = new Node(intiRoom.getXYZ()[0], intiRoom.getXYZ()[1], intiRoom.getXYZ()[2]);

        initNode.G = 10;
        initNode.H = (System.Math.Abs(initNode.xy[0] - targetNode.getXYZ()[0]) + System.Math.Abs(initNode.xy[1] - targetNode.getXYZ()[1])) * 10;
        initNode.F = initNode.G + initNode.H;
        openList.Add(initNode);

        while (!finded)
        {
            //计算起始位置周围的F值
            currentNode = getLessestNode(openList);
            //      Debug.Log(" currentNode Room is " + currentNode.xy[0] + "," + currentNode.xy[1]);
            closeList.Add(currentNode);
            if (currentNode.xy[0] == targetNode.getXYZ()[0] && currentNode.xy[1] == targetNode.getXYZ()[1])
            {
                //           Debug.Log("I got the targetRoom!!!!");
                finded = true;
                break;
            }

            RoomInterface currentRoom = roundController.findRoomByXYZ(currentNode.xy);
            //      Debug.Log(" currentRoom Room is " + currentRoom.getXYZ()[0] + "," + currentRoom.getXYZ()[1]);
            if (currentRoom.getNorthDoor().GetComponent <DoorInterface>().getShowFlag())
            {
                node = new Node(currentRoom.getXYZ()[0], currentRoom.getXYZ()[1] + 1, currentRoom.getXYZ()[2]);
                if (!this.containClose(node, closeList))
                {
                    node.G = 10 + currentNode.G;
                    node.H = (System.Math.Abs(node.xy[0] - targetNode.getXYZ()[0]) + System.Math.Abs(node.xy[1] - targetNode.getXYZ()[1])) * 10;
                    if (roundController.findRoomByXYZ(node.xy).isLock())
                    {
                        node.H = node.H + 50;
                    }
                    node.F      = node.G + node.H;
                    node.parent = currentNode;
                    openList.Add(node);
                }
            }
            if (currentRoom.getSouthDoor().GetComponent <DoorInterface>().getShowFlag())
            {
                node = new Node(currentRoom.getXYZ()[0], currentRoom.getXYZ()[1] - 1, currentRoom.getXYZ()[2]);
                if (!this.containClose(node, closeList))
                {
                    node.G = 10 + currentNode.G;
                    node.H = (System.Math.Abs(node.xy[0] - targetNode.getXYZ()[0]) + System.Math.Abs(node.xy[1] - targetNode.getXYZ()[1])) * 10;
                    if (roundController.findRoomByXYZ(node.xy).isLock())
                    {
                        node.H = node.H + 50;
                    }
                    node.F      = node.G + node.H;
                    node.parent = currentNode;
                    openList.Add(node);
                }
            }
            if (currentRoom.getEastDoor().GetComponent <DoorInterface>().getShowFlag())
            {
                node = new Node(currentRoom.getXYZ()[0] + 1, currentRoom.getXYZ()[1], currentRoom.getXYZ()[2]);
                if (!this.containClose(node, closeList))
                {
                    node.G = 10 + currentNode.G;
                    node.H = (System.Math.Abs(node.xy[0] - targetNode.getXYZ()[0]) + System.Math.Abs(node.xy[1] - targetNode.getXYZ()[1])) * 10;
                    if (roundController.findRoomByXYZ(node.xy).isLock())
                    {
                        node.H = node.H + 50;
                    }

                    node.F      = node.G + node.H;
                    node.parent = currentNode;
                    openList.Add(node);
                }
            }
            if (currentRoom.getWestDoor().GetComponent <DoorInterface>().getShowFlag())
            {
                node = new Node(currentRoom.getXYZ()[0] - 1, currentRoom.getXYZ()[1], currentRoom.getXYZ()[2]);
                if (!this.containClose(node, closeList))
                {
                    node.G = 10 + currentNode.G;
                    node.H = (System.Math.Abs(node.xy[0] - targetNode.getXYZ()[0]) + System.Math.Abs(node.xy[1] - targetNode.getXYZ()[1])) * 10;
                    if (roundController.findRoomByXYZ(node.xy).isLock())
                    {
                        node.H = node.H + 50;
                    }
                    node.F      = node.G + node.H;
                    node.parent = currentNode;
                    openList.Add(node);
                }
            }
            //     Debug.Log("openList.Count  " + openList.Count);
        }


        Stack <Node> paths = genPath(initNode, currentNode);

        return(paths);
    }
コード例 #10
0
    // Update is called once per frame
    void FixedUpdate()
    {
        Character     boss = roundController.getCurrentRoundChar();
        RoomInterface room = roomContraller.findRoomByXYZ(boss.getCurrentRoom());

        if (!isStartStory)
        {
            if (room.checkRoomStoryStart(boss, roundController))
            {
                isStartStory = true;
                //正式开始剧情模式, 剧情UI介绍
                // showStoryUI();

                Character[] charas = roundController.getAllChara();
                this.story = room.getStartedStory();
                story.initStroy(boss, roundController, taskMananger);
                Debug.Log("UI 显示《《剧情模式已经开启: " + story.getStoryInfo());
                boss.setScriptAction(story.getBadManScript());
                boss.setBoss(true);
                for (int i = 0; i < charas.Length; i++)
                {
                    if (charas[i].getName() != boss.getName())
                    {
                        charas[i].setScriptAction(story.getGoodManScript());
                        charas[i].setBoss(false);
                    }
                }
            }
        }
        else
        {
            //剧情已经开始,监听剧本的结束条件
            if (this.story.checkStoryEnd(boss, room, roundController))
            {
                //找到玩家所在的角色,检查胜利条件
                Debug.Log("剧情已经开始,监听剧本的结束条件");
                Character player = roundController.getPlayerChara();
                //调用 UI 显示 结局
                if (boss.isScriptWin())
                {
                    Debug.Log("有人胜利了,游戏结束");
                    if (!boss.isPlayer() && boss.isBoss())
                    {
                        if (duiHuaUImanager.isDuiHuaEnd())
                        {
                            Debug.Log("UI 显示《《 日了狗了,输了啊:" + player.getScriptAciont().getFailureEndInfo());
                        }
                    }
                    else
                    {
                        if (player.isBoss())
                        {
                            if (duiHuaUImanager.isDuiHuaEnd())
                            {
                                Debug.Log("UI 显示《《 日了狗了,输了啊:" + player.getScriptAciont().getFailureEndInfo());
                            }
                        }
                        else
                        {
                            if (duiHuaUImanager.isDuiHuaEnd())
                            {
                                Debug.Log("UI 显示《《 吊炸天,胜利了:" + boss.getScriptAciont().getWinEndInfo());
                            }
                        }
                    }



                    //黑屏 显示游戏结束画面,显示感谢 制作人信息
                    Debug.Log("UI 显示《《黑屏 显示游戏结束画面,显示感谢 制作人信息");
                    //扫尾工作,清除游戏的信息
                    Debug.Log("扫尾工作,清除游戏的信息,保存游戏进度信息等");
                    //返回开始页面
                    Debug.Log("返回开始页面");
                }
            }
        }
    }
コード例 #11
0
    private void P1Move(Character chara, RoomContraller roomContraller, EventController eventController, DiceRollCtrl diceRoll, APathManager aPathManager,
                        RoundController roundController, BattleController battleController)
    {
        Character monster = roundController.getCharaByName(SystemConstant.MONSTER1_NAME);

        Debug.Log("error: this.P1TargetRooms " + this.P1TargetRooms);
        Debug.Log("error: Count " + this.P1TargetRooms.Count);
        string roomType;
        NPC    npc = (NPC)chara;

        if (this.P1TargetRooms.Count >= 1)
        {
            roomType = this.P1TargetRooms.Peek();
            if (P1Message.Count > 0)
            {
                npc.sendMessageToPlayer(P1Message.Dequeue());
            }
        }
        else
        {
            if (P1Message.Count > 0)
            {
                npc.sendMessageToPlayer(P1Message.Dequeue());
            }

            if (monster.isDead())
            {
                if (P1Message.Count > 0)
                {
                    npc.sendMessageToPlayer(P1Message.Dequeue());
                }
                roomType = roomContraller.getRandomRoom().getRoomType();
            }
            else
            {
                roomType = roomContraller.findRoomByXYZ(monster.getCurrentRoom()).getRoomType();
            }
            this.P1TargetRooms.Enqueue(roomType);
        }
        if (AutoMoveManager.move(chara, roomContraller,
                                 eventController, diceRoll, aPathManager, roomContraller.findRoomByRoomType(roomType).getXYZ()))
        {
            this.P1TargetRooms.Dequeue();

            if (roomType == RoomConstant.ROOM_TYPE_HOSPITAIL_DEAN)
            {
                npc.sendMessageToPlayer(new string[] { "我在院长室了,这里有个保险箱,我打不开,快来帮忙" });
                P1Message.Enqueue(new string[] { "我们得杀死那个蜘蛛怪物。", "那个萝莉侦探疯了,我们不用管她。" });
            }
            else
            {
                if (!monster.isDead())
                {
                    battleController.fighte(chara, monster);
                    if (monster.isDead())
                    {
                        P1Message.Enqueue(new string[] { "那个蜘蛛怪物死了?。", "我们得想办法救救那个萝莉侦探。" });
                    }
                }
            }
        }
    }
コード例 #12
0
    public static bool doMove(Character chara, RoomContraller roomContraller, EventController eventController, DiceRollCtrl diceRoll, APathManager aPathManager, RoomInterface targetRoom, bool goUpOrDown)
    {
        if (chara.ActionPointrolled() || chara.getActionPoint() > 0)
        {
            Stack <Node> path = null;

            RoomInterface currentRoom = roomContraller.findRoomByXYZ(chara.getCurrentRoom());
            //如果当前房间不是目标房间
            //开始找路
            if (chara.getCurrentRoom()[0] != targetRoom.getXYZ()[0] || chara.getCurrentRoom()[1] != targetRoom.getXYZ()[1] || chara.getCurrentRoom()[2] != targetRoom.getXYZ()[2])
            {
                //  Debug.Log("如果当前房间不是目标房间");
                //判定是否同层
                if (chara.getCurrentRoom()[2] != targetRoom.getXYZ()[2])
                {
                    //   Debug.Log("如果目标房间是楼下, 先定位到下楼梯口房间, 如果目标是楼上,先定位到上楼梯口房间");
                    // 如果目标房间是楼下, 先定位到下楼梯口房间, 如果目标是楼上,先定位到上楼梯口房间
                    if (targetRoom.getXYZ()[2] == RoomConstant.ROOM_Z_UP)
                    {
                        //    Debug.Log("目标是楼上,先定位到上楼梯口房间");
                        // targetRoom = roomContraller.findRoomByType(RoomConstant.);
                        if (chara.getCurrentRoom()[2] == RoomConstant.ROOM_Z_GROUND)
                        {
                            //    Debug.Log("当前房间 是地面, 只要到向上楼梯房间");
                            if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_UPSTAIR, true))
                            {
                                return(false);
                            }
                            else
                            {
                                //      Debug.Log("当前房间 是楼上, 寻找目标房间");
                                path = aPathManager.findPath(roomContraller.findRoomByXYZ(chara.getCurrentRoom()), targetRoom, roomContraller);
                            }
                        }
                        else
                        {
                            if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_DOWNSTAIR_BACK, true))
                            {
                                return(false);
                            }
                            else
                            {
                                if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_UPSTAIR, true))
                                {
                                    return(false);
                                }
                                else
                                {
                                    //     Debug.Log("现在同层了。。可以找最终目标房间了 :" + targetRoom);
                                    path = aPathManager.findPath(roomContraller.findRoomByXYZ(chara.getCurrentRoom()), targetRoom, roomContraller);
                                }
                            }
                        }
                    }
                    else if (targetRoom.getXYZ()[2] == RoomConstant.ROOM_Z_GROUND)
                    {
                        if (chara.getCurrentRoom()[2] == RoomConstant.ROOM_Z_UP)
                        {
                            if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_UPSTAIR_BACK, true))
                            {
                                return(false);
                            }
                            else
                            {
                                //   Debug.Log("现在同层了。。可以找最终目标房间了 :" + targetRoom);
                                path = aPathManager.findPath(roomContraller.findRoomByXYZ(chara.getCurrentRoom()), targetRoom, roomContraller);
                            }
                        }
                        else
                        {
                            if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_DOWNSTAIR_BACK, true))
                            {
                                return(false);
                            }
                            else
                            {
                                //   Debug.Log("现在同层了。。可以找最终目标房间了 :" + targetRoom);
                                path = aPathManager.findPath(roomContraller.findRoomByXYZ(chara.getCurrentRoom()), targetRoom, roomContraller);
                            }
                        }
                    }

                    else if (targetRoom.getXYZ()[2] == RoomConstant.ROOM_Z_DOWN)
                    {
                        // Debug.Log("目标是楼下,先定位到下楼梯口房间");
                        if (chara.getCurrentRoom()[2] == RoomConstant.ROOM_Z_GROUND)
                        {
                            //   Debug.Log("当前房间 是地面, 只要到向下楼梯房间");
                            if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_DOWNSTAIR, true))
                            {
                                return(false);
                            }
                            else
                            {
                                //
                                //     Debug.Log("现在同层了。。可以找最终目标房间了 :" + targetRoom);

                                path = aPathManager.findPath(roomContraller.findRoomByXYZ(chara.getCurrentRoom()), targetRoom, roomContraller);
                            }
                        }
                        else
                        {
                            if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_UPSTAIR_BACK, true))
                            {
                                return(false);
                            }
                            else
                            {
                                if (!AutoMoveManager.move(chara, roomContraller, eventController, diceRoll, aPathManager, RoomConstant.ROOM_TYPE_DOWNSTAIR, true))
                                {
                                    return(false);
                                }
                                else
                                {
                                    Debug.Log("现在同层了。。可以找最终目标房间了 :" + targetRoom);
                                    path = aPathManager.findPath(roomContraller.findRoomByXYZ(chara.getCurrentRoom()), targetRoom, roomContraller);
                                }
                            }
                        }
                    }
                }
                else
                {
                    if (chara.ActionPointrolled())
                    {
                        //  Debug.Log("如果目标房间同层,直接找路");
                        int speed = chara.getAbilityInfo()[1] + chara.getDiceNumberBuffer();
                        int res   = diceRoll.calculateDice(speed) + chara.getDiceValueBuffer();
                        chara.updateActionPoint(res);
                        chara.setActionPointrolled(false);
                    }
                    path = aPathManager.findPath(currentRoom, targetRoom, roomContraller);
                }
                while (chara.getActionPoint() > 0 && path.Count > 0)
                {
                    Node nextRoom = path.Peek();
                    bool opened   = false;
                    //判断向什么方向的房间
                    GameObject targetDoor = null;
                    if (chara.getCurrentRoom()[0] == nextRoom.xy[0] && chara.getCurrentRoom()[1] - nextRoom.xy[1] < 0)
                    {
                        //up room
                        //调用AI 专用方法

                        targetDoor = currentRoom.getNorthDoor();
                        //开门成功
                    }
                    else if (chara.getCurrentRoom()[0] == nextRoom.xy[0] && chara.getCurrentRoom()[1] - nextRoom.xy[1] > 0)
                    {
                        //down room
                        targetDoor = currentRoom.getSouthDoor();
                    }
                    else if (chara.getCurrentRoom()[1] == nextRoom.xy[1] && chara.getCurrentRoom()[0] - nextRoom.xy[0] < 0)
                    {
                        //east room
                        targetDoor = currentRoom.getEastDoor();
                    }
                    else
                    {
                        //west room
                        targetDoor = currentRoom.getWestDoor();
                    }

                    if (roomContraller.findRoomByXYZ(nextRoom.xy).checkOpen(chara))
                    {
                        //     Debug.Log("没有锁,可以开门");
                        opened = targetDoor.GetComponent <WoodDoor>().openDoor(chara);
                        //开门成功
                    }
                    else
                    {
                        //     Debug.Log("有锁,不可以开门");
                        if (typeof(NPC).IsAssignableFrom(chara.GetType()))
                        {
                            //      Debug.Log("我是npc,我要去找钥匙开门");
                            NPC npc = (NPC)chara;
                            npc.checkTargetRoomLocked(roomContraller.findRoomByXYZ(nextRoom.xy).getRoomType());
                            return(false);
                        }
                        else
                        {
                            //      Debug.Log("怪物无法发言,只能等门被打开。");
                        };
                    }


                    //如果进入房间是目标房间 暂时回合结束
                    if (opened)
                    {
                        bool result = eventController.excuteLeaveRoomEvent(currentRoom, chara);

                        //非正式测试用,只考虑行动力足够

                        if (result == true)
                        {
                            //离开门成功
                            path.Pop();
                            currentRoom.removeChara(chara);
                            roomContraller.setCharaInMiniMap(chara.getCurrentRoom(), chara, false);
                            //当前人物坐标移动到下一个房间
                            chara.setCurrentRoom(nextRoom.xy);
                            roomContraller.findRoomByXYZ(nextRoom.xy).setChara(chara);
                            roomContraller.setCharaInMiniMap(nextRoom.xy, chara, true);

                            //触发进门事件
                            //	eventController.excuteEnterRoomEvent (nextRoom, roundController.getCurrentRoundChar ());  暂时禁用 运行时有异常
                        }
                        else
                        {
                            //离开失败
                            //   Debug.Log("WoodDoor.cs OnMouseDown 离开房间失败");
                        }
                    }
                }

                //找到房间后, 如果还有体力值, 判定是否是上下楼的房间,如果是 直接上下楼
                if (chara.getActionPoint() > 0)
                {
                    if (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_UPSTAIR_BACK ||
                        targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_DOWNSTAIR || targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_DOWNSTAIR_BACK)
                    {
                        //   Debug.Log("找到目标房间了,但是行动力没有用完,直接上下楼");
                        RoomInterface stairRoom;
                        if (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_UPSTAIR)
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_UPSTAIR_BACK);
                        }
                        else if (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_UPSTAIR_BACK)
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_UPSTAIR);
                        }
                        else if (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_DOWNSTAIR)
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_DOWNSTAIR_BACK);
                        }
                        else
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_DOWNSTAIR);
                        }

                        targetRoom.removeChara(chara);
                        roomContraller.setCharaInMiniMap(chara.getCurrentRoom(), chara, false);
                        stairRoom.setChara(chara);
                        chara.setCurrentRoom(stairRoom.getXYZ());
                        chara.updateActionPoint(chara.getActionPoint() - SystemConstant.UPStairActionPoint);
                        roomContraller.setCharaInMiniMap(stairRoom.getXYZ(), chara, true);


                        return(true);
                    }
                }
            }
            else
            {
                if (chara.ActionPointrolled())
                {
                    // Debug.Log("如果目标房间同层,直接找路");
                    int speed = chara.getAbilityInfo()[1] + chara.getDiceNumberBuffer();
                    int res   = diceRoll.calculateDice(speed) + chara.getDiceValueBuffer();
                    chara.updateActionPoint(res);
                    chara.setActionPointrolled(false);
                }

                if (goUpOrDown && (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_UPSTAIR || targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_UPSTAIR_BACK ||
                                   targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_DOWNSTAIR || targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_DOWNSTAIR_BACK))
                {
                    //  Debug.Log("当前房间是上或者下楼口");
                    //找到房间后, 如果还有体力值, 判定是否是上下楼的房间,如果是 直接上下楼
                    if (chara.getActionPoint() > 0)
                    {
                        //     Debug.Log("找到目标房间了,但是行动力没有用完,直接上下楼");
                        RoomInterface stairRoom;
                        if (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_UPSTAIR)
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_UPSTAIR_BACK);
                        }
                        else if (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_UPSTAIR_BACK)
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_UPSTAIR);
                        }
                        else if (targetRoom.getRoomType() == RoomConstant.ROOM_TYPE_DOWNSTAIR)
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_DOWNSTAIR_BACK);
                        }
                        else
                        {
                            stairRoom = roomContraller.findRoomByRoomType(RoomConstant.ROOM_TYPE_DOWNSTAIR);
                        }

                        targetRoom.removeChara(chara);
                        roomContraller.setCharaInMiniMap(chara.getCurrentRoom(), chara, false);
                        stairRoom.setChara(chara);
                        chara.setCurrentRoom(stairRoom.getXYZ());
                        chara.updateActionPoint(chara.getActionPoint() - SystemConstant.UPStairActionPoint);
                        roomContraller.setCharaInMiniMap(stairRoom.getXYZ(), chara, true);

                        return(true);
                    }
                    else
                    {
                        //   Debug.Log("没有体力行动了");
                        return(false);
                    }
                }

                // Debug.Log("和目标房间 一起");
                return(true);
            }
        }
        else
        {
            Debug.Log("你已经丢过行动力骰子");
            return(false);
        }
        return(false);
    }
コード例 #13
0
    private static bool move(Character chara, RoomContraller roomContraller, EventController eventController, DiceRollCtrl diceRoll, APathManager aPathManager, int[] targetRoomXYZ, bool goUpOrDown)
    {
        RoomInterface targetRoom = roomContraller.findRoomByXYZ(targetRoomXYZ);

        return(doMove(chara, roomContraller, eventController, diceRoll, aPathManager, targetRoom, goUpOrDown));
    }