Shulou(Shulou.com)06/01 Report--

Today, I will talk to you about how to develop Pokemon games based on Ethernet Square. Many people may not know much about it. In order to make you understand better, the editor has summarized the following content for you. I hope you can get something according to this article.

We'll learn how to develop an ERC721-based Monster Battle Mini Game, similar to a decentralized version of the Pok é mon game. The development tool used in the tutorial is Truffle, the development language is Solidity, and the third-party library is OpenZeppelin.

1. Create an ERC721 version of the Pok é mon game project

We use the Truffle development framework to create this ERC721-based Pokemon game project.

First create a new folder, and then initialize the Truffle project:

~ $mkdir ethermon~$ cd ethermon/~/ethermon$ truffle init2, using OpenZeppelin's mature ERC721 contract implementation code

In order to use OpenZepplin, we need to import this library using npm. Let's initialize npm and then get the correct version of OpenZeppelin. We are using version 2.5.0 of OpenZeppelin, so you need to use version 0.5.5 of the Solidity compiler:

~ / ethermon$ npm init~/ethermom$ npm install @ openzeppelin/contracts@2.5.0-- save3, ERC721 contract for extending OpenZeppelin

In our contracts/ folder, first create a new file, ethermon.sol. To use the functionality in the OpenZeppelin code, we need to introduce and extend ERC721.sol.

The following code shows the contents of Ethermon.sol so far:

Pragma solidity ^ 0.5.5 × import "@ openzeppelin/contracts/token/ERC721/ERC721.sol"; contract Ethermon is ERC721 {}

First use truffle compile to check and make sure our contract is compiled correctly. Next, we write a migration script to deploy the contract to the local block chain. Create a new migration file, 2_deploy_contracts.js, in the migrations/ directory as follows:

Const Ethermon = artifacts.require ("Ethermon"); module.exports = function (deployer) {deployer.deploy (Ethermon);}

To ensure that your truffle-config.js configuration can be correctly connected to the local block chain, you can use truffle test to test it first.

4. Write the implementation logic of Pokemon for ERC721.

We need Ethermon contracts to achieve the following functions:

Create a new monster.

Assign a monster to its master

The master can arrange monsters to fight.

Let's implement the first function first. We need to keep all the monsters in an array in the Ethermon contract. The data related to monsters that need to be saved include names, levels, etc. So we use a structure.

The code for the Ethermon contract so far is as follows:

Pragma solidity ^ 0.5.5 X import "@ openzeppelin/contracts/token/ERC721/ERC721.sol"; contract Ethermon is ERC721 {struct Monster {string name; uint level;} Monster [] public monsters; address public gameOwner; constructor () public {gameOwner = msg.sender;} function createNewMonster (string memory _ name, address _ to) public {require (msg.sender = = gameOwner, "Only game owner can create new monsters") Uint id = monsters.length; monsters.push (Monster (_ name, 1)); _ safeMint (_ to, id);}}

The Monster structure is defined on line 7, and the array is defined on line 12. We also added a gameOwner variable to hold the deployment account for the Ethermon contract. Line 19 begins with the implementation of the createNewMonster () function, which is responsible for creating new monsters.

First, it checks whether the function is called by the deployment account of the contract. Then generate an ID for the new monster, store the new monster in an array, and finally use the _ safeMint () function to assign the newly created monster to its owner.

_ safeMint () is a function implemented in the ERC721 contract we inherited. It securely assigns an ID to a specified account and checks whether the ID already exists before assigning it.

Well, now we can create a new monster and assign it to the specified account. It's time to move on to step three: battle logic.

5. The realization of battle logic of Pokemon game in ERC721 version.

As mentioned earlier, our fighting logic determines how much a monster can be promoted. Higher-level monsters can win and rise to two levels, while loser monsters can be promoted to one level. If two monsters are at the same level, the attacker wins. The following code shows the implementation of the combat logic in the contract:

Pragma solidity ^ 0.5.5 X import "@ openzeppelin/contracts/token/ERC721/ERC721.sol"; contract Ethermon is ERC721 {struct Monster {string name; uint level;} Monster [] public monsters; address public gameOwner; constructor () public {gameOwner = msg.sender;} function battle (uint _ attackingMonster, uint _ defendingMonster) public {Monster storage attacker = monsters [_ attackingMonster]; Monster storage defender = monsters [_ defendingMonster] If (attacker.level > = defender.level) {attacker.level + = 2; defender.level + = 1;} else {attacker.level + = 1; attacker.level + = 2;}} function createNewMonster (string memory _ name, address _ to) public {require (msg.sender = = gameOwner, "Only game owner can create new monsters") Uint id = monsters.length; monsters.push (Monster (_ name, 1)); _ safeMint (_ to, id);}}

Line 19 begins to show the fighting logic of monsters. Currently, any account can call the battle () method. However, we need to limit this to allow only the owner of the attacking monster to call this method. To do this, we can add a modifier that uses the ownerOf () function in the ERC721.sol contract to check the calling account. The following code shows the changes in this section:

Pragma solidity ^ 0.5.5 X import "@ openzeppelin/contracts/token/ERC721/ERC721.sol"; contract Ethermon is ERC721 {struct Monster {string name; uint level;} Monster [] public monsters; address public gameOwner; constructor () public {gameOwner = msg.sender;} modifier onlyOwnerOf (uint _ monsterId) {require (ownerOf (_ monsterId) = = msg.sender, "Must be owner of monster to battle"); _ } function battle (uint _ attackingMonster, uint _ defendingMonster) public onlyOwnerOf (_ attackingMonster) {Monster storage attacker = monsters [_ attackingMonster]; Monster storage defender = monsters [_ defendingMonster]; if (attacker.level > = defender.level) {attacker.level + = 2; defender.level + = 1;} else {attacker.level + = 1; attacker.level + = 2 }} function createNewMonster (string memory _ name, address _ to) public {require (msg.sender = = gameOwner, "Only game owner can create new monsters"); uint id = monsters.length; monsters.push (Monster (_ name, 1)); _ safeMint (_ to, id);}}

Okay! We have completed an ERC721 version of the monster battle game similar to Pokemon, although it is still very rough!

After reading the above, do you have any further understanding of how to develop Pokemon games based on Ethernet Square? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.