[20:29:50] [INFO] EdgeQuest Start
[20:29:50] [INFO] Theme set: torchlight
[20:29:50] [SEVERE] AssertionError: Looks like there is invalid or missing data in the torchlight theme! Using defaults...
----- STACK TRACE: -----------------------------
The stack trace has not been appended to your log file.[20:29:58] [INFO] Selecting theme...
[20:29:58] [INFO] Theme set: magma
[20:29:58] [SEVERE] AssertionError: Looks like there is invalid or missing data in the magma theme! Using defaults...
----- STACK TRACE: -----------------------------
The stack trace has not been appended to your log file.

It would make it so much easier to add/remove config options since we could just directly serialize them at once and not have to worry about a custom error scheme.

By the end of this Nick should

• Understand rust and rust concepts
• Understand design of the game

Since both of these are similar in implementation, let's combine them as issues. Here are some things we want:

Sound

• Sound must travel radially outward from some point. We should give some function a point, an amplitude, and a map of tiles, and it would update the tiles with the proper sound values.
• Actions must have sound attributed to them somehow. Looking for suggestions on how to do such a thing

Scent

• Proof of concept AI should be made that uses scent to track things.
• Discussion of what scents are necessary in the game should be had.
• Refinement of scent related functions should take place.

https://gyazo.com/102850950427740e6bb6f433408f2ac0
idk what to do. I installed Python 2.7

A* pathfinding freezes

What Happened

A* pathfinding gets stuck in an infinite loop where it cannot push the tamed mob out of the way

What Should have Happened

Movement of the player should displace the tamed mob

Steps to reproducing

1. Go into corridor
2. Have tamed mob following
3. Mouse click on other side of tamed mob

When you disable FOV, the following message is printed: "Your third eye closes, concealing the universe in fog.". This message should instead print when FOV is enabled. The same occurs when enabling FOV - instead of printing the above message, it prints the message associated with opening your third eye.

This also implies that Cellular Automata need to fundamentally change how they generate/check maps.

I have used the latest version and i rekt gaben lord of steam but no stairs will spawn

