main.go

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
)

const (
	ordinary heroType = iota
	elite
	legendary
)
const (
	unknown buffType = iota
	buffIas
	buffDmg
	buffEnergy
)
const speedMax = 2000
const speedMin = 200
const speedMultiple = 200

type heroType int
type buffType int

type writeHelper func(format string, args ...interface{})

type affect struct {
	Type     float64
	Value    float64
	Duration float64
}

type hero struct {
	Name        string
	Type        heroType
	AttackSpeed int
	Buffs       []affect
}

var heroTypes = map[heroType]string{
	ordinary:  "Ordinary",
	elite:     "Elite",
	legendary: "Legendary",
}

var berserks = []int{10, 15, 20, 25, 30, 40, 50, 70}

var celebrates = []int{10, 15, 20, 25, 30, 35, 40, 45, 50, 55}

var bases = []int{
	2000, // ac
	1500, // mino
	1200,
	1000,
	800, // ninja
	750, // reaper
}

type heroState struct {
	baseSpeed       int
	berserkLevel    int
	celebrateLevel  int
	celebrateStacks int
}

func newHeroState(baseSpeed, berserkLevel, celebrateLevel, celebrateStacks int) heroState {
	return heroState{
		baseSpeed:       baseSpeed,
		berserkLevel:    berserkLevel,
		celebrateLevel:  celebrateLevel,
		celebrateStacks: celebrateStacks,
	}
}

func (h *heroState) Base() int {
	return h.baseSpeed
}

func dec(i int) float64 {
	return 1.0 + (float64(i) / 100.0)
}

func (h *heroState) Calculated() int {
	base := float64(h.baseSpeed)
	berserk := dec(h.BerserkSpeed())
	celebratePL := dec(h.CelebrateSpeedPerLevel())
	celebrateS := float64(h.CelebrateStacks())
	celebrateB := math.Pow(celebratePL, celebrateS)
	speed := base

	if celebrateB > 0 {
		speed = speed / berserk / celebrateB
	} else {
		speed = base / berserk
	}

	//fmt.Println("  res", base, berserk, celebratePL, celebrateS, celebrateB)
	return breakpoint(int(speed))
}

func (h *heroState) IncreasedSpeed() int {
	return h.BerserkSpeed() + h.CelebrateSpeed()
}

func (h *heroState) BerserkLevel() int {
	return h.berserkLevel
}

func (h *heroState) BerserkSpeed() int {
	return berserks[h.berserkLevel-1]
}

func (h *heroState) CelebrateLevel() int {
	return h.celebrateLevel
}

func (h *heroState) CelebrateStacks() int {
	return h.celebrateStacks
}

func (h *heroState) CelebrateSpeed() int {
	return h.CelebrateSpeedPerLevel() * h.CelebrateStacks()
}

func (h *heroState) CelebrateSpeedPerLevel() int {
	return celebrates[h.celebrateLevel-1]
}

func (h *heroState) Render(writer writeHelper) {
	writer("[tr][td][color=%v]%v[/color][/td]", speedToRgb(h.Base()), h.Base())
	writer("[td][color=%v]%v[/color][/td]", speedToRgb(h.Calculated()), h.Calculated())
	writer("[td]%v[/td][/tr]", h.BerserkSpeed())
}

func check(e error) {
	if e != nil {
		panic(e)
	}
}

func breakpoint(current int) int {
	result := math.Ceil(float64(current)/float64(speedMultiple)) * float64(speedMultiple)
	return int(math.Max(result, speedMin))
}

type heroStateList struct {
	base   int
	heroes []heroState
}

func newHeroStateList(base int) heroStateList {
	return heroStateList{
		base:   base,
		heroes: []heroState{},
	}
}

func (l *heroStateList) Add(state heroState) {
	l.heroes = append(l.heroes, state)
}

func (l *heroStateList) Render(writer writeHelper) {
	writer("[b]Break points for base speed of [color=%v]%v[/color][/b]", speedToRgb(l.base), l.base)
	writer("[table][tr]")
	writer("[td][b]Base Speed[/b][/td]")
	writer("[td][b]Calculated Speed[/b][/td]")
	writer("[td][b]Berserk Speed[/b][/td]")
	writer("[/tr]")

	for _, heroState := range l.heroes {
		heroState.Render(writer)
	}
	writer("[/table]")
	writer("")
	writer("")
}

func speedToRgb(speed int) string {
	bp := breakpoint(speed)
	max := speedMax / speedMultiple
	step := bp / speedMultiple
	return linearRgb(max, step)
}

func linearRgb(max, step int) string {
	return rgbToHex((255*step)/max, (255*(max-step))/max, 0)
}

func rgbToHex(r, g, b int) string {
	return fmt.Sprintf("#%02X%02X%02X", r, g, b)
}

func a(base int) float64 {
	return float64(base)
}

func b(base int) float64 {
	return float64(base)
}

func c(base int) float64 {
	return float64(base)
}

func main() {

	f, err := os.Create("./table.txt")
	check(err)
	check(f.Truncate(0))
	defer f.Close()

	w := bufio.NewWriter(f)
	defer w.Flush()

	var writer = func(format string, args ...interface{}) {
		text := fmt.Sprintf(format, args...)
		text = text + "\r\n"
		fmt.Println(text)
		_, err = w.WriteString(text)
		check(err)
	}

	// Group tables by base speed
	for _, base := range bases {
		hsl := newHeroStateList(base)

		// Cascade list by berserk -> celebrate
		for berserkLevel := range berserks {
			hs := newHeroState(base, berserkLevel+1, 1, 0)
			hsl.Add(hs)
		}

		hsl.Render(writer)
	}
}