main.go

package main

import (
	//"bufio"
	"fmt"
	"io/ioutil"
	"math"
	"os"
	"path/filepath"
	"strconv"
	"strings"

	dem "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs"
	common "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/common"
	events "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/events"
)

//TODO
//"Catch up on the score" - dont remember what this is lol

//BUG fix
//add verification for missed event triggers if someone DCs/Cs after the redundant event that is stale
//csgo bots all have same steamID, need to use something else just in case for bots
//MM bug?

//add support for esea games? need to change validation and how we determine what round it is (gamestats rounds doesnt work)

//FUNCTIONAL CHANGES
//add verification for if a round event has triggered so far in the round (avoid double roundEnds)
//check for game start without pistol (if we have bad demo)
//Add backend support
//Add anchor stuff
//Add team economy round stats (ecos, forces, etc)
//Add various nil checking

//CLEAN CODE
//create a outputPlayer function to clean up output.go
//convert rating calculations to a function
//actually use killValues lmao

const DEBUG = false

//const suppressNormalOutput = false

//globals
const printChatLog = true
const printDebugLog = true

const tradeCutoff = 4 // in seconds
var multikillBonus = [...]float64{0, 0, 0.3, 0.7, 1.2, 2}
var clutchBonus = [...]float64{0, 0.2, 0.6, 1.2, 2, 3}
var killValues = map[string]float64{
	"attacking":     1.2, //base values
	"defending":     1.0,
	"bombDefense":   1.0,
	"retake":        1.2,
	"chase":         0.8,
	"exit":          0.6,
	"t_consolation": 0.5,
	"gravy":         0.6,
	"punish":        0.8,
	"entry":         0.8, //multipliers
	"t_opener":      0.3,
	"ct_opener":     0.5,
	"trade":         0.3,
	"flashAssist":   0.2,
	"assist":        0.15,
}

type game struct {
	//winnerID         int
	winnerClanName   string
	rounds           []*round
	potentialRound   *round
	teams            map[string]*team
	flags            flag
	mapName          string
	tickRate         int
	tickLength       int
	roundsToWin      int //30 or 16
	totalPlayerStats map[uint64]*playerStats
	totalTeamStats   map[string]*teamStats
	playerOrder      []uint64
	teamOrder        []string
	totalRounds      int
}

type flag struct {
	//all our sentinals and shit
	hasGameStarted            bool
	isGameLive                bool
	isGameOver                bool
	inRound                   bool
	prePlant                  bool
	postPlant                 bool
	postWinCon                bool
	roundIntegrityStart       int
	roundIntegrityEnd         int
	roundIntegrityEndOfficial int

	//for the round (gets reset on a new round) maybe should be in a new struct
	tAlive            int
	ctAlive           int
	tMoney            bool
	tClutchVal        int
	ctClutchVal       int
	tClutchSteam      uint64
	ctClutchSteam     uint64
	openingKill       bool
	lastTickProcessed int
	ticksProcessed    int
	didRoundEndFire   bool
	roundStartedAt    int
	haveInitRound     bool
}

type team struct {
	//id    int //meaningless?
	name  string
	score int
}

type teamStats struct {
	winPoints      float64
	impactPoints   float64
	tWinPoints     float64
	ctWinPoints    float64
	tImpactPoints  float64
	ctImpactPoints float64
	_4v5w          int
	_4v5s          int
	_5v4w          int
	_5v4s          int
	pistols        int
	pistolsW       int
	saves          int
	clutches       int
	traded         int
	fass           int
	ef             int
	ud             int
	util           int
	ctR            int
	ctRW           int
	tR             int
	tRW            int
	deaths         int

	//kinda garbo
	normalizer int
}

type round struct {
	//round value
	roundNum            int8
	startingTick        int
	endingTick          int
	playerStats         map[uint64]*playerStats
	teamStats           map[string]*teamStats
	initTerroristCount  int
	initCTerroristCount int
	winnerClanName      string
	//winnerID            int //this is the unique ID which should not change BUT IT DOES
	winnerENUM         int //this effectively represents the side that won: 2 (T) or 3 (CT)
	integrityCheck     bool
	planter            uint64
	defuser            uint64
	endDueToBombEvent  bool
	winTeamDmg         int
	serverNormalizer   int
	serverImpactPoints float64
}

type playerStats struct {
	name    string
	steamID uint64
	isBot   bool
	//teamID  int
	teamENUM     int
	teamClanName string
	side         int
	rounds       int
	//playerPoints float32
	//teamPoints float32
	damage              int
	kills               uint8
	assists             uint8
	deaths              uint8
	deathTick           int
	deathPlacement      float64
	ticksAlive          int
	trades              int
	traded              int
	ok                  int
	ol                  int
	cl_1                int
	cl_2                int
	cl_3                int
	cl_4                int
	cl_5                int
	_2k                 int
	_3k                 int
	_4k                 int
	_5k                 int
	nadeDmg             int
	infernoDmg          int
	utilDmg             int
	ef                  int
	fAss                int
	enemyFlashTime      float64
	hs                  int
	kastRounds          float64
	saves               int
	entries             int
	killPoints          float64
	impactPoints        float64
	winPoints           float64
	awpKills            int
	RF                  int
	RA                  int
	nadesThrown         int
	firesThrown         int
	flashThrown         int
	smokeThrown         int
	damageTaken         int
	suppRounds          int
	suppDamage          int
	lurkerBlips         int
	distanceToTeammates int
	lurkRounds          int
	wlp                 float64
	mip                 float64
	rws                 float64 //round win shares

	rwk int //rounds with kills

	//derived
	utilThrown   int
	atd          int
	kast         float64
	killPointAvg float64
	iiwr         float64
	adr          float64
	drDiff       float64
	kR           float64
	tr           float64 //trade ratio
	impactRating float64
	rating       float64

	//side specific
	tDamage               int
	ctDamage              int
	tImpactPoints         float64
	tWinPoints            float64
	tOK                   int
	tOL                   int
	ctImpactPoints        float64
	ctWinPoints           float64
	ctOK                  int
	ctOL                  int
	tKills                uint8
	tDeaths               uint8
	tKAST                 float64
	tKASTRounds           float64
	tADR                  float64
	ctKills               uint8
	ctDeaths              uint8
	ctKAST                float64
	ctKASTRounds          float64
	ctADR                 float64
	tTeamsWinPoints       float64
	ctTeamsWinPoints      float64
	tWinPointsNormalizer  int
	ctWinPointsNormalizer int
	tRounds               int
	ctRounds              int
	ctRating              float64
	tRating               float64
	tADP                  float64
	ctADP                 float64

	tRF   int
	ctAWP int

	//kinda garbo
	teamsWinPoints      float64
	winPointsNormalizer int

	//"flags"
	health             int
	tradeList          map[uint64]int
	mostRecentFlasher  uint64
	mostRecentFlashVal float64
	damageList         map[uint64]int
}

