Author: michaldrozd

pragma solidity ^0.4.24;

contract ZombieSurvival {
    //Struct to hold the information of a player
    struct Player {
        address owner;
        uint health;
        uint ammo;
        uint score;
        mapping(string => uint) inventory;
        mapping(string => uint) upgrades;
    }

    //Mapping to hold all the players
    mapping(address => Player) public players;

    //Event to be emitted when player shoots a zombies
    event Shoot(address shooter);
    //Event to be emitted when player's health changes
    event HealthChanged(address player, uint newHealth);
    //Event to be emitted when player's score changes
    event ScoreChanged(address player, uint newScore);

    //Function to join the game
    function joinGame() public {
        require(players[msg.sender].owner == address(0));
        players[msg.sender].owner = msg.sender;
        players[msg.sender].health = 100;
        players[msg.sender].ammo = 20;
        players[msg.sender].score = 0;
    }

    //Function to shoot a zombies
    function shoot() public {
        require(players[msg.sender].health > 0);
        require(players[msg.sender].ammo > 0);
        //decrement ammo
        players[msg.sender].ammo--;
        //increment score
        players[msg.sender].score++;
        //check if the player hit a zombies
        if (checkHit()) {
            //decrement health
            players[msg.sender].health -= 10;
            emit HealthChanged(msg.sender, players[msg.sender].health);
            checkDeath();
        }
        emit ScoreChanged(msg.sender, players[msg.sender].score);
        emit Shoot(msg.sender);
    }

    //Function to acquire an item
    function acquireItem(string _itemName) public {
        require(players[msg.sender].score >= getItemCost(_itemName));
        require(players[msg.sender].inventory[_itemName] == 0);
        players[msg.sender].score -= getItemCost(_itemName);
        players[msg.sender].inventory[_itemName]++;
    }
    //Function to upgrade a weapon
    function upgradeWeapon(string _weaponName) public {
        require(players[msg.sender].score >= getWeaponUpgradeCost(_weaponName));
        uint currentLevel = getWeaponLevel(msg.sender, _weaponName);
        require(currentLevel != 0);
        require(currentLevel < maxWeaponLevel);
        players[msg.sender].score -= getWeaponUpgradeCost(_weaponName);
        players[msg.sender].upgrades[_weaponName]++;
    }
    //Function to complete a quest
    function completeQuest(string _questName) public {
        require(players[msg.sender].health > 0);
        require(players[msg.sender].ammo > 0);
        //check if the player completed the quest
        if (checkQuestCompletion(_questName)) {
            //increment score
            players[msg.sender].score += getQuestReward(_questName);
            //increment health
            players[msg.sender].health += getQuestHealthReward(_questName);
            //increment ammo
            players[msg.sender].ammo += getQuestAmmoReward(_questName);
        }
    }
    //Function to buy TRX from the shop
    function buyTRX(uint _amount) public {
        require(msg.sender.transfer(_amount));
    }
    //Function to sell TRX to the shop
    function sellTRX(uint _amount) public payable {
        require(msg.value == _amount);
    }
    //Function to check if the player completed a quest
    function checkQuestCompletion(string _questName) private view returns (bool) {
        uint random = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 2;
        if (random == 1) return true;
        else return false;
    }
    //Function to get the cost of an item
    function getItemCost(string _itemName) public view returns (uint) {
        if (_itemName == "medkit") return 1000;
        if (_itemName == "ammo_box") return 5000;
        if (_itemName == "first_aid_kit") return 10000;
    }
    //Function to get the cost of upgrading a weapon
    function getWeaponUpgradeCost(string _weaponName) public view returns (uint) {
        if (_weaponName == "pistol") return 500;
        if (_weaponName == "shotgun") return 2500;
        if (_weaponName == "rifle") return 5000;
    }
    //Function to get the reward of a quest
    function getQuestReward(string _questName) public view returns (uint) {
        if (_questName == "survival") return 100;
        if (_questName == "zombie_hunt") return 250;
        if (_questName == "rescue_mission") return 500;
    }
    //Function to get the health reward of a quest
    function getQuestHealthReward(string _questName) public view returns (uint) {
        if (_questName == "survival") return 10;
        if (_questName == "zombie_hunt") return 25;
        if (_questName == "rescue_mission") return 50;
    }
    //Function to get the ammo reward of a quest
    function getQuestAmmoReward(string _questName) public view returns (uint) {
        if (_questName == "survival") return 5;
        if (_questName == "zombie_hunt") return 10;
        if (_questName == "rescue_mission") return 20;
    }
    //Function to get the current level of a weapon
    function getWeaponLevel(address _owner, string _weaponName) public view returns (uint) {
        return players[_owner].upgrades[_weaponName];
    }
    //Function to login and get a daily reward
    function login() public {
        require(players[msg.sender].health > 0);
        require(players[msg.sender].ammo > 0);
        //increment score
        players[msg.sender].score += 10;
        //increment health
        players[msg.sender].health += 5;
        //increment ammo
        players[msg.sender].ammo += 2;
    }
    //Function to save the game progress
    function saveProgress() public {
        //Save the player's data to storage or IPFS
    }
    //Function to load the game progress
    function loadProgress() public view returns (bool) {
        //Load the player's data from storage or IPFS
        //if the data is successfully loaded return true, else return false
    }
    //Function to trade with another player
    function trade(address _otherPlayer, string _itemName, uint _amount) public {
        require(players[msg.sender].inventory[_itemName] >= _amount);
        require(players[_otherPlayer].inventory[_itemName] >= _amount);
        players[msg.sender].inventory[_itemName] -= _amount;
        players[_otherPlayer].inventory[_itemName] += _amount;
    }
}

