recursal/Fanatic-Fandom huggingface dataset:
Algoritmo de decisão baseado em negociação - Leilão

## Descrição

O Algoritmo de Leilão aplica-se a diversas variações de um algoritmo de otimização combinatória que resolve problemas de atribuição e problemas de otimização de rede com custo linear e convexo não linear. Um algoritmo de leilão foi usado em uma empresa para determinar os melhores preços em um conjunto de produtos oferecidos a vários compradores. Trata-se de um procedimento iterativo, de modo que o nome "algoritmo de leilão" está relacionado a um leilão de vendas, em que várias propostas são comparadas para determinar a melhor oferta, com as vendas finais indo para os maiores proponentes.

## Detalhamento

Em nosso trabalho de conclusão de curso, no modo de jogo “Horda” os jogadores tem como objetivo alcançar a maior quantidade de pontos, e esses pontos são obtidos através da eliminação dos *npc’s*. Os *npc’s* por sua vez tem como objetivo eliminar os jogadores. O Algoritmo de Leilão foi implementado nesses agentes para que eles escolham a melhor opção para ser alvo, ajudando sua equipe a cumprir o objetivo e ganhar o jogo.

Ao iniciar a partida uma *wave* de inimigos é instanciada, quando todos os agentes dessa *wave* são eliminados uma nova *wave* com variação na quantidade e tipo de agente é instanciada, a fim de aumentar o desafio do jogo de forma progressiva.

No momento em que os agentes são instanciados uma tarefa é atribuída a eles, essa atribuição é realizada através do Algoritmo de Leilão, que preenche uma tabela de benefícios através da função que utiliza os parâmetros: distância, vida atual e vida máxima do alvo. Após isso os agentes atuam de acordo com a tarefa que lhes foi atribuída. O agente permanece nesta tarefa enquanto ela tiver bom custo/benefício, até que ela seja cumprida ou até que não exista mais objetivo. A atribuição, o custo das tarefas, o cálculo do custo/benefício, e os lances são atualizados a cada iteração. A tarefa também é atualizada quando o objetivo é cumprido. Por exemplo:

- inicia-se uma partida com 4 jogadores;

- a 1a wave com 30 agentes é instanciada;

- o algoritmo define quais são as tarefas e recebe os lances dos agentes a partir da função que calcula o benefício de cada inimigo para cada jogador;

- após a 1a iteração todos os agentes possuirão tarefas (perseguir e eliminar jogador X) e passam a atuar para cumprir essas tarefas;

- as iterações são feitas de tempos em tempos ou quando uma tarefa é cumprida (ex: o jogador foi eliminado).

## Aplicação

Link do vídeo no youtube: https://youtu.be/1rUh3u8S350
Algoritmo do Leilão

O algoritmo consiste em escolher a melhor opção de um produto para o cliente entre outros.Para cada produto os clientes tem um valor de interesse.A importância de cada produto para o cliente é definido pela forma(Valor= Interesse - valor do produto). O produto com o maior valor é o 1º melhor objeto , consequentemente o segundo maior valor é o 2º melhor objeto.

Para cada Cliente P não atribuída faça

Defina lance = 1ºMelhor Objeto(P) - 2º Melhor Objeto(P) + epslon

Aumente o preço do 1º Melhor Objeto em lance

Desfaça a atribuição de quem estava atribuído ao 1º Melhor Objeto

Atribua a pessoa P ao 1ºMelhor Objeto

O leilão só termina quando todo produto tiver um cliente.

O exemplo a seguir apresenta 3 clientes e 3 produtos, cada cliente possui uma barra de vida e eles tem interesse em entrar num leilão para conseguir adquirir um produto. No exemplo, ambos os clientes possui mais interesse na "poção G"(poção que recupera mais vida),mas o que possui o maior interesse na poção G é o cliente 3 que possuir a menor vida dos 3.O cliente 3 consegue a poção G pois lanço os melhores lance,consequentemente demonstro mais interesse naquela poção dos demais clientes.

Segue o exemplo em vídeo:
Máquina de Aprendizagem (Q-Learning)

**Conceito do algoritmo:**

O algoritmo de "Q-Learning" trata o sistema como um grafo de estados que são influenciados por suas respectivas ações.

**- Algoritmo do tipo "Model-Free"** :

Após executar uma ação um valor de feedback é dado normalmente é um valor entre -1 e 1 que influencia diretamente na ação a ser executada pelo algoritmo , representando o quanto essa ação é boa para um determinada situação.

**Q(s,a) = (1-α)Q(s,a) + α(r + y max (Q(s’, a’)))**

**α = taxa de aprendizado [0;1]**
**r = reforço (bônus)**
**y = desconto (penalização)**

**Exemplo Aplicado :**

 O exemplo abaixo foi construído na Unity , com a ideia de treinar uma ia que consiga superar os desafios impostos na fase.

**Obs.**​ : A direção que o cubo toma é decidida de forma randômica , porém ele possui mais chances de virar a esquerda e a direita do que seguir em frente. O Cubo se locomove entre os nodos , e ao mesmo tempo analisa se o id desse nodo já está na lista, caso não esteja o adiciona. também adicionando 3 variáveis float na lista de QSA sendo que cada valor representa a pontuação para uma ação (caminhar,pular,voltar) Chegando em um nodo ele chama o Start learning() // Que recebe o id do nodo e checa qual a melhor ação a ser tomada.

**- ID = Plataforma** //​ o Cubo permanece caminhando

**- ID = Hole** //​ o Cubo caminha , cai e volta para o início da fase, na segunda tentativa ele pula e assim começa a pular todos os buracos

**- ID = DeathHole** //​ O cubo caminha cai e volta para o início da fase, na

segunda tentativa ele pula também retornando para o início e finalmente na terceira ele volta para um nodo predeterminado.

- ID = Final //​ O cubo ficará parado no final até que saia do modo play.

- **O cálculo de Ajuste**

**- aux =​** é a posição do id do nodo em uma lista

**- numbAções =** ​Quantidade de ações que o cubo pode fazer

**- action =​** Qual ação o cubo tentou efetuar

**- alpha =** ​0.5f

