【官方】lordofpomelo 游戏分析
【官方】lordofpomelo 游戏分析
piggybear 发表于3年前
【官方】lordofpomelo 游戏分析
  • 发表于 3年前
  • 阅读 32
  • 收藏 0
  • 点赞 0
  • 评论 0

新睿云服务器60天免费使用,快来体验!>>>   

游戏体验

在线地址

部署游戏

lord of pomelo安装指南

分析思路

游戏服务器的流程除了启动部分外,大部分事件和流程都是并发的,如果按照一个流程去描述这样一件事情,会很混乱,所以我会根据自己对代码的理解,分开不同用户模块,不同业务去分析Lordofpomelo的代码。

Lordofpomelo 服务器介绍

各类服务器介绍

服务器图

Lordofpomelo启动流程

Lordofpomelo 启动流程

用户登录模块

用户流程

点击登录->输入账号和密码->输入正确

流程图

登录流程图

1.客户端输入账号密码,发送到register服务器上。

web-server/public/js/ui/clientManager.js

$.post(httpHost + 'login', {username: username, password: pwd}, function(data) {
if (data.code === 501) {
  alert('Username or password is invalid!');
  loading = false;
  return;
}
if (data.code !== 200) {
  alert('Username is not exists!');
  loading = false;
  return;
}

authEntry(data.uid, data.token, function() { //发送token到gate服务器
  loading = false;
});
localStorage.setItem('username', username);
});

function authEntry(uid, token, callback) {
  queryEntry(uid, function(host, port) { //gate服务器
    entry(host, port, token, callback);
  });
}

2.Register服务器返回token

3.客户端连接到pomelo的GATE服务器上

pomelo.init({host: config.GATE_HOST, port: config.GATE_PORT, log: true}, function() {})

4.发送uid到pomelo的Gate服务器上,执行服务器函数gate.gateHandler.queryEntry,该函数分配其中一台connector为用户服务,返回改connector服务器对应的IP和端口,客户端收到返回信息后,断开与gate服务器连接,并获得connector服务器的IP和端口。

game-server/app/servers/gate/handler/gateHandler.js

Handler.prototype.queryEntry = function(msg, session, next) {
    var uid = msg.uid;
    if(!uid) {
        next(null, {code: Code.FAIL});
        return;
    }

    var connectors = this.app.getServersByType('connector');
    if(!connectors || connectors.length === 0) {
        next(null, {code: Code.GATE.NO_SERVER_AVAILABLE});
        return;
    }

    var res = dispatcher.dispatch(uid, connectors);
    next(null, {code: Code.OK, host: res.host, port: res.clientPort});
  // next(null, {code: Code.OK, host: res.pubHost, port: res.clientPort});
};

5.根据获取的host和ip发送token到指定的connector服务器

客户端

web-server/public/js/ui/clientManager.js

pomelo.request('gate.gateHandler.queryEntry', { uid: uid}, function(data) {
  pomelo.disconnect();

  if(data.code === 2001) {
    alert('Servers error!');
    return;
  }

  callback(data.host, data.port);
});

6.执行connector.entryHandler.entry

7.将token发送到auth服务器,进行验证,验证没问题,生成session

8.服务器最后返回玩家信息给客户端

服务器端

game-server/app/servers/connector/handler/entryHandler.js

/**
 * New client entry game server. Check token and bind user info into session.
 *
 * @param  {Object}   msg     request message
 * @param  {Object}   session current session object
 * @param  {Function} next    next stemp callback
 * @return {Void}
 */
