Group 1 Wed Sept 27th checkin

Group 1 - README.md

@@ -0,0 +1,68 @@
+# Group 1: Agent Library Function Descriptions
+
+Below is a set of classes and functions designed to create multiple different Agents with various functionalities.
+
+<details>
+
+<summary> Path Agent </summary>
+Agent that has a user-defined custom movement pattern passed a sequence to be sequentially applied as the agent is updated
+
+- Constructor with ```std::vector```
+    - param ```id```: unique agent id
+    - param ```name```: name of path agent
+    - param ```offsets```: collection of offsets to move the agent
+    ```PathAgent(size_t id, std::string const& name, std::vector<cse491::GridPosition> && offsets = {}) : cse491::AgentBase(id, name), offsets_(offsets);```
+
+- Constructor with ```std::string```
+    - param ```id```: unique agent id
+    - param ```name```: name of path agent
+    - param ```commands```: sequence of commands to be interpreted as offsets
+    ```PathAgent::PathAgent(size_t id, std::string const& name, std::string_view commands) : cse491::AgentBase(id, name), offsets_(str_to_offsets(commands))```
+
+- Initializer
+    - Checks that the agent is able to freely change its own grid location.         Verifies that it can currently index into a valid offset
+    - return: ```true``` if so; ```false``` otherwise.
+    ```bool PathAgent::Initialize();```
+
+- Select Action
+    - Moves the agent by applying the current offset
+    - param ```WorldGrid```: reference grid
+    - param ```type_options_t```: type options
+    - param ```item_set_t```: set of items
+    - param ```agent_set_t```: agent set
+    ```size_t PathAgent::SelectAction(const WorldGrid & /* grid*/, const type_options_t & /* type_options*/, const item_set_t & /* item_set*/, const agent_set_t & /* agent_set*/)```
+
+
+- Set Properties with ```std::vector```
+    - Assigns the offsets_member to a new series of offsets
+    - param ```offsets```: collection of grid positions used as the new offsets
+    - param ```start_index = 0```: which offset to start indexing into (beginning by default)
+    - return: ```self```
+    - **Attention:** throws an `std::invalid_argument` when an invalid start index is provided
+    ```PathAgent& PathAgent::SetProperties(std::vector<cse491::GridPosition> && offsets, size_t start_index = 0)```
+
+- Set properties with ```std::string```
+    - Assigns the offsets_ member to a new series of offsets, taking a command string
+    - param ```commands```: formatted string of commands used as offsets
+    - param ```start_index = 0```: which command to begin indexing into (first command by default)
+    - return: ```self```
+    - **Attention:** throws an `std::invalid_argument` when mis-formatted commands an invalid index is provided
+    ```PathAgent& PathAgent::SetProperties(std::string_view commands, size_t start_index = 0)```
+
+- Helper function for a formatted ```std::string``` input
+    - Converts a string to a sequence of offsets
+    - This convenience method takes a string with a special formatting that allows one to specify a sequence of inputs in linear directions.
+    - The format is [steps[*]]<direction> where `steps` is a positive integer and optional (assumed to be 1 by default)
+    - star `*` represents scaling the movement by `steps`. Optional, but cannot be used if `steps` is not provided
+        - if the star is not present, then `steps` individual offsets are created in the direction `direction`
+    - Example: "n w 3e 10*s 5*w x" should create the sequence of offsets
+        - `{-1, 0}, {0, 1}, {0, -1}, {0, -1}, {0, -1}, {10, 0}, {0, 5}, {0, 0}`
+    - param `commands`: string in a format of sequential directions
+    - **note:** throws an `std::invalid_argument` when input string is poorly formatted
+    - **note:** this includes when a negative integer is passed as `steps`. If a zero is used, treated as the default (one)
+
+    ```static std::vector<cse491::GridPosition> str_to_offsets(std::string_view commands)```
+
+  </details>
+
+  More agents to be documented...

docs/Group 1 - README.md