- QS list [aux \* numbDeAções + action] = Posição que corresponde a uma determinada ação de um id

por exemplo: aux = 0 (plataforma) \* numbDeAções = 3 (mover,pular,moverParaTrás) + action ( 0 = mover , 1 = pular , 2 = moverParaTrás)

QSlist [aux \* numbDeAções + action] = (1 - alpha) \* QSlist[aux \* numbDeAções + action] + alpha

( reinforcement \* QSlist[aux \* numbDeAções + action])

// Identificando uma posição e colocando o valor do cálculo na mesma;

Link do Vídeo : https://youtu.be/bAq99kIKka0
Algoritmo de Leilão - Brock Lee

## **Brock Lee**  ​​​​​​**Algoritmo de Leilão**

Descrição geral do algoritmo:

O Leilão é um algoritmo de tomada de decisão, utilizado para resolver problemas de atribuição de ‘n’ tarefes a ‘n’ agentes baseado em custos de alocações.

Para realizar o algoritmo é necessário, como dito anteriormente, ‘n’ agentes, ‘n’ tarefas e um custo de atribuição para cada ligação agente-tarefa.
Cada agente define sua tarefa baseado no melhor custo de atribuição, e define um lance para essa tarefa utilizando a formula:

**lance = C1 – C2 + e**,

onde:
**C1** = Custo de atribuição do melhor objeto
**C2** = Custo de atribuição do segundo melhor objeto
**e** = Constante definida pelo desenvolvedor, onde para se obter uma solução ótima deve seguir a função:

**e < 1/n**

Caso um agente defina um lance para uma tarefa previamente atribuída deverá permanecer o melhor lance, fazendo com que o agente de menor lance realize a formula novamente desconsiderando esta tarefa.

Uso do Algoritmo de Leilão no Jogo Brock Lee

A ideia do funcionamento da IA dos inimigos do Brock Lee é: 2 inimigos seguirem o personagem, 1 cerca-lo  e 1 andar aleatoriamente pelo labirinto, criando um problema de alocação onde possuímos 4 inimigos para 4 tarefas que foi resolvido utilizando o Algoritmo de Leilão.

Os custos de atribuição foram definidos da seguinte maneira:

**Tarefa 1 (Seguir):**  1 / Distancia do inimigo até o Jogador.
**Tarefa 2 (Seguir):**  1 / Distancia do inimigo até o Jogador.
**Tarefa 3 (Cercar):**  1 / Distancia do inimigo até o Ponto que o jogador está olhando (Definido por Raycast).
**Tarefa 4 (Andar aleatório)**:  0.

Todos os valores com distancia são definidos 1/d a fim de obter um lance melhor para a menor distancia.
O algoritmo é realizado a cada 3 segundos fazendo com que os inimigos possam trocar de tarefa baseado nas ações do jogador tornando a IA mais divertida para o usuário.
Boids (pássaros)

Boids é um tipo de Inteligencia Artificial muito utilizado em filmes, jogos e simulações para imitar comportamentos de grupos de animais.

Em boids existem multiplos agentes e todos seguem regras especificas assim gerando um comportamento em grupo.

Foi colocado 3 regras:

1. ter uma distancia minima entre cada boid, impedindo que eles se atravessem .
2. eles irem em direção ao meio do grupo deles, para manter eles sempre perto uns dos outros.
3. Altera a direção do boid pegando a media de direções dos outros boids;
4. Mantem os boids em uma área limitada;

Os boids foram implementados na Unity da seguinte forma:

Um controlador com a lista de todos os boids (pássaros). Na cena ele é responsável por aplicar todas as regras em todos os boids.

Link de Script: Download
Algoritmo de Ajuste de parametros no problema do Canhão

## **Algoritmo de Ajuste de parâmetros**

O algoritmo de aprendizado mais simples, onde os parâmetros de um agente serão ajustados de acordo com o resultado de testes, para que este agente chegue no comportamento desejável, ou o mais próximo possível.

No decorrer do funcionamento, se o comportamento do agente não for o desejável, seu parâmetro será ajustado de acordo com o resultado deste comportamento. Até pequenos ajustes podem, resultar em comportamentos totalmente diferentes. É observado o novo comportamento após o ajuste para analisar o quão eficiente o agente pode ou não ter se tornado.

## **Problema do canhão**

No nosso problema do canhão, estamos tentando fazer o canhão acertar o alvo, o único parâmetro existente é o ângulo do canhão.

A primeiro momento, o algoritmo fará o calculo do erro(distancia) do tiro em relação ao alvo:

* posição do tiro - posição do alvo.

Um valor de ajuste será previamente definido.

A partir daí começaremos a realizar os possíveis ajustes:

* Se o tiro passar do alvo:
	+ O valor de ajuste será dividido por 2
	+ Será subtraído do ângulo usado este ajuste
	+ Informaremos o valor deste ângulo
* Se o tiro não alcançar o alvo:
	+ Será adicionado o valor de ajuste ao ângulo utilizado.
	+ Informaremos o valor deste ângulo
* Se acertou o alvo, apenas informaremos ao usuário o sucesso e o ângulo utilizado.

Segue **aqui** um link do vídeo exemplificando este funcionamento.

Página feita por: Johann Robert Ribeiro Moia
Redes Neurais - Jogos

Uma rede neural artificial é uma simulação de um modelo simplificado do cérebro e é composta por unidades chamadas neurônios (nós da
rede) e conexões com pesos entre esses nós. A RN adquire conhecimento do mundo e o mantém, representando-o nos pesos de suas conexões. Estes pesos são
refinados através de uma fase de treinamento de modo que a rede “aprenda” a se
comportar em um dado cenário.

Uma unidade neurônio básica possui um conjunto de entradas, um conjunto de camadas internas e um conjunto de saídas. Durante o processo de
treino de um neurônio, os sinais são conectados as suas entradas e um concentrador multiplica o valor das entradas pelos respectivos pesos e passa
este sinal para uma função de ativação correspondente a unidade, e está se disparada propaga o sinal para o próximo neurônio. Ao término desse processo, é calculado o erro das saídas em relação ao universo de exemplos de teste e os pesos são ajustados se necessário. O processo de testes só e finalizado quando a taxa de erro atinge um certo limiar ou após um dado número de ciclos de execução.

