Add philosophers folder

.gitignore

+desktop.ini
+.git
+.vscode
+.idea
+venv
+*.bat
+__pycache__/
\ No newline at end of file

philosophers/agent.py

+from ast import literal_eval
+from time import sleep
+
+import sys
+import pathlib
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+from agent import Agent
+from philosophers.fork import Fork
+from random import randrange
+
+
+class PhiAgent(Agent):
+
+    def __init__(self, identifier: int, broker_ip: str, total_agent):
+        self.total_agent = total_agent
+        Agent.__init__(self, identifier, broker_ip)
+
+    def on_initialization(self):
+        # 0: thinking, 1: hungry, 2: eat
+        self.state = 0
+
+        self.subscribe("env/fork/" + str(self.id), self.left_fork_update)
+        self.left_fork = Fork(self.id)
+
+        right_id = (self.id - 1) % self.total_agent
+        self.subscribe("env/fork/" + str(right_id), self.right_fork_update)
+        self.right_fork = Fork(right_id)
+
+        self.fork_wait = True
+
+        self.subscribe("env/agent/" + str(self.id) + "/ask_spoon", self.spoon_response)
+
+    def spoon_response(self, client, userdata, message):
+        res = literal_eval(message.payload.decode("utf-8"))
+        if res.get("response") == "True":
+            if res.get("side") == "right":
+                self.right_fork.taken_by = self.id
+                self.right_fork.state = res.get("state")
+            else:
+                self.left_fork.taken_by = self.id
+                self.left_fork.state = res.get("state")
+        self.fork_wait = False
+
+    def left_fork_update(self, client, userdata, message):
+        res = literal_eval(message.payload.decode("utf-8"))
+        self.left_fork.state = res.get("state")
+        self.left_fork.taken_by = res.get("tanken_by")
+
+    def right_fork_update(self, client, userdata, message):
+        res = literal_eval(message.payload.decode("utf-8"))
+        self.right_fork.state = res.get("state")
+        self.right_fork.taken_by = res.get("tanken_by")
+
+    def ask_spoon(self, left):
+        if left :
+            self.publish("ask_spoon", "left")
+        else :
+            self.publish("ask_spoon", "right")
+        while self.fork_wait:
+            sleep(self.wait_delay)
+        self.fork_wait = True
+
+    def on_decide(self):
+        super().on_decide()
+
+        if self.right_fork.taken_by == -1:
+            self.ask_spoon(False)
+
+        if self.left_fork.taken_by == -1:
+            self.ask_spoon(True)
+
+        if self.state == 1:
+            if self.right_fork.taken_by != self.id:
+                self.ask_spoon(False)
+            if self.left_fork.taken_by != self.id:
+                self.ask_spoon(True)
+
+    def on_act(self):
+        super().on_act()
+
+        if self.state == 0:
+            self.log("Is Thinking")
+            res = randrange(100)
+            if res % 5 == 0:
+                self.state = 1
+        elif self.state == 1:
+            self.log("Is Hungry")
+            if self.left_fork.taken_by == self.right_fork.taken_by == self.id:
+                self.state = 2
+        elif self.state == 2:
+            self.log("Is Eating")
+            self.publish("done_eating", "")
+            self.state = 0
+
+
+if __name__ == '__main__':
+    a = PhiAgent(int(sys.argv[1]), str(sys.argv[2]), int(sys.argv[3]))
+    a.run()

philosophers/amas.py

+import sys
+import pathlib
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+from amas import Amas
+
+
+class PhiAmas(Amas):
+
+    def __init__(self, broker_ip: str, clients, nbr_agent):
+        self.agent_to_create = nbr_agent
+        super().__init__(broker_ip, clients)
+
+    def on_initial_agents_creation(self):
+        for _ in range(self.agent_to_create):
+            self.add_agent("philosophers", [str(self.agent_to_create)])
+
+
+if __name__ == '__main__':
+    s = PhiAmas(str(sys.argv[1]), sys.argv[2], 5)
+    s.run()

philosophers/env.py

+
+import sys
+import pathlib
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent.parent))
+
+from environment import Environment
+from philosophers.fork import Fork
+
+
+class PhiEnv(Environment):
+
+    def __init__(self, broker_ip, nbr_phil):
+        self.nbr_phil = nbr_phil
+        super().__init__(broker_ip)
+
+    def on_initialization(self):
+        self.forks = []
+        for i in range(self.nbr_phil):
+            self.forks.append(Fork(i))
+            self.subscribe("agent/" + str(i) + "/ask_spoon", self.ask_spoon)
+            self.subscribe("agent/" + str(i) + "/done_eating", self.done_eating)
+
+    def ask_spoon(self, client, userdata, message):
+        res = str(message.payload.decode("utf-8"))
+        agent_id = int(str(message.topic).split("/")[1])
+
+        if res == "left":
+            fork_id = agent_id
+        else:
+            fork_id = (agent_id - 1) % self.nbr_phil
+
+        if self.forks[fork_id].state == 1:
+            message = {
+                "response": "False"
+            }
+        elif self.forks[fork_id].taken_by == -1:
+            message = {
+                "response": "True",
+                "side": res,
+                "state": 0
+            }
+            self.forks[fork_id].taken_by = agent_id
+        else:
+            message = {
+                "response": "True",
+                "side": res,
+                "state": 1
+            }
+            self.forks[fork_id].taken_by = agent_id
+            self.forks[fork_id].state = 1
+
+        self.client.publish("env/agent/" + str(agent_id) + "/ask_spoon", str(message))
+
+    def done_eating(self, client, userdata, message):
+        agent_id = int(str(message.topic).split("/")[1])
+
+        for fork_id in [agent_id, (agent_id - 1) % self.nbr_phil]:
+            self.forks[fork_id].state = 0
+
+    def on_cycle_begin(self) -> None:
+        for fork in self.forks:
+            self.client.publish("env/fork/" + str(fork.identifier), str(fork.to_msg()))
+            print("Fork : ", fork.identifier," taken by ", fork.taken_by, " and is :", fork.state)
+
+
+if __name__ == '__main__':
+    s = PhiEnv(str(sys.argv[1]), 5)
+    s.run()
\ No newline at end of file

philosophers/fork.py

+class Fork:
+
+    def __init__(self, identifier):
+
+        self.identifier = identifier
+
+        # 0: dirty, 1: clean
+        self.state = 0
+
+        self.taken_by = -1
+
+    def to_msg(self):
+        return {
+                "state": self.state,
+                "taken_by": self.taken_by
+            }
\ No newline at end of file