Ejemplo n.º 1
0
 def create(cls, description):
     """ generated source for method create """
     try:
         GamerLogger.log("StateMachine", "Converting...")
         return PropNetConverter().convert(Role.computeRoles(description), flatDescription)
     except Exception as e:
         GamerLogger.logStackTrace("StateMachine", e)
         return None
Ejemplo n.º 2
0
Archivo: Match.py Proyecto: hobson/ggpy
 def __init__(self, matchId, previewClock, startClock, playClock, theGame):
     """ generated source for method __init__ """
     self.matchId = matchId
     self.previewClock = previewClock
     self.startClock = startClock
     self.playClock = playClock
     self.theGame = theGame
     self.startTime = Date()
     self.randomToken = getRandomString(32)
     self.spectatorAuthToken = getRandomString(12)
     self.isCompleted = False
     self.isAborted = False
     self.numRoles = Role.computeRoles(theGame.getRules()).size()
     self.moveHistory = ArrayList()
     self.stateHistory = ArrayList()
     self.stateTimeHistory = ArrayList()
     self.errorHistory = ArrayList()
     self.goalValues = ArrayList()
Ejemplo n.º 3
0
 def create_0(cls, description, verbose):
     """ generated source for method create_0 """
     print "Building propnet..."
     startTime = System.currentTimeMillis()
     description = GdlCleaner.run(description)
     description = DeORer.run(description)
     description = VariableConstrainer.replaceFunctionValuedVariables(description)
     description = Relationizer.run(description)
     description = CondensationIsolator.run(description)
     if verbose:
         for gdl in description:
             print gdl
     # We want to start with a rule graph and follow the rule graph.
     # Start by finding general information about the game
     model = SentenceDomainModelFactory.createWithCartesianDomains(description)
     # Restrict domains to values that could actually come up in rules.
     # See chinesecheckers4's "count" relation for an example of why this
     # could be useful.
     model = SentenceDomainModelOptimizer.restrictDomainsToUsefulValues(model)
     if verbose:
         print "Setting constants..."
     constantChecker = ConstantCheckerFactory.createWithForwardChaining(model)
     if verbose:
         print "Done setting constants"
     sentenceFormNames = SentenceForms.getNames(model.getSentenceForms())
     usingBase = sentenceFormNames.contains("base")
     usingInput = sentenceFormNames.contains("input")
     # For now, we're going to build this to work on those with a
     # particular restriction on the dependency graph:
     # Recursive loops may only contain one sentence form.
     # This describes most games, but not all legal games.
     dependencyGraph = model.getDependencyGraph()
     if verbose:
         print "Computing topological ordering... ",
         System.out.flush()
     ConcurrencyUtils.checkForInterruption()
     topologicalOrdering = getTopologicalOrdering(model.getSentenceForms(), dependencyGraph, usingBase, usingInput)
     if verbose:
         print "done"
     roles = Role.computeRoles(description)
     components = HashMap()
     negations = HashMap()
     trueComponent = Constant(True)
     falseComponent = Constant(False)
     functionInfoMap = HashMap()
     completedSentenceFormValues = HashMap()
     for form in topologicalOrdering:
         ConcurrencyUtils.checkForInterruption()
         if verbose:
             print "Adding sentence form " + form,
             System.out.flush()
         if constantChecker.isConstantForm(form):
             if verbose:
                 print " (constant)"
             # Only add it if it's important
             if form.__name__ == cls.LEGAL or form.__name__ == cls.GOAL or form.__name__ == cls.INIT:
                 # Add it
                 for trueSentence in constantChecker.getTrueSentences(form):
                     trueProp.addInput(trueComponent)
                     trueComponent.addOutput(trueProp)
                     components.put(trueSentence, trueComponent)
             if verbose:
                 print "Checking whether " + form + " is a functional constant..."
             addConstantsToFunctionInfo(form, constantChecker, functionInfoMap)
             addFormToCompletedValues(form, completedSentenceFormValues, constantChecker)
             continue 
         if verbose:
             print 
         # TODO: Adjust "recursive forms" appropriately
         # Add a temporary sentence form thingy? ...
         addSentenceForm(form, model, components, negations, trueComponent, falseComponent, usingBase, usingInput, Collections.singleton(form), temporaryComponents, temporaryNegations, functionInfoMap, constantChecker, completedSentenceFormValues)
         # TODO: Pass these over groups of multiple sentence forms
         if verbose and not temporaryComponents.isEmpty():
             print "Processing temporary components..."
         processTemporaryComponents(temporaryComponents, temporaryNegations, components, negations, trueComponent, falseComponent)
         addFormToCompletedValues(form, completedSentenceFormValues, components)
         # if(verbose)
         # TODO: Add this, but with the correct total number of components (not just Propositions)
         # print "  "+completedSentenceFormValues.get(form).size() + " components added";
     # Connect "next" to "true"
     if verbose:
         print "Adding transitions..."
     addTransitions(components)
     # Set up "init" proposition
     if verbose:
         print "Setting up 'init' proposition..."
     setUpInit(components, trueComponent, falseComponent)
     # Now we can safely...
     removeUselessBasePropositions(components, negations, trueComponent, falseComponent)
     if verbose:
         print "Creating component set..."
     componentSet = HashSet(components.values())
     # Try saving some memory here...
     components = None
     negations = None
     completeComponentSet(componentSet)
     ConcurrencyUtils.checkForInterruption()
     if verbose:
         print "Initializing propnet object..."
     # Make it look the same as the PropNetFactory results, until we decide
     # how we want it to look
     normalizePropositions(componentSet)
     propnet = PropNet(roles, componentSet)
     if verbose:
         print "Done setting up propnet; took " + (System.currentTimeMillis() - startTime) + "ms, has " + len(componentSet) + " components and " + propnet.getNumLinks() + " links"
         print "Propnet has " + propnet.getNumAnds() + " ands; " + propnet.getNumOrs() + " ors; " + propnet.getNumNots() + " nots"
     # print propnet;
     return propnet