pro.entry = function(msg, session, next) {
    var token = msg.token, self = this;  //验证token信息,生成session

    if(!token) {
        next(new Error('invalid entry request: empty token'), {code: Code.FAIL});
        return;
    }

    var uid, players, player;
    async.waterfall([
        function(cb) {
            // auth token
            self.app.rpc.auth.authRemote.auth(session, token, cb); //通过
        }, function(code, user, cb) {
            // query player info by user id
            if(code !== Code.OK) {
                next(null, {code: code});
                return;
            }

            if(!user) {
                next(null, {code: Code.ENTRY.FA_USER_NOT_EXIST});
                return;
            }

            uid = user.id;
            userDao.getPlayersByUid(user.id, cb); //从数据库读取用户信息
        }, function(res, cb) {
            // generate session and register chat status
            players = res;
            self.app.get('sessionService').kick(uid, cb); //kick掉其他终端登录的用户
        }, function(cb) {
            session.bind(uid, cb);
        }, function(cb) {
            if(!players || players.length === 0) {
                next(null, {code: Code.OK});
                return;
            }

            player = players[0];

            session.set('serverId', self.app.get('areaIdMap')[player.areaId]); //根据数据库的记录获取玩家在哪个地图服务器,将地图服务器写在session
            session.set('playername', player.name); //用户名
            session.set('playerId', player.id);  //用户ID
            session.on('closed', onUserLeave.bind(null, self.app));
            session.pushAll(cb);
        }, function(cb) {
            self.app.rpc.chat.chatRemote.add(session, player.userId, player.name,
                channelUtil.getGlobalChannelName(), cb); //添加玩家到聊天室
        }
    ], function(err) {
        if(err) {
            next(err, {code: Code.FAIL});
            return;
        }

        next(null, {code: Code.OK, player: players ? players[0] : null}); //返回用户信息
    });
};

9.客户端收到玩家信息后,进行消息监听 loginMsgHandler监听登录和玩家在线情况,gameMsgHandler游戏逻辑信息监听,如移动行为等。

web-server/public/js/ui/clientManager.js

function entry(host, port, token, callback) {
  // init handler
  loginMsgHandler.init();
  gameMsgHandler.init();
}

10.加载地图信息,加载地图怪物,人物信息。

客户端 web-server/public/js/ui/clientManager.js

function afterLogin(data) {
  var userData = data.user;
  var playerData = data.player;

  var areaId = playerData.areaId;
  var areas = {1: {map: {id: 'jiangnanyewai.png', width: 3200, height: 2400}, id: 1}}; //读取trim地图信息

  if (!!userData) {
    pomelo.uid = userData.id;
  }
  pomelo.playerId = playerData.id;
  pomelo.areaId = areaId;
  pomelo.player = playerData;
  loadResource({jsonLoad: true}, function() {
    //enterScene();
    gamePrelude();
  });
}

function loadResource(opt, callback) {
  switchManager.selectView("loadingPanel");
  var loader = new ResourceLoader(opt);
  var $percent = $('#id_loadPercent').html(0);
  var $bar = $('#id_loadRate').css('width', 0);
  loader.on('loading', function(data) {
    var n = parseInt(data.loaded * 100 / data.total, 10);
    $bar.css('width', n + '%'); //加载地图进度
    $percent.html(n);
  });
  loader.on('complete', function() { //完成
    if (callback) {
      setTimeout(function(){
        callback();
      }, 500);
    }
  });

  loader.loadAreaResource();
}

web-server/public/js/utils/resourceLoader.js

pro.loadAreaResource = function() {
  var self = this;
  pomelo.request('area.resourceHandler.loadAreaResource',  {},function(data) {
    self.setTotalCount(1 + 1 + (data.players.length  + data.mobs.length) * 16 + data.npcs.length + data.items.length + data.equipments.length);

      self.loadJsonResource(function(){
      self.setLoadedCount(self.loadedCount + 1);
      self.loadMap(data.mapName);
      self.loadCharacter(data.players);
      self.loadCharacter(data.mobs);
      self.loadNpc(data.npcs);
      self.loadItem(data.items);
      self.loadEquipment(data.equipments);
      initObjectPools(data.mobs, EntityType.MOB);
      initObjectPools(data.players, EntityType.PLAYER);
    });
  });
};

服务器

11.读取game-server/config/data目录下的配置信息,返回客户端

handler.loadResource = function(msg, session, next) {
  var data = {};
  if (msg.version.fightskill !== version.fightskill) {
    data.fightskill = dataApi.fightskill.all();  //技能
  }
  if (msg.version.equipment !== version.equipment) {
    data.equipment = dataApi.equipment.all(); //装备
  }
  if (msg.version.item !== version.item) { //物品
    data.item = dataApi.item.all();
  }
  if (msg.version.character !== version.character) { //人物
    data.character = dataApi.character.all();
  }
  if (msg.version.npc !== version.npc) { //npc
    data.npc = dataApi.npc.all();
  }
  if (msg.version.animation !== version.animation) { //动物
    data.animation = _getAnimationJson();
  }
  if (msg.version.effect !== version.effect) {
    data.effect = require('../../../../config/effect.json');
  }

  next(null, {
    data: data,
    version: version
  });
};

12.加载地图数据完毕后,执行enterScene进入场景

