|
|
**Game Engine**
|
|
|
|
|
|
* Dev/Test endpoints
|
|
|
* Game APIs to game clients
|
|
|
* Sample JSON configuration files
|
|
|
* Game Engine APIs exposed to IoT layer (if any)
|
|
|
* IoT layer APIs needed by the game configuration engine
|
|
|
* Game Engine APIs exposed to the Incentive Server (if any)
|
|
|
* Incentive server APIs needed by the configuration engine.
|
|
|
* ecc ecc
|
|
|
|
|
|
|
|
|
**Game Configuration Server**
|
|
|
|
|
|
The main URL for the<strong> Game Configuration Server (GCS)</strong> are dependent on the game that they address.
|
|
|
|
|
|
Right now are:
|
|
|
* iceberg-inlife.cn.ntua.gr
|
|
|
* aksion-inlife.cn.ntua.gr
|
|
|
Which represents the front end for the configuration server.
|
|
|
|
|
|
Other than the frontend there is the actual <strong>Game Server (GS) </strong>which is reachable by [GCS]<em>/v1/api.php</em> and exposes several REST services that returns all configured game plans and missions for the logged user. This GS is used also by the game client to retrieve information about logged user, his status and the current mission/minigames list.
|
|
|
|
|
|
**JSON configuration files**
|
|
|
|
|
|
There are two main type of JSON that shall be defined to set an *environment* and his default *missions*, one to describe which are the elements of the game, the other to describe what is a mission and how to complete it successfully.
|
|
|
|
|
|
More specifically an *environment* consists in a container of objects and actions that can be performed on those objects, moreover every object has several options that can be set up.
|
|
|
|
|
|
A *mission* instead is a list of action that have to be played in a certain order plus an initial and a varying configuration of all objects in game.
|
|
|
|
|
|
*The developer has to write ONLY the JSON for the environment (schema.json)* because there is a way to configure the missions (mission.json) directly from the web GUI inteface of the *GCS.*
|
|
|
|
|
|
The game client however have to be able to read and interpret it. For this there will be the InLife SDK to foster game development.
|
|
|
|
|
|
The structure of the __schema.json__ shall be something like this one (attached [[%ATTACHURL%/schema.json][schema.json]]):
|
|
|
<pre>{
|
|
|
<strong>name</strong>:[name of the environment],
|
|
|
<strong>description</strong>:[description of the environment],
|
|
|
<strong>actions</strong>:[
|
|
|
{
|
|
|
<strong>id</strong>:[string to identify the action as a uuid],
|
|
|
<strong>name</strong>:[name of the action],
|
|
|
<strong>description</strong>:[description of the action],
|
|
|
<strong>type</strong>:[type of the action, can be: <em><strong>simple</strong></em>, <em><strong>bool</strong></em>, <em><strong>numeric</strong></em>, <strong><em>enum</em> </strong>or<em><strong> string</strong></em>],
|
|
|
[<strong>default</strong>]:{[default value range for <strong><em>numeric</em> </strong>and <strong><em>enum</em> </strong>types]
|
|
|
[for <em><strong>numeric</strong></em>]
|
|
|
<strong>step</strong>:[the minimum amount that have to be added to have a new number e.g. 1 or 0.1],
|
|
|
<strong>min</strong>:[the minimum value that can be selected for this action],
|
|
|
<strong>max</strong>:[the maximum value that can be set]
|
|
|
[for <em><strong>enum</strong></em>]
|
|
|
<strong>values</strong>:[ [list of the values for the enum it can be overriden when the action is used on an object]
|
|
|
{
|
|
|
<strong>id</strong>:[id for the enum value],
|
|
|
<strong>name</strong>:[visible name for the enum value],
|
|
|
<strong>description</strong>:[description for the enum value],
|
|
|
<strong>optional</strong>:[bool that identifies if this enum value can be disabled by educator in the mission description]
|
|
|
},<br /> ...
|
|
|
]<br /> },
|
|
|
<strong>options</strong>:[
|
|
|
[list of options available for the action that can be used to modify the behaviour ],
|
|
|
{
|
|
|
<strong>id</strong>:[id of the option],
|
|
|
<strong>name</strong>:[name of the option],
|
|
|
<strong>description</strong>:[description of the option],
|
|
|
<strong>type</strong>:[type of the option can be <em><strong>enum</strong></em>, <em><strong>numeric</strong></em>, <em><strong>bool</strong> </em>or <em><strong>string</strong></em>],
|
|
|
<strong>default</strong>:[default value for this option],<br />
|
|
|
[for <em><strong>enum</strong></em> type]
|
|
|
<strong>values</strong>:[[list of available values similar to the values for the actions but without option field]
|
|
|
{
|
|
|
<strong>id</strong>:[id for the enum value],
|
|
|
<strong>name</strong>:[visible name for the enum value],
|
|
|
<strong>description</strong>:[description for the enum value],
|
|
|
},
|
|
|
...
|
|
|
]
|
|
|
[for <em><strong>numeric</strong></em> type]
|
|
|
<strong>step</strong>:[the minimum amount that have to be added to have a new number e.g. 1 or 0.1],
|
|
|
<strong>min</strong>:[the minimum value that can be selected for this option],
|
|
|
<strong>max</strong>:[the maximum vaue that can be set for this option]
|
|
|
}]
|
|
|
|
|
|
},
|
|
|
...
|
|
|
],
|
|
|
<strong>objects</strong>:[
|
|
|
{
|
|
|
<strong>id</strong>:[id of the object as a string uuid]
|
|
|
<strong>name</strong>:[name of the object],
|
|
|
<strong>description</strong>:[description of the object],
|
|
|
<strong>actions</strong>:[
|
|
|
{
|
|
|
<strong>id</strong>:[reference to the action],
|
|
|
<strong>description</strong>:[a description that can override the default one for this object],
|
|
|
<strong>optional</strong>:[bool that identifies if the action can be disabled for this object on the mission description, default is false],
|
|
|
[other settings action type dependant that override the default ones e.g. <strong>step</strong>, <strong>min</strong> or <strong>max</strong> for <em><strong>numeric</strong></em> or the list of <strong>values</strong> for <em><strong>enum</strong></em>]
|
|
|
}
|
|
|
],
|
|
|
<strong>options</strong>:[
|
|
|
[list of options available for the object that can be used to modify appeareance or behaviour of an object],
|
|
|
{
|
|
|
<strong>id</strong>:[id of the option],
|
|
|
<strong>name</strong>:[name of the option],
|
|
|
<strong>description</strong>:[description of the option],
|
|
|
<strong>type</strong>:[type of the option can be <em><strong>color</strong></em>, <em><strong>enum</strong></em>, <em><strong>numeric</strong></em>, <em><strong>bool</strong> </em>or <em><strong>string</strong></em>],
|
|
|
<strong>default</strong>:[default value for this option],
|
|
|
[for <em><strong>enum</strong></em> type]
|
|
|
<strong>values</strong>:[[list of available values similar to the values for the actions but without optiona field]
|
|
|
{
|
|
|
<strong>id</strong>:[id for the enum value],
|
|
|
<strong>name</strong>:[visible name for the enum value],
|
|
|
<strong>description</strong>:[description for the enum value],
|
|
|
},
|
|
|
...
|
|
|
]
|
|
|
[for <em><strong>numeric</strong></em> type]
|
|
|
<strong>step</strong>:[the minimum amount that have to be added to have a new number e.g. 1 or 0.1],
|
|
|
<strong>min</strong>:[the minimum value that can be selected for this option],
|
|
|
<strong>max</strong>:[the maximum vaue that can be set for this option]
|
|
|
}],
|
|
|
<strong>status</strong>:[defines the status of the object in a format equals to the options, used to identify status variable that change during the play.
|
|
|
Moreover there are two flags:
|
|
|
<b>read-only</b>, which identifies the statuses that can't be modified in consequences,
|
|
|
<b>write-only</b>, which identifies the statuses that can't be read in prerequisites but only assigned in consequences],
|
|
|
<strong>optional</strong>:[bool that identifies if this object can be disabled on the mission description, default is false]
|
|
|
},
|
|
|
...
|
|
|
]<br />}</pre>
|
|
|
|
|
|
The structure of a __mission.json__ is instead (attached [[%ATTACHURL%/mission.json][mission.json]]):
|
|
|
<pre>{
|
|
|
<strong>title</strong>:[mission title],
|
|
|
<strong>description</strong>:[mission description],
|
|
|
<strong>configuration</strong>:{
|
|
|
<b>actions:</b>[<br /> {
|
|
|
<strong>id</strong>:[reference to the action],
|
|
|
<strong>options</strong>:{
|
|
|
[list of options for this actions with the parameters set in key value format]
|
|
|
}
|
|
|
},<br /> ...
|
|
|
],<br /> <b>objects:</b> [
|
|
|
[initial object configuration, if an object is <strong>optional</strong> if omitted from the list it will be disabled from the game]
|
|
|
{
|
|
|
<strong>id</strong>:[reference to the object],
|
|
|
<strong>options</strong>:{
|
|
|
[list of options for this gameobject with the parameter set in key value format]
|
|
|
},
|
|
|
<strong>status</strong>:{
|
|
|
[list of status vartiable for this gameobject with the parameter set in key value format]
|
|
|
},
|
|
|
<strong>actions</strong>:{
|
|
|
[list of actions available for this game object with their options in key value format],
|
|
|
[id of the action]:{
|
|
|
<strong>disabled</strong>:[if optional set to true in the schema an action can be disabled, default false]
|
|
|
[specific option for the action for e.g. <strong>values</strong> for <em><strong>enum</strong> </em>actions can contain optional values that can be disabled (like the whole action)]
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
...
|
|
|
]<br /> },
|
|
|
<strong>steps</strong>:[[ list of step to fulfill to perform the mission contains a list of action that have to be fulfilled before doing something else
|
|
|
to pass from one to another there are three possibilities
|
|
|
1. time expires
|
|
|
2. the user do an action belonging to the next step
|
|
|
3. an action is marked as final, thus, if done, consequences are applyed and the game moves to the next step]
|
|
|
{
|
|
|
<strong>name</strong>:[name of the step to complete],
|
|
|
<strong>max-time</strong>:[if you have only a certain amount of time to perform this step this value identify the time in seconds],
|
|
|
<strong>prerequisites</strong>:[[list of variables to check at the beginning of the step]
|
|
|
{
|
|
|
<strong>id</strong>:[id of the object to check],
|
|
|
<strong>status</strong>:[key value pair that identify what status variable to check and what is the desired value, it can be a complex object or a list depending on the type of the option],
|
|
|
<strong>mandatory</strong>:[if true raise a <em>severe error</em> if the prerequisite is not satisfied else raise only a <em>warning</em>],
|
|
|
<strong>feedback</strong>:{
|
|
|
<strong>positive</strong>:[a string that can appear if the user the prerequisite is satisfied],
|
|
|
<strong>negative</strong>:[a string that leave a feedback if the prerequisite is not satisfied]
|
|
|
}
|
|
|
}
|
|
|
],
|
|
|
<strong>actions</strong>:[[list of actions that can be performed in any order before proceed]
|
|
|
{
|
|
|
<strong>type</strong>:[id of the action to be done],
|
|
|
<strong>object</strong>:[id of the object where do the action],
|
|
|
<strong>optional</strong>:[define if this action is optional, if yes it will not raise a warning if not done in this step and can be done whenever the user want in the game from now on],
|
|
|
<strong>mandatory</strong>:[define if you have to perform this action to proceed, missing to do that action raise a severe error that ends the mission],
|
|
|
<strong>warning</strong>:[bool that defines if performing this action raise a warning],
|
|
|
<strong>severe</strong>:[bool that defines if performing this action raise a severe error that end the game],
|
|
|
<strong>final</strong>:[bool that defines if this action apply consequences and move to the next step],
|
|
|
<strong>score</strong>:{[define a score for this action it can be a number or a object with <strong>before</strong>, <strong>after</strong> and <strong>never</strong> fields]
|
|
|
<strong>before</strong>:[the score to assign if the action is done before passing to the next step],
|
|
|
<strong>after</strong>:[the score to assign if action is done after the end of this step],
|
|
|
<strong>never</strong>:[the score (bonus or malus) to assign if this action is never done]
|
|
|
},
|
|
|
<strong>feedback</strong>:{
|
|
|
<strong>positive</strong>:[a string that can appear if the user do the action correctly],
|
|
|
<strong>negative</strong>:[a string that leave a feedback if the action is not done correctly]
|
|
|
},
|
|
|
<strong>consequences</strong>:[list of consequences to apply if this action is done correctly],
|
|
|
[optional fields depending on the type of action]
|
|
|
<strong>count</strong>:[number of times that the action have to be performed, once if not defined used for <em><strong>simple</strong> </em>actions],
|
|
|
<strong>value</strong>:[for <em><strong>bool</strong></em>, <em><strong>enum</strong> </em>or <em><strong>string</strong> </em>action identifies the value that shall be selected in game to consider this action done,
|
|
|
can be a list where each range has a different score for example for <strong><em>numeric</em> </strong>it can be a list of object like:
|
|
|
{
|
|
|
<strong>min</strong>:[number that identify the minimum of the range inclusive, to better control the boundaries it can be made esclusive using a <em><strong>">"</strong></em> before the number, <br /> that sign means that the exact value shall not be considered inside the range,
|
|
|
moreover you can specify directly the minimum value just writing <strong>MIN</strong> that will take the minimum possible value for this action],
|
|
|
<strong>max</strong>:[maximum of the range inclusive, <strong>"<"</strong> to make it exclusive, as for MIN it exists a <strong>MAX</strong> value to identify the maximum value],
|
|
|
<strong>score</strong>:[score if value is set in this range]
|
|
|
}
|
|
|
that identifies a set of values for the action to be considered a success
|
|
|
]
|
|
|
},
|
|
|
[moreover there can be two special type of actions, the option one and the group:
|
|
|
- the "<em><strong>option</strong></em>" define that there can be two or more different action that can be fullfilled to achieve the same result (the consequences of the step)
|
|
|
- the "<em><strong>group</strong></em>" is used to contain a group of several action that can be put in an <em><strong>option</strong> </em>action list
|
|
|
]
|
|
|
{
|
|
|
<strong>type</strong>:"<em><strong>option</strong></em>",
|
|
|
<strong>object</strong>:[a name to identify the option],
|
|
|
<strong>optional</strong>:[as before],
|
|
|
<strong>mandatory</strong>:[need to be made a choice to proceed otherwise raise a severe error],
|
|
|
<strong>final</strong>:[if the action in this option are the final action],
|
|
|
<strong>options</strong>:[list of possibilities in form of actions or group],
|
|
|
<strong>feedback</strong>:{[positive or negative feedback]},
|
|
|
<strong>consequences</strong>:[list of consequences to apply if this option is solved]
|
|
|
},
|
|
|
{
|
|
|
<strong>type</strong>:"<em><strong>group</strong></em>",
|
|
|
<strong>object</strong>:[a name to identify the group],
|
|
|
<strong>optional</strong>:[as before],
|
|
|
<strong>mandatory</strong>:[need to be made a choice to proceed otherwise raise a severe error],
|
|
|
<strong>final</strong>:[if finalize this group is the final action],
|
|
|
<strong>elements</strong>:[list of actions, if an action is <strong>mandatory</strong> it will consider the group as the choosen option value if the action is performed],
|
|
|
<strong>feedback</strong>:{[positive or negative feedback if group is completed with all not optional values]},
|
|
|
<strong>consequences</strong>:[list of consequences to apply if all options of this group are done (except the optionals)]
|
|
|
}
|
|
|
],
|
|
|
<strong>consequences</strong>:[it have the same structure as configuration and identify a change in the status of objects.]
|
|
|
},
|
|
|
...
|
|
|
],
|
|
|
<strong>final-feedback</strong>:[a final feedback to show if the mission is achieved successfully]
|
|
|
}
|
|
|
</pre>
|
|
|
|
|
|
**Schema Example**
|
|
|
|
|
|
This schema ( [[%ATTACHURL%/schema_eg.json][schema_eg.json]]) identify a simple scholastic environment where there are several objects like the *door*, a *backpack*, a *watch*, the *classclock*, a *pen*, an <strong>agenda, </strong>a <strong>copybook </strong>and the class *blackboard*. Moreover there is also a meta object that is the <strong>starting position </strong>which is not an object that can be selected nor used, but it is usefull to identify an initial condition. All those elements have actions and options that can be used during gameplay or setup at the beginning in the mission.
|
|
|
<pre>{
|
|
|
"name":"school planet",
|
|
|
"description":"This is the planet of the school, in it you can move around the class, speak with the classmates and with the teacher, and interact with school desk objects.",
|
|
|
"actions":
|
|
|
[
|
|
|
{
|
|
|
"id":"take",
|
|
|
"name":"take the object",
|
|
|
"description":"with this action the user will have the object on his hand and he can use on other things.",
|
|
|
"type":"simple"
|
|
|
},
|
|
|
{
|
|
|
"id":"open",
|
|
|
"name":"open/close",
|
|
|
"description":"open/close something ",
|
|
|
"type":"bool"
|
|
|
},
|
|
|
{
|
|
|
"id":"draw",
|
|
|
"name":"draw on",
|
|
|
"description":"this action is activated if a user has an object to write on his hand.", ## NOTE: hardcoded in the game
|
|
|
"type":"simple"
|
|
|
},
|
|
|
{
|
|
|
"id":"knock",
|
|
|
"name":"knock",
|
|
|
"description":"the user knock on a knockable surface",
|
|
|
"type":"simple"
|
|
|
},
|
|
|
{
|
|
|
"id":"switch",
|
|
|
"name":"switch on/off",
|
|
|
"description":"use to switch on/off",
|
|
|
"type":"bool"
|
|
|
},
|
|
|
{
|
|
|
"id":"sethour",
|
|
|
"name":"set hour",
|
|
|
"description":"set the hour on a device"
|
|
|
"type":"numeric"
|
|
|
"default":{
|
|
|
"step":1,
|
|
|
"min":0,
|
|
|
"max":23
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"setminutes",
|
|
|
"name":"set minutes",
|
|
|
"description":"set the minutes on a device"
|
|
|
"type":"numeric"
|
|
|
"default":{
|
|
|
"step":1,
|
|
|
"min":0,
|
|
|
"max":59
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"read",
|
|
|
"name":"read",
|
|
|
"type":"simple"
|
|
|
},
|
|
|
{
|
|
|
"id":"pickup",
|
|
|
"name":"pick up a book",
|
|
|
"type":"enum",
|
|
|
"default":{
|
|
|
"values":
|
|
|
[
|
|
|
{
|
|
|
"id":"math",
|
|
|
"name":"copybook of math"
|
|
|
},
|
|
|
{ "id":"english",
|
|
|
"name":"copybook of english language"
|
|
|
},
|
|
|
{ "id":"science"
|
|
|
"name":"copybook of science"
|
|
|
},
|
|
|
{
|
|
|
"id":"agenda".
|
|
|
"name":"school agenda"
|
|
|
}
|
|
|
]
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"name":"write",
|
|
|
"description":"write something, available if user has something to write",
|
|
|
"type":"string"
|
|
|
}
|
|
|
],
|
|
|
"objects":[
|
|
|
{
|
|
|
"id":"door"
|
|
|
"name":"front class door",
|
|
|
"actions":[{
|
|
|
"id":"open",
|
|
|
},
|
|
|
{
|
|
|
"id":"knock",
|
|
|
"optional":true
|
|
|
}
|
|
|
],
|
|
|
"options":[
|
|
|
{
|
|
|
"id":"is_open",
|
|
|
"name":"is initially open",
|
|
|
"type":"bool",
|
|
|
"default":false
|
|
|
},
|
|
|
{
|
|
|
"id":"label",
|
|
|
"name":"label's content",
|
|
|
"description":"label on the top of the door",
|
|
|
"type":"string",
|
|
|
"default":"classroom"
|
|
|
}
|
|
|
],
|
|
|
"optional":true
|
|
|
},
|
|
|
{
|
|
|
"id":"startingposition",
|
|
|
"name":"starting position",
|
|
|
"description":"starting position at the beginning of the mission",
|
|
|
"action":[], ## empty: does not need any action since it is an initial configuration, can be omitted
|
|
|
"options":[{
|
|
|
"id":"position",
|
|
|
"name":"position",
|
|
|
"type":"enum",
|
|
|
"values":[
|
|
|
{
|
|
|
"id":"pos1",
|
|
|
"name":"out of the door"
|
|
|
},
|
|
|
{
|
|
|
"id":"pos2",
|
|
|
"name":"student school desk"
|
|
|
},
|
|
|
{
|
|
|
"id":"pos3",
|
|
|
"name":"class entrance"
|
|
|
}
|
|
|
],
|
|
|
"default":"pos1"
|
|
|
}]
|
|
|
},
|
|
|
{
|
|
|
"id":"backpack",
|
|
|
"name":"student backpack",
|
|
|
"action":[
|
|
|
{"id":"pickup"},
|
|
|
{"id":"open","optional":true},
|
|
|
{"id":"take","optional":true}
|
|
|
],
|
|
|
"options":[
|
|
|
{
|
|
|
"id":"color",
|
|
|
"name":"color",
|
|
|
"type":"color"
|
|
|
"default":"#FF0000"
|
|
|
},
|
|
|
{
|
|
|
"id":"is_open",
|
|
|
"name":"is initially open",
|
|
|
"type":"bool",
|
|
|
"default":false
|
|
|
},
|
|
|
{
|
|
|
"id":"label",
|
|
|
"name":"label of the backpack",
|
|
|
"type":"string",
|
|
|
"default":"Me"
|
|
|
}
|
|
|
],
|
|
|
"optional":true
|
|
|
},
|
|
|
{
|
|
|
"id":"watch",
|
|
|
"name":"student's watch",
|
|
|
"action":[
|
|
|
{"id":"setminutes","optional":true},
|
|
|
{"id":"sethour","optional":true},
|
|
|
{"id":"read"}
|
|
|
],
|
|
|
"options":[
|
|
|
{
|
|
|
"id":"type",
|
|
|
"name":"watch type",
|
|
|
"type":"enum",
|
|
|
"values":[{
|
|
|
"id":"analog",
|
|
|
"name":"analog watch"
|
|
|
},{
|
|
|
"id":"digital",
|
|
|
"name":"digital watch"
|
|
|
}],
|
|
|
"default":"analog"
|
|
|
},
|
|
|
{
|
|
|
"id":"color",
|
|
|
"name":"color",
|
|
|
"type":"color"
|
|
|
"default":"#FF0000"
|
|
|
},
|
|
|
{
|
|
|
"id":"hour",
|
|
|
"name":"hour",
|
|
|
"type":"numeric",
|
|
|
"step":1,
|
|
|
"min":0,
|
|
|
"max":23,
|
|
|
"default":"10"
|
|
|
},
|
|
|
{
|
|
|
"id":"minutes",
|
|
|
"name":"minutes",
|
|
|
"type":"numeric",
|
|
|
"step":1,
|
|
|
"min":0,
|
|
|
"max":59,
|
|
|
"default":"30"
|
|
|
}
|
|
|
],
|
|
|
"optional":true
|
|
|
},
|
|
|
{
|
|
|
"id":"classclock",
|
|
|
"name":"classroom clock",
|
|
|
"action":[
|
|
|
{"id":"read"}
|
|
|
],
|
|
|
"options":[
|
|
|
{
|
|
|
"id":"type",
|
|
|
"name":"watch type",
|
|
|
"type":"enum",
|
|
|
"values":[{
|
|
|
"id":"analog",
|
|
|
"name":"analog watch"
|
|
|
},{
|
|
|
"id":"digital",
|
|
|
"name":"digital watch"
|
|
|
}],
|
|
|
"default":"analog"
|
|
|
},
|
|
|
{
|
|
|
"id":"time",
|
|
|
"name":"clock's time"
|
|
|
"type":"string",
|
|
|
"default":"10:30"
|
|
|
}
|
|
|
]
|
|
|
},
|
|
|
{
|
|
|
"id":"pen",
|
|
|
"name":"pen on student school desk",
|
|
|
"action":[
|
|
|
{"id":"take"}
|
|
|
],
|
|
|
"options":[
|
|
|
{
|
|
|
"id":"color",
|
|
|
"name":"color",
|
|
|
"type":"color",
|
|
|
"default":"#0000AA"
|
|
|
}
|
|
|
],
|
|
|
"optional":true
|
|
|
},
|
|
|
{
|
|
|
"id":"agenda",
|
|
|
"name":"student agenda",
|
|
|
"action":[
|
|
|
{"id":"read", "description":"Read today class scheduling."}
|
|
|
],
|
|
|
"options":[
|
|
|
{
|
|
|
"id":"color",
|
|
|
"name":"color",
|
|
|
"type":"color",
|
|
|
"default":"#FF0000"
|
|
|
},
|
|
|
{
|
|
|
"id":"scheduling",
|
|
|
"name":"scheduling for today class"
|
|
|
"type":"string",
|
|
|
"default":"8:00-10:00 Math 10:00-12:00 English 12:00-13:00 Science"
|
|
|
},
|
|
|
{
|
|
|
"id":"position",
|
|
|
"name":"initial position of the agenda",
|
|
|
"type":"enum",
|
|
|
"values":[
|
|
|
{
|
|
|
"id":"backpack",
|
|
|
"name":"inside the backpack"
|
|
|
},
|
|
|
{
|
|
|
"id":"desk",
|
|
|
"name":"upon the school desk"
|
|
|
}
|
|
|
]
|
|
|
}
|
|
|
],
|
|
|
"optional":true
|
|
|
},
|
|
|
{
|
|
|
"id":"copybook",
|
|
|
"name":"school copybook",
|
|
|
"action":[
|
|
|
{"id":"read", "description":"Read copybook subject."},
|
|
|
{"id":"write"}
|
|
|
],
|
|
|
"option":[
|
|
|
{
|
|
|
"id":"position",
|
|
|
"name":"initial position of the copybook",
|
|
|
"type":"enum",
|
|
|
"values":[
|
|
|
{
|
|
|
"id":"backpack",
|
|
|
"name":"inside the backpack"
|
|
|
},
|
|
|
{
|
|
|
"id":"desk",
|
|
|
"name":"upon the school desk"
|
|
|
}
|
|
|
]
|
|
|
},
|
|
|
{
|
|
|
"id":"subject",
|
|
|
"name":"subject of the copybook"
|
|
|
"type":"string",
|
|
|
"default":"Math copybook"
|
|
|
},
|
|
|
{
|
|
|
"id":"type",
|
|
|
"name":"copybook theme",
|
|
|
"type":"enum",
|
|
|
"values":[
|
|
|
{
|
|
|
"id":"math",
|
|
|
"name":"math copybook"
|
|
|
},
|
|
|
{
|
|
|
"id":"english",
|
|
|
"name":"english copybook"
|
|
|
},
|
|
|
{
|
|
|
"id":"science",
|
|
|
"name":"science copybook"
|
|
|
}
|
|
|
]
|
|
|
}
|
|
|
],
|
|
|
"optional":true
|
|
|
},
|
|
|
{
|
|
|
"id":"blackboard",
|
|
|
"name":"class blackboard",
|
|
|
"action":[
|
|
|
{"id":"read", "description":"Read what is written on the blackboard."}
|
|
|
],
|
|
|
"options":[{
|
|
|
"id":"text",
|
|
|
"name":"blackboard handwritten text",
|
|
|
"type":"string",
|
|
|
"default":""}
|
|
|
]
|
|
|
}
|
|
|
]
|
|
|
}
|
|
|
</pre>
|
|
|
|
|
|
**Mission example**
|
|
|
|
|
|
The following json ( [[%ATTACHURL%/mission_eg.json][mission_eg.json]]) represents a simple game mission where the user have to identify which class is going on, reading the *agenda*, and write down on the <strong>copybook </strong>what the teacher write on the <strong>blackboard </strong>using the *pen*. Notice that a subtask has been inserted that doesn't interfere with the mission, but permits to obtain an higher score: the *watch* of the student has a wrong time that can be corrected based on the *class clock*. Notice moreover that the *door* is not added to the configuration objects so it will not be an interactable object for this mission
|
|
|
<pre>{
|
|
|
"title":"Lesson time",
|
|
|
"description":"Check which is the current class that you're attending and write down on your copybook what is written on the blackboard.",
|
|
|
"configuration":[
|
|
|
{
|
|
|
"id":"startingposition",
|
|
|
"options":{
|
|
|
"position":"pos2"
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"backpack",
|
|
|
"options":{ ## color can be left the default one
|
|
|
"label":"Mark",
|
|
|
"is_open":true
|
|
|
},
|
|
|
"actions":{
|
|
|
"open":{"disabled":true},
|
|
|
"take":{"disabled":true}
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"watch",
|
|
|
"options":{
|
|
|
"color":"#000000",
|
|
|
"type":"analog",
|
|
|
"hour":3,
|
|
|
"minutes":29
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"classclock",
|
|
|
"options":{
|
|
|
"time":"9:05"
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"pen"
|
|
|
},
|
|
|
{
|
|
|
"id":"agenda",
|
|
|
"options":{
|
|
|
"scheduling":"8:00-9:00 gym 9:00-11:00 Math 11:00-13:00 English",
|
|
|
"position":"backpack"
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"copybook",
|
|
|
"options":{
|
|
|
"position":"backpack",
|
|
|
"subject":"Math"
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"id":"blackboard",
|
|
|
"options":{
|
|
|
"text":""
|
|
|
}
|
|
|
}
|
|
|
],
|
|
|
"steps":[
|
|
|
{
|
|
|
"name":"Extract agenda from the backpack and check hour",
|
|
|
"actions":
|
|
|
[
|
|
|
{
|
|
|
"type":"pickup",
|
|
|
"object":"backpack",
|
|
|
"score":{
|
|
|
"before":2,
|
|
|
"after":1,
|
|
|
"never":-1
|
|
|
},
|
|
|
"feedback":{
|
|
|
"negative":"try to get the scheduling from the agenda before getting a copybook."
|
|
|
},
|
|
|
"value":"agenda"
|
|
|
},
|
|
|
{
|
|
|
"type":"read",
|
|
|
"object":"blackboard",
|
|
|
"optional":"true"
|
|
|
},
|
|
|
{
|
|
|
"type":"read",
|
|
|
"object":"classclock",
|
|
|
"score":{"before":1,"after":1,"never":-1},
|
|
|
"feedback":"check the class clock."
|
|
|
},
|
|
|
{
|
|
|
"type":"read",
|
|
|
"object":"watch",
|
|
|
"optional":"true",
|
|
|
"score":{"before":1,"after":1,"never":0}
|
|
|
},
|
|
|
{
|
|
|
"type":"sethour",
|
|
|
"object":"watch",
|
|
|
"optional":"true",
|
|
|
"value":[{
|
|
|
"min":9,
|
|
|
"max":9,
|
|
|
"score":1
|
|
|
}]
|
|
|
},
|
|
|
{
|
|
|
"type":"setminutes",
|
|
|
"object":"watch",
|
|
|
"optional":"true",
|
|
|
"value":[{
|
|
|
"min":5,
|
|
|
"max":5,
|
|
|
"score":1
|
|
|
}]
|
|
|
}
|
|
|
]
|
|
|
},
|
|
|
{
|
|
|
"name":"get the scheduling from the agenda",
|
|
|
"prerequisites":[
|
|
|
{
|
|
|
"id":"agenda",
|
|
|
"options":{
|
|
|
"position":"desk"
|
|
|
}
|
|
|
}
|
|
|
]
|
|
|
"actions":[{
|
|
|
"type":"read",
|
|
|
"object":"agenda",
|
|
|
"final":true,
|
|
|
"score":{
|
|
|
"before":2,
|
|
|
"after":1,
|
|
|
"never":-1
|
|
|
}
|
|
|
}]
|
|
|
},
|
|
|
{
|
|
|
"name":"get correct copybook",
|
|
|
"actions":[{
|
|
|
"type":"pickup",
|
|
|
"object":"backpack",
|
|
|
"final":true,
|
|
|
"value":"math",
|
|
|
"score":{
|
|
|
"before":2,
|
|
|
"after":1,
|
|
|
"never":-1
|
|
|
},
|
|
|
"feedback":{
|
|
|
"negative":"try again at this time there is not this class."
|
|
|
}
|
|
|
},
|
|
|
{
|
|
|
"type":"take",
|
|
|
"object":"pen",
|
|
|
"score":{
|
|
|
"before":2,
|
|
|
"after":1,
|
|
|
"never":-1
|
|
|
}
|
|
|
}
|
|
|
],
|
|
|
"consequences":[
|
|
|
{
|
|
|
"id":"blackboard",
|
|
|
"options":{
|
|
|
"text":"Pitagora's theorem"
|
|
|
}
|
|
|
}
|
|
|
]
|
|
|
},
|
|
|
{
|
|
|
"name":"write on the copybook what is written on the blackboard",
|
|
|
"prerequisites":[
|
|
|
{
|
|
|
"id":"copybook",
|
|
|
"options":{
|
|
|
"position":"desk",
|
|
|
"type":"math"
|
|
|
},
|
|
|
"feedback":{"negative":"You took the wrong copybook."}
|
|
|
}
|
|
|
],
|
|
|
"actions":[
|
|
|
{
|
|
|
"type":"read",
|
|
|
"object":"blackboard",
|
|
|
"score":{
|
|
|
"before":2,
|
|
|
"after":1,
|
|
|
"never":-1
|
|
|
}
|
|
|
},
|
|
|
|
|
|
{
|
|
|
"type":"write",
|
|
|
"object":"copybook",
|
|
|
"final":true,<br /> "mandatory":true,
|
|
|
"value":"Pitagora's theorem",
|
|
|
"score":{
|
|
|
"before":2,
|
|
|
"after":1,
|
|
|
"never":-1
|
|
|
},
|
|
|
"feedback":{"negative":"That's not what is written on the blackboard, check better."}
|
|
|
}
|
|
|
]
|
|
|
}
|
|
|
],
|
|
|
"final-feedback":"Congratulation! You identified correcly what class was running on."
|
|
|
}
|
|
|
</pre>
|
|
|
|
|
|
**Game Server SDK **
|
|
|
|
|
|
The SDK permits to communicate with the GS throught unity.
|
|
|
|
|
|
To use it just add the script StatusManager (SM) to a GameObject and select the type of SM between Demo and server. The demo permits to use the configuration using file while the server one connect directly to a remote server. From other scripts refer to the SM through the static instance StatusManager.instance.
|
|
|
|
|
|
**Status Manager Interface**
|
|
|
|
|
|
Both of the SM use the same interface (callable by the instance) which consist on (note that the login method is not usable on inlife since the auth is done by A2):
|
|
|
<pre>void SetToken (string token);</pre>
|
|
|
|
|
|
After the login with A2 add the token to the SM to add Authorization to all subsequent Api calls. NOTE: do that before perform other API calls or API through proxy will reply with a 401.
|
|
|
<pre>void ForceLoginPlatform (string id, string username, string email, System.Action<bool,string> callback);</pre>
|
|
|
|
|
|
After having done the Login to the A2 and set the token just pass to the ForceLoginPlatform method the user id, username and email to Force the Login to the GS. The Callback permits to manage the return function where the first bool parameter identifies if the login is successfull while the second one describe the possible error.
|
|
|
<pre>void Load<T> (LoadEnvelope<T>.ObjectLoadedHandler function,Hashtable parameters = null) where T:LoadableObject ,new() ;</pre>
|
|
|
|
|
|
The Load method retrive a resource from the GS. Available resources are *Plan*, *Game* and *Highscore*. To load a resource just call the method using the resource instead of the type *T.* The *ObjectLoaderHandler* is a callback function of type (bool success, T element, string error) where success identify if the SM succeeded in retrieve the resource, element is the parsed element of type <strong>T </strong>(Plan, Game etc.) obtained by parsing the resulting JSON from the REST call, finally error contains a message if the API call failed.
|
|
|
|
|
|
Parameters instead is an hashtable which contains all additional parameters to select the correct resource. e.g:
|
|
|
<pre> LoadEnvelope<Plan>.ObjectLoadedHandler loadHandler=InitLevelChoice;
|
|
|
StatusManager.instance.Load<Plan>(loadHandler,null);
|
|
|
</pre>
|
|
|
|
|
|
or
|
|
|
<pre> LoadEnvelope<Game>.ObjectLoadedHandler loadHandler=InitConfig;
|
|
|
StatusManager.instance.Load<Game>(loadHandler,("{\"pg_id\":"+[UUID OF THE GAME IN THE PLAN]+",\"session_id\":\""+[ID OF AN ISTANCE OF THE PLAN (SESSION)]+"\"}").hashtableFromJson());
|
|
|
</pre>
|
|
|
|
|
|
To add a new resource type a new class that extends *LoadableObject* has to be created. The new created class must implements _bool ParseFromJson (Hashtable input)_ function which return a bool that identifies a success or a failure, while input is a JSON in form of hashtable. Plus a new entry have to be added in three different dictionaries in the class *LoadUtils:*
|
|
|
|
|
|
* *PAGE_MAPPING*: {typeof([NEW CLASS TYPE]).Name, [ENDPOINT usually api.php]}
|
|
|
* *SERVICE_MAPPING*: {typeof([NEW CLASS TYPE]).Name, [SERVICE param: identify the type of service to call, like planner, logger etc.]}
|
|
|
* *ACTION_MAPPING*:{typeof([NEW CLASS TYPE]).Name, [ACTION param: identify the action on the service to call that returns the resource.]}
|
|
|
<pre>void LoadList<T> (LoadEnvelope<T>.ObjectListLoadedHandler function,Hashtable parameters = null) where T:LoadableObject ,new() ;</pre>
|
|
|
|
|
|
LoadList work exactly the same as Load, but it load a list of object of type T instead of a single one.
|
|
|
<pre>void Log(string type, Hashtable payload);</pre>
|
|
|
|
|
|
In the GS is embedded a Log system that add the possibility to log each custom event that Developer want to add. The log event has a type and a payload which is a JSON in form of hashtable. The type can be anything developer wants, however there are special types that have a meaning in the platform:
|
|
|
* *login*: log the login of the user. Useful to send to the server information about the device in use. The payload can contain an element "<em>device</em>":{"ip":"...","version":"version of the client","name":"device name","model":"device model","type":"device type","id":"UUID"}. e.g. StatusManager.instance.Log ("login",("{"device":{...}").hashtableFromJson());
|
|
|
* *startup*: identifies the start of a game, shall have in the payload:
|
|
|
<pre> {
|
|
|
<strong>pg_id</strong>:[Plan game id as obtained from the loading of the plan],
|
|
|
<strong>session_id</strong>:[actual session (Plan instance) ID]
|
|
|
}</pre>
|
|
|
* <strong>status-game: </strong>save the result of the game as a partial status
|
|
|
<pre> {
|
|
|
<strong>pg_id</strong>:[Plan game id as obtained from the loading of the plan],
|
|
|
<strong>session_id</strong>:[actual session (Plan instance) ID],
|
|
|
<strong>results</strong>:{[a custom JSON with everything the developer want to track about the game]}
|
|
|
}</pre>
|
|
|
* <strong>end-game: </strong>sends the feedback of a game to the server. It shall contains in the payload
|
|
|
<pre> {
|
|
|
<strong>pg_id</strong>:[Plan game id as obtained from the loading of the plan],
|
|
|
<strong>session_id</strong>:[actual session (Plan instance) ID],
|
|
|
<strong>status</strong>:[can be <em>complete</em>, <em>fail</em> or <em>userexit</em> to identify wheter the user complete succesfully the game, fails or just exit without finish],
|
|
|
<strong>score</strong>: [the score obtained during the game],
|
|
|
<strong>results</strong>:{[a custom JSON with everything the developer want to track about the game]}
|
|
|
}</pre>
|
|
|
* <strong>status-plan: </strong>save the result of the plan as a partial status
|
|
|
<pre> {
|
|
|
<strong>session_id</strong>:[actual session (Plan instance) ID],
|
|
|
<strong>results</strong>:{[a custom JSON with everything the developer want to track about the plan]}
|
|
|
}</pre>
|
|
|
* <strong>end-plan: </strong>save the result to the plan and end it
|
|
|
<pre> {
|
|
|
<strong>session_id</strong>:[actual session (Plan instance) ID],
|
|
|
<strong>results</strong>:{[a custom JSON with everything the developer want to track about the plan]}
|
|
|
}</pre>
|
|
|
|
|
|
Note that Log doesn't listen to the response by the server. If you want to have a callback use the method Save.
|
|
|
<pre>void Save(string type, Hashtable payload, StatusManager.ObjectSaverHandler saverHandler);</pre>
|
|
|
|
|
|
Works like the log but permits a callback, it have to be used if the application have to wait for the response to perform some action. The callback must be a function which accept as parameters a bool and a string the bool to identify the success of the save operation while the string is the possible error description.
|
|
|
|
|
|
**Plan**
|
|
|
|
|
|
A plan is just a container of games (gamesList) identified by a session id (session_id).
|
|
|
|
|
|
It can contain several options in key value format (to define if useful for inlife).
|
|
|
|
|
|
Moreover there is the attribute results that can contain saved information about the plan, custom defined by the developer.
|
|
|
|
|
|
**Game**
|
|
|
|
|
|
A game is defined by:
|
|
|
* <b>pg_id: </b>id of the game in the plan.
|
|
|
* *game_id*: id of the game/environment (independent by the plan, defines the id of the game itself)
|
|
|
* <b>name: </b>name of the game
|
|
|
* *description*: description of the game
|
|
|
* *parameters*: is an hashtable that contains all game parameters (if the game is a minigame) by key value
|
|
|
* *resource_URL*: contains a reference to a thumbnail of the game
|
|
|
* *executable*: the reference to the scene name (to define if useful in inlife)
|
|
|
* *version*: the version of the game, useful to distinghuish between different versions of the game
|
|
|
* *status*: the status of the game can be "<i>toplay</i>","<i>complete</i>","<i>userexit</i>" or "<i>fail</i>"
|
|
|
* *score*: is the score obtained in the game, previously saved (if the game was completed)
|
|
|
* *actualLevel*: a reference to the <b>Level </b>selected
|
|
|
* *levels*: a list of <b>Level </b>contained in the sequence (Can be a list of mission)
|
|
|
* *seqMode*: mode of the sequence of levels, it is used to define how the app shall treat the levels sequence, can be:
|
|
|
* <i>auto: </i>the level is advanced by default, so actual level is the one defined by the reasoner
|
|
|
* _unlocked:_ the level is unlocked and available once reached; the player can select the whole range of levels lower than the actual one
|
|
|
* _free:_ all the levels in the sequence are selectable
|
|
|
* _suggestion:_ the level is the one selected by the developer/educator in the plan, however the level choice in the plan provides information about the user status about the level. i.e. if the user have completed the level and should change level or not
|
|
|
* *dependencies*: a list of *Dependency* that shall be loaded to play the game (if they exists, and are usefull for the game)
|
|
|
* *mission*: actual <b>Mission </b>object related to the Level (a mission is in fact a Level for an environmental game)
|
|
|
|
|
|
**Level**
|
|
|
|
|
|
A level consists in:
|
|
|
* *id*: the id of the level
|
|
|
* *name*: the name of the level
|
|
|
* *progress*: the amount of progress of this level (if the level is inside a sequence); a value from 0 to 100, 100 means that the level is completed.
|
|
|
* *parameters*: if the game is a minigame, the parameters are pairs of key value.
|
|
|
* *mission*: if the game is environmental the level is identified by a mission.
|
|
|
|
|
|
**Dependency**
|
|
|
|
|
|
A dependency consists in a resource useful to the game, that have to be loaded in order to play the game.
|
|
|
* *name*: name of the dependency
|
|
|
* *type*: right now there can be two types of dependency:
|
|
|
* _Scene_: maps a Unity scene that have to be loaded in a multi scene environment
|
|
|
* _Resource_:maps whatever resource is useful to load
|
|
|
* *resource_URL*: a reference to the actual resource that have to be loaded
|
|
|
* *version*: the version of the resource (used for caching purpose)
|
|
|
|
|
|
**Mission**
|
|
|
|
|
|
The mission is a C# mapping of concepts inside the mission.json one to one.
|
|
|
|
|
|
**Status Manager Demo**
|
|
|
|
|
|
The *StatusManagerDemo* has only one parameter named <b>Prefix </b>which can address different subfolder containing different plans (e.g. "test/" reemember the final slash).
|
|
|
|
|
|
To hardlink a *Plan*, just create a new file __Plan.json__ in a Resources folder (for example Assets/Demo/Resources) with a structure like this one:
|
|
|
<pre>{
|
|
|
<b>Plan_ID</b>:"1", --- can be whatever
|
|
|
<b>Plan_Name</b>:"DEMO", --- or whatever
|
|
|
<b>Owner</b>:"0",
|
|
|
<b>Session_ID</b>:"1", --- can be whatever
|
|
|
<b>games</b>:[
|
|
|
{
|
|
|
<b>Plan_Game_ID</b>:[can be whatever but it is used to address the game configuration],
|
|
|
<b>Game_ID</b>:[identifies the minigame/environment by his ID on the GS],
|
|
|
<b>Parameter</b>:[parameters of the minigame],
|
|
|
[<b>Level</b>]:[default level (level definition in the game config)],
|
|
|
[<b>Sequence</b>]:[address if a sequence of levels is used by is ID, for the demo setting can be whatever or be empty],
|
|
|
<b>Name</b>:[Title of the game],
|
|
|
<b>Description</b>:[Description],
|
|
|
<b>Resource_URL</b>:[Path to a tooltip for the game],
|
|
|
<b>Executable</b>:[possible unity scene name if the game uses a multiscene system],
|
|
|
<b>Version</b>:[Version of the game use to solve cache issues],
|
|
|
<b>Dependencies</b>:[ -- this is a list of resourrces or unity scene that havve to be loaded before the game scene is it used to share common scene or resources between games
|
|
|
{
|
|
|
<b>Name</b>:[name of the dependency to load for the game],
|
|
|
<b>Resource_URL</b>:[url location (or file) of the resource to load],
|
|
|
<b>Version</b>:[version of the resource to solve cache issues],
|
|
|
<b>Type</b>:[can be Scene or Resource]
|
|
|
},
|
|
|
...
|
|
|
],
|
|
|
<b>Status</b>:"toplay", -- in the demo shall remain toplay
|
|
|
<b>Active</b>:"1",
|
|
|
<b>LevelName</b>:[the displayed name for the difficulty level]
|
|
|
},
|
|
|
...
|
|
|
],
|
|
|
<b>options</b>:{ --- a list of option for the plan only order by now
|
|
|
<b>order</b>:"\"free\""
|
|
|
}
|
|
|
}
|
|
|
</pre>
|
|
|
|
|
|
In the same folder for each game a file named __Game[PG_ID].json__ (eg. Game[1].json) shall be created containing:
|
|
|
<pre>{
|
|
|
<b>Plan_Game_ID</b>:[the same PG_ID defined in Plan.json],
|
|
|
<b>Game_ID</b>:[the id for this game],
|
|
|
<b>Parameters</b>:[the parameter set for this game, can be overridden by levels],
|
|
|
[<b>Sequence</b>]:[if defined refers to a sequence (list of levels) in DEMO can be any number, if not defined there will not be the possibility to select the level],
|
|
|
<b>Name</b>:[name of the game],
|
|
|
<b>Description</b>:[description of the game],
|
|
|
<b>Resource_URL</b>:[thumbnail],
|
|
|
<b>Executable</b>:[Scene name or whatever to identify the executable of this game],
|
|
|
<b>Version</b>:[version for refresh purposes],
|
|
|
<b>Dependencies</b>:[as defined in the plan],
|
|
|
<b>Status</b>:"toplay", --- as for Plan.json it's better to set this with "toplay"
|
|
|
<b>Score</b>:[previous score if already played just zero in DEMO mode],
|
|
|
<b>Active</b>:"1",
|
|
|
<b>Levels</b>:[ --- this is the list of all the levels available for this sequence
|
|
|
{
|
|
|
<b>Id</b>:[id of the sequence level (a level can be add to multiple sequences)],
|
|
|
<b>Level_ID</b>:[the id of the level (it's game dependant so not a uuid)],
|
|
|
<b>Parameters</b>:[the parameters for this level, can override the presets],
|
|
|
<b>Name</b>:[Display name for this level]
|
|
|
},<br /> ...
|
|
|
],
|
|
|
<b>SequenceMode</b>:"free" -- can be also <i>incremental</i>, <i>auto</i> or <i>suggestion</i>, but for DEMO purposes it's better to set <i>free</i> so that that the user can define at which level to play
|
|
|
}
|
|
|
</pre>
|
|
|
|
|
|
**Status Manager Server**
|
|
|
|
|
|
The <b>StatusManagerServer </b>behaviour has several parameters, but the most important to set are:
|
|
|
* *Dont Destroy On Load*: flag this if the StatusManager shall be used in a multiple scenes context.
|
|
|
* <b>Secret Key: </b>depends on how the server is configured it should be needed to add the Server secret key to the StatusManager to bound the communication between client and server.
|
|
|
* <b>Url Root Production/Stage: </b>used to address the status manager core endpoint it shall be [SERVER ADDRESS through A2 proxy]/core/
|
|
|
* <b>Use Stage: </b>manage which Url shall be used.
|
|
|
* <b>Log Debug Info: </b>a flag to activate the debug logging in the unity console.
|
|
|
* <b>Ping Interval Seconds: </b>if greater than 0 activate a ping which runs every N seconds which controls if the server is active [in inlife shall be set to 0]
|
|
|
* *Url Root Base Production/Stage*:used to address the status manager endpoint: shall be [SERVER ADDRESS through A2 proxy]/
|
|
|
The other parameters are not in use in Inlife so they can be left to the default value.
|
|
|
|
|
|
|