ktogame/controller/calculate.go

package controller

import (
	"fmt"
	"ktogame/models"
	"strings"

	"github.com/astaxie/beego/logs"

	"github.com/go-xorm/xorm"
)

func UpdateSuperiorsPerformance(engine *xorm.Session, superiorsStr string, amount float64) error {
	logs.Info("into UpdateSuperiorsPerformance:", superiorsStr, amount)
	ids := strings.Split(superiorsStr, ",")
	if len(ids) <= 0 {
		return nil
	}
	logs.Info("UpdateSuperiorsPerformance ids::::::", ids)
	var supers []models.UserInfo
	for _, sid := range ids {
		var tmpUser models.UserInfo
		ok, err := engine.Where("id = ?", sid).Get(&tmpUser)
		if err != nil {
			return err
		}
		if !ok {
			continue
		}
		supers = append(supers, tmpUser)
	}
	logs.Info("UpdateSuperiorsPerformance supers::::::%v", len(supers))
	if len(supers) == 0 {
		return nil
	}

	var rp models.RewardsPool
	_, err := engine.ID(1).Get(&rp)
	if err != nil {
		return err
	}

	for _, super := range supers {
		var per models.Performance
		ok, err := engine.ID(super.Addr).Get(&per)
		if err != nil {
			fmt.Println(err)
			continue
		}
		if !ok {
			logs.Info("%v not exist!", super.Addr)
			continue
		}

		per.TotalPerformance += amount
		if per.TotalPerformance >= float64(CommunityMarket) {
			var super models.Performance
			ok, err := engine.ID(per.Addr).Get(&super)
			if err != nil {
				fmt.Println(err)
				continue
			}
			if !ok {
				logs.Info("%v not exist!", per.Addr)
				continue
			}

			super.MarketNum = int(per.TotalPerformance / float64(CommunityMarket))
			logs.Debug("matket check=====,", per.Addr, per.TotalPerformance, CommunityMarket, super.MarketNum)
			_, err = engine.ID(super.Addr).Cols("market_num").Update(&super)
			if err != nil {
				fmt.Println(err)
				continue
			}
		}

		var level int = 0
		for i := 1; i < len(PerformanceLevel); i++ {
			if PerformanceLevel[i-1] <= per.TotalPerformance && per.TotalPerformance < PerformanceLevel[i] {
				level = i
				break
			}
		}
		logs.Debug("Performance check=====1,", per.Addr, rp.TeamPerformance, per.TotalPerformance, per.PerformanceRewards, level, per.PerformanceLevel)
		if level > 0 {
			if level > per.PerformanceLevel {
				ratio := PerformanceRatio[level] - PerformanceRatio[per.PerformanceLevel]
				rewards := amount * ratio
				if rp.TeamPerformance >= rewards {
					rp.TeamPerformance -= rewards     //pool sub rewards
					per.PerformanceRewards += rewards //user add rewards to PerformanceRewards
					per.PerformanceLevel = level
					//update available
					logs.Debug("Performance check=====2,", per.Addr, level, amount, ratio, rewards)

					err := UpdateAvailableRewards(engine, rewards, super.Addr, false, false)
					if err != nil {
						return err
					}
				}
			}
		}
		_, err = engine.ID(super.Addr).Cols("total_performance,performance_level,performance_rewards").Update(&per)
		if err != nil {
			return err
		}
		logs.Debug("Performance check=====3,", per.Addr, rp.TeamPerformance, per.TotalPerformance, per.PerformanceRewards, per.PerformanceLevel)

	}

	_, err = engine.ID(1).Cols("team_performance").Update(&rp)
	if err != nil {
		return err
	}
	logs.Info("UpdateSuperiorsPerformance end:", rp)
	return nil
}

func UpdateRewardsPool(engine *xorm.Session, amount float64) error {
	logs.Info("into UpdateRewardsPool:", amount)
	var rp models.RewardsPool
	_, err := engine.ID(1).Get(&rp)
	if err != nil {
		return err
	}

	rp.TeamPerformance += amount * 0.15
	rp.TeamCultivate += amount * 0.10
	rp.TotalPool += amount
	_, err = engine.ID(1).Update(&rp)
	if err != nil {
		return err
	}
	logs.Info("UpdateRewardsPool end:", rp)
	return nil
}