web-server/public/js/ui/clientManager.js

function enterScene(){
  pomelo.request("area.playerHandler.enterScene", null, function(data){
    app.init(data);
  });
}

13.服务器area.playerHandler.enterScene

/**
 * Player enter scene, and response the related information such as
 * playerInfo, areaInfo and mapData to client.
 *
 * @param {Object} msg
 * @param {Object} session
 * @param {Function} next
 * @api public
 */
handler.enterScene = function(msg, session, next) {
  var area = session.area;
  var playerId = session.get('playerId');
  var areaId = session.get('areaId');
    var teamId = session.get('teamId') || consts.TEAM.TEAM_ID_NONE;
    var isCaptain = session.get('isCaptain');
    var isInTeamInstance = session.get('isInTeamInstance');
    var instanceId = session.get('instanceId');
    utils.myPrint("1 ~ EnterScene: areaId = ", areaId);
    utils.myPrint("1 ~ EnterScene: playerId = ", playerId);
    utils.myPrint("1 ~ EnterScene: teamId = ", teamId);

  userDao.getPlayerAllInfo(playerId, function(err, player) { //读取用户所有信息
    if (err || !player) {
      logger.error('Get user for userDao failed! ' + err.stack);
      next(new Error('fail to get user from dao'), {
        route: msg.route,
        code: consts.MESSAGE.ERR
      });

      return;
    }

    player.serverId = session.frontendId;
        player.teamId = teamId;
        player.isCaptain = isCaptain;
        player.isInTeamInstance = isInTeamInstance;
        player.instanceId = instanceId;
        areaId = player.areaId;
        utils.myPrint("2 ~ GetPlayerAllInfo: player.instanceId = ", player.instanceId);

    pomelo.app.rpc.chat.chatRemote.add(session, session.uid,
            player.name, channelUtil.getAreaChannelName(areaId), null);
        var map = area.map; //加入到 该地图的频道

    //Reset the player's position if current pos is unreachable
        if(!map.isReachable(player.x, player.y)){
            var pos = map.getBornPoint(); //玩家的出生位置
            player.x = pos.x;
            player.y = pos.y;
        }

        var data = {
        entities: area.getAreaInfo({x: player.x, y: player.y}, player.range),
        curPlayer: player.getInfo(),
        map: {
          name : map.name,
          width: map.width,
          height: map.height,
          tileW : map.tileW,
          tileH : map.tileH,
          weightMap: map.collisions
        }
    };
        // utils.myPrint("1.5 ~ GetPlayerAllInfo data = ", JSON.stringify(data));
        next(null, data); //发送data到客户端

        utils.myPrint("2 ~ GetPlayerAllInfo player.teamId = ", player.teamId);
        utils.myPrint("2 ~ GetPlayerAllInfo player.isCaptain = ", player.isCaptain);
        if (!area.addEntity(player)) { 将玩家的最新信息添加到area
      logger.error("Add player to area faild! areaId : " + player.areaId);
      next(new Error('fail to add user into area'), {
       route: msg.route,
       code: consts.MESSAGE.ERR
      });
      return;
    }

        if (player.teamId > consts.TEAM.TEAM_ID_NONE) {
            // send player's new info to the manager server(team manager)
            var memberInfo = player.toJSON4TeamMember();
            memberInfo.backendServerId = pomelo.app.getServerId();
            pomelo.app.rpc.manager.teamRemote.updateMemberInfo(session, memberInfo, //更新队伍信息
                function(err, ret) {
                });
        }

  });
};

14.客户端收到服务器的信息后,执行app.init

web-server/public/js/app.js

/**
 * Init client ara
 * @param data {Object} The data for init area
 */
function init(data) {
    var map = data.map;
    pomelo.player = data.curPlayer;
    switchManager.selectView('gamePanel');
    if(inited){
        configData(data);
        area = new Area(data, map);
    }else{
        initColorBox();
        configData(data);
        area = new Area(data, map);

        area.run(); 
        chat.init();

        inited = true;
    }
ui.init();
}

数据持久化模块

Lord采用Pomelo-sync从内存同步数据到数据库,该模块的作用是创建一个sql行为处理队列,每隔一段时间轮询一次,执行队列里的sql 操作。

API文档

添加实体对象更新 game-server/app/domain/area.js

Instance.prototype.addEntity = function(e) {
    ...
    eventManager.addEvent(e);
    ...
}

game-server/app/domain/event/eventManager.js