func main() {
	input_dir := "in"
	files, _ := ioutil.ReadDir(input_dir)

	for _, file := range files {
		filename := file.Name()
		if strings.HasSuffix(filename, ".dem") {
			fmt.Println("processing", file.Name())
			go processDemo(filepath.Join(input_dir, filename))
		}
	}

	var input string
	fmt.Scanln(&input)

	//authenticate()
}

func initGameObject() *game {
	g := game{}
	g.rounds = make([]*round, 0)
	g.potentialRound = &round{}

	g.flags.hasGameStarted = false
	g.flags.isGameLive = false
	g.flags.isGameOver = false
	g.flags.inRound = false
	g.flags.prePlant = true
	g.flags.postPlant = false
	g.flags.postWinCon = false
	//these three vars to check if we have a complete round
	g.flags.roundIntegrityStart = -1
	g.flags.roundIntegrityEnd = -1
	g.flags.roundIntegrityEndOfficial = -1

	return &g
}

func processDemo(demoName string) {

	game := initGameObject()

	/*
	   var errLog = "";
	*/

	f, err := os.Open(demoName)
	//f, err := os.Open("league1.dem")
	if err != nil {
		panic(err)
	}
	defer f.Close()

	p := dem.NewParser(f)
	defer p.Close()

	//must parse header to get header info
	header, err := p.ParseHeader()
	if err != nil {
		panic(err)
	}

	//set map name
	game.mapName = strings.Title((header.MapName)[3:])
	fmt.Println("Map is", game.mapName)

	//set tick rate
	game.tickRate = int(math.Round(p.TickRate()))
	fmt.Println("Tick rate is", game.tickRate)

	game.tickLength = header.PlaybackTicks

	//creating a file to dump chat log into
	fmt.Printf("Creating chatLog file.\n")
	os.Mkdir("out", 0777)
	chatFile, chatFileErr := os.Create("out/chatLog.txt")
	if chatFileErr != nil {
		fmt.Printf("Error in opening chatLog file.\n")
	}
	defer chatFile.Close()

	fmt.Printf("Creating debug file.\n")
	debugFile, debugFileErr := os.Create("out/debug.txt")
	if debugFileErr != nil {
		fmt.Printf("Error in opening debug file.\n")
	}
	defer debugFile.Close()

	//---------------FUNCTIONS---------------

	initGameStart := func() {
		game.flags.hasGameStarted = true
		game.flags.isGameLive = true
		fmt.Println("GAME HAS STARTED!!!")

		game.teams = make(map[string]*team)

		teamTemp := p.GameState().TeamTerrorists()
		game.teams[teamTemp.ClanName()] = &team{name: validateTeamName(game, teamTemp.ClanName())}
		teamTemp = p.GameState().TeamCounterTerrorists()
		game.teams[teamTemp.ClanName()] = &team{name: validateTeamName(game, teamTemp.ClanName())}

		//to handle short and long matches
		if p.GameState().ConVars()["mp_maxrounds"] != "30" {
			maxRounds, fuckOFF := strconv.Atoi(p.GameState().ConVars()["mp_maxrounds"])
			if fuckOFF == nil {
				game.roundsToWin = maxRounds/2 + 1
			} else {
				//ADD TO ERROR LOG
				game.roundsToWin = maxRounds/2 + 1
				//maybe this gives us a way to check for short vs long match
			}
		} else {
			game.roundsToWin = 16 //we will assume long match in case convar is not set
		}

	}

	//reset various flags
	resetRoundFlags := func() {
		game.flags.prePlant = true
		game.flags.postPlant = false
		game.flags.postWinCon = false
		game.flags.tClutchVal = 0
		game.flags.ctClutchVal = 0
		game.flags.tClutchSteam = 0
		game.flags.ctClutchSteam = 0
		game.flags.tMoney = false
		game.flags.openingKill = true
		game.flags.lastTickProcessed = 0
		game.flags.ticksProcessed = 0
		game.flags.didRoundEndFire = false
		game.flags.roundStartedAt = 0
		game.flags.haveInitRound = false
	}

	initTeamPlayer := func(team *common.TeamState, currRoundObj *round) {
		for _, teamMember := range team.Members() {
			player := &playerStats{name: teamMember.Name, steamID: teamMember.SteamID64, isBot: teamMember.IsBot, side: int(team.Team()), teamENUM: team.ID(), teamClanName: validateTeamName(game, team.ClanName()), health: 100, tradeList: make(map[uint64]int), damageList: make(map[uint64]int)}
			currRoundObj.playerStats[player.steamID] = player
		}
	}

	initRound := func() {
		game.flags.roundIntegrityStart = p.GameState().TotalRoundsPlayed() + 1
		fmt.Println("We are starting round", game.flags.roundIntegrityStart)

		newRound := &round{roundNum: int8(game.flags.roundIntegrityStart), startingTick: p.GameState().IngameTick()}
		newRound.playerStats = make(map[uint64]*playerStats)
		newRound.teamStats = make(map[string]*teamStats)

		//set players in playerStats for the round
		terrorists := p.GameState().TeamTerrorists()
		counterTerrorists := p.GameState().TeamCounterTerrorists()

		initTeamPlayer(terrorists, newRound)
		initTeamPlayer(counterTerrorists, newRound)

		//set teams in teamStats for the round
		newRound.teamStats[validateTeamName(game, p.GameState().TeamTerrorists().ClanName())] = &teamStats{tR: 1}
		newRound.teamStats[validateTeamName(game, p.GameState().TeamCounterTerrorists().ClanName())] = &teamStats{ctR: 1}

		// Reset round
		game.potentialRound = newRound

		//track the number of people alive for clutch checking and record keeping
		game.flags.tAlive = len(terrorists.Members())
		game.flags.ctAlive = len(counterTerrorists.Members())
		game.potentialRound.initTerroristCount = game.flags.tAlive
		game.potentialRound.initCTerroristCount = game.flags.ctAlive

		resetRoundFlags()
	}

	processRoundOnWinCon := func(winnerClanName string) {
		game.flags.roundIntegrityEnd = p.GameState().TotalRoundsPlayed() + 1
		fmt.Println("We are processing round win con stuff", game.flags.roundIntegrityEnd)

		game.totalRounds = game.flags.roundIntegrityEnd

		game.flags.prePlant = false
		game.flags.postPlant = false
		game.flags.postWinCon = true

		//set winner
		game.potentialRound.winnerClanName = winnerClanName
		game.teams[game.potentialRound.winnerClanName].score += 1
		//fmt.Println("We think this team won", game.teams[game.potentialRound.winnerID].name)
		//check clutch

	}

	processRoundFinal := func(lastRound bool) {
		game.flags.inRound = false
		game.potentialRound.endingTick = p.GameState().IngameTick()
		game.flags.roundIntegrityEndOfficial = p.GameState().TotalRoundsPlayed()
		if lastRound {
			game.flags.roundIntegrityEndOfficial += 1
			game.totalRounds = game.flags.roundIntegrityEndOfficial
		}
		fmt.Println("We are processing round final stuff", game.flags.roundIntegrityEndOfficial)
		fmt.Println(len(game.rounds))

		//we have the entire round uninterrupted
		if game.flags.roundIntegrityStart == game.flags.roundIntegrityEnd && game.flags.roundIntegrityEnd == game.flags.roundIntegrityEndOfficial {
			game.potentialRound.integrityCheck = true

			//check team stats
			if game.potentialRound.teamStats[game.potentialRound.winnerClanName].pistols == 1 {
				game.potentialRound.teamStats[game.potentialRound.winnerClanName].pistolsW = 1
			}
			if game.potentialRound.teamStats[game.potentialRound.winnerClanName]._4v5s == 1 {
				game.potentialRound.teamStats[game.potentialRound.winnerClanName]._4v5w = 1
			} else if game.potentialRound.teamStats[game.potentialRound.winnerClanName]._5v4s == 1 {
				game.potentialRound.teamStats[game.potentialRound.winnerClanName]._5v4w = 1
			}
			if game.potentialRound.teamStats[game.potentialRound.winnerClanName].tR == 1 {
				game.potentialRound.teamStats[game.potentialRound.winnerClanName].tRW = 1
			} else if game.potentialRound.teamStats[game.potentialRound.winnerClanName].ctR == 1 {
				game.potentialRound.teamStats[game.potentialRound.winnerClanName].ctRW = 1
			}

			//set the clutch
			if game.potentialRound.winnerENUM == 2 && game.flags.tClutchSteam != 0 {
				game.potentialRound.teamStats[game.potentialRound.winnerClanName].clutches = 1
				game.potentialRound.playerStats[game.flags.tClutchSteam].impactPoints += clutchBonus[game.flags.tClutchVal]
				switch game.flags.tClutchVal {
				case 1:
					game.potentialRound.playerStats[game.flags.tClutchSteam].cl_1 = 1
				case 2:
					game.potentialRound.playerStats[game.flags.tClutchSteam].cl_2 = 1
				case 3:
					game.potentialRound.playerStats[game.flags.tClutchSteam].cl_3 = 1
				case 4:
					game.potentialRound.playerStats[game.flags.tClutchSteam].cl_4 = 1
				case 5:
					game.potentialRound.playerStats[game.flags.tClutchSteam].cl_5 = 1
				}
			} else if game.potentialRound.winnerENUM == 3 && game.flags.ctClutchSteam != 0 {
				game.potentialRound.teamStats[game.potentialRound.winnerClanName].clutches = 1
				game.potentialRound.playerStats[game.flags.ctClutchSteam].impactPoints += clutchBonus[game.flags.ctClutchVal]
				switch game.flags.ctClutchVal {
				case 1:
					game.potentialRound.playerStats[game.flags.ctClutchSteam].cl_1 = 1
				case 2:
					game.potentialRound.playerStats[game.flags.ctClutchSteam].cl_2 = 1
				case 3:
					game.potentialRound.playerStats[game.flags.ctClutchSteam].cl_3 = 1
				case 4:
					game.potentialRound.playerStats[game.flags.ctClutchSteam].cl_4 = 1
				case 5:
					game.potentialRound.playerStats[game.flags.ctClutchSteam].cl_5 = 1
				}
			}

			//add multikills & saves & misc
			highestImpactPoints := 0.0
			mipPlayers := 0
			for _, player := range (game.potentialRound).playerStats {
				if player.deaths == 0 {
					player.kastRounds = 1
					if player.teamENUM != game.potentialRound.winnerENUM {
						player.saves = 1
						game.potentialRound.teamStats[player.teamClanName].saves = 1
					}
				}
				game.potentialRound.playerStats[player.steamID].impactPoints += player.killPoints
				game.potentialRound.playerStats[player.steamID].impactPoints += float64(player.damage) / float64(250)
				game.potentialRound.playerStats[player.steamID].impactPoints += multikillBonus[player.kills]

				switch player.kills {
				case 2:
					player._2k = 1
				case 3:
					player._3k = 1
				case 4:
					player._4k = 1
				case 5:
					player._5k = 1
				}

				if player.impactPoints > highestImpactPoints {
					highestImpactPoints = player.impactPoints
				}

				if player.teamENUM == game.potentialRound.winnerENUM {
					player.winPoints = player.impactPoints

					player.RF = 1
				} else {
					player.RA = 1
				}
			}

			for _, player := range (game.potentialRound).playerStats {
				if player.impactPoints == highestImpactPoints {
					mipPlayers += 1
				}
			}
			for _, player := range (game.potentialRound).playerStats {
				if player.impactPoints == highestImpactPoints {
					player.mip = 1.0 / float64(mipPlayers)
				}
			}

			//check the lurk
			var susLurker uint64
			susLurkBlips := 0
			invalidLurk := false
			for _, player := range game.potentialRound.playerStats {
				if player.side == 2 {
					if player.lurkerBlips > susLurkBlips {
						susLurkBlips = player.lurkerBlips
						susLurker = player.steamID
					}
				}
			}
			for _, player := range game.potentialRound.playerStats {
				if player.side == 2 {
					if player.lurkerBlips == susLurkBlips && player.steamID != susLurker {
						invalidLurk = true
					}
				}
			}
			if !invalidLurk && susLurkBlips > 3 {
				game.potentialRound.playerStats[susLurker].lurkRounds = 1
			}

			//add our valid round
			game.rounds = append(game.rounds, game.potentialRound)
		}

		//endRound function functionality

	}

	//-------------ALL OUR EVENTS---------------------

	p.RegisterEventHandler(func(e events.FrameDone) {
		if game.flags.roundStartedAt > 0 && game.flags.roundStartedAt+(1*game.tickRate) > p.GameState().IngameTick() && !game.flags.haveInitRound {
			pistol := false

			//we are going to check to see if the first pistol is actually starting
			membersT := p.GameState().TeamTerrorists().Members()
			membersCT := p.GameState().TeamCounterTerrorists().Members()
			if len(membersT) != 0 && len(membersCT) != 0 {
				if membersT[0].Money()+membersT[0].MoneySpentThisRound() == 800 && membersCT[0].Money()+membersCT[0].MoneySpentThisRound() == 800 {
					//start the game
					if !game.flags.hasGameStarted {
						initGameStart()
					}

					//track the pistol
					pistol = true
				}
			}
			//fmt.Println("Has the Game Started?", game.flags.hasGameStarted)

			if game.flags.isGameLive {
				//init round stats
				initRound()
				game.flags.haveInitRound = true
				if pistol {
					for _, team := range game.potentialRound.teamStats {
						team.pistols = 1
					}
				}

			}
		}

		if game.flags.inRound && game.flags.lastTickProcessed+(4*game.tickRate) < p.GameState().IngameTick() {
			game.flags.lastTickProcessed = p.GameState().IngameTick()
			game.flags.ticksProcessed += 1

			//this will be triggered every 4 seconds of in round time after the first 10 seconds

			//check for lurker
			if game.flags.tAlive > 2 && !game.flags.postWinCon && p.GameState().IngameTick() > (18*game.tickRate)+game.potentialRound.startingTick {
				membersT := p.GameState().TeamTerrorists().Members()
				for _, terrorist := range membersT {
					if terrorist.IsAlive() {
						for _, teammate := range membersT {
							if terrorist.SteamID64 != teammate.SteamID64 && teammate.IsAlive() {
								dist := int(terrorist.Position().Distance(teammate.Position()))
								if dist < 500 {
									//invalidate the lurk blip b/c we have a close teammate
									game.potentialRound.playerStats[terrorist.SteamID64].distanceToTeammates = -999999
								}
								if game.potentialRound.playerStats[terrorist.SteamID64] != nil {
									game.potentialRound.playerStats[terrorist.SteamID64].distanceToTeammates += dist
								} else {
									fmt.Println("THIS IS WHERE WE BROKE_______________________________---------------------------------------------------")
								}
							}
						}
					}
				}
				var lurkerSteam uint64
				lurkerDist := 999999
				for _, terrorist := range membersT {
					if terrorist.IsAlive() {
						if game.potentialRound.playerStats[terrorist.SteamID64] == nil {
							fmt.Println(terrorist.Name)
						}
						dist := game.potentialRound.playerStats[terrorist.SteamID64].distanceToTeammates
						if dist < lurkerDist && dist > 0 {
							lurkerDist = dist
							lurkerSteam = terrorist.SteamID64
						}
					}
				}
				if lurkerSteam != 0 {
					game.potentialRound.playerStats[lurkerSteam].lurkerBlips += 1
				}
			}
		}
	})

	p.RegisterEventHandler(func(e events.RoundStart) {
		fmt.Println("Round Start", p.GameState().TotalRoundsPlayed())

		game.flags.roundStartedAt = p.GameState().IngameTick()

	})

	p.RegisterEventHandler(func(e events.RoundFreezetimeEnd) {
		fmt.Printf("Round Freeze Time End\n")
		pistol := false

		//we are going to check to see if the first pistol is actually starting
		membersT := p.GameState().TeamTerrorists().Members()
		membersCT := p.GameState().TeamCounterTerrorists().Members()
		if len(membersT) != 0 && len(membersCT) != 0 {
			if membersT[0].Money()+membersT[0].MoneySpentThisRound() == 800 && membersCT[0].Money()+membersCT[0].MoneySpentThisRound() == 800 {
				//start the game
				if !game.flags.hasGameStarted {
					initGameStart()
				}

				//track the pistol
				pistol = true
			}
		}
		fmt.Println("Has the Game Started?", game.flags.hasGameStarted)

		if game.flags.isGameLive {
			//init round stats
			game.flags.inRound = true
			initRound()
			if pistol {
				for _, team := range game.potentialRound.teamStats {
					team.pistols = 1
				}
			}

		}

	})

	p.RegisterEventHandler(func(e events.RoundEnd) {
		if game.flags.isGameLive {

			game.flags.didRoundEndFire = true

			fmt.Println("Round", p.GameState().TotalRoundsPlayed()+1, "End", e.WinnerState.ClanName(), "won", "this determined from e.WinnerState.ClanName()")

			fmt.Println("e.WinnerState.ID()", e.WinnerState.ID(), "and", "e.Winner", e.Winner, "and", "e.WinnerState.Team()", e.WinnerState.Team())

			validWinner := true
			if e.Winner < 2 {
				validWinner = false
				//and set the integrity flag to false

			} else if e.Winner == 2 {
				game.flags.tMoney = true
			} else {
				//we need to check if the game is over

			}

			//we want to actually process the round
			if game.flags.isGameLive && validWinner && game.flags.roundIntegrityStart == p.GameState().TotalRoundsPlayed()+1 {
				game.potentialRound.winnerENUM = int(e.Winner)
				processRoundOnWinCon(validateTeamName(game, e.WinnerState.ClanName()))

				//check last round
				roundWinnerScore := game.teams[validateTeamName(game, e.WinnerState.ClanName())].score
				roundLoserScore := game.teams[validateTeamName(game, e.LoserState.ClanName())].score
				fmt.Println("winner Rounds", roundWinnerScore)
				fmt.Println("loser Rounds", roundLoserScore)

				if game.roundsToWin == 16 {
					//check for normal win
					if roundWinnerScore == 16 && roundLoserScore < 15 {
						//normal win
						game.winnerClanName = game.potentialRound.winnerClanName
						processRoundFinal(true)
					} else if roundWinnerScore > 15 { //check for OT win
						overtime := ((roundWinnerScore+roundLoserScore)-30-1)/6 + 1
						//OT win
						if (roundWinnerScore-15-1)/3 == overtime {
							game.winnerClanName = game.potentialRound.winnerClanName
							processRoundFinal(true)
						}
					}
				} else if game.roundsToWin == 9 {
					//check for normal win
					if roundWinnerScore == 9 && roundLoserScore < 8 {
						//normal win
						game.winnerClanName = game.potentialRound.winnerClanName
						processRoundFinal(true)
					} else if roundWinnerScore == 8 && roundLoserScore == 8 { //check for tie
						//tie
						game.winnerClanName = game.potentialRound.winnerClanName
						processRoundFinal(true)
					}
				}
			}

			//check last round
			//or check overtime win

		}
	})

	//round end official doesnt fire on the last round
	p.RegisterEventHandler(func(e events.ScoreUpdated) {
		fmt.Printf("Score Updated\n")

		if game.flags.isGameLive && !game.flags.didRoundEndFire && e.NewScore > e.OldScore && game.winnerClanName == "" {
			//we are replicating RoundEndEvent functionality because it did not fire

			//this TeamState will "always" be the winner, why update the losing team?
			winnerEnum := e.TeamState.Team()
			winnerClanName := e.TeamState.ClanName()
			loserClanName := ""
			for teamName, _ := range game.teams {
				if teamName != validateTeamName(game, winnerClanName) {
					loserClanName = teamName
				}
			}

			fmt.Println("Round", p.GameState().TotalRoundsPlayed()+1, "End", winnerClanName, "won", "this determined from e.WinnerState.ClanName()")

			validWinner := true
			if winnerEnum < 2 {
				validWinner = false
				//and set the integrity flag to false

			} else if winnerEnum == 2 {
				game.flags.tMoney = true
			} else {
				//we need to check if the game is over

			}

			fmt.Println("ris", game.flags.roundIntegrityStart, "p.GS.TotalRounds", p.GameState().TotalRoundsPlayed())

			//we want to actually process the round
			if game.flags.isGameLive && validWinner && game.flags.roundIntegrityStart == p.GameState().TotalRoundsPlayed() {
				game.potentialRound.winnerENUM = int(winnerEnum)
				processRoundOnWinCon(validateTeamName(game, winnerClanName))

				//check last round
				roundWinnerScore := game.teams[validateTeamName(game, winnerClanName)].score
				roundLoserScore := game.teams[validateTeamName(game, loserClanName)].score
				fmt.Println("winner Rounds", roundWinnerScore)
				fmt.Println("loser Rounds", roundLoserScore)

				if game.roundsToWin == 16 {
					//check for normal win
					if roundWinnerScore == 16 && roundLoserScore < 15 {
						//normal win
						game.winnerClanName = game.potentialRound.winnerClanName
						processRoundFinal(true)
					} else if roundWinnerScore > 15 { //check for OT win
						overtime := ((roundWinnerScore+roundLoserScore)-30-1)/6 + 1
						//OT win
						if (roundWinnerScore-15-1)/3 == overtime {
							game.winnerClanName = game.potentialRound.winnerClanName
							processRoundFinal(true)
						}
					}
				} else if game.roundsToWin == 9 {
					//check for normal win
					if roundWinnerScore == 9 && roundLoserScore < 8 {
						//normal win
						game.winnerClanName = game.potentialRound.winnerClanName
						processRoundFinal(true)
					} else if roundWinnerScore == 8 && roundLoserScore == 8 { //check for tie
						//tie
						game.winnerClanName = game.potentialRound.winnerClanName
						processRoundFinal(true)
					}
				}
			}

			//check last round
			//or check overtime win

		}
	})

	//round end official doesnt fire on the last round
	p.RegisterEventHandler(func(e events.RoundEndOfficial) {

		fmt.Printf("Round End Official\n")

		if !game.flags.didRoundEndFire {
			game.flags.roundIntegrityEnd -= 1
		}

		fmt.Println("isGameLive", game.flags.isGameLive, "roundIntegrityEnd", game.flags.roundIntegrityEnd, "pTotalRoundsPlayed", p.GameState().TotalRoundsPlayed())

		if game.flags.isGameLive && game.flags.roundIntegrityEnd == p.GameState().TotalRoundsPlayed() {
			processRoundFinal(false)
		}
	})

	// Register handler on kill events
	p.RegisterEventHandler(func(e events.Kill) {
		if game.flags.isGameLive && isDuringExpectedRound(game, p) {
			pS := game.potentialRound.playerStats
			tick := p.GameState().IngameTick()

			killerExists := false
			victimExists := false
			assisterExists := false
			if e.Killer != nil && pS[e.Killer.SteamID64] != nil {
				killerExists = true
			}
			if e.Victim != nil && pS[e.Victim.SteamID64] != nil {
				victimExists = true
			}
			if e.Assister != nil && pS[e.Assister.SteamID64] != nil {
				assisterExists = true
			}

			killValue := 1.0
			multiplier := 1.0
			traded := false
			assisted := false
			flashAssisted := false

			//death logic (traded here)
			if victimExists {
				pS[e.Victim.SteamID64].deaths += 1
				pS[e.Victim.SteamID64].deathTick = tick
				if e.Victim.Team == 2 {
					game.flags.tAlive -= 1
					pS[e.Victim.SteamID64].deathPlacement = float64(game.potentialRound.initTerroristCount - game.flags.tAlive)
					//pS[e.Victim.SteamID64].tADP = float64(game.potentialRound.initTerroristCount - game.flags.tAlive)
				} else if e.Victim.Team == 3 {
					game.flags.ctAlive -= 1
					pS[e.Victim.SteamID64].deathPlacement = float64(game.potentialRound.initCTerroristCount - game.flags.ctAlive)
					//pS[e.Victim.SteamID64].ctADP = float64(game.potentialRound.initCTerroristCount - game.flags.ctAlive)
				} else {
					//else log an error
				}

				//do 4v5 calc
				if game.flags.openingKill && game.potentialRound.initCTerroristCount+game.potentialRound.initTerroristCount == 10 {
					//the 10th player died
					_4v5Team := pS[e.Victim.SteamID64].teamClanName
					game.potentialRound.teamStats[_4v5Team]._4v5s = 1
					for teamName, team := range game.potentialRound.teamStats {
						if teamName != _4v5Team {
							team._5v4s = 1
						}
					}
				}

				//add support damage
				for suppSteam, suppDMG := range pS[e.Victim.SteamID64].damageList {
					if killerExists && suppSteam != e.Killer.SteamID64 {
						pS[suppSteam].suppDamage += suppDMG
						if pS[suppSteam].suppDamage > 60 {
							pS[suppSteam].suppRounds = 1
						}
					} else if !killerExists {
						pS[suppSteam].suppDamage += suppDMG
						if pS[suppSteam].suppDamage > 60 {
							pS[suppSteam].suppRounds = 1
						}
					}

				}

				//check clutch start

				if !game.flags.postWinCon {
					if game.flags.tAlive == 1 && game.flags.tClutchVal == 0 {
						game.flags.tClutchVal = game.flags.ctAlive
						membersT := p.GameState().TeamTerrorists().Members()
						for _, terrorist := range membersT {
							if terrorist.IsAlive() && e.Victim.SteamID64 != terrorist.SteamID64 {
								game.flags.tClutchSteam = terrorist.SteamID64
								fmt.Println("Clutch opportunity:", terrorist.Name, game.flags.tClutchVal)
							}
						}
					}
					if game.flags.ctAlive == 1 && game.flags.ctClutchVal == 0 {
						game.flags.ctClutchVal = game.flags.tAlive
						membersCT := p.GameState().TeamCounterTerrorists().Members()
						for _, counterTerrorist := range membersCT {
							if counterTerrorist.IsAlive() && e.Victim.SteamID64 != counterTerrorist.SteamID64 {
								game.flags.ctClutchSteam = counterTerrorist.SteamID64
								fmt.Println("Clutch opportunity:", counterTerrorist.Name, game.flags.ctClutchVal)
							}
						}
					}
				}

				pS[e.Victim.SteamID64].ticksAlive = tick - game.potentialRound.startingTick
				for deadGuySteam, deadTick := range (*game.potentialRound).playerStats[e.Victim.SteamID64].tradeList {
					if tick-deadTick < tradeCutoff*game.tickRate {
						pS[deadGuySteam].traded = 1
						pS[deadGuySteam].kastRounds = 1
					}
				}
			}

			//assist logic
			if assisterExists && victimExists && e.Assister.TeamState.ID() != e.Victim.TeamState.ID() {
				//this logic needs to be replaced
				pS[e.Assister.SteamID64].assists += 1
				pS[e.Assister.SteamID64].kastRounds = 1
				pS[e.Assister.SteamID64].suppRounds = 1
				assisted = true
				if e.AssistedFlash {
					pS[e.Assister.SteamID64].fAss += 1
					flashAssisted = true
				} else if float64(p.GameState().IngameTick()) < pS[e.Victim.SteamID64].mostRecentFlashVal {
					//this will trigger if there is both a flash assist and a damage assist
					pS[pS[e.Victim.SteamID64].mostRecentFlasher].fAss += 1
					pS[pS[e.Victim.SteamID64].mostRecentFlasher].suppRounds = 1
					flashAssisted = true
				}

			}

			//kill logic (trades here)
			if killerExists && victimExists && e.Killer.TeamState.ID() != e.Victim.TeamState.ID() {
				pS[e.Killer.SteamID64].kills += 1
				pS[e.Killer.SteamID64].kastRounds = 1
				pS[e.Killer.SteamID64].rwk = 1
				pS[e.Killer.SteamID64].tradeList[e.Victim.SteamID64] = tick
				if e.Weapon.Type == 309 {
					pS[e.Killer.SteamID64].awpKills += 1
					if e.Killer.Team == 3 {
						pS[e.Killer.SteamID64].ctAWP += 1
					}
				}
				if e.IsHeadshot {
					pS[e.Killer.SteamID64].hs += 1
				}
				for _, deadTick := range (*game.potentialRound).playerStats[e.Victim.SteamID64].tradeList {
					if tick-deadTick < tradeCutoff*game.tickRate {
						pS[e.Killer.SteamID64].trades += 1
						traded = true
						break
					}
				}

				killerTeam := e.Killer.Team
				if game.flags.prePlant {
					//normal base value
					if killerTeam == 2 {
						//taking site by T
						killValue = 1.2
					} else if killerTeam == 3 {
						//site Defense by CT
						killValue = 1
					}
				} else if game.flags.postPlant {
					//site D or retake
					if killerTeam == 2 {
						//site Defense by T
						killValue = 1
					} else if killerTeam == 3 {
						//retake
						killValue = 1.2
					}
				} else if game.flags.postWinCon {
					//exit or chase
					if game.potentialRound.winnerENUM == 2 { //Ts win
						if killerTeam == 2 { //chase
							killValue = 0.8
						}
						if killerTeam == 3 { //exit
							killValue = 0.6
						}
					} else if game.potentialRound.winnerENUM == 3 { //CTs win
						if killerTeam == 2 { //T kill in lost round
							killValue = 0.5
						}
						if killerTeam == 3 { //CT kill in won round
							if game.flags.tMoney {
								killValue = 0.6
							} else {
								killValue = 0.8
							}
						}
					}
				}

				if game.flags.openingKill {
					game.flags.openingKill = false

					pS[e.Killer.SteamID64].ok = 1
					pS[e.Victim.SteamID64].ol = 1

					if killerTeam == 2 { //T entry/opener {
						if game.flags.prePlant {
							multiplier += 0.8
							pS[e.Killer.SteamID64].entries = 1
						} else {
							multiplier += 0.3
						}
					} else if killerTeam == 3 { //CT opener
						multiplier += 0.5
					}

				} else if traded {
					multiplier += 0.3
				}

				if flashAssisted { //flash assisted kill
					multiplier += 0.2
				}
				if assisted { //assisted kill
					killValue -= 0.15
					pS[e.Assister.SteamID64].impactPoints += 0.15
				}

				killValue *= multiplier

				ecoRatio := float64(e.Victim.EquipmentValueCurrent()) / float64(e.Killer.EquipmentValueCurrent())
				ecoMod := 1.0
				if ecoRatio > 4 {
					ecoMod += 0.25
				} else if ecoRatio > 2 {
					ecoMod += 0.14
				} else if ecoRatio < 0.25 {
					ecoMod -= 0.25
				} else if ecoRatio < 0.5 {
					ecoMod -= 0.14
				}
				killValue *= ecoMod

				pS[e.Killer.SteamID64].killPoints += killValue
			}

		}
		var hs string
		if e.IsHeadshot {
			hs = " (HS)"
		}
		var wallBang string
		if e.PenetratedObjects > 0 {
			wallBang = " (WB)"
		}
		fmt.Printf("%s <%v%s%s> %s at %d\n", e.Killer, e.Weapon, hs, wallBang, e.Victim, p.GameState().IngameTick())
	})

	p.RegisterEventHandler(func(e events.PlayerHurt) {
		//fmt.Printf("Player Hurt\n")
		if game.flags.isGameLive {
			equipment := e.Weapon.Type
			if e.Player != nil {
				game.potentialRound.playerStats[e.Player.SteamID64].damageTaken += e.HealthDamageTaken
			}
			if e.Player != nil && e.Attacker != nil && e.Player.Team != e.Attacker.Team {
				game.potentialRound.playerStats[e.Attacker.SteamID64].damage += e.HealthDamageTaken

				//add to damage list for supp damage calc
				game.potentialRound.playerStats[e.Player.SteamID64].damageList[e.Attacker.SteamID64] += e.HealthDamageTaken

				if equipment >= 500 && equipment <= 506 {
					game.potentialRound.playerStats[e.Attacker.SteamID64].utilDmg += e.HealthDamageTaken
					if equipment == 506 {
						game.potentialRound.playerStats[e.Attacker.SteamID64].nadeDmg += e.HealthDamageTaken
					}
					if equipment == 502 || equipment == 503 {
						game.potentialRound.playerStats[e.Attacker.SteamID64].infernoDmg += e.HealthDamageTaken
					}
				}
			}
		}
	})

	p.RegisterEventHandler(func(e events.PlayerFlashed) {
		//fmt.Printf("Player Flashed\n")
		tick := float64(p.GameState().IngameTick())
		blindTicks := e.FlashDuration().Seconds() * 128.0
		if game.flags.isGameLive && e.Player != nil && e.Attacker != nil {
			victim := e.Player
			flasher := e.Attacker
			if flasher.Team != victim.Team && blindTicks > 128.0 && victim.IsAlive() && (float64(victim.FlashDuration) < (blindTicks/128.0 + 1)) {
				game.potentialRound.playerStats[flasher.SteamID64].ef += 1
				game.potentialRound.playerStats[flasher.SteamID64].enemyFlashTime += (blindTicks / 128.0)
				if tick+blindTicks > game.potentialRound.playerStats[victim.SteamID64].mostRecentFlashVal {
					game.potentialRound.playerStats[victim.SteamID64].mostRecentFlashVal = tick + blindTicks
					game.potentialRound.playerStats[victim.SteamID64].mostRecentFlasher = flasher.SteamID64
				}

			}
			// if flasher.Name != "" {
			// 	debugMsg := fmt.Sprintf("%s flashed %s for %.2f at %d. He was %f blind.\n", flasher, victim, blindTicks/128, int(tick), victim.FlashDuration)
			// 	debugFile.WriteString(debugMsg)
			// 	debugFile.Sync()
			// }

		}
	})

	p.RegisterEventHandler(func(e events.RoundImpactScoreData) {
		fmt.Println("-------ROUNDIMPACTSCOREDATA", e.RawMessage)
	})

	p.RegisterEventHandler(func(e events.BombPlanted) {
		fmt.Printf("Bomb Planted\n")
		if game.flags.isGameLive && !game.flags.postWinCon {
			game.flags.prePlant = false
			game.flags.postPlant = true
			game.flags.tMoney = true
			game.potentialRound.planter = e.BombEvent.Player.SteamID64
		}
	})

	p.RegisterEventHandler(func(e events.BombDefused) {
		fmt.Println("Bomb Defused by", e.BombEvent.Player.Name)
		if game.flags.isGameLive && !game.flags.postWinCon {
			game.flags.prePlant = false
			game.flags.postPlant = false
			game.flags.postWinCon = true
			game.potentialRound.endDueToBombEvent = true
			game.potentialRound.defuser = e.Player.SteamID64
			game.potentialRound.playerStats[e.BombEvent.Player.SteamID64].impactPoints += 0.5
		}
	})

	p.RegisterEventHandler(func(e events.BombExplode) {
		fmt.Printf("Bomb Exploded\n")
		if game.flags.isGameLive && !game.flags.postWinCon {
			game.flags.prePlant = false
			game.flags.postPlant = false
			game.flags.postWinCon = true
			game.potentialRound.endDueToBombEvent = true
			game.potentialRound.playerStats[game.potentialRound.planter].impactPoints += 0.5
		}
	})

	p.RegisterEventHandler(func(e events.GrenadeProjectileThrow) {
		//fmt.Println("Grenade Thrown", e.Projectile.WeaponInstance.Type)
		if game.flags.isGameLive {
			if e.Projectile.WeaponInstance.Type == 506 {
				game.potentialRound.playerStats[e.Projectile.Thrower.SteamID64].nadesThrown += 1
			} else if e.Projectile.WeaponInstance.Type == 505 {
				game.potentialRound.playerStats[e.Projectile.Thrower.SteamID64].smokeThrown += 1
			} else if e.Projectile.WeaponInstance.Type == 504 {
				game.potentialRound.playerStats[e.Projectile.Thrower.SteamID64].flashThrown += 1
			} else if e.Projectile.WeaponInstance.Type == 502 || e.Projectile.WeaponInstance.Type == 503 {
				game.potentialRound.playerStats[e.Projectile.Thrower.SteamID64].firesThrown += 1
			}

		}
	})

	p.RegisterEventHandler(func(e events.PlayerTeamChange) {
		fmt.Println("Player Changed Team:", e.Player, e.OldTeam, e.NewTeam)

		if game.flags.isGameLive && game.flags.inRound {
			if e.NewTeam > 1 {
				//we are joining an actual team
				if game.potentialRound.playerStats[e.Player.SteamID64] == nil && e.Player.IsBot && e.Player.IsAlive() {
					//get team
					team := e.NewTeamState
					player := &playerStats{name: e.Player.Name, steamID: e.Player.SteamID64, isBot: e.Player.IsBot, side: int(team.Team()), teamENUM: team.ID(), teamClanName: validateTeamName(game, team.ClanName()), health: 100, tradeList: make(map[uint64]int), damageList: make(map[uint64]int)}
					game.potentialRound.playerStats[player.steamID] = player
				}
			}
		}
	})

	p.RegisterEventHandler(func(e events.PlayerDisconnected) {
		fmt.Println("Player DC", e.Player)

		//update alive players
		if game.flags.isGameLive {
			game.flags.tAlive = 0
			game.flags.ctAlive = 0

			membersT := p.GameState().TeamTerrorists().Members()
			for _, terrorist := range membersT {
				if terrorist.IsAlive() {
					game.flags.tAlive += 1
				}
			}
			membersCT := p.GameState().TeamCounterTerrorists().Members()
			for _, counterTerrorist := range membersCT {
				if counterTerrorist.IsAlive() {
					game.flags.ctAlive += 1
				}
			}
		}

	})

	p.RegisterEventHandler(func(e events.Footstep) {
		if game.flags.isGameLive {
			game.flags.inRound = true
		}

	})

	if printChatLog {
		p.RegisterEventHandler(func(e events.ChatMessage) {
			chatMsg := fmt.Sprintf("%s: \"%s\" at %d\n", e.Sender, e.Text, p.GameState().IngameTick())
			chatFile.WriteString(chatMsg)
			chatFile.Sync()
			//check(err)
		})
	}

	// Parse to end
	err = p.ParseToEnd()
	if err != nil {
		panic(err)
	}

	//----END OF MATCH PROCESSING----
	//we want to iterate through rounds backwards to make sure their are no repeats

	endOfMatchProcessing(game)

	fmt.Println("Demo is complete!")
	//cleanup()

}