Пример #1
0
func (a *Move) AiMoveToPos(ent *game.Entity, dst []int, max_ap int) game.ActionExec {
	base.Log().Printf("PATH: Request move to %v", dst)
	graph := ent.Game().Graph(ent.Side(), false, nil)
	src := []int{ent.Game().ToVertex(ent.Pos())}
	_, path := algorithm.Dijkstra(graph, src, dst)
	base.Log().Printf("PATH: Found path of length %d", len(path))
	ppx, ppy := ent.Pos()
	if path == nil {
		return nil
	}
	_, xx, yy := ent.Game().FromVertex(path[len(path)-1])
	base.Log().Printf("PATH: %d,%d -> %d,%d", ppx, ppy, xx, yy)
	if ent.Stats.ApCur() < max_ap {
		max_ap = ent.Stats.ApCur()
	}
	path = limitPath(ent, src[0], path, max_ap)
	_, xx, yy = ent.Game().FromVertex(path[len(path)-1])
	base.Log().Printf("PATH: (limited) %d,%d -> %d,%d", ppx, ppy, xx, yy)
	if len(path) <= 1 {
		return nil
	}
	var exec moveExec
	exec.SetBasicData(ent, a)
	exec.Path = path
	return &exec
}
Пример #2
0
func (exec *moveExec) measureCost(ent *game.Entity, g *game.Game) int {
	if len(exec.Path) == 0 {
		base.Error().Printf("Zero length path")
		return -1
	}
	if g.ToVertex(ent.Pos()) != exec.Path[0] {
		base.Error().Printf("Path doesn't begin at ent's position, %d != %d", g.ToVertex(ent.Pos()), exec.Path[0])
		return -1
	}
	graph := g.Graph(ent.Side(), true, nil)
	v := g.ToVertex(ent.Pos())
	cost := 0
	for _, step := range exec.Path[1:] {
		dsts, costs := graph.Adjacent(v)
		ok := false
		prev := v
		base.Log().Printf("Adj(%d):", v)
		for j := range dsts {
			base.Log().Printf("Node %d", dsts[j])
			if dsts[j] == step {
				cost += int(costs[j])
				v = dsts[j]
				ok = true
				break
			}
		}
		base.Log().Printf("%d -> %d: %t", prev, v, ok)
		if !ok {
			return -1
		}
	}
	return cost
}
Пример #3
0
func loadHouse(gp *GamePanel) lua.GoFunction {
	return func(L *lua.State) int {
		if !LuaCheckParamsOk(L, "LoadHouse", LuaString) {
			return 0
		}
		gp.script.syncStart()
		defer gp.script.syncEnd()

		name := L.ToString(-1)
		def := house.MakeHouseFromName(name)
		if def == nil || len(def.Floors) == 0 {
			base.Error().Printf("No house exists with the name '%s'.", name)
			return 0
		}
		gp.game = makeGame(def)
		gp.game.viewer.Edit_mode = true
		gp.game.script = gp.script
		base.Log().Printf("script = %p", gp.game.script)

		gp.AnchorBox = gui.MakeAnchorBox(gui.Dims{1024, 768})
		gp.AnchorBox.AddChild(gp.game.viewer, gui.Anchor{0.5, 0.5, 0.5, 0.5})
		gp.AnchorBox.AddChild(MakeOverlay(gp.game), gui.Anchor{0.5, 0.5, 0.5, 0.5})

		base.Log().Printf("Done making stuff")
		return 0
	}
}
Пример #4
0
// Performs a move action to the closest one of any of the specifed inputs
// points.  The movement can be restricted to not spend more than a certain
// amount of ap.
//    Format:
//    success, p = DoMove(dsts, max_ap)
//
//    Input:
//    dsts  - array[table[x,y]] - Array of all points that are acceptable
//                                destinations.
//    max_ap - integer - Maxmium ap to spend while doing this move, if the
//                       required ap exceeds this the entity will still move
//                       as far as possible towards a destination.
//
//    Output:
//    success = bool - True iff the move made it to a position in dsts.
//    p - table[x,y] - New position of this entity, or nil if the move failed.
func DoMoveFunc(a *Ai) lua.GoFunction {
	return func(L *lua.State) int {
		if !game.LuaCheckParamsOk(L, "DoMove", game.LuaArray, game.LuaInteger) {
			return 0
		}
		me := a.ent
		max_ap := L.ToInteger(-1)
		L.Pop(1)
		cur_ap := me.Stats.ApCur()
		if max_ap > cur_ap {
			max_ap = cur_ap
		}
		n := int(L.ObjLen(-1))
		dsts := make([]int, n)[0:0]
		for i := 1; i <= n; i++ {
			L.PushInteger(i)
			L.GetTable(-2)
			x, y := game.LuaToPoint(L, -1)
			dsts = append(dsts, me.Game().ToVertex(x, y))
			L.Pop(1)
		}
		var move *actions.Move
		var ok bool
		for i := range me.Actions {
			move, ok = me.Actions[i].(*actions.Move)
			if ok {
				break
			}
		}
		if !ok {
			// TODO: what to do here?  This poor guy didn't have a move action :(
			L.PushNil()
			L.PushNil()
			return 2
		}
		exec := move.AiMoveToPos(me, dsts, max_ap)
		if exec != nil {
			a.execs <- exec
			<-a.pause
			// TODO: Need to get a resolution
			x, y := me.Pos()
			v := me.Game().ToVertex(x, y)
			complete := false
			for i := range dsts {
				if v == dsts[i] {
					complete = true
					break
				}
			}
			L.PushBoolean(complete)
			game.LuaPushPoint(L, x, y)
			base.Log().Printf("Finished move")
		} else {
			base.Log().Printf("Didn't bother moving")
			L.PushBoolean(true)
			L.PushNil()
		}
		return 2
	}
}
Пример #5
0
func (a *AoeAttack) AiAttackPosition(ent *game.Entity, x, y int) game.ActionExec {
	if !ent.HasLos(x, y, 1, 1) {
		base.Log().Printf("Don't have los")
		return nil
	}
	if a.Ap > ent.Stats.ApCur() {
		base.Log().Printf("Don't have the ap")
		return nil
	}
	var exec aoeExec
	exec.SetBasicData(ent, a)
	exec.X, exec.Y = x, y
	return &exec
}
Пример #6
0
// Returns an array of all points that can be reached by walking from a
// specific location that end in a certain general area.  Assumes that a 1x1
// unit is doing the walking.
//    Format:
//    points = AllPathablePoints(src, dst, min, max)
//
//    Inputs:
//    src - table[x,y] - Where the path starts.
//    dst - table[x,y] - Another point near where the path should go.
//    min - integer    - Minimum distance from dst that the path should end at.
//    max - integer    - Maximum distance from dst that the path should end at.
//
//    Outputs:
//    points - array[table[x,y]]
func AllPathablePointsFunc(a *Ai) lua.GoFunction {
	return func(L *lua.State) int {
		if !game.LuaCheckParamsOk(L, "AllPathablePoints", game.LuaPoint, game.LuaPoint, game.LuaInteger, game.LuaInteger) {
			return 0
		}
		min := L.ToInteger(-2)
		max := L.ToInteger(-1)
		x1, y1 := game.LuaToPoint(L, -4)
		x2, y2 := game.LuaToPoint(L, -3)

		a.ent.Game().DetermineLos(x2, y2, max, grid)
		var dst []int
		for x := x2 - max; x <= x2+max; x++ {
			for y := y2 - max; y <= y2+max; y++ {
				if x > x2-min && x < x2+min && y > y2-min && y < y2+min {
					continue
				}
				if x < 0 || y < 0 || x >= len(grid) || y >= len(grid[0]) {
					continue
				}
				if !grid[x][y] {
					continue
				}
				dst = append(dst, a.ent.Game().ToVertex(x, y))
			}
		}
		vis := 0
		for i := range grid {
			for j := range grid[i] {
				if grid[i][j] {
					vis++
				}
			}
		}
		base.Log().Printf("Visible: %d", vis)
		graph := a.ent.Game().Graph(a.ent.Side(), true, nil)
		src := []int{a.ent.Game().ToVertex(x1, y1)}
		reachable := algorithm.ReachableDestinations(graph, src, dst)
		L.NewTable()
		base.Log().Printf("%d/%d reachable from (%d, %d) -> (%d, %d)", len(reachable), len(dst), x1, y1, x2, y2)
		for i, v := range reachable {
			_, x, y := a.ent.Game().FromVertex(v)
			L.PushInteger(i + 1)
			game.LuaPushPoint(L, x, y)
			L.SetTable(-3)
		}
		return 1
	}
}
Пример #7
0
// Need a goroutine for each ai - all things will go through is so that things
// stay synchronized
func (a *Ai) masterRoutine() {
	for {
		select {
		case <-a.terminate:
			if a.watcher != nil {
				a.watcher.Close()
			}
			close(a.active_query)
			return

		case a.active = <-a.active_set:
			if a.active == false {
				if a.ent == nil {
					base.Log().Printf("Evaluating = false")
				} else {
					base.Log().Printf("Ent %p inactivated", a.ent)
				}
				a.evaluating = false
			}

		case a.active_query <- a.active:

		case <-a.exec_query:
			if a.active {
				select {
				case a.pause <- struct{}{}:
				default:
				}
			}
			if a.active && !a.evaluating {
				a.evaluating = true
				go func() {
					if a.ent == nil {
						base.Log().Printf("Eval master")
					} else {
						base.Log().Printf("Eval ent: %p", a.ent)
					}
					base.Log().Printf("Evaluating lua script: %s", a.Prog)
					// Reset the execution limit in case it was set to 0 due to a
					// previous error
					a.L.SetExecutionLimit(2500000)

					// DoString will panic, and we can catch that, calling it manually
					// will exit() if it fails, which we cannot catch
					a.L.DoString("Think()")
					if a.ent == nil {
						base.Log().Printf("Completed master")
					} else {
						base.Log().Printf("Completed ent: %p", a.ent)
					}
					a.active_set <- false
					a.execs <- nil
					base.Log().Printf("Sent nil value")
				}()
			}
		}
	}
}
Пример #8
0
// Returns true iff the position specified is a valid position to click in the
// text area.  Also sets everything up so that if te.Entry.entering can be set
// to true to begin editing at that position.
func (te *TextEntry) setCursor(mx, my int) bool {
	if !pointInsideRect(mx, my, te.Entry.bounds.x, te.Entry.bounds.y, te.Entry.bounds.dx, te.Entry.bounds.dy) {
		te.Entry.ghost.offset = -1
		return false
	}

	d := base.GetDictionary(te.Button.Text.Size)
	last_dx := 0
	base.Log().Printf("Inside")
	te.Entry.ghost.index = -1
	for i := range te.Entry.text {
		w := int(d.StringWidth(te.Entry.text[0 : i+1]))
		avg := (last_dx + w) / 2
		if pointInsideRect(mx, my, te.Entry.bounds.x, te.Entry.bounds.y, avg, te.Entry.bounds.dy) {
			te.Entry.ghost.offset = last_dx
			te.Entry.ghost.index = i
			break
		}
		last_dx = w
	}
	if te.Entry.ghost.index < 0 {
		te.Entry.ghost.offset = int(d.StringWidth(te.Entry.text))
		te.Entry.ghost.index = len(te.Entry.text)
	}
	return true
}
Пример #9
0
func (b *Button) RenderAt(x, y int) {
	gl.Color4ub(255, 255, 255, byte(b.shade*255))
	if b.Texture.Path != "" {
		b.Texture.Data().RenderNatural(b.X+x, b.Y+y)
		b.bounds.x = b.X + x
		b.bounds.y = b.Y + y
		b.bounds.dx = b.Texture.Data().Dx()
		b.bounds.dy = b.Texture.Data().Dy()
	} else {
		d := base.GetDictionary(b.Text.Size)
		b.bounds.x = b.X + x
		b.bounds.y = b.Y + y
		b.bounds.dx = int(d.StringWidth(b.Text.String))
		b.bounds.dy = int(d.MaxHeight())
		base.Log().Printf("Button '%s' @ %d %d %d %d", b.Text.String, b.bounds.x, b.bounds.y, b.bounds.dx, b.bounds.dy)
		var just gui.Justification
		switch b.Text.Justification {
		case "center":
			just = gui.Center
			b.bounds.x -= b.bounds.dx / 2
		case "left":
			just = gui.Left
		case "right":
			just = gui.Right
			b.bounds.x -= b.bounds.dx
		default:
			just = gui.Center
			b.bounds.x -= b.bounds.dx / 2
			b.Text.Justification = "center"
			base.Warn().Printf("Failed to indicate valid aligmnent, '%s' is not valid.", b.Text.Justification)
		}
		d.RenderString(b.Text.String, float64(b.X+x), float64(b.Y+y), 0, d.MaxHeight(), just)
	}
}
Пример #10
0
func execMinionFunc(a *Ai) lua.GoFunction {
	return func(L *lua.State) int {
		base.Log().Printf("Exec minion")
		if !game.LuaNumParamsOk(L, 1, "execMinion") {
			return 0
		}
		ent := game.LuaToEntity(L, a.game, -1)
		if ent == nil {
			game.LuaDoError(L, "Tried to execMinion entity which doesn't exist.")
			return 0
		}
		if ent.HauntEnt == nil || ent.HauntEnt.Level != game.LevelMinion {
			game.LuaDoError(L, fmt.Sprintf("Tried to execMinion entity with Id=%d, which is not a minion.", ent.Id))
			return 0
		}
		if !ent.Ai.Active() {
			game.LuaDoError(L, fmt.Sprintf("Tried to execMinion entity with Id=%d, which is not active.", ent.Id))
			return 0
		}
		exec := <-ent.Ai.ActionExecs()
		if exec != nil {
			a.execs <- exec
		}
		<-a.pause
		return 0
	}
}
Пример #11
0
func InsertVersusMenu(ui gui.WidgetParent, replace func(gui.WidgetParent) error) error {
	// return doChooserMenu(ui, makeChooseVersusMetaMenu, replace, inserter(insertGoalMenu))
	chooser, done, err := makeChooseVersusMetaMenu()
	if err != nil {
		return err
	}
	ui.AddChild(chooser)
	go func() {
		m := <-done
		ui.RemoveChild(chooser)
		if m != nil && len(m) == 1 {
			base.Log().Printf("Chose: %v", m)
			switch m[0] {
			case "Select House":
				ui.AddChild(MakeGamePanel("versus/basic.lua", nil, map[string]string{"map": "select"}, ""))
			case "Random House":
				ui.AddChild(MakeGamePanel("versus/basic.lua", nil, map[string]string{"map": "random"}, ""))
			case "Continue":
				ui.AddChild(MakeGamePanel("versus/basic.lua", nil, map[string]string{"map": "continue"}, ""))
			default:
				base.Error().Printf("Unknown meta choice '%s'", m[0])
				return
			}
		} else {
			err := replace(ui)
			if err != nil {
				base.Error().Printf("Error replacing menu: %v", err)
			}
		}
	}()
	return nil
}
Пример #12
0
// Distributes the ents among the spawn points.  Since this is done randomly
// it might not work, so there is a very small chance that not all spawns will
// have an ent given to them, even if it is possible to distrbiute them
// properly.  Regardless, at least some will be spawned.
func spawnEnts(g *Game, ents []*Entity, spawns []*house.SpawnPoint) {
	sort.Sort(orderSpawnsSmallToBig(spawns))
	sanity := 100
	var places []entSpawnPair
	for sanity > 0 {
		sanity--
		places = places[0:0]
		sort.Sort(orderEntsBigToSmall(ents))
		//slightly shuffle the ents
		for i := range ents {
			j := i + rand.Intn(5) - 2
			if j >= 0 && j < len(ents) {
				ents[i], ents[j] = ents[j], ents[i]
			}
		}
		// Go through each ent and try to place it in an unused spawn point
		used_spawns := make(map[*house.SpawnPoint]bool)
		for _, ent := range ents {
			for _, spawn := range spawns {
				if used_spawns[spawn] {
					continue
				}
				if spawn.Dx < ent.Dx || spawn.Dy < ent.Dy {
					continue
				}
				used_spawns[spawn] = true
				places = append(places, entSpawnPair{ent, spawn})
				break
			}
		}
		if len(places) == len(spawns) {
			break
		}
	}
	if sanity > 0 {
		base.Log().Printf("Placed all objects with %d sanity remaining", sanity)
	} else {
		base.Warn().Printf("Only able to place %d out of %d objects", len(places), len(spawns))
	}
	for _, place := range places {
		place.ent.X = float64(place.spawn.X + rand.Intn(place.spawn.Dx-place.ent.Dx+1))
		place.ent.Y = float64(place.spawn.Y + rand.Intn(place.spawn.Dy-place.ent.Dy+1))
		g.viewer.AddDrawable(place.ent)
		g.Ents = append(g.Ents, place.ent)
		base.Log().Printf("Using object '%s' at (%.0f, %.0f)", place.ent.Name, place.ent.X, place.ent.Y)
	}
}
Пример #13
0
// Decodes a value from the reader and pushes it onto the stack
func LuaDecodeValue(r io.Reader, L *lua.State, g *Game) error {
	var le luaEncodable
	err := binary.Read(r, binary.LittleEndian, &le)
	if err != nil {
		return err
	}
	switch le {
	case luaEncBool:
		var v byte
		err = binary.Read(r, binary.LittleEndian, &v)
		L.PushBoolean(v == 1)
	case luaEncNumber:
		var f float64
		err = binary.Read(r, binary.LittleEndian, &f)
		L.PushNumber(f)
	case luaEncNil:
		L.PushNil()
	case luaEncEntity:
		var id uint64
		err = binary.Read(r, binary.LittleEndian, &id)
		ent := g.EntityById(EntityId(id))
		LuaPushEntity(L, ent)
		if ent != nil {
			base.Log().Printf("LUA: Push Ent %s", ent.Name)
		} else {
			base.Log().Printf("LUA: Push Ent NIL")
		}
	case luaEncTable:
		err = LuaDecodeTable(r, L, g)
	case luaEncString:
		var length uint32
		err = binary.Read(r, binary.LittleEndian, &length)
		if err != nil {
			return err
		}
		sb := make([]byte, length)
		err = binary.Read(r, binary.LittleEndian, &sb)
		L.PushString(string(sb))
	default:
		return errors.New(fmt.Sprintf("Unknown lua value id == %d.", le))
	}
	if err != nil {
		return err
	}
	return nil
}
Пример #14
0
func (e *Entity) LoadAi() {
	filename := e.Ai_path.String()
	if e.Ai_file_override != "" {
		filename = e.Ai_file_override.String()
	}
	if filename == "" {
		base.Log().Printf("No ai for %s", e.Name)
		e.Ai = inactiveAi{}
		return
	}
	ai_maker(filename, e.Game(), e, &e.Ai, EntityAi)
	if e.Ai == nil {
		e.Ai = inactiveAi{}
		base.Log().Printf("Failed to make Ai for '%s' with %s", e.Name, filename)
	} else {
		base.Log().Printf("Made Ai for '%s' with %s", e.Name, filename)
	}
}
Пример #15
0
func (a *Ai) Activate() {
	if a.ent != nil {
		base.Log().Printf("Activated entity: %v", a.ent.Name)
	}
	reload := false
	for {
		select {
		case <-a.watcher.Event:
			reload = true
		default:
			goto no_more_events
		}
	}
no_more_events:
	if reload {
		a.setupLuaState()
		base.Log().Printf("Reloaded lua state for '%p'", a)
	}
	a.active_set <- true
}
Пример #16
0
func (g *Game) checkWinConditions() {
	return
	// Check for explorer win conditions
	explorer_win := false

	if explorer_win {
		base.Log().Printf("Explorers won - kaboom")
	}

	// Check for haunt win condition - all intruders dead
	haunts_win := true
	for i := range g.Ents {
		if g.Ents[i].Side() == SideExplorers {
			haunts_win = false
		}
	}
	if haunts_win {
		base.Log().Printf("Haunts won - kaboom")
	}
}
Пример #17
0
// Ripped from game/ai/ai.go - should probably sync up with it
func registerUtilityFunctions(L *lua.State) {
	L.Register("print", func(L *lua.State) int {
		var res string
		n := L.GetTop()
		for i := -n; i < 0; i++ {
			res += LuaStringifyParam(L, i) + " "
		}
		base.Log().Printf("GameScript(%p): %s", L, res)
		return 0
	})
}
Пример #18
0
func (g *Game) setup() {
	g.gameDataTransient.alloc()
	g.all_ents_in_game = make(map[*Entity]bool)
	g.all_ents_in_memory = make(map[*Entity]bool)
	for i := range g.Ents {
		base.Log().Printf("Ungob, ent: %p", g.Ents[i])
		if g.Ents[i].Side() == g.Side {
			base.Log().Printf("Ungob, ent: %p", g.Ents[i])
			g.UpdateEntLos(g.Ents[i], true)
		}
	}
	if g.Side == SideHaunt {
		g.viewer.Los_tex = g.los.intruders.tex
	} else {
		g.viewer.Los_tex = g.los.denizens.tex
	}

	g.Ai.minions = inactiveAi{}
	g.Ai.denizens = inactiveAi{}
	g.Ai.intruders = inactiveAi{}
}
Пример #19
0
func (e *Entity) LoadAi() {
  filename := e.Ai_file_override.String()
  if filename == "" {
    e.Ai = inactiveAi{}
    return
  }
  ai_maker(filename, e.Game(), e, &e.Ai, EntityAi)
  base.Log().Printf("Made Ai for '%s'", e.Name)
  if e.Ai == nil {
    e.Ai = inactiveAi{}
  }
}
Пример #20
0
func (a *Move) Maintain(dt int64, g *game.Game, ae game.ActionExec) game.MaintenanceStatus {
	if ae != nil {
		exec := ae.(*moveExec)
		a.ent = g.EntityById(ae.EntityId())
		if len(exec.Path) == 0 {
			base.Error().Printf("Got a move exec with a path length of 0: %v", exec)
			return game.Complete
		}
		a.cost = exec.measureCost(a.ent, g)
		if a.cost > a.ent.Stats.ApCur() {
			base.Error().Printf("Got a move that required more ap than available: %v", exec)
			base.Error().Printf("Path: %v", exec.Path)
			return game.Complete
		}
		if a.cost == -1 {
			base.Error().Printf("Got a move that followed an invalid path: %v", exec)
			base.Error().Printf("Path: %v", exec.Path)
			if a.ent == nil {
				base.Error().Printf("ENT was Nil!")
			} else {
				x, y := a.ent.Pos()
				v := g.ToVertex(x, y)
				base.Error().Printf("Ent pos: (%d, %d) -> (%d)", x, y, v)
			}
			return game.Complete
		}
		algorithm.Map2(exec.Path, &a.path, func(v int) [2]int {
			_, x, y := g.FromVertex(v)
			return [2]int{x, y}
		})
		base.Log().Printf("Path Validated: %v", exec)
		a.ent.Stats.ApplyDamage(-a.cost, 0, status.Unspecified)
		src := g.ToVertex(a.ent.Pos())
		graph := g.Graph(a.ent.Side(), true, nil)
		a.drawPath(a.ent, g, graph, src)
	}
	// Do stuff
	factor := float32(math.Pow(2, a.ent.Walking_speed))
	dist := a.ent.DoAdvance(factor*float32(dt)/200, a.path[0][0], a.path[0][1])
	for dist > 0 {
		if len(a.path) == 1 {
			a.ent.DoAdvance(0, 0, 0)
			a.ent.Info.RoomsExplored[a.ent.CurrentRoom()] = true
			a.ent = nil
			return game.Complete
		}
		a.path = a.path[1:]
		a.ent.Info.RoomsExplored[a.ent.CurrentRoom()] = true
		dist = a.ent.DoAdvance(dist, a.path[0][0], a.path[0][1])
	}
	return game.InProgress
}
Пример #21
0
func (rc *RosterChooser) Respond(ui *gui.Gui, group gui.EventGroup) bool {
	base.Log().Printf("RosterChooser.Respond")
	if found, event := group.FindEvent('l'); found && event.Type == gin.Press {
		rc.focus += rc.layout.Num_options
		return true
	}
	if found, event := group.FindEvent('o'); found && event.Type == gin.Press {
		rc.focus -= rc.layout.Num_options
		return true
	}
	if found, event := group.FindEvent(gin.MouseLButton); found && event.Type == gin.Press {
		x, y := event.Key.Cursor().Point()
		gp := gui.Point{x, y}
		if gp.Inside(rc.render.down) {
			rc.focus += rc.layout.Num_options
			return true
		} else if gp.Inside(rc.render.up) {
			rc.focus -= rc.layout.Num_options
			return true
		} else if gp.Inside(rc.render.all_options) {
			for i := range rc.render.options {
				if gp.Inside(rc.render.options[i]) {
					rc.selector(i, rc.selected, true)
					return true
				}
			}
		} else if gp.Inside(rc.render.done) {
			if rc.selector(-1, rc.selected, false) {
				base.Log().Printf("calling on-complete")
				rc.on_complete(rc.selected)
			}
			return true
		} else if rc.on_undo != nil && gp.Inside(rc.render.undo) {
			rc.on_undo()
			return true
		}
	}
	return false
}
Пример #22
0
func MakeGamePanel(script string, p *Player, data map[string]string, game_key mrgnet.GameKey) *GamePanel {
	var gp GamePanel
	gp.AnchorBox = gui.MakeAnchorBox(gui.Dims{1024, 768})
	if p == nil {
		p = &Player{}
	}
	base.Log().Printf("Script path: %s / %s", script, p.Script_path)
	if script == "" {
		script = p.Script_path
	}
	startGameScript(&gp, script, p, data, game_key)
	return &gp
}
Пример #23
0
func doExec(gp *GamePanel) lua.GoFunction {
	return func(L *lua.State) int {
		if !LuaCheckParamsOk(L, "DoExec", LuaTable) {
			return 0
		}
		L.PushString("__encoded")
		L.GetTable(-2)
		str := L.ToString(-1)
		L.Pop(1)
		var execs []ActionExec
		base.Log().Printf("Decoding from: '%s'", str)
		err := base.FromBase64FromGob(&execs, str)
		if err != nil {
			base.Error().Printf("Error decoding exec: %v", err)
			return 0
		}
		if len(execs) != 1 {
			base.Error().Printf("Error decoding exec: Found %d execs instead of exactly 1.", len(execs))
			return 0
		}
		base.Log().Printf("ScriptComm: Exec: %v", execs[0])
		gp.game.comm.script_to_game <- execs[0]
		base.Log().Printf("ScriptComm: Sent exec")
		<-gp.game.comm.game_to_script
		base.Log().Printf("ScriptComm: exec done")
		done := make(chan bool)
		gp.script.syncStart()
		go func() {
			for i := range gp.game.Ents {
				gp.game.Ents[i].Sprite().Wait([]string{"ready", "killed"})
			}
			done <- true
		}()
		gp.script.syncEnd()
		<-done
		return 0
	}
}
Пример #24
0
func dialogBox(gp *GamePanel) lua.GoFunction {
	return func(L *lua.State) int {
		if L.GetTop() == 1 {
			if !LuaCheckParamsOk(L, "DialogBox", LuaString) {
				return 0
			}
		} else {
			if !LuaCheckParamsOk(L, "DialogBox", LuaString, LuaTable) {
				return 0
			}
		}
		gp.script.syncStart()
		defer gp.script.syncEnd()
		path := L.ToString(1)
		var args map[string]string
		if L.GetTop() > 1 {
			args = make(map[string]string)
			L.PushValue(2)
			L.PushNil()
			for L.Next(-2) != 0 {
				args[L.ToString(-2)] = L.ToString(-1)
				L.Pop(1)
			}
			L.Pop(1)
		}
		box, output, err := MakeDialogBox(filepath.ToSlash(path), args)
		if err != nil {
			base.Error().Printf("Error making dialog: %v", err)
			return 0
		}
		gp.AnchorBox.AddChild(box, gui.Anchor{0.5, 0.5, 0.5, 0.5})
		gp.script.syncEnd()

		var choices []string
		for choice := range output {
			choices = append(choices, choice)
		}
		base.Log().Printf("Dialog box press: %v", choices)

		gp.script.syncStart()
		gp.AnchorBox.RemoveChild(box)
		L.NewTable()
		for i, choice := range choices {
			L.PushInteger(i + 1)
			L.PushString(choice)
			L.SetTable(-3)
		}
		return 1
	}
}
Пример #25
0
func (he *HouseEditor) Load(path string) error {
	house, err := MakeHouseFromPath(path)
	if err != nil {
		return err
	}
	base.Log().Printf("Loaded %s\n", path)
	house.Normalize()
	he.house = *house
	he.viewer.SetBounds()
	for _, tab := range he.widgets {
		tab.Reload()
	}
	return err
}
Пример #26
0
func MakeUiSelectMap(gp *GamePanel) (gui.Widget, <-chan string, error) {
	var ui UiSelectMap

	datadir := base.GetDataDir()
	err := base.LoadAndProcessObject(filepath.Join(datadir, "ui", "select_map", "config.json"), "json", &ui.layout)
	if err != nil {
		return nil, nil, err
	}

	ui.region.Dx = 1024
	ui.region.Dy = 768
	var options []hui.Option
	// TODO: may want to reload the registry on this one?  If we want to pik up
	// new changes to files that is.
	for _, name := range base.GetAllNamesInRegistry("houses") {
		var mo MapOption
		mo.house_def = house.MakeHouseFromName(name)
		mo.layout = &ui.layout
		options = append(options, &mo)
	}
	out := make(chan string, 2)
	chooser := hui.MakeRosterChooser(options, hui.SelectExactlyOne, func(m map[int]bool) {
		var index int
		base.Log().Printf("On complete: %v", m)
		for index = range m {
			out <- options[index].(*MapOption).house_def.Name
			base.Log().Printf("Sent '%s'", options[index].(*MapOption).house_def.Name)
			break
		}
		base.Log().Printf("Closing")
		close(out)
	},
		nil)
	ui.chooser = chooser

	return &ui, out, nil
}
Пример #27
0
func selectHouse(gp *GamePanel) lua.GoFunction {
	return func(L *lua.State) int {
		if !LuaCheckParamsOk(L, "SelectHouse") {
			return 0
		}
		gp.script.syncStart()
		defer gp.script.syncEnd()
		selector, output, err := MakeUiSelectMap(gp)
		if err != nil {
			base.Error().Printf("Error selecting map: %v", err)
			return 0
		}
		gp.AnchorBox.AddChild(selector, gui.Anchor{0.5, 0.5, 0.5, 0.5})
		gp.script.syncEnd()

		name := <-output
		base.Log().Printf("Received '%s'", name)
		gp.script.syncStart()
		gp.AnchorBox.RemoveChild(selector)
		base.Log().Printf("Removed seletor")
		L.PushString(name)
		return 1
	}
}
Пример #28
0
// Tries to place new_ent in the game at its current position.  Returns true
// on success, false otherwise.
// pattern is a regexp that matches only the names of all valid spawn points.
func (g *Game) placeEntity(pattern string) bool {
	if g.new_ent == nil {
		base.Log().Printf("No new ent")
		return false
	}
	re, err := regexp.Compile(pattern)
	if err != nil {
		base.Error().Printf("Failed to compile regexp: '%s': %v", pattern, err)
		return false
	}
	g.new_ent.Info.RoomsExplored[g.new_ent.CurrentRoom()] = true
	ix, iy := int(g.new_ent.X), int(g.new_ent.Y)
	idx, idy := g.new_ent.Dims()
	r, f, _ := g.House.Floors[0].RoomFurnSpawnAtPos(ix, iy)

	if r == nil || f != nil {
		return false
	}
	for _, e := range g.Ents {
		x, y := e.Pos()
		dx, dy := e.Dims()
		r1 := image.Rect(x, y, x+dx, y+dy)
		r2 := image.Rect(ix, iy, ix+idx, iy+idy)
		if r1.Overlaps(r2) {
			return false
		}
	}

	// Check for spawn points
	for _, spawn := range g.House.Floors[0].Spawns {
		if !re.MatchString(spawn.Name) {
			continue
		}
		x, y := spawn.Pos()
		dx, dy := spawn.Dims()
		if ix < x || ix+idx > x+dx {
			continue
		}
		if iy < y || iy+idy > y+dy {
			continue
		}
		g.Ents = append(g.Ents, g.new_ent)
		g.new_ent = nil
		return true
	}
	return false
}
Пример #29
0
func (gdt *gameDataTransient) alloc() {
	if gdt.los.denizens.tex != nil {
		return
	}
	gdt.los.denizens.tex = house.MakeLosTexture()
	gdt.los.intruders.tex = house.MakeLosTexture()
	gdt.los.full_merger = make([]bool, house.LosTextureSizeSquared)
	gdt.los.merger = make([][]bool, house.LosTextureSize)
	for i := range gdt.los.merger {
		gdt.los.merger[i] = gdt.los.full_merger[i*house.LosTextureSize : (i+1)*house.LosTextureSize]
	}

	gdt.comm.script_to_game = make(chan interface{}, 1)
	gdt.comm.game_to_script = make(chan interface{}, 1)

	gdt.script = &gameScript{}
	base.Log().Printf("script = %p", gdt.script)
}
Пример #30
0
func placeEntities(gp *GamePanel) lua.GoFunction {
	return func(L *lua.State) int {
		if !LuaCheckParamsOk(L, "PlaceEntities", LuaString, LuaTable, LuaInteger, LuaInteger) {
			return 0
		}
		gp.script.syncStart()
		defer gp.script.syncEnd()
		L.PushNil()
		var names []string
		var costs []int
		for L.Next(-4) != 0 {
			L.PushInteger(1)
			L.GetTable(-2)
			names = append(names, L.ToString(-1))
			L.Pop(1)
			L.PushInteger(2)
			L.GetTable(-2)
			costs = append(costs, L.ToInteger(-1))
			L.Pop(2)
		}
		ep, done, err := MakeEntityPlacer(gp.game, names, costs, L.ToInteger(-2), L.ToInteger(-1), L.ToString(-4))
		if err != nil {
			base.Error().Printf("Unable to make entity placer: %v", err)
			return 0
		}
		gp.AnchorBox.AddChild(ep, gui.Anchor{0, 0, 0, 0})
		for i, kid := range gp.AnchorBox.GetChildren() {
			base.Log().Printf("Kid[%d] = %s", i, kid.String())
		}
		gp.script.syncEnd()
		ents := <-done
		L.NewTable()
		for i := range ents {
			L.PushInteger(i + 1)
			LuaPushEntity(L, ents[i])
			L.SetTable(-3)
		}
		gp.script.syncStart()
		gp.AnchorBox.RemoveChild(ep)
		return 1
	}
}