func getGlobalJotaResolver() *jotaResolver {
globalJotaResolverOnce.Do(func() {
globalJotaResolver = jotaResolver{
cache: make(map[string][]byte),
root: filepath.Join(base.GetDataDir(), "scripts"),
}
})
return &globalJotaResolver
}
func (editor *editorData) saveAction(room *Room) {
data, err := json.MarshalIndent(room, "", " ")
if err != nil {
base.Error().Printf("Unable to encode room to json: %v", err)
return
}
name := fmt.Sprintf("save-%v.json", time.Now())
fullPath := filepath.Join(base.GetDataDir(), name)
err = ioutil.WriteFile(fullPath, data, 0664)
if err != nil {
base.Warn().Printf("Unable to write output json file: %v", err)
return
}
}
func (p *PlayerEnt) Draw(game *Game) {
var t *texture.Data
var alpha gl.Ubyte
if game.local.Side == p.Side() {
alpha = gl.Ubyte(255.0 * (1.0 - p.Stats().Cloaking()/2))
} else {
alpha = gl.Ubyte(255.0 * (1.0 - p.Stats().Cloaking()))
}
gl.Color4ub(255, 255, 255, alpha)
// if p.Id() == 1 {
t = texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ships/ship.png"))
// } else if p.Id() == 2 {
// t = texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ships/ship3.png"))
// } else {
// t = texture.LoadFromPath(filepath.Join(base.GetDataDir(), "ships/ship2.png"))
// }
t.RenderAdvanced(
p.Position.X-float64(t.Dx())/2,
p.Position.Y-float64(t.Dy())/2,
float64(t.Dx()),
float64(t.Dy()),
p.Angle_,
false)
for _, proc := range p.Processes {
proc.Draw(p.Id(), game.local.Gid, game)
}
base.EnableShader("status_bar")
base.SetUniformF("status_bar", "inner", 0.08)
base.SetUniformF("status_bar", "outer", 0.09)
base.SetUniformF("status_bar", "buffer", 0.01)
base.SetUniformF("status_bar", "frac", 1.0)
gl.Color4ub(125, 125, 125, alpha/2)
texture.Render(p.Position.X-100, p.Position.Y-100, 200, 200)
health_frac := float32(p.Stats().HealthCur() / p.Stats().HealthMax())
if health_frac > 0.5 {
color_frac := 1.0 - (health_frac-0.5)*2.0
gl.Color4ub(gl.Ubyte(255.0*color_frac), 255, 0, alpha)
} else {
color_frac := health_frac * 2.0
gl.Color4ub(255, gl.Ubyte(255.0*color_frac), 0, alpha)
}
base.SetUniformF("status_bar", "frac", health_frac)
texture.Render(p.Position.X-100, p.Position.Y-100, 200, 200)
base.EnableShader("")
}
func setupSound() {
soundInit.Do(func() {
var err error
// fmodSys, err = fmod.CreateSystem()
if err != nil {
// base.Error().Fatalf("Unable to initialize fmod: %v", err)
}
// err = fmodSys.Init(2, 0, nil)
if err != nil {
// base.Error().Fatalf("Unable to initialize fmod: %v", err)
}
target := filepath.Join(base.GetDataDir(), "sound/ping.wav")
base.Log().Printf("Trying to load ", target)
// sound, err = fmodSys.CreateSound_FromFilename(target, fmod.MODE_DEFAULT)
if err != nil {
base.Error().Fatalf("Unable to load sound: %v", err)
}
})
}
func MakeGame() *Game {
var g Game
g.Setup = &SetupData{}
g.Setup.Players = make(map[int64]*SetupPlayerData)
// NOTE: Obviously this isn't threadsafe, but I don't intend to be Init()ing
// multiple game objects at the same time.
base.RemoveRegistry("champs")
base.RegisterRegistry("champs", make(map[string]*champ.ChampionDef))
base.RegisterAllObjectsInDir("champs", filepath.Join(base.GetDataDir(), "champs"), ".json", "json")
names := base.GetAllNamesInRegistry("champs")
g.Champs = make([]champ.Champion, len(names))
for i, name := range names {
g.Champs[i].Defname = name
base.GetObject("champs", &g.Champs[i])
base.Log().Printf("Champ %v has %v", name, g.Champs[i].Abilities)
}
return &g
}
func (u SetupComplete) Apply(_g interface{}) {
g := _g.(*Game)
if g.Setup == nil {
return
}
sideCount := make(map[int]int)
// Must have at least two sides
sideCount[0] = 0
sideCount[1] = 0
for _, spd := range g.Setup.Players {
sideCount[spd.Side]++
}
g.Engines = make(map[int64]*PlayerData)
for id, player := range g.Setup.Players {
var gid Gid
if id < 0 {
gid = Gid(fmt.Sprintf("Ai:%d", -id))
} else {
gid = Gid(fmt.Sprintf("Engine:%d", id))
}
g.Engines[id] = &PlayerData{
PlayerGid: Gid(gid),
Side: player.Side,
ChampIndex: player.ChampIndex,
}
}
// Now that we have the information we can set up a lot of the local data for
// this engine's player.
if g.IsPlaying() {
g.local.Side = g.Engines[g.local.Engine.Id()].Side
g.local.Gid = g.Engines[g.local.Engine.Id()].PlayerGid
g.local.Data = g.Engines[g.local.Engine.Id()]
}
var room Room
err := base.LoadJson(filepath.Join(base.GetDataDir(), "rooms/basic.json"), &room)
if err != nil {
base.Error().Fatalf("%v", err)
}
errs := room.Validate()
for _, err := range errs {
base.Error().Printf("%v", err)
}
if len(errs) > 0 {
base.Error().Fatalf("Errors with the level, bailing...")
}
g.Level = &Level{}
g.Level.Room = room
g.Rng = cmwc.MakeGoodCmwc()
g.Rng.Seed(u.Seed)
g.Ents = make(map[Gid]Ent)
g.Friction = 0.97
g.losCache = makeLosCache(g.Level.Room.Dx, g.Level.Room.Dy)
sides := make(map[int][]int64)
var playerDatas []*PlayerData
base.DoOrdered(g.Engines, func(a, b int64) bool { return a < b }, func(id int64, data *PlayerData) {
sides[data.Side] = append(sides[data.Side], id)
playerDatas = append(playerDatas, data)
})
for id, ed := range g.Engines {
base.Log().Printf("%v -> %v", id, *ed)
}
g.AddPlayers(playerDatas)
g.MakeControlPoints()
g.Init()
base.Log().Printf("Nillifying g.Setup()")
g.Setup = nil
}