Esempio n. 1
0
        /**
         * Compute the payoffs of the game.
         *
         * @param prevMoves The list of the last moves.
         * @return List of triplets with player's name, payoff, and a flag telling whether it's the played role.
         */
        public List<PayOff> GetPayoffs(GdlList prevMoves)
        {
            // (role name, payoff, my role?) list
            var payoffs = new List<PayOff>(Roles.Count);

            // Construct list of previous moves
            GroundFact[] previousMoves = ParsePreviousMoves(prevMoves);
            UpdateCurrentState(previousMoves);

            foreach (TermObject role in Roles)
            {
                int payoff;
                try
                {
                    Fact goal = GetAnAnswer(CurrentContext, "goal", role.ToString(), "?x");
                    var score = (TermObject)goal.GetTerm(1);
                    payoff = int.Parse(score.ToString());
                }
                catch (Exception)
                {
                    payoff = -1;
                }
                payoffs.Add(new PayOff(role.ToString(), payoff, role.Equals(MyRole)));
            }

            return payoffs;
        }
Esempio n. 2
0
        public static void Initialise(GdlList description)
        {
            SymbolTable = Parser.SymbolTable;

            GameInformation = new MetaGdl(Parser).ExamineGdl(description);

            var expressions = new List<Expression>();
            expressions.AddRange(GameInformation.GetRules());
            expressions.AddRange(GameInformation.GetAllGrounds());
            Prover = new AimaProver(expressions);
        }
Esempio n. 3
0
        /// <summary>
        /// Ends the game specified by <tt>gameId</tt>. The final moves are
        /// processed and the payoffs are computed and printed to the logger.
        /// </summary>
        /// <param name="gameId">Name of the game to terminate.</param>
        /// <param name="prevMoves">The last set of moves made in the game.</param>
        public static void EndGame(String gameId, GdlList prevMoves)
        {
            IGamer gamer = Games[gameId];

            if (gamer == null)
            {
                Logger.Error(gameId + ": WARNING: Attempting to terminate game [" + gameId + "], but no such game");
                return;
            }

            try
            {
                var prevMovesStr = new StringBuilder();
                prevMovesStr.Append(" Previous moves: ");
                foreach (GdlExpression exp in prevMoves)
                {
                    prevMovesStr.Append(exp);
                    prevMovesStr.Append("  ");
                }

                Logger.Info(gameId + ": Beginning payoff computation." + prevMovesStr);

                // Get the list of payoffs: <Role, Payoff, IsMe>
                List<PayOff> results = gamer.GetPayoffs(prevMoves);

                // Figure out what the longest role is
                int maxRoleLength = results.Select(res => res.PlayerName.Length).Concat(new[] { 0 }).Max();

                // Print out the payoffs
                foreach (PayOff res in results)
                {
                    // print the right amount of spaces (so that things line up right)
                    var spacing = new StringBuilder();
                    for (int i = 0; i < maxRoleLength - res.PlayerName.Length; i++)
                        spacing.Append(" ");

                    Logger.Info("       " + (res.PlayedRole ? "->" : "  ") + " " + res.PlayerName + spacing + " " + res.Payoff + " " + (res.PlayedRole ? "<-" : "  "));
                }
            }
            catch (Exception e)
            {
                Logger.Fatal(gameId + ": Error computing payoff: " + e.GetType().Name + " - " + e.Message);
            }

            // tell the game it's time to die.
            gamer.StopIt();
            Games.Remove(gameId);
        }