@@ -0,0 +1,68 @@
+# Group 1: Agent Library Function Descriptions
+
+Below is a set of classes and functions designed to create multiple different Agents with various functionalities.
+
+<details>
+
+<summary> Path Agent </summary>
+Agent that has a user-defined custom movement pattern passed a sequence to be sequentially applied as the agent is updated
+
+- Constructor with ```std::vector```
+    - param ```id```: unique agent id
+    - param ```name```: name of path agent
+    - param ```offsets```: collection of offsets to move the agent
+    ```PathAgent(size_t id, std::string const& name, std::vector<cse491::GridPosition> && offsets = {}) : cse491::AgentBase(id, name), offsets_(offsets);```
+
+- Constructor with ```std::string```
+    - param ```id```: unique agent id
+    - param ```name```: name of path agent
+    - param ```commands```: sequence of commands to be interpreted as offsets
+    ```PathAgent::PathAgent(size_t id, std::string const& name, std::string_view commands) : cse491::AgentBase(id, name), offsets_(str_to_offsets(commands))```
+
+- Initializer
+    - Checks that the agent is able to freely change its own grid location.         Verifies that it can currently index into a valid offset
+    - return: ```true``` if so; ```false``` otherwise.
+    ```bool PathAgent::Initialize();```
+
+- Select Action
+    - Moves the agent by applying the current offset
+    - param ```WorldGrid```: reference grid
+    - param ```type_options_t```: type options
+    - param ```item_set_t```: set of items
+    - param ```agent_set_t```: agent set
+    ```size_t PathAgent::SelectAction(const WorldGrid & /* grid*/, const type_options_t & /* type_options*/, const item_set_t & /* item_set*/, const agent_set_t & /* agent_set*/)```
+
+
+- Set Properties with ```std::vector```
+    - Assigns the offsets_member to a new series of offsets
+    - param ```offsets```: collection of grid positions used as the new offsets
+    - param ```start_index = 0```: which offset to start indexing into (beginning by default)
+    - return: ```self```
+    - **Attention:** throws an `std::invalid_argument` when an invalid start index is provided
+    ```PathAgent& PathAgent::SetProperties(std::vector<cse491::GridPosition> && offsets, size_t start_index = 0)```
+
+- Set properties with ```std::string```
+    - Assigns the offsets_ member to a new series of offsets, taking a command string
+    - param ```commands```: formatted string of commands used as offsets
+    - param ```start_index = 0```: which command to begin indexing into (first command by default)
+    - return: ```self```
+    - **Attention:** throws an `std::invalid_argument` when mis-formatted commands an invalid index is provided
+    ```PathAgent& PathAgent::SetProperties(std::string_view commands, size_t start_index = 0)```
+
+- Helper function for a formatted ```std::string``` input
+    - Converts a string to a sequence of offsets
+    - This convenience method takes a string with a special formatting that allows one to specify a sequence of inputs in linear directions.
+    - The format is [steps[*]]<direction> where `steps` is a positive integer and optional (assumed to be 1 by default)
+    - star `*` represents scaling the movement by `steps`. Optional, but cannot be used if `steps` is not provided
+        - if the star is not present, then `steps` individual offsets are created in the direction `direction`
+    - Example: "n w 3e 10*s 5*w x" should create the sequence of offsets
+        - `{-1, 0}, {0, 1}, {0, -1}, {0, -1}, {0, -1}, {10, 0}, {0, 5}, {0, 0}`
+    - param `commands`: string in a format of sequential directions
+    - **note:** throws an `std::invalid_argument` when input string is poorly formatted
+    - **note:** this includes when a negative integer is passed as `steps`. If a zero is used, treated as the default (one)
+
+    ```static std::vector<cse491::GridPosition> str_to_offsets(std::string_view commands)```
+
+  </details>
+
+  More agents to be documented...

project_specs/team-1-specs.md

@@ -72,3 +72,8 @@ modules.
     ii. Params and returns will be added after discussion with other groups to
     see if this is wanted
 
+
+#### Challenge 
+1. Creating an Autonomous agent that is capable of moving around an interacting
+   with the world
+2. Working with other agent teams to implement functionality they need for their agents

source/Agents/AStarAgent.hpp

