962 lines
34 KiB
JavaScript
962 lines
34 KiB
JavaScript
"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 BridgeController = require("bridge.controller");
|
|
var BattleEvent = require("battle_event");
|
|
var BattleConst = require("battle_const");
|
|
var MainuiEvent = require("mainui_event");
|
|
var BattleRolePool = require("battle_role_pool");
|
|
var FID = require("bridge.function.ids");
|
|
var BattleController = cc.Class({
|
|
"extends": BridgeController,
|
|
name: "BattleController",
|
|
// 销毁
|
|
onDestroy: function onDestroy() {
|
|
// 强制清除scene
|
|
this.openDramaFightUI(false);
|
|
this.model.closeFormView();
|
|
this.clearBattleScene();
|
|
if (BattleRolePool.getInstance) {
|
|
BattleRolePool.getInstance().clearCachePool();
|
|
delete BattleRolePool.instance;
|
|
BattleRolePool.instance = null;
|
|
}
|
|
this._super();
|
|
},
|
|
// 初始化配置数据
|
|
initConfig: function initConfig() {
|
|
this.model = Utils.createClass("battle_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 = []; //缓存界面列表
|
|
this.is_watch_witness = false; // --是否为观战状态
|
|
this.init_fight_status = false;
|
|
this.circle_round_data = null; // --挂机缓存数据
|
|
this.cur_fight_type = 0;
|
|
this.is_battle_start = false; //--是否已进入战斗状态
|
|
this.is_pk_battle = false; //--是否切磋状态
|
|
this.extend_fight_type = BattleConst.Fight_Type.Darma; //--额外的战斗类型记录
|
|
this.fighting_type_list = {};
|
|
this.is_drama_result = false;
|
|
this.sum_lev = 0; // --己方总等级
|
|
this.enemy_lev = 0; //--敌方总等级
|
|
|
|
//关于假数据
|
|
this.is_battle_hook_wait = false; //开始假挂机数据等待
|
|
this.battle_test_data = {};
|
|
this.is_test_skip = false;
|
|
|
|
//特殊·结算
|
|
this.special_results = {};
|
|
},
|
|
// 返回当前的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));
|
|
}
|
|
|
|
//请求进入竞技场之前，需要告诉服务器，我要进去了，有没有真是战斗，快点告诉我
|
|
if (this.combat_type_back_event == null) {
|
|
this.combat_type_back_event = gcore.GlobalEvent.bind(BattleEvent.COMBAT_TYPE_BACK, function (combat_type, type) {
|
|
if (type === 0) {
|
|
//不存在战斗
|
|
this.openRelevanceWindowAtOnce(combat_type);
|
|
}
|
|
// else{
|
|
// let config = game.configs.combat_type_data.data_fight_list[combat_type];
|
|
// if(config && config.des){
|
|
// let tip = cc.js.formatStr(nx.text.getKey("battle_loading_tip"),config.des);
|
|
// return nx.tbox(tip);
|
|
// }
|
|
// }
|
|
}, this);
|
|
}
|
|
|
|
// 退出战斗需要打开进入战斗之前的一些窗体
|
|
if (!this.battle_exit_event) {
|
|
this.battle_exit_event = gcore.GlobalEvent.bind(EventId.EXIT_FIGHT, function (combat_type) {
|
|
this.openRelevanceWindowAtOnce(combat_type);
|
|
}.bind(this));
|
|
}
|
|
},
|
|
// 注册协议接受事件
|
|
registerProtocals: function registerProtocals() {
|
|
this.RegisterProtocal(20027, this.scInitFightStart); // 战斗真正初始化数据,从0到1的战斗
|
|
this.RegisterProtocal(20001, this.handle20001);
|
|
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); // 跳过战斗
|
|
this.RegisterProtocal(20063, this.handle20063);
|
|
this.RegisterProtocal(20064, this.handle20064); //直接请求通关
|
|
this.RegisterProtocal(20065, this.handle20065); //新版战斗总回合数
|
|
this.RegisterProtocal(20066, this.handle20066); //无尽试炼下波次上报
|
|
this.RegisterProtocal(20070, this.handle20070);
|
|
this.RegisterProtocal(20080, this.handle20080);
|
|
},
|
|
reqBaseFromServer: function reqBaseFromServer(_cb) {
|
|
// 配置加载
|
|
var cfgs = ["battle_act_data",
|
|
// 英雄战斗模型
|
|
"battle_bg_data",
|
|
// 战斗场景
|
|
"buff_data",
|
|
// buff
|
|
"combat_halo_data",
|
|
// 阵容光环配置
|
|
"combat_type_data",
|
|
// 战斗配置（类型、天平模式、倍速等）
|
|
"battle_lens_data"];
|
|
this.loadConfigs(cfgs, function (_ret, _data) {
|
|
nx.dt.fnInvoke(_cb, true);
|
|
});
|
|
},
|
|
openDramaFightUI: function openDramaFightUI(status) {
|
|
if (this.show_fight_ui_status == status && this.fight_ui_combat == this.model.getFightStatus()) {
|
|
return;
|
|
}
|
|
this.show_fight_ui_status = status;
|
|
this.fight_ui_combat = this.model.getFightStatus();
|
|
if (!status) {
|
|
nx.bridge.closePanel("WndBattleHook");
|
|
this.model.setBattleListPanelTime();
|
|
} else {
|
|
nx.bridge.createPanel("WndBattleHook", {
|
|
is_real_combat: this.model.getFightStatus()
|
|
});
|
|
this.model.setBattleListPanelTime(0);
|
|
}
|
|
this.setIsNormaBattle(this.model.getFightStatus());
|
|
this.model.startCountDownToDelete();
|
|
},
|
|
// 是否在战斗中
|
|
isInFight: function isInFight() {
|
|
return this.model.getFightStatus();
|
|
},
|
|
// 是否有战斗场景
|
|
hadBattleScene: function hadBattleScene() {
|
|
return this.model.getBattleScene() != null;
|
|
},
|
|
// 设置战斗场景的状态
|
|
handleBattleSceneStatus: function handleBattleSceneStatus(status) {
|
|
this.model.handleBattleSceneStatus(status);
|
|
},
|
|
handle20001: function handle20001(data) {},
|
|
// 根据战斗类型请求数据,r如果是切出战斗的话 则 combat_type:BattleConst.Fight_Type.Nil
|
|
send20060: function send20060(combat_type, _cb) {
|
|
var protocal = {
|
|
combat_type: combat_type
|
|
};
|
|
this.SendProtocal(20060, protocal, _cb);
|
|
|
|
//新版战斗需要清除参数
|
|
if (this.isInFight()) {}
|
|
},
|
|
// 返回战斗状态,
|
|
handle20060: function handle20060(data) {
|
|
if (data.combat_type == 0) {
|
|
// 这个就是切出战斗,
|
|
this.clearBattleScene();
|
|
} else {}
|
|
gcore.GlobalEvent.fire(BattleEvent.COMBAT_TYPE_BACK, data.combat_type, data.type);
|
|
},
|
|
send20070: function send20070(id, _cb) {
|
|
var protocal = {
|
|
id: id
|
|
};
|
|
this.SendProtocal(20070, protocal, _cb);
|
|
},
|
|
// 返回战斗状态,
|
|
handle20070: function handle20070(data) {
|
|
if (!this.isGoodData(data)) {
|
|
return;
|
|
}
|
|
if (data.id != null) {
|
|
this.show_bat_id = data.id;
|
|
}
|
|
},
|
|
getShowBatID: function getShowBatID() {
|
|
return this.show_bat_id;
|
|
},
|
|
OutResult: function OutResult() {
|
|
this.SendProtocal(20080, {});
|
|
},
|
|
handle20080: function handle20080(_data) {
|
|
if (!this.isGoodData(_data)) {
|
|
return;
|
|
}
|
|
},
|
|
handle20063: function handle20063(data) {
|
|
if (data.type_list) {
|
|
this.in_bat_list = data.type_list;
|
|
}
|
|
},
|
|
send20064: function send20064(combat_type) {
|
|
var protocal = {
|
|
combat_type: combat_type
|
|
};
|
|
this.SendProtocal(20064, protocal);
|
|
},
|
|
handle20064: function handle20064(data) {
|
|
console.log(data);
|
|
},
|
|
handle20065: function handle20065(data) {},
|
|
send20066: function send20066(wave) {
|
|
var protocal = {
|
|
wave: wave
|
|
};
|
|
this.SendProtocal(20066, protocal);
|
|
},
|
|
handle20066: function handle20066(data) {},
|
|
waitOvertimeBattleHook: function waitOvertimeBattleHook() {
|
|
var _this = this;
|
|
if (!this.connect_timer) {
|
|
this.connect_timer = gcore.Timer.set(function () {
|
|
if (_this.is_battle_hook_wait) {
|
|
_this.is_battle_hook_wait = false; //关闭
|
|
gcore.GlobalEvent.fire(BattleEvent.COMBAT_TYPE_BACK, 3, 2); //锁定假战斗
|
|
}
|
|
}, 1000, 1);
|
|
}
|
|
},
|
|
pushBattleResultData: function pushBattleResultData(data) {},
|
|
// 战斗结算的,也有可能不需要出结算面板
|
|
scFightEnd: function scFightEnd(data) {
|
|
if (data.show_panel_type == 1 || data.combat_type == BattleConst.Fight_Type.LadderWar) {
|
|
nx.bridge.vset("ResultInfo", data);
|
|
}
|
|
var is_replay = false;
|
|
if (data.combat_type > 1000) {
|
|
data.combat_type = data.combat_type - 1000;
|
|
is_replay = true;
|
|
}
|
|
this.model.showWin(data, is_replay);
|
|
},
|
|
// 清理战斗场景,在退出战斗或者战斗结算之后,如果个战斗是剧情副本的战斗,那么就不需要清理掉场景,而是直接切换到假战斗
|
|
clearBattleScene: function clearBattleScene() {
|
|
this.model.clearBattleScene();
|
|
},
|
|
// 请求切出战斗
|
|
requestCutOutBattle: function requestCutOutBattle(_cb) {
|
|
this.send20060(BattleConst.Fight_Type.Nil, _cb);
|
|
},
|
|
// 战斗初始化数据
|
|
scInitFightStart: function scInitFightStart(data) {
|
|
var skip = nx.storage.get("vip_skip");
|
|
if (Number(skip) == 1) return;
|
|
if (this.is_test_skip) {
|
|
this.is_test_skip = false;
|
|
return;
|
|
}
|
|
if (BattleConst.canDoBattle(data.combat_type)) {
|
|
if (data.combat_type == 35 || data.combat_type == 27) {//组队竞技场
|
|
//加一个开始标志
|
|
// this.model.setInitFightData( data );
|
|
} else {
|
|
// this.model.setArenaTeamStart( false );
|
|
}
|
|
// if( this.model.isArenaTeamStart() ) return;
|
|
|
|
//设置最大回合数
|
|
// this.model.setMaxActionCount( game.configs.combat_type_data.data_fight_list[ data.combat_type ].max_action_count );
|
|
this.model.updateCurBattleData(data, true);
|
|
this.prepareLoaderBattleScene(data.combat_type, 2);
|
|
}
|
|
},
|
|
// 切进战斗
|
|
scReBattleFight: function scReBattleFight(data) {
|
|
if (BattleConst.canDoBattle(data.combat_type)) {
|
|
this.model.updateCurBattleData(data, false);
|
|
this.prepareLoaderBattleScene(data.combat_type, 2);
|
|
}
|
|
},
|
|
// 回合开始的播报
|
|
scRoundFightStart: function scRoundFightStart(data) {
|
|
if (nx.dt.objEmpty(data)) return;
|
|
nx.debug("回合开始播报");
|
|
this.model.playRoundStart(data);
|
|
},
|
|
// 回合中的播报
|
|
scRoundFightOn: function scRoundFightOn(data) {
|
|
if (nx.dt.objEmpty(data)) return;
|
|
nx.debug("回合播报");
|
|
this.model.playRoundIn(data);
|
|
},
|
|
// 回合播报结束通知服务端,对应的是20004
|
|
csSkillPlayEnd: function csSkillPlayEnd() {
|
|
nx.debug("20004 播报完成");
|
|
this.SendProtocal(20005, {});
|
|
},
|
|
// 回合开始播报完成之后,通知服务端,对应的是20002
|
|
csRoundFightEnd: function csRoundFightEnd() {
|
|
nx.debug("20002 播报完成");
|
|
this.SendProtocal(20019, {});
|
|
},
|
|
// 战斗初始化完成之后
|
|
csReadyFightStart: function csReadyFightStart() {
|
|
nx.debug("战斗初始化完成,通知服务端可以开始播报了");
|
|
this.SendProtocal(20001, {});
|
|
},
|
|
// 请求跳过战斗
|
|
send20062: function send20062() {
|
|
this.SendProtocal(20062, {});
|
|
},
|
|
handle20062: function handle20062(data) {
|
|
if (!this.isGoodData(data)) {
|
|
return;
|
|
}
|
|
},
|
|
// 假战斗数据
|
|
handle20061: function handle20061(data) {
|
|
cc.log("假战斗数据");
|
|
|
|
//清除假数据
|
|
this.is_battle_hook_wait = false;
|
|
if (this.connect_timer) {
|
|
gcore.Timer.del(this.connect_timer);
|
|
this.connect_timer = null;
|
|
}
|
|
if (this.hook_model) {
|
|
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) {
|
|
nx.tbox(data.msg);
|
|
if (data.code == 1) {
|
|
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 = 2;
|
|
nx.bridge.vset("ResultInfo", data);
|
|
}
|
|
this.model.showWin(data);
|
|
},
|
|
newPKResultWin: function newPKResultWin() {
|
|
// if( !this.battle_pk_result_data ) return;
|
|
// let data = this.battle_pk_result_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( this.battle_pk_result_data );
|
|
// this.battle_pk_result_data = null;
|
|
},
|
|
// 分享切磋视频
|
|
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) {
|
|
nx.tbox(data.msg);
|
|
},
|
|
/**
|
|
* 切换进战斗的唯一接口
|
|
* @param {*} combat_type
|
|
* @param {*} in_fight_type 0:没有战斗 1:假战斗 2:真战斗
|
|
*/
|
|
prepareLoaderBattleScene: function prepareLoaderBattleScene(combat_type, in_fight_type) {
|
|
if (combat_type == 1) {
|
|
//gm测试战斗
|
|
this.ui_fight_type = 1;
|
|
}
|
|
if (this.ui_fight_type == 0) return;
|
|
if (this.model) {
|
|
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(dt);
|
|
},
|
|
// 切换战斗背景移动状态,主要是用于真假剧情战斗切换
|
|
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) {
|
|
nx.tbox(data.msg);
|
|
},
|
|
// 跳过一队
|
|
csSkipFirstTeam: function csSkipFirstTeam() {
|
|
this.SendProtocal(20009, {});
|
|
},
|
|
scSkipFirstTeam: function scSkipFirstTeam(data) {
|
|
nx.tbox(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 = [];
|
|
},
|
|
//特殊結算
|
|
pushSpecialRetInfo: function pushSpecialRetInfo(combat_type, data) {
|
|
this.special_results[combat_type] = data;
|
|
|
|
//如果當前戰鬥就是目標戰鬥，那就直接結算
|
|
if (this.model.getCombatType() == 0) {
|
|
//this.getIsSameBattleType(combat_type) ||
|
|
this.checkSpecialResults();
|
|
}
|
|
},
|
|
//每次特殊結算界面關閉時，清除目標數據
|
|
delSpecialRetInfo: function delSpecialRetInfo(combat_type) {
|
|
if (this.special_results[combat_type]) {
|
|
console.log("特殊结算缓存清除");
|
|
delete this.special_results[combat_type];
|
|
}
|
|
},
|
|
checkSpecialResults: function checkSpecialResults() {
|
|
console.log("特殊结算展示");
|
|
for (var type in this.special_results) {
|
|
nx.bridge.createPanel("WndSpecialSettle", {
|
|
data: this.special_results[type]
|
|
});
|
|
return;
|
|
}
|
|
},
|
|
// 战斗结算界面
|
|
openFinishView: function openFinishView(status, combat_type, data) {
|
|
if (status == true) {
|
|
if (!this.is_unlock_chapter) {
|
|
if (combat_type == BattleConst.Fight_Type.LadderWar) {
|
|
nx.storage.set("battleArena", FID.CrossLadder);
|
|
gcore.GlobalEvent.fire(BattleEvent.DISPENSE_TYPE_RESLUT);
|
|
} else if (combat_type == BattleConst.Fight_Type.Arean_Team) {//組隊競技場
|
|
// var ArenateamController = require("arenateam_controller")
|
|
// ArenateamController.getInstance().openArenateamFightResultPanel(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 (combat_type == BattleConst.Fight_Type.Arena) {
|
|
//自己有自己的结算界面
|
|
|
|
nx.storage.set("battleArena", FID.Arena);
|
|
gcore.GlobalEvent.fire(BattleEvent.DISPENSE_TYPE_RESLUT);
|
|
} else if (combat_type == BattleConst.Fight_Type.Adventrue) {
|
|
var _data2 = nx.bridge.vget("ResultInfo");
|
|
this.model.result(_data2, null);
|
|
nx.bridge.vset("ResultInfo", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.Training_Camp) {
|
|
nx.storage.set("battleArena", FID.NewTrain);
|
|
// nx.bridge.createPanel( "WndTrainingCamp" );
|
|
}
|
|
// else if(combat_type == 3 || combat_type == 7){
|
|
// if(data.result == 1){
|
|
// this.checkSpecialResults(combat_type);
|
|
// }else{
|
|
// if( combat_type != 0 ){
|
|
// this.openOtherFinish( combat_type );
|
|
// }
|
|
// }
|
|
// }
|
|
else {
|
|
if (data.result == 1) {
|
|
//设置不要马上显示升级
|
|
// LevupgradeController.getInstance().waitForOpenLevUpgrade(true)
|
|
if (combat_type == 0) {
|
|
gcore.GlobalEvent.fire(BattleEvent.DISPENSE_TYPE_RESLUT);
|
|
return;
|
|
}
|
|
this.openOtherFinish(combat_type);
|
|
} else {
|
|
// cc.log( "打开失败界面" )
|
|
if (combat_type != 0) {
|
|
this.openOtherFinish(combat_type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} 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;
|
|
// }
|
|
// }
|
|
},
|
|
//主要用于结算id不等于20006的结算功能
|
|
openOtherFinish: function openOtherFinish(combat_type) {
|
|
if (this.getIsSameBattleType(combat_type)) {
|
|
var data = nx.bridge.vget("ResultInfo");
|
|
if (data.result) {
|
|
if (data.result == 1) {
|
|
//成功
|
|
this.openWinFinishView(true, combat_type);
|
|
// nx.bridge.Tag2PanelClose("WndWinSettle");
|
|
} else {
|
|
//失败
|
|
this.openFailFinishView(true, combat_type);
|
|
// nx.bridge.Tag2PanelClose("WndFailSettle");
|
|
}
|
|
|
|
nx.bridge.vset("DailyPop", 1);
|
|
} else {//不需要结算数据
|
|
}
|
|
}
|
|
},
|
|
openWinFinishView: function openWinFinishView(status, combat_type) {
|
|
if (status) {
|
|
if (!this.is_unlock_chapter) {
|
|
//设置不要马上显示升级
|
|
var data = nx.bridge.vget("ResultInfo");
|
|
if (data.combat_type != combat_type) return;
|
|
nx.bridge.createPanel("WndWinSettle", {
|
|
combat_type: combat_type
|
|
});
|
|
} else {
|
|
this.battle_controller.send20060(BattleConst.Fight_Type.Darma);
|
|
}
|
|
} else {
|
|
nx.bridge.closePanel("WndWinSettle");
|
|
nx.bridge.vset("ResultInfo", {});
|
|
}
|
|
},
|
|
//失败结算界面
|
|
openFailFinishView: function openFailFinishView(status, combat_type) {
|
|
if (status) {
|
|
if (!this.is_unlock_chapter) {
|
|
//设置不要马上显示升级
|
|
nx.bridge.createPanel("WndFailSettle", {
|
|
combat_type: combat_type
|
|
});
|
|
} else {
|
|
this.battle_controller.send20060(BattleConst.Fight_Type.Darma);
|
|
}
|
|
} else {
|
|
nx.bridge.closePanel("WndFailSettle");
|
|
nx.bridge.vset("ResultInfo", {});
|
|
}
|
|
},
|
|
//获取是否相同的战斗类型
|
|
getIsSameBattleType: function getIsSameBattleType(combat_type) {
|
|
return combat_type == this.model.getCombatType();
|
|
},
|
|
getIsInBattleing: function getIsInBattleing(combat_type) {
|
|
for (var i in this.in_bat_list) {
|
|
var type = this.in_bat_list[i];
|
|
if (type != 11 && combat_type == type) {
|
|
//非无尽试炼
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
// -- 打开阵营详细面板
|
|
openBattleCampView: function openBattleCampView(status, form_id) {
|
|
if (status == true) {
|
|
nx.bridge.createPanel("WndBattkeCamp", {
|
|
form_id: form_id
|
|
});
|
|
} else {
|
|
nx.bridge.closePanel("WndBattkeCamp");
|
|
}
|
|
},
|
|
// 记录是否为假战斗的战斗
|
|
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) {
|
|
if (data.code == 0) {
|
|
nx.tbox(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) {
|
|
nx.tbox(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) {
|
|
nx.tbox(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 || "");
|
|
nx.mbox(desc, ["cancel", "confirm"], function (_key, _box) {
|
|
if (_key == "cancel") {
|
|
refuse_fun();
|
|
} else if (_key == "confirm") {
|
|
accept_fun();
|
|
}
|
|
}, "friend_str12");
|
|
}
|
|
}
|
|
},
|
|
// 发起者同意进战斗或者拒绝
|
|
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) {
|
|
nx.bridge.createPanel("WndBattleBuffInfo", {
|
|
left_name: left_name,
|
|
right_name: right_name
|
|
});
|
|
} else {
|
|
nx.bridge.closePanel("WndBattleBuffInfo");
|
|
}
|
|
},
|
|
// - 更新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) {
|
|
nx.bridge.createPanel("WndBattleBuffList", {
|
|
data: data,
|
|
group: group,
|
|
partner_bid: partner_bid
|
|
});
|
|
} else {
|
|
nx.bridge.closePanel("WndBattleBuffList");
|
|
}
|
|
},
|
|
openBattleView: function openBattleView(status, combat_type) {
|
|
if (status) this.createMap(null, BattleConst.Fight_Type.Darma);else {
|
|
if (this.resources_load) {
|
|
this.resources_load.DeleteMe();
|
|
this.resources_load = null;
|
|
}
|
|
this.setCurFightType(0);
|
|
this.send20060(0);
|
|
this.circle_round_data = null;
|
|
// 這個地方感覺需要判斷當前是不是在戰鬥中,否則這裡也會拋出退出戰鬥事件
|
|
this.clear(true);
|
|
}
|
|
},
|
|
clear: function clear(is_change) {
|
|
this.model.clear(true);
|
|
this.battle_hook_model.battleclear();
|
|
var is_detele = this.getExtendFightType() != BattleConst.Fight_Type.Darma || this.cur_fight_type == 0;
|
|
if (this.battle_scene && !tolua.isnull(this.battle_scene)) {
|
|
if (is_detele == true || is_change == true) {
|
|
if (this.resources_load) {
|
|
this.resources_load.DeleteMe();
|
|
this.resources_load = null;
|
|
}
|
|
this.battle_scene.cleanFightView();
|
|
this.battle_scene.destroy();
|
|
this.battle_scene = null;
|
|
this.fight_type = null;
|
|
}
|
|
}
|
|
},
|
|
setCurFightType: function setCurFightType(fight_type) {
|
|
this.cur_fight_type = fight_type;
|
|
},
|
|
/*****战斗面板切换 */
|
|
// 获取当前的面板
|
|
getUIFightType: function getUIFightType() {
|
|
return this.ui_fight_type;
|
|
},
|
|
// 设置当前面板数据
|
|
setUIFightType: function setUIFightType(value) {
|
|
this.ui_fight_type = value;
|
|
},
|
|
// 是否在剧情副本界面
|
|
checkIsInDramaUIFight: function checkIsInDramaUIFight() {
|
|
return this.ui_fight_type == 4;
|
|
},
|
|
// 请求打开战斗相关的窗体,同时也包含了剧情副本的
|
|
requestOpenBattleRelevanceWindow: function requestOpenBattleRelevanceWindow(battle_type, params, _cb) {
|
|
this.relevance_ui_last_type = this.ui_fight_type;
|
|
this.relevance_battle_type = battle_type;
|
|
this.relevance_params = params;
|
|
this.relevance_ui_fight_type = BattleConst.getUIFightByFightType(battle_type);
|
|
this.setUIFightType(this.relevance_ui_fight_type);
|
|
this.send20060(battle_type, _cb);
|
|
},
|
|
// 还原之前的ui战斗类型,因为可能几个带战斗类型的面板互相调用
|
|
resetUIFightType: function resetUIFightType() {
|
|
if (this.relevance_ui_last_type) {
|
|
this.ui_fight_type = this.relevance_ui_last_type;
|
|
this.relevance_ui_last_type = 0;
|
|
}
|
|
},
|
|
//新手演示和试用战斗触发 1 演示 2 试用
|
|
//id 英雄id 1默认试用
|
|
requestUseHeroBattle: function requestUseHeroBattle(type, id) {
|
|
var _this2 = this;
|
|
if (type === void 0) {
|
|
type = 1;
|
|
}
|
|
if (id === void 0) {
|
|
id = 1;
|
|
}
|
|
var fight_type = 44;
|
|
if (type == 2) {
|
|
fight_type = 45;
|
|
}
|
|
this.requestOpenBattleRelevanceWindow(fight_type, null, function (_data) {
|
|
if (_data) {
|
|
_this2.send20070(id);
|
|
nx.bridge.plot.next();
|
|
}
|
|
});
|
|
},
|
|
//打开关联窗体,这里针对世界boss又需要重新判断调整
|
|
openRelevanceWindowAtOnce: function openRelevanceWindowAtOnce(combat_type) {
|
|
if (combat_type == BattleConst.Fight_Type.WorldBoss || combat_type == BattleConst.Fight_Type.SingleBoss) {
|
|
if (this.relevance_battle_type != BattleConst.Fight_Type.WorldBoss && this.relevance_battle_type != BattleConst.Fight_Type.SingleBoss) return;
|
|
} else {
|
|
if (this.relevance_battle_type != combat_type) return;
|
|
}
|
|
if (combat_type == BattleConst.Fight_Type.GuildDun) {
|
|
//公會boss
|
|
nx.bridge.createPanel("WndGuildChallenge");
|
|
} else if (combat_type == BattleConst.Fight_Type.StarTower) {
|
|
//試煉塔
|
|
nx.bridge.createPanel("WndStartower", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.Arena) {
|
|
//競技場
|
|
nx.bridge.createPanel("WndArenaLoopChallenge");
|
|
} else if (combat_type == BattleConst.Fight_Type.CrossChampion) {
|
|
//跨服冠军赛
|
|
nx.bridge.createPanel("WndCrossChampionWorship");
|
|
} else if (combat_type == BattleConst.Fight_Type.Endless) {
|
|
//無盡試煉
|
|
require("endless_trail_controller").getInstance().openEndlessMainWindow(true);
|
|
} else if (combat_type == BattleConst.Fight_Type.ExpeditFight) {
|
|
// require( "heroexpedit_controller" ).getInstance().openHeroExpeditView( true )
|
|
} else if (combat_type == BattleConst.Fight_Type.LadderWar) {
|
|
//天梯賽
|
|
nx.bridge.createPanel("WndLadder");
|
|
} else if (combat_type == BattleConst.Fight_Type.DungeonStone) {
|
|
//日常副本
|
|
nx.bridge.createPanel("WndDungeonMain", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.GuildWar) {
|
|
nx.bridge.createPanel("WndGuildBatMain", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.Adventrue) {
|
|
nx.bridge.createPanel("WndAdventureModel", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.LimitExercise) {
|
|
// require( "limitexercise_controller" ).getInstance().openLimitExerciseChangeView( true )
|
|
} else if (combat_type == BattleConst.Fight_Type.ElementWar) {
|
|
//元素神殿
|
|
require("element_controller").getInstance().openElementMainWindow(true);
|
|
} else if (combat_type == BattleConst.Fight_Type.PlanesWar) {
|
|
//位面戰爭
|
|
nx.bridge.createPanel("WndPlanesafkMain", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.Training_Camp) {
|
|
// 新手训练营
|
|
nx.bridge.createPanel("WndTrainingCamp");
|
|
} else if (combat_type == BattleConst.Fight_Type.Arean_Team) {// 组队竞技场
|
|
// require( "arenateam_controller" ).getInstance().openArenateamMainWindow( true )
|
|
} else if (combat_type == BattleConst.Fight_Type.EliteMatchWar || combat_type == BattleConst.Fight_Type.EliteKingMatchWar) {
|
|
nx.bridge.createPanel("WndEliteRankMain", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.GuildSecretArea) {//公會秘境
|
|
// require( "guildsecretarea_controller" ).getInstance().openGuildsecretareaMainWindow( true, this.relevance_params )
|
|
} else if (combat_type == BattleConst.Fight_Type.HeavenWar) {
|
|
//神裝副本
|
|
nx.bridge.createPanel("WndHeavenMain", {});
|
|
} else if (combat_type == BattleConst.Fight_Type.newYearBoss) {
|
|
//陣營大戰
|
|
nx.bridge.createPanel("WndCampfightMain", {});
|
|
}
|
|
this.relevance_battle_type = null;
|
|
this.relevance_params = null;
|
|
}
|
|
|
|
/*****战斗面板切换 */
|
|
});
|
|
|
|
module.exports = BattleController;
|
|
|
|
cc._RF.pop(); |