481 lines
17 KiB
TypeScript
481 lines
17 KiB
TypeScript
import { GachaData, Floor, GachaResult, Hope, GachaListReturn } from "../../domain/activityField/gachaField";;
|
||
import { DicGacha } from "../../pubUtils/dictionary/DicGacha";
|
||
import { UserGachaType, UserGachaModel } from "../../db/UserGacha";
|
||
import { shouldRefresh, getRandEelm, getRandEelmWithWeight, getRandSingleIndex, getRandSingleEelm } from "../../pubUtils/util";
|
||
import { REFRESH_TIME, GACHA_TO_FLOOR, GACHA_FLOOR_TYPE, GACHA_CONTENT_TYPE, HERO_QUALITY_TYPE, GACHA_OCCUPY_HID, IT_TYPE, ITID, CONSUME_TYPE, SPECIAL_ATTR, TIME_OUTPUT_TYPE, GACHA_ID } from "../../consts";
|
||
import { getTimeFunD, getZeroPointD } from "../../pubUtils/timeUtil";
|
||
import { gameData, getDicGachaFloor, getGachaContentOfHeroQuality } from "../../pubUtils/data";
|
||
import { RoleModel } from "../../db/Role";
|
||
import { RewardInter } from "../../pubUtils/interface";
|
||
import { CreateHeroParam } from "../../domain/roleField/hero";
|
||
import { HeroType } from "../../db/Hero";
|
||
import { NewHeroGachaItem } from "../../domain/activityField/newHeroGachaField";
|
||
import { getActivityById } from "./activityService";
|
||
import { transPiece } from "../role/util";
|
||
import { getRoleCreateTime, getServerCreateTime } from "../redisService";
|
||
|
||
/**
|
||
* 获取招募列表
|
||
* @param roleId
|
||
*/
|
||
export async function getGachaList(roleId: string) {
|
||
let userGachaList = await UserGachaModel.findAllByRole(roleId);
|
||
let list: GachaListReturn[] = [];
|
||
for (let [id, dicGacha] of gameData.gacha) {
|
||
if (id == GACHA_ID.TIMELIMIT) continue; // 不包括限时
|
||
|
||
let userGacha = userGachaList.find(cur => cur.gachaId == id);
|
||
if (userGacha)
|
||
userGacha = await refreshGacha(dicGacha, userGacha);
|
||
let param = new GachaListReturn(dicGacha, userGacha);
|
||
list.push(param);
|
||
}
|
||
return list;
|
||
}
|
||
|
||
/**
|
||
* 获取活动页签里的限时卡池
|
||
*
|
||
* @param roleId 玩家id
|
||
* @param aid 活动id
|
||
*/
|
||
export async function getLimitGacha(serverId: number, roleId: string, activityId: number) {
|
||
|
||
let activityData = await getActivityById(activityId);
|
||
if (!activityData) return false;
|
||
|
||
let createTime = await getRoleCreateTime(roleId);
|
||
let serverTime = await getServerCreateTime(serverId);
|
||
let gachaData = new GachaData(activityData, createTime, serverTime);
|
||
let userGacha = await UserGachaModel.findByRole(roleId, gachaData.gachaId, activityId);
|
||
userGacha = await refreshGacha(gameData.gacha.get(gachaData.gachaId), userGacha);
|
||
gachaData.setUserGacha(userGacha);
|
||
return gachaData
|
||
}
|
||
|
||
/**
|
||
* 刷新免费次数
|
||
* @param dicGacha
|
||
* @param userGacha
|
||
*/
|
||
export async function refreshGacha(dicGacha: DicGacha, userGacha: UserGachaType) {
|
||
let { day, count } = dicGacha.free;
|
||
|
||
if (count <= 0) {
|
||
return userGacha;
|
||
}
|
||
|
||
let { roleId, gachaId, refFreeTime, refHopeTime, hope } = userGacha;
|
||
if (shouldRefresh(refFreeTime, new Date(), REFRESH_TIME, day)) {
|
||
let ref = <Date>getTimeFunD().getAfterDayByGap(refFreeTime, day);
|
||
userGacha = await UserGachaModel.refreshFreeCount(roleId, gachaId, 0, ref);
|
||
}
|
||
if (shouldRefresh(refHopeTime, new Date(), REFRESH_TIME)) {
|
||
hope = hope.map(cur => { return { ...cur, hasGet: false } });
|
||
let ref = getZeroPointD();
|
||
userGacha = await UserGachaModel.refreshHopeCount(roleId, gachaId, 0, hope, ref);
|
||
}
|
||
return userGacha
|
||
}
|
||
|
||
|
||
export async function getVisitedHeroList(roleId: string) {
|
||
|
||
let { visitedHero, refVisitedTime } = await UserGachaModel.findByRole(roleId, GACHA_ID.NORMAL, 0);
|
||
if (shouldRefresh(refVisitedTime, new Date())) {
|
||
visitedHero = [];
|
||
}
|
||
|
||
return visitedHero;
|
||
}
|
||
|
||
class PlayerGachaRecord {
|
||
public lv: number; // 玩家等级
|
||
public hope: Hope[] = []; // 玩家记录的心愿单达成情况
|
||
public floor: Floor[] = [];
|
||
public pickHero: number = 0;
|
||
|
||
constructor(userGacha: UserGachaType, item: NewHeroGachaItem) {
|
||
if(userGacha) {
|
||
this.floor = userGacha.floor;
|
||
this.hope = userGacha.hope;
|
||
this.pickHero = userGacha.pickHero;
|
||
}
|
||
if(item) {
|
||
this.floor.push({ id: GACHA_FLOOR_TYPE.ASSIGN, count: item.count, hasGetFloor: item.hasGetFloor });
|
||
}
|
||
}
|
||
|
||
public getFloorCountByFloorType(floorType: GACHA_FLOOR_TYPE) {
|
||
let userFloor = this.floor.find(cur => cur.id == floorType);
|
||
if(userFloor) {
|
||
return { floorCount: userFloor.count, hasGetFloor: userFloor.hasGetFloor }
|
||
} else {
|
||
return { floorCount: 0, hasGetFloor: false }
|
||
}
|
||
}
|
||
|
||
public setFloorCount(floorType: GACHA_FLOOR_TYPE, count: number, hasGetFloor: boolean) {
|
||
let index = this.floor.findIndex(cur => cur.id == floorType);
|
||
if(index == -1) {
|
||
this.floor.push({ id: floorType, count, hasGetFloor })
|
||
} else {
|
||
this.floor[index].count = count;
|
||
this.floor[index].hasGetFloor = hasGetFloor;
|
||
}
|
||
}
|
||
|
||
public getHopeHero(randHopePosition: number) {
|
||
let userHope = this.hope.find(cur => cur.id == randHopePosition);
|
||
if(!userHope || userHope.hasGet) return 0;
|
||
return userHope.hid||0;
|
||
}
|
||
|
||
public setUserHope(hid: number) {
|
||
if(hid <= 0) return;
|
||
let userHope = this.hope.find(cur => cur.hid == hid);
|
||
if(userHope && !userHope.hasGet) userHope.hasGet = true;
|
||
}
|
||
|
||
public getUserGachaParam() {
|
||
return { hope: this.hope, floor: this.floor }
|
||
}
|
||
}
|
||
|
||
class GachaResults {
|
||
count: number = 0;
|
||
list: GachaResult[] = [];
|
||
|
||
addResult(contentId: number, id?: number) {
|
||
this.count++;
|
||
this.list.push(new GachaResult(contentId, id));
|
||
}
|
||
|
||
public shouldPurpleFloor(floorCount: number) {
|
||
return this.count % floorCount == 0 && !this.hasPurple();
|
||
}
|
||
|
||
public hasPurple() {
|
||
return this.list.findIndex(gachaResult => this.checkContentIsHero(gachaResult.contentId, HERO_QUALITY_TYPE.PURPLE)) != -1;
|
||
}
|
||
|
||
private checkContentIsHero(contentId: number, quality: HERO_QUALITY_TYPE) {
|
||
let {type, param} = gameData.gachaContent.get(contentId);
|
||
return type == GACHA_CONTENT_TYPE.HERO && param[0] >= quality;
|
||
}
|
||
|
||
public getRandItemNotPurple() {
|
||
let indexes = this.filterIndex(item => {
|
||
return !this.checkContentIsHero(item.contentId, HERO_QUALITY_TYPE.PURPLE);
|
||
});
|
||
let index = getRandSingleEelm(indexes);
|
||
return this.list[index];
|
||
}
|
||
|
||
|
||
private filterIndex(callback: (item: GachaResult) => boolean) {
|
||
let result: number[] = [];
|
||
for(let i = 0; i < this.list.length; i++) {
|
||
if(callback(this.list[i])) {
|
||
result.push(i);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 抽卡方法
|
||
*/
|
||
export class GachaPull {
|
||
private gachaType: GACHA_ID; // 抽卡类型
|
||
// 字典
|
||
private dicFloor: Map<GACHA_FLOOR_TYPE, number> = new Map(); // 保底次数
|
||
private percent: { id: number, weight: number, goodId?: number }[] = [];
|
||
private bigReward: { id: number, weight: number, goodId?: number }; // 保底的一项，percent中的一项
|
||
// 玩家数据
|
||
private player: PlayerGachaRecord;
|
||
// 结果
|
||
private result = new GachaResults();
|
||
|
||
constructor(gachaType: GACHA_ID, ) {
|
||
this.gachaType = gachaType;
|
||
}
|
||
|
||
// 一般抽卡setter
|
||
public setByUserGacha(dicGacha: DicGacha, userGacha: UserGachaType, isGuide: boolean) {
|
||
// 字典方面
|
||
this.percent = dicGacha.percent;
|
||
if (dicGacha.floorReward > 0) {
|
||
this.bigReward = this.percent[dicGacha.floorReward - 1];
|
||
}
|
||
if(!isGuide) this.setDicFloor();
|
||
// 玩家数据
|
||
this.player = new PlayerGachaRecord(userGacha, null);
|
||
}
|
||
|
||
private setDicFloor() {
|
||
let dicFloor = GACHA_TO_FLOOR.get(this.gachaType)||[];
|
||
for(let id of dicFloor) {
|
||
this.dicFloor.set(id, getDicGachaFloor(id));
|
||
}
|
||
}
|
||
|
||
// 新武将活动setter
|
||
public setByActivity(item: NewHeroGachaItem) {
|
||
this.percent = item.percent;
|
||
if (item.floorReward >= 0) {
|
||
this.bigReward = item.percent[item.floorReward]
|
||
}
|
||
this.dicFloor.set(GACHA_FLOOR_TYPE.ASSIGN, item.floorCount);
|
||
this.player = new PlayerGachaRecord(null, item);
|
||
}
|
||
|
||
|
||
public pull(count: number, userHeroes: HeroType[]) {
|
||
this.pullContent(count);
|
||
this.processFloors();
|
||
this.processDetail();
|
||
this.processHope();
|
||
let { heroInfo, items, resultList } = this.getFinalResult(userHeroes)
|
||
return { resultList, heroInfo, items };
|
||
}
|
||
|
||
// 根据基础的percent抽基地
|
||
private pullContent(count: number) {
|
||
for (let i = 0; i < count; i++) {
|
||
// 按照一般概率抽出
|
||
let { dic } = getRandEelmWithWeight(this.percent);
|
||
if(dic) this.result.addResult(dic.id, dic.goodId);
|
||
}
|
||
}
|
||
|
||
// 保底
|
||
private processFloors() {
|
||
for(let [id, floorCount] of this.dicFloor) {
|
||
switch(id) {
|
||
case GACHA_FLOOR_TYPE.PURPLE:
|
||
this.setPurpleFloor(floorCount);
|
||
break;
|
||
case GACHA_FLOOR_TYPE.GOLD:
|
||
this.setGoldFloor(floorCount);
|
||
break;
|
||
case GACHA_FLOOR_TYPE.ASSIGN:
|
||
this.setAssignFloor(floorCount);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 紫将保底，10连抽必出一个紫将
|
||
private setPurpleFloor(floorCount: number) {
|
||
if(this.result.shouldPurpleFloor(floorCount)) {
|
||
let item = this.result.getRandItemNotPurple();
|
||
item.setContentId(getGachaContentOfHeroQuality(HERO_QUALITY_TYPE.PURPLE));
|
||
}
|
||
}
|
||
|
||
// 元宝招募保底，金将保底，按次数给保底，抽到就重新计算次数，单抽也算
|
||
public setGoldFloor(dicFloorCount: number) {
|
||
let floorType = GACHA_FLOOR_TYPE.GOLD;
|
||
let { floorCount: historyCount } = this.player.getFloorCountByFloorType(floorType);
|
||
for(let gachaResult of this.result.list) {
|
||
let isTarget = this.bigReward.id == gachaResult.contentId;
|
||
if(++historyCount >= dicFloorCount || isTarget) {
|
||
gachaResult.setContentId(this.bigReward.id, this.bigReward.goodId);
|
||
historyCount = 0;
|
||
}
|
||
}
|
||
this.player.setFloorCount(floorType, historyCount, false);
|
||
}
|
||
|
||
// 求贤若渴，和活动抽卡金色保底，伪随机，n次内给且只给一个，单抽也算
|
||
public setAssignFloor(dicFloorCount: number) {
|
||
let floorType = GACHA_FLOOR_TYPE.ASSIGN;
|
||
let { floorCount: historyCount, hasGetFloor } = this.player.getFloorCountByFloorType(floorType);
|
||
for(let gachaResult of this.result.list) {
|
||
let isTarget = this.bigReward.id == gachaResult.contentId;
|
||
if(++historyCount >= dicFloorCount || isTarget) {
|
||
if(hasGetFloor) { // 已经获得过一次保底了, 不给，换个给
|
||
gachaResult.setContentId(getGachaContentOfHeroQuality(HERO_QUALITY_TYPE.PURPLE));
|
||
} else {
|
||
gachaResult.setContentId(this.bigReward.id, this.bigReward.goodId);
|
||
hasGetFloor = true;
|
||
}
|
||
}
|
||
if(historyCount >= dicFloorCount) {
|
||
hasGetFloor = false;
|
||
historyCount = 0;
|
||
}
|
||
}
|
||
this.player.setFloorCount(floorType, historyCount, hasGetFloor);
|
||
}
|
||
|
||
// 具体的卡池
|
||
private processDetail() {
|
||
for(let gachaResult of this.result.list) {
|
||
let detail = new ContentDetail(gachaResult.contentId, gachaResult.pickHero||this.player.pickHero);
|
||
let id = detail.getResult();
|
||
gachaResult.setHidOrGid(id, detail.count);
|
||
}
|
||
}
|
||
|
||
// 心愿单
|
||
private processHope() {
|
||
if(this.gachaType != GACHA_ID.NORMAL) return;
|
||
for(let gachaResult of this.result.list) {
|
||
if(gachaResult.contentId != getGachaContentOfHeroQuality(HERO_QUALITY_TYPE.GOLD)) continue; // 只有橙将
|
||
let { dic: { id: randHopePosition } } = getRandEelmWithWeight(gameData.gachaHope);
|
||
if(randHopePosition > 0) { // 按玩家设置的心愿单塞
|
||
let hopeHero = this.player.getHopeHero(randHopePosition)
|
||
if(hopeHero > 0) gachaResult.setHidOrGid(hopeHero);
|
||
}
|
||
this.player.setUserHope(gachaResult.hid); // 设置心愿单中了没有
|
||
}
|
||
}
|
||
|
||
// 创建信息
|
||
public getFinalResult(userHeroes: HeroType[]) {
|
||
return this.transferToFinalResult(this.result.list, userHeroes);
|
||
}
|
||
|
||
public pullBySimpleResult(simpleResult: {contentId: number, hid: number }[], userHeroes: HeroType[]) {
|
||
let results = simpleResult.map(obj => {
|
||
let gachaResult = new GachaResult(obj.contentId);
|
||
gachaResult.setHidOrGid(obj.hid);
|
||
return gachaResult;
|
||
});
|
||
|
||
return this.transferToFinalResult(results, userHeroes);
|
||
}
|
||
|
||
private transferToFinalResult(results: GachaResult[], userHeroes: HeroType[]) {
|
||
let hids = userHeroes.map(cur => cur.hid);
|
||
let items: RewardInter[] = [], heroInfo: CreateHeroParam[] = [];
|
||
|
||
for (let result of results) {
|
||
if (result.hid > 0) {
|
||
let hasHero = hids.indexOf(result.hid) != -1;
|
||
if (hasHero) { // 已有转换为碎片
|
||
let { pieceId, count } = transPiece(result.hid);
|
||
result.transferToPiece(pieceId, count);
|
||
items.push({ id: pieceId, count });
|
||
} else {
|
||
heroInfo.push({ hid: result.hid, count: 1 })//默认1个英雄
|
||
hids.push(result.hid);
|
||
}
|
||
} else {
|
||
items.push({ id: result.id, count: result.count });
|
||
}
|
||
}
|
||
return { items, heroInfo, resultList: results }
|
||
}
|
||
|
||
// 获得需要储存的数据
|
||
// 一般抽卡getter
|
||
public getUserGachaParam() {
|
||
return this.player.getUserGachaParam()
|
||
}
|
||
// 活动getter
|
||
public getActivityParam() {
|
||
let { hasGetFloor, floorCount } = this.player.getFloorCountByFloorType(GACHA_FLOOR_TYPE.ASSIGN);
|
||
return { hasGetFloor, floorCount };
|
||
}
|
||
}
|
||
|
||
class ContentDetail {
|
||
contentId: number;
|
||
type: number;
|
||
count: number;
|
||
param: number[];
|
||
pickHero: number;
|
||
|
||
constructor(contentId: number, pickHero: number) {
|
||
this.contentId = contentId;
|
||
let dicGachaContet = gameData.gachaContent.get(contentId);
|
||
this.type = dicGachaContet.type;
|
||
this.count = dicGachaContet.count;
|
||
this.param = dicGachaContet.param;
|
||
this.pickHero = pickHero;
|
||
}
|
||
|
||
public getResult() {
|
||
let { type } = gameData.gachaContent.get(this.contentId);
|
||
switch(type) {
|
||
case GACHA_CONTENT_TYPE.HERO:
|
||
return this.randomHeroByQuality(this.param[0]);
|
||
case GACHA_CONTENT_TYPE.HERO_PIECE:
|
||
return this.randomHeroPieceByQuality(this.param[0]);
|
||
case GACHA_CONTENT_TYPE.STONE:
|
||
return this.randomStoneByLv(this.param[0]);
|
||
case GACHA_CONTENT_TYPE.ITEMS:
|
||
return getRandSingleEelm(this.param);
|
||
default:
|
||
return 0
|
||
}
|
||
}
|
||
|
||
private randomHeroByQuality(quality: number) {
|
||
if(quality == 0) return this.pickHero;
|
||
|
||
let heroes = getAllHeroByQuality(quality);
|
||
return getRandSingleEelm(heroes);
|
||
}
|
||
|
||
|
||
private randomHeroPieceByQuality(quality: number) {
|
||
let pieces = getAllItemByQuality(IT_TYPE.HERO_PIECE, quality);
|
||
return getRandSingleEelm(pieces);
|
||
}
|
||
|
||
|
||
private randomStoneByLv(lv: number) {
|
||
let stones = getAllStoneByLv(lv);
|
||
return getRandSingleEelm(stones);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
/**
|
||
* 根据品质获得武将池
|
||
* @param quality 品质
|
||
*/
|
||
export function getAllHeroByQuality(quality: number) {
|
||
let allHero: number[] = [];
|
||
let allQuality: number[] = [];
|
||
for (let { actorId } of gameData.recruit) {
|
||
let dicHero = gameData.hero.get(actorId);
|
||
if (dicHero.quality == quality) {
|
||
allHero.push(actorId);
|
||
}
|
||
if (allQuality.indexOf(dicHero.quality) == -1) allQuality.push(dicHero.quality);
|
||
}
|
||
allQuality.sort((a, b) => a - b);
|
||
if (allQuality.length == 0) return [];
|
||
if (allHero.length == 0) {
|
||
allHero = getAllHeroByQuality(allQuality[0]);
|
||
}
|
||
return allHero;
|
||
}
|
||
|
||
export function getAllItemByQuality(itid: number, quality: number) {
|
||
let allPiece: number[] = [];
|
||
for (let [id, dicGoods] of gameData.goods) {
|
||
if (dicGoods.itid == itid) {
|
||
if (quality == 0 || dicGoods.quality == quality) {
|
||
allPiece.push(id);
|
||
}
|
||
}
|
||
}
|
||
return allPiece;
|
||
}
|
||
|
||
export function getAllStoneByLv(lv: number) {
|
||
let items: number[] = [];
|
||
for(let [id, dicStone] of gameData.stone) {
|
||
if(dicStone.lv == lv) items.push(id);
|
||
}
|
||
return items;
|
||
}
|