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 {
	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, tmpUser models.UserInfo
	ok, err := engine.ID(uaddr).Get(&user)
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}

	ok, err = engine.Desc("id").Get(&tmpUser)
	if err != nil {
		return err
	}
	if !ok {
		logs.Info("%v not exist!", uaddr)
		return nil
	}

	var leftNum, rightNum int64
	if user.Id >= 26 {
		leftNum = 25
	} else {
		leftNum = user.Id - 1
	}
	if tmpUser.Id-user.Id >= 25 {
		rightNum = 25
	} else {
		rightNum = tmpUser.Id - user.Id
	}

	rewards := amount * (float64(leftNum+rightNum) / 100)
	err = UpdateAvailableRewards(engine, rewards, user.Addr, false, false)
	if err != nil {
		return err
	}

	var per models.Performance
	ok, err = engine.ID(uaddr).Get(&per)
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}
	per.CommunityGift += rewards
	_, err = engine.ID(uaddr).Cols("community_gift").Update(&per)
	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
}