Esempio n. 4
0
        /// <summary>
        /// Construct a variable fact from a GdlList. Note that the list <i>must</i>
        /// be a list of atoms, in other words, there cannot be any nested lists. The
        /// fact is constructed by taking the first element of the list as the fact's
        /// relation name, and every subsequent element as a column. If an atom is
        /// found to be a variable, then that column is marked as a variable.
        /// </summary>
        /// <param name="list">The list to build the fact from.</param>
        /// <returns>A variable fact representing the data from the list.</returns>
        public static Fact FromList(GdlList list)
        {
            int relName = ((GdlAtom)list[0]).GetToken();

            var terms = new Term[list.Arity];

            // Turn each element of the list into a term.
            // Make sure to turn same variables into the same term.

            bool vars = false;

            var varMap = new Dictionary<GdlVariable, TermVariable>();

            for (int i = 0; i < list.Arity; i++)
            {
                GdlExpression exp = list[i + 1];

                if ((exp is GdlVariable) == false)
                {
                    terms[i] = Term.BuildFromGdl(exp, varMap);

                    // Check to see if this term has variables in it.
                    // (But don't bother if we already know that we have variables.)
                    if (!vars && terms[i].HasVariables)
                        vars = true;
                }
                else
                {
                    var var = (GdlVariable)exp;
                    terms[i] = new TermVariable(var.GetToken());
                    vars = true;
                }

            }

            // Only return a variable fact if this actually has variables
            if (vars)
                return new VariableFact(true, relName, terms);
            return new GroundFact(relName, terms);
        }
Esempio n. 5
0
 internal StopRequestHandler(ISocketWrapper socket, HttpHeader header, GdlList content, string matchId)
     : base(socket, header, matchId)
 {
     _content = content;
 }
Esempio n. 6
0
        protected GroundFact[] ParsePreviousMoves(GdlList prevMoves)
        {
            if (prevMoves == null)
                return new GroundFact[0];

            if (prevMoves.Size != Roles.Count)
                Logger.Error(GameId + ": Previous move list is not the same size as number of roles!");

            var previousMoves = new GroundFact[prevMoves.Size];

            for (int i = 0; i < prevMoves.Size; i++)
            {
                if (i >= Roles.Count)
                    break;

                previousMoves[i] = new GroundFact(Parser.TokDoes, Roles[i], Term.BuildFromGdl(prevMoves[i]));
            }

            return previousMoves;
        }
Esempio n. 7
0
        /**
         * Think about the next move and return it.
         *
         * @param prevMoves The moves just made, or nil if none (first move).
         * @return A triple containing: the move, an explanation (or null) and a taunt (or null).
         */
        public Tuple<GdlExpression, string, string> Play(GdlList prevMoves)
        {
            // Construct list of previous moves
            GroundFact[] previousMoves = ParsePreviousMoves(prevMoves);

            if (previousMoves.Length > 0)
                UpdateCurrentState(previousMoves);

            Tuple<Term, string, string> move = MoveThink();

            // Convert the Term to a GdlExpression

            GdlExpression moveGdl;

            if (move == null || move.Item1 == null)
            {
                Logger.Error(GameId + ": move returned by moveThink was null");
                moveGdl = new GdlAtom(SymbolTable, Parser.TokNil);
                move = new Tuple<Term, string, string>(null, "", "");
            }
            else
            {
                // the top-level element returned is list of all elements in the parse;
                // in this case, we have just one, the move.
                moveGdl = Parser.Parse(move.Item1.ToString())[0];
            }

            var m = new Tuple<GdlExpression, string, string>(moveGdl, move.Item2, move.Item3);

            return m;
        }
Esempio n. 8
0
        /// <summary>
        /// Starts a new game. Takes the information from the start message
        /// and gives it to the gamer factory, which creates an appropriate
        /// gamer for the game.
        /// see stanfordlogic.Gamer
        /// </summary>
        /// <param name="gameId">The identifier of the game being started.</param>
        /// <param name="role">The role I am playing in the new game.</param>
        /// <param name="description">The description (rules) of the game.</param>
        /// <param name="startClock">The time given to think about the game.</param>
        /// <param name="playClock">The time given to make a move.</param>
        /// <returns>The Gamer instance created to play the game.</returns>
        public static IGamer NewGame(String gameId, GdlAtom role, GdlList description, int startClock, int playClock)
        {
            lock (typeof(GameManager))
            {
                if (_gamerFactory == null)
                {
                    Logger.Error("No gamer factory set!");
                    return null;
                }

                // Make sure this game isn't already active:
                if (Games.Contains(gameId))
                {
                    Logger.Error("Game already active: " + gameId);
                    return null;
                }

                Logger.Info("");
                Logger.Info("-----------------------------------------------");
                Logger.Info("NEW GAME! " + gameId);
                Logger.Info("");
                Logger.Info("    My role : " + role);
                Logger.Info("Start clock : " + startClock);
                Logger.Info(" Play clock : " + playClock);
                Logger.Info("");

                // put in a temporary game:
                Games[gameId] = null;
            }

            IGamer g = _gamerFactory.MakeGamer(gameId, role, description, startClock, playClock);

            lock (typeof(GameManager))
            {
                Games[gameId] = g;
            }

            return g;
        }