/**
 * Listen event for entity
 */
exp.addEvent = function(entity){
    ...
    addSaveEvent(entity);
    ...
};

/**
 * Add save event for player
 * @param {Object} player The player to add save event for.
 */
function addSaveEvent(player) {  //通过同步工具,回写相关信息到数据库
    var app = pomelo.app;
    player.on('save', function() {
        app.get('sync').exec('playerSync.updatePlayer', player.id, player.strip());
    });

    player.bag.on('save', function() {
        app.get('sync').exec('bagSync.updateBag', player.bag.id, player.bag);
    });

    player.equipments.on('save', function() {
        app.get('sync').exec('equipmentsSync.updateEquipments', player.equipments.id, player.equipments);
    });
}

Pomelo-sync的模块提供了exec方法,当函数收到save事件后,执行exec,将操作行为放到数据库队列里面,每隔一段时间执行。

如何发送save事件呢?

game-server/app/domain/persistent.js

/**
 * Persistent object, it is saved in database
 *
 * @param {Object} opts
 * @api public
 */
var Persistent = function(opts) {
    this.id = opts.id;
    this.type = opts.type;
    EventEmitter.call(this);
};

util.inherits(Persistent, EventEmitter);

module.exports = Persistent;
// Emit the event 'save'
Persistent.prototype.save = function() {
    this.emit('save');
};

这个是可持久化对象的基类,所有的子类都可以调用基类的方法,如equipments装备,executeTask任务,fightskill,通过执行基类的方法,向EventEmitter发送事件,监听的事件得到相应后,写入同步数据库缓冲队列,每隔一段时间回写到服务器。

场景管理模块

简介

Lordofpomelo中每个场景对应一个独立的场景服务器,所有的业务逻辑都在场景服务器内部进行。

主流程

初始化场景管理模块game-server/app/domain/area/area.js

/**
 * Init areas
 * @param {Object} opts
 * @api public
 */
var Instance = function(opts){
  this.areaId = opts.id;
  this.type = opts.type;
  this.map = opts.map;

  //The map from player to entity
  this.players = {}; //玩家
  this.users = {}; 
  this.entities = {}; //实体
  this.zones = {}; //地区
  this.items = {}; //物品
  this.channel = null;

  this.playerNum = 0;
  this.emptyTime = Date.now();
  //Init AOI
  this.aoi = aoiManager.getService(opts);

  this.aiManager = ai.createManager({area:this}); //怪物ai 工厂方法
  this.patrolManager = patrol.createManager({area:this}); //patrol 巡逻工厂方法
  this.actionManager = new ActionManager(); //action 动作工厂方法

  this.timer = new Timer({
    area : this,
    interval : 100
  });

  this.start();
};

启动场景管理服务 game-server/app/domain/area/area.js

/**
 * @api public
 */
Instance.prototype.start = function() {
  aoiEventManager.addEvent(this, this.aoi.aoi); //aoi监听事件

  //Init mob zones
  this.initMobZones(this.map.getMobZones()); //初始化怪物空间
  this.initNPCs(this); //初始化NPC

  this.aiManager.start(); //AI管理服务启动
  this.timer.run();   //地图计时器,定时执行地图内的处理信息任务
};
  1. initMobZones 读取相对目录./map/mobzone.js 文件,初始化MobZone,通过读取game-server/config/data/character.json 文件来初始化。
  2. initNPCs 读取game-server/config/data/npc.json 生成NPC人物
  3. aiManager.start() 初始化AI行为,读取game-server/app/api/brain/目录下的ai行为文件,利用提供Pomelo-bt 行为树来控制ai的策略,通过aiManager 注册brain。当用户利用addEntity添加实例的时候,将ai行为添加到该实体。
  4. timer.run() 执行地图的tick,轮询地图内的变量,当变量有变化的时候,通知客户端。

game-server/app/domain/area/timer.js

var Timer = function(opts){
  this.area = opts.area;
  this.interval = opts.interval||100;
};


Timer.prototype.run = function () {
  this.interval = setInterval(this.tick.bind(this), this.interval); //定时执行 tick
};

