We need to find a stack that's best suited for our needs. As such, I propose the following:

We create a POC repository for a program that will listen in on incoming connections. What connections this will be is not important, the format can be either raw UDP, web sockets, HTTP, etc.

General priorities in terms of design:

1. Server infrastructure shouldn't be difficult or costly to maintain, but easily scalable. We should have a server program that can connect to a Redis or MongoDB cluster, but if a user doesn't have access to those resources, then they can host the server on their computer. The approach is similar to Minecraft.
2. The storage of passwords and user information should be avoided because of the above. A solution for figuring out how to authenticate a user from an external server might be ideal here; authentication could be dependent on using homeservers (similar to matrix) so that authentication is decentralized could be one solution.
3. Maintainability (duh!) and compatability with Unity. Using languages that are commonly used by developers is of advantage here. Languages similar to C# may be preferred because of familiarity ( Please don't program the server in C++. ) Moreover, choosing a protocol to interact with the server is crucial here; designing a protocol for raw UDP packets might need to be justified here, since maintaining a library for reading from packets here might be prone to security issues and the like. The protocol should also have some sort of support for Unity. An actively maintained library for Unity may be preferred here.

Server program POC requirements:

• Must listen to any incoming connection using the IP protocol. The specifics of the protocol ( i.e. raw UDP, HTTP, websockets, etc.) doesn't matter as long as it can fill in the requirements.
• Maintain a session for the user (i.e. a status indicating connection) Ideally, have it try to contact or reconnect to the server occasionally.
• Compatible with the AGPL license
• Actively maintained (or maintainable) library for a Unity client to connect to it
• Events communicated to and from the server
• OK with having a user hosting the server from their local network
• Connects to a database (ideally, should be designed so that it's independent of the DB of choice, and perhaps even accept SQLite or some library for file-io so that anyone hosting the server won't have to set up a database connection)

As a developer, I want integration tests and unit tests for my in-game modules so that I am sure that any features I implement will continue to function

Sorting the priorities of 2D assets is a difficult (especially in isometric environments), but necessary task for games. While some of it is achieved, there are still issues with the sorting of map items in Waggington. (Like the dirt patch!).

Sorting is also achieved by using a quick-and-dirty method of positioning the pivot of a tile for the image (and modifying Tiled to account for it), however this isn't ideal. Additionally, for items that tend to span over a couple of tiles, there are usually issues with how the character will underlap or overlap some regions of the item.

An ideal solution would be to have something similar to this video: https://www.youtube.com/watch?v=yRZlVrinw9I

As a user, I want my character's animations to correlate with their movement in the map; I want their sprite to change angles based on the direction they're walking in. I also want them to run or walk in that direction based on what angle they're moving in.

Dependencies:

• Completed Mega-Rig that can be descended from and edited. Should contain all 8 angles
• Minimally one of the Kitty rigs that is arranged so that you can verify the animations work correctly
• 8 animations for each angle of the run cycle
• 8 animations for each angle of the walk cycle

TODO:

• A handler that rotates the charcater based on what angle they have
• The animator and the animations that support it
• Logic for determining whether or not the character is running or walking

Filesizes for the map items generally cause a lot of issues. Not only does the image data consume a substantial amount of memory, none of them are consistent with their sizes and how they should appear in game. Either we:

• Reduce the sizes manually
• Implement some sort of pipeline that reduces the image size in memory
• Fork Tiled so that it can handle sizes of images of smaller resolutions (since unity has a setting to decrease the size)

multiplayer MVP:

• sending player name
• sending player chats
• sending player location
• sending player CrAP data
• moving to a tile

Documentation is generally important for any newcomers who decide to work on the project. Having something written down is generally a good idea for people to not get overwhelmed at the sight of a large codebase. I propose the following for the project:

• Auto-generated documentation for the C# classes
• A style-guide for commits, file names, etc.
• Guides on how to use some of the libraries
• Guides on how to set up and run the repository

It would be nice if this was hosted on a website so that users can easily navigate it. I've thought about using Doxygen, but the HTML might need to be adjusted here.

Some UI assets are duplicates in the Art/UI folders; we should sort those image assets and have unity use one of those files to draw the image.