server-libs/src/Util.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const promise_1 = require("./promise");
function compareList(a, key, value) {
    if (!a || !a.hasOwnProperty(key))
        return -1;
    if (a[key] > value)
        return 1;
    if (a[key] == value)
        return 0;
    return -1;
}
/**
 * 开始二分法查找
 * @param list 查找用的列表
 * @param key 查找的单位元素
 * @param value 比较用的数值
 */
function orderListFind(list, key, value, desc = false) {
    if (list.length == 0)
        return 0;
    var small = -1, big = list.length;
    while (true) {
        var ret = 0;
        var center = Math.floor((small + big) / 2);
        if (small == big) {
            if (small == -1 || big == list.length)
                return small;
            switch (compareList(list[big], key, value)) {
                case 0: return big;
                case -1: return desc ? big - 1 : big + 1;
                case 1: return desc ? big + 1 : big;
            }
        }
        else if (small + 1 == big) {
            // 差一个的时候比较一下小的
            // switch (compareList<T>(list[big], key, value)) {
            //     case 0: return big;
            //     case -1: return desc ? small : (big == list.length ? big : big + 1);
            //     case 1: return desc ? big + 1 : small;
            // }
            // 这里比较一下，先从小的开始
            var sr = -2, br = -2;
            if (small >= 0) {
                sr = compareList(list[small], key, value);
            }
            if (big < list.length) {
                br = compareList(list[big], key, value);
            }
            if (desc) {
                if (sr != -2 && br != -2) {
                    if (sr == -1) {
                        return small - 1;
                    }
                    else if (sr == 0) {
                        return small;
                    }
                    else if (br == 0) {
                        return big;
                    }
                    else if (br == -1) {
                        // 这里 比小的大，但是比大的小
                        return small;
                    }
                    else {
                        return big;
                    }
                }
                else if (br != -2) {
                    // 这里小的是不存在的，就是说大的是第 0 位
                    if (br == -1) {
                        return small;
                    }
                    else {
                        return big;
                    }
                }
                else if (sr != -2) {
                    // 这里表示大的不存在，就是说小的是最后一个
                    if (sr == -1) {
                        return small - 1;
                    }
                    else {
                        return small;
                    }
                }
                else {
                    return -1;
                }
            }
            else {
                if (sr != -2 && br != -2) {
                    if (sr == 1) {
                        return small - 1;
                    }
                    else if (sr == 0) {
                        return small;
                    }
                    else if (br == 0) {
                        return big;
                    }
                    else if (br == 1) {
                        // 这里 比小的大，但是比大的小
                        return small;
                    }
                    else {
                        return big;
                    }
                }
                else if (br != -2) {
                    // 这里小的是不存在的，就是说大的是第 0 位
                    if (br == 1) {
                        return small;
                    }
                    else {
                        return big;
                    }
                }
                else if (sr != -2) {
                    // 这里表示大的不存在，就是说小的是最后一个
                    if (sr == 1) {
                        return small - 1;
                    }
                    else {
                        return small;
                    }
                }
                else {
                    return -1;
                }
            }
        }
        else {
            ret = compareList(list[center], key, value);
        }
        if (desc) {
            switch (ret) {
                case 0: // 中间值是相等的数值的 当成 1处理
                    big = center;
                    break;
                case 1:
                    small = center;
                    break;
                case -1:
                    big = center;
                    break;
            }
        }
        else {
            switch (ret) {
                case 0: // 中间值是相等的数值的 当成 1处理
                    big = center;
                    break;
                case 1:
                    big = center;
                    break;
                case -1:
                    small = center;
                    break;
            }
        }
    }
}
function orderListInsert(insertValue, list, key, value, desc = false) {
    // 先找一下位置
    var index = orderListFind(list, key, value, desc);
    list.splice(index + 1, 0, insertValue);
}
function orderListRemove(list, key, value, desc = false) {
    var index = orderListFind(list, key, value, desc);
    for (var i = index; i < list.length; i++) {
        var rkInfo = list[i];
        if (rkInfo) {
            if (rkInfo[key] == value) {
                list.splice(i, 1);
            }
            else if ((rkInfo[key] > value && !desc) || (rkInfo[key] < value && desc)) {
                break;
            }
            else if (i != index) {
                console.log("err");
            }
        }
    }
}
class TeMap {
    constructor(_data) {
        this._data = {};
        if (_data) {
            this._data = _data;
        }
    }
    has(key) {
        return this._data.hasOwnProperty(key.toString());
    }
    get(key) {
        return this._data[key];
    }
    set(key, v) {
        this._data[key] = v;
    }
    get keys() {
        return Object.keys(this._data);
    }
    del(key) {
        var obj = this._data[key];
        if (obj && typeof obj == 'object' && obj['destory'] && typeof obj['destory'] == 'function') {
            obj['destory']();
        }
        delete this._data[key];
    }
    rand() {
        var keys = this.keys;
        var tid = keys[Math.floor(Math.random() * keys.length)];
        return this.get(tid);
    }
    clear() {
        this._data = {};
    }
}
exports.TeMap = TeMap;
/**
 * list 的方式实现map
 */
