mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
tvl-depot/users/grfn/xanthous/test/Spec.hs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

54 lines
1.9 KiB
Haskell
Raw Normal View History

Add support for multiple levels Add a data structure, based on the zipper comonad, which provides support for multiple levels, each of which is its own entity map. The current level is provided by coreturn, which the `entities` lens has been updated to use. Nothing currently supports going up or down levels yet - that's coming next.
2020-01-05 05:48:51 +01:00
--------------------------------------------------------------------------------
import Test.Prelude
--------------------------------------------------------------------------------
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
import qualified Xanthous.Data.EntitiesSpec
Use menus for combat and picking up items Refactor a bunch of stuff around to allow for polymorphically surfacing an EntityChar for all entities, and use this to write a generic `entityMenu` function, which generates a menu from the chars of a list of entities - and use that to fully implement (removing `undefined`) menus for both attacking and picking things up when there are multiple entities on the relevant tile.
2019-11-30 04:59:15 +01:00
import qualified Xanthous.Data.EntityCharSpec
Update the vision every time we step the game Recalculate the character's lines of sight every time we step the game, rather than just every time the character *moves*. I had originally thought this was a non-contiguous lines-of-sight bug - which there's a test disproving - but it actually turned out to be that actions like eating or attacking would step the game forward (thus moving gormlaks) without re-calculating the positions visible to the character.
2019-12-23 23:55:28 +01:00
import qualified Xanthous.Data.EntityMap.GraphicsSpec
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
import qualified Xanthous.Data.EntityMapSpec
Add support for multiple levels Add a data structure, based on the zipper comonad, which provides support for multiple levels, each of which is its own entity map. The current level is provided by coreturn, which the `entities` lens has been updated to use. Nothing currently supports going up or down levels yet - that's coming next.
2020-01-05 05:48:51 +01:00
import qualified Xanthous.Data.LevelsSpec
feat(xanthous): Memoize characterVisiblePositions Memoize the return value of characterVisiblePositions to a new, semi-abstracted "memo" field on the GameState, recalcuclated if the character position ever changes. I'm 90% sure that the perf issues we were encountering were actually caused by characterVisiblePositions getting called once for *every tile* on draw, but this slightly larger change also makes the game perform relatively-usably again. Since this is only recalculated if the character position changes, if we ever get non-transparent entities moving around without the characters influence (maybe something building or knocking down walls?) we'll have an issue there where the vision won't be updated as a result of those changes if they happen while the character is taking a non-moving action - but we can cross that bridge when we come to it. Change-Id: I3fc745ddf0014d6f164f735ad7e5080da779b92a Reviewed-on: https://cl.tvl.fyi/c/depot/+/3185 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-12 20:41:24 +02:00
import qualified Xanthous.Data.MemoSpec
Begin a broken-out NestedMap type Begin breaking out a NestedMap data structure, which existed in both the variables for the new template system and the structure that stored messages.
2020-05-25 17:21:19 +02:00
import qualified Xanthous.Data.NestedMapSpec
Add cellular-automata cave generator Add a cellular-automata-based cave level generator, plus an optparse-applicative-based CLI for invoking level generators in general.
2019-09-07 20:49:59 +02:00
import qualified Xanthous.DataSpec
import qualified Xanthous.Entities.RawsSpec
feat(xanthous): Fistfighting builds knuckle calluses 2000 ticks after the character damages their fists by hitting something, the character now develops calluses on their fists (scaled by *how* damaged they've become) that reduce the chance of them receiving additional damage from hitting things - up to a max of 5, which prevents *all* damage from fistfighting. This is all tracked in a new "Knuckles" struct in a new "Body" struct on the character datatype, which manages stepping itself forward as part of the Brain impl on the character. Change-Id: Ica269f16fb340fb25900d2c77fbad32f10c00be2 Reviewed-on: https://cl.tvl.fyi/c/depot/+/3222 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-18 22:07:39 +02:00
import qualified Xanthous.Entities.CharacterSpec
Add entities, and allow walking around Add support for entities via a port of the EntityMap type, and implement command support starting at basic hjkl.
2019-08-31 19:17:27 +02:00
import qualified Xanthous.GameSpec
feat(xanthous): Add a method to get the name for a type of entity I didn't end up using this directly for the thing I was doing, but it still seems generally useful enough that I'm keeping it around for now Change-Id: I05c8902d75845f2230ec2373a9677d61cfaafafd Reviewed-on: https://cl.tvl.fyi/c/depot/+/3206 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-14 05:02:11 +02:00
import qualified Xanthous.Game.StateSpec
refactor(xanthous): Generators -> Generators.Level I'm going to start adding generators for things like text soon, so it makes sense to specifically sequester level generators as their own thing Change-Id: I175025375204fab7d75eba67dd06dab9bd2939d3 Reviewed-on: https://cl.tvl.fyi/c/depot/+/3201 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-12 20:57:30 +02:00
import qualified Xanthous.Generators.Level.UtilSpec
Implement messages Implement messages almost the same as in the Rust version, only with YAML instead of TOML this time, and a regular old mustache template instead of something handrolled. Besides that, pretty much everything here is the same.
2019-09-01 19:54:27 +02:00
import qualified Xanthous.MessageSpec
Add a new template system Add a parser, pretty-printer, and renderer for a new template system, which should eventually be a drop-in replacement for the current mustache-based template system, but also supports text filters (which will be used for things like pluralization and noun casing). Nothing currently uses it yet, though.
2020-05-24 17:14:02 +02:00
import qualified Xanthous.Messages.TemplateSpec
Implement messages Implement messages almost the same as in the Rust version, only with YAML instead of TOML this time, and a regular old mustache template instead of something handrolled. Besides that, pretty much everything here is the same.
2019-09-01 19:54:27 +02:00
import qualified Xanthous.OrphansSpec
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
import qualified Xanthous.RandomSpec
Add dungeon level generation Add a dungeon level generator, which: 1. generates an infinite sequence of rectangular rooms within the dimensions of the level 2. removes any duplicates from that sequence 3. Generates a graph from the delaunay triangulation of the centerpoints of those rooms 4. Generates the minimum-spanning-tree of that delaunay triangulation, with weights given by line length in points 5. Adds back a subset (default 10-15%) of edges from the delaunay triangulation to the graph 6. Uses the resulting graph to draw corridors between the rooms, using a random point on the near edge of each room to pick the points of the corridors
2019-12-30 17:31:56 +01:00
import qualified Xanthous.Util.GraphSpec
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
import qualified Xanthous.Util.GraphicsSpec
Describe what you see when you walk over items Every step the character takes, describe the entities at that position excluding the character.
2019-09-21 01:38:16 +02:00
import qualified Xanthous.Util.InflectionSpec
Use menus for combat and picking up items Refactor a bunch of stuff around to allow for polymorphically surfacing an EntityChar for all entities, and use this to write a generic `entityMenu` function, which generates a menu from the chars of a list of entities - and use that to fully implement (removing `undefined`) menus for both attacking and picking things up when there are multiple entities on the relevant tile.
2019-11-30 04:59:15 +01:00
import qualified Xanthous.UtilSpec
Add support for multiple levels Add a data structure, based on the zipper comonad, which provides support for multiple levels, each of which is its own entity map. The current level is provided by coreturn, which the `entities` lens has been updated to use. Nothing currently supports going up or down levels yet - that's coming next.
2020-01-05 05:48:51 +01:00
--------------------------------------------------------------------------------
An @-sign in a box, in haskell Initial commit of a Haskell version of Xanthous, written using Brick and built with Nix. This is so much nicer and so much easier
2019-08-25 19:28:10 +02:00
Add entities, and allow walking around Add support for entities via a port of the EntityMap type, and implement command support starting at basic hjkl.
2019-08-31 19:17:27 +02:00
main :: IO ()
main = defaultMain test
test :: TestTree
test = testGroup "Xanthous"
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
[ Xanthous.Data.EntitiesSpec.test
Update the vision every time we step the game Recalculate the character's lines of sight every time we step the game, rather than just every time the character *moves*. I had originally thought this was a non-contiguous lines-of-sight bug - which there's a test disproving - but it actually turned out to be that actions like eating or attacking would step the game forward (thus moving gormlaks) without re-calculating the positions visible to the character.
2019-12-23 23:55:28 +01:00
, Xanthous.Data.EntityMap.GraphicsSpec.test
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
, Xanthous.Data.EntityMapSpec.test
Begin a broken-out NestedMap type Begin breaking out a NestedMap data structure, which existed in both the variables for the new template system and the structure that stored messages.
2020-05-25 17:21:19 +02:00
, Xanthous.Data.LevelsSpec.test
feat(xanthous): Memoize characterVisiblePositions Memoize the return value of characterVisiblePositions to a new, semi-abstracted "memo" field on the GameState, recalcuclated if the character position ever changes. I'm 90% sure that the perf issues we were encountering were actually caused by characterVisiblePositions getting called once for *every tile* on draw, but this slightly larger change also makes the game perform relatively-usably again. Since this is only recalculated if the character position changes, if we ever get non-transparent entities moving around without the characters influence (maybe something building or knocking down walls?) we'll have an issue there where the vision won't be updated as a result of those changes if they happen while the character is taking a non-moving action - but we can cross that bridge when we come to it. Change-Id: I3fc745ddf0014d6f164f735ad7e5080da779b92a Reviewed-on: https://cl.tvl.fyi/c/depot/+/3185 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-12 20:41:24 +02:00
, Xanthous.Data.MemoSpec.test
Begin a broken-out NestedMap type Begin breaking out a NestedMap data structure, which existed in both the variables for the new template system and the structure that stored messages.
2020-05-25 17:21:19 +02:00
, Xanthous.Data.NestedMapSpec.test
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
, Xanthous.DataSpec.test
Add raws, loaded statically from a folder Add raw types with support for both creatures and items, loaded statically from a "raws" folder just like in the Rust version.
2019-09-02 19:56:25 +02:00
, Xanthous.Entities.RawsSpec.test
feat(xanthous): Fistfighting builds knuckle calluses 2000 ticks after the character damages their fists by hitting something, the character now develops calluses on their fists (scaled by *how* damaged they've become) that reduce the chance of them receiving additional damage from hitting things - up to a max of 5, which prevents *all* damage from fistfighting. This is all tracked in a new "Knuckles" struct in a new "Body" struct on the character datatype, which manages stepping itself forward as part of the Brain impl on the character. Change-Id: Ica269f16fb340fb25900d2c77fbad32f10c00be2 Reviewed-on: https://cl.tvl.fyi/c/depot/+/3222 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-18 22:07:39 +02:00
, Xanthous.Entities.CharacterSpec.test
Add entities, and allow walking around Add support for entities via a port of the EntityMap type, and implement command support starting at basic hjkl.
2019-08-31 19:17:27 +02:00
, Xanthous.GameSpec.test
feat(xanthous): Add a method to get the name for a type of entity I didn't end up using this directly for the thing I was doing, but it still seems generally useful enough that I'm keeping it around for now Change-Id: I05c8902d75845f2230ec2373a9677d61cfaafafd Reviewed-on: https://cl.tvl.fyi/c/depot/+/3206 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-14 05:02:11 +02:00
, Xanthous.Game.StateSpec.test
refactor(xanthous): Generators -> Generators.Level I'm going to start adding generators for things like text soon, so it makes sense to specifically sequester level generators as their own thing Change-Id: I175025375204fab7d75eba67dd06dab9bd2939d3 Reviewed-on: https://cl.tvl.fyi/c/depot/+/3201 Reviewed-by: grfn <grfn@gws.fyi> Tested-by: BuildkiteCI
2021-06-12 20:57:30 +02:00
, Xanthous.Generators.Level.UtilSpec.test
Implement messages Implement messages almost the same as in the Rust version, only with YAML instead of TOML this time, and a regular old mustache template instead of something handrolled. Besides that, pretty much everything here is the same.
2019-09-01 19:54:27 +02:00
, Xanthous.MessageSpec.test
Add a new template system Add a parser, pretty-printer, and renderer for a new template system, which should eventually be a drop-in replacement for the current mustache-based template system, but also supports text filters (which will be used for things like pluralization and noun casing). Nothing currently uses it yet, though.
2020-05-24 17:14:02 +02:00
, Xanthous.Messages.TemplateSpec.test
Implement messages Implement messages almost the same as in the Rust version, only with YAML instead of TOML this time, and a regular old mustache template instead of something handrolled. Besides that, pretty much everything here is the same.
2019-09-01 19:54:27 +02:00
, Xanthous.OrphansSpec.test
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
, Xanthous.RandomSpec.test
Add dungeon level generation Add a dungeon level generator, which: 1. generates an infinite sequence of rectangular rooms within the dimensions of the level 2. removes any duplicates from that sequence 3. Generates a graph from the delaunay triangulation of the centerpoints of those rooms 4. Generates the minimum-spanning-tree of that delaunay triangulation, with weights given by line length in points 5. Adds back a subset (default 10-15%) of edges from the delaunay triangulation to the graph 6. Uses the resulting graph to draw corridors between the rooms, using a random point on the near edge of each room to pick the points of the corridors
2019-12-30 17:31:56 +01:00
, Xanthous.Util.GraphSpec.test
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
, Xanthous.Util.GraphicsSpec.test
Describe what you see when you walk over items Every step the character takes, describe the entities at that position excluding the character.
2019-09-21 01:38:16 +02:00
, Xanthous.Util.InflectionSpec.test
feat(xan): Generate random villages This algorithm is a little rough around the edges right now, but generally the idea is we find a relatively closed-off region of the map, and place rooms randomly on it, expanding them until they run into each other, then we put doors in the walls of the rooms and a single door opening into the region. Later on, we'll generate friendly (or unfriendly!) NPCs to put in those rooms. Change-Id: Ic989b9905f55ad92a01fdf6db11aa57afb4ce383 Reviewed-on: https://cl.tvl.fyi/c/depot/+/726 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-29 01:33:27 +02:00
, Xanthous.UtilSpec.test
, Xanthous.Data.EntityCharSpec.test
Add entities, and allow walking around Add support for entities via a port of the EntityMap type, and implement command support starting at basic hjkl.
2019-08-31 19:17:27 +02:00
]
Reference in a new issue Copy permalink