All Classes
| Class | Description |
|---|---|
| ActivateBonusWrapper | |
| AllRuleSets |
Stores rule sets, and allows lookup by name.
|
| AnalyzeTranscripts |
Methods for the statistical analysis of game transcripts.
|
| ArithmeticResult |
A tool for an easy online testing of arithmetic expression evaluation.
|
| Arrows | |
| AutomaticRuleGenerator |
An AutomaticRuleGenerator is used to create multiple rule set
files based on the same pattern.
|
| AutomaticRuleGeneratorService |
The AutomaticRuleGenerator demo service.
|
| Board | |
| Board.Pos |
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), ...
|
| BoardConditionsChecker |
For the training/testing restrictions on boards, as introduced in GS 6.010.
|
| BoardDisplayService |
HTML display for user-upload boards (in JSON format), for use by
the ML team (Shubham)
|
| BoardDisplayService.BoardList | |
| BoardManager |
Reading and writing Boards to CSV files
|
| Captive |
The main class for the Captive Game Server
|
| CheckPlanService |
The "Check my experiment plan" service.
|
| Clustering | |
| ColorMap | |
| Comparandum |
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).
|
| Composite |
The description of a single composite ImageObject, or a family
of such objects, obtained by parsing its name
(which may contain wildcards).
|
| Composite.Generator |
A tool for drawing concrete ImageObjects from a family defined by a Composite object,
or a union of such families.
|
| ContextInfo |
Prepares some information needed for proper URL construction in
our app.
|
| ConvertRules |
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.
|
| CreateRoles |
A very simple, stand-alone program that creates necessary Role
entities in the roles table, and at least one User entity.
|
| CsvData |
Represents the entire content of a CSV file.
|
| CsvData.BasicLineEntry | |
| CsvData.CommentEntry |
Stores a comment line from the CSV file.
|
| CsvData.LineEntry | |
| Display |
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.
|
| Ecd | |
| EligibilityForOrders |
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.
|
| Episode |
An Episode is a single instance of a Game played by a person or
machine with our game server.
|
| Episode.CODE |
Return codes for the /move and /display API web API calls,
and for the MOVE command in the captive game server.
|
| Episode.FINISH_CODE | |
| Episode.Move |
A Move instance describes an [attempted] act of picking a piece
and dropping it into a bucket.
|
| Episode.OutputMode | |
| Episode.Pick |
A Pick instance describes the act of picking a piece, without
specifying its destination
|
| EpisodeInfo |
An EpisodeInfo instance extends an Episode, containing additional
information related to it being played as part of an
experiment.
|
| EpisodeMemory |
Auxiliary data structures for the Episode class, keeping track of
"memory variables".
|
| ExportTable |
This is a substitute for something like this:
|
| Expression | |
| Expression.AdditiveExpression | |
| Expression.ArithmeticExpression |
An arithmetic expression is composed of variables, constants,
and arithmetic operations; parentheses can be used for
ordering operations.
|
| Expression.BracketList | |
| Expression.ColonExpression |
Id:ArithmeticExpression; used in GS 3
|
| Expression.ComparisonExpression |
Has exactly two operands, and the operator is '=='
|
| Expression.ExList |
Can be overridden as needed
|
| Expression.Id |
A variable.
|
| Expression.Mapper |
A Mapper is something that can take a variable
(Expression.Id) and produce another Expression (e.g.
|
| Expression.MapTo<T> |
A HashMap storing a set of values of a given type T for each key
|
| Expression.MultiplicativeExpression | |
| Expression.NegationExpression |
!E evaluates to [1] if E is an empty set, or to [] otherwise
|
| Expression.Num |
A numeric constant
|
| Expression.ParenList | |
| Expression.PropMap |
Values are String or Integer
|
| Expression.QualifiedId |
A.B
|
| Expression.RangeExpression |
[Num..Num]
|
| Expression.SerialExpression |
Additive or multiplicative
|
| Expression.Star |
A Star expression is simply "*".
|
| Expression.VarMap | |
| Expression.VarMap2 |
Objects in question may be Integer, String, or PropMap
(ImageObject or equivalent)
|
| ExtendedSessionManagement |
This class is used to manage extended sessions, which survive over the
web server restart.
|
| Files |
Information about the data files the Rule Game web server reads and writes
|
| FileUploadResource | |
| FileWriteReport |
This data structure is converted to JSON and send to the client in response to the /writeFile web API call.
|
| Fmter |
Auxiliary class for formatting output as plain text of HTML.
|
| FrontEndForm2 |
For Tanvi: helps the player to generate a unique playerID
|
| Game |
A Game object defines how an Episode may be created.
|
| GameGenerator |
This class generates random games (with the same rule set and
randomly created initial boards) based on the provided parameter
range specifications
|
| GamePlayException | |
| GameService |
The "First Batch" of API calls, primarily for use in the research environment, where a player can choose any game to play
|
| GameService2 |
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.
|
| GameService2Html |
The HTML wrapper for the Second Batch calls, to allow for the "HTML Play".
|
| GameServiceHtml |
The HTML wrapper for the First Batch calls, to allow for the "HTML Play".
|
| GameSocketServer |
The socket implementation of a captive game server.
|
| GetBookletPageServlet |
Returns the content of an image file (SVG, PNG, etc) for one of the
pages of the instruction booklet.
|
| GetBookletPageWrapper |
Returns the content of the specified page of the instruction booklet
for the specified player
|
| GetImageServlet |
Returns the content of an image file (SVG, PNG, etc) for the
specified shape.
|
| GetSvgWrapper |
Returns the content of the SVG file for the specified shape
|
| GiveUpWrapper | |
| GuessWriteReport |
This data structure is converted to JSON and send to the client in response to the /guess web API call.
|
| Hosts |
Convenience routines to determine the host name etc
|
| HTMLFmter |
Auxiliary class for formatting output as HTML.
|
| IllegalInputException |
An exception of this type is thrown when we want to report to the user that
the data he's entered are invalid
|
| ImageObject |
Describes an image-and-properties-based object.
|
| ImageObject.Generator | |
| ImageObject.PickFromList |
A Generator interface to a stored list of ImageObjects
|
| ImageObjectReport | |
| ImportCSV |
Methods responsible for parsing CSV files.
|
| JsonReflect |
Tools for exporting Java objects as JSON structures
|
| JsonToJava |
Tools for importing Java objects from JSON structures.
|
| LabelMap |
Maps false.someThingXandY to X, etc.
|
| LaunchMain |
As requested by Paul, "Rule Game -- challenge UWisc faculty and staff",
2021-09-23.
|
| LaunchRules |
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.
|
| LaunchRulesBase |
The common base for the Launch pages that allows one to play all
rule sets from rules/APP, rules/MLC, and others.
|
| LaunchRulesBase.AndroidRuleInfoReport |
The list of rule sets to be displayed in the Android app
|
| LaunchRulesBase.Mode |
The name refers to the directory from whih trial lists or rule sets
are read
|
| LaunchRulesBase.RuleInfo |
An auxiliary class that can be used to transmit information about
the buttons etc the Android app needs to display
|
| ListShapesWrapper |
Lists all available shapes
|
| Logging |
Methods used by CHEETA to log warning and error
messages.
|
| LoginServlet | |
| LogoutServlet | |
| Main |
An object that is responsible for getting EntityManager object(s)
for the application.
|
| MainConfig |
Accessing the main configuration file of the Game Server, which
can be used by the site administrator to override some
defaults.
|
| ManagerDashboardService |
Tools for the manager dashboard.
|
| MannWhitney |
The Mann-Whitney math
|
| MannWhitneyComparison |
Comparing players or rules based on the Mann-Whitney test
|
| MannWhitneyComparison.Mode | |
| MergeDatasets | |
| MlcEntry |
An MlcEntry contains the data for a (participant, ruleset, run)
tuple.
|
| MlcLog |
An auxiliary class used by the Captive Game Server for the optional
logging of MLC run results.
|
| MlcLog.LogFormat |
Supported log file formats
|
| MlcLoginServlet |
The login page for the MLC results sumbission tool
|
| MlcMain |
The back end behind web/mlc/index.jsp
|
| MlcManagerDashboard | |
| MlcUploadService |
Uploading and processing results files by MLC
participants.
|
| MwByHuman |
Ranking rule sets by the ease of learning by human players.
|
| MwByHuman.MwSeries |
The data for a series (group of episodes played by one player under the same rule set) needed to contribute a number to an M-W Comparandum.
|
| MwByHuman.PrecMode |
Used to control how series are assigned to comparanda
|
| NewEpisodeWrapper | |
| NewEpisodeWrapper2 |
This is an object that's converted to a JSON structure and sent to the client as a response in /GameService2/newEpisode calls.
|
| Order |
An Order object describe a built-in or custom ordering of
|
| Order.PositionSelector |
Names of built-in (predefined) orders
|
| OurTable |
All our entities (corresponding to table rows) implement this.
|
| ParaSet | |
| ParaSet.Incentive |
Various incentive schemes available to experiment designers.
|
| ParseConfig |
This class is used to obtain configuration parameters, from a configuration
file or from Java System Properties.
|
| Piece |
Represents a piece of a specified type at a specified location.
|
| Piece.Color | |
| Piece.PseudoEnum |
A flexible replacement for an Enum
|
| Piece.Shape | |
| PlanStats |
Lists experiment plans and the number of players who played them, etc
|
| PlayerInfo |
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.
|
| PlayerInfo.Action |
What type of action takes the player to a particular destination?
|
| PlayerInfo.Transition |
Where can we go from here?
|
| PlayerResponse |
The object returned by the /player call.
|
| PredefinedBoardGameGenerator |
This class generates games based on a set of predefined initial boards
|
| PregameService |
Retrieving various pages needed by the client to customize the player's pregame and postgame experience.
|
| PregameService.BookletSize |
An HTML page + error code
|
| PregameService.Page |
An HTML page + error code
|
| PregameService.PregameResponseBase |
Some info + error code
|
| PropertiesTable |
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.
|
| PVTest |
Testing Apache Commons methods for MW and KS p-values.
|
| RandomGameGenerator |
This class generates random games (with the same rule set and
randomly created initial boards) based on the provided parameter
range specifications
|
| RandomImageGameGenerator |
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
|
| RandomRG | |
| Reflect |
A bunch of methods to figure what fields a class has, and how to
print them out in a more or less sensible way.
|
| Reflect.Entry |
An entry describes one field of the class, complete with its
access methods (getter and setter) and the display hints
|
| ReplayedEpisode |
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.
|
| ReplayedEpisode.RandomPlayer |
The possible random player models.
|
| ResponseBase |
The parent class for various structures that are returned, in JSON form,'
by REST calls.
|
| ResultsBase |
The base of all "results object" classes used in JSP pages
|
| Role |
A role is simply a database-storable wrapper around the role name
|
| Role.Name | |
| RuleParseException | |
| RuleSet |
A RuleSet describes the rules of a game.
|
| RuleSet.Atom |
Syntax:(counter,shape,color,position,bucketFunctions)
|
| RuleSet.BucketList |
A BucketList represents the information about the destination
buckets given in the "buckets" field of an atom.
|
| RuleSet.BucketSelector |
The list of "legacy" variables that can be used in the bucket
expression.
|
| RuleSet.PositionList |
Represents the restrictions on the positions from which game pieces
can be picked
|
| RuleSet.Row |
A row object represents the content of one line of the rule set
description file, i.e.
|
| SessionData |
A single instance of this class is associated with a particular
session of the Rule Game web app.
|
| StalemateTester |
Tools for testing a rule set for a possibility of a stalemate.
|
| SvgEcd |
Utilities for generating SVG plots for ECD data
|
| SvgEcd.Point | |
| Test |
Used for testing JPA persistence features
|
| TestChild |
An EpisodeInfo instance extends an Episode, containing additional
information related to it being played as part of an
experiment.
|
| TestParent | |
| Token |
A token represents an element of the input text.
|
| Token.Type | |
| Tools |
Various methods related to generating HTML forms and their
components, and processing requests sent by the web browser when
those forms are filled
|
| TranscriptManager |
An auxiliary class for writing and reading transcript files.
|
| TranscriptManager.ReadTranscriptData |
Some of the transcript data read back from a file.
|
| TranscriptManager.ReadTranscriptData.Entry |
Stores the content of one line read back from the transcript
file
|
| TrialList | |
| TrialList.ExperimentPlanHandle |
Identifies an experiment plan as a static or dynamic (P: or R: type)
one
|
| TrivialGameGenerator |
Just keeps returning the same game every time
|
| User |
Information about a repeat user (who may own multiple playerId) stored in the SQL database.
|
| UserResponse |
Used by LoginServlet and the Android app for registering new users and logging in
|
| Util |
Auxiliary methods for manipulating hash tables etc
|
| WebException |
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.
|