calculate.go 7.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300
  1. package controller
  2. import (
  3. "fmt"
  4. "ktogame/dbUtil"
  5. "ktogame/models"
  6. "strings"
  7. "github.com/astaxie/beego/logs"
  8. "github.com/go-xorm/xorm"
  9. )
  10. func UpdateSuperiorsPerformance(engine *xorm.Engine, superiorsStr string, amount float64) error {
  11. logs.Info("into UpdateSuperiorsPerformance:", superiorsStr, amount)
  12. ids := strings.Split(superiorsStr, ",")
  13. if len(ids) <= 0 {
  14. return nil
  15. }
  16. var supers []models.UserInfo
  17. for _, sid := range ids {
  18. var tmpUser models.UserInfo
  19. ok, err := engine.Where("id = ?", sid).Get(&tmpUser)
  20. if err != nil {
  21. return err
  22. }
  23. if !ok {
  24. continue
  25. }
  26. supers = append(supers, tmpUser)
  27. }
  28. if len(supers) == 0 {
  29. return nil
  30. }
  31. var rp models.RewardsPool
  32. _, err := engine.Id(1).Get(&rp)
  33. if err != nil {
  34. return err
  35. }
  36. for _, super := range supers {
  37. var per models.Performance
  38. ok, err := engine.Id(super.Addr).Get(&per)
  39. if err != nil {
  40. fmt.Println(err)
  41. continue
  42. }
  43. if !ok {
  44. logs.Info("%v not exist!", super.Addr)
  45. continue
  46. }
  47. per.TotalPerformance += amount
  48. if per.TotalPerformance >= CommunityMarket {
  49. if per.Recorded == 0 {
  50. var super models.Performance
  51. ok, err := engine.Id(per.Addr).Get(&super)
  52. if err != nil {
  53. fmt.Println(err)
  54. continue
  55. }
  56. if !ok {
  57. logs.Info("%v not exist!", per.Addr)
  58. continue
  59. }
  60. super.MarketNum += 1
  61. _, err = engine.ID(super.Addr).Cols("markit_num").Update(&super)
  62. if err != nil {
  63. fmt.Println(err)
  64. continue
  65. }
  66. per.Recorded = 1
  67. }
  68. }
  69. var level int = 0
  70. for i := 1; i < len(PerformanceLevel); i++ {
  71. if PerformanceLevel[i-1] <= per.TotalPerformance && per.TotalPerformance < PerformanceLevel[i] {
  72. level = i
  73. break
  74. }
  75. }
  76. if level > 0 {
  77. if level > per.PerformanceLevel {
  78. ratio := PerformanceRatio[level] - PerformanceRatio[per.PerformanceLevel]
  79. rewards := amount * ratio
  80. if rp.TeamPerformance >= rewards {
  81. rp.TeamPerformance -= rewards //pool sub rewards
  82. per.PerformanceRewards += rewards //user add rewards to PerformanceRewards
  83. per.PerformanceLevel = level
  84. //update available
  85. err := UpdateAvailableRewards(rewards, super.Addr, false, false)
  86. if err != nil {
  87. return err
  88. }
  89. _, err = engine.ID(super.Addr).Cols("total_performance,performance_rewards,performance_level").Update(&per)
  90. if err != nil {
  91. return err
  92. }
  93. }
  94. }
  95. }
  96. }
  97. _, err = engine.ID(1).Cols("team_performance").Update(&rp)
  98. if err != nil {
  99. return err
  100. }
  101. logs.Info("into UpdateSuperiorsPerformance end:", rp)
  102. return nil
  103. }
  104. func UpdateRewardsPool(engine *xorm.Engine, amount float64) error {
  105. logs.Info("into UpdateRewardsPool:", amount)
  106. var rp models.RewardsPool
  107. rp.TeamPerformance = amount * 0.15
  108. rp.TeamCultivate = amount * 0.10
  109. rp.TotalPool += amount
  110. _, err := engine.ID(1).Update(&rp)
  111. if err != nil {
  112. return err
  113. }
  114. logs.Info("UpdateRewardsPool end:", rp)
  115. return nil
  116. }
  117. func UpdateAvailableRewards(rewards float64, uaddr string, join, isdirect bool) error {
  118. logs.Info("into UpdateAvailableRewards:", rewards, uaddr, join, isdirect)
  119. a_rewards := rewards * 60 / 100
  120. a_reinput := rewards * 40 / 100
  121. var user models.UserInfo
  122. ok, err := dbUtil.Engine.Id(uaddr).Get(&user)
  123. if err != nil {
  124. return err
  125. }
  126. if !ok {
  127. logs.Info("%v not exist!", uaddr)
  128. return nil
  129. }
  130. user.AvailableClaim = a_rewards
  131. user.AvailableReinput = a_reinput
  132. if join {
  133. if isdirect {
  134. user.DirectNumber += 1
  135. user.DirectRewards += rewards
  136. logs.Info("check direct info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
  137. _, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput,direct_number,direct_rewards").Update(&user)
  138. if err != nil {
  139. return err
  140. }
  141. } else {
  142. user.IndirectNumber += 1
  143. user.IndirectRewards += rewards
  144. logs.Info("check indirect info=====:", rewards, a_rewards, a_reinput, user.AvailableClaim, user.AvailableReinput, user.DirectNumber, user.DirectRewards)
  145. _, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput,indirect_number,indirect_rewards").Update(&user)
  146. if err != nil {
  147. return err
  148. }
  149. }
  150. } else {
  151. logs.Info("check else info=====:", user.AvailableClaim, user.AvailableReinput)
  152. _, err := dbUtil.Engine.ID(user.Addr).Cols("available_claim,available_reinput").Update(&user)
  153. if err != nil {
  154. return err
  155. }
  156. }
  157. logs.Info("into UpdateAvailableRewards end:", user)
  158. return nil
  159. }
  160. func UpdateCommunityGift(engine *xorm.Engine, amount float64, uaddr string) error {
  161. logs.Info("into UpdateCommunityGift:", amount, uaddr)
  162. var user, tmpUser models.UserInfo
  163. ok, err := engine.Id(uaddr).Get(&user)
  164. if err != nil {
  165. return err
  166. }
  167. if !ok {
  168. return nil
  169. }
  170. ok, err = engine.Desc("id").Get(&tmpUser)
  171. if err != nil {
  172. return err
  173. }
  174. if !ok {
  175. logs.Info("%v not exist!", uaddr)
  176. return nil
  177. }
  178. var leftNum, rightNum int64
  179. if user.Id >= 26 {
  180. leftNum = 25
  181. } else {
  182. leftNum = user.Id - 1
  183. }
  184. if tmpUser.Id-user.Id >= 25 {
  185. rightNum = 25
  186. } else {
  187. rightNum = tmpUser.Id - user.Id
  188. }
  189. rewards := amount * (float64(leftNum+rightNum) / 100)
  190. err = UpdateAvailableRewards(rewards, user.Addr, false, false)
  191. if err != nil {
  192. return err
  193. }
  194. var per models.Performance
  195. ok, err = engine.Id(uaddr).Get(&per)
  196. if err != nil {
  197. return err
  198. }
  199. if !ok {
  200. return nil
  201. }
  202. per.CommunityGift += rewards
  203. _, err = engine.ID(uaddr).Cols("community_gift").Update(&per)
  204. if err != nil {
  205. return err
  206. }
  207. logs.Info("into UpdateCommunityGift end:", amount, uaddr)
  208. return nil
  209. }
  210. func UpdateCommunityNodes(engine *xorm.Engine, amount float64) error {
  211. logs.Info("into UpdateCommunityNodes:", amount)
  212. var nodes []models.UserInfo
  213. err := engine.Where("state = ?", CommunityUsers).Find(&nodes)
  214. if err != nil {
  215. return err
  216. }
  217. if len(nodes) == 0 {
  218. return nil
  219. }
  220. rewards := (amount * 5 / 100) / float64(len(nodes))
  221. for _, node := range nodes {
  222. err = UpdateAvailableRewards(rewards, node.Addr, false, false)
  223. if err != nil {
  224. fmt.Println(err)
  225. continue
  226. }
  227. }
  228. logs.Info("into UpdateCommunityNodes end:", amount)
  229. return nil
  230. }
  231. func UpdateMarket(engine *xorm.Engine, amount float64) error {
  232. logs.Info("into UpdateMarket:", amount)
  233. var pers []models.Performance
  234. err := engine.Where("market_num >= ?", 2).Find(&pers)
  235. if err != nil {
  236. return err
  237. }
  238. var rp models.RewardsPool
  239. ok, err := engine.Id(1).Get(&rp)
  240. if err != nil {
  241. return err
  242. }
  243. if !ok {
  244. return nil
  245. }
  246. for _, per := range pers {
  247. var level int = 0
  248. for i := 1; i < len(MarketLevel); i++ {
  249. if MarketLevel[i-1] <= per.MarketNum && per.MarketNum < MarketLevel[i] {
  250. level = i
  251. break
  252. }
  253. }
  254. if level > 0 {
  255. if level > per.MarketLevel {
  256. ratio := MarketRatio[level] - MarketRatio[per.MarketLevel]
  257. rewards := amount * ratio
  258. if rp.TeamCultivate >= rewards {
  259. rp.TeamCultivate -= rewards //pool sub rewards
  260. per.MarketRewards += rewards //user add rewards to PerformanceRewards
  261. per.MarketLevel = level
  262. //update available
  263. err := UpdateAvailableRewards(rewards, per.Addr, false, false)
  264. if err != nil {
  265. return err
  266. }
  267. _, err = engine.ID(per.Addr).Cols("market_level,market_rewards").Update(&per)
  268. if err != nil {
  269. return err
  270. }
  271. }
  272. }
  273. }
  274. }
  275. _, err = engine.ID(1).Cols("team_performance").Update(&rp)
  276. if err != nil {
  277. return err
  278. }
  279. logs.Info("into UpdateMarket end:", amount)
  280. return nil
  281. }