Esempio n. 9
0
        private void ExamineTopLevelList(GdlList list)
        {
            // Is this a rule, or a relation?
            // Note that it is safe to assume that the head is in fact an atom.
            var head = (GdlAtom)list[0];

            if (head.GetToken() == _parser.TokImpliedby)
            {
                Implication impl = ExamineRule(list);
                AddRule(impl.Consequent.RelationName, impl);
            }
            else
            {
                // It must be a ground fact at this point: it can't have variables,
                // since there is no rule to specify binding.
                var f = (GroundFact)ExamineListRelation(list, head.GetToken());
                AddGround(head.GetToken(), f);

                // Is this a role?
                if (head.GetToken() == _parser.TokRole)
                    _roles.Add((TermObject)f.GetTerm(0));
            }
        }
Esempio n. 10
0
        private void ExamineListTerm(GdlList list)
        {
            // The first element here must be a function symbol.
            // Note that it is safe to assume that the head is in fact an atom.
            var head = (GdlAtom)list[0];

            int token = head.GetToken();

            //TODO: Make sure that 'token' is a function symbol.
            //if (IsObjectSymbol(token) || IsRelationSymbol(token))
            //    throw new Exception("Symbol '" + token + "' (" + _parser.SymbolTable[token] + ") already exists, but not as a function symbol!");

            // Add it to our list of function symbols
            AddFunctionSymbol(token);

            // Now look at the rest of the elements in the list.
            for (int i = 1; i < list.Size; i++)
                ExamineTerm(list[i]);
        }
Esempio n. 11
0
        private Expression ExamineListRelation(GdlList relation, int relName)
        {
            // First: check to see if this is a logical operator, i.e. one of not/or/and

            if (relName == _parser.TokNotOp)
                // The next element must be a sentence
                return new Negation(ExamineRelation(relation[1]));

            if (relName == _parser.TokOrOp)
            {
                // all the rest of the elements are relations (sentences), not terms.
                var disjuncts = new Expression[relation.Arity];

                for (int i = 1; i <= relation.Arity; i++)
                    disjuncts[i - 1] = ExamineRelation(relation[i]);

                return new Disjunction(false, disjuncts);
            }

            // Second case: normal relation.

            //TODO: Make sure this symbol isn't a function/object symbol already.
            //if (IsFunctionSymbol(relName) || IsObjectSymbol(relName))
            //    throw new Exception(string.Format("Symbol '{0}' ({1}) already exists, but not as a relation symbol!", relName, _parser.SymbolTable[relName]));

            // Add the relation name to our list of relation symbols.
            AddRelationSymbol(relName, relation.Arity);

            // Examine each term of the relation
            for (int i = 1; i <= relation.Arity; i++)
                ExamineTerm(relation[i]);

            // Convert the relation to a (ground or variable) fact.
            return Fact.FromExpression(relation);
        }
Esempio n. 12
0
        public Implication ExamineRule(GdlList rule)
        {
            // First element is the IMPLIEDBY token; ignore it.

            // Second element is the head of the rule. It's a relation (fact).
            var head = (Fact)ExamineRelation(rule[1]);

            // Everything thereafter are the antecedent relations.
            var conjuncts = new Expression[rule.Arity - 1];

            // Create the conjunct list
            for (int i = 2; i < rule.Size; i++)
                conjuncts[i - 2] = ExamineRelation(rule[i]);

            conjuncts = DistinctSorter.SortDistincts(conjuncts);

            // Create a rule structure and add it to our list.
            return new Implication(false, head, conjuncts);
        }
Esempio n. 13
0
 protected abstract RequestHandler CreateFromList(ISocketWrapper socket, RequestHandler.HttpHeader header, GdlList list);