Embora RNs possam ser utilizadas como um modulo fechado (caixa preta), são uma técnica complexa e é necessário ter conhecimento de como
funcionam internamente para poder tirar proveito do que podem oferecer. Alguns pontos que devem ser observados são como escolher as entradas da rede (modelando o ambiente com cuidado), que precauções tomar durante o processo de treinamento e como definir a estrutura da rede.

Poucos desenvolvedores de jogos têm utilizado essa técnica até o momento e geralmente aplicado apenas o modelo de rede mais popular e fácil de utilizar, o multilateral perceptron, mas, embora aplicadas na maioria das vezes de maneira muito simples, redes neurais têm-se mostrado adequadas aos ambientes encontrados em jogos digitais e cenários similares. Alguns exemplos de sua aplicação com sucesso em jogos são: para que agentes jogadores de futebol aprendam a interceptar a bola durante uma partida ou NPCs a dirigir um carro como no jogo ‘Colin McRae Rally 2.0’ da Codemasters. A técnica de redes neurais pode até mesmo ser implementada por meio de programação em placa gráfica de modo a liberar mais tempo de processamento para outras tarefas se necessário.

Fonte: Using a Neural Network in a Game: A Concrete Example, John Manslow.

Fernando Lucas de Souza - 548974
Algoritmo Genético no problema do cavalo

## Definição do cromossomo:

O cromossomo do cavalo foi mais complexo que o canhão. Criei uma classe chamada CASA, onde eu registro dois inteiros, ou um par de coordenadas, e uma classe chamada Gene, onde eu registro uma lista N de casas. No caso de um tabuleiro de xadrez, registramos 64.

## Definição da população inicial

A população fica a critério do usuário, sendo editável no inspector. O ideal é que ela seja múltiplo de 4, pois não foram feitos testes para outras situações.

## Função de aptidão (fitness)

Cada cavalo possui um registro de repetição das casas. Aí o rank deles fica do menor pro maior. O que repetiu menos casas, tem um rank 0, o que repetiu mais, dentre N indivíduos, tem rank N-1

## Método de seleção

Com N indivíduos, nos pegamos N/2, dentre os primeiros colocados.

## Método de cruzamento

Para a metade restante da população, repetimos os genes, e para a segunda, não há um cruzamento, mas herança com mutação. Ocorre como descrito no tópico abaixo.

Porém, é muito fácil substituir por, ou adicionar um método de cruzamento por cross over, aonde você gera um indivíduo aleatório, e cruza as casas do gene dele com as casas do gene do pai.

## Método de mutação

A mutação é feita na segunda metade da população, aonde deletamos todos os "cromossomos", ou casas até um ponto aonde elas não se repitam, e geramos aleatoriamente novas casas. Se um cavalo andou N casas até repetir a primeira, deletamos todas as outras 64-N casas após, e geramos novas casas aleatórias.

## Condição de parada

A condição de parada é dada pelo usuário. Devido á natureza do exercício, eu preferi deixar a reprodução controlada para analisar possíveis erros. É necessário apertar Z, apertar F, esperar os cavalos se moverem, depois R, depois repetir o ciclo até estar satisfeito com o resultado.

É possível alterar a velocidade dos cavalos caminhando, é só aumentar o valor do MoveDelayer (Sim, ele chama delayer, mas acaba acelerando. Ele divide o tempo de espera entre cada passo :p)

Isso é facilmente modificável para atender um padrão automático.

## Observações:

O código de movimentação foi meio maluco. Eu fiz um diagrama no papel pra compreender todas as possibilidades de restrição de movimento, e eu posso disponibilizá-los se alguém quiser. Mas é uma ideia bem simples e boba:

Um cavalo pode se mover para quatro casas diferentes, dada uma posição (x,y), desde que x ou y sejam maiores que 1 ((x,y)>(1,1)) e menores que 6 ((x,y)<(6,6)).
Lariat Pro Wrestling

**Pariat Pro Wrestling** (doing business as **Lariatpro**) (**LPW**) is an American publicly traded, privately controlled entertainment company dealing primarily in professional wrestling, with major revenue sources also coming from film, music, product licensing, and direct product sales.

Daniel Bryan is the majority owner, chairman and chief executive officer (CEO) of the company. Together with his wife Brie Bella, the Bryans hold own the company.

Lariatpro holds an extensive library videos, representing a significant portion of the visual history of professional wrestling.

## Championships and accomplishments

### Current champions

*Main article: List of current champions in Lariat Pro Wrestling*

## See also

* History
* Roster
* Lariatpro PPV
* LPW House Show
* LPW Board of Directors
* LPW Live 2016–Present

## External links

Template:Lariat Pro Wrestling

Template:LPW Video Games
Template:LPW PPV Images
Leilao

## Descrição

O algorítimo de leilão consiste na alocação de pessoas para objetos, no estagio inicial todos objetos tem custo 0 e as pessoas envolvidas no leilão tem um interesse por cada item.

Para cada pessoa não atribuída ao objeto fazemos:

e < 1/n traz a solução ótima.

pegamos o valor real de cada objeto = interesse da pessoa pelo objeto - preço do objeto

Definir o lance = primeiro melhor objeto - segundo melhor objeto + e;

Aumentamos o preço do primeiro melhor objeto no valor do lance.

Se o primeiro melhor objeto já estiver atribuído a uma pessoa tiramos essa atribuição e colocamos o atual comprador.

isso eh feito para todas as pessoas serem atribuídas ou paramos se todos objetos já foram alocados.
Sunlit

**Sunlit is a character in the book.**

## Background

Sunlit was the queen of the Equestria. She was Celestia's mother and Luna's adopted sister.She was famous but she didn't want others to know about her,so she decided to said that who know about her and dare to talk about her to others will be punished.So her history doesn't know much.
Ajuste de parâmetros (Hugo José)

Descrição Geral

O algorítimo pega os parâmetros e ajusta para que ele se aproxime do resultado desejado.