pragma solidity ^0.4.24;

contract Kingdoms {
    // Struct to hold the information of a Kingdom
    struct Kingdom {
        address owner;
        uint army;
        uint gold;
        uint resources;
        mapping(string => uint) structures;
    }

    // Mapping to hold all the Kingdoms
    mapping(address => Kingdom) public kingdoms;

    // Event to be emitted on attack
    event Attack(address attacker, address defender, bool success);
    //Event to be emitted on structure building
    event Build(address owner, string structureName);

    // Function to create a new Kingdom
    function createKingdom(uint initialArmy, uint initialGold, uint initialResources) public {
        require(kingdoms[msg.sender].owner == address(0));
        kingdoms[msg.sender].owner = msg.sender;
        kingdoms[msg.sender].army = initialArmy;
        kingdoms[msg.sender].gold = initialGold;
        kingdoms[msg.sender].resources = initialResources;
    }

    // Function to attack another Kingdom
    function attack(address _defender) public {
        require(kingdoms[msg.sender].army > 0);
        require(kingdoms[_defender].owner != address(0));
        //calculate the success of the attack
        bool success = calculateAttack(kingdoms[msg.sender].army, kingdoms[_defender].army);
        if (success) {
            kingdoms[_defender].army = kingdoms[_defender].army / 2;
            kingdoms[msg.sender].gold += kingdoms[_defender].gold;
            kingdoms[msg.sender].resources += kingdoms[_defender].resources;
        } else {
            kingdoms[msg.sender].army = kingdoms[msg.sender].army / 2;
        }
        emit Attack(msg.sender, _defender, success);
    }
    // Function to build structures in a Kingdom
    function buildStructure(string _structureName) public {
        require(kingdoms[msg.sender].gold >= getStructureCost(_structureName));
        require(getStructureLevel(msg.sender, _structureName) == 0);
        kingdoms[msg.sender].gold -= getStructureCost(_structureName);
        kingdoms[msg.sender].structures[_structureName] = 1;
        emit Build(msg.sender, _structureName);
    }

    // Function to upgrade a structure in a Kingdom
    function upgradeStructure(string _structureName) public {
        require(kingdoms[msg.sender].gold >= getStructureUpgradeCost(_structureName));
        uint currentLevel = getStructureLevel(msg.sender, _structureName);
        require(currentLevel != 0);
        require(currentLevel < maxStructureLevel);
        kingdoms[msg.sender].gold -= getStructureUpgradeCost(_structureName);
        kingdoms[msg.sender].structures[_structureName]++;
    }

    // Function to get the current level of a structure in a Kingdom
    function getStructureLevel(address _owner, string _structureName) public view returns (uint) {
        return kingdoms[_owner].structures[_structureName];
    }

    // Function to get the cost of building a structure
    function getStructureCost(string _structureName) public view returns (uint) {
        if (_structureName == "wall") return 1000;
        if (_structureName == "tower") return 5000;
        if (_structureName == "barracks") return 10000;
    }

    // Function to get the cost of upgrading a structure
    function getStructureUpgradeCost(string _structureName) public view returns (uint) {
        if (_structureName == "wall") return 500;
        if (_structureName == "tower") return 2500;
        if (_structureName == "barracks") return 5000;
    }

    // Function to calculate the success of the attack
    function calculateAttack(uint attackerArmy, uint defenderArmy) private view returns (bool) {
        uint random = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % 2;
        if (random == 1 && attackerArmy > defenderArmy) return true;
        else return false;
    }
}

// rock-paper-scissors game in EOS

#include <eosiolib/eosio.hpp>
#include <eosiolib/print.hpp>

using namespace eosio;

class rps : public contract {
 public:
	using contract::contract;

