CHANGES.txt

== 0.18.3 | 2025-02-23 ==
* Fix major memory leaks

== 0.18.2 | 2025-02-20 ==
* A crash fix relating to the unloading code, which was too eager

== 0.18.1 | 2025-02-14 ==
* Crash fixes

== 0.18.0 | 2025-02-13 ==
* Changed name of "LiSE" to "Lisien" -- thanks to https://webb.page for the name
* Changed name of "ELiDE" to "Elide"
(letters cased like normal English if that's what you're writing,
"elide" and "lisien" in Python)
* Rules may now be designated "big," which will enable an optimization to
  only write the changes they make to the world after they're all computed.
* Neighborhoods get keyframed properly, now, the same as other rule attributes.
* Added Kenney graphics, and changed the default background to Kenney's parchment
* Fixed rules displaying out of order in the stepper
* Fixed dragged objects dropping when they shouldn't
* Improved locking for caches, fixing some intermittent data loss
* Dropped support for Python 3.8 and 3.9

== 0.17.2 | 2024-11-30 ==
* Fix rule poller. It only worked for some rulebook types before.
* Performance improvements as a result of new caching behavior for the above.

== 0.17.1 | 2024-11-09 ==
* Disable editing all throughout ELiDE whenever the simulation is running.
  It was only disabled sometimes, in some parts of the UI.
* Add a button to edit a function card without backing out of the rule editor
* Fix ELiDE crash in Python 3.8 when making more than one new Place or Thing


== 0.17.0 | 2024-10-31 ==
* Overhaul the entire caching infrastructure, which should greatly cut down on
  crashes. No new features, but it does make some changes to the database
  schema.

== 0.16.16 | 2024-10-18 ==
* Fix pawn duplication in ELiDE

== 0.16.15 | 2024-10-16 ==
* Fix a different way pawns could disappear in ELiDE

== 0.16.14 | 2024-10-16 ==
* Fix disappearing pawns in ELiDE

== 0.16.13 | 2024-10-16 ==
* Fix worker process states getting desynchronized when you made a new character
* Fix methods not being callable in worker processes
* Improved performance when planning a lot of future state
* Made the LiSE engine itself an Executor, which I guess breaks compatibility.
	Whatever, zerover makes no promises. Use `Engine.submit(..)` to schedule
	computation in worker processes now.
* Made ELiDE's stat list scrollable

== 0.16.2 & 0.16.12 | 2024-10-14 ==
* Fix ELiDE crash when adding graph-shaped world state to a grid-shaped world

== 0.16.1 | 2024-10-13 ==
* Fix some incoherent world state that could result from doing things
	on tick zero of turn zero, if you started the world with a NetworkX graph.
* Fix a rule running when it shouldn't have in the wolfsheep example

== 0.16.0 | 2024-10-11 ==
* A process pool. When you've stored a function in LiSE, you can `submit` it
	to `Engine.pool.submit(..)` using the standard Python
	`concurrent.futures.Executor` API. The worker processes all have read-only
	views on the state of the simulation.
* Trigger functions now run in parallel by default. Set the `workers` option
	to 0 to disable this.
* Neighborhoods. If your rule only runs when something changes near the Thing
	or Place it runs on, you can indicate this by setting the rule's
	neighborhood property to an integer, and your sim will run faster.
	See "Getting started" in the README for an example.
* ELiDE once again updates its graphics in response to events in the LiSE core
	-- set the "_image_paths" of a `Thing` or `Place` object to a list of
	paths.


== 0.15.9 | 2024-09-01 ==
* More data corruption fixes

== 0.15.8 | 2024-09-01 ==
* More concurrency fixes

== 0.15.7 | 2024-08-27 ==
* A variety of database corruption fixes

== 0.15.6 | 2024-08-16 ==
* Fix Thing objects occasionally forgetting their location

== 0.15.5 | 2024-08-10 ==
* Fix a crash when resuming ELiDE in the past of a simulation
* Fix rules sometimes not triggering, based on when the trigger was set

== 0.15.4 | 2024-08-08 ==
* Fix time travel via rule stepper
* Restore the ability to delete Characters
* Even faster interbranch time travel
* Fix a crash when time traveling between times with no changes to the world

== 0.15.3 | 2024-07-22 ==
* More crash fixes

== 0.15.2 | 2024-07-05 ==
* Crash fixes involving time travel
* Speed up interbranch time travel somewhat
* Switch to ruff formatter

== 0.15.1 | 2024-06-24 ==
* Fix another concurrency issue

