mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
tvl-depot/users/glittershark/xanthous/xanthous.cabal

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

456 lines
11 KiB
Text
Raw Normal View History

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
cabal-version: 1.12
refactor(xan): Switch to V2 over tuples most places These are generally rather nicer to work due to some typeclass instances, and integrate better with other ecosystems for things like linear algebra etc. Change-Id: I546c8da7b17234648f3d612b28741c1fded25447 Reviewed-on: https://cl.tvl.fyi/c/depot/+/910 Tested-by: BuildkiteCI Reviewed-by: glittershark <grfn@gws.fyi>
2020-07-04 02:32:36 +02:00
-- This file has been generated from package.yaml by hpack version 0.33.1.
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
--
-- see: https://github.com/sol/hpack
--
refactor(xan): Switch to V2 over tuples most places These are generally rather nicer to work due to some typeclass instances, and integrate better with other ecosystems for things like linear algebra etc. Change-Id: I546c8da7b17234648f3d612b28741c1fded25447 Reviewed-on: https://cl.tvl.fyi/c/depot/+/910 Tested-by: BuildkiteCI Reviewed-by: glittershark <grfn@gws.fyi>
2020-07-04 02:32:36 +02:00
-- hash: bb0a26ab512a1b8d095f3fa71370dcc5221c3f20888042a0d5c41d054dc403cf
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
name: xanthous
version: 0.1.0.0
synopsis: A WIP TUI RPG
description: Please see the README on GitHub at <https://github.com/glittershark/xanthous>
category: Game
homepage: https://github.com/glittershark/xanthous#readme
bug-reports: https://github.com/glittershark/xanthous/issues
author: Griffin Smith
maintainer: root@gws.fyi
copyright: 2019 Griffin Smith
license: GPL-3
license-file: LICENSE
build-type: Simple
extra-source-files:
README.org
source-repository head
type: git
location: https://github.com/glittershark/xanthous
library
exposed-modules:
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
Data.Aeson.Generic.DerivingVia
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
Main
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.AI.Gormlak
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
Xanthous.App
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
Xanthous.App.Autocommands
Xanthous.App.Common
Xanthous.App.Prompt
Xanthous.App.Time
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.Command
Xanthous.Data
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
Xanthous.Data.App
Factor out an EntityAttributes type Factor out a new EntityAttributes type from some of the methods of the Entity class, to avoid the proliferation of 1-argument boolean methods on the entity class that always have to be forwarded through the Entity instance for SomeEntity if they have defaults (forgetting to do which has wasted tons of my time up to this point). Currently blocksVision, blocksObject, and collision are all in there.
2020-02-08 23:24:27 +01:00
Xanthous.Data.Entities
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
Xanthous.Data.EntityChar
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.Data.EntityMap
Progressively reveal the map to the player As the character walks around the map, progressively reveal the entities on the map to them, using an algorithm based on well known circle-rasterizing and line-rasterizing algorithms to calculate lines of sight that are potentially obscured by walls.
2019-09-15 19:00:28 +02:00
Xanthous.Data.EntityMap.Graphics
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
Xanthous.Data.Levels
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.NestedMap
Add a drop command Add a drop command, bound to 'd', which prompts the character for an item in their inventory, removes it from the inventory, and places it on the ground. Along the way I had to fix a bug in the `EntityMap.atPosition` lens, which was always appending to the existing entities at the position on set, without removing the entities that were already there - the rabbit hole of quickchecking the lens laws here also lead to replacing the target of this lens with a newtype called `VectorBag`, which ignores order (since the entitymap makes no guarantees about order of entities at a given position).
2019-12-23 18:19:51 +01:00
Xanthous.Data.VectorBag
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.Entities.Character
Put a test gormlak on the screen Implement a concrete "Creature" entity, and place one on the screen at the game startup for testing. This revealed a bug with drawing when getting the maximum entity position, but that appears to be fixed now (yay)
2019-09-02 20:45:36 +02:00
Xanthous.Entities.Creature
Decouple Gormlak AI from creatures Decouple the definition of the Gormlak AI from the creature type itself using generic lenses and a "HasVisionRadius" typeclass, to begin to untangle the hs-boot web of circular dependencies. This actually *increases* the number of hs-boot files from 1 to 2, but both of the source imports that use them are single-instance (unlike gormlak AI which I would expect to grow linearly with the growth of the game), plus at least one should be able to go away once we remove collision from the game lenses module and move it into something defined in the entity class itself.
2020-01-03 18:41:48 +01:00
Xanthous.Entities.Creature.Hippocampus
Convert generated levels to walls Add support for converting generated levels to walls, and merge one into the entity map at the beginning of the game. There's nothing here that guarantees the character ends up *inside* the level though (they almost always don't) so that'll have to be slotted into the level generation process.
2019-09-10 02:54:33 +02:00
Xanthous.Entities.Draw.Util
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
Xanthous.Entities.Entities
Convert generated levels to walls Add support for converting generated levels to walls, and merge one into the entity map at the beginning of the game. There's nothing here that guarantees the character ends up *inside* the level though (they almost always don't) so that'll have to be slotted into the level generation process.
2019-09-10 02:54:33 +02:00
Xanthous.Entities.Environment
Add items and inventory Add a new "Item" entity, which pulls from the previously-existent ItemType raw, and add a "PickUp" command which takes the (currently *only*) item off the ground and puts it into the inventory.
2019-09-19 19:56:14 +02:00
Xanthous.Entities.Item
feat(xan): Use Witherable in the prelude Install the witherable library, expose it in the prelude, and update all call sites that are broken by that change. This is a really nice library, and basically the ideal abstraction layer for what it does. Change-Id: I640e099318c1ecce0ad483bc336c379698bdab88 Reviewed-on: https://cl.tvl.fyi/c/depot/+/725 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-28 22:43:20 +02:00
Xanthous.Entities.Marker
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.Raws
Xanthous.Entities.RawTypes
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
Xanthous.Game
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.Game.Arbitrary
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
Xanthous.Game.Draw
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
Xanthous.Game.Env
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.Game.Lenses
Add the beginnings of a prompt system Add the beginnings of a generic prompt system, with exclusive support atm for string prompts, and test it out by asking the character for their name at startup
2019-09-20 18:03:30 +02:00
Xanthous.Game.Prompt
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.Game.State
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
Xanthous.Generators
Xanthous.Generators.CaveAutomata
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.Generators.Dungeon
Place the chacracter in the level at startup time Randomly select a position in the largest contiguous region of the generated level in which to place the character at startup time.
2019-09-13 21:24:05 +02:00
Xanthous.Generators.LevelContents
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
Xanthous.Generators.Util
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.Generators.Village
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.Messages
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.Template
Link up messages to the overall game Add a "say" function for saying messages within an app monad to the user, and link everything up to display them and track their history
2019-09-01 22:21:45 +02:00
Xanthous.Monad
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.Orphans
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
Xanthous.Prelude
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.Random
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.Util
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
Xanthous.Util.Comonad
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.Graph
Progressively reveal the map to the player As the character walks around the map, progressively reveal the entities on the map to them, using an algorithm based on well known circle-rasterizing and line-rasterizing algorithms to calculate lines of sight that are potentially obscured by walls.
2019-09-15 19:00:28 +02:00
Xanthous.Util.Graphics
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.Inflection
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
Xanthous.Util.JSON
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.Optparse
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
Xanthous.Util.QuickCheck
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
other-modules:
Paths_xanthous
hs-source-dirs:
src
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
default-extensions: BlockArguments ConstraintKinds DataKinds DeriveAnyClass DeriveGeneric DerivingStrategies DerivingVia FlexibleContexts FlexibleInstances FunctionalDependencies GADTSyntax GeneralizedNewtypeDeriving KindSignatures LambdaCase MultiWayIf NoImplicitPrelude NoStarIsType OverloadedStrings PolyKinds RankNTypes ScopedTypeVariables TupleSections TypeApplications TypeFamilies TypeOperators ViewPatterns
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
ghc-options: -Wall
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
build-depends:
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
JuicyPixels
, MonadRandom
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
, QuickCheck
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
, Rasterific
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
, aeson
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
, array
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, async
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
, base
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
, bifunctors
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
, brick
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
, checkers
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
, classy-prelude
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
, comonad
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
, comonad-extras
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
, constraints
, containers
refactor(xan): Switch to V2 over tuples most places These are generally rather nicer to work due to some typeclass instances, and integrate better with other ecosystems for things like linear algebra etc. Change-Id: I546c8da7b17234648f3d612b28741c1fded25447 Reviewed-on: https://cl.tvl.fyi/c/depot/+/910 Tested-by: BuildkiteCI Reviewed-by: glittershark <grfn@gws.fyi>
2020-07-04 02:32:36 +02:00
, criterion
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
, data-default
, deepseq
Prompt before overwriting files when saving When saving the game to a file that already exists, prompt for whether or not to overwrite the file. Since this was the first instance of a prompt triggered by another prompt, this also had to do a minor fix to swap the order of completing the prompt and clearing it, so that we don't submit the prompt and then immediately clear it.
2019-12-31 17:09:18 +01:00
, directory
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
, fgl
, fgl-arbitrary
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
, file-embed
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
, filepath
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
, generic-arbitrary
Add items and inventory Add a new "Item" entity, which pulls from the previously-existent ItemType raw, and add a "PickUp" command which takes the (currently *only*) item off the ground and puts it into the inventory.
2019-09-19 19:56:14 +02:00
, generic-lens
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
, generic-monoid
, groups
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
, hgeometry
, hgeometry-combinatorial
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
, lens
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, lifted-async
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
, linear
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
, megaparsec
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, mmorph
, monad-control
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
, mtl
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
, optparse-applicative
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
, parallel
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
, parser-combinators
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
, pointed
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
, quickcheck-instances
, quickcheck-text
, random
Tweak gormlak movement slightly - Don't let gormlaks run into things like walls or each other - Add a small element of randomness to gormlaks' motion - Increase gormlaks' vision by a large amount
2019-09-28 21:02:30 +02:00
, random-extras
, random-fu
, random-source
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
, raw-strings-qq
, reflection
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
, semigroupoids
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
, stache
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
, streams
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
, text
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
, text-zipper
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
, tomland
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
, transformers
Allow eating edible items Add menu support to the prompt system, and an "Eat" command that prompts for an item to eat and eats the item the character specifies, restoring an amount of hitpoints configurable via the item raw type.
2019-10-06 18:50:29 +02:00
, vector
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
, vty
feat(xan): Use Witherable in the prelude Install the witherable library, expose it in the prelude, and update all call sites that are broken by that change. This is a really nice library, and basically the ideal abstraction layer for what it does. Change-Id: I640e099318c1ecce0ad483bc336c379698bdab88 Reviewed-on: https://cl.tvl.fyi/c/depot/+/725 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-28 22:43:20 +02:00
, witherable
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
, yaml
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
, zlib
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
default-language: Haskell2010
executable xanthous
main-is: Main.hs
other-modules:
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
Data.Aeson.Generic.DerivingVia
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.AI.Gormlak
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
Xanthous.App
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
Xanthous.App.Autocommands
Xanthous.App.Common
Xanthous.App.Prompt
Xanthous.App.Time
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.Command
Xanthous.Data
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
Xanthous.Data.App
Factor out an EntityAttributes type Factor out a new EntityAttributes type from some of the methods of the Entity class, to avoid the proliferation of 1-argument boolean methods on the entity class that always have to be forwarded through the Entity instance for SomeEntity if they have defaults (forgetting to do which has wasted tons of my time up to this point). Currently blocksVision, blocksObject, and collision are all in there.
2020-02-08 23:24:27 +01:00
Xanthous.Data.Entities
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
Xanthous.Data.EntityChar
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.Data.EntityMap
Progressively reveal the map to the player As the character walks around the map, progressively reveal the entities on the map to them, using an algorithm based on well known circle-rasterizing and line-rasterizing algorithms to calculate lines of sight that are potentially obscured by walls.
2019-09-15 19:00:28 +02:00
Xanthous.Data.EntityMap.Graphics
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
Xanthous.Data.Levels
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.NestedMap
Add a drop command Add a drop command, bound to 'd', which prompts the character for an item in their inventory, removes it from the inventory, and places it on the ground. Along the way I had to fix a bug in the `EntityMap.atPosition` lens, which was always appending to the existing entities at the position on set, without removing the entities that were already there - the rabbit hole of quickchecking the lens laws here also lead to replacing the target of this lens with a newtype called `VectorBag`, which ignores order (since the entitymap makes no guarantees about order of entities at a given position).
2019-12-23 18:19:51 +01:00
Xanthous.Data.VectorBag
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.Entities.Character
Put a test gormlak on the screen Implement a concrete "Creature" entity, and place one on the screen at the game startup for testing. This revealed a bug with drawing when getting the maximum entity position, but that appears to be fixed now (yay)
2019-09-02 20:45:36 +02:00
Xanthous.Entities.Creature
Decouple Gormlak AI from creatures Decouple the definition of the Gormlak AI from the creature type itself using generic lenses and a "HasVisionRadius" typeclass, to begin to untangle the hs-boot web of circular dependencies. This actually *increases* the number of hs-boot files from 1 to 2, but both of the source imports that use them are single-instance (unlike gormlak AI which I would expect to grow linearly with the growth of the game), plus at least one should be able to go away once we remove collision from the game lenses module and move it into something defined in the entity class itself.
2020-01-03 18:41:48 +01:00
Xanthous.Entities.Creature.Hippocampus
Convert generated levels to walls Add support for converting generated levels to walls, and merge one into the entity map at the beginning of the game. There's nothing here that guarantees the character ends up *inside* the level though (they almost always don't) so that'll have to be slotted into the level generation process.
2019-09-10 02:54:33 +02:00
Xanthous.Entities.Draw.Util
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
Xanthous.Entities.Entities
Convert generated levels to walls Add support for converting generated levels to walls, and merge one into the entity map at the beginning of the game. There's nothing here that guarantees the character ends up *inside* the level though (they almost always don't) so that'll have to be slotted into the level generation process.
2019-09-10 02:54:33 +02:00
Xanthous.Entities.Environment
Add items and inventory Add a new "Item" entity, which pulls from the previously-existent ItemType raw, and add a "PickUp" command which takes the (currently *only*) item off the ground and puts it into the inventory.
2019-09-19 19:56:14 +02:00
Xanthous.Entities.Item
feat(xan): Use Witherable in the prelude Install the witherable library, expose it in the prelude, and update all call sites that are broken by that change. This is a really nice library, and basically the ideal abstraction layer for what it does. Change-Id: I640e099318c1ecce0ad483bc336c379698bdab88 Reviewed-on: https://cl.tvl.fyi/c/depot/+/725 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-28 22:43:20 +02:00
Xanthous.Entities.Marker
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.Raws
Xanthous.Entities.RawTypes
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
Xanthous.Game
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.Game.Arbitrary
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
Xanthous.Game.Draw
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
Xanthous.Game.Env
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.Game.Lenses
Add the beginnings of a prompt system Add the beginnings of a generic prompt system, with exclusive support atm for string prompts, and test it out by asking the character for their name at startup
2019-09-20 18:03:30 +02:00
Xanthous.Game.Prompt
Implement the start of creature AI Add a Brain class, which determines for an entity the set of moves it makes every step of the game, and begin to implement that for gormlaks. The idea here is that every step of the game, a gormlak will move towards the furthest-away wall it can see.
2019-09-28 19:20:57 +02:00
Xanthous.Game.State
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
Xanthous.Generators
Xanthous.Generators.CaveAutomata
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.Generators.Dungeon
Place the chacracter in the level at startup time Randomly select a position in the largest contiguous region of the generated level in which to place the character at startup time.
2019-09-13 21:24:05 +02:00
Xanthous.Generators.LevelContents
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
Xanthous.Generators.Util
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.Generators.Village
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.Messages
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.Template
Link up messages to the overall game Add a "say" function for saying messages within an app monad to the user, and link everything up to display them and track their history
2019-09-01 22:21:45 +02:00
Xanthous.Monad
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.Orphans
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
Xanthous.Prelude
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.Random
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.Util
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
Xanthous.Util.Comonad
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.Graph
Progressively reveal the map to the player As the character walks around the map, progressively reveal the entities on the map to them, using an algorithm based on well known circle-rasterizing and line-rasterizing algorithms to calculate lines of sight that are potentially obscured by walls.
2019-09-15 19:00:28 +02:00
Xanthous.Util.Graphics
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.Inflection
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
Xanthous.Util.JSON
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.Optparse
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
Xanthous.Util.QuickCheck
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
Paths_xanthous
hs-source-dirs:
src
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
default-extensions: BlockArguments ConstraintKinds DataKinds DeriveAnyClass DeriveGeneric DerivingStrategies DerivingVia FlexibleContexts FlexibleInstances FunctionalDependencies GADTSyntax GeneralizedNewtypeDeriving KindSignatures LambdaCase MultiWayIf NoImplicitPrelude NoStarIsType OverloadedStrings PolyKinds RankNTypes ScopedTypeVariables TupleSections TypeApplications TypeFamilies TypeOperators ViewPatterns
Fix an injectivity issue with saving the game Fix an injectivity issue with JSON-encoding the entity map that was causing the game saving to not properly round-trip. As part of this, there's a refactor to the internals of the entity map to use sets instead of vectors, which should also get us a nice perf boost.
2019-11-30 21:00:39 +01:00
ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N -O2
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
build-depends:
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
JuicyPixels
, MonadRandom
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
, QuickCheck
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
, Rasterific
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
, aeson
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
, array
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, async
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
, base
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
, bifunctors
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
, brick
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
, checkers
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
, classy-prelude
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
, comonad
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
, comonad-extras
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
, constraints
, containers
refactor(xan): Switch to V2 over tuples most places These are generally rather nicer to work due to some typeclass instances, and integrate better with other ecosystems for things like linear algebra etc. Change-Id: I546c8da7b17234648f3d612b28741c1fded25447 Reviewed-on: https://cl.tvl.fyi/c/depot/+/910 Tested-by: BuildkiteCI Reviewed-by: glittershark <grfn@gws.fyi>
2020-07-04 02:32:36 +02:00
, criterion
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
, data-default
, deepseq
Prompt before overwriting files when saving When saving the game to a file that already exists, prompt for whether or not to overwrite the file. Since this was the first instance of a prompt triggered by another prompt, this also had to do a minor fix to swap the order of completing the prompt and clearing it, so that we don't submit the prompt and then immediately clear it.
2019-12-31 17:09:18 +01:00
, directory
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
, fgl
, fgl-arbitrary
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
, file-embed
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
, filepath
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
, generic-arbitrary
Add items and inventory Add a new "Item" entity, which pulls from the previously-existent ItemType raw, and add a "PickUp" command which takes the (currently *only*) item off the ground and puts it into the inventory.
2019-09-19 19:56:14 +02:00
, generic-lens
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
, generic-monoid
, groups
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
, hgeometry
, hgeometry-combinatorial
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
, lens
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, lifted-async
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
, linear
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
, megaparsec
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, mmorph
, monad-control
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
, mtl
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
, optparse-applicative
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
, parallel
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
, parser-combinators
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
, pointed
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
, quickcheck-instances
, quickcheck-text
, random
Tweak gormlak movement slightly - Don't let gormlaks run into things like walls or each other - Add a small element of randomness to gormlaks' motion - Increase gormlaks' vision by a large amount
2019-09-28 21:02:30 +02:00
, random-extras
, random-fu
, random-source
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
, raw-strings-qq
, reflection
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
, semigroupoids
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
, stache
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
, streams
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
, text
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
, text-zipper
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
, tomland
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
, transformers
Allow eating edible items Add menu support to the prompt system, and an "Eat" command that prompts for an item to eat and eats the item the character specifies, restoring an amount of hitpoints configurable via the item raw type.
2019-10-06 18:50:29 +02:00
, vector
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
, vty
feat(xan): Use Witherable in the prelude Install the witherable library, expose it in the prelude, and update all call sites that are broken by that change. This is a really nice library, and basically the ideal abstraction layer for what it does. Change-Id: I640e099318c1ecce0ad483bc336c379698bdab88 Reviewed-on: https://cl.tvl.fyi/c/depot/+/725 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-28 22:43:20 +02:00
, witherable
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
, xanthous
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
, yaml
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
, zlib
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
default-language: Haskell2010
test-suite test
type: exitcode-stdio-1.0
main-is: Spec.hs
other-modules:
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
Test.Prelude
Factor out an EntityAttributes type Factor out a new EntityAttributes type from some of the methods of the Entity class, to avoid the proliferation of 1-argument boolean methods on the entity class that always have to be forwarded through the Entity instance for SomeEntity if they have defaults (forgetting to do which has wasted tons of my time up to this point). Currently blocksVision, blocksObject, and collision are all in there.
2020-02-08 23:24:27 +01:00
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
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
Xanthous.Data.EntityMap.GraphicsSpec
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.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
Xanthous.Data.LevelsSpec
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
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.DataSpec
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
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
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
Xanthous.Generators.UtilSpec
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
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
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
Xanthous.RandomSpec
Progressively reveal the map to the player As the character walks around the map, progressively reveal the entities on the map to them, using an algorithm based on well known circle-rasterizing and line-rasterizing algorithms to calculate lines of sight that are potentially obscured by walls.
2019-09-15 19:00:28 +02:00
Xanthous.Util.GraphicsSpec
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
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
Allow eating edible items Add menu support to the prompt system, and an "Eat" command that prompts for an item to eat and eats the item the character specifies, restoring an amount of hitpoints configurable via the item raw type.
2019-10-06 18:50:29 +02:00
Xanthous.UtilSpec
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
Paths_xanthous
hs-source-dirs:
test
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
default-extensions: BlockArguments ConstraintKinds DataKinds DeriveAnyClass DeriveGeneric DerivingStrategies DerivingVia FlexibleContexts FlexibleInstances FunctionalDependencies GADTSyntax GeneralizedNewtypeDeriving KindSignatures LambdaCase MultiWayIf NoImplicitPrelude NoStarIsType OverloadedStrings PolyKinds RankNTypes ScopedTypeVariables TupleSections TypeApplications TypeFamilies TypeOperators ViewPatterns
Fix an injectivity issue with saving the game Fix an injectivity issue with JSON-encoding the entity map that was causing the game saving to not properly round-trip. As part of this, there's a refactor to the internals of the entity map to use sets instead of vectors, which should also get us a nice perf boost.
2019-11-30 21:00:39 +01:00
ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N -O0
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
build-depends:
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
JuicyPixels
, MonadRandom
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
, QuickCheck
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
, Rasterific
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
, aeson
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
, array
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, async
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
, base
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
, bifunctors
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
, brick
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
, checkers
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
, classy-prelude
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
, comonad
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
, comonad-extras
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
, constraints
, containers
refactor(xan): Switch to V2 over tuples most places These are generally rather nicer to work due to some typeclass instances, and integrate better with other ecosystems for things like linear algebra etc. Change-Id: I546c8da7b17234648f3d612b28741c1fded25447 Reviewed-on: https://cl.tvl.fyi/c/depot/+/910 Tested-by: BuildkiteCI Reviewed-by: glittershark <grfn@gws.fyi>
2020-07-04 02:32:36 +02:00
, criterion
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
, data-default
, deepseq
Prompt before overwriting files when saving When saving the game to a file that already exists, prompt for whether or not to overwrite the file. Since this was the first instance of a prompt triggered by another prompt, this also had to do a minor fix to swap the order of completing the prompt and clearing it, so that we don't submit the prompt and then immediately clear it.
2019-12-31 17:09:18 +01:00
, directory
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
, fgl
, fgl-arbitrary
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
, file-embed
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
, filepath
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
, generic-arbitrary
Add items and inventory Add a new "Item" entity, which pulls from the previously-existent ItemType raw, and add a "PickUp" command which takes the (currently *only*) item off the ground and puts it into the inventory.
2019-09-19 19:56:14 +02:00
, generic-lens
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
, generic-monoid
, groups
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
, hgeometry
, hgeometry-combinatorial
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
, lens
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
, lens-properties
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, lifted-async
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
, linear
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
, megaparsec
Add a very basic, naive auto-move command Add a very basic, naive auto-move command, which just steps the player in a direction until they collide with something, regardless of any surrounding beasties who might want to eat them. There's a lot of other stuff going on here - in order to get this working the way I wanted with a slight (I settled on 50ms) delay between every step in these autocommands while still redrawing in between I had to do all the extra machinery for custom Brick events with a channel, and then at the same time adding the bits for actually executing autocommands in a general fashion (because there will definitely be more!) hit my threshold for size for App.hs which sent me on a big journey to break it up into smaller files -- which seems actually like it was quite successful. Hopefully this will help with compile times too, though App.hs is still pretty slow (maybe more to do here).
2020-05-12 05:03:21 +02:00
, mmorph
, monad-control
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
, mtl
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
, optparse-applicative
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
, parallel
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
, parser-combinators
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
, pointed
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
, quickcheck-instances
, quickcheck-text
, random
Tweak gormlak movement slightly - Don't let gormlaks run into things like walls or each other - Add a small element of randomness to gormlaks' motion - Increase gormlaks' vision by a large amount
2019-09-28 21:02:30 +02:00
, random-extras
, random-fu
, random-source
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
, raw-strings-qq
, reflection
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
, semigroupoids
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
, stache
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
, streams
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
, tasty
, tasty-hunit
, tasty-quickcheck
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
, text
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
, text-zipper
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
, tomland
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
, transformers
, vector
, vty
, witherable
, xanthous
, yaml
, zlib
default-language: Haskell2010
benchmark benchmark
type: exitcode-stdio-1.0
main-is: Bench.hs
other-modules:
Bench.Prelude
Xanthous.Generators.UtilBench
Xanthous.RandomBench
Paths_xanthous
hs-source-dirs:
bench
default-extensions: BlockArguments ConstraintKinds DataKinds DeriveAnyClass DeriveGeneric DerivingStrategies DerivingVia FlexibleContexts FlexibleInstances FunctionalDependencies GADTSyntax GeneralizedNewtypeDeriving KindSignatures LambdaCase MultiWayIf NoImplicitPrelude NoStarIsType OverloadedStrings PolyKinds RankNTypes ScopedTypeVariables TupleSections TypeApplications TypeFamilies TypeOperators ViewPatterns
ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N
build-depends:
JuicyPixels
, MonadRandom
, QuickCheck
, Rasterific
, aeson
, array
, async
, base
, bifunctors
, brick
, checkers
, classy-prelude
, comonad
, comonad-extras
, constraints
, containers
, criterion
, data-default
, deepseq
, directory
, fgl
, fgl-arbitrary
, file-embed
, filepath
, generic-arbitrary
, generic-lens
, generic-monoid
, groups
, hgeometry
, hgeometry-combinatorial
, lens
, lifted-async
, linear
, megaparsec
, mmorph
, monad-control
, mtl
, optparse-applicative
, parallel
, parser-combinators
, pointed
, quickcheck-instances
, quickcheck-text
, random
, random-extras
, random-fu
, random-source
, raw-strings-qq
, reflection
, semigroupoids
, stache
, streams
, text
, text-zipper
, tomland
, transformers
Allow eating edible items Add menu support to the prompt system, and an "Eat" command that prompts for an item to eat and eats the item the character specifies, restoring an amount of hitpoints configurable via the item raw type.
2019-10-06 18:50:29 +02:00
, vector
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
, vty
feat(xan): Use Witherable in the prelude Install the witherable library, expose it in the prelude, and update all call sites that are broken by that change. This is a really nice library, and basically the ideal abstraction layer for what it does. Change-Id: I640e099318c1ecce0ad483bc336c379698bdab88 Reviewed-on: https://cl.tvl.fyi/c/depot/+/725 Reviewed-by: glittershark <grfn@gws.fyi>
2020-06-28 22:43:20 +02:00
, witherable
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
, xanthous
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
, yaml
Implement saving+loading the game Implement ToJSON and FromJSON for all of the various pieces of the game state, and add a pair of functions saveGame/loadGame implementing a prism to save the game as zlib-compressed JSON. To test this, there's now Arbitrary, CoArbitrary, and Function instances for all the parts of the game state - to get around circular imports with the concrete entities this unfortunately is happening via orphan instances, plus an hs-boot file to break a circular import that was just a little too hard to remove by moving things around. Ugh.
2019-11-29 20:33:52 +01:00
, zlib
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
default-language: Haskell2010
Reference in a new issue Copy permalink