El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

En aquesta secció, explorarem els conceptes fonamentals de la Intel·ligència Artificial (IA) aplicats als videojocs. Aquests conceptes són essencials per comprendre com es desenvolupen i implementen els comportaments intel·ligents en els personatges del joc.

Què és la Intel·ligència Artificial?

La Intel·ligència Artificial (IA) és una branca de la informàtica que se centra en la creació de sistemes capaços de realitzar tasques que normalment requereixen intel·ligència humana. Aquestes tasques inclouen:

Aprenentatge: Capacitat d'adquirir coneixements i millorar amb l'experiència.
Raonament: Capacitat de resoldre problemes i prendre decisions.
Percepció: Capacitat d'interpretar dades sensorials.
Interacció: Capacitat de comunicar-se amb humans i altres màquines.

Tipus de IA en Videojocs

En els videojocs, la IA es pot classificar en diverses categories segons la seva funció i complexitat:

IA Reactiva: Respon a estímuls immediats sense planificació a llarg termini. Exemple: un enemic que ataca quan el jugador s'apropa.
IA Planificadora: Pren decisions basades en una seqüència d'accions per assolir un objectiu. Exemple: un personatge que planifica una ruta per arribar a un punt específic.
IA Adaptativa: Aprèn i s'adapta basant-se en l'experiència. Exemple: un enemic que millora les seves tàctiques després de ser derrotat diverses vegades.

Components de la IA en Videojocs

3.1. Agents

Un agent és una entitat que percep el seu entorn i actua sobre ell per assolir els seus objectius. En els videojocs, els agents poden ser personatges no jugadors (NPCs), enemics, aliats, etc.

3.2. Entorn

L'entorn és el món en què opera l'agent. Pot incloure altres agents, obstacles, objectius, etc. L'entorn pot ser estàtic (no canvia) o dinàmic (canvia amb el temps).

3.3. Sensors

Els sensors permeten als agents percebre el seu entorn. En els videojocs, els sensors poden ser visuals (càmera), auditius (sons), tàctils (col·lisions), etc.

3.4. Actuadors

Els actuadors permeten als agents interactuar amb el seu entorn. En els videojocs, els actuadors poden incloure moviments, accions, comunicacions, etc.

Algoritmes Bàsics de IA

4.1. Algoritmes de Cerca

Els algoritmes de cerca són fonamentals per a la navegació i la presa de decisions en els videojocs. Alguns dels més comuns són:

Búsqueda en Amplitud (BFS): Explora tots els nodes a un nivell abans de passar al següent nivell.
Búsqueda en Profunditat (DFS): Explora tan profundament com sigui possible abans de retrocedir.
Algoritme A*: Troba el camí més curt utilitzant una funció de cost que combina la distància recorreguda i la distància estimada al destí.

4.2. Màquines d'Estats Finits (FSM)

Les FSM són una manera senzilla i efectiva de modelar el comportament dels agents. Un agent pot estar en un estat determinat i canviar a un altre estat en resposta a certs estímuls. Exemple:

Estat: Patrullar
  - Si veu un enemic -> Canvia a Estat: Atacar
  - Si rep dany -> Canvia a Estat: Fugir

4.3. Arbres de Decisió

Els arbres de decisió són una estructura jeràrquica que permet als agents prendre decisions basades en una sèrie de condicions. Cada node representa una condició i cada branca representa una acció o una altra condició.

4.4. Xarxes Neuronals

Les xarxes neuronals són models d'aprenentatge automàtic inspirats en el cervell humà. Són útils per a tasques complexes com el reconeixement de patrons i l'aprenentatge per reforç.

Exemples Pràctics

Exemple 1: Implementació d'una FSM

class Agent:
    def __init__(self):
        self.state = "patrullar"

    def veure_enemic(self):
        if self.state == "patrullar":
            self.state = "atacar"

    def rebre_dany(self):
        if self.state == "patrullar":
            self.state = "fugir"

    def actualitzar(self):
        if self.state == "patrullar":
            print("Patrullant...")
        elif self.state == "atacar":
            print("Atacant l'enemic!")
        elif self.state == "fugir":
            print("Fugint del perill!")

Exemple 2: Algoritme A*

import heapq

def a_star(inici, objectiu, graella):
    obert = []
    heapq.heappush(obert, (0, inici))
    tancat = set()
    costos = {inici: 0}
    pares = {inici: None}

    while obert:
        _, actual = heapq.heappop(obert)
        if actual == objectiu:
            camí = []
            while actual:
                camí.append(actual)
                actual = pares[actual]
            return camí[::-1]

        tancat.add(actual)
        for veí in obtenir_veïns(actual, graella):
            if veí in tancat:
                continue
            nou_cost = costos[actual] + cost(actual, veí)
            if veí not in costos or nou_cost < costos[veí]:
                costos[veí] = nou_cost
                prioritat = nou_cost + heurística(veí, objectiu)
                heapq.heappush(obert, (prioritat, veí))
                pares[veí] = actual

    return None

Exercicis Pràctics

Exercici 1: Crear una FSM per a un NPC

Descripció: Implementa una FSM per a un NPC que pugui patrullar, atacar i fugir.

Solució:

class NPC:
    def __init__(self):
        self.state = "patrullar"

    def veure_jugador(self):
        if self.state == "patrullar":
            self.state = "atacar"

    def rebre_dany(self):
        if self.state == "patrullar":
            self.state = "fugir"

    def actualitzar(self):
        if self.state == "patrullar":
            print("Patrullant...")
        elif self.state == "atacar":
            print("Atacant el jugador!")
        elif self.state == "fugir":
            print("Fugint del perill!")

Exercici 2: Implementar l'algoritme A* per a la navegació

Descripció: Implementa l'algoritme A* per trobar el camí més curt en una graella.

Solució:

import heapq

def heurística(a, b):
    return abs(a[0] - b[0]) + abs(a[1] - b[1])

def obtenir_veïns(node, graella):
    veïns = []
    for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
        x, y = node[0] + dx, node[1] + dy
        if 0 <= x < len(graella) and 0 <= y < len(graella[0]) and graella[x][y] == 0:
            veïns.append((x, y))
    return veïns

def cost(a, b):
    return 1

def a_star(inici, objectiu, graella):
    obert = []
    heapq.heappush(obert, (0, inici))
    tancat = set()
    costos = {inici: 0}
    pares = {inici: None}

    while obert:
        _, actual = heapq.heappop(obert)
        if actual == objectiu:
            camí = []
            while actual:
                camí.append(actual)
                actual = pares[actual]
            return camí[::-1]

        tancat.add(actual)
        for veí in obtenir_veïns(actual, graella):
            if veí in tancat:
                continue
            nou_cost = costos[actual] + cost(actual, veí)
            if veí not in costos or nou_cost < costos[veí]:
                costos[veí] = nou_cost
                prioritat = nou_cost + heurística(veí, objectiu)
                heapq.heappush(obert, (prioritat, veí))
                pares[veí] = actual

    return None

Conclusió

En aquesta secció, hem cobert els conceptes bàsics de la IA en videojocs, incloent-hi els tipus d'IA, els components clau i alguns dels algoritmes més utilitzats. Aquests fonaments són essencials per comprendre com es desenvolupen els comportaments intel·ligents en els personatges del joc. En les següents seccions, aprofundirem en aquests conceptes i veurem com implementar-los en situacions més complexes.

Conceptes Bàsics de IA