Module TranslateGame

module TranslateGame: sig .. end

Translating games from GDL to Toss.

val generate_test_case : string option Pervasives.ref

val set_timeout : (unit -> bool) -> unit

type as_defined_rels =

`\|`	`By_arity`
`\|`	`By_const_param`
`\|`	`By_ground_def`
`\|`	`By_all_ground`

two heuristics for selecting defined relations: select relations with arity smaller than three; or, select relations that have ground defining clauses (i.e. defining clauses with empty bodies).

val as_defined_rels : as_defined_rels Pervasives.ref

val playout_horizon : int Pervasives.ref

Limit on plys for both aggregate and random playouts.

val saturation_engine : bool Pervasives.ref

Use saturation-based Datalog engine instead of a Prolog interpreter.

val playouts_for_rule_filtering : int Pervasives.ref

How many random playouts to generate states for rule filtering (a rule needs to match in at least one generated state to be kept).

val filter_possibly_redundant : bool Pervasives.ref

When filter_possibly_redundant is false, only whole groups of variable-sharing "next" clause literals that together are subsumed by "legal" clause literals are filtered out. With filter_possibly_redundant set to true, subsumed "next" literals are removed, even though they may be intended for different elements as witnessed by remaining "next" clause literals (which get their variables renamed to match the "legal" clause literals).

type tossrule_data = {

	`legal_tuple :GDL.term array;`
	`rule_add :(string * string array) list;`
	`rule_del :(string * string array) list;`
	`struc_elems :string list;`
	`fixvar_terms :(string * (GDL.term * GDL.path) list) list;`
	`rulevar_terms :GDL.term Aux.StrMap.t;`

}

type gdl_translation = {

	`elem_term_map :GDL.term Aux.IntMap.t;`
	`f_paths :GDL.path_set;`
	`c_paths :GDL.path_set;`
	`roots :GDL.term list;`
	`tossrule_data :tossrule_data Aux.StrMap.t;`
	`turnbased_noops :GDL.term option array array option;`
	`playing_as :int;`
	`is_concurrent :bool;`
	`transl_data :TranslateFormula.transl_data;`
	`fluents :string list;`

}

Data to be used when translating moves.

val empty_gdl_translation : gdl_translation

val translate_game : ?playing_as:GDL.term ->
       GDL.clause list ->
       gdl_translation * Arena.game * (Arena.game * Arena.game_state)

val translate_incoming_move : gdl_translation ->
       Arena.game * Arena.game_state ->
       GDL.term list -> (int * (string * DiscreteRule.matching)) list

val translate_outgoing_move : gdl_translation ->
       Arena.game * Arena.game_state -> string -> (string * string) list -> string

val noop_move : gdl_translation -> Arena.game_state -> string

val our_turn : gdl_translation -> Arena.game_state -> bool

val is_turnbased : gdl_translation -> bool