Timer.prototype.tick = function() {
  var area = this.area;

  //Update mob zones
  for(var key in area.zones){
    area.zones[key].update();  //遍历 所有zones的更新
  }

  //Update all the items
  for(var id in area.items) {  //检查人物状态值
    var item = area.entities[id];
    item.update();

    if(item.died) {   //如果角色死亡,向客户端发送消息
      area.channel.pushMessage('onRemoveEntities', {entities: [id]});
      area.removeEntity(id);  
    }
  }

  //run all the action
  area.actionManager.update(); //动作更新

  area.aiManager.update();  //ai 更新,检查ai反应动作

  area.patrolManager.update(); //patrol巡逻动作更新
};
  • area.zones[key].update() 定时刷怪
  • item.update(); 检查用户生命时间,若到0,则玩家状态变成死亡。
  • area.actionManager.update() 将日常攻击,移动的动作寄存在一个一个队列里面,定时将队列里面的动作执行和清空
  • area.aiManager.update() ai根据行为树,作出反应,让怪物可以主动攻击玩家
  • area.patrolManager.update() 怪物巡逻

动作缓冲机制

在Area地图Tick下 area.actionManager.update() 读取action数组,执行action行为。

game-server/app/domain/action/actionManager.js 初始化动作队列

/**
 * Action Manager, which is used to contrll all action
 */
var ActionManager = function(opts){
    opts = opts||{};

    this.limit = opts.limit||10000;

    //The map used to abort or cancel action, it's a two level map, first leven key is type, second leven is id
    this.actionMap = {};

    //The action queue, default size is 10000, all action in the action queue will excute in the FIFO order
    this.actionQueue = new Queue(this.limit);
}; 

添加动作到动作队列

/**
 * Add action 
 * @param {Object} action  The action to add, the order will be preserved
 */
ActionManager.prototype.addAction = function(action){
    if(action.singleton) {
        this.abortAction(action.type, action.id);
    }

    this.actionMap[action.type] = this.actionMap[action.type]||{};

    this.actionMap[action.type][action.id] = action;    

    return this.actionQueue.push(action);
};

遍历动作数组里的所有执行动作,并执行该动作的update 方法

/**
 * Update all action
 * @api public
 */
ActionManager.prototype.update = function(){
    var length = this.actionQueue.length;

    for(var i = 0; i < length; i++){
        var action = this.actionQueue.pop();

        if(action.aborted){
            continue;
        }

        action.update();
        if(!action.finished){
            this.actionQueue.push(action);
        }else{
            delete this.actionMap[action.type][action.id];
        }
    }
};  

Example:当客户端发送一个玩家移动行为的时候,服务器将创建一个Move对象

var action = new Move({
    entity: player,
    path: path,
    speed: speed
});

当执行area.actionManager.update()时,将执行动作队列里的Move.update的方法;

game-server/app/domain/action/move.js

/**
 * Update the move action, it will calculate and set the entity's new position, and update AOI module
 */
Move.prototype.update = function(){
    this.tickNumber++;
    var time = Date.now()-this.time;
    ....
};

总得来说,为了避免太多的动作行为,导致服务器多次响应,所以采用一个队列,隔一段短时间,处理一次。

AI管理模块

/game-server/app/ai/service/aiManager.js

为角色添加AI行为和行为准则

/**
 * Add a character into ai manager.
 * Add a brain to the character if the type is mob.
 * Start the tick if it has not started yet.
 */
pro.addCharacters = function(cs) {

    ...
    brain = this.brainService.getBrain('player', Blackboard.create({
        manager: this,
        area: this.area,
        curCharacter: c
    }));
    this.players[c.entityId] = brain;
    } 

    ....

};

读取game-server/app/ai/brain目录下的所有行为模式。lord目录下,有player.js和tiger.js ,将动作行为,添加到this.mobs[]下

以怪物来做案例 game-server/app/ai/brain/tiger.js

var bt = require('pomelo-bt'); //初始化了 ai的行为树

行为树原理 http://www.cnblogs.com/cnas3/archive/2011/08/14/2138445.html

pomelo-bt API https://github.com/NetEase/pomelo-bt

持续攻击行为

var loopAttack = new Loop({
    blackboard: blackboard, 
    child: attack, 
    loopCond: checkTarget
});

行为树的Loop循环节点,循环判断checkTarget检查对象是否存在,如果存在,则一直攻击

如果有目标,则开始执行持续攻击

var attackIfHaveTarget = new If({
    blackboard: blackboard, 
    cond: haveTarget, 
    action: loopAttack
});

使用了行为树中的条件节点,当haveTarget的作用是检查角色里面target有没锁定对象符合条件,则展开loopAttack持续攻击