@@ -0,0 +1,87 @@
+/**
+ * @file AStarAgent.h
+ * @author Matt Kight
+ */
+#pragma once
+
+#include <vector>
+#include "../core/AgentBase.hpp"
+#include "AgentLibary.hpp"
+#include <iostream>
+namespace cse491
+{
+    namespace walle
+    {
+        /**
+         * Class that describes a AStarAgent class
+         */
+        class AStarAgent : public cse491::AgentBase
+        {
+        private:
+            std::vector<GridPosition> path;      // Path this agent is taking
+            cse491::GridPosition goal_position;  // Where the agent wants to end up
+            int recalculate_after_x_turns = 100; // How often agent recalculates moves
+            int current_move_num = 0;            // What move # we are currently on
+            WorldBase *world = nullptr;
+
+        public:
+            AStarAgent(size_t id, const std::string &name) : AgentBase(id, name)
+            {
+            }
+            ~AStarAgent() = default;
+
+            /**
+             * @brief Set the word object
+             *
+             * @param world world this agent is a part of
+             */
+            void SetWorld(WorldBase *world) { this->world = world; }
+
+            /// @brief This agent needs a specific set of actions to function.
+            /// @return Success.
+            bool Initialize() override
+            {
+                return HasAction("up") && HasAction("down") && HasAction("left") && HasAction("right");
+            }
+
+            void SetGoalPosition(const GridPosition gp)
+            {
+                goal_position = gp;
+            }
+            /// Choose the action to take a step in the appropriate direction.
+            size_t SelectAction(const WorldGrid & /*grid*/,
+                                const type_options_t & /* type_options*/,
+                                const item_set_t & /* item_set*/,
+                                const agent_set_t & /* agent_set*/) override
+            {
+                if(world == nullptr){
+                    // Do nothing if the agent doesnt know about its world
+                    return 0;
+                }
+                // We are taking an action so another turn has passed
+                ++current_move_num;
+                // If the last step failed, or we need a new path the then regenerate the path
+                if (action_result == 0 || path.empty() || current_move_num > recalculate_after_x_turns)
+                {
+                    path = world->ShortestPath(GetPosition(), goal_position);
+                    current_move_num = 0;
+                }
+                // Return whatever action gets us closer to our goal
+                if (!path.empty())
+                {
+                    auto pos = path.back();
+                    path.pop_back();
+                    if (pos.GetX() == position.GetX() && pos.GetY() == position.GetY() - 1)
+                        return action_map["up"];
+                    if (pos.GetX() == position.GetX() && pos.GetY() == position.GetY() + 1)
+                        return action_map["down"];
+                    if (pos.GetX() == position.GetX() - 1 && pos.GetY() == position.GetY())
+                        return action_map["left"];
+                    if (pos.GetX() == position.GetX() + 1 && pos.GetY() == position.GetY())
+                        return action_map["right"];
+                }
+                return 0; // If no path then do not do anything
+            }
+        };
+    };
+}

source/Agents/AgentLibary.hpp

@@ -0,0 +1,49 @@
+//
+// Created by Matthew Kight on 9/24/23.
+//
+#pragma once
+#include "../core/AgentBase.hpp"
+#include <vector>
+#include <map>
+#include <queue>
+#include <tuple>
+namespace cse491
+{
+    namespace walle
+    {
+
+        /**
+         * @brief Node class to make A* search easier
+         *
+         */
+        struct Node
+        {
+            cse491::GridPosition position; // Where node is located
+            int g;                         // Cost from start to current node
+            int h;                         // Heuristic (estimated cost from current node to goal)
+            std::shared_ptr<Node> parent;
+
+            Node(cse491::GridPosition position, double g, double h, std::shared_ptr<Node> parent)
+                : position(position), g(g), h(h), parent(parent) {}
+
+            // Calculate the total cost (f) of the node
+            int f() const
+            {
+                return g + h;
+            }
+        };
+
+        /**
+         * @brief Custom comparison function for priority queue
+         *
+         */
+        struct CompareNodes
+        {
+            bool operator()(const std::shared_ptr<walle::Node> a, const std::shared_ptr<walle::Node> b) const
+            {
+                return a->f() > b->f();
+            }
+        };
+
+    }
+}

source/Worlds/MazeWorld.hpp

@@ -53,10 +53,11 @@ namespace cse491 {
 
       // Set the agent to its new postion.
       agent.SetPosition(new_position);
-
       return true;
     }
 
+    /// Can walk on all tiles except for walls
+    bool IsWalkable (cse491::GridPosition pos) override {return main_grid.At(pos) != wall_id;}
   };
 
 } // End of namespace cse491