游戏领域区块链探索

D小游 · 发表于 2018-3-12 17:42:53

文/Mr. Neo Chan, 陈景峯

本文节选自电子书《Netkiller Blockchain 手札》

中国广东省深圳市龙华新区民治街道溪山美地
518131
+86 13113668890

<netkiller@msn.com>

文档始创于2018-02-10

版权 © 2018 Netkiller(Neo Chan). All rights reserved.

版权声明

内容摘要

这一部关于区块链开发及运维的电子书。

为什么会写区块链电子书？因为2018年是区块链年。

这本电子书是否会出版（纸质图书）？不会，因为互联网技术更迭太快，纸质书籍的内容无法实时更新，一本书动辄百元，很快就成为垃圾，你会发现目前市面的上区块链书籍至少是一年前写的，内容已经过时，很多例子无法正确运行。所以我不会出版，电子书的内容会追逐技术发展，及时跟进软件版本的升级，做到内容最新，至少是主流。

这本电子书与其他区块链书籍有什么不同？市面上大部分区块链书籍都是用2/3去讲区块链原理，只要不到 1/3 的干货，干货不够理论来凑，通篇将理论或是大谈特谈区块链行业，这些内容更多是头脑风暴，展望区块链，均无法落地实施。本书与那些书籍完全不同，不讲理论和原理，面向应用落地，注重例子，均是干货。

电子书更新频率？每天都会有新内容加入，更新频率最迟不会超过一周，更新内容请关注 https://github.com/netkiller/netkiller.github.io/commits/master

本文采用碎片化写作，原文会不定期更新，请尽量阅读原文。

http://www.netkiller.cn/blockchain/index.html

您的打赏是我的写作动力：http://www.netkiller.cn/blockchain/donations.html

-------------------------

33.4. 游戏领域区块链探索

如何将区块链嫁接到游戏领域，我做了很多思考，经过分析总结，发现下面几项内容非常适合上链。

上链内容

积分代币

如果说区块链应用于游戏领域，可能99%的人首先会想到是代币，的确游戏领域实施区块链连，代币必不可少。但是区块链不等于代币。

游戏装备
人物属性
关卡任务

下面我们要思考为什么需要将游戏数据放到区块链上，玩游戏的人都知道私服，私人架设游戏服务器，私服上玩游戏遇到最大的问题就是公平性。管理员可以随意调整服务器参数。

私服存在哪些问题呢？

修改游戏装备属性
修改生命与魔法值
关卡参数
人物属性
随意封账号

这是我们在私服上遇到的最大问题，那么官方服务器就公平吗？不一定，对于弱势的玩家只能相信游戏公司的承诺。

有了区块链技术，我们能做什么呢？例如我们将用户装备数据等数据上链，这样保证了装备永远属于玩家

区块链能做什么？

“点” 奖励采用代币实现，可以实现流通，兑换，消费等等......
爆出装备立即上链
用户等级属性上链
用户状态上链
关卡数据上链

凸显公平性，我们采用公链，查询用户数据可以使用接口，也可以直接到公链上查询。

下面详细讲解具体怎么实现。

33.4.1. 游戏代币

传统币 Point (点) 仅仅是一个数字，数字存在数据库中，例如

Username | Point (Integer)
-----------------------
Neo | 1000
Jam | 500

复制代码

因为仅仅是一个数字，管理员可以随意修改，黑客也可随意修改，例如

update member set point = 1000000000000 where username = 'Neo'

复制代码

瞬间就有 1000000000000 点。由于是在数据库中修改，没有日志，不知道谁操作的，可能是开发人员，可以是管理员，也可能是黑客。

如何消费“点呢”，例如消费 100 个点：

update member set point = point - 100 where username = 'Neo'

复制代码

传统币“点”，只是一个数字做加法和减法运算，安全性主要依赖于开发团队的能（期望别出BUG），运维团队的能力（被别黑客攻击），以及DBA（数据库管理员）的节操。

审计全靠开发人员打印出的日志。

现在我们再看看数字货币，跟很多朋友聊天中发现，他们还没有理解什么是币，他们认为数字代币花掉就没了（消失了），然后通过挖矿不停的产生新币，这种理解完全错误。

数字币是这样运作的，首先发行时设置了币的总量例如 1000000，然后将所有代币存入发行者账号，例如 account 1

account | coin
---------------------------------
account1 | 1000000
account2 | 0
account3 | 0
account4 | 0
account5 | 0

复制代码

现在 account2 游戏在线1小时奖励 10 个币，系统从账号account1转账5个币给 account2

account | coin
---------------------------------
account1 | 999990
account2 | 10
account3 | 0
account4 | 0
account5 | 0

复制代码

以此类推，从 account1 转账给其他账号。

account | coin
---------------------------------
account1 | 999960
account2 | 10
account3 | 10
account4 | 10
account5 | 10

复制代码

现在 account3 消费 5个币买了装备。从 account3 转 5 个币到 account1

account | coin
---------------------------------
account1 | 999965
account2 | 10
account3 | 5
account4 | 10
account5 | 10

复制代码

现在你应该看懂了把，代币是流通的，总量是不变的。account1 账号负责币的发行，回收等等工作。

同时任何转账将产生区块，历史数据永久记录。

下面是一个高级代币合约，地址https://github.com/ibook/NetkillerAdvancedToken

