All Classes and Interfaces
Class
Description
Stores rule sets, and allows lookup by name.
Methods for the statistical analysis of game transcripts.
A tool for an easy online testing of arithmetic expression evaluation.
An AutomaticRuleGenerator is used to create multiple rule set
files based on the same pattern.
The AutomaticRuleGenerator demo service.
Can be used to describe the position of a piece on the [1:N]x[1:N] grid,
or that of a bucket (at (0,0), ...
For the training/testing restrictions on boards, as introduced in GS 6.010.
HTML display for user-upload boards (in JSON format), for use by
the ML team (Shubham)
Reading and writing Boards to CSV files
The main class for the Captive Game Server
The "Check my experiment plan" service.
Represents a thing to be compared using the Mann-Whitney-test:
either an algo (which is to be compared with other algos based on
its performance on some rule set), or a rule set (which is being
compare to other rule set based on how a particular algo, or the
set of humans, perform on it).
The description of a single composite ImageObject, or a family
of such objects, obtained by parsing its name
(which may contain wildcards).
A tool for drawing concrete ImageObjects from a family defined by a Composite object,
or a union of such families.
Prepares some information needed for proper URL construction in
our app.
This class is used for a one-off project: converting the list of rules found in
Kevin's GUI (stored in a JSON file there) to text files describing rules
in a similar, but slightly different, format used by our server.
A very simple, stand-alone program that creates necessary Role
entities in the roles table, and at least one User entity.
Represents the entire content of a CSV file.
Stores a comment line from the CSV file.
An annotation describing how, if at all, a particular data field
(content of a SQL database column) is to be displayed in HTML
tables and data entry forms etc.
At present, which pieces are eligible for picking under each of
the existing orders? (For example, which pieces are presently in
the topmost occupied row? Which piece is the first in the English
reading order?) This structure needs to be updated every time a
piece is removed from the board.
An Episode is a single instance of a Game played by a person or
machine with our game server.
Return codes for the /move and /display API web API calls,
and for the MOVE command in the captive game server.
A Move instance describes an [attempted] act of picking a piece
and dropping it into a bucket.
A Pick instance describes the act of picking a piece, without
specifying its destination
An EpisodeInfo instance extends an Episode, containing additional
information related to it being played as part of an
experiment.
Auxiliary data structures for the Episode class, keeping track of
"memory variables".
This is a substitute for something like this:
An arithmetic expression is composed of variables, constants,
and arithmetic operations; parentheses can be used for
ordering operations.
Id:ArithmeticExpression; used in GS 3
Has exactly two operands, and the operator is one of '==',
'!=', 'invalid input: '<'=', '>', etc
Can be overridden as needed
A variable.
A Mapper is something that can take a variable
(Expression.Id) and produce another Expression (e.g.
A HashMap storing a set of values of a given type T for each key
!E evaluates to [1] if E is an empty set, or to [] otherwise
A numeric constant
Values are String or Integer
A.B
[Num..Num]
Additive or multiplicative
A Star expression is simply "*".
Objects in question may be Integer, String, or PropMap
(ImageObject or equivalent)
This class is used to manage extended sessions, which survive over the
web server restart.
Information about the data files the Rule Game web server reads and writes.
Names of subdirectories under "saved"
This data structure is converted to JSON and send to the client in response to the /writeFile web API call.
Auxiliary class for formatting output as plain text of HTML.
For Tanvi: helps the player to generate a unique playerID
A Game object defines how an Episode may be created.
A GameGenerator generates random games (with the same rule set and
randomly created initial boards) based on the provided parameter
range specifications
The "First Batch" of API calls, primarily for use in the research environment, where a player can choose any game to play
The "Second Batch" of API calls, primarily for use with players constrained by an experiment plan, and playing a sequence of games as outlined in the trial list to which the player is assigned.
The page generator for the HTML Play interface.
The HTML wrapper for the First Batch calls, to allow for the "HTML Play".
The socket implementation of a captive game server.
Returns the content of an image file (SVG, PNG, etc) for one of the
pages of the instruction booklet.
Returns the content of the specified page of the instruction booklet
for the specified player
Returns the content of an image file (SVG, PNG, etc) for the
specified shape.
Returns the content of the SVG file for the specified shape
This data structure is converted to JSON and send to the client in response to the /guess web API call.
Convenience routines to determine the host name etc
Drawing boards in HTML.
Auxiliary class for formatting output as HTML.
An exception of this type is thrown when we want to report to the user that
the data he's entered are invalid
Describes an image-and-properties-based object.
An image generator is an object that can be used to obtain a random IPB object.
A Generator interface to a stored list of ImageObjects, from which they can be retrieved
at random.
Methods responsible for parsing CSV files.
Tools for exporting Java objects as JSON structures
Tools for importing Java objects from JSON structures.
Maps "false.someThingXandY" to "X", etc.
As requested by Paul, "Rule Game -- challenge UWisc faculty and staff",
2021-09-23.
The Launch page that allows one to play all rule sets from a specific
subdirectory of the rules directory, such as rules/APP, rules/BRM, or rules/CGS.
The common base for the Launch pages that allows one to play all
rule sets from rules/APP, rules/MLC, and others.
The list of rule sets to be displayed in the Android app
The name refers to the directory from whih trial lists or rule sets
are read
An auxiliary class that can be used to transmit information about
the buttons etc the Android app needs to display
Lists all available shapes
Methods used by CHEETA to log warning and error
messages.
An object that is responsible for getting EntityManager object(s)
for the application.
A MainConfig is a structure storing the content of a configuration file.
Tools for the manager dashboard.
The Mann-Whitney math
Comparing players or rules based on the Mann-Whitney test
An MlcEntry contains the data for a (participant, ruleset, run)
tuple.
An auxiliary class used by the Captive Game Server for the optional
logging of MLC run results.
Supported log file formats
The login page for the MLC results sumbission tool
The back end behind web/mlc/index.jsp
Uploading and processing results files by MLC
participants.
Ranking rule sets by the ease of learning by human players.
An MWSeries object contains the data for one series (group of episodes played by one player under the same rule set) needed to contribute a number to an M-W Comparandum.
Used to control how series are assigned to comparanda
This is an object that's converted to a JSON structure and sent to the client as a response in /GameService2/newEpisode calls.
An Order object describe a built-in or custom ordering of board cells
(positions)
Names of built-in (predefined) orders
All our entities (corresponding to table rows) implement this.
Auxiliary methods for two-player games, introduced in GS 7.*.
A player's current state in the pairing system.
Various incentive schemes available to experiment designers.
This class is used to obtain configuration parameters, from a configuration
file or from Java System Properties.
Represents a piece of a specified type at a specified location.
A flexible replacement for an Enum
Lists experiment plans and the number of players who played them, etc
A PlayerInfo object represent information about a player (what trial list he's in, what episodes he's done etc) stored in the SQL database.
What type of action takes the player to a particular destination?
Where can we go from here?
The object returned by the /player call.
Represents the restrictions on the positions from which game pieces
can be picked.
This class generates games based on a set of predefined initial boards
Retrieving various pages needed by the client to customize the player's pregame and postgame experience.
An HTML page + error code
An HTML page + error code
Some info + error code
This is an auxiliary class, used to read the entire content of a properties
file, and to create ImageObject objects for all image files in the
directory.
Testing Apache Commons methods for MW and KS p-values.
This class generates random games (with the same rule set and
randomly created initial boards) based on the provided parameter
range specifications
This class generates random games (with the same rule set and
randomly created initial boards) using image-and-property based
game pieces based on the provided parameter
range specifications
A bunch of methods to figure what fields a class has, and how to
print them out in a more or less sensible way.
An entry describes one field of the class, complete with its
access methods (getter and setter) and the display hints
Built on top of an Episode object, a ReplayedEpisode is created during
the analysis of transcripts, in order to recreate the episode's events
step by step.
The possible random player models.
The parent class for various structures that are returned, in JSON form,'
by REST calls.
The base of all "results object" classes used in JSP pages
A role is simply a database-storable wrapper around the role name
A RuleSet describes the rules of a game.
Syntax:(counter,shape,color,position,bucketFunctions)
A BucketList represents the information about the destination
buckets given in the "buckets" field of an atom.
The list of "legacy" variables that can be used in the bucket
expression.
A row object represents the content of one line of the rule set
description file, i.e.
A single instance of this class is associated with a particular
session of the Rule Game web app.
Tools for testing a rule set for a possibility of a stalemate.
Utilities for generating SVG plots for ECD data
Used for testing JPA persistence features
An EpisodeInfo instance extends an Episode, containing additional
information related to it being played as part of an
experiment.
A token represents an element of the input text.
Various methods related to generating HTML forms and their
components, and processing requests sent by the web browser when
those forms are filled
An auxiliary class for writing and reading transcript files.
Some of the transcript data read back from a file.
Stores the content of one line (representing one move/pick
attempt) read back from the transcript file
Identifies an experiment plan as a static or dynamic (P: or R: type)
one
Just keeps returning the same game every time
Information about a repeat user (who may own multiple playerId) stored in the SQL database.
Used by LoginServlet and the Android app for registering new users and logging in
Auxiliary methods for manipulating hash tables etc
File copy statistics
See https://docs.oracle.com/javaee/7/tutorial/websocket007.htm or
https://www.baeldung.com/java-websockets
for documentation on encoders
Messages sent to a GUI client to tell it that something is ready
for it, and it can make another /newEpisode or /display call
This is used when a lower-level function can tell a higher-level function
what kind of error it shoudl report to the end user.