	[[eosio::action]]
	void play(name player1, name player2, std::string choice1, std::string choice2) {
		require_auth(player1);
		require_auth(player2);

		eosio_assert(choice1 == "rock" || choice1 == "paper" || choice1 == "scissors", "Invalid choice1");
		eosio_assert(choice2 == "rock" || choice2 == "paper" || choice2 == "scissors", "Invalid choice2");

		game_index games(_self, _self.value);
		games.emplace(player1, [&](auto& g) {
			g.key = games.available_primary_key();
			g.player1 = player1;
			g.player2 = player2;
			g.choice1 = choice1;
			g.choice2 = choice2;
		});
	}

	[[eosio::action]]
	void reveal(uint64_t key) {
		game_index games(_self, _self.value);
		auto itr = games.find(key);
		eosio_assert(itr != games.end(), "Game not found");

		name p1 = itr->player1;
		name p2 = itr->player2;
		require_auth(p1);
		require_auth(p2);

		endgame(itr);
	}

 private:
	struct [[eosio::table]] game {
		uint64_t key;
		name player1;
		name player2;
		std::string choice1;
		std::string choice2;

		uint64_t primary_key() const { return key; }
	};

	typedef eosio::multi_index<"games"_n, game> game_index;

	void endgame(game_index::const_iterator itr) {
		name winner;
		std::string choice1 = itr->choice1;
		std::string choice2 = itr->choice2;
		if (choice1 == choice2) {
			winner = "tie"_n;
		} else if (choice1 == "rock" && choice2 == "scissors" || choice1 == "paper" && choice2 == "rock" || choice1 == "scissors" && choice2 == "paper") {
			winner = itr->player1;
		} else {
			winner = itr->player2;
		}

		print("Winner: ", winner);
	}
};

EOSIO_DISPATCH(rps, (play)(reveal))

#include <eosio/eosio.hpp>

using namespace eosio;

CONTRACT token
: public contract {
public:
using contract::contract;

ACTION create(name issuer, asset maximum_supply);

ACTION issue(name to, asset quantity, string memo);

ACTION transfer(name from, name to, asset quantity, string memo);

private:
TABLE account{
	asset    balance;
	uint64_t primary_key()const { return balance.symbol.code().raw(); }
};

TABLE currency_stats{
	asset          supply;
	asset          max_supply;
	name           issuer;
	uint64_t primary_key()const { return supply.symbol.code().raw(); }
};

typedef eosio::multi_index<"accounts"_n, account> accounts;
typedef eosio::multi_index<"stat"_n, currency_stats> stats;

void sub_balance(name owner, asset value);

void add_balance(name owner, asset value, name ram_payer);

};

ACTION token::create(name issuer, asset maximum_supply)
{
	require_auth(issuer);
	auto sym = maximum_supply.symbol;
	eosio::check(sym.is_valid(), "invalid symbol name");
	eosio::check(maximum_supply.is_valid(), "invalid supply");
	eosio::check(maximum_supply.amount > 0, "max-supply must be positive");

	stats statstable(get_self(), sym.code().raw());
	auto existing = statstable.find(sym.code().raw());
	eosio::check(existing == statstable.end(), "token with symbol already exists");

	statstable.emplace(issuer, [&](auto& s)
	{
		s.supply = asset{ 0, sym };
		s.max_supply = maximum_supply;
		s.issuer = issuer;
	});
}

ACTION token::issue(name to, asset quantity, string memo)
{
	auto sym = quantity.symbol;
	eosio::check(sym.is_valid(), "invalid symbol name");
	eosio::check(memo.size() <= 256, "memo has more than 256 bytes");

	stats statstable(get_self(), sym.code().raw());
	auto existing = statstable.find(sym.code().raw());
	eosio::check(existing != statstable.end(), "token with symbol does not exist, create token before issue");
	const auto& st = *existing;

	require_auth(st.issuer);
	eosio::check(quantity.is_valid(), "invalid quantity");
	eosio::check(quantity.amount > 0, "must issue positive quantity");

	eosio::check(quantity.symbol == st.supply.symbol, "symbol precision mismatch");
	eosio::check(quantity.amount <= st.max_supply.amount - st.supply.amount, "quantity exceeds available supply");
	statstable.modify(st, same_payer, [&](auto& s)
	{
		s.supply += quantity;
	});

	add_balance(to, quantity, st.issuer);
}

ACTION token::transfer(name from, name to, asset quantity, string memo)
{
	eosio::check(from != to, "cannot transfer to self");
	require_auth(from);
	eosio::check(is_account(to), "to account does not exist");
	auto sym = quantity.symbol.code();
	stats statstable(get_self(), sym.raw());
	const auto& st = statstable.get(sym.raw());
	require_recipient(from);
	require_recipient(to);

	eosio::check(quantity.is_valid(), "invalid quantity");
	eosio::check(quantity.amount > 0, "must transfer positive quantity");
	eosio::check(quantity.symbol == st.supply.symbol, "symbol precision mismatch");
	eosio::check(memo.size() <= 256, "memo has more than 256 bytes");

	sub_balance(from, quantity);
	add_balance(to, quantity, from);
}

