commit 2599448f6a86c894afe54f70d5e5540743f14422 Author: [Luis Rodrigues] Date: Thu May 9 22:24:04 2024 +0100 1st commit diff --git a/README.md b/README.md new file mode 100644 index 0000000..98823c7 --- /dev/null +++ b/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 + diff --git a/dilema_prisioneiro.py b/dilema_prisioneiro.py new file mode 100644 index 0000000..a7ba6b2 --- /dev/null +++ b/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) \ No newline at end of file