1st commit

README.md

@@ -0,0 +1,51 @@
+# Game Theory of Life (Teoria de Jogo da Vida)
+
+## Dilema do Prisioneiro - A experiencia original
+
+https://pt.wikipedia.org/wiki/Dilema_do_prisioneiro
+
+"Dois suspeitos, A e B, são presos pela polícia. A polícia tem provas insuficientes para os condenar, mas, separando os prisioneiros, oferece a ambos o mesmo acordo: se um dos prisioneiros, confessando, testemunhar contra o outro e esse outro permanecer em silêncio, o que confessou sai livre enquanto o cúmplice silencioso cumpre 10 anos de sentença. Se ambos ficarem em silêncio, a polícia só pode condená-los a 6 meses de cadeia cada um. Se ambos traírem o comparsa, cada um leva 5 anos de cadeia. Cada prisioneiro faz a sua decisão sem saber que decisão o outro vai tomar, e nenhum tem certeza da decisão do outro. A questão que o dilema propõe é: o que vai acontecer? Como o prisioneiro vai reagir?"
+
+
+                                |       Prisioneiro         |
+                                |           B               |
+                                |___________________________|
+                                |             |             |
+                                |      S      |      T      |
+    ____________________________|_____________|_____________|
+                        |       |  1          |  10         |
+                        |   S   |             |             |
+        Prisioneiro     |       |          1  |          0  |
+            A           |-------|---------------------------|
+                        |       |  0          |  5          |
+                        |   T   |             |             |
+                        |       |         10  |          5  |
+    ____________________|_______|_____________|_____________|
+
+
+Legenda:
+
+S -> Silencio
+
+T -> Confissão
+
+## Dilema do Prisioneiro Iterado
+
+A mesma situação que a anterior, mas a situação é colocada repetidamente, e os jogadores lembram-se da(s) jogada(s) anteriore(s) do adversário. Pode haver número máximo de situações (no torneio de Robert Axelrod, haviam 200 iterações) ou ser infinito (jogadores não sabem quando termina o jogo).
+
+## Multiplos jogadores (Sociedade) 
+
+Aplicam-se as mesmas regras do "Dilema do Prisioneiro Iterado", mas deixa de haver um confronto apenas entre dois jogadores por iteração (1v1) e passa a ser um confronto de um jogador contra vários por iteração (1vM).
+
+Neste modo, os jogadores só actualizam a memória quando terminam todos os confrontos (fim da iteração)
+
+Para este modo de jogo, existem duas variantes: 
+    Confrontos Globais  ->  por cada iteração, cada jogador confronta à vez todos os adversários do jogo (o jogador tem todos os adversários à distancia de 1 unidade))
+    Confrontos Locais   ->  por cada iteração, cada jogados contronta à vez apenas os adversários locais (o jogador tem adversários à distancia de 1 unidade, adversários a distancia de 2 unidades, etc...))
+
+Na variante "Confrontos Globais", o estado do jogo a cada iteração, reflecte a performance de estratégias à escala global, ao passo que na variante "Confrontos Locais" é introduzido uma componente dinâmica das estratégias, e o sucesso das estratégias depende não apenas dos adversários locais, mas também dos confrontos desses adversários locais com adversários indirectos.
+
+A escolha inicial das estratégias dos jogadores, assim como a sua localização, influencia o estado do jogo a cada iteração. Será que o estado de jogo entra em equilibrio? Existirá grandes desvios de resultados entre as estratégias? 
+
+# Tipos de Estratégias
+

dilema_prisioneiro.py

@@ -0,0 +1,35 @@
+from enum import Enum
+import random
+
+class Estrategia(Enum):
+    Neutro = 0
+    Tit4Tat = 1
+    Vingativo = 2
+
+
+class Agente():
+    def __init__(self):
+        self.estrategia = Estrategia(random.randint(0,Estrategia.__len__()-1))
+        #self.estrategia = random.choice(Estrategia._member_names_)
+   # factores da estrategia (probabilidade): -1...0...1
+    # amabilidade -> não desertar a menos que o adversário deserte (-1 -> desertar sempre; 1 -> nunca desertar)
+    self.amabilidade = 0
+    # retaliação -> retaliar quando um adversário deserta (-1 -> nunca retaliar; 1 -> retaliar sempre)
+    self.retaliação = 0
+    # perdao -> perdoar um adversário desertor, assim que este deixa de desertar (-1 -> nunca perdoar; 1 -> perdoar sempre)
+    self.perdao = 0
+    # coerencia -> ser coerente na estrategia, evitar aleatoriedade (-1 -> aletório negativo; 0 -> não aleatorio; 1 -> aleatorio positivo)
+    self.coerencia = 0
+
+agente = Agente()
+
+print(agente.estrategia)
+
+
+# lista_estrategias = Estrategia._member_map_
+# lista_estrategias = Estrategia.__dict__
+
+# for estrategia in lista_estrategias:
+#     print(estrategia)
+
+#print(lista_estrategias)