"use strict";
cc._RF.push(module, '62167uC4DxBcKgCTRWlKWsl', 'battle_controller');
// Scripts/mod/battle/battle_controller.js

"use strict";

// @author: xxx@syg.com(必填, 创建模块的人员)
// --------------------------------------------------------------------
// @description:
//      战斗控制器
// <br/>Create: 2018-11-28 19:19:19
// --------------------------------------------------------------------
var BattleEvent = require("battle_event");

var BattleConst = require("battle_const");

var MainuiController = require("mainui_controller");

var LevupgradeController = require("levupgrade_controller");

var MainuiEvent = require("mainui_event");

var BattleController = cc.Class({
  "extends": BaseController,
  ctor: function ctor() {},
  // 初始化配置数据
  initConfig: function initConfig() {
    // var BattleModel = require("battle_model");
    this.model = Utils.createClass("battle_model"); // var BattleHookModel = require("battle_hook_model");

    this.hook_model = Utils.createClass("battle_hook_model");
    this.model.initConfig();
    this.hook_model.initConfig();
    this.is_watch_replay = false; // 是否属于观战状态

    this.is_unlock_chapter = false; // 是否解锁章节中 

    this.is_normal_battle = false; // 是否是真战斗        

    this.finish_result_view_list = {}; // 胜利面板列表

    this.finish_fail_view_list = {}; // 失败面板列表;

    this.cache_list = []; //缓存界面列表
  },
  // 返回当前的model
  getModel: function getModel() {
    return this.model;
  },
  // 假战斗数据
  getHookModel: function getHookModel() {
    return this.hook_model;
  },
  // 注册监听事件
  registerEvents: function registerEvents() {
    if (this.loading_enter_scene == null) {
      this.loading_enter_scene = gcore.GlobalEvent.bind(MainuiEvent.LOADING_ENTER_SCENE, function () {
        this.showCachePanel();
      }.bind(this));
    }
  },
  // 注册协议接受事件
  registerProtocals: function registerProtocals() {
    this.RegisterProtocal(20027, this.scInitFightStart); // 战斗真正初始化数据,从0到1的战斗

    this.RegisterProtocal(20002, this.scRoundFightStart); // 回合开始的播报   -- 包含回合开始的buff

    this.RegisterProtocal(20004, this.scRoundFightOn); // 回合中的播报     -- 包含回合结束buff和效果播报的buff

    this.RegisterProtocal(20006, this.scFightEnd); // 战斗结算的,也就是真是战斗结束的

    this.RegisterProtocal(20008, this.scFightExit); // 退出战斗

    this.RegisterProtocal(20009, this.scSkipFirstTeam); // 跳过一队

    this.RegisterProtocal(20013, this.scReBattleFight); // 战斗重连,切进战斗或者短线重连的战斗

    this.RegisterProtocal(20014, this.scBattlePk); // 战斗切磋请求

    this.RegisterProtocal(20015, this.scBattlePkRe); // 战斗切磋返回

    this.RegisterProtocal(20016, this.scBattlePkTwice); // 战斗切磋同意

    this.RegisterProtocal(20020, this.scRoundNextFight); // 下一波怪物

    this.RegisterProtocal(20022, this.scFightSpeed); // 改变播放速度

    this.RegisterProtocal(20029, this.scRecordBattle); // 看录像

    this.RegisterProtocal(20033, this.handle20033); // 切磋结算

    this.RegisterProtocal(20034, this.handle20034); // 切磋视频分享

    this.RegisterProtocal(20036, this.handle20036); // 观看跨服录像,最后应该29协议全部转到这一条

    this.RegisterProtocal(20060, this.handle20060); // 请求战斗类型返回,这个时候只需要做对应ui操作的

    this.RegisterProtocal(20061, this.handle20061); // 假战斗初始化的,如果触发这个数据但是实际上是在真战斗中的时候,不做处理

    this.RegisterProtocal(20062, this.handle20062); // 跳过战斗
  },
  // 是否在战斗中
  isInFight: function isInFight() {
    return this.model.getFightStatus();
  },
  // 是否有战斗场景
  hadBattleScene: function hadBattleScene() {
    return this.model.getBattleScene() != null;
  },
  // 设置战斗场景的状态
  handleBattleSceneStatus: function handleBattleSceneStatus(status) {
    this.model.handleBattleSceneStatus(status);
  },
  // 根据战斗类型请求数据,r如果是切出战斗的话 则 combat_type:BattleConst.Fight_Type.Nil
  send20060: function send20060(combat_type) {
    cc.log("请求切出战斗");
    var protocal = {
      combat_type: combat_type
    };
    this.SendProtocal(20060, protocal);
  },
  //  返回战斗状态,
  handle20060: function handle20060(data) {
    // data.combat_type, data.type(0:不存在战斗 1:存在战斗 2:假战斗)
    if (data.combat_type == 0) {
      // 这个就是切出战斗,
      this.clearBattleScene();
    } else {}

    gcore.GlobalEvent.fire(BattleEvent.COMBAT_TYPE_BACK, data.combat_type, data.type);
  },
  // 战斗结算的,也有可能不需要出结算面板
  scFightEnd: function scFightEnd(data) {
    cc.log("战斗结算的,也有可能不需要出结算面板---", data);
    var is_replay = false;

    if (data.combat_type > 1000) {
      data.combat_type = data.combat_type - 1000;
      is_replay = true;
    }

    if (data.combat_type == BattleConst.Fight_Type.Endless) {
      var PromptController = require("prompt_controller");

      var PromptTypeConst = require("prompt_type_const");

      PromptController.getInstance().getModel().removePromptDataByTpye(PromptTypeConst.Endless_trail);
    }

    this.model.showWin(data, is_replay);
  },
  // 清理战斗场景,在退出战斗或者战斗结算之后,如果个战斗是剧情副本的战斗,那么就不需要清理掉场景,而是直接切换到假战斗
  clearBattleScene: function clearBattleScene() {
    this.model.clearBattleScene();
  },
  // 请求切出战斗
  requestCutOutBattle: function requestCutOutBattle() {
    var BattleConst = require("battle_const");

    this.send20060(BattleConst.Fight_Type.Nil);
  },
  // 战斗初始化数据
  scInitFightStart: function scInitFightStart(data) {
    var BattleConst = require("battle_const");

    if (BattleConst.canDoBattle(data.combat_type)) {
      this.model.updateCurBattleData(data, true);
      this.prepareLoaderBattleScene(data.combat_type, 2);
    }
  },
  // 切进战斗
  scReBattleFight: function scReBattleFight(data) {
    var BattleConst = require("battle_const");

    if (BattleConst.canDoBattle(data.combat_type)) {
      this.model.updateCurBattleData(data, false);
      this.prepareLoaderBattleScene(data.combat_type, 2);
    }
  },
  // 回合开始的播报
  scRoundFightStart: function scRoundFightStart(data) {
    Log.info("回合开始播报"); // cc.log(data);

    this.model.playRoundStart(data);
  },
  // 回合中的播报
  scRoundFightOn: function scRoundFightOn(data) {
    Log.info("回合播报"); // cc.log(data);

    this.model.playRoundIn(data);
  },
  // 回合播报结束通知服务端,对应的是20004
  csSkillPlayEnd: function csSkillPlayEnd() {
    Log.info("20004 播报完成");
    this.SendProtocal(20005, {});
  },
  // 回合开始播报完成之后,通知服务端,对应的是20002
  csRoundFightEnd: function csRoundFightEnd() {
    Log.info("20002 播报完成");
    this.SendProtocal(20019, {});
  },
  // 战斗初始化完成之后
  csReadyFightStart: function csReadyFightStart() {
    Log.info("战斗初始化完成,通知服务端可以开始播报了");
    this.SendProtocal(20001, {});
  },
  // 请求跳过战斗
  send20062: function send20062() {
    this.SendProtocal(20062, {});
  },
  handle20062: function handle20062(data) {
    message(data.msg);
  },
  // 假战斗数据
  handle20061: function handle20061(data) {
    cc.log("假战斗数据");
    cc.log(data);
    this.hook_model.updateUnrealBattleData(data);
    this.prepareLoaderBattleScene(data.combat_type, 1);
  },
  csRecordBattle: function csRecordBattle(replay_id) {
    var protocal = {};
    protocal.replay_id = replay_id;
    this.SendProtocal(20029, protocal);
  },
  // 战斗录像,这里只是记录战斗录像状态
  scRecordBattle: function scRecordBattle(data) {
    message(data.msg);

    if (data.code == 1) {
      // ChatController:getInstance():closeChatUseAction()
      this.setWatchReplayStatus(true);
    }
  },
  // 切磋结果返回
  handle20033: function handle20033(data) {
    if (data.combat_type == null) {
      data.combat_type = BattleConst.Fight_Type.PK;
    }

    if (data.show_panel_type == null) {
      data.show_panel_type = 1;
    }

    this.model.showWin(data);
  },
  // 分享切磋视频
  on20034: function on20034(replay_id, channel, target_name, share_type) {
    var protocal = {};
    protocal.replay_id = replay_id;
    protocal.channel = channel;
    protocal.target_name = target_name;
    protocal.share_type = share_type;
    this.SendProtocal(20034, protocal);
  },
  handle20034: function handle20034(data) {
    message(data.msg);
  },

  /**
   * 切换进战斗的唯一接口
   * @param {*} combat_type 
   * @param {*} in_fight_type 0:没有战斗 1:假战斗 2:真战斗
   */
  prepareLoaderBattleScene: function prepareLoaderBattleScene(combat_type, in_fight_type) {
    this.model.createBattleScene(in_fight_type, combat_type); // 进入战斗,抛出事件

    if (in_fight_type == 2) {
      gcore.GlobalEvent.fire(EventId.ENTER_FIGHT, combat_type, in_fight_type);
    }
  },

  /**
   * 下一波怪物的入口
   * @param {*} data 
   */
  scRoundNextFight: function scRoundNextFight(data) {
    if (data) {
      this.model.upDateNextMon(data);
    }
  },
  // 战斗每一帧更新
  update: function update(dt) {
    this.model.mapMovescheduleUpdate();
  },
  // 切换战斗背景移动状态,主要是用于真假剧情战斗切换
  changeMoveMapStatus: function changeMoveMapStatus(status) {
    this.model.changeMoveMapStatus();
  },
  // 查看录像返回
  sender_20036: function sender_20036(replay_id, replay_srv_id) {
    var protocal = {
      replay_id: replay_id,
      replay_srv_id: replay_srv_id
    };
    this.SendProtocal(20036, protocal);
  },
  handle20036: function handle20036(data) {
    if (data.code == 1) {
      this.setWatchReplayStatus(true);
    }
  },
  // 退出战斗
  csFightExit: function csFightExit() {
    this.SendProtocal(20008, {});
  },
  scFightExit: function scFightExit(data) {
    message(data.msg);
  },
  // 跳过一队
  csSkipFirstTeam: function csSkipFirstTeam() {
    this.SendProtocal(20009, {});
  },
  scSkipFirstTeam: function scSkipFirstTeam(data) {
    message(data.msg);
  },
  // 是否是观战状态
  getWatchReplayStatus: function getWatchReplayStatus() {
    return this.is_watch_replay;
  },
  // 设置观战状态
  setWatchReplayStatus: function setWatchReplayStatus(status) {
    this.is_watch_replay = status;
  },
  // 是否是观战或者切磋状态
  getIsClickStatus: function getIsClickStatus() {
    var combat_type = this.model.getCombatType();
    return this.getWatchReplayStatus() || combat_type == BattleConst.Fight_Type.PK || combat_type == BattleConst.Fight_Type.HeroTestWar;
  },
  setUnlockChapterStatus: function setUnlockChapterStatus(status) {
    this.is_unlock_chapter = status;
  },
  getUnlockChapterStatus: function getUnlockChapterStatus() {
    return this.is_unlock_chapter;
  },
  //进入主场景后显示缓存的界面
  showCachePanel: function showCachePanel() {
    if (this.cache_list == null || this.cache_list.length <= 0) return;

    for (var i in this.cache_list) {
      if (this.cache_list[i]["function"]) {
        this.cache_list[i]["function"]();
      }
    }

    this.cache_list = [];
  },
  // 战斗结算界面
  openFinishView: function openFinishView(status, combat_type, data) {
    if (status == true) {
      if (IS_LOADING == true) {
        this.cache_list.push({
          "function": function (status, combat_type, data) {
            this.openFinishView(status, combat_type, data);
          }.bind(this, status, combat_type, data)
        });
        return;
      }

      if (this.finish_result_view_list[combat_type]) {
        this.finish_result_view_list[combat_type].close();
        this.finish_result_view_list[combat_type] = null;
      }

      if (!this.is_unlock_chapter) {
        if (combat_type == BattleConst.Fight_Type.StarTower) {
          //试炼塔
          var StartowerController = require("startower_controller");

          StartowerController.getInstance().openResultWindow(true, data);
        } else if (combat_type == BattleConst.Fight_Type.Arena) {
          var ArenaController = require("arena_controller");

          ArenaController.getInstance().openLoopResultWindow(true, data);
        } else if (combat_type == BattleConst.Fight_Type.Darma && data && data.result == 1) {
          //剧情副本战斗胜利时
          //设置不要马上显示升级
          LevupgradeController.getInstance().waitForOpenLevUpgrade(true);

          var BattleMvpWindow = require("battle_mvp_window");

          this.finish_result_view_list[combat_type] = new BattleMvpWindow(data);
          this.finish_result_view_list[combat_type].open();
        } else if (combat_type == BattleConst.Fight_Type.GuildDun) {
          //公会副本
          require("guildboss_controller").getInstance().openGuildbossResultWindow(true, data);
        } else if (combat_type == BattleConst.Fight_Type.PK) {
          // PK
          this.finish_result_view_list[combat_type] = Utils.createClass("battle_pk_result_window");
          this.finish_result_view_list[combat_type].open(data);
        } else {
          if (!this.finish_result_view_list[combat_type]) {
            if (data.result == 1) {
              //设置不要马上显示升级
              LevupgradeController.getInstance().waitForOpenLevUpgrade(true);

              var BattleResultView = require("battle_result_window");

              this.finish_result_view_list[combat_type] = new BattleResultView(data.result, combat_type);
              this.finish_result_view_list[combat_type].open({
                data: data,
                fight_type: combat_type
              });
            } else {
              cc.log("打开失败界面");
              this.openFailFinishView(true, combat_type, data.result, data);
            }
          }
        }
      }
    } else {
      if (this.finish_result_view_list[combat_type]) {
        this.finish_result_view_list[combat_type].close();
        this.finish_result_view_list[combat_type] = null;
      }
    }
  },
  getFinishView: function getFinishView(combat_type) {
    if (this.finish_result_view_list) {
      return this.finish_result_view_list[combat_type];
    }
  },
  //打开战斗伤害统计界面
  openBattleHarmInfoView: function openBattleHarmInfoView(status, data) {
    if (status == true) {
      if (this.harm_info_view == null) {
        this.harm_info_view = Utils.createClass("battle_harm_info_window");
      }

      this.harm_info_view.open(data);
    } else {
      if (this.harm_info_view) {
        this.harm_info_view.close();
        this.harm_info_view = null;
      }
    }
  },
  //失败结算界面
  openFailFinishView: function openFailFinishView(status, combat_type, result, data) {
    if (status == true) {
      //如果是在剧情中,则不需要弹出这些
      // if(require("guide_controller").getInstance().isInGuide())return
      if (!this.is_unlock_chapter) {
        if (!this.finish_fail_view_list[combat_type]) {
          //设置不要马上显示升级
          LevupgradeController.getInstance().waitForOpenLevUpgrade(true);

          var BattleFailView = require("battle_fail_window");

          var finish_view = new BattleFailView(combat_type, result, data);

          if (finish_view) {
            finish_view.open();
          }

          this.finish_fail_view_list[combat_type] = finish_view;
        }
      } else {
        if (MainuiController.getInstance().checkIsInDramaUIFight()) {
          this.battle_controller.send20060(BattleConst.Fight_Type.Darma);
        }
      }
    } else {
      if (this.finish_fail_view_list[combat_type]) {
        this.finish_fail_view_list[combat_type].close();
        this.finish_fail_view_list[combat_type] = null;
      }
    }
  },
  //获取是否相同的战斗类型
  getIsSameBattleType: function getIsSameBattleType(combat_type) {
    return combat_type == this.model.getCombatType();
  },
  // -- 打开阵营详细面板
  openBattleCampView: function openBattleCampView(status, form_id) {
    if (status == true) {
      if (!this.battle_camp_view) {
        var BattleCampView = require("battle_camp_window");

        this.battle_camp_view = new BattleCampView();
      }

      if (this.battle_camp_view.isOpen() == false) {
        this.battle_camp_view.open(form_id);
      }
    } else {
      if (this.battle_camp_view) {
        this.battle_camp_view.close();
        this.battle_camp_view = null;
      }
    }
  },
  // 记录是否为假战斗的战斗
  setIsNormaBattle: function setIsNormaBattle(status) {
    this.is_normal_battle = status;
  },
  // 是否是假战斗....
  getIsNoramalBattle: function getIsNoramalBattle() {
    return this.is_normal_battle;
  },
  // 改变战斗速度
  csFightSpeed: function csFightSpeed(speed) {
    var protocal = {};
    protocal.speed = speed;
    this.SendProtocal(20022, protocal);
  },
  scFightSpeed: function scFightSpeed(data) {
    message(data.msg);
  },
  getCtrlBattleScene: function getCtrlBattleScene(cal_back) {
    var battle_scen = this.model.getBattleScene();
    cal_back(battle_scen);
  },
  getDramaFightUI: function getDramaFightUI(finish_cb) {
    if (finish_cb) {
      finish_cb(this.model.getDramaFightUI());
    } else {
      if (this.model) return this.model.getDramaFightUI();
    }
  },
  // ---------------------切磋请求
  csBattlePk: function csBattlePk(target_id, target_srv_id, is_province) {
    var protocal = {};
    protocal.target_id = target_id;
    protocal.target_srv_id = target_srv_id;
    protocal.is_province = is_province;
    this.SendProtocal(20014, protocal);
  },
  scBattlePk: function scBattlePk(data) {
    message(data.msg);

    require("chat_controller").getInstance().closeChatPanel(false);

    require("friend_controller").getInstance().openFriendCheckPanel(false);
  },
  // 被切磋对象,在18600收到提示之后,调用这个接口同意或者取消掉
  confirmBattlePk: function confirmBattlePk(promptVo) {},
  // 被切磋对象,同意切磋或者拒绝切磋
  csBattlePkRe: function csBattlePkRe(bool, data) {
    var protocal = {};
    protocal.target_id = data.target_id;
    protocal.target_srv_id = data.target_srv_id;
    protocal.is_agree = bool ? 1 : 0;
    this.SendProtocal(20015, protocal);
  },
  scBattlePkRe: function scBattlePkRe(data) {
    message(data.msg);
  },
  // 目标这统一了自己发起的请求.这时候自己的二次确认
  scBattlePkTwice: function scBattlePkTwice(data) {
    if (data) {
      if (!this.isInFight()) {
        var accept_fun = function () {
          this.csBattlePkTwiceConfirm(true, {
            target_srv_id: data.target_srv_id,
            target_id: data.target_id
          });
        }.bind(this);

        var refuse_fun = function () {
          this.csBattlePkTwiceConfirm(false, {
            target_srv_id: data.target_srv_id,
            target_id: data.target_id
          });
        }.bind(this);

        var desc = cc.js.formatStr(Utils.TI18N("玩家<color=#0x249015>%s</color>同意了你的切磋请求,点击”立即切磋“立即进入切磋战斗？"), data.target_name || "");

        require("commonalert").show(desc, Utils.TI18N("立即切磋"), accept_fun, Utils.TI18N("取消"), refuse_fun);
      }
    }
  },
  // 发起者同意进战斗或者拒绝
  csBattlePkTwiceConfirm: function csBattlePkTwiceConfirm(bool, data) {
    var protocal = {};
    protocal.target_id = data.target_id;
    protocal.target_srv_id = data.target_srv_id;
    protocal.is_agree = bool ? 1 : 0;
    ;
    this.SendProtocal(20016, protocal);
  },
  //  打开buff总览界面
  openBattleBuffInfoView: function openBattleBuffInfoView(status, left_name, right_name) {
    if (status == true) {
      if (this.buff_info_view == null) {
        var BattleBuffInfoView = require("battle_buff_info_window");

        this.buff_info_view = new BattleBuffInfoView();
      }

      if (this.buff_info_view.isOpen() == false) {
        this.buff_info_view.open({
          left_name: left_name,
          right_name: right_name
        });
      }
    } else {
      if (this.buff_info_view) {
        this.buff_info_view.close();
        this.buff_info_view = null;
      }
    }
  },
  // - 更新buff列表界面数据
  updateBattleBuffListView: function updateBattleBuffListView(data, group, partner_bid) {
    if (this.buff_list_view && this.buff_list_view.checkIsChosedBuffList(group, partner_bid)) {
      this.buff_list_view.setData(data);
    }
  },
  // -- 打开buff列表界面
  openBattleBuffListView: function openBattleBuffListView(status, data, group, partner_bid) {
    if (status == true) {
      if (this.buff_list_view == null) {
        var BattleBuffListView = require("battle_buff_list_window");

        this.buff_list_view = new BattleBuffListView();
      }

      if (this.buff_list_view.isOpen() == false) {
        this.buff_list_view.open({
          data: data,
          group: group,
          partner_bid: partner_bid
        });
      }
    } else {
      if (this.buff_list_view) {
        this.buff_list_view.close();
        this.buff_list_view = null;
      }
    }
  }
});
module.exports = BattleController;

cc._RF.pop();