我是靠谱客的博主 满意香水,最近开发中收集的这篇文章主要介绍游戏领域区块链探索游戏领域区块链探索Netkiller Blockchain 手札,觉得挺不错的,现在分享给大家,希望可以做个参考。

概述

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

游戏领域区块链探索

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

Netkiller Blockchain 手札

本文作者最近在找工作,有意向致电 13113668890

Mr. Neo Chan, 陈景峯(BG7NYT)

中国广东省深圳市龙华新区民治街道溪山美地 518131 +86 13113668890 <netkiller@msn.com>

文档始创于2018-02-10

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

版权声明

转载请与作者联系,转载时请务必标明文章原始出处和作者信息及本声明。

 

 

http://www.netkiller.cnhttp://netkiller.github.iohttp://netkiller.sourceforge.net

http://www.netkiller.cn

http://netkiller.github.io

http://netkiller.sourceforge.net

 

 

微信订阅号 netkiller-ebook (微信扫描二维码)QQ:13721218 请注明“读者”QQ群:128659835 请注明“读者”

微信订阅号 netkiller-ebook (微信扫描二维码)

QQ:13721218 请注明“读者”

QQ群:128659835 请注明“读者”

 

http://www.netkiller.cn

http://netkiller.github.io

http://netkiller.sourceforge.net

 

微信订阅号 netkiller-ebook (微信扫描二维码)

QQ:13721218 请注明“读者”

QQ群:128659835 请注明“读者”

$Data$

内容摘要

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

为什么会写区块链电子书?因为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://my.oschina.net/neochen/blog/1631914

最后

以上就是满意香水为你收集整理的游戏领域区块链探索游戏领域区块链探索Netkiller Blockchain 手札的全部内容,希望文章能够帮你解决游戏领域区块链探索游戏领域区块链探索Netkiller Blockchain 手札所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错,欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(47)

评论列表共有 0 条评论

立即
投稿
返回
顶部