O algorítimo pega parâmetros cria números aleatórios para a primeira iteração e, a partir disso, ele usa esses parâmetros para realizar uma ação, caso esses parâmetros não satisfaçam a ação, ele usa um cálculo específico para ajustar esses parâmetros para poder se aproximar o máximo da solução desejada.

No caso do vídeo abaixo, eu cálculo a distância entra a bala e o alvo, após isso, eu multiplico a distância pela taxa de aprendizado e subtraio a antiga rotação, e coloco na nova rotação o resultado.

Para não girar o canhão tanto, existe um limite de 10 a 80 graus.

Após isso, eu faço o mesmo cálculo para a força, mas limitando-a para 1 a 100 m/s.

A cada erro (a bala de canhão não acerta o alvo) ele ajusta os parâmetros fazendo as contas descritas acima. Ele continua fazendo as contas até acertar o alvo, quando ele acerta, ele para a execução.

Em um jogo onde você também controla um canhão, pode-se usar essa IA para que ofereça um pouco de dificuldade para o jogador, pois é mais ou menos como uma pessoa jogaria esse tipo de jogo, a cada erro, ela tentaria ajustar o canhão para que consiga acertar o alvo.
Jogo da vida

## O Jogo da Vida

Jogo da vida é um Autômato Celular criado por John Horton Conway. A ideia do modelo é simular a reprodução e morte de grupos de seres vivos através de regras simples.

Implementado em uma grid bi dimensional cada célula representa um ser vivo e dependendo do seus vizinhos essa célula terá seu estado mantido como viva ou morta. É importante lembrar que cada celula do automato celular não é um agente, e sim o sistema como um todo que após verificar toda a grid tem seu estado alterado na próxima geração.

Meu exemplo foi desenvolvido na Unity utilizei cubos e os coloquei em uma matriz, cada cubo representa uma celula.

As regras implementadas foram:

Se a quantidade de vizinhos da célula for menor que 2 ela estará morta na próxima geração.

Se a quantidade de vizinhos for 3 a célula estará viva na próxima geração.

Se a quantidade de vizinhos for maior que 3 a célula estará morta na próxima geração.

## Como Utilizar

Colocar o executável Jogo da vida e Jogo da vida\_Data juntos.

Executar o jogo.

Passando o mouse em cima das células é possível dar vida a elas, após criar o padrão que deseja aperte espaço para que o Automato vá para a próxima geração.

No link a seguir se encontra o projeto Unity com scripts e implementação junto ao Executavel e a sua pasta Data.

https://drive.google.com/open?id=0B6EDbtbUaIEdMGpxSGhlS1V6MU0
Q lerning

Q-learning é uma técnica de aprendizado de reforço usada em aprendizado de máquina. O Q-learning pode lidar com problemas com transições e recompensas estocásticas, sem exigir adaptações.

Q(s,a) = (1-α)Q(s,a) + α(r + y max (Q(s’, a’)))

Após executar uma ação um feedback é dado.Normalmente um valor entre [-1;1].

Elementos básicos:

Potencial da ação(Q(s,a))

Estado Inicial (s)

α = taxa de aprendizado [0;1]

r = reforço (bônus)

y = desconto (penalização)

max (Q(s’, a’)) = Maior valor potencial das ações

No exemplo a seguir,o personagem possui 3 estados,sendo eles: vida acima de 50,vida entre 25 á 50 e vida entre 0 á 25. No estado acima de 50 o personagem tem a tendência a realizar a ação "atirar", no estado entre 25 á 50 de vida o personagem tem a tendência a realizar a ação "agachar" e abaixo de 25 de vida o personagem tem a tendência a realizar a ação "correr".Os pesos começam com valores aleatórios, consequentemente a ação a ser executada pode não ser a que ele tem a tendência a se realizar devido ao pesos inicias de cada ação. Ao decorrer da execução do algoritmo, a ação com o maior peso é executada, caso a ação não seja a que o estado tem tendência a fazer, o peso da ação executada diminui,logo o peso da ação que que tem tendência de acordo com o estado irá subir caso não aja alteração no estado, assim superando o peso das demais ações.
ChatBot

Foi ultilizada o CleverBot.api para e um servidor para intermediar a comunicacao do bot com o usuario.

O Cleverbot é mais robusto se ultilizar JavaScript ou Node.JS. A verçao do C# ela é obsoleta em algumas funcoes.

Como implementar no seu proprio chat o bot:

1º Va no menu Ferramentas -> NuGet Package Manager -> Package Manager Console.

2º - Escreva no console: Install-Package Cleverbot.net e espere o final da instalaçao.

3º - Va no site Cleverbot e pegue suas credenciais.

Exemplo de um simples console application:

apiUser e apoKey voce encontra no site do cleverbot.

```
using System;
using Cleverbot.Net;

class Program
{
    static void Main()
    {
        string message;
        var session = CleverbotSession.NewSession("apiUser", "apiKey");//Chama a instancia online do bot.
        do {
            Console.Write("Escreva sua mensagem: ");
            message = Console.ReadLine();
            Console.Write("Bot: ");
            Console.WriteLine(session.Send(message));// O bot vai retorna uma resposta a partir da mensagem que ele receber
        } while (message.ToLower().Trim() != "exit");
    }
}

```
Projekt Abyss

Projekt rozvinuté informační sítě, který se zabývá obnovou informačních zdrojů a kanálů a vytvářením nových. Prvním počinem Abyssu bylo zřízení nové radiové stanice zvané Radio Abyss, která nejprve pouze opakovala varovnou zprávu o šíření nákazy a pokyny, jak se mají obyvatelé zachovat. Později se kanál rozšířil o místa armádní evakuace, umístění velkých Útočišť, místa řádění tlup banditů a další užitečné informace.

Díky úporné snaze mnoha lidí i týmů instalujících či opravujících vysílače se brzy začal zvětšovat i dosah tohoto média a brzy tak přesáhlo hranice Města. Po ustálení systému pro rozšiřování této sítě se část lidí, tento projekt podporujících, začala soustředit na další možné cesty, jak informace šířit – například částečnou obnovu internetové sítě či televizního vysílání.

