def runScramblerTest(self, scrambler): """ generated source for method runScramblerTest """ repo = GameRepository.getDefaultRepository() for gameKey in repo.getGameKeys(): for rule in game.getRules(): theScrambledRules.add(GdlFactory.create(renderedScrambledRule)) # If the scrambler claims that it scrambles the game, then the # scrambled rules should be different than the original rules. # Otherwise they should be identical. if scrambler.scrambles(): assertTrue(gameKey, not renderedRule == renderedScrambledRule) else: assertEquals(gameKey, renderedRule, renderedScrambledRule) # One important property for any scrambler is that the original # and the unscrambled Gdl must be the same. This guarantees that # the server can correctly unscramble responses from the players. assertEquals(gameKey, renderedRule, renderedUnscrambledRule) # An important property for any scrambler is that the scrambled rules # have the same physics as the regular rules. For example, the number # of roles in each game should be the same, and the number of facts # that are true in the initial state should be the same. There could # be more thorough verification here, like looking at the number of # legal joint moves in the first state, or simulating entire matches, # but that would be expensive. pNormal.initialize(game.getRules()) pScrambled.initialize(theScrambledRules) assertEquals(gameKey, pNormal.getRoles().size(), pScrambled.getRoles().size()) assertEquals(gameKey, pNormal.getInitialState().getContents().size(), pScrambled.getInitialState().getContents().size())
def parseMoves(self, symbol): """ generated source for method parseMoves """ if isinstance(symbol, (SymbolAtom, )): return None else: while i < len(list_): moves.add(GdlFactory.createTerm(list_.get(i))) i += 1 return moves
def getRules(self): """ generated source for method getRules """ try: while i < len(list_): rules.add(GdlFactory.create(list_.get(i))) i += 1 return rules except GdlFormatException as e: e.printStackTrace() return None except SymbolFormatException as e: e.printStackTrace() return None
def createStart(self, gamer, list_): """ generated source for method createStart """ if len(list_) < 6: raise IllegalArgumentException("Expected at least 5 arguments!") arg1 = list_.get(1) arg2 = list_.get(2) arg3 = list_.get(3) arg4 = list_.get(4) arg5 = list_.get(5) matchId = arg1.getValue() roleName = GdlFactory.createTerm(arg2) theRulesheet = arg3.__str__() startClock = Integer.valueOf(arg4.getValue()) playClock = Integer.valueOf(arg5.getValue()) # For now, there are only five standard arguments. If there are any # new standard arguments added to START, they should be added here. theReceivedGame = Game.createEphemeralGame(theRulesheet) return StartRequest(gamer, matchId, roleName, theReceivedGame, startClock, playClock)
def unscramble(self, x): """ generated source for method unscramble """ return GdlFactory.create(x)
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
def unscramble(self, x): """ generated source for method unscramble """ return GdlFactory.create(self.UnscramblingRenderer().renderGdl(GdlFactory.create(x)))