programminglanguagesclub / elemental-magicks Goto Github PK

Code should be callable from Idris functions and use the C FFI to print out logging information.

If we had a serializer for somewhat arbitrary Idris types, it would be better, but primitive types is fine.

AI should ideally play completely randomly: At every point it has several moves available, play them all with equal probability.

The browser should notify important messages such as when the opponent made a move. We also probably want one for game started, in addition to the users being required to confirm after an opponent is found, to start a game.

This is not a graphic design task;

This is a programming task in Ur/Web.

This game will have a clock that will function much like clocks do in chess.

In Ur/Web, maintain the current time for each player.
On the front end, display the current time for each player.
When the server sends a message to the client, it includes a message about how much time they have left as follows:

(ideally)

The server includes a timestamp of how much time each player has at a particular Unix time.

The client then checks the time and updates its clocks accordingly.

In this way sync is preserved between client and server.

If ever a player runs out of time, they lose the round.

In implementing, remember that updates can be received by a player which is not currently
on-move, but you may assume that every time a request is received,
Ur/Web has the player on-move cached (ultimately from interactions with the backend)

Use Elo, although it is true there are other systems.

This should be built in Ur/Web.
Assume we know the players and the result, and need to update the rating.
Ratings will be stored in the database.

The JS FFI is giving me a lot of trouble. The ultimate goal is to not only have the JS FFI working, but to be able to pass Ur/Web callback functions to JavaScript, or otherwise be able to handle three.js events.

We previously got something working using global pipes.
We now wish to get a version working that is robust to large messages, high throughput, race conditions, etc.

The stack of our project works like this: Two players connect via an HTML interface to an Ur/Web server, which communicates to an Idris backend. Idris will keep persistent state, and Ur/Web will also have access to a database to store more boring values (like account details, etc).

Build a hello world version of this.

Implement solution described here: #25

Ideally, we want to be adding lots of information to the types in Idris. Sometimes there will be ways to add more information into the types than is currently provided, which correspond to stronger guarantees and simpler programs.

Among other things, this should provide a detailed description of the architecture being used for the minimum viable product, as pertains to the card/skill DSL, as well as the database, and also planned refactorings.

It should detail everything else as well, ideally well enough that new programmers can quickly join the project.

I want to use names and operators in the DSL (such as := etc) that already exist in the rest of the code.
For some reason, Idris doesn't seem to like this at all.
Thankfully, other than the name collision problem, Idris makes it very pleasant to build a DSL.

Thus the only task that remains is to write a program that will take a text file and perform a set of textual substitutions from the syntax we want to the actual syntax of the DSL in Idris. There is no structural analysis, etc. One only has to change some keywords.

I do not have a complete list of keywords at the moment, and it may change,
so the program should be capable of arbitrarily performing substitutions.

Implement the core game in Idris.
This is without yet adding any cards.
Just the core functionality needed to play a basic game.
Perhaps a couple cards could be added for test purposed.

We need a system to manage connection of users in Ur/Web now that we have migrated away from Google Accounts.

People should be able to view games, to try different moves (and take them back, etc), to add annotations (commentary), etc. This should be able to run in the browser and also have a nice notation for players to read.

Add code to block all IPs from 2016 presidential red states from accessing and playing the game.

This is to be used to more easily design interesting cards.

The following are important:

The game should automatically resize the canvas to be the maximum size it can be given the current size of the browser window. It must do it seemlessly, and not have any weird rendering issues if the browser window is resized.

It must be able therefore to also resize a representation of text.
The HTML 4 has some issues with this as well, so if there are some hiccups it's okay.

It could make the interface significantly nicer if we could user HTML 5, but it must satisfy these requirements. This could be difficult: It took me a long time to get this working in HTML 4.

Probably using Three.js for Web GL

This applies to all code. We want cleaner, more easily understood, more efficient, etc.

Note that there are already JSON serializers and deserializers which exist,
but we need to be able to marshal the JSON into the appropriate Idris type.

Essentially, we need something like Google Gson but for Idris.

Alternatively, propose an different method of building the interface to the backend.

We need a system to manage accounts now that we have migrated away from Google Accounts.

People should be able to watch existing games. They should also be able to analyze the game with the functionality of the replay system

Clean script should handle removing all of the .ibc, etc files.
We should still have a build script, but should have separate scripts to just build the Ur/Web or Idris part.
I guess we also want one for the C part.
The build script can then call all of these.
Additionally, should probably add a script to typecheck the Idris code but not compile (I think that's possible).

This should include the ability to play against either a human or the computer. In the case of human players, there should both be the ability to challenge players and to randomly duel.

Make sure the game full stack runs fast enough. Diagnose which parts are slow.

In particular, Ord and Eq.

This will make some of the other code somewhat easier.

This can be modeled on the existing domain specific language existing in the prototype of this game.

When updates are delivered to the client, they often will trigger a list of animations.
The user should be able to step through these animations as they desire, skip ahead, go back, etc.
They should also be able to speed up or slow down animations, etc.

This should be implemented together with a system for managing the client-side state of the game.

Can be based on existing HTML front-end. Doesn't have to be too awesome for now.
This is mostly a task of integrating an existing mess into Ur/Web.

Should be somewhat interesting for new players. In other words, should be capable of winning close to 100% of the time against the uniformly random AI.

We already have a representation of bounded numbers:
A number p if of type Bounded n m if n <= p <= m.

This isn't quite enough to represent Hitpoints, however. Hitpoints are bounded, but they're bounded above by Max Hitpoints, which is in term bounded from above and below.

It's possible this isn't too hard if you can create an instance of the Ord (and possibly Eq) typeclass
for Bounded, but it's slightly tricky as Bounded isn't a type but rather a family of types.

Alternatively, there may be another way of doing this.
Perhaps we should require a proof to be passed that hp <= max hp?

Try to find a nice way to do this, and then define transform functions for hp and max hp,
similar to what exists for other stats in the code.

Note: All that is required for this task is to create a type (or family of types) that is useful,
and transform functions to operate on them.

Because there are so many cards in the game, we have to decide how to store them. Should they all be stored in Idris and loaded into the game? Should they be stored as text in a database and loaded into the game when the player picks them? Also, what sorts of animations exist, and which are specific to particular skills? Are any? If any are, then we need to think about when to serve this data to the client.

One additional bit of information is that this database should be searchable. If we intend to put everything in Postgresql for searching, then we might want to only have it there to avoid duplication of data.

On the other hand, if it's in Postgresql, then we need to think about how to verify the stats of the cards using Idris.