func MakeHouseFromName(name string) *HouseDef {
var idiot iamanidiotcontainer
idiot.Defname = name
base.GetObject("houses", &idiot)
idiot.HouseDef.setDoorsOpened(false)
return idiot.HouseDef
}
func (he *HouseEditor) Reload() {
for _, floor := range he.house.Floors {
for i := range floor.Rooms {
base.GetObject("rooms", floor.Rooms[i])
}
}
for _, tab := range he.widgets {
tab.Reload()
}
}
func registerInteracts() map[string]func() game.Action {
interact_actions := make(map[string]*InteractDef)
base.RemoveRegistry("actions-interact_actions")
base.RegisterRegistry("actions-interact_actions", interact_actions)
base.RegisterAllObjectsInDir("actions-interact_actions", filepath.Join(base.GetDataDir(), "actions", "interacts"), ".json", "json")
makers := make(map[string]func() game.Action)
for name := range interact_actions {
cname := name
makers[cname] = func() game.Action {
a := Interact{Defname: cname}
base.GetObject("actions-interact_actions", &a)
return &a
}
}
return makers
}
func registerMoves() map[string]func() game.Action {
move_actions := make(map[string]*MoveDef)
base.RemoveRegistry("actions-move_actions")
base.RegisterRegistry("actions-move_actions", move_actions)
base.RegisterAllObjectsInDir("actions-move_actions", filepath.Join(base.GetDataDir(), "actions", "movement"), ".json", "json")
makers := make(map[string]func() game.Action)
for name := range move_actions {
cname := name
makers[cname] = func() game.Action {
a := Move{Defname: cname}
base.GetObject("actions-move_actions", &a)
return &a
}
}
return makers
}
func registerBasicConditions() {
registry_name := "conditions-basic_conditions"
base.RemoveRegistry(registry_name)
base.RegisterRegistry(registry_name, make(map[string]*BasicConditionDef))
base.RegisterAllObjectsInDir(registry_name, filepath.Join(base.GetDataDir(), "conditions", "basic_conditions"), ".json", "json")
names := base.GetAllNamesInRegistry(registry_name)
for _, name := range names {
cname := name
f := func() Condition {
c := BasicCondition{Defname: cname}
base.GetObject(registry_name, &c)
return &c
}
condition_makers[name] = f
}
}
func registerAoeAttacks() map[string]func() game.Action {
aoe_actions := make(map[string]*AoeAttackDef)
base.RemoveRegistry("actions-aoe_actions")
base.RegisterRegistry("actions-aoe_actions", aoe_actions)
base.RegisterAllObjectsInDir("actions-aoe_actions", filepath.Join(base.GetDataDir(), "actions", "aoe_attacks"), ".json", "json")
makers := make(map[string]func() game.Action)
for name := range aoe_actions {
cname := name
makers[cname] = func() game.Action {
a := AoeAttack{Defname: cname}
base.GetObject("actions-aoe_actions", &a)
if a.Ammo > 0 {
a.Current_ammo = a.Ammo
} else {
a.Current_ammo = -1
}
return &a
}
}
return makers
}
func makeHouseDataTab(house *HouseDef, viewer *HouseViewer) *houseDataTab {
var hdt houseDataTab
hdt.VerticalTable = gui.MakeVerticalTable()
hdt.house = house
hdt.viewer = viewer
hdt.name = gui.MakeTextEditLine("standard", "name", 300, 1, 1, 1, 1)
num_floors_options := []string{"1 Floor", "2 Floors", "3 Floors", "4 Floors"}
hdt.num_floors = gui.MakeComboTextBox(num_floors_options, 300)
if hdt.house.Icon.Path == "" {
hdt.house.Icon.Path = base.Path(filepath.Join(datadir, "houses", "icons"))
}
hdt.icon = gui.MakeFileWidget(string(hdt.house.Icon.Path), imagePathFilter)
hdt.VerticalTable.AddChild(hdt.name)
hdt.VerticalTable.AddChild(hdt.num_floors)
hdt.VerticalTable.AddChild(hdt.icon)
names := GetAllRoomNames()
room_buttons := gui.MakeVerticalTable()
for _, name := range names {
n := name
room_buttons.AddChild(gui.MakeButton("standard", name, 300, 1, 1, 1, 1, func(int64) {
if hdt.temp_room != nil {
return
}
hdt.temp_room = &Room{Defname: n}
base.GetObject("rooms", hdt.temp_room)
hdt.temp_room.temporary = true
hdt.temp_room.invalid = true
hdt.house.Floors[0].Rooms = append(hdt.house.Floors[0].Rooms, hdt.temp_room)
hdt.drag_anchor.x = float32(hdt.temp_room.Size.Dx / 2)
hdt.drag_anchor.y = float32(hdt.temp_room.Size.Dy / 2)
}))
}
scroller := gui.MakeScrollFrame(room_buttons, 300, 700)
hdt.VerticalTable.AddChild(scroller)
return &hdt
}
func (e *Entity) SetGear(gear_name string) bool {
if e.ExplorerEnt == nil {
base.Error().Printf("Tried to set gear on a non-explorer entity.")
return false
}
if e.ExplorerEnt.Gear != nil && gear_name != "" {
base.Error().Printf("Tried to set gear on an explorer that already had gear.")
return false
}
if e.ExplorerEnt.Gear == nil && gear_name == "" {
base.Error().Printf("Tried to remove gear from an explorer with no gear.")
return false
}
if gear_name == "" {
algorithm.Choose(&e.Actions, func(a Action) bool {
return a.String() != e.ExplorerEnt.Gear.Action
})
if e.ExplorerEnt.Gear.Condition != "" {
e.Stats.RemoveCondition(e.ExplorerEnt.Gear.Condition)
}
e.ExplorerEnt.Gear = nil
return true
}
var g Gear
g.Defname = gear_name
base.GetObject("gear", &g)
if g.Name == "" {
base.Error().Printf("Tried to load gear '%s' that doesn't exist.", gear_name)
return false
}
e.ExplorerEnt.Gear = &g
if g.Action != "" {
e.Actions = append(e.Actions, MakeAction(g.Action))
}
if g.Condition != "" {
e.Stats.ApplyCondition(status.MakeCondition(g.Condition))
}
return true
}
func MakeEntity(name string, g *Game) *Entity {
ent := Entity{Defname: name}
base.GetObject("entities", &ent)
for _, action_name := range ent.Action_names {
ent.Actions = append(ent.Actions, MakeAction(action_name))
}
if ent.Side() == SideHaunt || ent.Side() == SideExplorers {
stats := status.MakeInst(ent.Base)
stats.OnBegin()
ent.Stats = &stats
}
ent.Info = makeInfo()
ent.Id = g.Entity_id
g.Entity_id++
ent.Load(g)
g.all_ents_in_memory[&ent] = true
return &ent
}
func registerBasicAttacks() map[string]func() game.Action {
attack_actions := make(map[string]*BasicAttackDef)
base.RemoveRegistry("actions-attack_actions")
base.RegisterRegistry("actions-attack_actions", attack_actions)
base.RegisterAllObjectsInDir("actions-attack_actions", filepath.Join(base.GetDataDir(), "actions", "basic_attacks"), ".json", "json")
makers := make(map[string]func() game.Action)
for name := range attack_actions {
cname := name
makers[cname] = func() game.Action {
a := BasicAttack{Defname: cname}
base.GetObject("actions-attack_actions", &a)
if !a.Target_allies && !a.Target_enemies {
base.Error().Printf("Basic Attack '%s' cannot target anything! Either Target_allies or Target_enemies must be true", a.Name)
}
if a.Ammo > 0 {
a.Current_ammo = a.Ammo
} else {
a.Current_ammo = -1
}
return &a
}
}
return makers
}
// Pushes an entity onto the stack, it is a table containing the following:
// e.id -> EntityId of this entity
// e.name -> Name as displayed to the user
// e.gear_options -> Table mapping gear to icon for all available gear
// e.gear -> Name of the selected gear, nil if none is selected
// e.actions -> Array of actions this entity has available
func LuaPushEntity(L *lua.State, _ent *Entity) {
if _ent == nil {
L.PushNil()
return
}
// id and Name can be added to the ent table as static data since they
// never change.
L.NewTable()
L.PushString("Name")
L.PushString(_ent.Name)
L.SetTable(-3)
L.PushString("id")
L.PushInteger(int(_ent.Id))
L.SetTable(-3)
L.PushString("type")
L.PushString("Entity")
L.SetTable(-3)
id := _ent.Id
// Meta table for the Entity so that any dynamic data is generated
// on-the-fly
LuaPushSmartFunctionTable(L, FunctionTable{
"Conditions": func() {
ent := _ent.Game().EntityById(id)
L.NewTable()
for _, condition := range ent.Stats.ConditionNames() {
L.PushString(condition)
L.PushBoolean(true)
L.SetTable(-3)
}
},
"Side": func() {
ent := _ent.Game().EntityById(id)
L.NewTable()
sides := map[string]Side{
"Denizen": SideHaunt,
"Intruder": SideExplorers,
"Npc": SideNpc,
"Object": SideObject,
}
for str, side := range sides {
L.PushString(str)
L.PushBoolean(ent.Side() == side)
L.SetTable(-3)
}
},
"State": func() {
ent := _ent.Game().EntityById(id)
L.PushString(ent.Sprite().State())
},
"Master": func() {
ent := _ent.Game().EntityById(id)
L.NewTable()
for key, val := range ent.Ai_data {
L.PushString(key)
L.PushString(val)
L.SetTable(-3)
}
},
"GearOptions": func() {
ent := _ent.Game().EntityById(id)
L.NewTable()
if ent.ExplorerEnt != nil {
for _, gear_name := range ent.ExplorerEnt.Gear_names {
var g Gear
g.Defname = gear_name
base.GetObject("gear", &g)
L.PushString(gear_name)
L.PushString(g.Large_icon.Path.String())
L.SetTable(-3)
}
}
},
"Gear": func() {
ent := _ent.Game().EntityById(id)
if ent.ExplorerEnt != nil && ent.ExplorerEnt.Gear != nil {
L.PushString(ent.ExplorerEnt.Gear.Name)
} else {
L.PushNil()
}
},
"Actions": func() {
ent := _ent.Game().EntityById(id)
L.NewTable()
for _, action := range ent.Actions {
L.PushString(action.String())
action.Push(L)
L.SetTable(-3)
}
},
"Pos": func() {
ent := _ent.Game().EntityById(id)
x, y := ent.Pos()
LuaPushPoint(L, x, y)
},
"Corpus": func() {
ent := _ent.Game().EntityById(id)
L.PushInteger(ent.Stats.Corpus())
},
"Ego": func() {
ent := _ent.Game().EntityById(id)
L.PushInteger(ent.Stats.Ego())
},
"HpCur": func() {
ent := _ent.Game().EntityById(id)
L.PushInteger(ent.Stats.HpCur())
},
"HpMax": func() {
ent := _ent.Game().EntityById(id)
L.PushInteger(ent.Stats.HpMax())
},
"ApCur": func() {
ent := _ent.Game().EntityById(id)
L.PushInteger(ent.Stats.ApCur())
},
"ApMax": func() {
ent := _ent.Game().EntityById(id)
L.PushInteger(ent.Stats.ApMax())
},
"Info": func() {
ent := _ent.Game().EntityById(id)
L.NewTable()
L.PushString("LastEntityThatIAttacked")
LuaPushEntity(L, ent.Game().EntityById(ent.Info.LastEntThatIAttacked))
L.SetTable(-3)
L.PushString("LastEntThatAttackedMe")
LuaPushEntity(L, ent.Game().EntityById(ent.Info.LastEntThatAttackedMe))
L.SetTable(-3)
},
})
L.SetMetaTable(-2)
}
func (d *Door) Load() {
base.GetObject("doors", d)
}
func MakeFurniture(name string) *Furniture {
f := Furniture{Defname: name}
base.GetObject("furniture", &f)
return &f
}
func MakeGear(name string) *Gear {
g := Gear{Defname: name}
base.GetObject("gear", &g)
return &g
}
func (wt *WallTexture) Load() {
base.GetObject("wall_textures", wt)
}
func MakeDoor(name string) *Door {
d := Door{Defname: name}
base.GetObject("doors", &d)
return &d
}
func (g *Game) GobDecode(data []byte) error {
g.gameDataPrivate = gameDataPrivate{}
for ent := range g.all_ents_in_memory {
ent.Release()
}
if g.Ai.intruders != nil {
g.Ai.intruders.Terminate()
}
if g.Ai.minions != nil {
g.Ai.minions.Terminate()
}
if g.Ai.denizens != nil {
g.Ai.denizens.Terminate()
}
g.gameDataGobbable = gameDataGobbable{}
dec := gob.NewDecoder(bytes.NewBuffer(data))
if err := dec.Decode(&g.gameDataGobbable); err != nil {
return err
}
base.ProcessObject(reflect.ValueOf(g.House), "")
g.House.Normalize()
g.viewer = house.MakeHouseViewer(g.House, 62)
g.viewer.Edit_mode = true
for _, ent := range g.Ents {
base.GetObject("entities", ent)
}
g.setup()
for _, ent := range g.Ents {
ent.Load(g)
base.Log().Printf("Ungob, ent: %p, %s", ent, ent.Name)
g.UpdateEntLos(ent, true)
}
g.mergeLos(SideHaunt)
g.mergeLos(SideExplorers)
var sss []sprite.SpriteState
if err := dec.Decode(&sss); err != nil {
return err
}
if len(sss) != len(g.Ents) {
return errors.New("SpriteStates were not recorded properly.")
}
for i := range sss {
g.Ents[i].Sprite().SetSpriteState(sss[i])
}
// If Ais were bound then their paths will be listed here and we have to
// reload them
if g.Ai.Path.Denizens != "" {
ai_maker(g.Ai.Path.Denizens, g, nil, &g.Ai.denizens, DenizensAi)
}
if g.Ai.denizens == nil {
g.Ai.denizens = inactiveAi{}
}
if g.Ai.Path.Intruders != "" {
ai_maker(g.Ai.Path.Intruders, g, nil, &g.Ai.intruders, IntrudersAi)
}
if g.Ai.intruders == nil {
g.Ai.intruders = inactiveAi{}
}
if g.Ai.Path.Minions != "" {
ai_maker(g.Ai.Path.Minions, g, nil, &g.Ai.minions, MinionsAi)
}
if g.Ai.minions == nil {
g.Ai.minions = inactiveAi{}
}
return nil
}
func MakeEntityPlacer(game *Game, roster_names []string, roster_costs []int, min, max int, pattern string) (*EntityPlacer, <-chan []*Entity, error) {
var ep EntityPlacer
err := base.LoadAndProcessObject(filepath.Join(base.GetDataDir(), "ui", "entity_placer", "config.json"), "json", &ep.layout)
if err != nil {
return nil, nil, err
}
if len(roster_names) != len(roster_costs) {
return nil, nil, errors.New("Must have as many names as costs.")
}
if len(roster_names) <= 0 || len(roster_names) > ep.layout.Roster.Max_options {
return nil, nil, errors.New(fmt.Sprintf("Can't have more than %d ents in a roster.", ep.layout.Roster.Max_options))
}
ep.layout.Undo.valid_func = func() bool {
return len(ep.ents) > 0
}
ep.layout.Undo.f = func(interface{}) {
ent := ep.ents[len(ep.ents)-1]
ep.points += ep.roster[ent.Name]
ep.ents = ep.ents[0 : len(ep.ents)-1]
algorithm.Choose(&game.Ents, func(e *Entity) bool { return e != ent })
game.viewer.RemoveDrawable(ent)
}
ep.layout.Done.valid_func = func() bool {
return ep.points >= 0 && min <= (max-ep.points)
}
done := make(chan []*Entity)
ep.layout.Done.f = func(interface{}) {
done <- ep.ents
close(done)
house.PopSpawnRegexp()
game.viewer.RemoveDrawable(game.new_ent)
game.new_ent = nil
}
ep.roster_names = roster_names
ep.roster = make(map[string]int)
for i, name := range ep.roster_names {
ep.roster[name] = roster_costs[i]
}
ep.game = game
ep.show_points = !(min == 1 && max == 1)
ep.points = max
ep.pattern = pattern
house.PushSpawnRegexp(ep.pattern)
x := ep.layout.Roster.X
for _, name := range ep.roster_names {
var b Button
b.X = x
x += (ep.layout.Roster.X2 - ep.layout.Roster.X) / (ep.layout.Roster.Max_options - 1)
b.Y = ep.layout.Roster.Y
ent := Entity{Defname: name}
base.GetObject("entities", &ent)
b.Texture = ent.Still
cost := ep.roster[name]
b.valid_func = func() bool {
return ep.points >= cost
}
b.f = func(interface{}) {
ep.game.viewer.RemoveDrawable(ep.game.new_ent)
ep.game.new_ent = MakeEntity(ent.Name, ep.game)
ep.game.viewer.AddDrawable(ep.game.new_ent)
}
ep.ent_buttons = append(ep.ent_buttons, &b)
}
ep.buttons = []*Button{
&ep.layout.Undo,
&ep.layout.Done,
}
for _, b := range ep.ent_buttons {
ep.buttons = append(ep.buttons, b)
}
return &ep, done, nil
}