func UpdateAvailableRewards(engine *xorm.Session, rewards float64, uaddr string, join, isdirect bool) error {
	if rewards <= 0 {
		return nil
	}
	logs.Info("into UpdateAvailableRewards:", rewards, uaddr, join, isdirect)
	a_rewards := rewards * 60 / 100
	a_reinput := rewards * 40 / 100
	var user models.UserInfo
	ok, err := engine.ID(uaddr).Get(&user)
	if err != nil {
		return err
	}
	if !ok {
		logs.Info("%v not exist!", uaddr)
		return nil
	}
	user.AvailableClaim += a_rewards
	user.AvailableReinput += a_reinput
	if join {
		if isdirect {
			user.DirectNumber += 1
			user.DirectRewards += rewards
			logs.Info("check direct info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
			_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput,direct_number,direct_rewards").Update(&user)
			if err != nil {
				return err
			}
		} else {
			user.IndirectNumber += 1
			user.IndirectRewards += rewards
			logs.Info("check indirect info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
			_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput,indirect_number,indirect_rewards").Update(&user)
			if err != nil {
				return err
			}
		}
	} else {
		logs.Info("check else info=====:", user.AvailableClaim, user.AvailableReinput)
		_, err := engine.ID(user.Addr).Cols("available_claim,available_reinput").Update(&user)
		if err != nil {
			return err
		}
	}
	logs.Info("UpdateAvailableRewards end:", user)
	return nil
}

func UpdateCommunityGift(engine *xorm.Session, amount float64, uaddr string) error {
	logs.Info("into UpdateCommunityGift:", amount, uaddr)
	var user models.UserInfo
	ok, err := engine.ID(uaddr).Get(&user)
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}

	//front 10
	var leftNum int64
	if user.Id > 10 {
		leftNum = 10
	} else {
		leftNum = user.Id - 1
	}
	rewards := amount * (float64(leftNum) / 100)

	err = UpdateGift(engine, user.Addr, rewards)
	if err != nil {
		return err
	}

	//back 10
	var fronts []models.UserInfo
	if user.Id > 10 {
		err := engine.Where("id >= ? and id < ?", user.Id-10, user.Id).Find(&fronts)
		if err != nil {
			return err
		}
	} else {
		err := engine.Where("id >= ? and id < ?", 1, user.Id).Find(&fronts)
		if err != nil {
			return err
		}
	}
	if len(fronts) > 0 {
		backrewards := amount / 100
		for _, u := range fronts {
			err = UpdateGift(engine, u.Addr, backrewards)
			if err != nil {
				return err
			}
		}
	}

	//inviter front 10-25%
	if user.Direct != "" {
		var inviter models.UserInfo
		ok, err := engine.ID(user.Direct).Get(&inviter)
		if err != nil {
			return err
		}
		if !ok {
			return nil
		}
		var frontNum int64
		if inviter.DirectNumber == 1 {
			//front 10 - 15
			if inviter.Id <= 10 {
				frontNum = 0
			}
			if inviter.Id > 10 && inviter.Id <= 15 {
				frontNum = inviter.Id - 10
			}
			if inviter.Id > 15 {
				frontNum = 5
			}
		} else if inviter.DirectNumber == 2 {
			//front 16 - 20
			if inviter.Id <= 15 {
				frontNum = 0
			}
			if inviter.Id > 15 && inviter.Id <= 20 {
				frontNum = inviter.Id - 15
			}
			if inviter.Id > 20 {
				frontNum = 5
			}
		} else if inviter.DirectNumber == 3 {
			//front 21 - 25
			if inviter.Id <= 20 {
				frontNum = 0
			}
			if inviter.Id > 20 && inviter.Id <= 25 {
				frontNum = inviter.Id - 20
			}
			if inviter.Id > 25 {
				frontNum = 5
			}
		} else {
			frontNum = 0
		}

		frontrewards := amount * (float64(frontNum / 100))
		err = UpdateGift(engine, inviter.Addr, frontrewards)
		if err != nil {
			return err
		}
	}

	//back 10-25%,DirectNumber 1,2,3===============
	var frontUsers []models.UserInfo
	err = engine.Where("back_users like ?", "%,"+fmt.Sprint(user.Id)+"%").Find(&frontUsers)
	if err != nil {
		return err
	}
	for _, fu := range frontUsers {
		var num int64 = 0
		if fu.DirectNumber == 0 {
			continue
		}
		if fu.DirectNumber >= 1 {
			if fu.BackNum < 5 {
				num = user.Id - (fu.Id + 10) - fu.BackNum
				fu.BackNum += num
			}
		}
		if fu.DirectNumber >= 2 {
			if fu.BackNum >= 5 && fu.BackNum < 10 {
				num += user.Id - (fu.Id + 10) - fu.BackNum
				fu.BackNum += num
			}
		}
		if fu.DirectNumber >= 3 {
			if fu.BackNum >= 10 && fu.BackNum < 15 {
				num += user.Id - (fu.Id + 10) - fu.BackNum
				fu.BackNum += num
			}
		}
		_, err = engine.ID(user).Cols("back_num").Update(&fu)
		if err != nil {
			return err
		}
		invitrewards := amount * (float64(num / 100))
		err = UpdateGift(engine, fu.Addr, invitrewards)
		if err != nil {
			return err
		}
	}
	//back >25, DirectNumber 1,2,3
	if user.Direct != "" {
		var inviter models.UserInfo
		ok, err := engine.ID(user.Direct).Get(&inviter)
		if err != nil {
			return err
		}
		if !ok {
			return nil
		}
		var backNum int64 = 0
		if user.Id > inviter.Id+25 && inviter.BackNum < 15 {
			if inviter.DirectNumber >= 1 {
				if inviter.BackNum < 5 {
					backNum += 5 - inviter.BackNum
				}
			}
			if inviter.DirectNumber >= 2 {
				if inviter.BackNum >= 5 && inviter.BackNum < 10 {
					backNum += 10 - inviter.BackNum - backNum
				}
			}
			if inviter.DirectNumber >= 3 {
				if inviter.BackNum >= 10 && inviter.BackNum < 15 {
					backNum += 15 - inviter.BackNum - backNum
				}
			}
			inviter.BackNum += backNum

			_, err = engine.ID(user).Cols("back_num").Update(&inviter)
			if err != nil {
				return err
			}
			rewards := amount * (float64(backNum / 100))
			err = UpdateGift(engine, inviter.Addr, rewards)
			if err != nil {
				return err
			}
		}
	}

	logs.Info("UpdateCommunityGift end:", amount, uaddr)
	return nil
}

func UpdateCommunityNodes(engine *xorm.Session, amount float64) error {
	logs.Info("into UpdateCommunityNodes:", amount)
	var nodes []models.UserInfo
	err := engine.Where("state = ?", CommunityUsers).Find(&nodes)
	if err != nil {
		return err
	}
	if len(nodes) == 0 {
		return nil
	}
	rewards := (amount * 5 / 100) / float64(len(nodes))
	for _, node := range nodes {
		err = UpdateAvailableRewards(engine, rewards, node.Addr, false, false)
		if err != nil {
			fmt.Println(err)
			continue
		}

		var per models.Performance
		_, err = engine.ID(node.Addr).Get(&per)
		if err != nil {
			fmt.Println(err)
			continue
		}

		per.CommunityNode += rewards
		_, err = engine.ID(node.Addr).Cols("community_node").Update(&per)
		if err != nil {
			fmt.Println(err)
			continue
		}
	}
	logs.Info("UpdateCommunityNodes end:", amount)
	return nil
}

func UpdateMarket(engine *xorm.Session, amount float64) error {
	logs.Info("into UpdateMarket:", amount)
	var pers []models.Performance
	err := engine.Where("market_num >= ?", 2).Find(&pers)
	if err != nil {
		return err
	}
	var rp models.RewardsPool
	ok, err := engine.ID(1).Get(&rp)
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}

	for _, per := range pers {
		var level int = 0
		for i := 1; i < len(MarketLevel); i++ {
			if MarketLevel[i-1] <= per.MarketNum && per.MarketNum < MarketLevel[i] {
				level = i
				break
			}
		}
		logs.Debug(" UpdateMarket=====1,", per.Addr, rp.TeamCultivate, per.MarketRewards, level, per.MarketLevel)

		if level > 0 {
			if level > per.MarketLevel {
				ratio := MarketRatio[level] - MarketRatio[per.MarketLevel]
				rewards := amount * ratio
				if rp.TeamCultivate >= rewards {
					rp.TeamCultivate -= rewards  //pool sub rewards
					per.MarketRewards += rewards //user add rewards to PerformanceRewards
					per.MarketLevel = level
					//update available
					logs.Debug(" UpdateMarket=====2,", per.Addr, rewards)

					err := UpdateAvailableRewards(engine, rewards, per.Addr, false, false)
					if err != nil {
						return err
					}
					_, err = engine.ID(per.Addr).Cols("market_level,market_rewards").Update(&per)
					if err != nil {
						return err
					}
				}
			}
		}
		logs.Debug(" UpdateMarket=====3,", per.Addr, rp.TeamCultivate, per.MarketRewards, level, per.MarketLevel)

	}
	_, err = engine.ID(1).Cols("team_performance").Update(&rp)
	if err != nil {
		return err
	}
	logs.Info("UpdateMarket end:", amount)
	return nil
}

func UpdateGift(engine *xorm.Session, user string, rewards float64) error {
	if rewards <= 0 {
		return nil
	}
	err := UpdateAvailableRewards(engine, rewards, user, false, false)
	if err != nil {
		return err
	}

	var per models.Performance
	ok, err := engine.ID(user).Get(&per)
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}
	per.CommunityGift += rewards
	_, err = engine.ID(user).Cols("community_gift").Update(&per)
	if err != nil {
		return err
	}
	return nil
}