AIGC在游戏开发中的革命性潜力-自动生成内容与智能化NPC

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision.utils import save_image

# 定义生成器
class Generator(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(Generator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.ReLU(True),
            nn.Linear(256, 512),
            nn.ReLU(True),
            nn.Linear(512, 1024),
            nn.ReLU(True),
            nn.Linear(1024, output_dim),
            nn.Tanh()
        )

    def forward(self, x):
        return self.main(x)

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self, input_dim):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Linear(input_dim, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(1024, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.main(x)

# 生成和判别器的实例化
latent_dim = 100  # 输入噪声维度
gen = Generator(latent_dim, 784)  # 假设输出是28x28像素的角色图像
disc = Discriminator(784)

# 优化器与损失函数
criterion = nn.BCELoss()
optimizer_g = optim.Adam(gen.parameters(), lr=0.0002)
optimizer_d = optim.Adam(disc.parameters(), lr=0.0002)

# 训练循环
for epoch in range(10000):
    # 训练判别器
    real_data = torch.randn(64, 784)  # 真实游戏角色数据
    fake_data = gen(torch.randn(64, latent_dim)).detach()  # 生成的假数据
    optimizer_d.zero_grad()
    real_loss = criterion(disc(real_data), torch.ones(64, 1))  # 真实数据标签为1
    fake_loss = criterion(disc(fake_data), torch.zeros(64, 1))  # 假数据标签为0
    d_loss = real_loss + fake_loss
    d_loss.backward()
    optimizer_d.step()

    # 训练生成器
    optimizer_g.zero_grad()
    generated_data = gen(torch.randn(64, latent_dim))  # 生成新数据
    g_loss = criterion(disc(generated_data), torch.ones(64, 1))  # 目标是“骗过”判别器
    g_loss.backward()
    optimizer_g.step()

    if epoch % 1000 == 0:
        save_image(generated_data.view(64, 1, 28, 28), f'generated_{epoch}.png')
        print(f'Epoch {epoch}: D_loss: {d_loss.item()}, G_loss: {g_loss.item()}')

from transformers import GPT2LMHeadModel, GPT2Tokenizer

# 加载预训练的GPT-2模型和tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# 定义输入任务提示
input_prompt = "The hero embarks on a dangerous quest to"

# 将提示输入模型
inputs = tokenizer(input_prompt, return_tensors='pt')
outputs = model.generate(inputs['input_ids'], max_length=100, num_return_sequences=3)

# 输出生成的任务描述
for i, output in enumerate(outputs):
    print(f"任务描述 {i + 1}: {tokenizer.decode(output, skip_special_tokens=True)}")

import numpy as np
import random

# 游戏环境的状态数与动作数
n_states = 10  # 游戏中的不同状态
n_actions = 4  # 游戏中的不同动作（上下左右）

# Q-table 初始化
q_table = np.zeros((n_states, n_actions))

# 超参数
learning_rate = 0.1
discount_factor = 0.95
epsilon = 0.1  # 探索几率

# 模拟游戏环境
def take_action(state, action):
    if action == 0:  # 上
        return max(state - 1, 0)
    elif action == 1:  # 下
        return min(state + 1, n_states - 1)
    elif action == 2:  # 左
        return max(state - 1, 0)
    elif action == 3:  # 右
        return min(state + 1, n_states - 1)

# Q-learning 算法
for episode in range(1000):
    state = random.randint(0, n_states - 1)  # 随机初始化状态

    for step in range(100):
        if random.uniform(0, 1) < epsilon:
            action = random.randint(0, n_actions - 1)  # 探索：随机选择动作
        else:
            action = np.argmax(q_table[state])  # 利用：选择Q值最高的动作

        next_state = take_action(state, action)
        reward = 1 if next_state == n_states - 1 else -1  # 奖励机制

        # Q-learning 更新公式
        q_table[state, action] = q_table[state, action] + learning_rate * (
            reward + discount_factor * np.max(q_table[next_state]) - q_table[state, action])

        state = next_state

        if state == n_states - 1:
            break  # 任务完成

print("训练后的Q-table：")
print(q_table)

from transformers import GPT2LMHeadModel, GPT2Tokenizer

# 加载GPT-2模型和tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# NPC的初始对话提示
npc_prompt = "Welcome, adventurer! How can I assist you on your quest?"

# 将提示输入模型，生成后续对话
inputs = tokenizer(npc_prompt, return_tensors='pt')
outputs = model.generate(inputs['input_ids'], max_length=50, num_return_sequences=1)

# 输出生成的NPC对话
generated_dialogue = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("NPC对话生成：", generated_dialogue)

import numpy as np
import matplotlib.pyplot as plt
from noise import pnoise2

# 地图尺寸
map_size = (100, 100)
scale = 10.0  # 缩放因子，用于调整地形的细节层次

# 生成地形高度图
terrain = np.zeros(map_size)
for i in range(map_size[0]):
    for j in range(map_size[1]):
        terrain[i][j] = pnoise2(i / scale, j / scale, octaves=6)

# 可视化生成的地形
plt.imshow(terrain, cmap='terrain')
plt.colorbar()
plt.title("Procedurally Generated Terrain")
plt.show()

import numpy as np

# 定义关卡环境，1为障碍物，0为路径
def generate_level(size):
    level = np.random.choice([0, 1], size=(size, size), p=[0.7, 0.3])
    level[0, 0] = 0  # 确保起点没有障碍物
    level[size-1, size-1] = 0  # 确保终点没有障碍物
    return level

# 生成关卡
level_size = 10
level = generate_level(level_size)

# 可视化关卡
plt.imshow(level, cmap='binary')
plt.title("Randomly Generated Level")
plt.show()

from magenta.models.shared import melody_rnn_sequence_generator
from magenta.protobuf import generator_pb2
from magenta.protobuf import music_pb2

# 配置生成参数
generator_options = generator_pb2.GeneratorOptions()
generator_options.generate_sections.add(
    start_time=0, end_time=30  # 生成30秒的音乐
)

# 初始化音乐生成器
generator = melody_rnn_sequence_generator.MelodyRnnSequenceGenerator()
generated_sequence = generator.generate(generator_options)

# 打印生成的音符序列
print(generated_sequence)