pragma solidity ^0.4.20;
/******************************************/
/* Netkiller ADVANCED TOKEN */
/******************************************/
/* Author netkiller <netkiller@msn.com> */
/* Home http://www.netkiller.cn */
/* Version 2018-03-05 */
/* Version 2018-03-06 - Add Global lock */
/******************************************/
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract NetkillerAdvancedToken {
address public owner;
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 2;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 public sellPrice;
uint256 public buyPrice;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
bool lock = true;
/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
function NetkillerAdvancedToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
owner = msg.sender;
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier isLock {
require(!lock);
_;
}
function setLock(bool _lock) onlyOwner {
lock = _lock;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) isLock internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
Transfer(_from, _to, _value);
}
/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return true;
}
/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
Burn(_from, _value);
return true;
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
/// @notice Buy tokens from contract by sending ether
function buy() payable public {
uint amount = msg.value / buyPrice; // calculates the amount
_transfer(this, msg.sender, amount); // makes the transfers
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
require(this.balance >= amount * sellPrice); // checks if the contract has enough ether to buy
_transfer(msg.sender, this, amount); // makes the transfers
msg.sender.transfer(amount * sellPrice); // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
transfer(_to, _value);
require(_to.call(_data));
return true;
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
transferFrom(_from, _to, _value);
require(_to.call(_data));
return true;
}
function approve(address _spender, uint256 _value, bytes _data) public returns (bool) {
require(_spender != address(this));
approve(_spender, _value);
require(_spender.call(_data));
return true;
}
}

复制代码

这个代币合约实现了，增发，减持，全局锁，账号冻结/解冻等等功能。

33.4.2. 玩家属性与游戏装备

下面的合约实现了游戏玩家上链，上链信息有玩家属性，例如肤色，眼睛，头发，血统等等。身上的穿戴物品包括武器等等。

pragma solidity ^0.4.20;
contract Player {
address public owner;
string name;
bool lock = false; //合约锁
uint number = 1;
uint attr_number = 1;
mapping (address => string) guestbook; //客户留言本
struct Attribute {
string key; // 属性的名字
string value; // 属性值
}
mapping (uint => Attribute) attribute;
struct Wear {
string name; // 装备名
string desciption; // 信息
string attribute; // 属性，存储json 数据。例如生命+10，魔法+5，冰冻系...
}
mapping (uint => Wear) wear;
function Player(string _name) public {
name = _name;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// 名称
function getName() public view returns(string){
return name;
}
function setLock(bool _lock) onlyOwner public {
lock = _lock;
}
// 增加人物属性，例如肤色，眼睛，头发等等
function putAttribute(string _key, string _value) onlyOwner public{
if(lock == false){
Attribute memory item = Attribute(_key, _value);
attribute[attr_number] = item;
attr_number = attr_number + 1;
}
}
// 获得属性
function getAttribute(uint _attr_number) public view returns(string, string) {
require(_attr_number < attr_number);
Attribute memory item = attribute[_attr_number];
return (item.key, item.value);
}
// 增加装备信息，穿戴物品，武器，
function putWear(string _name, string _description, string _attribute ) onlyOwner public{
if(lock == false){
Wear memory node = Wear(_name,_description,_attribute);
wear[number] = node;
number = number + 1;
lock = true;
}
}
// 获得信息
function getWear(uint _number) public view returns(string, string, string) {
require(_number < number);
Wear memory item = wear[_number];
return (item.name, item.desciption, item.attribute);
}
// 数量
function getWearCount() public view returns(uint){
return number;
}
// 客户留言
function addGuestbook(address _owner, string message) onlyOwner public{
guestbook[_owner] = message;
}
}

复制代码

33.4.3. 物品合成计算

区块链还可用于物品合成计算或者叫炼金术等等

很早的时候玩《暗黑破坏神III》里面已一个盒子，放入符文，可以根据公式合成其他属性的符文，我任务这个需求可以使用区块链来完成。

另外在我玩XBOX游戏《巫师3》中的炼金术，铸造，药水合成等等，我逗人都可以使用区块链完成。

33.4.4. 实施步骤

如果着手一个游戏项目上链，我们需要怎么做呢？

上链步骤

收集需求，收集公司的内部上链需求，听取所有部门的建议和诉求。

收集内容例如，代币发行量多少？代币小数位数，代币名称，是否会增发，是否需要冻结，代币怎样流通，怎样回收
Dapp 的 UI 设计，各种功能流程

分析需求，因为需求来自各种部门，各种岗位等等，他们不一定从事需求分析工作，所以我们需求对他们的需求过滤，分析，然后给出初步的PRD文档（产品需求文档）
根据收集的需求设计合约

根据需求设计Dapp
系统架构设计，软件架构设计，技术选型；需要考虑扩展性，灵活性，并发设计，数据安全，部署，后期监控，各种埋点（统计、监控）

准备环境，我们需要三个环境，开发，测试，生产（运营）。
项目启动

运维部门准备环境
开发部门开发合约和Dapp
测试部门准备测试用例，测试环境

测试

Alpha 阶段，将合约部署到测试环境，测试合约的每个函数的工作逻辑，确保无误。因为合约一旦部署将不能更改，只能废弃使用新的合约，所以这个测试步骤必须重视。
Beta 阶段，将测试合约部署到测试网，例如 Ropsten ，可以邀请公司内部测试

部署生产环境

部署合约，将合约部署到主网
Dapp 部署到生产环境。

验收测试，在生产环境做最后验收测试

原文地址：https://cloud.tencent.com/developer/article/1053033

账号		自动登录	找回密码
密码			立即注册

游戏领域区块链探索

相关帖子