Někteří z nich ale měli za to, že by Abyss neměl informace jen šířit, ale zároveň je i a uchovávat. Vzniklo proto několik archivů, které začínají shromažďovat veškeré možné znalosti a vědomosti lidstva a jeho kulturního dědictví. To mimo jiné slibuje i mnoho příležitostí k výdělku dobrodruhům, jelikož ceny za výkup cenných knih či datových nosičů v dobrém stavu se mohou vyšplhat až do stovek plíšků.

Jen velmi málo lidí ví, kde přesně tyto archivy jsou, natož jak se dostat dovnitř. Odkup, shromažďování a následnou přepravou věcí do nich zařizují zástupci Abyssu ve větších Útočištích. I tak uniklo několik krycích jmen, která používají členové skupiny pro tato úložiště s nějakým primárním zaměřením.

DaVinci – technologie a výzkum
Teresa – medicína a biologie
Pantheon – historie a umění
Kerberos – veškerá literatura
Leilão (Presa - Predador)

## **O que é o Leilão?**

Baseado em um leilão verdadeiro, o **Algoritmo de Leilão** faz uma oferta inicial para o preço dos produtos e os consumidores começam a submeter ofertas a fim de subir esse preço até que reste um único consumidor para aquele produto.

O Leilão trata-se de um algoritmo de **Tomada de Decisão**, que pode ser classificado como um método para resolver problemas de atribuição.

## **Como Funciona o Leilão?**

Inicialmente temos um número X de agentes e Y de objetos. Definimos como preço inicial dos objetos o valor de 0. Calculamos então o valor da constante ε, que precisa ser maior que zero. Esse cálculo é feito dessa forma:

```
ε < 1/MaxAtribuicoes (para que a solução seja **ótima**)

```

Para iniciar os cálculos, precisamos também avaliar qual a finalidade do Leilão. Se for para **maximizar** **benefícios**, o valor das arestas são **positivas**. Se for para **minimizar** **custos**, o valor das arestas são **negativas**. Utilizaremos como exemplo à seguir um caso em que o Leilão esteja sendo usado para minimizar custos.

Definidos essas questões, podemos começar a rodar o algoritmo. Para isso, podemos preencher uma tabela com cinco opções:

* Número da Iteração Atual
* Alocação
* Incremento
* Novo Preço
* Desalocação

Ao rodar a primeira Iteração, fazemos a Alocação dos Agentes para o objeto cujo valor da aresta seja o maior (mais próximo de 0). Fazemos então, o cálculo do **Valor Real** dos dois melhores objetos, usando a fórmula abaixo:

```
Vr = ValorAresta - Preço

```

O próximo passo a ser feito é o cálculo do Incremento, definido pela fórmula abaixo:

```
Incremento = Vr(MelhorObjeto) - Vr(SegundoMelhorObjeto) + ε

```

E então, atualizamos o preço do objeto seguindo a seguinte fórmula:

```
PreçoNovo = PreçoAtual + Incremento

```

E alocamos o Agente para o Objeto em questão. Caso algum agente já esteja alocado naquele objeto, fazemos a próxima iteração apenas para o Agente que foi desalocado, repetindo os passos anteriores já atualizados.

O leilão termina quando todos os agentes forem alocados. Fazemos então a soma das arestas de cada objeto que foi alocado e encontramos o resultado.

## **Exemplo em Jogos**

Foi utilizado o Leilão como exemplo em um jogo Presa - Predador para que os agentes sejam realocados após a execução do algoritmo.

Primeiramente são geradas duas listas (uma de Presas e outra de Predadores) e também definimos a constante ε, que é calculada dessa forma:

```
ε = (1 / MaxAtribuicoes) - 0.00001

```

Os benefícios são definidos através da distância calculada entre a presa e o predador.

O Leilão começa a rodar no algoritmo de forma que os Predadores fazem os lances, calculando o valor real da distância até a presa, calculando o incremento e o novo preço. Após esse calculo, os Predadores são realocados no mapa de forma a perseguir as Presas.

https://drive.google.com/file/d/1BPh2BnMhAvVP8\_IPFcE0676pUMxrCgNF/view?usp=sharing

**Otávio Henrique Horsth**
Algoritmo Genético no aprendizado de canhões

## Definição do cromossomo:

O cromossomo do canhão é bem simples, registrando apenas seu ângulo, e poder usado no tiro.

## Definição da população inicial

A população fica a critério do usuário, sendo editável no inspector. O ideal é que ela seja múltiplo de 4, pois não foram feitos testes para outras situações.

## Função de aptidão (fitness)

A aptidão é decidida comparando a distância entre cada tiro e um alvo fixo. O rank, é definido comparando os indivíduos. O melhor indivíduo, ou seja, aquele que se aproximou mais, tem rank 0, o pior, dentre N indivíduos, tem rank N.

## Método de seleção

Com N indivíduos, nos pegamos N/2, dentre os primeiros colocados.

## Método de cruzamento

Para a metade restante da população, cruzamos indivíduo[0] com indivíduo [N/2-1], [1] COM [N/2-2], até completar a fileira.

## Método de mutação

Neste código, há apenas mutação quando há um número ímpar de indivíduos, onde geramos um indivíduo aleatório por reprodução. Porém, é possível, no método par, retirar um indivíduo de cada metade, e gerar um aleatório.

## Condição de parada

A condição de parada é dada pelo usuário. Devido á natureza do exercício, eu preferi deixar a reprodução controlada para analisar possíveis erros. É necessário apertar Z, esperar as bolas atingirem no chão, apertar F, depois R, depois repetir o ciclo até estar satisfeito com o resultado.

Isso é facilmente modificável para atender um padrão automático.
Leilão (Hugo José)

LEILÃO

O algorítimo de leilão busca alocar todos os agentes em um objeto cada. Cada objeto começa com um peso 0 e os agentes têm um interessa para cada objeto.

O cálculo é feito assim:

Valor real do Objeto = Interesse – peso

O lance = Primeiro melhor objeto – segundo melhor objeto + e, onde “e” é uma constante que tem de ser menor que 1/n. Quanto mais próximo de 1/n, melhor é a solução.