//find nearby target action
//var findTarget = new FindNearbyPlayer({blackboard: blackboard});
//patrol action
var patrol = new Patrol({blackboard: blackboard});

//composite them together
this.action = new Select({
    blackboard: blackboard
});

this.action.addChild(attackIfHaveTarget);
//this.action.addChild(findTarget);
this.action.addChild(patrol);

怪物的行为策略为,Select 顺序节点,优先选择攻击附近对象,其次是巡逻,通过行为树的组合,组合成了AI。

遍历所有怪物 game-server/app/service/aiManager.js

/**
 * Update all the managed characters.
 * Stop the tick if there is no ai mobs.
 */
pro.update = function() {
    if(!this.started || this.closed) {
        return;
    }
    var id;
    for(id in this.players) {
        if(typeof this.players[id].update === 'function') {
            this.players[id].update();
        }
    }
    for(id in this.mobs) {
        if(typeof this.mobs[id].update === 'function') {
            this.mobs[id].update();
        }
    }
};

遍历this.mobs的怪物对象,执行对象的update方法,执行doAction

pro.update = function() {
    return this.action.doAction();
};

doAction 遍历行为树,根据行为树的设定,执行响应的 action。

AOI灯塔模块

Lord采用的是思路,空间切割监视的灯塔设计,将场景分为等大的格子,在对象进入或退出格子时,维护每个灯塔上的对象列表。

pomelo-aoi文档

https://github.com/NetEase/pomelo-aoi/blob/master/README.md

实际使用的时候很简单

  • 当一个人第一次登入到地图的时候,我们就调用aoi.addObject(obj, pos) 添加对象到aoi上,通知附近观察者,aoi.addWatcher(watcher, oldPos, newPos, oldRange, newRange);
  • 当一个人移动的时候,那么我们就调用aoi.updateObject(obj, oldPos, newPos);更新个人位置,通知其他观察者updateWatcher(watcher, oldPos, newPos, oldRange, newRange);
  • Watcher 相当于人物的视野
  • Object 相当于在塔的对象

当aoi服务的对象,产生变化的时候,会激活回调事件

aoiEventManager.addEvent(this, this.aoi.aoi); //aoi监听事件


//Add event for aoi
exp.addEvent = function(area, aoi){
    aoi.on('add', function(params){
        params.area = area;
        switch(params.type){
            case EntityType.PLAYER:
                onPlayerAdd(params);
                break;
            case EntityType.MOB:
                onMobAdd(params);
                break;
        }
    });

    aoi.on('remove', function(params){
        params.area = area;
        switch(params.type){
            case EntityType.PLAYER:
                onPlayerRemove(params);
                break;
            case EntityType.MOB:
                break;
        }
    });

    aoi.on('update', function(params){
        params.area = area;
        switch(params.type){
            case EntityType.PLAYER:
                onObjectUpdate(params);
                break;
            case EntityType.MOB:
                onObjectUpdate(params);
                break;
        }
    });

    aoi.on('updateWatcher', function(params) {
        params.area = area;
        switch(params.type) {
            case EntityType.PLAYER:
                onPlayerUpdate(params);
                break;
        }
    });
};

根据AOI不同的事件回调,向客户端发出不同的回调事件。如添加实物,附近玩家等信息。

点击实物模块

用户流程

点击实物->怪物->攻击行为

点击实物->NPC->聊天

点击实物->玩家->组队或战斗

程序流程

1.客户端绑定鼠标点击实体事件

web-server/public/js/componentAdder.js

/**
 * Mouse click handlerFunction
 */
var launchAi = function (event, node) {
    var id = node.id;
    if (event.type === 'mouseClicked') {
        clientManager.launchAi({id: id});
    }
};

绑定鼠标点击实体事件到launchAi函数

2.检查鼠标点击实物的事件,属于哪种类型

web-server/js/ui/clientManager.js

