1089 lines
26 KiB
Go
1089 lines
26 KiB
Go
package playroom
|
|
|
|
import (
|
|
"fmt"
|
|
"server/GoUtil"
|
|
limitedTimeEventCfg "server/conf/limitedTimeEvent"
|
|
playroomCfg "server/conf/playroom"
|
|
"server/game/mod/item"
|
|
"server/game/mod/quest"
|
|
"server/msg"
|
|
"sort"
|
|
)
|
|
|
|
type PlayroomMod struct {
|
|
Collect map[int]int // 装饰
|
|
NewCollect map[int]*CollectInfo
|
|
Room map[int]int // 房间
|
|
Dress map[int][]int // 服装仓库
|
|
NewDress map[int]*DressInfo
|
|
DressSet map[int]int // 服装穿戴
|
|
PetAir []int // 宠物空气背包
|
|
NewPetAir map[int]*PetAirInfo // 新宠物空气背包
|
|
PetAirSet int // 宠物空气背包穿戴
|
|
Status int // 0: 未拜访 1: 拜访
|
|
Endtime int64 // 结束时间
|
|
Starttime int64 // 开始时间
|
|
WorkStatus int // 0: 未开始 1: 进行中 2: 结束
|
|
Visitor map[int]*Info // 访客
|
|
MoodInfo map[int]*Mood // 心情
|
|
AllMood int // 总心情
|
|
Reward []*item.Item // 奖励
|
|
DayFirstT int // 每日未首次触发次数
|
|
Trigger int // 未触发次数
|
|
TriggerTime int64 // 触发时间
|
|
HasVisit map[int]int64 // 今日已拜访的玩家
|
|
Target int // 拜访的目标
|
|
GameId int // 游戏ID
|
|
GameReward map[int]*item.Item // 游戏奖励
|
|
GameStatus int // 游戏状态
|
|
GameInfo map[int]interface{} // 游戏信息
|
|
Exclude bool // 是否排除
|
|
LoseItem []*item.Item // 失去的物品
|
|
ChipList []*ChipInfo // 碎片列表
|
|
Flip map[int]int // 翻牌
|
|
FlipReward []*item.Item // 翻牌奖励
|
|
WorkOutline int // 是否离线
|
|
LastFlip int // 上次翻牌奖励档次
|
|
NoFlip int // 连续未获取最高翻牌奖励次数
|
|
TodayFlip bool // 今日是否已获得最高档奖励
|
|
JackpotNum int // 每日转盘数量
|
|
Upvote int // 收到点赞次数
|
|
UpvoteList []int // 点赞列表
|
|
RoomPoint int // 房间点数
|
|
UnlockList map[int]int64 // 解锁
|
|
DailyTask map[int]*DailyTask // 每日任务
|
|
DailyTaskReward []int // 每日任务奖励
|
|
Physiology map[int]*Physiology
|
|
InteractNum int // 互动次数
|
|
RevengeUid int64 // 复仇Uid
|
|
FilterVisitor bool // 是否过滤访客
|
|
TodayVisitedUsers []int // 今日已拜访过的用户
|
|
ADItem map[int]*ItemInfo
|
|
}
|
|
|
|
type DressInfo struct {
|
|
Id int // 服装ID
|
|
Part int // 服装部位
|
|
AddTime int64 // 添加时间
|
|
EndTime int64 // 结束时间
|
|
Label string // 标签
|
|
Num int // 数量
|
|
}
|
|
|
|
type PetAirInfo struct {
|
|
Id int // 空气ID
|
|
Part int // 空气部位
|
|
AddTime int64 // 添加时间
|
|
EndTime int64 // 结束时间
|
|
Label string // 标签
|
|
Num int // 数量
|
|
}
|
|
|
|
type CollectInfo struct {
|
|
Id int // 空气ID
|
|
Part int // 空气部位
|
|
AddTime int64 // 添加时间
|
|
EndTime int64 // 结束时间
|
|
Label string // 标签
|
|
Num int // 数量
|
|
}
|
|
|
|
type ItemInfo struct {
|
|
Watch int // 观看次数
|
|
LastTime int64 // 上次观看时间
|
|
}
|
|
|
|
type DailyTask struct {
|
|
Items []*item.Item
|
|
Status int
|
|
Quest quest.QuestProgress
|
|
UnLock bool
|
|
Index int
|
|
}
|
|
|
|
const (
|
|
STATUS_IDLE = 0 // 未开始
|
|
STATUS_VISIT = 1 // 拜访
|
|
|
|
MOOD_TYPE_ENTER = 1 // 娱乐
|
|
MOOD_TYPE_CLEAN = 2 // 清洁
|
|
MOOD_TYPE_FOOD = 3 // 食物
|
|
|
|
GAME_RESULT_LOSE = 0 // 输
|
|
GAME_RESULT_LOW = 1 // 低
|
|
GAME_RESULT_MIDDLE = 2 // 中
|
|
GAME_RESULT_HIGH = 3 // 高
|
|
|
|
FLIP_TYPE_COPPER = 1 // 铜
|
|
FLIP_TYPE_SILVER = 2 // 银
|
|
FLIP_TYPE_GOLD = 3 // 金
|
|
|
|
PHYSIOLOGY_TYPE_STROKE = 1 // 抚摸
|
|
PHYSIOLOGY_TYPE_PLAY = 2 // 玩耍
|
|
PHYSIOLOGY_TYPE_FEED = 3 // 进食
|
|
PHYSIOLOGY_TYPE_CLEAN = 4 // 清洁
|
|
PHYSIOLOGY_TYPE_TOLIET = 5 // 上厕所
|
|
|
|
GAME_TYPE_HOOK = 1 // 愿者上钩
|
|
GAME_TYPE_FILP = 2 // 翻牌
|
|
GAME_TYPE_HIDE = 3 // 捉迷藏
|
|
|
|
DAILY_TASK_TYPE_ONE = 1 // 一阶段任务
|
|
DAILY_TASK_TYPE_TWO = 2 // 二阶段任务
|
|
|
|
ROOM_POINT_UNLOCK_LV = 6 // 房间点数解锁等级
|
|
)
|
|
|
|
type ChipInfo struct {
|
|
Uid int
|
|
Time int64
|
|
Emoji int
|
|
}
|
|
|
|
type Mood struct {
|
|
Id int
|
|
Num int
|
|
Time int64
|
|
}
|
|
|
|
type Physiology struct {
|
|
Id int
|
|
Num int
|
|
Time int64
|
|
}
|
|
|
|
type Info struct {
|
|
Time int64
|
|
Times int
|
|
}
|
|
|
|
func (p *PlayroomMod) InitData() {
|
|
if p.Collect == nil {
|
|
p.Collect = make(map[int]int)
|
|
}
|
|
if p.Dress == nil {
|
|
p.Dress = make(map[int][]int)
|
|
}
|
|
if p.DressSet == nil {
|
|
p.DressSet = make(map[int]int)
|
|
}
|
|
if p.GameInfo == nil {
|
|
p.GameInfo = make(map[int]interface{})
|
|
}
|
|
if p.NewCollect == nil {
|
|
p.NewCollect = make(map[int]*CollectInfo)
|
|
}
|
|
InitCollect := playroomCfg.GetInitDecorate()
|
|
if len(p.NewCollect) == 0 {
|
|
for _, v := range InitCollect {
|
|
p.NewCollect[v] = &CollectInfo{
|
|
Id: v,
|
|
AddTime: GoUtil.Now(),
|
|
EndTime: 0,
|
|
Num: 1,
|
|
}
|
|
}
|
|
}
|
|
if len(p.Collect) > 0 {
|
|
for k, v := range p.Collect {
|
|
p.NewCollect[k] = &CollectInfo{
|
|
Id: k,
|
|
AddTime: GoUtil.Now(),
|
|
EndTime: 0,
|
|
Num: v,
|
|
}
|
|
}
|
|
p.Collect = make(map[int]int)
|
|
}
|
|
for _, v := range InitCollect {
|
|
p.Collect[v] = 1
|
|
}
|
|
if p.Room == nil {
|
|
p.Room = make(map[int]int)
|
|
p.JackpotNum = playroomCfg.GetJackpotNum()
|
|
}
|
|
if p.Visitor == nil {
|
|
p.Visitor = make(map[int]*Info)
|
|
}
|
|
if p.MoodInfo == nil {
|
|
p.MoodInfo = make(map[int]*Mood)
|
|
}
|
|
if p.Physiology == nil {
|
|
p.Physiology = make(map[int]*Physiology)
|
|
}
|
|
if p.Reward == nil {
|
|
p.Reward = make([]*item.Item, 0)
|
|
}
|
|
if p.HasVisit == nil {
|
|
p.HasVisit = make(map[int]int64)
|
|
}
|
|
if p.GameReward == nil {
|
|
p.GameReward = make(map[int]*item.Item)
|
|
}
|
|
if p.LoseItem == nil {
|
|
p.LoseItem = make([]*item.Item, 0)
|
|
}
|
|
if p.Flip == nil {
|
|
p.Flip = make(map[int]int)
|
|
}
|
|
if p.UnlockList == nil {
|
|
p.UnlockList = make(map[int]int64)
|
|
}
|
|
if p.DailyTask == nil {
|
|
p.DailyTask = make(map[int]*DailyTask)
|
|
}
|
|
if len(p.NewPetAir) == 0 {
|
|
p.NewPetAir = make(map[int]*PetAirInfo, 0)
|
|
InitPetAir := playroomCfg.GetInitAirList()
|
|
for _, v := range InitPetAir {
|
|
p.NewPetAir[v] = &PetAirInfo{
|
|
Id: v,
|
|
AddTime: GoUtil.Now(),
|
|
Num: 1,
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(p.PetAir) > 0 {
|
|
for _, v := range p.PetAir {
|
|
p.NewPetAir[v] = &PetAirInfo{
|
|
Id: v,
|
|
AddTime: GoUtil.Now(),
|
|
Num: 1,
|
|
}
|
|
}
|
|
p.PetAir = make([]int, 0)
|
|
}
|
|
if p.NewDress == nil {
|
|
p.NewDress = make(map[int]*DressInfo)
|
|
}
|
|
if len(p.NewDress) == 0 {
|
|
InitDressList := playroomCfg.GetInitDressList()
|
|
for _, v := range InitDressList {
|
|
Part := playroomCfg.GetDressPart(v)
|
|
p.NewDress[v] = &DressInfo{
|
|
Id: v,
|
|
Part: Part,
|
|
AddTime: GoUtil.Now(),
|
|
EndTime: 0,
|
|
Label: "",
|
|
Num: 1,
|
|
}
|
|
}
|
|
}
|
|
// Dress仓库重构
|
|
if len(p.Dress) != 0 {
|
|
for _, v := range p.Dress {
|
|
for _, id := range v {
|
|
Part := playroomCfg.GetDressPart(id)
|
|
p.NewDress[id] = &DressInfo{
|
|
Id: id,
|
|
Part: Part,
|
|
AddTime: GoUtil.Now(),
|
|
EndTime: 0,
|
|
Label: "",
|
|
Num: 1,
|
|
}
|
|
}
|
|
}
|
|
p.Dress = make(map[int][]int)
|
|
}
|
|
if p.ADItem == nil {
|
|
p.ADItem = make(map[int]*ItemInfo)
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) ZeroUpdate() {
|
|
p.TodayFlip = false
|
|
p.LastFlip = 0
|
|
p.JackpotNum = playroomCfg.GetJackpotNum()
|
|
p.UpvoteList = make([]int, 0)
|
|
p.DailyTaskReward = make([]int, 0)
|
|
p.TodayVisitedUsers = make([]int, 0)
|
|
p.ADItem = make(map[int]*ItemInfo)
|
|
p.InitDailyTask()
|
|
}
|
|
|
|
func (p *PlayroomMod) InitDailyTask() {
|
|
p.DailyTask = make(map[int]*DailyTask)
|
|
Index := 1
|
|
TaskList1 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_ONE)
|
|
for k, v := range TaskList1 {
|
|
Items := playroomCfg.GetDailyTaskReward(Index)
|
|
Quest, _ := quest.ParseQuest(v)
|
|
p.DailyTask[k] = &DailyTask{
|
|
Items: Items,
|
|
Status: 0,
|
|
Quest: Quest,
|
|
UnLock: true,
|
|
Index: Index,
|
|
}
|
|
Index++
|
|
}
|
|
TaskList2 := playroomCfg.GetDailyTask(DAILY_TASK_TYPE_TWO)
|
|
for k, v := range TaskList2 {
|
|
Items := playroomCfg.GetDailyTaskReward(Index)
|
|
Quest, _ := quest.ParseQuest(v)
|
|
p.DailyTask[k] = &DailyTask{
|
|
Items: Items,
|
|
Status: 0,
|
|
Quest: Quest,
|
|
UnLock: false,
|
|
Index: Index,
|
|
}
|
|
Index++
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) QuestTrigger(Tr *quest.Trigger) bool {
|
|
update := false
|
|
unlock := true
|
|
for k, v := range p.DailyTask {
|
|
if !v.UnLock {
|
|
continue
|
|
}
|
|
if v.Status != quest.QUEST_STATUS_UNFINISH {
|
|
continue
|
|
}
|
|
up := quest.TriggerQuestProgress(&v.Quest, Tr)
|
|
if up {
|
|
update = true
|
|
}
|
|
|
|
if v.Quest.Status {
|
|
v.Status = quest.QUEST_STATUS_FINISH
|
|
|
|
}
|
|
Type := playroomCfg.GetDailyTaskType(k)
|
|
if Type == DAILY_TASK_TYPE_ONE && v.Status == quest.QUEST_STATUS_UNFINISH {
|
|
unlock = false
|
|
}
|
|
}
|
|
if unlock {
|
|
for _, v := range p.DailyTask {
|
|
v.UnLock = true
|
|
}
|
|
}
|
|
return update
|
|
}
|
|
|
|
func (p *PlayroomMod) DailyTaskCanReward(Id int) bool {
|
|
IdList := playroomCfg.GetDailyTaskListById(Id)
|
|
for _, v := range IdList {
|
|
v, ok := p.DailyTask[v]
|
|
if !ok {
|
|
return false
|
|
}
|
|
if v.Status != quest.QUEST_STATUS_FINISH {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (p *PlayroomMod) GetDailyTaskReward(Id int) ([]*item.Item, error) {
|
|
v, ok := p.DailyTask[Id]
|
|
if !ok {
|
|
return nil, fmt.Errorf("GetDailyTaskReward Id is not ok")
|
|
}
|
|
if v.Status != quest.QUEST_STATUS_FINISH {
|
|
return nil, fmt.Errorf("GetDailyTaskReward Status is not finish")
|
|
}
|
|
v.Status = quest.QUEST_STATUS_REWARD
|
|
p.DailyTask[Id] = v
|
|
return v.Items, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) GetVisitor() map[int]*Info {
|
|
return p.Visitor
|
|
}
|
|
|
|
func (p *PlayroomMod) GetTarget() int {
|
|
return p.Target
|
|
}
|
|
|
|
func (p *PlayroomMod) GetHasVisit() map[int]int64 {
|
|
return p.HasVisit
|
|
}
|
|
|
|
func (p *PlayroomMod) GetTodayVisitedUsers() []int {
|
|
return p.TodayVisitedUsers
|
|
}
|
|
|
|
func (p *PlayroomMod) GetMood() map[int]int {
|
|
Mood := make(map[int]int)
|
|
for k, v := range p.MoodInfo {
|
|
Mood[k] = v.Num
|
|
}
|
|
return Mood
|
|
}
|
|
|
|
func (p *PlayroomMod) GetPhysiologyList() map[int]int {
|
|
Physiology := make(map[int]int)
|
|
for k, v := range p.Physiology {
|
|
Physiology[k] = v.Num
|
|
}
|
|
return Physiology
|
|
}
|
|
|
|
func (p *PlayroomMod) GetMoodInfo(Id int) *Mood {
|
|
return p.MoodInfo[Id]
|
|
}
|
|
|
|
func (p *PlayroomMod) GetPhysiology(Id int) *Physiology {
|
|
return p.Physiology[Id]
|
|
}
|
|
|
|
func (p *PlayroomMod) GetCollect() map[int]*CollectInfo {
|
|
return p.NewCollect
|
|
}
|
|
|
|
func (p *PlayroomMod) GetRoom() map[int]int {
|
|
return p.Room
|
|
}
|
|
|
|
func (p *PlayroomMod) GetStatus() int {
|
|
return p.Status
|
|
}
|
|
|
|
func (p *PlayroomMod) GetChip() int {
|
|
return len(p.ChipList)
|
|
}
|
|
|
|
func (p *PlayroomMod) AddChip(Uid int, Time int64, Emoji int) {
|
|
if len(p.ChipList) >= playroomCfg.GetChipNum() {
|
|
return
|
|
}
|
|
p.ChipList = append(p.ChipList, &ChipInfo{Uid: Uid, Time: Time, Emoji: Emoji})
|
|
p.RevengeUid = int64(Uid)
|
|
}
|
|
|
|
func (p *PlayroomMod) SetTarget(Target int) {
|
|
p.Target = Target
|
|
p.Status = 1
|
|
p.HasVisit[Target] = GoUtil.Now()
|
|
}
|
|
|
|
func (p *PlayroomMod) SetGameId(GameId int) {
|
|
// if (p.GameId == GAME_TYPE_HOOK || p.GameId == GAME_TYPE_HIDE) && GameId == GAME_TYPE_HOOK {
|
|
// return
|
|
// }
|
|
p.GameId = GameId
|
|
}
|
|
|
|
func (p *PlayroomMod) CreateOrderReward(Star int, itemMod *item.ItemMod) {
|
|
if Star == 0 {
|
|
return
|
|
}
|
|
p.Reward = make([]*item.Item, 0)
|
|
FoodItem := playroomCfg.GetFoodItem()
|
|
CleanItem := playroomCfg.GetCleanItem()
|
|
ToyItem := playroomCfg.GetToyItem()
|
|
DailyItem := playroomCfg.GetDailyItem()
|
|
|
|
FoodItemNum := itemMod.GetItemNumByList(FoodItem)
|
|
CleanItemNum := itemMod.GetItemNumByList(CleanItem)
|
|
ToyItemNum := itemMod.GetItemNumByList(ToyItem)
|
|
DailyItemNum := itemMod.GetItemNumByList(DailyItem)
|
|
type d struct {
|
|
Id []int
|
|
Num int
|
|
}
|
|
sortList := make([]d, 0)
|
|
sortList = append(sortList, d{Id: FoodItem, Num: FoodItemNum})
|
|
sortList = append(sortList, d{Id: CleanItem, Num: CleanItemNum})
|
|
sortList = append(sortList, d{Id: ToyItem, Num: ToyItemNum})
|
|
sortList = append(sortList, d{Id: DailyItem, Num: DailyItemNum})
|
|
sort.Slice(sortList, func(i, j int) bool {
|
|
return sortList[i].Num < sortList[j].Num
|
|
})
|
|
|
|
Prob := GoUtil.RandSlice(sortList[0].Id)
|
|
p.Reward = append(p.Reward, &item.Item{Id: Prob, Num: 1})
|
|
}
|
|
|
|
func (p *PlayroomMod) GetReward() []*item.Item {
|
|
return p.Reward
|
|
}
|
|
|
|
func (p *PlayroomMod) Interact(Id, Type int) ([]*item.Item, int, error) {
|
|
MoodType, ItemList, Effect := playroomCfg.GetInteract(Id, Type)
|
|
if MoodType == 0 {
|
|
return nil, 0, fmt.Errorf("Interact MoodType is 0")
|
|
}
|
|
if Effect > 0 {
|
|
p.AllMood = min(100, p.AllMood+10)
|
|
}
|
|
PType, PEffect := playroomCfg.GetInteractPhysiology(Id)
|
|
p.AddPhysiology(PType, PEffect)
|
|
p.AddMood(MoodType, Effect)
|
|
p.AddInteractNum()
|
|
return ItemList, PType, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) AddInteractNum() {
|
|
p.InteractNum++
|
|
p.InteractNum = min(p.InteractNum, playroomCfg.GetInteractNum())
|
|
}
|
|
|
|
func (p *PlayroomMod) AddMood(Id, Num int) {
|
|
_, ok := p.MoodInfo[Id]
|
|
if !ok {
|
|
p.MoodInfo[Id] = &Mood{Id: Id, Num: 0}
|
|
}
|
|
p.MoodInfo[Id].Num = max(0, min(p.MoodInfo[Id].Num+Num, 100))
|
|
if p.MoodInfo[Id].Num != 0 && p.MoodInfo[Id].Time == 0 {
|
|
p.MoodInfo[Id].Time = GoUtil.Now()
|
|
}
|
|
if p.MoodInfo[Id].Num == 0 {
|
|
p.MoodInfo[Id].Time = 0
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) GetMoodNum(MoodType int) int {
|
|
Mood, ok := p.MoodInfo[MoodType]
|
|
if !ok {
|
|
return 0
|
|
}
|
|
return Mood.Num
|
|
}
|
|
|
|
func (p *PlayroomMod) AddPhysiology(Id, Num int) {
|
|
Phy := p.GetPhysiology(Id)
|
|
if Phy == nil {
|
|
Phy = &Physiology{Id: Id, Num: 0, Time: 0}
|
|
}
|
|
Max := playroomCfg.GetPhysiologyMax(Id)
|
|
Phy.Num = max(0, min(Phy.Num+Num, Max))
|
|
Phy.Time = GoUtil.Now()
|
|
if Phy.Num == 0 {
|
|
Phy.Time = 0
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) AddVisitor(Id int, Time int64) {
|
|
v, ok := p.Visitor[Id]
|
|
if !ok {
|
|
p.Visitor[Id] = &Info{Time: Time, Times: 1}
|
|
return
|
|
}
|
|
v.Times++
|
|
v.Time = Time
|
|
}
|
|
|
|
func (p *PlayroomMod) SetRoom(Room map[int]int) (map[int]int, error) {
|
|
diff := GoUtil.DiffMap(p.Room, Room)
|
|
p.Room = Room
|
|
return diff, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) AddCollect(Id int) {
|
|
p.NewCollect[Id] = &CollectInfo{
|
|
Id: Id,
|
|
AddTime: GoUtil.Now(),
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) AddDress(Id int) {
|
|
Part := playroomCfg.GetDressPart(Id)
|
|
if _, ok := p.NewDress[Id]; !ok {
|
|
p.NewDress[Id] = &DressInfo{
|
|
Id: Id,
|
|
Part: Part,
|
|
AddTime: GoUtil.Now(),
|
|
EndTime: 0,
|
|
Label: "",
|
|
Num: 1,
|
|
}
|
|
} else {
|
|
p.NewDress[Id].Num++
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) ResetGame() {
|
|
p.TodayVisitedUsers = append(p.TodayVisitedUsers, p.Target)
|
|
p.Target = 0
|
|
p.Status = STATUS_IDLE
|
|
p.GameId = 0
|
|
p.GameReward = make(map[int]*item.Item)
|
|
p.InteractNum = 0
|
|
p.RevengeUid = 0
|
|
}
|
|
func (p *PlayroomMod) GetGameId() int {
|
|
return p.GameId
|
|
}
|
|
|
|
func (p *PlayroomMod) ResetLose() {
|
|
p.LoseItem = make([]*item.Item, 0)
|
|
}
|
|
|
|
func (p *PlayroomMod) SetGameReward(Chess1, Chess2, Star int) {
|
|
p.GameReward[1] = &item.Item{Id: Chess1, Num: 1}
|
|
p.GameReward[2] = &item.Item{Id: Chess2, Num: 1}
|
|
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: Star}
|
|
}
|
|
|
|
func (p *PlayroomMod) SetGameRewardFlip(N1, N2, N3 int) {
|
|
p.GameReward[1] = &item.Item{Id: item.ITEM_STAR_ID, Num: N1}
|
|
p.GameReward[2] = &item.Item{Id: item.ITEM_STAR_ID, Num: N2}
|
|
p.GameReward[3] = &item.Item{Id: item.ITEM_STAR_ID, Num: N3}
|
|
}
|
|
|
|
func (p *PlayroomMod) SelectReward(Id int) []*item.Item {
|
|
v, ok := p.GameReward[Id]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
Items := make([]*item.Item, 0)
|
|
Items = append(Items, v)
|
|
if Id < 3 {
|
|
Items = append(Items, item.NewItem(item.ITEM_STAR_ID, 5))
|
|
}
|
|
return Items
|
|
}
|
|
|
|
func (p *PlayroomMod) Lose(Item []*item.Item) {
|
|
p.LoseItem = append(p.LoseItem, Item...)
|
|
}
|
|
|
|
func (p *PlayroomMod) Work() ([]*item.Item, error) {
|
|
if p.Endtime > GoUtil.Now() {
|
|
p.WorkStatus = 1
|
|
return nil, nil
|
|
}
|
|
p.Starttime = GoUtil.Now()
|
|
p.Endtime = GoUtil.Now() + 86400
|
|
p.WorkStatus = 1
|
|
ItemId := playroomCfg.GetWorkItem()
|
|
return []*item.Item{item.NewItem(ItemId, 1)}, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) Rest() {
|
|
p.WorkStatus = 2
|
|
}
|
|
|
|
func (p *PlayroomMod) SetWorkOutline(Status int) {
|
|
p.WorkOutline = Status
|
|
}
|
|
|
|
func (p *PlayroomMod) ResetWork() {
|
|
p.WorkStatus = 0
|
|
p.Endtime = 0
|
|
}
|
|
|
|
func (p *PlayroomMod) Outline() {
|
|
p.WorkOutline = 1
|
|
}
|
|
|
|
func (p *PlayroomMod) GetVisitorInfo(Id int) (int, int64) {
|
|
v, ok := p.Visitor[Id]
|
|
if !ok {
|
|
return 0, 0
|
|
}
|
|
return v.Times, v.Time
|
|
}
|
|
|
|
func (p *PlayroomMod) GetTaskReward(Type int) (int, []*item.Item, error) {
|
|
if GoUtil.InArray(Type, p.DailyTaskReward) {
|
|
return 0, nil, fmt.Errorf("GetTaskReward Type is already in DailyTaskReward")
|
|
}
|
|
p.DailyTaskReward = append(p.DailyTaskReward, Type)
|
|
Id := 0
|
|
var Items []*item.Item
|
|
if Type == DAILY_TASK_TYPE_TWO {
|
|
ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
|
|
Id = GoUtil.RandMap(ProbList)
|
|
Items = limitedTimeEventCfg.GetSenceJackpotReward(Id)
|
|
} else {
|
|
ProbList := playroomCfg.GetTaskJackpotProb()
|
|
Id = GoUtil.RandMap(ProbList)
|
|
Items = playroomCfg.GetTaskJackpotReward(Id)
|
|
}
|
|
if len(Items) > 1 {
|
|
// 多个奖励时，随机选择一个
|
|
Items = []*item.Item{GoUtil.RandItem(Items)}
|
|
}
|
|
return Id, Items, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) Draw() (int, []*item.Item, error) {
|
|
// if p.AllMood < 100 {
|
|
// return 0, nil, fmt.Errorf("Draw AllMood < 100")
|
|
// }
|
|
if p.JackpotNum == 0 {
|
|
return 0, nil, fmt.Errorf("Draw JackpotNum is 0")
|
|
}
|
|
p.JackpotNum--
|
|
p.AllMood = 0
|
|
ProbList := limitedTimeEventCfg.GetSenceJackpotProb()
|
|
Id := GoUtil.RandMap(ProbList)
|
|
Items := limitedTimeEventCfg.GetSenceJackpotReward(Id)
|
|
if len(Items) > 1 {
|
|
// 多个奖励时，随机选择一个
|
|
Items = []*item.Item{GoUtil.RandItem(Items)}
|
|
}
|
|
return Id, Items, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) NotifyWork() *msg.NotifyPlayroomWork {
|
|
return &msg.NotifyPlayroomWork{
|
|
WorkStatus: int32(p.WorkStatus),
|
|
StartTime: int32(p.Starttime),
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) NotifyLose() *msg.NotifyPlayroomLose {
|
|
ChipMessage := make([]*msg.ChipInfo, 0)
|
|
for _, v := range p.ChipList {
|
|
ChipMessage = append(ChipMessage, &msg.ChipInfo{
|
|
Uid: int64(v.Uid),
|
|
})
|
|
}
|
|
return &msg.NotifyPlayroomLose{
|
|
LoseItem: item.ItemToMsg(p.LoseItem),
|
|
Chip: ChipMessage,
|
|
Revenge: p.RevengeUid,
|
|
}
|
|
}
|
|
func (p *PlayroomMod) ResetPhysiology(MoodType int) {
|
|
PhysiologyList := playroomCfg.GetPhysiologyList(MoodType)
|
|
for _, v := range PhysiologyList {
|
|
Phy := p.GetPhysiology(v)
|
|
if Phy != nil {
|
|
Phy.Num = 0
|
|
Phy.Time = 0
|
|
}
|
|
}
|
|
}
|
|
func (p *PlayroomMod) NotifyStatus() *msg.NofiPlayroomStatus {
|
|
return &msg.NofiPlayroomStatus{
|
|
WorkOutline: int32(p.WorkOutline),
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) NotifyMood() *msg.NotifyPlayroomMood {
|
|
Mood := make(map[int32]int32, 0)
|
|
for k, v := range p.MoodInfo {
|
|
Mood[int32(k)] = int32(v.Num)
|
|
}
|
|
resAdItems := make([]*msg.AdItem, 0)
|
|
for k, v := range p.ADItem {
|
|
resAdItems = append(resAdItems, &msg.AdItem{
|
|
ItemId: int32(k),
|
|
Watch: int32(v.Watch),
|
|
LastWatch: int32(v.LastTime),
|
|
})
|
|
}
|
|
return &msg.NotifyPlayroomMood{
|
|
AllMood: int32(p.AllMood),
|
|
Mood: Mood,
|
|
Physiology: GoUtil.MapIntToInt32(p.GetPhysiologyList()),
|
|
AdItem: resAdItems,
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) Fire(ChargeId int) []*item.Item {
|
|
WorkChargeId := playroomCfg.GetWorkChargeId()
|
|
if ChargeId == WorkChargeId {
|
|
ItemId := playroomCfg.GetWorkItem()
|
|
return []*item.Item{item.NewItem(ItemId, 1)}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *PlayroomMod) RemoveChip(Uids []int64) ([]*item.Item, int, error) {
|
|
len1 := len(p.ChipList)
|
|
len2 := len(Uids)
|
|
if len1 == 0 {
|
|
return nil, 0, fmt.Errorf("RemoveChip Uids is 0")
|
|
}
|
|
if len1 == len2 {
|
|
p.ChipList = make([]*ChipInfo, 0)
|
|
} else {
|
|
uidCount := make(map[int64]int)
|
|
for _, uid := range Uids {
|
|
uidCount[uid]++
|
|
}
|
|
|
|
newChipList := make([]*ChipInfo, 0)
|
|
for _, chip := range p.ChipList {
|
|
if uidCount[int64(chip.Uid)] > 0 {
|
|
uidCount[int64(chip.Uid)]--
|
|
} else {
|
|
newChipList = append(newChipList, chip)
|
|
}
|
|
}
|
|
p.ChipList = newChipList
|
|
}
|
|
return []*item.Item{item.NewItem(item.ITEM_STAR_ID, len2*25)}, len2, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) FlipCard(Pos int) (int, error) {
|
|
if p.Status != STATUS_VISIT {
|
|
return 0, fmt.Errorf("FlipCard Status is not STATUS_VISIT")
|
|
}
|
|
RandMap := map[int]int{
|
|
FLIP_TYPE_COPPER: 35,
|
|
FLIP_TYPE_SILVER: 45,
|
|
FLIP_TYPE_GOLD: 20,
|
|
}
|
|
Prob := GoUtil.RandMap(RandMap)
|
|
|
|
/**
|
|
若玩家同一天内上一次游玩猫猫小金库未能获得金币档位奖励，且当天还未获得过金币档位奖励
|
|
或玩家已连续三次未能获得金币档位奖励，则启用以下保底逻辑
|
|
玩家已翻出两个银币或铜币图案的情况下，后续翻牌必然为金币
|
|
*/
|
|
check := make(map[int]int)
|
|
for _, v := range p.Flip {
|
|
check[v]++
|
|
}
|
|
if check[FLIP_TYPE_COPPER] == 2 || check[FLIP_TYPE_SILVER] == 2 {
|
|
if p.LastFlip != FLIP_TYPE_GOLD && !p.TodayFlip {
|
|
Prob = FLIP_TYPE_GOLD
|
|
}
|
|
if p.NoFlip == 3 {
|
|
Prob = FLIP_TYPE_GOLD
|
|
}
|
|
}
|
|
p.Flip[Pos] = Prob
|
|
|
|
return Prob, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) GetFlipReward() ([]*item.Item, int, error) {
|
|
check := make(map[int]int)
|
|
Items := make([]*item.Item, 0)
|
|
T := p.Target
|
|
for _, v := range p.Flip {
|
|
check[v]++
|
|
if check[v] == 3 {
|
|
switch v {
|
|
case FLIP_TYPE_COPPER:
|
|
p.NoFlip++
|
|
Items = append(Items, p.GameReward[FLIP_TYPE_COPPER])
|
|
case FLIP_TYPE_SILVER:
|
|
p.NoFlip++
|
|
Items = append(Items, p.GameReward[FLIP_TYPE_SILVER])
|
|
case FLIP_TYPE_GOLD:
|
|
p.NoFlip = 0
|
|
p.TodayFlip = true
|
|
Items = append(Items, p.GameReward[FLIP_TYPE_GOLD])
|
|
}
|
|
p.LastFlip = v
|
|
p.Flip = make(map[int]int)
|
|
p.ResetGame()
|
|
return Items, T, nil
|
|
}
|
|
}
|
|
|
|
return Items, T, fmt.Errorf("GetFlipReward check is not 3")
|
|
}
|
|
|
|
func (p *PlayroomMod) BuyItem(Id int) ([]*item.Item, []*item.Item) {
|
|
return playroomCfg.GetBuyItem(Id)
|
|
|
|
}
|
|
|
|
func (p *PlayroomMod) UnLock(Lv int) bool {
|
|
UnlockLv := playroomCfg.GetUnLockLv()
|
|
if Lv < UnlockLv || len(p.Physiology) != 0 {
|
|
return false
|
|
}
|
|
if len(p.Physiology) == 0 {
|
|
Now := GoUtil.Now()
|
|
p.Physiology = make(map[int]*Physiology)
|
|
TypeList := playroomCfg.GetPhysiologyTypeList()
|
|
for _, v := range TypeList {
|
|
Max := playroomCfg.GetPhysiologyMax(v)
|
|
p.Physiology[v] = &Physiology{Id: v, Num: Max, Time: Now}
|
|
}
|
|
}
|
|
if len(p.MoodInfo) == 0 {
|
|
p.MoodInfo = make(map[int]*Mood)
|
|
for k := 1; k <= 3; k++ {
|
|
p.MoodInfo[k] = &Mood{Id: k, Num: 100}
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// shop
|
|
func (p *PlayroomMod) ShopBuy(Id, Num int) ([]*item.Item, []*item.Item, error) {
|
|
AddItemId, CostItem := playroomCfg.GetShopItem(Id)
|
|
if AddItemId == 0 {
|
|
return nil, nil, fmt.Errorf("ShopBuy AddItemId is 0")
|
|
}
|
|
NewCostItem := item.MutilItem(CostItem, Num)
|
|
return []*item.Item{item.NewItem(AddItemId, Num)}, NewCostItem, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) UnlockDress(Type, Id int) error {
|
|
p.NewDress[Id] = &DressInfo{
|
|
Id: Id,
|
|
Part: Type,
|
|
AddTime: GoUtil.Now(),
|
|
EndTime: 0,
|
|
Label: "",
|
|
Num: 1,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *PlayroomMod) RandGameType() int {
|
|
return GoUtil.RandMap(map[int]int{1: 50, 3: 50})
|
|
}
|
|
|
|
func (p *PlayroomMod) UnlockPetAir(Id int) {
|
|
p.NewPetAir[Id] = &PetAirInfo{
|
|
Id: Id,
|
|
AddTime: GoUtil.Now(),
|
|
Num: 1,
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) PlayroomDressSet(DressSet map[int]int) ([]int, map[int]int, error) {
|
|
// 判断服装是否存在
|
|
Part := make([]int, 0)
|
|
Diff := GoUtil.DiffMap(DressSet, p.DressSet)
|
|
for Type, Id := range DressSet {
|
|
if Id == 0 {
|
|
continue
|
|
}
|
|
dressInfo, ok := p.NewDress[Type]
|
|
if !ok {
|
|
return nil, nil, fmt.Errorf("dress type not found")
|
|
}
|
|
if dressInfo.EndTime < GoUtil.Now() && dressInfo.EndTime != 0 {
|
|
return nil, nil, fmt.Errorf("dress timeout")
|
|
}
|
|
if p.DressSet[Type] == 0 && Id != 0 {
|
|
Part = append(Part, Type)
|
|
}
|
|
}
|
|
p.DressSet = DressSet
|
|
return Part, Diff, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) GiveUpvote(Uid int) ([]*item.Item, error) {
|
|
if GoUtil.InArray(Uid, p.UpvoteList) {
|
|
return nil, fmt.Errorf("upvote already")
|
|
}
|
|
p.UpvoteList = append(p.UpvoteList, Uid)
|
|
return []*item.Item{item.NewItem(item.ITEM_ENERGY_ID, 5)}, nil
|
|
}
|
|
|
|
func (p *PlayroomMod) AddUpvote() {
|
|
p.Upvote++
|
|
}
|
|
|
|
func (p *PlayroomMod) PlayroomPetAirSet(Id int) error {
|
|
if _, ok := p.NewPetAir[Id]; !ok {
|
|
return fmt.Errorf("PlayroomPetAirSet Id is not ok")
|
|
}
|
|
p.PetAirSet = Id
|
|
return nil
|
|
}
|
|
|
|
func (p *PlayroomMod) Unlock(Id int) error {
|
|
Need := playroomCfg.GetUnlockNeed(Id)
|
|
if Need == 0 || Need > p.RoomPoint {
|
|
return fmt.Errorf("unlock need is 0 or need > RoomPoint")
|
|
}
|
|
p.UnlockList[Id] = GoUtil.Now()
|
|
return nil
|
|
}
|
|
|
|
func (p *PlayroomMod) GetUnlockIds() []int32 {
|
|
UnlockIds := make([]int32, 0)
|
|
for k := range p.UnlockList {
|
|
UnlockIds = append(UnlockIds, int32(k))
|
|
}
|
|
return UnlockIds
|
|
}
|
|
|
|
func (p *PlayroomMod) GetDressSet() map[int]int {
|
|
return p.DressSet
|
|
}
|
|
|
|
func (p *PlayroomMod) GetPetAirSet() int {
|
|
return p.PetAirSet
|
|
}
|
|
|
|
func (p *PlayroomMod) GetDress() map[int]*DressInfo {
|
|
return p.NewDress
|
|
}
|
|
|
|
func (p *PlayroomMod) GetPetAir() map[int]*PetAirInfo {
|
|
return p.NewPetAir
|
|
}
|
|
|
|
// RoomPoint Get Set
|
|
func (p *PlayroomMod) GetRoomPoint() int {
|
|
return p.RoomPoint
|
|
}
|
|
func (p *PlayroomMod) SetRoomPoint(Point int) {
|
|
p.RoomPoint = Point
|
|
}
|
|
func (p *PlayroomMod) AddRoomPointInvite(lv int) {
|
|
if lv < ROOM_POINT_UNLOCK_LV {
|
|
return
|
|
}
|
|
Point := playroomCfg.GetRoomPointInvite()
|
|
p.RoomPoint += Point
|
|
if p.RoomPoint < 0 {
|
|
p.RoomPoint = 0
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) AddRoomPointAdd(lv int) {
|
|
if lv < ROOM_POINT_UNLOCK_LV {
|
|
return
|
|
}
|
|
Point := playroomCfg.GetRoomPointAdd()
|
|
p.RoomPoint += Point
|
|
if p.RoomPoint < 0 {
|
|
p.RoomPoint = 0
|
|
}
|
|
}
|
|
|
|
func (p *PlayroomMod) BackDataTask() []*msg.DailyTask {
|
|
DailyTask := make([]*msg.DailyTask, 0)
|
|
for k, v := range p.DailyTask {
|
|
DailyTask = append(DailyTask, &msg.DailyTask{
|
|
Status: int32(v.Status),
|
|
UnLock: v.UnLock,
|
|
Progress: quest.QuestProgressToMsg(&v.Quest),
|
|
Items: item.ItemToMsg(v.Items),
|
|
Index: int32(v.Index),
|
|
Id: int32(k),
|
|
})
|
|
}
|
|
sort.Slice(DailyTask, func(i, j int) bool {
|
|
return DailyTask[i].Index < DailyTask[j].Index
|
|
})
|
|
return DailyTask
|
|
}
|
|
|
|
func (p *PlayroomMod) Guide(Type int) error {
|
|
if _, ok := p.Physiology[Type]; !ok {
|
|
return fmt.Errorf("Guide Type is not ok")
|
|
}
|
|
p.Physiology[Type].Num = 0
|
|
return nil
|
|
}
|
|
|
|
func (p *PlayroomMod) AdWatch(Id int) error {
|
|
if _, ok := p.ADItem[Id]; !ok {
|
|
p.ADItem[Id] = &ItemInfo{Watch: 0, LastTime: 0}
|
|
}
|
|
p.ADItem[Id].Watch++
|
|
p.ADItem[Id].LastTime = GoUtil.Now()
|
|
if p.ADItem[Id].Watch > playroomCfg.GetShopItemAdNum(Id) {
|
|
return fmt.Errorf("AdWatch Watch is over limit")
|
|
}
|
|
return nil
|
|
}
|