cgserver 6.0.6 → 6.0.9

package/dist/lib/AI/AiObject.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiObject = void 0;
+class AiObject {
+    onTriggerIn(obj, trigger) {
+    }
+    onTriggerOut(obj, trigger) {
+    }
+}
+exports.AiObject = AiObject;

package/dist/lib/AI/Astar.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AStar = exports.Rect = void 0;
+const Point_1 = require("./Point");
+class Rect {
+    x = 0;
+    y = 0;
+    width = 0;
+    height = 0;
+}
+exports.Rect = Rect;
+class AStarNode {
+    ParentNode = null;
+    CurTilePos = null;
+    G = 0;
+    H = 0;
+    constructor(node, tilePos) {
+        this.ParentNode = node;
+        this.CurTilePos = tilePos;
+        if (this.ParentNode) {
+            this.G = this.ParentNode.G + 10;
+        }
+        else {
+            this.G = 0;
+        }
+    }
+    F() {
+        return this.G + this.H;
+    }
+}
+class AStar {
+    _markList = null;
+    _markedList = null;
+    _routes = null;
+    _maxTileWidth = 0;
+    _maxTileHeight = 0;
+    /**
+     * 先y在x，p(x:1,y:2),data[2][1]
+     */
+    _mapData = null;
+    getRoutes(srcTilePos, tarTilePos, mapData) {
+        if (srcTilePos.equals(tarTilePos)) {
+            return [];
+        }
+        this._markList = [];
+        this._markedList = [];
+        this._routes = [];
+        this._mapData = mapData;
+        this._maxTileWidth = this._mapData.width();
+        this._maxTileHeight = this._mapData.height();
+        let tp = srcTilePos.sub(tarTilePos);
+        let node = new AStarNode(null, srcTilePos);
+        node.H = (Math.abs(tp.x) + Math.abs(tp.y)) * 10 + mapData.extraWeight(tarTilePos);
+        this._markList.push(node);
+        node = this._routing(srcTilePos, tarTilePos);
+        while (node) {
+            this._routes.push(node.CurTilePos);
+            node = node.ParentNode;
+        }
+        this._routes.reverse();
+        this._routes.shift();
+        return this._routes;
+    }
+    _routing(srcTilePos, tarTilePos) {
+        if (this._markList.length <= 0) //已经没有节点，是死路根本无法到达
+         {
+            return null;
+        }
+        let node = this._markList[0];
+        let curIndex = 0;
+        for (let i = 0; i < this._markList.length; ++i) {
+            if (node.F() > this._markList[i].F()) {
+                node = this._markList[i];
+                curIndex = i;
+            }
+            if (this._markList[i].CurTilePos.equals(tarTilePos)) //到达终点
+             {
+                return this._markList[i];
+            }
+        }
+        this._markList.splice(curIndex, 1);
+        this._markedList.push(node);
+        let tp = new Point_1.Point(0, 0);
+        //上
+        tp.x = node.CurTilePos.x;
+        tp.y = node.CurTilePos.y + 1;
+        this._addToMark(tp, tarTilePos, node);
+        //下
+        tp = new Point_1.Point(0, 0);
+        tp.x = node.CurTilePos.x;
+        tp.y = node.CurTilePos.y - 1;
+        this._addToMark(tp, tarTilePos, node);
+        //左
+        tp = new Point_1.Point(0, 0);
+        tp.x = node.CurTilePos.x - 1;
+        tp.y = node.CurTilePos.y;
+        this._addToMark(tp, tarTilePos, node);
+        //右
+        tp = new Point_1.Point(0, 0);
+        tp.x = node.CurTilePos.x + 1;
+        tp.y = node.CurTilePos.y;
+        this._addToMark(tp, tarTilePos, node);
+        return this._routing(srcTilePos, tarTilePos);
+    }
+    _isInMark(tilePos) {
+        for (let i = 0; i < this._markList.length; ++i) {
+            if (this._markList[i].CurTilePos.equals(tilePos)) {
+                return true;
+            }
+        }
+        for (let i = 0; i < this._markedList.length; ++i) {
+            if (this._markedList[i].CurTilePos.equals(tilePos)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _addToMark(curTilePos, tarTilePos, parentAStarNode) {
+        //无地图数据
+        if (curTilePos.x < 0 || curTilePos.y < 0
+            || !this._mapData.canPass(curTilePos)) {
+            return;
+        }
+        if (!this._isInMark(curTilePos)) //未曾添加
+         {
+            let newNode = new AStarNode(parentAStarNode, curTilePos);
+            let temp_tp = parentAStarNode.CurTilePos.sub(tarTilePos);
+            newNode.H = (Math.abs(temp_tp.x) + Math.abs(temp_tp.y)) * 10;
+            this._markList.push(newNode);
+        }
+    }
+}
+exports.AStar = AStar;

package/dist/lib/AI/BehaviorAI.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BehaviorAI = void 0;
+const Log_1 = require("./../Logic/Log");
+const Core_1 = require("./../Core/Core");
+const _ = require("underscore");
+const TriggerMgr_1 = require("./TriggerMgr");
+class BehaviorAI {
+    _obj;
+    _targetObjs;
+    _triggers;
+    _behavior_data;
+    _current_behavior;
+    _current_behavior_name = "";
+    _current_check;
+    _targetObj;
+    constructor(behavior_data, obj, targetObjs) {
+        this._obj = obj;
+        this._behavior_data = behavior_data;
+        if (Core_1.core.isArray(targetObjs)) {
+            this._targetObjs = targetObjs;
+        }
+        else if (targetObjs) {
+            this._targetObjs[0] = targetObjs;
+        }
+        else {
+            this._targetObjs = [];
+        }
+        this._triggers = [];
+        let code = TriggerMgr_1.GTriggerMgr.addConditionTriggerEvent(TriggerMgr_1.EConditionType.Die, this.onTriggerDie.bind(this), { code: this._obj.getCode() });
+        this._triggers.push({ type: TriggerMgr_1.EConditionType.Die, code: code });
+    }
+    //启动行为树AI
+    start() {
+        if (!this._behavior_data) {
+            Log_1.GLog.info("------------error------------this._behavior_data  can not be null!", true);
+            return;
+        }
+        this.goto(this._behavior_data.start);
+    }
+    //结束行为树AI
+    end() {
+        for (let i = 0, length = this._triggers.length; i < length; ++i) {
+            TriggerMgr_1.GTriggerMgr.removeConditionTriggerEvent(this._triggers[i].type, this._triggers[i].code);
+        }
+        this._triggers = [];
+    }
+    //帧检查
+    //支持多条件check
+    update(dt) {
+        if (this._current_check.length < 0) {
+            return;
+        }
+        for (let i = 0; i < this._current_check.length; ++i) {
+            let current = this._current_check[i];
+            //目前只支持同时存在一个update检查
+            if (current.event_name == "target_insight") {
+                let targetInfo = this._getNearestTarget();
+                if (targetInfo) {
+                    let target = targetInfo.target;
+                    let distance = targetInfo.distance;
+                    if (distance <= this._behavior_data.insight) //视野发现敌人
+                     {
+                        this._current_check = this._current_check.splice(i, 1);
+                        --i;
+                        let forceReturn = this._doEvents(this._current_behavior.conditions[current.event_name]);
+                        if (forceReturn) {
+                            return; //防止goto修改this._current_check后，做了立刻check
+                        }
+                    }
+                }
+            }
+            else if (current.event_name == "sure") {
+                this._current_check = this._current_check.splice(i, 1);
+                --i;
+                let forceReturn = this._doEvents(this._current_behavior.conditions[current.event_name]);
+                if (forceReturn) {
+                    return; //防止goto修改this._current_check后，做了立刻check
+                }
+            }
+            else if (current.event_name == "near") {
+                if (this._targetObj) {
+                    let objPos = this._obj.getPosition();
+                    let tpos = this._targetObj.getPosition();
+                    let distance = objPos.sub(tpos).length(); //目标和自己的距离
+                    let dty = objPos.y - tpos.y;
+                    dty = dty >= 0 ? dty : -dty;
+                    if (distance <= current.distance && dty <= 10) //视野发现敌人
+                     {
+                        this._current_check = this._current_check.splice(i, 1);
+                        --i;
+                        let forceReturn = this._doEvents(this._current_behavior.conditions[current.event_name]);
+                        if (forceReturn) {
+                            return; //防止goto修改this._current_check后，做了立刻check
+                        }
+                    }
+                }
+                else {
+                    this._current_check = this._current_check.splice(i, 1);
+                    --i;
+                    let forceReturn = this._doEvents(this._current_behavior.conditions[current.event_name], true);
+                    if (forceReturn) {
+                        return; //防止goto修改this._current_check后，做了立刻check
+                    }
+                }
+            }
+            else if (current.event_name == "timeout") {
+                current.time -= dt;
+                if (current.time <= 0) {
+                    this._current_check = this._current_check.splice(i, 1);
+                    --i;
+                    let forceReturn = this._doEvents(this._current_behavior.conditions[current.event_name]);
+                    if (forceReturn) {
+                        return; //防止goto修改this._current_check后，做了立刻check
+                    }
+                }
+            }
+        }
+    }
+    //goto事件
+    goto(behavior_name) {
+        //GLog.info("=====goto behavior=" + behavior_name);
+        if (this._behavior_data && this._behavior_data.name == behavior_name) {
+            return; //拒绝相同行为跳转
+        }
+        this._current_check = [];
+        this._current_behavior = this._behavior_data.behaviors[behavior_name];
+        //全局条件
+        if (this._behavior_data.conditions) {
+            this._checkConditions(this._behavior_data.conditions);
+        }
+        //行为条件
+        if (this._current_behavior.conditions) {
+            this._checkConditions(this._current_behavior.conditions);
+        }
+        if (this._current_behavior.animation) {
+            if (!this._current_behavior.conditions.animation_done) {
+                this._obj.behaviorAnimation(this._current_behavior.animation.name, this._current_behavior.animation.loop);
+            }
+            else {
+                let self = this;
+                this._obj.behaviorAnimation(this._current_behavior.animation.name, this._current_behavior.animation.loop, function () {
+                    self._doEvents(self._current_behavior.conditions.animation_done);
+                });
+            }
+        }
+        else {
+            Log_1.GLog.info("---------warning--------_goto->behavior_name=" + behavior_name + ".animaiton not exist!");
+        }
+    }
+    //检查有没有已经达到的条件,又的话就执行他的相关事件
+    _checkConditions(conditions) {
+        if (!conditions) {
+            return;
+        }
+        for (let key in conditions) {
+            switch (key) {
+                case "target_insight":
+                    {
+                        this._current_check.push({ event_name: key });
+                    }
+                    break;
+                case "timeout":
+                    {
+                        this._current_check.push({ event_name: key, time: conditions[key].time });
+                    }
+                    break;
+                case "sure":
+                    {
+                        this._current_check.push({ event_name: key }); //下次update执行
+                    }
+                    break;
+                case "near":
+                    {
+                        this._targetObj = null;
+                        this._current_check.push({ event_name: key, distance: conditions[key].distance });
+                        let targetInfo = this._getNearestTarget();
+                        if (targetInfo) {
+                            if (this._behavior_data.name == "sm")
+                                Log_1.GLog.info("distance" + targetInfo.distance);
+                            this._targetObj = targetInfo.target;
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    //执行事件
+    _doEvents(events, fail = false) {
+        if (!events) {
+            return false;
+        }
+        if (fail && events.failto) {
+            this.goto(events.failto);
+            return true;
+        }
+        let forceReturn = false;
+        for (let key in events) {
+            switch (key) {
+                case "goto":
+                    {
+                        this.goto(events[key]);
+                        forceReturn = true;
+                    }
+                    break;
+                case "walk_any":
+                    {
+                        if (this._obj.behaviorWalkAny) {
+                            this._obj.behaviorWalkAny();
+                        }
+                    }
+                    break;
+                case "persue":
+                    {
+                        if (this._obj.behaviorPersue && this._targetObj) {
+                            this._obj.behaviorPersue(this._targetObj);
+                        }
+                    }
+                    break;
+                case "call":
+                    {
+                        if (events[key].fun && this._obj[events[key].fun]) {
+                            this._obj[events[key].fun](events[key].params);
+                        }
+                    }
+                    break;
+                case "random":
+                    {
+                        let r = _.random(0, 100); //百分率
+                        let rate = 0;
+                        let done = false;
+                        //最后一条不参与检测
+                        for (let i = 0, length = events[key].length; i < length - 1; ++i) {
+                            rate += events[key][i].rate;
+                            if (r <= rate) {
+                                forceReturn = this._doEvents(events[key][i].events);
+                                done = true;
+                                break;
+                            }
+                        }
+                        //如果前面都没有成功，必须保证最后一条得到执行
+                        if (!done) {
+                            forceReturn = this._doEvents(events[key][events[key].length - 1].events);
+                        }
+                    }
+                default:
+                    break;
+            }
+        }
+        return forceReturn;
+    }
+    //角色死亡触发
+    onTriggerDie(userDM) {
+        if (!userDM) {
+            return;
+        }
+        if (this._obj.getCode() === userDM.code) {
+            this.goto("die");
+            this.end();
+            return;
+        }
+        for (let i = 0, length = this._targetObjs.length; i < length; ++i) {
+            if (this._targetObjs[i].getCode() === userDM.code) {
+                this._targetObjs = this._targetObjs.splice(i, 1);
+                if (this._targetObj.getCode() === userDM.code) {
+                    this._targetObj = null;
+                }
+                return;
+            }
+        }
+        return;
+    }
+    //获取最近的target
+    _getNearestTarget() {
+        let targetNum = this._targetObjs.length;
+        if (targetNum <= 0) {
+            return null;
+        }
+        let objPos = this._obj.getPosition();
+        if (targetNum == 1) {
+            return { target: this._targetObjs[0], distance: objPos.sub(this._targetObjs[0].getPosition()).length() };
+        }
+        let minIndex = 0;
+        let mindis = objPos.sub(this._targetObjs[0].getPosition()).length();
+        for (let i = 1; i < targetNum; ++i) {
+            let dis = objPos.sub(this._targetObjs[i].getPosition()).length();
+            if (mindis > dis) {
+                mindis = dis;
+                minIndex = i;
+            }
+        }
+        return { target: this._targetObjs[minIndex], distance: mindis };
+    }
+    //添加target
+    addTarget(target) {
+        if (!target) {
+            return;
+        }
+        this._targetObjs.push(target);
+    }
+    getTargets() {
+        return this._targetObjs;
+    }
+}
+exports.BehaviorAI = BehaviorAI;

package/dist/lib/AI/Entity.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = void 0;
+const Point_1 = require("./Point");
+//世界物体，具有坐标可移动等特性
+class Entity {
+    _id = -1;
+    get id() {
+        return this._id;
+    }
+    _world_pos = new Point_1.Point();
+    get worldPos() {
+        return this._world_pos;
+    }
+    set worldPos(value) {
+        this._world_pos = value;
+    }
+    _cell = new Point_1.Point();
+    get cellPos() {
+        return this._cell;
+    }
+    set cellPos(value) {
+        this._cell = value;
+    }
+    initPos(pos) {
+        //不能直接赋值，因为是引用
+        this._world_pos.x = pos.x + 0.5;
+        this._world_pos.y = pos.y + 0.5;
+        this._cell.x = pos.x;
+        this._cell.y = pos.y;
+    }
+}
+exports.Entity = Entity;

package/dist/lib/AI/Point.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Point = void 0;
+class Point {
+    x = 0;
+    y = 0;
+    constructor(x = 0, y = 0) {
+        this.x = x;
+        this.y = y;
+    }
+    sub(pt) {
+        return new Point(this.x - pt.x, this.y - pt.y);
+    }
+    subSelf(pt) {
+        this.x -= pt.x;
+        this.y -= pt.y;
+    }
+    add(pt) {
+        return new Point(this.x + pt.x, this.y + pt.y);
+    }
+    addSelf(pt) {
+        this.x += pt.x;
+        this.y += pt.y;
+    }
+    equals(pt) {
+        return this.x == pt.x && this.y == pt.y;
+    }
+    fuzzyEqual(pt, w) {
+        let dtx = Math.abs(this.x - pt.x);
+        if (dtx >= w) {
+            return false;
+        }
+        let dty = Math.abs(this.y - pt.y);
+        if (dty >= w) {
+            return false;
+        }
+        return true;
+    }
+    length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+    mul(n) {
+        return new Point(this.x * n, this.y * n);
+    }
+    mulSelf(n) {
+        this.x *= n;
+        this.y *= n;
+    }
+    toI() {
+        return new Point(Math.floor(this.x), Math.floor(this.y));
+    }
+    normalize() {
+        let len = this.length();
+        if (len == 0) {
+            return new Point();
+        }
+        return new Point(this.x / len, this.y / len);
+    }
+    normalizeSelf() {
+        let len = this.length();
+        if (len == 0) {
+            return;
+        }
+        this.x /= len;
+        this.y /= len;
+    }
+}
+exports.Point = Point;