O lance é somado ao peso do objeto que foi escolhido, o agente é atribuído a esse objeto e segue as “escolhas” dos outros agentes, se algum agente quiser escolher algum objeto que já foi escolhido, ele manda o lance, se faz os cálculos de aumento de preço e ele passa a ser o “dono” desse objeto, desatribuindo o antigo. O algoritmo se repete até todos os agentes possuírem um objeto cada (sem ser repetido).

No vídeo abaixo, as distâncias são os interesses e cada presa tem um peso que, a medida que avança no tempo, o predador que não vê vantagem mais na presa, troca de alvo.
Leilão - Presa&Predador

## **O que é o Algorítimo de Leilão?**

O algoritmo de leilão permite o escalonamento eficiente entre tarefas e agentes, proporcionando o equilíbrio ótimo. Um agente centralizador (leiloeiro) efetua todos os cálculos de lances e informa para cada agente a atribuição de sua tarefa respectiva.

## **Como Funciona o Algorítimo de Leilão?**

**Etapa de Inicialização:**
– Definir as quantidades de Agentes e de Tarefas;
– Inseri-los em arrays;
– Definir a condição de parada (NAgentes ou NTarefas);
– Calcular e salvar o parâmetro E;
• E = (1 / maxAtribuições) – 0.00001
• Para o resultado ser ótimo, 0 < E < 1/Atribuições;
– Calcular e preencher a matriz de benefícios [A, T];
– Definir o custo positivo e comum para todas Tarefas (valor inicial do leilão);

**Etapa de Execução:**
– Repetir enquanto não chegar na condição de parada;
• Para cada agente sem tarefa atribuída, faça:
– Calcular o Lance do Agente para a Tarefa de melhor custo-benefício;
– Se a Tarefa tinha um dono alocado, desalocar;
– Alocar o novo dono (Agente) da Tarefa;
– Atualizar número de Atribuições;
– Atualizar o custo dessa Tarefa somando o valor do Lance;

**Cálculo do Lance do Agente:**
– Criar duas variáveis para armazenar o melhor e o segundo melhor valor de custo-benefício;
– Criar uma variável para armazenar o valor do lance;
– CB = matrizBeneficios[A,T] – custo[T];
• Atualizar o melhor e o segundo melhor custo benefício até o momento;
• Guardar qual é a melhor tarefa até o momento;
– Valor do lance = melhorCB – segundoCB + E;

Em jogos digitais, o algoritmo pode ser executado toda vez que:
• Uma tarefa for cumprida;
• Um agente “morrer”;

## **Exemplo de Aplicação:**

Um exemplo de jogo em que pode ser utilizado essa aplicação é em um RTS para definir qual o alvo ativo no com base ou na distancia ou na vida/ataque da unidade.

**Aluno: Samuel Gonçalves Mordente - 567253**
Ajuste de parametros - Canhao

## **Sobre o ajuste de parâmetro**

Esta é a forma mais simples de aprendizagem. Composta por procedimentos bem definidos para resolução de problemas em um número limitado de etapas. A solução pode ser a melhor encontrada entre todos os tipos de aprendizagem, mas também pode ser uma solução próxima a melhor.

## **Funcionamento**

Para o funcionamento deste canhão foram passados alguns procedimentos específicos que serão explicados melhor abaixo.

## **Declaração das variáveis**

Achei necessário a declaração das seguintes variáveis: AnguloAtual, AnguloAntigo, Distância, Ajuste, Maior Erro e Bateu.Como os valores para uma melhor solução encontrada podem não ser inteiros todas as variáveis com exceção da booleana Bateu são do tipo float. De forma com que todos essas variáveis sejam públicas para ser possível a visualização de todas à cada interação.

## **Início do Programa**

Para a primeira interação é declarado o valor do AnguloAtual = 0 , o valor de Ajuste = 15, MaiorErro = 1,5f e Bateu=false.

## **Após a primeira interação**

Após a primeira interação é necessário fazer algumas verificações.Estas verificações estarão em loop até que o projétil atinja o alvo.As verificações são :

* **Verificar se o projétil caiu:** Uma das maneiras para fazer essa verificação e foi a que eu achei mais fácil foi fazer a verificação da posição do projétil no eixo y. Caso esta posição seja maior que 0 significa que o projétil ainda não atingiu o chão, se ele for menor ou igual a 0 significa que o projétil significa que ele atingiu ou passou do chão. Se ele atingiu o chão passamos para a próxima etapa.
* **Calcular a distância do projétil:** A distância é calculada pela subtração entre a posição do projétil ao atingir o chão e a posição do alvo. Dependendo do valor desta distância iremos cair algum dos 3 casos a seguir.

1. **Passou do alvo:** Se a distância for maior que a variável MaiorErro, o valor da variável ajuste será alterado para a metade do valor atual da variável ajuste.
2. **Não alcançou o Alvo:** Se a distância for menor que o valor da variável MaiorErro negativo, a variável AnguloAntigo vai receber o valor da variável AnguloAtual e a variável AngulosAtual será atualizado com a soma da variável AnguloAtual com a variável Ajuste.
3. **Acertou o Alvo:** Se o projétil atingir o alvo atribuímos true à booleana Bateu, o que acarreta no encerramento do loop.

## **Aplicação em jogo**

Este projeto pode ser utilizado na implementação de um NPC que tenta acertar o jogador, mostrando ao jogador que o NPC está evoluindo para a angulação e a força necessária e automaticamente obriga o jogador a não ficar parado por muito tempo.

## Vídeo de funcionamento

Link.

**Página escrita por : Carlos A. B. Mariano - 467072 - 6º período de Tecnologia em Jogos Digitais - Pela Pontifícia Universidade Católica de Minas Gerais.**
Modelos baseados em Agentes - Objeto

## Descrição

Na implementação do agente como objeto, cada agente é uma instância de uma classe.

É definido um mecanismo de escalonamento e então o agente é executado à partir dos seus métodos configurados.

## Exemplo e implementação

Nesse exemplo, implementamos um sistema presa vs predador. Ambos andam aleatoriamente, até se encontrarem a uma certa distância. O predador tentará perseguir a presa, que tentará fugir.

Seguem as classes implementadas:

Agente.cs

Mundo.cs

Predador.cs

Presa.cs

Program.cs
Detention