class MapList {
    constructor(mkey) {
        this._data = [];
        this.mkey = mkey;
    }
    _find_index(v) {
        var num = orderListFind(this._data, this.mkey, v);
        if (num < 0 || num >= this._data.length)
            return -1;
        var rInfo = this._data[num];
        if (rInfo[this.mkey] != v) {
            return -1;
        }
        return num;
    }
    has(k) {
        if (this._find_index(k.toString()) >= 0) {
            return true;
        }
        return false;
    }
    at(idx) {
        return this._data[idx];
    }
    get(v) {
        v = v.toString();
        var num = this._find_index(v);
        return (num == -1) ? null : this._data[num];
    }
    set(k, v) {
        k = k.toString();
        var num = this._find_index(k);
        if (num >= 0) {
            // 找到了就使用
            this._data[num] = v;
        }
        else {
            // 没找到就要新增一个
            orderListInsert(v, this._data, this.mkey, k);
        }
    }
    remove(v) {
        v = v.toString();
        orderListRemove(this._data, this.mkey, v);
    }
    get length() {
        return this._data.length;
    }
    clear() {
        this._data = [];
    }
}
exports.MapList = MapList;
var showUpdate = false;
function promise_setInterval(...args) {
    let [name, callback, time] = args;
    if (typeof name != 'string') {
        name = '';
        callback = args[0];
        time = args[1];
    }
    let handle;
    function update() {
        if (showUpdate)
            console.log(handle.name, callback.name, 'start');
        promise_1.createPromise(callback()).finally(function () {
            if (showUpdate)
                console.log(handle.name, callback.name, 'finish');
            handle && handle.refresh();
        });
    }
    handle = setTimeout(update, time);
    handle['name'] = name;
    return {
        stop: function () {
            clearTimeout(handle);
        }
    };
}
class TeRandom {
    constructor(seed = Math.random()) {
        this._seed = 5;
        this._seed = seed;
    }
    reset(seed) {
        this._seed = seed;
    }
    get seed() {
        return this._seed;
    }
    random(min, max, msg = "") {
        max = (max == undefined) ? 1 : max;
        min = (min == undefined) ? 0 : min;
        this._seed = (this._seed * 9301 + 49297) % 233280;
        var rnd = this._seed / 233280.0;
        // console.log(gMain.iGameTime,this._seed,min,max,min + rnd * (max - min),msg);
        return min + rnd * (max - min);
    }
    ;
    randInt(min, max, msg = "") {
        return Math.floor(this.random(min, max, msg));
    }
}
exports.TeRandom = TeRandom;
TeRandom.DEFAULT_SEED = 6364;
class HashMap {
    constructor() {
        this._data = {};
    }
    get(key) {
        key = key.toString();
        return this._data[key] || [];
    }
    add(key, v) {
        if (typeof key == 'number') {
            key = key.toString();
        }
        if (!this._data[key]) {
            this._data[key] = [];
        }
        this._data[key].push(v);
    }
    get keys() {
        return Object.keys(this._data);
    }
    set(key, v) {
        key = key.toString();
        this._data[key] = v;
    }
    clear() {
        this._data = {};
    }
    has(key, v) {
        key = key.toString();
        if (this._data.hasOwnProperty(key)) {
            if (v && this.get(key).indexOf(v) < 0)
                return false;
            return true;
        }
        return false;
    }
    sort(fn) {
        for (var key in this._data) {
            var r = this._data[key];
            r.sort(fn);
        }
    }
}
exports.HashMap = HashMap;
// 拷贝函数 是否包括函数拷贝
function func_copy(obj, bFunc = false) {
    var out;
    if (obj instanceof Array) {
        out = [];
        // 数组这里就
        for (let i = 0; i < obj.length; i++) {
            out[i] = func_copy(obj[i], bFunc);
        }
    }
    else if (obj instanceof Buffer) {
        // buffer 这里就不拷贝算了
        out = Buffer.from(obj);
    }
    else if (typeof obj == 'object') {
        out = {};
        for (var key in obj) {
            if (key == 'clone' || key == 'global') {
                continue;
            }
            if (typeof obj[key] == 'function' && !bFunc) {
                continue;
            }
            if (obj[key] == null) {
                out[key] = null;
            }
            else
                out[key] = func_copy(obj[key], false);
        }
    }
    else {
        out = obj;
    }
    return out;
}
exports.Util = {
    Sort: {
        orderListFind: orderListFind,
        orderListRemove: orderListRemove,
        orderListInsert: orderListInsert
    },
    Map: TeMap,
    MapList: MapList,
    setInterval: promise_setInterval,
    switchShowInterval: function (b) {
        showUpdate = b;
    },
    Random: TeRandom,
    HashMap: HashMap,
    copy: func_copy
};