Ejemplo n.º 4
0
 def initialize(self, description):
     """ generated source for method initialize """
     self.prover = AimaProver(description)
     self.roles = Role.computeRoles(description)
     self.initialState = computeInitialState()
Ejemplo n.º 5
0
Archivo: Match.py Proyecto: hobson/ggpy
 def __init___0(self, theJSON, theGame, authToken):
     """ generated source for method __init___0 """
     theMatchObject = JSONObject(theJSON)
     self.matchId = theMatchObject.getString("matchId")
     self.startClock = theMatchObject.getInt("startClock")
     self.playClock = theMatchObject.getInt("playClock")
     if theGame == None:
         self.theGame = RemoteGameRepository.loadSingleGame(theMatchObject.getString("gameMetaURL"))
         if self.theGame == None:
             raise RuntimeException("Could not find metadata for game referenced in Match object: " + theMatchObject.getString("gameMetaURL"))
     else:
         self.theGame = theGame
     if theMatchObject.has("previewClock"):
         self.previewClock = theMatchObject.getInt("previewClock")
     else:
         self.previewClock = -1
     self.startTime = Date(theMatchObject.getLong("startTime"))
     self.randomToken = theMatchObject.getString("randomToken")
     self.spectatorAuthToken = authToken
     self.isCompleted = theMatchObject.getBoolean("isCompleted")
     if theMatchObject.has("isAborted"):
         self.isAborted = theMatchObject.getBoolean("isAborted")
     else:
         self.isAborted = False
     self.numRoles = Role.computeRoles(self.theGame.getRules()).size()
     self.moveHistory = ArrayList()
     self.stateHistory = ArrayList()
     self.stateTimeHistory = ArrayList()
     self.errorHistory = ArrayList()
     theMoves = theMatchObject.getJSONArray("moves")
     i = 0
     while i < len(theMoves):
         while j < len(moveElements):
             theMove.add(GdlFactory.createTerm(moveElements.getString(j)))
             j += 1
         self.moveHistory.add(theMove)
         i += 1
     theStates = theMatchObject.getJSONArray("states")
     i = 0
     while i < len(theStates):
         while j < len(stateElements):
             theState.add(GdlFactory.create("( true " + stateElements.get(j).__str__() + " )"))
             j += 1
         self.stateHistory.add(theState)
         i += 1
     theStateTimes = theMatchObject.getJSONArray("stateTimes")
     i = 0
     while i < len(theStateTimes):
         self.stateTimeHistory.add(Date(theStateTimes.getLong(i)))
         i += 1
     if theMatchObject.has("errors"):
         while i < len(theErrors):
             while j < len(errorElements):
                 theMoveErrors.add(errorElements.getString(j))
                 j += 1
             self.errorHistory.add(theMoveErrors)
             i += 1
     self.goalValues = ArrayList()
     try:
         while i < len(theGoalValues):
             self.goalValues.add(theGoalValues.getInt(i))
             i += 1
     except JSONException as e:
         pass
     #  TODO: Add a way to recover cryptographic public keys and signatures.
     #  Or, perhaps loading a match into memory for editing should strip those?
     if theMatchObject.has("playerNamesFromHost"):
         self.thePlayerNamesFromHost = ArrayList()
         while i < len(thePlayerNames):
             self.thePlayerNamesFromHost.add(thePlayerNames.getString(i))
             i += 1
     if theMatchObject.has("isPlayerHuman"):
         self.isPlayerHuman = ArrayList()
         while i < len(isPlayerHumanArray):
             self.isPlayerHuman.add(isPlayerHumanArray.getBoolean(i))
             i += 1
Ejemplo n.º 6
0
 def completeMetadataFromRulesheet(cls, theMetaJSON, theRulesheet):
     """ generated source for method completeMetadataFromRulesheet """
     theRoles = Role.computeRoles(Game.createEphemeralGame(Game.preprocessRulesheet(theRulesheet)).getRules())
     theMetaJSON.put("roleNames", theRoles)
     theMetaJSON.put("numRoles", len(theRoles))