// newLevel creates the indicated game level.
func newLevel(g *game, levelNum int) *level {
var levelType = map[int]grid.Grid{
0: grid.New(grid.DENSE_SKIRMISH),
1: grid.New(grid.DENSE_SKIRMISH),
2: grid.New(grid.SPARSE_SKIRMISH),
3: grid.New(grid.ROOMS_SKIRMISH),
4: grid.New(grid.ROOMS_SKIRMISH),
}
// initialize the scenes.
lvl := &level{}
lvl.fade = g.vr * 0.7
lvl.units = 2
lvl.colour = 1.0
lvl.fov = 75
lvl.root = g.mp.eng.Root().NewPov()
lvl.view = lvl.root.NewView()
lvl.view.SetCull(vu.NewFrontCull(g.vr))
lvl.cam = lvl.view.Cam()
lvl.cam.SetPerspective(lvl.fov, float64(g.ww)/float64(g.wh), 0.1, 50)
// save everything as one game stage.
lvl.mp = g.mp
lvl.num = levelNum
// create hud before player since player is drawn within hd.scene.
s := g.mp.eng.State()
lvl.hd = newHud(g.mp.eng, gameMuster[lvl.num], s.X, s.Y, s.W, s.H)
lvl.player = lvl.makePlayer(lvl.hd.root, lvl.num+1)
lvl.makeSentries(lvl.root, lvl.num)
// create one large floor.
lvl.floor = lvl.root.NewPov().SetLocation(0, 0.2, 0)
// create a new layout for the stage.
plan := levelType[lvl.num]
levelSize := gameMapSize(lvl.num)
plan.Generate(levelSize, levelSize)
// build and populate the floorplan
lvl.walls = []vu.Pov{}
lvl.cc = newCoreControl(lvl.units, g.mp.ani)
lvl.buildFloorPlan(lvl.root, lvl.hd, plan)
lvl.plan = plan
// set the intial player location.
lvl.body = lvl.root.NewPov().SetLocation(4, 0.5, 10)
// start sentinels at the center of the stage.
for _, sentry := range lvl.sentries {
sentry.setGridLocation(lvl.gcx, lvl.gcy)
}
lvl.player.resetEnergy()
lvl.setVisible(false)
return lvl
}
// Create is the engine callback for initial asset creation.
func (ff *fftag) Create(eng vu.Eng, s *vu.State) {
rand.Seed(time.Now().UTC().UnixNano())
// create the overlay
ff.top = eng.Root().NewPov()
view := ff.top.NewView()
view.SetUI()
ff.cam = view.Cam()
ff.mmap = ff.top.NewPov().SetScale(10, 10, 0)
ff.mmap.SetLocation(30, 30, 0)
// populate the map
ff.msize = 69
ff.plan = grid.New(grid.ROOMS_SKIRMISH)
ff.plan.Generate(ff.msize, ff.msize)
width, height := ff.plan.Size()
for x := 0; x < width; x++ {
for y := 0; y < height; y++ {
if ff.plan.IsOpen(x, y) {
block := ff.mmap.NewPov()
block.SetLocation(float64(x), float64(y), 0)
block.NewModel("uv").LoadMesh("icon").AddTex("wall")
ff.spots = append(ff.spots, ff.id(x, y))
}
}
}
// populate chasers and a goal.
numChasers := 30
for cnt := 0; cnt < numChasers; cnt++ {
chaser := ff.mmap.NewPov()
chaser.NewModel("uv").LoadMesh("icon").AddTex("token")
ff.chasers = append(ff.chasers, chaser)
}
ff.goal = ff.mmap.NewPov()
ff.goal.NewModel("uv").LoadMesh("icon").AddTex("goal")
ff.flow = grid.NewFlow(ff.plan) // flow field for the given plan.
ff.resetLocations()
// set non default engine state.
eng.SetColor(0.15, 0.15, 0.15, 1)
ff.resize(s.W, s.H)
}
// setLevel switches to the indicated level.
func (rl *rltag) setLevel(eng vu.Eng, keyCode int) {
if _, ok := rl.floors[keyCode]; !ok {
var gridSizes = map[int]int{
vu.K_1: 15,
vu.K_2: 21,
vu.K_3: 27,
vu.K_4: 33,
vu.K_5: 39,
vu.K_6: 45,
vu.K_7: 51,
vu.K_8: 57,
vu.K_9: 63,
vu.K_0: 69,
}
var gridType = map[int]grid.Grid{
vu.K_1: grid.New(grid.DENSE_SKIRMISH),
vu.K_2: grid.New(grid.DENSE_SKIRMISH),
vu.K_3: grid.New(grid.SPARSE_SKIRMISH),
vu.K_4: grid.New(grid.SPARSE_SKIRMISH),
vu.K_5: grid.New(grid.ROOMS_SKIRMISH),
vu.K_6: grid.New(grid.ROOMS_SKIRMISH),
vu.K_7: grid.New(grid.CAVE),
vu.K_8: grid.New(grid.CAVE),
vu.K_9: grid.New(grid.DUNGEON),
vu.K_0: grid.New(grid.DUNGEON),
}
flr := &floor{}
// create the scene
flr.top = eng.Root().NewPov()
flr.plan = flr.top.NewPov()
flr.cam = flr.plan.NewCam()
flr.cam.SetLocation(1, 0, -1)
flr.cam.SetPerspective(60, float64(rl.ww)/float64(rl.wh), 0.1, 50)
flr.cam.SetCull(vu.NewFrontCull(10))
// create the overlay
flr.mmap = flr.top.NewPov()
flr.ui = flr.mmap.NewCam()
flr.ui.SetUI()
flr.ui.SetView(vu.XZ_XY)
flr.ui.SetOrthographic(0, float64(rl.ww), 0, float64(rl.wh), 0, 20)
flr.mapPart = flr.mmap.NewPov()
flr.mapPart.SetScale(7.5, 7.5, 7.5)
flr.mapPart.SetLocation(20, 0, -20)
// display some rendering statistics.
flr.modelStats = rl.newText(flr.mmap, 0)
flr.vertexStats = rl.newText(flr.mmap, 1)
flr.times = rl.newText(flr.mmap, 2)
// populate the scenes
lsize := gridSizes[keyCode]
flr.layout = gridType[keyCode]
flr.layout.Generate(lsize, lsize)
width, height := flr.layout.Size()
for x := 0; x < width; x++ {
for y := 0; y < height; y++ {
if flr.layout.IsOpen(x, y) {
block := flr.mapPart.NewPov().SetLocation(float64(x), 0, float64(-y))
block.NewModel("alpha").LoadMesh("cube").LoadMat("transparent_gray")
} else {
block := flr.plan.NewPov().SetLocation(float64(x), 0, float64(-y))
block.NewModel("uv").LoadMesh("box").AddTex("tile")
}
}
}
flr.arrow = flr.mapPart.NewPov().SetLocation(flr.cam.Location())
flr.arrow.NewModel("solid").LoadMesh("arrow").LoadMat("transparent_blue")
rl.floors[keyCode] = flr
}
if rl.flr != nil {
rl.flr.plan.SetVisible(false)
rl.flr.mmap.SetVisible(false)
}
rl.flr = rl.floors[keyCode]
rl.flr.plan.SetVisible(true)
rl.flr.mmap.SetVisible(true)
rl.arrow = rl.flr.arrow
}