"**Detention**" is the series premiere of Season 1 and first episode of **Freakish.** It debuted October 10, 2016.

## Plot

Despite not having Saturday detention, Grover Jones attends anyway just to be near the girl of his dreams, Violet Adams. When a nearby chemical plant explodes, they find themselves trapped in the school along with his sister Mary, basketball players Lashawn and Noodle, Lashawn's girlfriend Zoe, bully Diesel, computer whiz geek Barrett, and Natalie while the other students venture outside to try and find any survivors. At the end of the episode, one of the students who ventured outside, Lyle, re-enters the school, with strange sick-like symptoms. When Grover questions him, Lyle replies: "All dead."

## Cast

* Liza Koshy as Violet Adams
* Adam Hicks as Diesel Turner
* Aislinn Paul as Natalie Callaway
* Meghan Rienks as Zoe Parker
* Melvin Gregg as LaShawn Devereux
* Tyler Chase as Barrett McIntyre
* Mary Mouser as Mary Jones
* Hayes Grier as Noodle Nelson

Guest Starring* Alex Ozerov as Lyle
* Chad L. Coleman as Coach
* Olivia Gonzales as Addy
* Aaron Doh as Sam

## Trivia

* As the characters move around at night they pass a classroom. On the blackboard is a Fornier problem in graphing mathematics, homeomorphical and irreducible with a degree of n-10, the same as the one in MIT from "Good Will Hunting."
Automato Celular - Jogo da Vida

## Descrição

Este Automato Celular possui um controlador onde temos uma array de tiles onde a cada interação é aplicada algumas regras simples:

Qualquer célula viva com menos de dois vizinhos vivos morre

Qualquer célula viva com mais de três vizinhos vivos morre

Qualquer célula morta com exatamente três vizinhos vivos se torna uma célula viva

Qualquer célula viva com dois ou três vizinhos vivos continua no mesmo estado para a próxima geração

Depois de ter aplicado todas as regras o tile armazena a informação de qual seu próximo estado e entao assim que terminar de passar por todo o array de tiles pode ser atualizado o estado atual.

C#
--

AutomataCelular.cs

Tile.cs

## Video

   Neste Primeiro Video temos o automato celular com um padrao que fica em um loop, o mesmo acontece no segundo video, e no terceiro temos as mesmas regras mostrando outros padroes.
Lógica Fuzzy

## Descrição

A lógica Fuzzy (nebulosa, difusa) é um modelo de lógica mais próximo da linguagem natural. Basea-se em palavras ao invés de números.Ao contrário da lógica binária, a lógica Fuzzy não contem somente dois estados bem demarcados, e sim um nível de pertinência a cada estado.

Digamos que uma pessoa com menos que 20 anos seja considerada jovem. Se ela tiver 20 anos e 1 dia, a linguagem natural ainda considera que a pessoa é jovem. Essa implementação gera uma tomada de decisão mais suave, como podemos perceber no gráfico abaixo.

## Exemplo e implementação

Nesse exemplo, implementamos um sistema para avisar ao jogador se o inimigo está longe, médio ou perto, através da cor de sua barra de vida (verde, amarelo, vermelho). Percebe-se que estas denominações de distância não são valores binários, portanto a lógica Fuzzy encaixa perfeitamente, de modo a suavizar a implementação dessa noção de distância.

Para atingir esse comportamento, foram implementas três funções no script de Inimigo: DistanceToPortal, Fuzzyfy e FuzzyRules. Essas funções podem ser encontradas no arquivo abaixo:

EnemyController.cs
Lógica Fuzzy - Jogos

Seres humanos frequentemente analisam situações de maneiras
imprecisas, isto é, fazem uso de termos como “pouca força”, “muito longe” ou “bastante apertado”. A lógica fuzzy consegue então representar problemas de uma maneira similar à maneira com que humanos pensam sobre eles, pois conceitos como longe e pouco não são representados por intervalos discretos, mas por conjuntos fuzzy que permitem que um valor pertença a vários conjuntos com diversos graus de pertinência.

Por exemplo, um certo personagem de um jogo pode ter seu estado emocional pertencente ao conjunto feliz com grau de pertinência 0.7 e ao conjunto frustrado com grau 0.5. A lógica booleana tradicional só suporta valores de estado discretos resultando em mudanças de estado abruptas e para se conseguir respostas mais suaves em um sistema baseado em lógica booleana é necessária a adição de mais estados (o que novamente pode levar a explosões da quantidade de regras). Ao passo que lógica nebulosa evita esses problemas pois a resposta vai variar suavemente dado o grau de “verdade” das condições de entrada.

Sua versatilidade faz dela uma excelente opção para aplicações que tem um certo grau de incerteza ou que necessitam de grande flexibilidade e capacidade de adaptação. Sendo assim, jogos eletrônicos constituem um campo potencial para sua aplicação.

No jogo Age of Empires 2, por exemplo, se aplicado a ações de um NPC, podemos dizer um determinado soldado tem 70% de chance de ver o jogador se estiver próximo a ele ou calcular bônus sobre elevações em relação a outro NPC e visão de terreno. Esta técnica é muito útil e traz um grau de realismo importante e fundamental a este gênero. O vídeo mostra como a diferença de posicionamento e campo de visão faz total diferença no jogo, mesmo sendo um jogo feito 1997.

https://www.youtube.com/watch?v=ooBkMc9pVwM

Fernando Lucas de Souza - 548974
Algoritmo de tomada de decisão - Lógica Fuzzy

## Descrição

Lógica *Fuzzy* é a forma de lógica multivalorada na qual os valores lógicos das variáveis podem ser qualquer número real entre 0, correspondente ao valor falso, e 1, correspondente ao valor verdadeiro. Diferentemente, na lógica booleana, os valores lógicos das variáveis podem ser apenas 0 e 1. A Lógica *Fuzzy* foi estendida para lidar com o conceito de verdade parcial, onde o valor verdade pode compreender entre completamente verdadeiro e completamente falso. Além disso, quando variáveis linguísticas são usadas, esses graus podem ser manipulados por funções específicas.

