lordless.io Open in urlscan Pro
2606:4700:3031::6815:1cf2  Public Scan

URL: https://lordless.io/
Submission: On April 08 via api from US — Scanned from DE

Form analysis 0 forms found in the DOM

Text Content

crosscheckmarkid-Data-Analysisid-Guided-trafficid-Precise-deliveryid-User-interactionquestionicon-logo-imageicon-logo-textemailredditmediumfacebooktelegramtwitterlinkedingithubgoogle+wechatetherscanyoutubelocation
Promotions Taverns Marketplace
 * Opensea
 * Spiderdex

WHITEPAPER(EN) WHITEPAPER(中文) Whitepaper
 * English
 * 中文版

中文

Be a bounty hunter in my tavern.

Get started



PLAY YOUR ROLE

LORDLESS is a fantasy game where you rule your Tavern.
Recruit bounty hunters, send them on quests, and reap the rewards. You can also
play a bounty hunter to complete the quests and get the rewards.

 * Host
   
   The host posts a quest to reach the desired goal. In the world of LORDLESS,
   the Quest host is the publisher of all quests and the provider of all quest
   rewards.

 * Tavern master
   
   The owner of a tavern is the Tavern master. Once you become a master, you get
   the right to buy and sell the tavern, as well as take the cut of rewards.

 * Bounty hunter
   
   Bounty hunters can take the quests posted by the host in different taverns.
   When they complete the quest, the bounty hunter will reap a corresponding
   reward.


TRADING ON OPENSEA

OpenSea is the world’s largest digital marketplace for crypto collectibles. You
can buy, sell, and discover exclusive digital assets.

Explore the sea

 * #800
   
   
   SHANGHAI CIRCUS WORLD
   
    121.446536, 31.2797366
   
   
   0x35d4**09
   
   
    * 710
      
      Max AP
   
    * 84
      
      Level
   
    * 53
      
      Hunters

 * #1800
   
   
   SHANGHAI ART MUSEUM
   
    121.490278, 31.1864101
   
   
   0x35d4**09
   
   
    * 607
      
      Max AP
   
    * 71
      
      Level
   
    * 50
      
      Hunters

 * #0
   
   
   ORIENTAL PEARL TOWER
   
    121.495376, 31.2416800
   
   
   0x35d4**09
   
   
    * 1,121
      
      Max AP
   
    * 131
      
      Level
   
    * 496
      
      Hunters

 * #101
   
   
   JING'AN TEMPLE
   
    12144.0712, 31.2253722
   
   
   0x35d4**09
   
   
    * 1,044
      
      Max AP
   
    * 122
      
      Level
   
    * 148
      
      Hunters

 * #100
   
   
   BUND 27, THE HOUSE OF ROOSEVELT
   
    121.485552, 31.2423914
   
   
   0x35d4**09
   
   
    * 949
      
      Max AP
   
    * 111
      
      Level
   
    * 107
      
      Hunters

 * #801
   
   
   XUJIAHUI SAINT IGNATIUS CATHEDRAL
   
    121.431471, 31.1930143
   
   
   0x35d4**09
   
   
    * 684
      
      Max AP
   
    * 80
      
      Level
   
    * 48
      
      Hunters

 * #1801
   
   
   HENGSHAN MOLLER VILLA HOTEL SHANGHAI
   
    121.451688, 31.2248880
   
   
   0x1a08**ed
   
   
    * 581
      
      Max AP
   
    * 68
      
      Level
   
    * 47
      
      Hunters

 * #802
   
   
   CITY GOD TEMPLE OF SHANGHAI
   
    121.488054, 31.2277205
   
   
   0x35d4**09
   
   
    * 616
      
      Max AP
   
    * 73
      
      Level
   
    * 34
      
      Hunters


SMART CONTRACT

LORDLESS is built entirely on Ethereum. All smart contracts are interrelated to
build an overall decentralized system.