== 0.15.0 | 2024-06-18 ==
* Automatically unload history, thus minimizing memory usage for long games
    By default, this happens whenever you commit changes to the database.
* Improved support for ELiDE widgets in games
    * New example sim, awareness.py, to demonstrate this
* Moved `game_start` into its own module
* Dropped support for Python 3.7 and the lz4 module
* A lot of fixes regarding thread safety and interprocess sync

== 0.14.2 | 2023-04-27 ==
* Fix the rest of the loader

== 0.14.1 | 2023-04-26 ==
* Fix a loading error when you make two keyframes and then start the engine before the first

== 0.14.0 | 2023-04-07 ==
* Seek bar for time travel in ELiDE, and some other minor UI improvements
* Vastly improved performance in ELiDE for large worlds
* History queries no longer require the whole of history to be loaded, and are faster
	* SQLAlchemy is now a hard dependency
	* numpy is required again
* Save the state of the randomizer every time you use it, not just on time travel
* Rule stepper now works when you reopen the sim
* New example sim, wolfsheep.py
* `enforce_end_of_time` option, so it's not so trivial to make voids of time by accident
* Lots of crash fixes
* yapf formatting, with tabs
* Improved documentation

==0.13.2 | 2022-07-31 ==
* Fix an intermittent error where entity deletion sometimes wouldn't go through all the way
* Performance improvements
* LiSE now saves keyframes on close by default. Change ``keyframe_on_close`` to ``False`` to disable this
* Renamed "modulus" options to end with "interval" instead
* Disable the cache arranger by default

== 0.13.0 | 2022-07-23 ==
* ELiDE now has the Timestream view, easing time travel when history gets complicated
* Rename "avatar" to "unit"
* Nodes now support the `.user.only` property, just like characters' `.unit.only`
* Improve interprocess communication some more, particularly when time travelling between branches
* Tab indentation, with yapf formatting
* Rename some Engine methods to use snake_case
* numpy is no longer required for the LiSE core (will speed up IPC, though)
* Fix a loading error with changes in branches other than trunk
* Crash fixes
* Drop support for Python 3.6

== 0.12.1 | 2021-07-04 ==
* Optimize interprocess synchronization
* Fix some inconsistencies in the rulebook sync
* Crush all of a character's initial state into the one keyframe, fixing integrity problems
* License change; no longer accept later versions of the AGPL
* Support networkx 2.5
* ELiDE changes
  * Rule stepper to help you view the state of the game after one rule's run, just before the next
  * Don't crash when resuming the game on non-trunk branches
  * Fix stats configurator
  * Fix rules configurators
  * Accept a prefix on the command line
  * Grid view shows characters other than the one you started with
  * Dialog options from the game itself don't appear more than requested
  * Fix crash when laying out one-dimensional boards

== 0.11.2 | 2021-04-19 ==
* Fix the branch input in ELiDE
* Performance improvements

== 0.11.1 | 2021-03-17 ==
* Fix a flaw in the keyframes implementation that caused them to overwrite each other when several were made in a single session

== 0.11 | 2021-02-03 ==
* Add support for "keyframes," snapshots of the world state at some specific time. These are currently most useful for supplying the world's initial state by instantiating a Character with a networkx graph, eg. `engine.new_character('new', nx.grid_2d_graph(3, 3))`
    * Drastically improved load times for large initial world states