void token::sub_balance(name owner, asset value)
{
	accounts from_acnts(get_self(), owner.value);

	const auto& from = from_acnts.get(value.symbol.code().raw(), "no balance object found");
	eosio::check(from.balance.amount >= value.amount, "overdrawn balance");

	from_acnts.modify(from, owner, [&](auto& a)
	{
		a.balance -= value;
	});
}

void token::add_balance(name owner, asset value, name ram_payer)
{
	accounts to_acnts(get_self(), owner.value);
	auto to = to_acnts.find(value.symbol.code().raw());
	if (to == to_acnts.end())
	{
		to_acnts.emplace(ram_payer, [&](auto& a)
		{
			a.balance = value;
		});
	}
	else
	{
		to_acnts.modify(to, same_payer, [&](auto& a)
		{
			a.balance += value;
		});
	}
}

module Main where

import Language.PlutusTx
import Language.PlutusTx.Prelude
import Language.PlutusTx.Builtins

data Auction = Auction {
    itemName :: String,
    itemDescription :: String,
    startPrice :: Integer,
    highestBid :: Integer,
    highestBidder :: Address
}

placeBid : Auction -> Integer -> (Boolean, Auction)
placeBid auction bid =
    if bid > highestBid auction then
        (True, auction { highestBid = bid, highestBidder = txSender })
    else
        (False, auction)

endAuction : Auction -> (Boolean, String)
endAuction auction =
    if txSender == highestBidder auction then
        (True, "Auction sold to " ++ show (highestBidder auction) ++ " for " ++ show (highestBid auction))
    else
        (False, "Auction not ended")

main : () -> ()
main _ =
    let
        auction = Auction {
            itemName = "My Item",
            itemDescription = "This is a very nice item",
            startPrice = 100,
            highestBid = 0,
            highestBidder = Address "0x0"
        }
    in
    trace auction
    trace $ placeBid auction 150

module Main where

import Language.PlutusTx
import Language.PlutusTx.Prelude
import Language.PlutusTx.Builtins

data Campaign = Campaign {
    campaignName :: String,
    campaignDescription :: String,
    targetFunding :: Integer,
    currentFunding :: Integer,
    deadline :: Integer
}

contribute : Campaign -> Integer -> (Boolean, Campaign)
contribute campaign amount =
    if (txTimestamp <= deadline campaign) && (currentFunding campaign + amount <= targetFunding campaign) then
        (True, campaign { currentFunding = currentFunding campaign + amount })
    else
        (False, campaign)

refund : Campaign -> Address -> (Boolean, Integer)
refund campaign contributor =
    if (txSender == contributor) && (currentFunding campaign < targetFunding campaign) then
        (True, currentFunding campaign)
    else
        (False, 0)

main : () -> ()
main _ =
    let
        campaign = Campaign {
            campaignName = "My Campaign",
            campaignDescription = "This is a very nice campaign",
            targetFunding = 1000,
            currentFunding = 0,
            deadline = 10000000000
        }
    in
    trace campaign
    trace $ contribute campaign 500

module Main where

import Language.PlutusTx
import Language.PlutusTx.Prelude
import Language.PlutusTx.Builtins

data Escrow = Escrow {
    buyer :: Address,
    seller :: Address,
    arbitrator :: Address,
    item :: String,
    amount :: Integer,
    status :: String
}

create : Address -> Address -> Address -> String -> Integer -> Escrow
create buyer seller arbitrator item amount =
    Escrow {
        buyer = buyer,
        seller = seller,
        arbitrator = arbitrator,
        item = item,
        amount = amount,
        status = "created"
    }

release : Escrow -> (Boolean, Escrow)
release escrow =
    if (txSender == buyer escrow) && (status escrow == "created") then
        (True, escrow { status = "released" })
    else
        (False, escrow)

refund : Escrow -> (Boolean, Escrow)
refund escrow =
    if (txSender == seller escrow) && (status escrow == "created") then
        (True, escrow { status = "refunded" })
    else
        (False, escrow)

arbitrate : Escrow -> (Boolean, Escrow)
arbitrate escrow =
    if (txSender == arbitrator escrow) && (status escrow == "created") then
        (True, escrow { status = "arbitrated" })
    else
        (False, escrow)

main : () -> ()
main _ =
    let
        escrow = create (Address "0x1") (Address "0x2") (Address "0x3") "My Item" 500
    in
    trace escrow
    trace $ release escrow