View on GitHub

    pragma solidity ^0.4.24;


    import "../lib/SafeMath.sol";
    import "./ITavern.sol";

    contract TavernBase is ITavern {
      using SafeMath for *;

      struct Tavern {
        uint256 initAt; // The time of tavern init
        int longitude; // The longitude of tavern
        int latitude; // The latitude of tavern
        uint8 popularity; // The popularity of tavern
        uint256 activeness; // The activeness of tavern
      }

      uint8 public constant decimals = 16; // longitude latitude decimals

      mapping(uint256 => Tavern) internal tokenTaverns;

      function _tavern(uint256 _tokenId) internal view returns (uint256, int, int, uint8, uint256) {
        Tavern storage tavern = tokenTaverns[_tokenId];
        return (
          tavern.initAt,
          tavern.longitude,
          tavern.latitude,
          tavern.popularity,
          tavern.activeness
        );
      }

      function _isBuilt(uint256 _tokenId) internal view returns (bool){
        Tavern storage tavern = tokenTaverns[_tokenId];
        return (tavern.initAt > 0);
      }

      function _build(
        uint256 _tokenId,
        int _longitude,
        int _latitude,
        uint8 _popularity
        ) internal {

        // Check whether tokenid has been initialized
        require(!_isBuilt(_tokenId));
        require(_isLongitude(_longitude));
        require(_isLatitude(_latitude));
        require(_popularity != 0);
        uint256 time = block.timestamp;
        Tavern memory tavern = Tavern(
          time, _longitude, _latitude, _popularity, uint256(0)
        );
        tokenTaverns[_tokenId] = tavern;
        emit Build(time, _tokenId, _longitude, _latitude, _popularity);
      }

      function _batchBuild(
        uint256[] _tokenIds,
        int[] _longitudes,
        int[] _latitudes,
        uint8[] _popularitys
        ) internal {
        uint256 i = 0;
        while (i < _tokenIds.length) {
          _build(
            _tokenIds[i],
            _longitudes[i],
            _latitudes[i],
            _popularitys[i]
          );
          i += 1;
        }


      }

      function _activenessUpgrade(uint256 _tokenId, uint256 _deltaActiveness) internal {
        require(_isBuilt(_tokenId));
        Tavern storage tavern = tokenTaverns[_tokenId];
        uint256 oActiveness = tavern.activeness;
        uint256 newActiveness = tavern.activeness.add(_deltaActiveness);
        tavern.activeness = newActiveness;
        tokenTaverns[_tokenId] = tavern;
        emit ActivenessUpgrade(_tokenId, oActiveness, newActiveness);
      }
      function _batchActivenessUpgrade(uint256[] _tokenIds, uint256[] __deltaActiveness) internal {
        uint256 i = 0;
        while (i < _tokenIds.length) {
          _activenessUpgrade(_tokenIds[i], __deltaActiveness[i]);
          i += 1;
        }
      }

      function _popularitySetting(uint256 _tokenId, uint8 _popularity) internal {
        require(_isBuilt(_tokenId));
        uint8 oPopularity = tokenTaverns[_tokenId].popularity;
        tokenTaverns[_tokenId].popularity = _popularity;
        emit PopularitySetting(_tokenId, oPopularity, _popularity);
      }

      function _batchPopularitySetting(uint256[] _tokenIds, uint8[] _popularitys) internal {
        uint256 i = 0;
        while (i < _tokenIds.length) {
          _popularitySetting(_tokenIds[i], _popularitys[i]);
          i += 1;
        }
      }

      function _isLongitude (
        int _param
      ) internal pure returns (bool){

        return(
          _param <= 180 * int(10 ** uint256(decimals))&&
          _param >= -180 * int(10 ** uint256(decimals))
          );
      }

      function _isLatitude (
        int _param
      ) internal pure returns (bool){
        return(
          _param <= 90 * int(10 ** uint256(decimals))&&
          _param >= -90 * int(10 ** uint256(decimals))
          );
        }
      }
    
  

TavernBase.solhosted with byGitHub

view raw




PARTNER

 * 
 * 
 * 

 * 
 * 

 * 
 * 
 * 
 * 

 * LORDLESS
 * Game
 * Taverns
 * Marketplace
 * Home

 * User
 * Overview
 * Candy
 * Tasks
 * Taverns
 * Authorization
 * Activity

 * About
 * Guide
 * FAQs

 * Whitepaper
 * English
 * 中文



Newsletter

The latest LORDLESS news, articles, and resources, sent straight to your inbox
every month.



Subscribe


Copyright © 2017 - 2019 LORDLESS. All right reserved

Term of use & Privacy policy