Description:
FOV and AI break upon generation of the world. This causes the player to be unable to see the area around them (the area would normally be illuminated by the player's FOV). In addition, NPCs such as the ant and cat will not take turns, which is visible if FOV is turned off. Strangely all issues are resolved if the player attempts to walk into a wall followed by walking away from the wall immediately after.

Reproduce:
To see FOV break:

1. Start the game.
2. Press "w" to re-generate the world. Notice that, for all world generations other than the first, FOV breaks immediately and you are unable to see any tiles other than your player tile (unless FOV is turned off).

To see AI break:

1. Start the game.
2. Turn FOV off (to avoid the above mentioned issue).
3. Press "w" to generate worlds until the player does not spawn directly next to a wall.
4. Move around, taking care not to stand directly next to any walls. Notice that NPCs are entirely still, and do not move as their AI dictates.

To temporarily resolve the issue:

1. Start the game.
2. Follow either of the above directions to get the game into a bugged state.
3. Move your player until it is directly adjacent to a wall.
4. Take a turn moving directly into the wall.
5. Take a turn moving away from the wall. Notice that NPCs start taking turns again, and FOV is fixed.

Dungeon needs more low-level, architectural work done. Related to #45 though not exactly.

• Dungeon generation relies on a series of "filters" but they have a fairly loose definition. It would be constructive to further abstract these systems into Filter traits such that upon being given a list of such filters, an apply() or such can be ran to add the filter onto the dungeon map. This would solidify dungeon generation and make it slightly more comprehendible and gives a better interface for adding changes.
• The structure system is ass and that whole file needs a ton of work to get it to an acceptable level.
• I HATE having to do dungeon.grid it makes NO sense, what is the dungeon if the meaningful details are stored within the grid? I would love it if dungeon both had implementation and also was indexable. Maybe we can impl a trait for this? Basically I just want to hide Grid from anything that's not a Dungeon

Water renders improperly as a background for creatures. Issue revolves around how water changes color and that color isn't updated for entity backgrounds on that tile.

"volcanic": {
"highlight": {
"wall": "#ff0000",
"ground": "#ff0000"
},
"ground": {
"light": "#cc1111",
"dark": "#22"
},
"wall": {
"light": "#333333",
"dark": "#000000"
},
"accent": {
"light": "#ffffff"
}
},

Game is a singleton as of right now. I see no reason why we can't just consolidate the two together and form some Engine struct. (Alternatively call it Edgequest or whatever we choose to name/rename the game). This would directly make managing the issue raised in #49 as now the Engine would be able to keep track of the renderer, keypresses, root console, debug flags, etc.

Makes game too easy.

Edgequest cannot run on the apple macbook operating system. This OS is technically not supported, however I'll attempt to work on this problem. If you use a macbook, and have suggestions or problems, leave them under this issue. Thank you

There seems to be a problem with libtcod.

Why.

Pls fix m9.

Lore should be somewhere within /docs ideally however in what format do we store lore? Should we go with an html/js wiki style system or some other method? I personally dislike the use of GitHub wikis, though others may disagree.

We should propose ideas and then take the one we like the most and start trying to use that.

doesnt work in rust OS, will give it 8/8 once fixed

• pub fn load(path: &str) -> Config should probably be something like pub fn load(path: &str) -> Result<Config, WhateverThisIs>

We currently use .em which apparently is for ember script so I'm hoping we can figure out an appropriate extension that won't make it seem like this is somehow a Rust + JS project.

Creature and Fighter are two structs that are very much tied into one another, however it seems like they overlap in terms of what they do:

• Creature has scent, state, ai, and a Fighter that it holds.
• Fighter has a position, glyph, color, and name.

It seems like that a Creature should be the struct that should have a name, and/or possibly a Fighter is the struct that should have a scent. As we move forward:

1. How should we best organize Fighters and Creatures?
2. Which one gets stats?

When using the built-in A* algorithm for moving to an explored tile, the game suddenly locks up and freezes. Please limit your use of this functionality until the bug is fixed.

Feature/Issue

Clippy is a linter that shows where code can be improved, it's in the CI but complains about a list of things that could be improved.

Breakdown

Add a detailed breakdown of how you plan to tackle the issue. Task manager optional.

• Address all warnings
• Determine which to allow and which to fix

By the end, all warnings should be gone.

The renderer could benefit from a Screen trait that has some draw_all() method implemented. This would allow the renderer to hold some Box<Screen> and allow the game to swap such screens in and out. This would allow for things such as UI screens, a main game screen, etc that could be modularly hot swapped on a button press.

The scent system (and associated structs) is very dependent on a C-like idea where it is implied that the ScentType enum has some variant that represents the total number of variants as an integer. Since rust can't do this, we have a SCENT_TYPES const to hold that number. There must be a better, more idiomatic rust way of thinking to solve this.

Dungeons could use a system where premade structures are added in to make things more interesting.

• Implement basic framework (Probably some Builder object or altogether new crate)
• Implement ability to read structures from files
• Implement ability to take said structures, turn them into tiles, and then update the dungeon map with them

Describe the bug
During normal game play (about 10 or so seconds from launching the game), taking a turn will cause the game to crash for the following error:
thread 'main' panicked at 'index out of bounds: the len is 100 but the index is 18446744073709551615', C:\projects\rust\src\libcore\slice\mod.rs:865:10

To Reproduce
This bug is easy to reproduce, but occurs for an unknown reason.
Walk around in-game. That's it. It'll happen eventually.

Expected behavior
Edgequest should not crash for index-out-of-range reasons.

Desktop

• OS: Windows 10

Describe the bug
In some dungeons the stairs may spawn in unreachable locations.

To Reproduce
Steps to reproduce the behavior:

1. Start game
2. Toggle FOV off
3. Regenerate floors until one spawns with unreachable stairs, either up or down

Expected behavior
All dungeons should be able to be traversable, that is, a walkable path from up stair to down stair can be made that does not cross over hazards.

Additional context
Can probably fixed by on first map generation, check if a solid path can be made from up stair to down stair with tcod's built in A* algorithm.

As discussed in #43:

• Change Figther to Actor
• Create some temp Stats struct
• Make AI take in Stats

Maybe have a shell file that gets and unpacks simplejson and other large files?

If that is not a viable option, doing everything in a Python script might work...

What types of improvements would you like to see in dungeons? So far we want

• Biome system
• More plant life
• Better generation techniques
• Structures (See #38)

If you have any ideas feel free to list them below.

(precise)fleck@localhost:~/Downloads/edgequest-master$ python2.7 edgequest.py
Traceback (most recent call last):
File "edgequest.py", line 9, in
import simplejson as json
ImportError: No module named simplejson

Ties into #47 as screens will be necessary to complete.

The goal is to have some sort of navigable main menu screen, but how is this to be done? The simplest answer is to have the Engine update Screens in the Renderer and have the Engine capture input of the player navigating around the options. I think its possible to have:

• Name entry
• Race selection (Which raises the question of lore)

at the very minimum to prove this is possible.

perhaps add a rare item that allows you to tame a monster. Add a level system to the monsters and make it so the item only works on a monster that is less than yours. Or add a new skill that you can level up to make monsters your allies when you use a spell.

Makes no sense for the renderer to know about these things. Game should know and be able to call specific functions of other things depending on these flags.

The next EdgeQuest release, v0.0.4 'Squirrel', is going to come out soon.

Are there any last minute bells and whistles that should be added to EdgeQuest? Are there any bugs you've found? Do you have ideas for enhancements gameplay-wise or for the technical side of EdgeQuest? Please tell me below.

As of right now I want to have:

• A better wiki
• Better combat balance
• More people playing the game

Thank you all for supporting EdgeQuest thus far.

Feature/Issue

Good roguelikes are separated from others based off several key features, one of which is a comprehensive speed and time system. The idea here is to incorporate a simple time system detailed here.

Possible issues

Several considerations to the existing architecture will need to be considered:

Unknowns

• How will creatures be ordered into the queue? The player will go first but how will other creatures organize themselves? Is it necessary even?
• How will non-creature entities be registered? Poison should proc every time it takes its turn, but how will ownership affect this? Should statuses like poison even have a turn? Should creatures simply hold a vector of properties that get applied every time they take a turn?

It seems like a lot will need to be changed about the ways creatures, AI, and items interact with the world.