添加抽卡的方法

src/api.server.ts

@@ -19,6 +19,7 @@ const fs = require('fs');
 const join = require('path').join;
 
 let config: Config = require('../config/config.json');
+require('./common/Extend');
 
 export class ApiServer {
     server: FastifyInstance<Server, IncomingMessage, ServerResponse>;

src/common/Extend.ts

@@ -0,0 +1,863 @@
+
+/**
+ * 对数字进行补0操作
+ * @param value 要补0的数值
+ * @param length 要补的总长度
+ * @return 补0之后的字符串
+ */
+function zeroize(value: number | string, length: number = 2): string {
+    let str = "" + value;
+    let zeros = "";
+    for (let i = 0, len = length - str.length; i < len; i++) {
+        zeros += "0";
+    }
+    return zeros + str;
+}
+
+/****************************************扩展Object****************************************/
+interface Object {
+    /**
+     * 返回一个浅副本的对象
+     * 此对象会拷贝key value
+     *
+     * @memberOf Object
+     */
+    clone?(): Object;
+    /**
+     * 将数据拷贝到 to
+     * @param to 目标
+     */
+    copyto?(to: Object):void;
+    /**
+     * 获取指定属性的描述，会查找当前数据和原型数据
+     * @param property 指定的属性名字
+     */
+    getPropertyDescriptor?(property: string): PropertyDescriptor;
+
+
+    zssign?(target: any): any;
+}
+
+Object.defineProperties(Object.prototype, {
+    clone: {
+        value: function () {
+            let o = {};
+            for (let n in this) {
+                // @ts-ignore
+                o[n] = this[n];
+            }
+            return o;
+        },
+        writable: true
+    },
+    getPropertyDescriptor: {
+        value: function (property: string): any {
+            let data = Object.getOwnPropertyDescriptor(this, property);
+            if (data) {
+                return data;
+            }
+            let prototype = Object.getPrototypeOf(this);
+            if (prototype) {
+                return prototype.getPropertyDescriptor(property);
+            }
+            return;
+        },
+        writable: true
+    },
+    copyto: {
+        value: function (to: Object) {
+            for (let p in this) {
+                if (!(p in to)) { // 本身没有这个属性
+                    // @ts-ignore
+                    to[p] = this[p];
+                } else {
+                    let data: PropertyDescriptor = to.getPropertyDescriptor(p);
+                    if (data) {
+                        if (data.set || data.writable) {// 可进行赋值
+                            // @ts-ignore
+                            to[p] = this[p];
+                        }
+                    }
+                }
+            }
+        },
+        writable: true
+    },
+    zssign: {
+        value: function (target: Object) {
+            if (target === undefined || target === null) {
+                throw new TypeError('Cannot convert undefined or null to object');
+            }
+
+            let output = Object(target);
+            for (let nextKey in this) {
+                if (!(nextKey in output)) { // 本身没有这个属性
+                    output[nextKey] = this[nextKey];
+                }
+                // else {
+                //     let data: PropertyDescriptor = output.getPropertyDescriptor(nextKey);
+                //     if (data) {
+                //         if (data.set || data.writable) {// 可进行赋值
+                //             output[nextKey] = this[nextKey];
+                //         }
+                //     }
+                // }
+            }
+            return output;
+        },
+        writable: true
+    }
+});
+
+/****************************************扩展Math****************************************/
+interface Math {
+    /**
+     * 让数值处于指定的最大值和最小值之间，低于最小值取最小值，高于最大值取最大值
+     * @param value 要处理的数值
+     * @param min   最小值
+     * @param max   最大值
+     */
+    clamp?(value: number, min: number, max: number): number;
+
+    /**
+     * 从最小值到最大值之间随机[min,max)
+     */
+    random2?(min: number, max: number): number;
+    /**
+     * 角度转弧度的乘数
+     * Math.PI / 180
+     * @type {number}
+     * @memberOf Math
+     */
+    DEG_TO_RAD: number;
+    /**
+     * 弧度转角度的乘数
+     * 180 / Math.PI
+     */
+    RAD_TO_DEG: number;
+    /**
+     * 整圆的弧度
+     */
+    PI2: number;
+    /**
+     * 90°的弧度
+     *
+     * @type {number}
+     * @memberOf Math
+     */
+    PI_1_2: number;
+}
+
+Math.DEG_TO_RAD = Math.PI / 180;
+
+Math.RAD_TO_DEG = 180 / Math.PI;
+
+Math.PI2 = 2 * Math.PI;
+
+Math.PI_1_2 = Math.PI * .5;
+
+Math.clamp = (value, min, max) => {
+    if (value < min) {
+        value = min;
+    }
+    if (value > max) {
+        value = max;
+    }
+    return value;
+}
+
+Math.random2 = (min, max) => {
+    return min + Math.random() * (max - min);
+}
+
+/****************************************扩展Number********************************************/
+interface Number {
+    /**
+     * 对数字进行补0操作
+     * @param length 要补的总长度
+     * @return 补0之后的字符串
+     */
+    zeroize?(length: number): string;
+
+    /**
+     * 数值介于，`min` `max`直接，包含min，max
+     * 即：[min,max]
+     *
+     * @param {number} min
+     * @param {number} max
+     * @returns {boolean}
+     * @memberof Number
+     */
+    between?(min: number, max: number): boolean;
+}
+
+Object.defineProperties(Number.prototype, {
+    zeroize: {
+        value: function (this: number, length: number) { return zeroize(this, length) },
+        writable: true
+    },
+    between: {
+        value: function (this: number, min: number, max: number) { return min <= this && max >= this },
+        writable: true
+    }
+});
+
+/****************************************扩展String****************************************/
+interface String {
+    /**
+     * 替换字符串中{0}{1}{2}{a} {b}这样的数据，用obj对应key替换，或者是数组中对应key的数据替换
+     */
+    substitute?(...args: any): string;
+    substitute?(args: any[]): string;
+    /**
+     * 对数字进行补0操作
+     * @param length 要补的总长度
+     * @return 补0之后的字符串
+     */
+    zeroize?(length: number): string;
+    /**
+     * 将一个字符串转换成一个很小几率重复的数值
+     * <font color="#ff0000">此方法hash的字符串并不一定唯一，慎用</font>
+     */
+    hash?(): number;
+
+    /**
+     * 获取字符串长度，中文方块字符算两个长度
+     */
+    trueLength?(): number;
+    /**
+     * 中文字符个数
+     * */
+    cnLength?(): number;
+    /**
+     * 比较版本号
+     * */
+    versionCompare?(target: string): number;
+}
+
+
+Object.defineProperties(String.prototype, {
+    zeroize: {
+        value: function (length: number) { return zeroize(this, length) },
+        writable: true
+    },
+    substitute: {
+        value: function (this: string) {
+            let len = arguments.length;
+            if (len > 0) {
+                let obj: IArguments;
+                if (len == 1) {
+                    obj = arguments[0];
+                    if (typeof obj !== "object") {
+                        obj = arguments;
+                    }
+                } else {
+                    obj = arguments;
+                }
+                if ((obj instanceof Object) && !(obj instanceof RegExp)) {
+                    return this.replace(/\{(?:%([^{}]+)%)?([^{}]+)\}/g, function (match: string, handler: string, key: string) {
+                        //检查key中，是否为%开头，如果是，则尝试按方法处理
+                        // @ts-ignore
+                        let value = obj[key];
+                        if (handler) {//如果有处理器，拆分处理器
+                            let func = String.subHandler[handler];
+                            if (func) {
+                                value = func(value);
+                            }
+                        }
+                        return (value !== undefined) ? '' + value : match;
+                    });
+                }
+            }
+            return this.toString();//防止生成String对象，ios反射String对象会当成一个NSDictionary处理
+        },
+        writable: true
+    },
+    hash: {
+        value: function () {
+            let len = this.length;
+            let hash = 5381;
+            for (let i = 0; i < len; i++) {
+                hash += (hash << 5) + this.charCodeAt(i);
+            }
+            return hash & 0x7fffffff;
+        },
+        writable: true
+    },
+    trueLength: {
+        value: function () {
+            let arr: string[] = this.match(/[\u2E80-\u9FBF]/ig);
+            return this.length + (arr ? arr.length : 0);
+        },
+        writable: true
+    },
+    cnLength: {
+        value: function () {
+            let arr: string[] = this.match(/[\u2E80-\u9FBF]/ig);
+            return arr ? arr.length : 0;
+        },
+        writable: true
+    },
+    versionCompare: {
+        value: function (target: string): number {
+            const GTR = 1; //大于
+            const LSS = -1; //小于
+            const EQU = 0; //等于
+            if (!target) {
+                return GTR;
+            }
+            let v1arr = String(this).split(".").map(function (a) {
+                return parseInt(a);
+            });
+            let v2arr = String(target).split(".").map(function (a) {
+                return parseInt(a);
+            });
+            let arrLen = Math.max(v1arr.length, v2arr.length);
+            let result;
+
+            //排除错误调用
+            if (this == undefined || target == undefined) {
+                throw new Error();
+            }
+
+            //检查空字符串，任何非空字符串都大于空字符串
+            if (this.length == 0 && target.length == 0) {
+                return EQU;
+            } else if (this.length == 0) {
+                return LSS;
+            } else if (target.length == 0) {
+                return GTR;
+            }
+            //循环比较版本号
+            for (let i = 0; i < arrLen; i++) {
+                result = versionComp(v1arr[i], v2arr[i]);
+                if (result == EQU) {
+                    continue;
+                } else {
+                    break;
+                }
+            }
+            return result;
+
+            function versionComp(n1: number, n2: number) {
+                if (typeof n1 != "number") {
+                    n1 = 0;
+                }
+                if (typeof n2 != "number") {
+                    n2 = 0;
+                }
+                if (n1 > n2) {
+                    return GTR;
+                } else if (n1 < n2) {
+                    return LSS;
+                } else {
+                    return EQU;
+                }
+            }
+        },
+        writable: true
+    }
+});
+interface StringConstructor {
+    /**
+     * 对数字进行补0操作
+     * @param value 要补0的数值
+     * @param length 要补的总长度
+     * @return 补0之后的字符串
+     */
+    zeroize?: (value: number, length: number) => string;
+
+
+    /**
+     * substitute的回调函数
+     *
+     * @type {Readonly<{ [index: string]: { (input: any): string } }>}
+     * @memberOf StringConstructor
+     */
+    subHandler?: Readonly<{ [index: string]: { (input: any): string } }>;
+}
+
+String.zeroize = zeroize;
+
+
+
+/****************************************扩展Date****************************************/
+
+
+interface Date {
+
+    /**
+     * 格式化日期
+     *
+     * @param {string} mask 时间字符串
+     * @param {boolean} [local] 是否基于本地时间显示，目前项目，除了报错信息，其他时间都用UTC时间显示
+     * @returns {string} 格式化后的时间
+     */
+    format(mask: string, local?: boolean): string;
+}
+
+Object.defineProperties(Date.prototype, {
+    format: {
+        value: function (mask: string, local?: boolean) {
+            let d: Date = this;
+            // @ts-ignore
+            return mask.replace(/"[^"]*"|'[^']*'|(?:d{1,2}|m{1,2}|yy(?:yy)?|([hHMs])\1?)/g, function ($0: string) {
+                switch ($0) {
+                    case "d": return gd();
+                    case "dd": return zeroize(gd());
+                    case "M": return gM() + 1;
+                    case "MM": return zeroize(gM() + 1);
+                    case "yy": return (gy() + "").substr(2);
+                    case "yyyy": return gy();
+                    case "h": return gH() % 12 || 12;
+                    case "hh": return zeroize(gH() % 12 || 12);
+                    case "H": return gH();
+                    case "HH": return zeroize(gH());
+                    case "m": return gm();
+                    case "mm": return zeroize(gm());
+                    case "s": return gs();
+                    case "ss": return zeroize(gs());
+                    default: return $0.substr(1, $0.length - 2);
+                }
+            });
+            function gd() { return local ? d.getDate() : d.getUTCDate() }
+            function gM() { return local ? d.getMonth() : d.getUTCMonth() }
+            function gy() { return local ? d.getFullYear() : d.getUTCFullYear() }
+            function gH() { return local ? d.getHours() : d.getUTCHours() }
+            function gm() { return local ? d.getMinutes() : d.getUTCMinutes() }
+            function gs() { return local ? d.getSeconds() : d.getUTCSeconds() }
+        },
+        writable: true
+    }
+});
+
+/****************************************扩展Array****************************************/
+const enum ArraySort {
+    /**
+     * 升序
+     */
+    ASC = 0,
+    /**
+     * 降序
+     */
+    DESC = 1
+}
+
+
+
+interface ArrayConstructor {
+    // binaryInsert<T>(partArr: T[], item: T, filter: { (tester: T, ...args): boolean }, ...args);
+    SORT_DEFAULT: { number: 0, string: "", boolean: false };
+}
+
+/**
+ * 用于对Array排序时，处理undefined
+ */
+Array.SORT_DEFAULT = {
+    number: 0,
+    string: "",
+    boolean: false
+}
+Object.freeze(Array.SORT_DEFAULT);
+
+interface Array<T> {
+    /**
+     * 如果数组中没有要放入的对象，则将对象放入数组
+     *
+     * @param {T} t 要放入的对象
+     * @returns {number} 放入的对象，在数组中的索引
+     *
+     * @member Array
+     */
+    pushOnce?(t: T): number;
+
+    /**
+    *
+    * 删除某个数据
+    * @param {T} t
+    * @returns {boolean}   true 有这个数据并且删除成功
+    *                      false 没有这个数据
+    */
+    remove?(t: T): boolean;
+
+    /**
+     * 排序 支持多重排序
+     * 降序, 升序
+     * @param {(keyof T)[]} kArr              参数属性列表
+     * @param {(boolean[] | ArraySort[])} [dArr] 是否降序，默认升序
+     * @returns {this}
+     *
+     * @member Array
+     */
+    multiSort?(kArr: (keyof T)[], dArr?: boolean[] | ArraySort[]): this;
+
+    /**
+     * 默认排序
+     *
+     * @param {string} [key]
+     * @param {boolean} [descend]
+     *
+     * @member Array
+     */
+    doSort?(key?: keyof T, descend?: boolean | ArraySort): this;
+    doSort?(descend?: boolean | ArraySort, key?: keyof T): this;
+
+    /**
+     * 将数组克隆到to
+     * to的数组长度会和当前数组一致
+     *
+     * @template T
+     * @param {Array<T>} to
+     */
+    cloneTo?<T>(to: Array<T>):void;
+
+    /**
+     * 将数组附加到to中
+     *
+     * @template T
+     * @param {Array<T>} to
+     *
+     * @member ArrayConstructor
+     */
+    appendTo?<T>(to: Array<T>):void;
+
+    /**
+     * 移除数组index位置的元素, 比slice效率高
+     * @param index
+     */
+    spliceOne?(index: number): boolean;
+
+    /**
+     * 随机排序
+     */
+    randomSort?():void;
+
+    /**
+     * 检查数组中是否含有另外一个object
+     * @param obj 与数组同类型的obj | 同类型的数组 | 指定child字段的值 | 指定child字段的数组
+     * @param child 比较字段
+     */
+    contains?<T>(obj: T | T[] | {} | {}[], child?: string): boolean;
+
+    /**
+     * 将数组随机插入当前数组中
+     * @param arr
+     */
+    randomInsert?<T>(arr: Array<T>):void;
+    /**
+     * 随机获取n个元素
+     * @param count
+     */
+    randomGet?<T>(count?: number):T[];
+    /**
+     * 随机获取1个元素
+     */
+    randomOne?<T>():T;
+    /**
+     * 随机移除n个元素
+     * @param count
+     */
+    randomRemove?<T>(count?: number):T[];
+    /**
+     * 数组移动n位
+     * @param n n > 0 右移, n<0 左移
+     */
+    moveElement?<T>(n: number): T[];
+
+    /**
+     * 两个数组并集
+     * @param arr
+     */
+    union?<T>(arr: T[]): T[];
+
+    /**
+     * 两个数组交集
+     * @param arr
+     */
+    intersect?<T>(arr: T[]): T[];
+    /**
+     * 相对于arr的差集
+     * @param arr
+     */
+    difference?<T>(arr: T[]): T[];
+}
+
+Object.defineProperties(Array.prototype, {
+    cloneTo: {
+        value: function <T>(this: T[], b: any[]) {
+            b.length = this.length;
+            let len = this.length;
+            b.length = len;
+            for (let i = 0; i < len; i++) {
+                b[i] = this[i];
+            }
+        },
+        writable: true
+    },
+    appendTo: {
+        value: function <T>(this: T[], b: any[]) {
+            let len = this.length;
+            for (let i = 0; i < len; i++) {
+                b.push(this[i]);
+            }
+        },
+        writable: true
+    },
+    pushOnce: {
+        value: function <T>(this: T[], t: T) {
+            let idx = this.indexOf(t);
+            if (!~idx) {
+                idx = this.length;
+                this[idx] = t;
+            }
+            return idx;
+        },
+        writable: true
+    },
+    remove: {
+        value: function <T>(this: T[], t: T) {
+            let idx = this.indexOf(t);
+            if (~idx) {
+                this.splice(idx, 1);
+                return true;
+            }
+            return false;
+        },
+        writable: true
+    },
+    doSort: {
+        value: function () {
+            let key: string, descend: boolean;
+            let len = arguments.length;
+
+            for (let i = 0; i < len; i++) {
+                let arg = arguments[i];
+                let t = typeof arg;
+                if (t === "string") {
+                    key = arg;
+                } else {
+                    descend = !!arg;
+                }
+            }
+            if (key) {
+                return this.sort((a: any, b: any) => descend ? b[key] - a[key] : a[key] - b[key]);
+            } else {
+                return this.sort((a: any, b: any) => descend ? b - a : a - b);
+            }
+        },
+        writable: true
+    },
+    multiSort: {
+        value: function (kArr: string[], dArr?: boolean[] | boolean) {
+            let isArr = Array.isArray(dArr);
+            return this.sort((a: any, b: any): number => {
+                const def = Array.SORT_DEFAULT;
+                for (let idx = 0, len = kArr.length; idx < len; idx++) {
+                    let key = kArr[idx];
+                    // @ts-ignore
+                    let mode = isArr ? !!dArr[idx] : !!dArr;
+                    let av = a[key];
+                    let bv = b[key];
+                    let typea = typeof av;
+                    let typeb = typeof bv;
+                    if (typea == "object" || typeb == "object") {
+                        return 0;
+                    }
+                    else if (typea != typeb) {
+                        if (typea == "undefined") {
+                            // @ts-ignore
+                            bv = def[typeb];
+                        } else if (typeb == "undefined") {
+                            // @ts-ignore
+                            av = def[typea];
+                        }
+                        else {
+                            return 0;
+                        }
+                    }
+                    if (av < bv) {
+                        return mode ? 1 : -1;
+                    } else if (av > bv) {
+                        return mode ? -1 : 1;
+                    } else {
+                        continue;
+                    }
+                }
+                return 0;
+            });
+        },
+        writable: true
+    },
+    spliceOne: {
+        value: function (index: number): boolean {
+            if (index === -1 || index >= this.length) {
+                return false;
+            }
+            const len = this.length - 1;
+            for (let i = index; i < len; i++) {
+                this[i] = this[i + 1];
+            }
+            this.length = len;
+            return true;
+        },
+        writable: true
+    },
+
+    randomSort: {
+        value: function<T> () {
+            for (let j, x, i = this.length; i; j = (Math.random() * i) | 0, x = this[--i], this[i] = this[j], this[j] = x) {
+                ;
+            }
+        },
+        writable: true
+    },
+    contains: {
+        value: function<T> (obj: T | T[] | {} | {}[], child?: string): boolean {
+            let result = false;
+            if (child) {
+                const isArr = Array.isArray(obj);
+                if (isArr) {
+                    // @ts-ignore
+                    if (obj[0].hasOwnProperty(child)) {
+                        let set0 = new Set();
+                        // @ts-ignore
+                        for (let s of obj) {
+                            // @ts-ignore
+                            set0.add(s[child]);
+                        }
+                        // @ts-ignore
+                        let set1 = new Set(this.filter (x => set0.has(x)));
+                        return set0.size === set1.size;
+                    } else {
+                        // @ts-ignore
+                        let set0 = new Set(obj);
+                        let set1 = new Set(this.filter ((x: {}) => set0.has(x)));
+                        return set1.size === set0.size;
+                    }
+
+                } else {
+                    if (obj.hasOwnProperty(child)) {
+                        for (let sub of this) {
+                            if (sub.hasOwnProperty(child)) {
+                                // @ts-ignore
+                                if (sub[child] === obj[child]) {
+                                    result = true;
+                                    break;
+                                }
+                            }
+                        }
+                    } else {
+                        for (let sub of this) {
+                            if (sub.hasOwnProperty(child)) {
+                                // @ts-ignore
+                                if (sub[child] === obj) {
+                                    result = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                }
+            } else {
+                // 不指定 比较字段 的话, 只处理2种情况
+                // 1: obj 为数组
+                // 2: obj 不是数组
+                if (Array.isArray(obj)) {
+                    let set0 = new Set(obj);
+                    // @ts-ignore
+                    let set1 = new Set(this.filter (x => set0.has(x)));
+                    return set1.size === set0.size;
+                } else {
+                    let idx = this.indexOf(obj);
+                    return !!(~idx);
+                }
+
+            }
+            return result;
+        },
+        writable: true
+    },
+    randomInsert: {
+        value: function<T>(arr: Array<T>) {
+            const length = this.length;
+            arr.forEach(value => {
+                this.splice(Math.random() * length, 0 , value);
+            })
+        },
+        writable: true
+    },
+    randomGet: {
+        value: function<T>(count: number = 1):T[] {
+            let shuffled: T[] = this.slice(0), i = this.length, min = i - count, temp, index;
+            if (min < 0) {
+                return shuffled;
+            }
+            while (i-- > min) {
+                index = Math.floor((i + 1) * Math.random());
+                temp = shuffled[index];
+                shuffled[index] = shuffled[i];
+                shuffled[i] = temp;
+            }
+            return shuffled.slice(min);
+        },
+        writable: true
+    },
+    randomOne: {
+        value: function<T>(): T {
+            let results = this.randomGet(1);
+            if (results.length > 0) {
+                return results[0];
+            } else {
+                return null;
+            }
+        },
+        writable: true
+    },
+    randomRemove: {
+        value: function<T>(count: number = 1):T[] {
+            let result = [];
+            while (count -- > 0 && this.length > 0) {
+                let index = Math.random() * this.length | 0;
+                result.push(...this.splice(index, 1));
+            }
+            return result;
+        },
+        writable: true
+    },
+
+    moveElement: {
+        value: function<T> (n: number): T[] {
+            if (Math.abs(n) > this.length) n = n % this.length;
+            return this.slice(-n).concat(this.slice(0, -n));
+        },
+        writable: true
+    },
+
+    union: {
+        value: function<T> (this: T[], b: any[]): T[] {
+            let a = this.concat(b);
+            return [...new Set(a)];
+        },
+        writable: true
+    },
+
+    intersect: {
+        value: function<T> (this: T[], b: any[]): T[] {
+            let set0 = new Set(b);
+            let set1 = new Set(this.filter (x => set0.has(x)));
+            return [...set1];
+        },
+        writable: true
+    },
+
+    difference: {
+        value: function<T> (this: T[], b: any[]): T[] {
+            let set0 = new Set(b);
+            let set1 = new Set(this.filter(x => !set0.has(x)));
+            return [...set1];
+        },
+        writable: true
+    }
+
+});

src/controllers/CardController.ts

@@ -4,6 +4,7 @@ import {CardGroup} from "../models/CardGroup";
 import {ZError} from "../common/ZError";
 import {Card} from "../models/subdoc/Card";
 import {MoneyTypeConst} from "../constants/MoneyTypeConst";
+import {BaseConst} from "../constants/BaseConst";
 
 export default class CardController extends BaseController {
     @router('post /api/:accountid/card_group/:heroid')
@@ -102,8 +103,37 @@ export default class CardController extends BaseController {
         }
         account.moneys.set(MoneyTypeConst.CARD_SCROLL, money - count);
 
-        // TODO: 随机取count张卡牌, 并与当前已有的卡比较, 将新卡添加进用户卡组
+        // TODO: 根据配置的概率获取卡
+        let cardMap = global.$cfg.get(BaseConst.UNIT);
+        let cards: any[] = [];
+        for (let [id, card] of cardMap) {
+            if (card.unittypei_id == 2) {
+                cards.push(card);
+            }
+        }
+        let cardsgetd: number[] = cards.randomGet(count).map((o: any) => o.id);
+        let totalCards = account.cards.union(cardsgetd);
+        let dulpSet = new Set(account.cards.intersect(cardsgetd));
+        let results: any = [];
+        let expHero = account.moneys.get(MoneyTypeConst.HERO_EXP) || 0;
+        //TODO: 根据配置设置每张卡分解后得到的经验
+        const expPreCard = 10;
+        for (let id of cardsgetd) {
+            let data: any = {id};
+            if (dulpSet.has(id)) {
+                data.isnew = false;
+                data.expdust = MoneyTypeConst.HERO_EXP;
+                data.dustcount = expPreCard;
+                expHero += expPreCard;
+            } else {
+                data.isnew = true;
+            }
+            results.push(data);
+        }
+
+        account.moneys.set(MoneyTypeConst.HERO_EXP, expHero);
+        account.cards = totalCards;
         await account.save();
-        return {};
+        return results;
     }
 }