As implementações da Lógica *Fuzzy* permitem que estados indeterminados possam ser tratados por dispositivos de controle. Desse modo, é possível avaliar conceitos não-quantificáveis.

## Detalhamento

Em nosso trabalho de conclusão de curso, no modo de jogo “Horda” os jogadores tem como objetivo alcançar a maior quantidade de pontos, e esses pontos são obtidos através da eliminação dos *npc’s*. Os *npc’s* por sua vez tem como objetivo eliminar os jogadores. Após uma tarefa ser atribuída ao agente pelo Algoritmo de Leilão, a Lógica *Fuzzy* é responsável por lidar com as ações que serão executadas pelos agentes. As ações levam em consideração o nível de ameaça que o jogador representa para o agente, esse nível de ameaça é obtido através de uma função Fitness que leva em consideração os parâmetros vida atual do agente e a arma que o jogador possui. Após calcular o nível de ameaça o algoritmo faz a comparação do parâmetro "bravura" com a porcentagem de ameaça e através dessa comparação define o comportamento do agente, que pode ser agressivo, normal ou defensivo, e cada comportamento possui um conjunto de ações.

Por exemplo:

- o agente possui vida cheia e sua tarefa é eliminar um jogador que não possui arma, portanto representa baixo nível de ameaça para o agente;

- o comportamento do agente é agressivo e ele executa a ação de perseguir e atacar o jogador;

- o jogador encontra uma arma poderosa e agora representa um alto nível de ameaça para o agente;

- o algoritmo calcula a porcentagem de ameaça com o parâmetro bravura do agente que define o seu comportamento;

- o comportamento do agente passa a ser defensivo e a sua ação é de fugir.

## Aplicação

Link para o vídeo no youtube: https://youtu.be/YFgtr1F3NSk
Automato Celular (Fogo e Jogo da Vida)

Sistema simula o comportamento de Fogo e o jogo da Vida.

O Sistema tem um tempo que é controlado pelo **tic**(tempo de espera em segundo), a cada **tic** o estado da célula muda.

A cada **tic** a célula verifica os seus vizinhos e muda seu estado

Ex: No comportamento de **Fogo** a grama se tiver algum vizinho com estado de fogo pega fogo no próximo **tic.**

O sistema tem 2 tipos de comportamentos: Fogo e Jogo da Vida.

## **Fogo**

A célula possui 5 estados:

1. Grama
2. Começo de fogo
3. Fogo mais forte
4. Fogo apagando
5. Cinzas

quando existe uma celular que não tem fogo e existe algum vizinho que tem grama ele pega fogo, no estado de cinza ele fica no primeiro estado que seria o "vazio".

## **Jogo da Vida**

A célula possui 4 regras :

1. Qualquer célula viva com menos de dois vizinhos vivos morre
2. Qualquer célula viva com mais de três vizinhos vivos morre
3. Qualquer célula morta com exatamente três vizinhos vivos se torna uma célula viva
4. Qualquer célula viva com dois ou três vizinhos vivos continua no mesmo estado para a próxima geração

Link do executável: Download
Modelo Baseado em Agente - Unity

## Descrição

Este exemplo feito na Unity foi baseado no App: My Talking Tom, onde tentamos implementar um agente que parece interagir com o usuário , ele possui necessidades básicas como Dormir, Comer, Divertir,Higienizar, o usuario utiliza o Mouse como input.

## Formas de interação

Drag and Drop, Mouse Input, botão Escape(pause)

## Interações - Comer

Durante essa interação cada alimento possui seu valor nutricional e quando o alimento é levado pela Mecânica de Drag and Drop na boca do personagem ele se alimenta. Possível implementação quando o personagem receber uma sobrecarga de alimentos ele faz vomito e se suja.

## Interações - Dormir

Durante essa interação o personagem apenas cai no sono quando a luz esta apagada, sendo assim podendo descansar.

## Interações - Diversão

Durante essa interação o personagem deve encontrar e o objeto que é escondido dentro de uma das esferas, se errar perde diversão se acertar ganha pontos de diversão, para reiniciar o jogo basta errar ou um click do mouse.

## Interações - Higienizar

Durante essa interação o personagem deve pegar a bucha e passar no personagem para limpar e ganhar pontos de higiene.

## Save

O save é temporário e quando o jogador fica offline o seu personagem continua decrementando seus status mas em uma taxa muito menor, o botão Escape abre o menu de pause onde podemos dar save manualmente e load manualmente e poder reiniciar o jogo.

## Autores

Guilherme Froes Camba de Freitas - guilhermedevgames@gmail.com

Lucas Marques Silva Pinho - kelthalos2@gmail.com
Machine Learning (Hugo José)

Machine Learning é o algorítimo que se treina para exercer uma determinada função.

O algorítimo de machine learning funciona dessa forma:

Existem um numero x de entradas que irão para uma parte do algorítimo que fica “escondida”, ela faz os cálculos e retorna valores para as saídas, que serão usadas pelo algorítimo.

Baseado na tentativa e erro, os valores vão se adaptando cada vez mais até ficarem mais precisos, por exemplo, um personagem que está aprendendo a correr em uma pista de corrida, ele começa errando e batendo sempre, mas a cada erro, ele se adapta e melhora, para que ele consiga fazer a primeira curva. Depois de um número x de interações, ele, finalmente, consegue fazer a primeira curva, e, por conta desse aprendizado, ele é capaz de tentar fazer uma curva de forma melhor. Depois dele conseguir dar uma volta completa em um percurso, é possível que se ele for colocado em um percurso diferente e ele consiga aprender a fazer o percurso num intervalo de tempo bem menor e, até mesmo futuramente, fazer percursos sem precisar errar.

No vídeo abaixo, são gerados vários carros e eles vão para vários lados, testando várias possibilidades. Os melhores carros, seus dados são passados, em parte, para outros carros para que eles consigam evoluir também da mesma forma. A cada geração, um carro consegue avançar cada vez mais e, mais carros conseguem começar a fazer o percurso de forma efetiva. (O verde é o carro com os melhores resultados, o amarelo é
o segundo melhor carro.)

O projeto usado no vídeo vocês podem baixar nesse link:

https://arztsamuel.github.io/en/projects/unity/deepCars/deepCars.html