function launchAi(args) {
  var areaId = pomelo.areaId;
  var playerId = pomelo.playerId;
  var targetId = args.id;
  if (pomelo.player.entityId === targetId) {
    return;
  }
  var skillId = pomelo.player.curSkill;
  var area = app.getCurArea();
  var entity = area.getEntity(targetId);
  if (entity.type === EntityType.PLAYER || entity.type === EntityType.MOB) {  //被攻击的对象类型判断
    if (entity.died) {
      return;
    }
    if (entity.type === EntityType.PLAYER) {  //如果是玩家,弹出选项,组队或者交易等
      var curPlayer = app.getCurPlayer();
      pomelo.emit('onPlayerDialog', {targetId: targetId, targetPlayerId: entity.id,
        targetTeamId: entity.teamId, targetIsCaptain: entity.isCaptain,
        myTeamId: curPlayer.teamId, myIsCaptain: curPlayer.isCaptain});
    } else if (entity.type === EntityType.MOB) {
      pomelo.notify('area.fightHandler.attack',{targetId: targetId}); //通知服务器处理攻击事件,不要求回调
    }
  } else if (entity.type === EntityType.NPC) {  //如果是NPC是对话模式
    pomelo.notify('area.playerHandler.npcTalk',{areaId :areaId, playerId: playerId, targetId: targetId});
  } else if (entity.type === EntityType.ITEM || entity.type === EntityType.EQUIPMENT) { //检查一下捡东西相关的
    var curPlayer = app.getCurPlayer();
    var bag = curPlayer.bag;
    if (bag.isFull()) {
      curPlayer.getSprite().hintOfBag();
      return;
    }
    pomelo.notify('area.playerHandler.pickItem',{areaId :areaId, playerId: playerId, targetId: targetId}); //捡东西
  }
}

3.不同类型的点击行为对应不同的服务器响应函数

  • 怪物: area.fightHandler.attack
  • NPC: area.playerHandler.npcTalk
  • 捡东西: area.playerHandler.pickItem

点击玩家后出现对话框 对话框选项,可以根据需求

/**
* Execute player action
*/
function exec(type, params) {
switch (type) {
  case btns.ATTACK_PLAYER: {
    attackPlayer(params); //攻击玩家
  }
    break;

  case btns.APPLY_JOIN_TEAM: {
    applyJoinTeam(params);  //加入队伍
  }
    break;

  case btns.INVITE_JOIN_TEAM: {
    inviteJoinTeam(params); //邀请加入队伍
  }
    break;
}
}
  • 攻击玩家: area.fightHandler.attack
  • 加入队伍: area.teamHandler.applyJoinTeam
  • 邀请队伍: area.teamHandler.inviteJoinTeam

4.执行服务端程序

area.fightHandler.attack

/**
 * Action of attack.
 * Handle the request from client, and response result to client
 * if error, the code is consts.MESSAGE.ERR. Or the code is consts.MESSAGE.RES
 *
 * @param {Object} msg
 * @param {Object} session
 * @api public
 */
handler.attack = function(msg, session, next) {
    var player = session.area.getPlayer(session.get('playerId'));
    var target = session.area.getEntity(msg.targetId);

    if(!target || !player || (player.target === target.entityId) || (player.entityId === target.entityId) || target.died){
        next();
        return;
    } //数据校验

    session.area.timer.abortAction('move', player.entityId); //停止移动
    player.target = target.entityId; //锁定攻击目标


    next();
};

area.playerHandler.npcTalk

handler.npcTalk = function(msg, session, next) {
  var player = session.area.getPlayer(session.get('playerId'));
  player.target = msg.targetId;
  next();
};

area.playerHandler.pickItem

/**
 * Player pick up item.
 * Handle the request from client, and set player's target
 *
 * @param {Object} msg
 * @param {Object} session
 * @param {Function} next
 * @api public
 */
handler.pickItem = function(msg, session, next) {
  var area = session.area;

  var player = area.getPlayer(session.get('playerId'));
  var target = area.getEntity(msg.targetId);
  if(!player || !target || (target.type !== consts.EntityType.ITEM && target.type !== consts.EntityType.EQUIPMENT)){
    next(null, {
      route: msg.route,
      code: consts.MESSAGE.ERR
    });
    return;
  }

  player.target = target.entityId;
  next();
};

上述三个处理函数都有一个共同点,只设置了player.target就返回给客户端了,这当中包含了什么玄机?请回忆起场景处理模块。

图

1.客户端发送请求到服务器

2.服务器修改play.target 为taget添加对象

3.场景通过tick对area.aiManager.update()进行更新,根据ai行为树,检测到target存在对象,判断对象是否能被攻击,是否能谈话,是否能捡起来,分配到不同的处理函数,处理函数执行完毕后,服务器端通过pushMessage等方式,向客户端发出广播信息,客户端通过pomelo.on(event,func)的方式监测到对应的事件后,执行对应的回调事情。

未完,待续。

  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 3
博文 237
码字总数 37552
×
piggybear
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: