domain

var BombPlantedType = graphql.NewObject(graphql.ObjectConfig{
	Name: "BombPlanted",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "BOMB_PLANTED", nil
			},
		},
		"player": &graphql.Field{
			Name: "player",
			Type: PlayerType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(BombPlanted).Player, nil
			},
		},
		"bombsite": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(BombPlanted).Bombsite, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "BOMB_PLANTED"
	},
})

var BombType = graphql.NewObject(graphql.ObjectConfig{
	Name: "bomb",
	Fields: graphql.Fields{
		"lastOnGroundPosition": &graphql.Field{
			Type: PositionType,
		},
		"carrier": &graphql.Field{
			Type: PlayerType,
		},
	},
})

var EquipmentType = graphql.NewObject(graphql.ObjectConfig{
	Name: "equipment",
	Fields: graphql.Fields{
		"type": &graphql.Field{
			Type: graphql.Int,
		},
		"ammoInMagazine": &graphql.Field{
			Type: graphql.Int,
		},
		"ammoReserve": &graphql.Field{
			Type: graphql.Int,
		},
	},
})

var FireExpiredType = graphql.NewObject(graphql.ObjectConfig{
	Name: "FireExpired",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "FIRE_EXPIRED", nil
			},
		},
		"position": &graphql.Field{
			Type: PositionType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(FireExpiredEvent).Position, nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(FireExpiredEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "FIRE_EXPIRED"
	},
})

var FireStartedType = graphql.NewObject(graphql.ObjectConfig{
	Name: "FireStarted",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "FIRE_STARTED", nil
			},
		},
		"position": &graphql.Field{
			Type: PositionType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(FireStartedEvent).Position, nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(FireStartedEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "FIRE_STARTED"
	},
})

var FlashExplosionType = graphql.NewObject(graphql.ObjectConfig{
	Name: "FlashExploded",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "FLASH_EXPLOSION", nil
			},
		},
		"position": &graphql.Field{
			Type: PositionType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(FlashExplosionEvent).Position, nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(FlashExplosionEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "FLASH_EXPLOSION"
	},
})

var GameEventType = graphql.NewUnion(graphql.UnionConfig{
	Name: "AnyGameEvent",
	Types: []*graphql.Object{
		BombPlantedType,
		WeaponFiredType,
		SmokeStartedType,
		SmokeExpiredType,
		FireStartedType,
		FireExpiredType,
		RoundStartedType,
		RoundEndedType,
		MatchStartedEventTpe,
		FlashExplosionType,
		HEExplosionType,
	},
})

var GrenadeProjectileType = graphql.NewObject(graphql.ObjectConfig{
	Name: "Grenade",
	Fields: graphql.Fields{
		"tick": &graphql.Field{
			Type: graphql.Int,
		},
		"thrower": &graphql.Field{
			Type: PlayerType,
		},
		"owner": &graphql.Field{
			Type: PlayerType,
		},
		"position": &graphql.Field{
			Type: PositionType,
		},
		"trajectory": &graphql.Field{
			Type: graphql.NewList(PositionType),
		},
		"weapon": &graphql.Field{
			Type: EquipmentType,
		},
	},
})

var HEExplosionType = graphql.NewObject(graphql.ObjectConfig{
	Name: "HEExploded",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "HE_EXPLOSION", nil
			},
		},
		"position": &graphql.Field{
			Type: PositionType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(HEExplosionEvent).Position, nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(HEExplosionEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "HE_EXPLOSION"
	},
})

var HeaderType = graphql.NewObject(graphql.ObjectConfig{
	Name: "Header",
	Fields: graphql.Fields{
		"mapName": &graphql.Field{
			Type: graphql.String,
		},
		"tickRate": &graphql.Field{
			Type: graphql.Int,
		},
		"fps": &graphql.Field{
			Type: graphql.Int,
		},
	},
})

var InfernoType = graphql.NewObject(graphql.ObjectConfig{
	Name: "Inferno",
	Fields: graphql.Fields{
		"hull": &graphql.Field{
			Type: graphql.NewList(PositionType),
		},
	},
})

var MatchStartedEventTpe = graphql.NewObject(graphql.ObjectConfig{
	Name: "MatchStarted",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "MATCH_STARTED", nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(MatchStartedEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "MATCH_STARTED"
	},
})

