前言
大学时期我热衷于玩魔兽世界，仅点卡就花了上万，这对于一个穷学生来说是一笔巨款。为了省钱我当时想要开发自己的wow，但苦于当时有心无技术。而今天，这个梦想可以实现了：“为了部落”，当然也为了联盟！
FBI警告
这是一篇纯技术篇，小白也可以学习的教程。
使用技术：
前端：cocos2d、unity3D
后端：python、nodejs
数据库：MongoDB, MySQL
实时通信：WebSocket, Socket.io
现在开始我们将设计一款类似于《魔兽世界》的策略类手游。以下是我们项目的基本步骤：
项目概述
我们将设计一个类似于《魔兽世界》的策略类手游，包括以下功能：
用户界面 - 主要菜单，游戏界面，角色创建，地图，战斗系统。
角色管理 - 角色创建，角色升级，技能树。
战斗系统 - 回合制或实时战斗系统，敌人AI。
任务系统 - 主线任务，支线任务。
多人在线 - 联机对战，公会系统。
资源管理 - 经济系统，物品掉落，市场交易。
图形与声音 - 2D/3D图形，背景音乐，音效。
初步设计
用户界面（UI）
主要菜单
开始游戏
设置
退出
游戏界面
角色信息面板
地图
战斗日志
聊天窗口
角色管理
角色创建
选择种族
选择职业
自定义外观
角色升级
经验值系统
技能点分配
战斗系统
战斗模式
回合制战斗
实时战斗
敌人AI
敌人行为模式
难度调整
任务系统
任务类型
主线任务
支线任务
任务奖励
经验值
金钱
道具
多人在线
联机对战
PVP系统
排位赛
公会系统
创建公会
公会任务
资源管理
经济系统
金钱获取
道具购买
市场交易
玩家之间交易
拍卖行
图形与声音
图形
2D/3D图形渲染
动画效果
声音
背景音乐
音效
目录结构
my_game_project/
│
├── frontend/
│ ├── assets/
│ ├── scenes/
│ ├── scripts/
│ └── main.js
│
├── backend/
│ ├── api/
│ ├── models/
│ ├── controllers/
│ └── app.js
│
├── config/
│ ├── db_config.js
│ └── server_config.js
│
└── package.json
详细设计与伪代码
- 用户界面（UI）
主要菜单
MainMenu
├── StartGameButton
├── SettingsButton
└── ExitButton
class MainMenu:
def __init__(self):
self.start_game_button = Button("Start Game", self.start_game)
self.settings_button = Button("Settings", self.open_settings)
self.exit_button = Button("Exit", self.exit_game)
def start_game(self):
# Code to start the game
pass
def open_settings(self):
# Code to open settings menu
pass
def exit_game(self):
# Code to exit the game
pass
游戏界面
GameInterface
├── CharacterInfoPanel
├── Map
├── BattleLog
└── ChatWindow
class GameInterface:
def __init__(self):
self.character_info_panel = CharacterInfoPanel()
self.map = GameMap()
self.battle_log = BattleLog()
self.chat_window = ChatWindow()
- 角色管理
角色创建
CharacterCreation
├── SelectRace
├── SelectClass
└── CustomizeAppearance
class CharacterCreation:
def __init__(self):
self.race = self.select_race()
self.char_class = self.select_class()
self.appearance = self.customize_appearance()
def select_race(self):
# Code to select race
pass
def select_class(self):
# Code to select class
pass
def customize_appearance(self):
# Code to customize appearance
pass
角色升级
CharacterLeveling
├── ExperienceSystem
└── SkillTree
class CharacterLeveling:
def __init__(self, experience=0, level=1):
self.experience = experience
self.level = level
self.skill_tree = SkillTree()
def gain_experience(self, amount):
self.experience += amount
if self.experience >= self.experience_needed_for_next_level():
self.level_up()
def experience_needed_for_next_level(self):
# Code to calculate experience needed
pass
def level_up(self):
self.level += 1
self.skill_tree.gain_skill_point()
- 战斗系统
战斗模式
BattleSystem
├── TurnBasedCombat
└── RealTimeCombat
class BattleSystem:
def __init__(self, mode='turn_based'):
if mode == 'turn_based':
self.combat_mode = TurnBasedCombat()
elif mode == 'real_time':
self.combat_mode = RealTimeCombat()
else:
raise ValueError("Invalid combat mode")
def start_combat(self):
self.combat_mode.start()
敌人AI
EnemyAI
├── BehaviorPatterns
└── DifficultyAdjustment
class EnemyAI:
def __init__(self, difficulty='normal'):
self.behavior_patterns = self.load_behavior_patterns()
self.difficulty = difficulty
def load_behavior_patterns(self):
# Code to load enemy behavior patterns
pass
def adjust_difficulty(self, difficulty):
self.difficulty = difficulty
# Code to adjust difficulty
pass
- 任务系统
任务类型
QuestSystem
├── MainQuests
└── SideQuests
class QuestSystem:
def __init__(self):
self.main_quests = self.load_main_quests()
self.side_quests = self.load_side_quests()
def load_main_quests(self):
# Code to load main quests
pass
def load_side_quests(self):
# Code to load side quests
pass
QuestRewards
├── ExperiencePoints
├── Money
└── Items
class QuestRewards:
def __init__(self, experience=0, money=0, items=[]):
self.experience = experience
self.money = money
self.items = items
def give_rewards(self, player):
player.gain_experience(self.experience)
player.earn_money(self.money)
player.receive_items(self.items)
新任务确认… 初始化详细设计模式 🧑💻🔓
详细设计与伪代码
- 用户界面（UI）
主要菜单
plaintext
复制代码
MainMenu
├── StartGameButton
├── SettingsButton
└── ExitButton
伪代码
python
复制代码
class MainMenu:
def init(self):
self.start_game_button = Button(“Start Game”, self.start_game)
self.settings_button = Button(“Settings”, self.open_settings)
self.exit_button = Button(“Exit”, self.exit_game)
def start_game(self):
# Code to start the game
pass
def open_settings(self):
# Code to open settings menu
pass
def exit_game(self):
# Code to exit the game
pass
游戏界面
plaintext
复制代码
GameInterface
├── CharacterInfoPanel
├── Map
├── BattleLog
└── ChatWindow
伪代码
python
复制代码
class GameInterface:
def init(self):
self.character_info_panel = CharacterInfoPanel()
self.map = GameMap()
self.battle_log = BattleLog()
self.chat_window = ChatWindow()
2. 角色管理
角色创建
plaintext
复制代码
CharacterCreation
├── SelectRace
├── SelectClass
└── CustomizeAppearance
伪代码
python
复制代码
class CharacterCreation:
def init(self):
self.race = self.select_race()
self.char_class = self.select_class()
self.appearance = self.customize_appearance()
def select_race(self):
# Code to select race
pass
def select_class(self):
# Code to select class
pass
def customize_appearance(self):
# Code to customize appearance
pass
角色升级
plaintext
复制代码
CharacterLeveling
├── ExperienceSystem
└── SkillTree
伪代码
python
复制代码
class CharacterLeveling:
def init(self, experience=0, level=1):
self.experience = experience
self.level = level
self.skill_tree = SkillTree()
def gain_experience(self, amount):
self.experience += amount
if self.experience >= self.experience_needed_for_next_level():
self.level_up()
def experience_needed_for_next_level(self):
# Code to calculate experience needed
pass
def level_up(self):
self.level += 1
self.skill_tree.gain_skill_point()
- 战斗系统
战斗模式
plaintext
复制代码
BattleSystem
├── TurnBasedCombat
└── RealTimeCombat
伪代码
python
复制代码
class BattleSystem:
def init(self, mode=‘turn_based’):
if mode == ‘turn_based’:
self.combat_mode = TurnBasedCombat()
elif mode == ‘real_time’:
self.combat_mode = RealTimeCombat()
else:
raise ValueError(“Invalid combat mode”)
def start_combat(self):
self.combat_mode.start()
敌人AI
plaintext
复制代码
EnemyAI
├── BehaviorPatterns
└── DifficultyAdjustment
伪代码
python
复制代码
class EnemyAI:
def init(self, difficulty=‘normal’):
self.behavior_patterns = self.load_behavior_patterns()
self.difficulty = difficulty
def load_behavior_patterns(self):
# Code to load enemy behavior patterns
pass
def adjust_difficulty(self, difficulty):
self.difficulty = difficulty
# Code to adjust difficulty
pass
- 任务系统
任务类型
plaintext
复制代码
QuestSystem
├── MainQuests
└── SideQuests
伪代码
python
复制代码
class QuestSystem:
def init(self):
self.main_quests = self.load_main_quests()
self.side_quests = self.load_side_quests()
def load_main_quests(self):
# Code to load main quests
pass
def load_side_quests(self):
# Code to load side quests
pass
任务奖励
plaintext
复制代码
QuestRewards
├── ExperiencePoints
├── Money
└── Items
伪代码
python
复制代码
class QuestRewards:
def init(self, experience=0, money=0, items=[]):
self.experience = experience
self.money = money
self.items = items
def give_rewards(self, player):
player.gain_experience(self.experience)
player.earn_money(self.money)
player.receive_items(self.items)
- 多人在线
联机对战
class Multiplayer:
def __init__(self):
self.pvp_system = PVPSystem()
self.ranking_system = RankingSystem()
def start_pvp_match(self):
self.pvp_system.start_match()
def update_ranking(self, player):
self.ranking_system.update(player)
公会系统
GuildSystem
├── CreateGuild
└── GuildQuests
class GuildSystem:
def __init__(self):
self.guilds = []
def create_guild(self, name, leader):
new_guild = Guild(name, leader)
self.guilds.append(new_guild)
def assign_guild_quests(self, guild):
guild.assign_quests()
- 资源管理
经济系统
EconomySystem
├── MoneyEarning
└── ItemPurchasing
class EconomySystem:
def __init__(self):
self.money = 0
def earn_money(self, amount):
self.money += amount
def purchase_item(self, item, cost):
if self.money >= cost:
self.money -= cost
return item
else:
raise ValueError("Not enough money")
市场交易
Market
├── PlayerTrading
└── AuctionHouse
class Market:
def __init__(self):
self.items_for_sale = []
self.auction_house = AuctionHouse()
def list_item_for_sale(self, item, price):
self.items_for_sale.append((item, price))
def buy_item(self, item):
for i, (listed_item, price) in enumerate(self.items_for_sale):
if listed_item == item:
self.items_for_sale.pop(i)
return item, price
raise ValueError("Item not found")
frontend/
├── assets/
├── scenes/
│ ├── MainMenu.fire
│ └── Game.fire
├── scripts/
│ ├── MainMenu.js
│ └── Game.js
└── main.js
MainMenu.js
cc.Class({
extends: cc.Component,
properties: {
startGameButton: cc.Button,
settingsButton: cc.Button,
exitButton: cc.Button,
},
onLoad() {
this.startGameButton.node.on('click', this.startGame, this);
this.settingsButton.node.on('click', this.openSettings, this);
this.exitButton.node.on('click', this.exitGame, this);
},
startGame() {
cc.director.loadScene('Game');
},
openSettings() {
// Open settings menu (to be implemented)
console.log('Open settings');
},
exitGame() {
cc.game.end();
}
});
Game.fire (Cocos Creator 场景文件)
在Cocos Creator中新建一个名为Game的场景。
添加角色信息面板、地图、战斗日志和聊天窗口的UI组件。
Game.js
cc.Class({
extends: cc.Component,
properties: {
characterInfoPanel: cc.Node,
map: cc.Node,
battleLog: cc.Node,
chatWindow: cc.Node,
},
onLoad() {
// Initialize game interface elements
}
});
目录结构
backend/
├── api/
│ ├── routes/
│ │ ├── auth.js
│ │ ├── characters.js
│ │ ├── quests.js
│ │ └── battles.js
│ └── index.js
├── models/
│ ├── user.js
│ ├── character.js
│ ├── quest.js
│ └── battle.js
├── controllers/
│ ├── authController.js
│ ├── characterController.js
│ ├── questController.js
│ └── battleController.js
└── app.js
const express = require(‘express’);
const mongoose = require(‘mongoose’);
const bodyParser = require(‘body-parser’);
const app = express();
const port = process.env.PORT || 3000;
// Middleware
app.use(bodyParser.json());
// Routes
const authRoutes = require(‘./api/routes/auth’);
const characterRoutes = require(‘./api/routes/characters’);
const questRoutes = require(‘./api/routes/quests’);
const battleRoutes = require(‘./api/routes/battles’);
app.use(‘/auth’, authRoutes);
app.use(‘/characters’, characterRoutes);
app.use(‘/quests’, questRoutes);
app.use(‘/battles’, battleRoutes);
// Connect to MongoDB
mongoose.connect(‘mongodb://localhost:27017/my_game_db’, { useNewUrlParser: true, useUnifiedTopology: true })
.then(() => console.log(‘MongoDB connected’))
.catch(err => console.log(err));
app.listen(port, () => {
console.log(Server running on port ${port});
});
api/routes/auth.js
const express = require(‘express’);
const router = express.Router();
const authController = require(‘…/…/controllers/authController’);
router.post(‘/register’, authController.register);
router.post(‘/login’, authController.login);
module.exports = router;
const User = require(‘…/models/user’);
exports.register = async (req, res) => {
const { username, password } = req.body;
try {
const user = new User({ username, password });
await user.save();
res.status(201).json({ message: 'User registered successfully' });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.login = async (req, res) => {
const { username, password } = req.body;
try {
const user = await User.findOne({ username });
if (!user || user.password !== password) {
return res.status(401).json({ message: 'Invalid credentials' });
}
res.status(200).json({ message: 'User logged in successfully' });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
const User = require(‘…/models/user’);
exports.register = async (req, res) => {
const { username, password } = req.body;
try {
const user = new User({ username, password });
await user.save();
res.status(201).json({ message: 'User registered successfully' });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.login = async (req, res) => {
const { username, password } = req.body;
try {
const user = await User.findOne({ username });
if (!user || user.password !== password) {
return res.status(401).json({ message: 'Invalid credentials' });
}
res.status(200).json({ message: 'User logged in successfully' });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
- 数据库模型
models/user.js
const mongoose = require(‘mongoose’);
const UserSchema = new mongoose.Schema({
username: { type: String, required: true, unique: true },
password: { type: String, required: true }
});
module.exports = mongoose.model(‘User’, UserSchema);
const mongoose = require(‘mongoose’);
const CharacterSchema = new mongoose.Schema({
userId: { type: mongoose.Schema.Types.ObjectId, ref: ‘User’, required: true },
name: { type: String, required: true },
race: { type: String, required: true },
class: { type: String, required: true },
level: { type: Number, default: 1 },
experience: { type: Number, default: 0 },
skills: [{ type: String }]
});
module.exports = mongoose.model(‘Character’, CharacterSchema);
const mongoose = require(‘mongoose’);
const QuestSchema = new mongoose.Schema({
title: { type: String, required: true },
description: { type: String, required: true },
rewards: {
experience: { type: Number, default: 0 },
money: { type: Number, default: 0 },
items: [{ type: String }]
}
});
module.exports = mongoose.model(‘Quest’, QuestSchema);
const mongoose = require(‘mongoose’);
const QuestSchema = new mongoose.Schema({
title: { type: String, required: true },
description: { type: String, required: true },
rewards: {
experience: { type: Number, default: 0 },
money: { type: Number, default: 0 },
items: [{ type: String }]
}
});
module.exports = mongoose.model(‘Quest’, QuestSchema);
const mongoose = require(‘mongoose’);
const BattleSchema = new mongoose.Schema({
characterId: { type: mongoose.Schema.Types.ObjectId, ref: ‘Character’, required: true },
enemy: { type: String, required: true },
result: { type: String, required: true },
rewards: {
experience: { type: Number, default: 0 },
money: { type: Number, default: 0 },
items: [{ type: String }]
}
});
module.exports = mongoose.model(‘Battle’, BattleSchema);
角色管理
我们将实现角色创建和角色升级功能。以下是详细的代码实现：
api/routes/characters.js
const express = require(‘express’);
const router = express.Router();
const characterController = require(‘…/…/controllers/characterController’);
router.post(‘/create’, characterController.createCharacter);
router.get(‘/:userId’, characterController.getCharacters);
router.post(‘/level-up/:characterId’, characterController.levelUpCharacter);
module.exports = router;
const Character = require(‘…/models/character’);
exports.createCharacter = async (req, res) => {
const { userId, name, race, class: charClass } = req.body;
try {
const character = new Character({ userId, name, race, class: charClass });
await character.save();
res.status(201).json({ message: 'Character created successfully', character });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.getCharacters = async (req, res) => {
const { userId } = req.params;
try {
const characters = await Character.find({ userId });
res.status(200).json({ characters });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.levelUpCharacter = async (req, res) => {
const { characterId } = req.params;
const { experience } = req.body;
try {
const character = await Character.findById(characterId);
character.experience += experience;
if (character.experience >= character.level * 100) {
character.level += 1;
character.experience = 0;
character.skills.push('New Skill'); // Example skill
}
await character.save();
res.status(200).json({ message: 'Character leveled up', character });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
战斗系统
我们将实现战斗系统，包括回合制战斗和敌人AI。
api/routes/battles.js
const express = require(‘express’);
const router = express.Router();
const battleController = require(‘…/…/controllers/battleController’);
router.post(‘/start’, battleController.startBattle);
router.post(‘/turn/:battleId’, battleController.performTurn);
router.post(‘/end/:battleId’, battleController.endBattle);
module.exports = router;
const Battle = require(‘…/models/battle’);
const Character = require(‘…/models/character’);
exports.startBattle = async (req, res) => {
const { characterId, enemy } = req.body;
try {
const battle = new Battle({ characterId, enemy, result: 'ongoing' });
await battle.save();
res.status(201).json({ message: 'Battle started', battle });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.performTurn = async (req, res) => {
const { battleId } = req.params;
const { action } = req.body;
try {
const battle = await Battle.findById(battleId);
// Implement turn-based logic (e.g., reduce enemy HP, check for win/lose conditions)
// Example: action could be 'attack', 'defend', etc.
battle.save();
res.status(200).json({ message: 'Turn performed', battle });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.endBattle = async (req, res) => {
const { battleId } = req.params;
const { result } = req.body;
try {
const battle = await Battle.findById(battleId);
battle.result = result; // 'win' or 'lose'
if (result === 'win') {
// Give rewards to the character
const character = await Character.findById(battle.characterId);
character.experience += battle.rewards.experience;
// Add other rewards logic here
await character.save();
}
await battle.save();
res.status(200).json({ message: 'Battle ended', battle });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
const Battle = require(‘…/models/battle’);
const Character = require(‘…/models/character’);
exports.startBattle = async (req, res) => {
const { characterId, enemy } = req.body;
try {
const battle = new Battle({ characterId, enemy, result: 'ongoing' });
await battle.save();
res.status(201).json({ message: 'Battle started', battle });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.performTurn = async (req, res) => {
const { battleId } = req.params;
const { action } = req.body;
try {
const battle = await Battle.findById(battleId);
// Implement turn-based logic (e.g., reduce enemy HP, check for win/lose conditions)
// Example: action could be 'attack', 'defend', etc.
battle.save();
res.status(200).json({ message: 'Turn performed', battle });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.endBattle = async (req, res) => {
const { battleId } = req.params;
const { result } = req.body;
try {
const battle = await Battle.findById(battleId);
battle.result = result; // 'win' or 'lose'
if (result === 'win') {
// Give rewards to the character
const character = await Character.findById(battle.characterId);
character.experience += battle.rewards.experience;
// Add other rewards logic here
await character.save();
}
await battle.save();
res.status(200).json({ message: 'Battle ended', battle });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
任务系统
我们将实现任务系统，包括主线任务和支线任务。
api/routes/quests.js
const express = require(‘express’);
const router = express.Router();
const questController = require(‘…/…/controllers/questController’);
router.get(‘/’, questController.getQuests);
router.post(‘/complete/:questId’, questController.completeQuest);
module.exports = router;
controllers/questController.js
const Quest = require(‘…/models/quest’);
const Character = require(‘…/models/character’);
exports.getQuests = async (req, res) => {
try {
const quests = await Quest.find();
res.status(200).json({ quests });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
exports.completeQuest = async (req, res) => {
const { questId } = req.params;
const { characterId } = req.body;
try {
const quest = await Quest.findById(questId);
const character = await Character.findById(characterId);
character.experience += quest.rewards.experience;
// Add other rewards logic here
await character.save();
res.status(200).json({ message: 'Quest completed', character });
} catch (error) {
res.status(500).json({ error: error.message });
}
};
由于篇幅过长，代码较多，本教程未完！
请参见手把手教你使用cocos和node开发一款属于自己的魔兽世界手游【教程二】
7052
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
