Enhance game controller and implement referee commands

.github/config.yml

@@ -0,0 +1,8 @@
+# These are the available config settings.
+keyword: ["@todo", "TODO:", "TODO", "TO DO"] # string|string[]
+bodyKeyword: ["@body", "BODY", "BODY:"] # string|string[]
+blobLines: 5                # number|boolean, 0 or false to disable
+autoAssign: true            # string|string[]|boolean
+label: true                 # boolean|string|string[]
+reopenClosed: true          # boolean
+caseSensitive: false

.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - no_stale
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

README.md

@@ -1,9 +1,147 @@
-## Parsian SSL 
-[![CircleCI](https://circleci.com/gh/ParsianRoboticLab/ssl/tree/develop.svg?style=svg)](https://circleci.com/gh/ParsianRoboticLab/ssl/tree/develop) 
-[![CodeFactor](https://www.codefactor.io/repository/github/parsianroboticlab/ssl/badge/develop)](https://www.codefactor.io/repository/github/parsianroboticlab/ssl/overview/develop)
+# Parsian SSL
 
-# Install Stuff
+[![CircleCI](https://circleci.com/gh/ParsianRoboticLab/ssl/tree/develop.svg?style=svg)](https://circleci.com/gh/ParsianRoboticLab/ssl/tree/develop)
+[![CodeFactor](https://www.codefactor.io/repository/github/parsianroboticlab/ssl/badge?s=ae124388adc531f2cb4c8fc1621e1f251f0c9747)](https://www.codefactor.io/repository/github/parsianroboticlab/ssl)
+[![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+
+The **Parsian SSL** stack is the full software framework used by [Parsian Robotic Lab](https://github.com/ParsianRoboticLab) to compete in the [RoboCup Small Size League (SSL)](https://ssl.robocup.org/). It is built on top of [ROS](https://www.ros.org/) and provides a complete pipeline from raw vision and referee data all the way down to individual robot motion commands.
+
+---
+
+## Table of Contents
+
+- [Architecture](#architecture)
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+- [Building](#building)
+- [Usage](#usage)
+- [Contributing](#contributing)
+- [License](#license)
+- [Acknowledgements](#acknowledgements)
+
+---
+
+## Architecture
+
+The stack is organized as a collection of ROS packages, each responsible for a distinct layer of the pipeline:
+
+```
+SSL Vision / Referee / grSim
+          │
+          ▼
+parsian_protobuf_wrapper   ← decodes UDP protobuf packets into ROS messages
+          │
+          ▼
+parsian_world_model        ← sensor fusion & Kalman filtering → world model
+          │
+          ▼
+parsian_ai                 ← multi-agent behavioral AI & play execution
+          │
+          ▼
+parsian_agent              ← per-robot path planning & motion control
+          │
+          ▼
+parsian_communication      ← serializes commands & sends to robots via radio
 ```
+
+| Package | Description |
+|---|---|
+| [`parsian_protobuf_wrapper`](parsian_protobuf_wrapper/) | Wraps SSL Vision, grSim, and SSL Referee protobuf UDP streams into ROS topics |
+| [`parsian_world_model`](parsian_world_model/) | Reads vision data, runs a Kalman-filter based tracker, and publishes a fused world-model |
+| [`parsian_ai`](parsian_ai/) | Behavioral AI layer: evaluates game state, selects plays, and assigns per-robot tasks |
+| [`parsian_agent`](parsian_agent/) | Per-robot node: consumes task messages and produces low-level motion commands via path planning |
+| [`parsian_communication`](parsian_communication/) | Encodes robot commands into binary packets and transmits them over a serial/radio link |
+| [`parsian_msgs`](parsian_msgs/) | Shared ROS message and service definitions used across all packages |
+| [`parsian_util`](parsian_util/) | Shared utility library: geometry primitives, action helpers, and math utilities |
+| [`parsian_tools`](parsian_tools/) | Miscellaneous tooling and helper nodes |
+| [`rqt_parsian_gui`](rqt_parsian_gui/) | rqt-based graphical monitor and operator interface |
+
+---
+
+## Prerequisites
+
+- **OS**: Ubuntu 16.04 (Xenial) or later
+- **ROS**: [ROS Kinetic](http://wiki.ros.org/kinetic/Installation) (or a compatible distro)
+- **Build tools**: `catkin_tools` (`catkin build`)
+- **System libraries**:
+  - `libqt4-dev`, `libqjson-dev`
+  - `protobuf-compiler`, `libprotobuf-dev`
+  - `libeigen3-dev`
+  - `curl`
+- **ROS packages**: `dynamic-reconfigure`, `nodelet`, `roslint`, `rqt-gui-cpp`, `rqt-gui`
+
+---
+
+## Installation
+
+A bootstrapping script handles cloning all required repositories and installing dependencies:
+
+```bash
 sh -c "$(curl -fsSL https://gist.githubusercontent.com/mahi97/60295c82e21215701d42d4c1e679ac1f/raw/66662032274aa55888099138884748cd2a47f092/install.sh clone)"
 ```
 
+> **Note:** Review the script before running it. It will clone this repository into a catkin workspace and install the necessary system and ROS dependencies.
+
+---
+
+## Building
+
+After installation, build the entire workspace with:
+
+```bash
+cd ~/catkin_ws          # or wherever the workspace was created
+catkin build
+source devel/setup.bash
+```
+
+---
+
+## Usage
+
+Launch the full stack (vision receiver → world model → AI → agent → communication):
+
+```bash
+# Start the protobuf wrappers (SSL Vision, Referee, grSim)
+roslaunch parsian_protobuf_wrapper protos.launch
+
+# Start the world model
+roslaunch parsian_world_model parsian_world_model.launch
+
+# Start the AI
+roslaunch parsian_ai ai.launch
+
+# Open the operator GUI
+rqt --perspective-file $(rospack find rqt_parsian_gui)/perspectives/Main.perspective
+```
+
+For simulation with **grSim**, make sure grSim is running and listening on the default ports before launching the wrappers.
+
+---
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on naming conventions, coding style, and how to submit changes.
+
+---
+
+## License
+
+This project is licensed under the **GNU Lesser General Public License v3.0**. See [LICENSE](LICENSE) for the full text.
+
+---
+
+## Acknowledgements
+
+Parsian SSL is built and maintained by the Parsian Robotic Lab team at Amirkabir University of Technology (Tehran Polytechnic). Core contributors include:
+
+- Mohammad Mahdi Rahimi
+- Ali Gavahi
+- Mohammad Mahdi Shirazi
+- Kian Behzad
+- Hamidreza Roodabeh
+- Fateme Hashemi
+- Nadia Moradi
+
+See [CHANGELOG](CHANGELOG) for a full history of contributions.
+
+

parsian_agent/include/parsian_agent/kick.h

@@ -18,8 +18,6 @@ enum class KMode {
     DONTKICK        = 4,
     JTurn           = 5,
     TurnForKick     = 6
-
-
 };
 
 class CSkillKick : public CSkill, public KickAction {

parsian_agent/include/planner/planner.h

@@ -8,7 +8,7 @@
 #include <QMetaType>
 #include <parsian_msgs/parsian_path.h>
 #include <parsian_util/core/field.h>
-#include "parsian_util/tools/drawer.h"                      //TODO must be new in node
+#include "parsian_util/tools/drawer.h"                      // TODO must be new in node
 #include "parsian_util/tools/blackboard.h"
 #include "parsian_util/core/agent.h"
 #include "parsian_util/geom/geom.h"
@@ -21,7 +21,7 @@
 #define _PLANNER_EXTEND_POINT_LIMIT 150
 #define _PLANNER_EXTEND_MAX_ATTEMPT 200
 
-#define _MAX_NUM_PLAYERS 12         //TODO must be get from somewhere else
+#define _MAX_NUM_PLAYERS 12         // TODO must be get from somewhere else
 
 
 

parsian_agent/src/auto_decider/auto_decider_nodelet.cpp

@@ -5,74 +5,104 @@
 #include <parsian_msgs/parsian_robot.h>
 #include <parsian_msgs/parsian_world_model.h>
 #include <parsian_util/geom/vector_2d.h>
-#include <parsian_msgs/parsian_robot_fault.h>
+#include <parsian_msgs/parsian_robots_fault.h>
 #include <parsian_util/tools/blackboard.h>
 #include <QList>
+#include <QTime>
 
 using namespace rcsc;
 # define buffer_size  200
 # define threshold 0.25
+#define _MAX_NUM_PLAYERS 12
+#define status_timeout 10000
+
+//                          about this node
+//this node detects robots faults based on wm and robot_status data,
+//and publishes the result on /autofualt topic
+//the result contains a list of robot_fualt message for all robots
+//if the robots dont send their status for more than 'status_timeout' ms
+//the node decides to not to detect faults for any robots
 
-//TODOS
-//1)select what state the damaged robot is
-//2)what kick(or what ever)fault = true means (dameged or not)
-//3)whats the best number f0or threshold and buffersize
 
 namespace auto_decider {
+
+    struct RobotInfo{
+        parsian_msgs::parsian_robot_status status;
+        bool ballIsNear;
+        QList<bool> fault;
+    };
+
     class Decider : public nodelet::Nodelet {
     public:
-        parsian_msgs::parsian_robot_faultPtr res;
+        parsian_msgs::parsian_robots_faultPtr robotsFault;
         ros::Publisher pub;
         ros::Subscriber robo_sub,wm_sub;
-        bool shootSensors[12];
-        bool isNear[12];
-        QList<bool> faults[12];
+        QList<RobotInfo> robotInfos;
+        QTime timer;
     private:
         virtual void onInit() {
 
             ros::NodeHandle &private_nh = getPrivateNodeHandle();
             ros::NodeHandle &nh = getNodeHandle();
-            pub = private_nh.advertise<parsian_msgs::parsian_robot_fault>("/autofault", 5);
+            pub = private_nh.advertise<parsian_msgs::parsian_robots_fault>("/autofault", 5);
             robo_sub = nh.subscribe("/robots_status", 100, &Decider::statusCb, this);
             wm_sub = nh.subscribe("/world_model", 100, &Decider::wmCb, this);
+            for(int i{}; i < _MAX_NUM_PLAYERS; i++)
+            {
+                RobotInfo tmp;
+                robotInfos.push_back(tmp);
+            }
         }
 
         void statusCb(const parsian_msgs::parsian_robots_status msg) {
-            for (int i = 0; i < 12; i++)
-                shootSensors[i] = msg.status[i].shootSensor;
+            timer.start();
+            for(int i{}; i < robotInfos.size(); i++)
+            {
+                robotInfos[i].status = parsian_msgs::parsian_robot_status();
+                robotInfos[i].status.id = i;
+            }
+            for (auto stat: msg.status)
+                robotInfos[stat.id].status = stat;
         }
 
         void wmCb(const parsian_msgs::parsian_world_model msg) {
-            for (int i = 0; i < 12; i++)
-                isNear[i] = Vector2D(msg.our[i].pos).dist(msg.ball.pos) < threshold;
+            for (auto robotinfo: robotInfos)
+                robotinfo.ballIsNear = Vector2D(msg.our[robotinfo.status.id].pos).dist(msg.ball.pos) < threshold;
             faultdetect();
         }
 
         void faultdetect() {
+            robotsFault.reset(new parsian_msgs::parsian_robots_fault);
+            for (int i = 0; i < robotInfos.size(); i++){
+                parsian_msgs::parsian_robot_faultPtr tmp;
+                tmp.reset(new parsian_msgs::parsian_robot_fault);
+                robotsFault->robots.push_back(*tmp);
+            }
 
+            for (auto robotinfo: robotInfos) {
+                parsian_msgs::parsian_robot_faultPtr tmp;
+                tmp.reset(new parsian_msgs::parsian_robot_fault);
+                tmp->robot_id = robotinfo.status.id;
+                robotinfo.fault.append(!robotinfo.ballIsNear && robotinfo.status.shootSensor);
 
-            for (int i = 0; i < 12; i++) {
-                res.reset(new parsian_msgs::parsian_robot_fault);
-                res->robot_id=i;
-                faults[i].append(!isNear[i] && shootSensors[i]);
-
-                if (faults[i].size() > buffer_size)
-                    faults[i].removeFirst();
+                if (robotinfo.fault.size() > buffer_size)
+                    robotinfo.fault.removeFirst();
 
                 int sum = 0;
-                for (auto fault : faults[i])
+                for (auto fault : robotinfo.fault)
                     sum+= fault;
 
 
-                if(sum > faults[i].size() * .7)
-                    res->select = 2;
+                if(sum > robotinfo.fault.size() * .7 && timer.elapsed() < status_timeout)
+                    tmp->select = 2;
                 else
-                    res->select = 0;
+                    tmp->select = 0;
 
-                PDEBUG(QString("faults %1 = ").arg(i).toStdString(),sum,D_ALI);
-                PDEBUG(QString("select %2 = ").arg(i).toStdString(),res->select,D_ALI);
-                pub.publish(res);
+                //PDEBUG(QString("faults %1 = ").arg(i).toStdString(),sum,D_ALI);
+                //PDEBUG(QString("select %2 = ").arg(i).toStdString(),tmp->select,D_ALI);
+                robotsFault->robots[tmp->robot_id] = *tmp;
             }
+            pub.publish(robotsFault);
         }
 
     };

parsian_agent/src/parsian_agent/gotopointavoid.cpp

@@ -32,12 +32,16 @@ void CSkillGotoPointAvoid::execute() {
     bangBang->setDecMax(conf->DecMax);
     bangBang->setOneTouch(oneTouchMode);
     bangBang->setDiveMode(diveMode);
+    double effectiveVelMax = conf->VelMax;
+    if (maxVelocity > 0.0f) {
+        effectiveVelMax = min(effectiveVelMax, static_cast<double>(maxVelocity));
+    }
     if (slowMode) {
         bangBang->setVelMax(1.4);
         bangBang->setSlow(true);
     } else {
         bangBang->setSlow(false);
-        bangBang->setVelMax(conf->VelMax);
+        bangBang->setVelMax(effectiveVelMax);
     }
 
     if (!Vector2D(targetPos).valid()) {
@@ -89,9 +93,20 @@ void CSkillGotoPointAvoid::execute() {
     if (!noAvoid) {
 
         /*********** PLANNER ***************/
+        ourRelaxList.clear();
+        for (auto id : ourrelax) {
+            ourRelaxList.append(static_cast<int>(id));
+        }
+        oppRelaxList.clear();
+        for (auto id : theirrelax) {
+            oppRelaxList.append(static_cast<int>(id));
+        }
         agent->initPlanner(targetPos , ourRelaxList , oppRelaxList , avoidPenaltyArea , avoidCenterCircle , ballObstacleRadius);
-        for (long i = agent->pathPlannerResult.size() - 1 ; i >= 0 ; i--) {
-            result.append(agent->pathPlannerResult[i]);
+        auto plannerSize = agent->pathPlannerResult.size();
+        if (plannerSize > 0) {
+            for (long i = static_cast<long>(plannerSize) - 1; i >= 0; --i) {
+                result.append(agent->pathPlannerResult[static_cast<std::size_t>(i)]);
+            }
         }
     }