var PlayerType = graphql.NewObject(graphql.ObjectConfig{
	Name: "Player",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Type: graphql.String,
		},
		"entityId": &graphql.Field{
			Type: graphql.Int,
		},
		"team": &graphql.Field{
			Type: graphql.Int,
		},
		"position": &graphql.Field{
			Type: PositionType,
		},
		"angleX": &graphql.Field{
			Type: graphql.Float,
		},
		"angleY": &graphql.Field{
			Type: graphql.Float,
		},
		"hp": &graphql.Field{
			Type: graphql.Int,
		},
		"armor": &graphql.Field{
			Type: graphql.Int,
		},
		"flashDuration": &graphql.Field{
			Type: graphql.Float,
		},
		"npc": &graphql.Field{
			Type: graphql.Boolean,
		},
		"hasHelmet": &graphql.Field{
			Type: graphql.Boolean,
		},
		"hasDefuseKit": &graphql.Field{
			Type: graphql.Boolean,
		},
		"equipment": &graphql.Field{
			Type: graphql.NewList(EquipmentType),
		},
		"planting": &graphql.Field{
			Type: graphql.Boolean,
		},
		"defusing": &graphql.Field{
			Type: graphql.Boolean,
		},
		"inBuyzone": &graphql.Field{
			Type: graphql.Boolean,
		},
		"firing": &graphql.Field{
			Type: graphql.Boolean,
		},
		"money": &graphql.Field{
			Type: graphql.Int,
		},
		"kills": &graphql.Field{
			Type: graphql.Int,
		},
		"deaths": &graphql.Field{
			Type: graphql.Int,
		},
	},
})

var PositionType = graphql.NewObject(graphql.ObjectConfig{
	Name: "Position",
	Fields: graphql.Fields{
		"x": &graphql.Field{
			Type: graphql.Float,
		},
		"y": &graphql.Field{
			Type: graphql.Float,
		},
		"z": &graphql.Field{
			Type: graphql.Float,
		},
	},
})

var RoundEndedType = graphql.NewObject(graphql.ObjectConfig{
	Name: "RoundEnded",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "ROUND_ENDED", nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(RoundEndEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "ROUND_ENDED"
	},
})

var RoundStartedType = graphql.NewObject(graphql.ObjectConfig{
	Name: "RoundStarted",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "ROUND_STARTED", nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(RoundStartedEvent).Tick, nil
			},
		},
		"timeLimit": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(RoundStartedEvent).TimeLimit, nil
			},
		},
		"objective": &graphql.Field{
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(RoundStartedEvent).Objective, nil
			},
		},
		"fragLimit": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(RoundStartedEvent).FragLimit, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "ROUND_STARTED"
	},
})

var SmokeExpiredType = graphql.NewObject(graphql.ObjectConfig{
	Name: "SmokeExpired",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "SMOKE_EXPIRED", nil
			},
		},
		"position": &graphql.Field{
			Type: PositionType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(SmokeExpiredEvent).Position, nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(SmokeExpiredEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "SMOKE_EXPIRED"
	},
})

var SmokeStartedType = graphql.NewObject(graphql.ObjectConfig{
	Name: "SmokeStarted",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "SMOKE_STARTED", nil
			},
		},
		"position": &graphql.Field{
			Type: PositionType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(SmokeStartedEvent).Position, nil
			},
		},
		"tick": &graphql.Field{
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				return x.RealEvent.(SmokeStartedEvent).Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "SMOKE_STARTED"
	},
})

var SmokeType = graphql.NewObject(graphql.ObjectConfig{
	Name: "smoke",
	Fields: graphql.Fields{
		"position": &graphql.Field{
			Type: PositionType,
		},
		"id": &graphql.Field{
			Type: graphql.Int,
		},
	},
})

var TickType = graphql.NewObject(graphql.ObjectConfig{
	Name: "Tick",
	Fields: graphql.Fields{
		"tick": &graphql.Field{
			Type: graphql.Int,
		},
		"players": &graphql.Field{
			Type: graphql.NewList(PlayerType),
		},
		"bomb": &graphql.Field{
			Type: BombType,
		},
		"grenades": &graphql.Field{
			Type: graphql.NewList(GrenadeProjectileType),
		},
		"infernos": &graphql.Field{
			Type: graphql.NewList(InfernoType),
		},
		"smokes": &graphql.Field{
			Type: graphql.NewList(SmokeType),
		},
		"totalRoundsPlayed": &graphql.Field{
			Type: graphql.Int,
		},
	},
})

var WeaponFiredType = graphql.NewObject(graphql.ObjectConfig{
	Name: "WeaponFired",
	Fields: graphql.Fields{
		"name": &graphql.Field{
			Name: "name",
			Type: graphql.String,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				return "WEAPON_FIRED", nil
			},
		},
		"shooter": &graphql.Field{
			Name: "shooter",
			Type: PlayerType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				event := x.RealEvent.(WeaponFired)
				return event.Shooter, nil
			},
		},
		"weapon": &graphql.Field{
			Name: "weapon",
			Type: EquipmentType,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				event := x.RealEvent.(WeaponFired)
				return event.Weapon, nil
			},
		},
		"tick": &graphql.Field{
			Name: "tick",
			Type: graphql.Int,
			Resolve: func(p graphql.ResolveParams) (interface{}, error) {
				x := p.Source.(GameEvent)
				event := x.RealEvent.(WeaponFired)
				return event.Tick, nil
			},
		},
	},
	IsTypeOf: func(p graphql.IsTypeOfParams) bool {
		eventName := p.Value.(GameEvent).Name

		return eventName == "WEAPON_FIRED"
	},
})