* Removed the would-be world generation API; for now, use [the networkx graph generators](https://networkx.org/documentation/stable/reference/generators.html), and `LiSE.character.grid_2d_8graph`if you want a square grid that's connected at the corners as well as the sides.
* Removed the "sense" feature. It will need a reimagining at some point. In the meantime you can still use `Character.facade()` to get a transient, mutable view onto a `Character` that won't be saved
* `allegedb` is a submodule of `LiSE` now, and will not be published on its own.
    * Dropped support for graph types other than `DiGraph`
* Dropped support for Python versions prior to 3.6
* Compatibility with msgpack 1.0.0
* ELiDE changes
    * Grid view
    * File browser
    * Grid generator when starting new simulation
    * Symmetrical portals
    * New agenda widget, for scheduling things in the future
      The stat list on the left of the default ELiDE view is technically a calendar now, where an agenda is a related widget class that offers more flexibility to interface designers.
    * Require Kivy 2.0

== 0.10.1 | 2020-01-08 ==
* Compatibility with networkx 2.4
* Smaller database
* Performance improvements
* Default database filename is now 'world.db', and you can instantiate Engine with no arguments


== 0.10 | 2019-03-16 ==
* Improved documentation.
* Improved performance.
* Prevented the user from trying to start the rules engine while it's already running.
* Minor API changes. clear_world and clear_code are now one option, clear
* Any trigger that's going to run in a given turn is now guaranteed to run prior to any prereq or action. This is mostly to prepare for experiments in parallelism.
* If you branch the timeline while stuff is planned for the future, the plan will be copied to the new branch, unless the plan has not yet started.
* Made facades act more like regular characters. They still aren't very useful... I'm planning to add some new API to them that lets you munge and filter their data lazily


== 0.9 | 2018-10-29 ==
This release is for ProcJam 2018.

* Changed license to AGPL3+, but also waive rights in case of my death.
* Switched to semantic versioning.
* Made the frontend experience faster by implementing deltas. Use Engine.get_delta(...) to rapidly generate a dictionary describing changes between two points in time in a single branch.
* Switched serialization format from an abuse of JSON to msgpack.
* Improved the API of the ELiDE widgets, making it easier to use them in your own game. See https://github.com/LogicalDash/DungeonUniversity for an example.
* You can zoom the map with the mousewheel now.
* Reduced memory usage for large worlds. They still take a long time to load; I'll work on that.
* Wrote a real tutorial for building LiSE games in Python outside of ELiDE.
* Made the order of execution for rulebooks easier to understand. Basically, rulebooks are followed in alphabetical order; rules within them go in whatever order they were added.
* Rearranged the UI a little.
* You can edit every rulebook in ELiDE now, including the ones that apply to all a character's avatars and so forth.
* Rules will only be followed for entities that still exist when they're run.
* The turn will always increment *before* running any rules, and no rules will be run on turn 0.
* Various little performance improvements and fixes to things like data integrity.


== Alpha 8 | 2017-10-06 ==
This release is for ProcJam 2017.

* Made the time model more granular. What was formerly called a tick is now a turn, which contains as many ticks as you need.
* Support a rudimentary form of dialog menu for player interaction.
* Rules and rulebooks are now journaled, and may change throughout the game.
* Python source code is no longer stored in SQLite--just plain text files.
* Changed the rule API so that rule functions are only ever called with a single argument, the entity that they apply to.
* ELiDE is now a pure Python module.
* Performance improvements.


=== Alpha 7 | 2017-05-06 ===
* Restructure everything in LiSE around a new caching strategy.
* Generally cleaner UI.
* If all your places are named with pairs of integers, you get automatic grid layout in ELiDE.


=== Alpha 6 | 2016-02-01 ===
* Opening a functions editor no longer crashes the app.
* All the function editors are now in tabs of one screen.
* Nicer auto layout of spots.
* Various smaller fixes.


=== Alpha 5 | 2016-01-03 ===
* A whole new approach to interprocess communication resulting in much more acceptable performance within ELiDE.
* LiSE caches the whole world state.
* ELiDE has a new caching scheme as well. This is invisible to the user but rules out some aliasing bugs.
* Fixed some rules not being polled.
* A new example, college.py, and some fixes to kobold.py where it hadn't kept up with API changes.
* The first sprouts of a world generation API, currently undocumented since I myself don't know how to work with it. Observe its methods within the class AbstractCharacter in the LiSE.character module. Chain the methods together and play around with the order to the best effect.
* Lots of refactoring.
* Some new graphics from Marsh Davies for Procjam 2015. And it's easier to include your own now, with an atlas and a change in elide.ini (though undocumented).
* Real version numbers in the Python packages.


=== Alpha 4 | 2015-08-26 ===
* The rules editor is now usable under normal conditions. After you've made Actions and Triggers, check this out by selecting something and pressing the Rules button.
* The big > button will cause time to pass for so long as it is toggled, as it was always meant to.
* Improvements to input handling and collision detection.
* Less cryptic README.
* Crash fixes.


=== Alpha 3 | 2015-08-11 ===
* Performance improvements.
* Architectural changes in ELiDE.
* Many crash bugs fixed.
* Pop-over windows changed into Screens, making them tidier and enabling transition animations that aren't much to look at presently.
* Thing and Place graphics can now be added in the elide.ini configuration file.


=== Alpha 2 | 2015-03-29 ===
* The core LiSE simulation process and the ELiDE graphical frontend are now running in separate processes.
* Fixed some UI interactions.


=== Alpha 1 | 2015-03-06 ===
* Initial release.