317 lines
11 KiB
Solidity
317 lines
11 KiB
Solidity
// SPDX-License-Identifier: MIT
|
|
pragma solidity ^0.8.13;
|
|
|
|
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
|
|
import "@openzeppelin/contracts/access/Ownable.sol";
|
|
|
|
import {RaidGeldUtils} from "../src/RaidGeldUtils.sol";
|
|
import {Army, Player, Raider, Boss} from "../src/RaidGeldStructs.sol";
|
|
import "../src/Constants.sol";
|
|
|
|
contract RaidGeld is ERC20, Ownable, Constants {
|
|
uint256 public constant MANTISSA = 1e4;
|
|
uint256 public constant BUY_IN_AMOUNT = 0.0005 ether;
|
|
uint256 public immutable BUY_IN_DAO_TOKEN_AMOUNT;
|
|
uint256 public constant INITIAL_GELD = 500 * MANTISSA;
|
|
mapping(address => Player) private players;
|
|
mapping(address => Army) private armies;
|
|
mapping(address => Boss) private bosses;
|
|
|
|
// WETH
|
|
IWETH public immutable weth = IWETH(WETH);
|
|
// RGCVII token
|
|
ERC20 public daoToken;
|
|
// RGCVII pool
|
|
address public pool;
|
|
// Uniswap
|
|
ISwapRouter02 private constant router = ISwapRouter02(SWAP_ROUTER);
|
|
// Events
|
|
|
|
event PlayerRegistered(address indexed player, uint256 initialGeld);
|
|
event RaidPerformed(address indexed player, uint256 totalMinted, uint256 geldBalance);
|
|
event UnitAdded(
|
|
address indexed player,
|
|
uint8 unitType,
|
|
uint16 nUnits,
|
|
uint256 cost,
|
|
uint256 geldBalance,
|
|
uint16 molochDenierLevel,
|
|
uint16 apprenticeLevel,
|
|
uint16 anointedLevel,
|
|
uint16 championLevel
|
|
);
|
|
|
|
// Modifier for functions that should only be available to registered players
|
|
modifier onlyPlayer() {
|
|
require(players[msg.sender].created_at != 0, "Not an initiated player");
|
|
_;
|
|
}
|
|
|
|
modifier onlyActiveSession() {
|
|
require(players[msg.sender].active_session, "Session is not active, you need to buy into the game first");
|
|
_;
|
|
}
|
|
|
|
modifier newPlay() {
|
|
Player memory player = players[msg.sender];
|
|
bool notRegistered = player.created_at == 0;
|
|
bool returningPlayer = player.has_registered && !player.has_active_session;
|
|
require(notRegistered || returningPlayer, "Active session already in progress");
|
|
_;
|
|
}
|
|
|
|
constructor(address _daoToken, address _pool) ERC20("Raid Geld", "GELD") Ownable(msg.sender) {
|
|
daoToken = ERC20(_daoToken);
|
|
pool = _pool;
|
|
BUY_IN_DAO_TOKEN_AMOUNT = 500 * 10 ** daoToken.decimals();
|
|
}
|
|
|
|
function init_player(address player) private {
|
|
bool existing_player = players[player].is_registered;
|
|
|
|
// Mint some starting tokens to the player
|
|
_mint(player, INITIAL_GELD);
|
|
// Reset or set player
|
|
reset_player(player);
|
|
|
|
if (existing_player) {
|
|
// TODO: Emit new run
|
|
} else {
|
|
// Emit event
|
|
emit PlayerRegistered(msg.sender, INITIAL_GELD);
|
|
}
|
|
}
|
|
|
|
function reset_player(address addr) private {
|
|
Player memory player = players[addr];
|
|
uint32 current_n_runs = player.n_runs + 1;
|
|
uint256 current_total_rewards = player.total_rewards;
|
|
bool has_registered = player.is_registered;
|
|
// Set initial states
|
|
players[msg.sender] = Player({
|
|
total_minted: INITIAL_GELD,
|
|
created_at: block.timestamp,
|
|
last_raided_at: block.timestamp,
|
|
n_runs: current_n_runs,
|
|
total_rewards: current_total_rewards,
|
|
active_session: false
|
|
});
|
|
armies[msg.sender] = Army({
|
|
moloch_denier: Raider({level: 0}),
|
|
apprentice: Raider({level: 0}),
|
|
anointed: Raider({level: 0}),
|
|
champion: Raider({level: 0}),
|
|
profit_per_second: 0
|
|
});
|
|
bosses[msg.sender] = Boss({level: 0, variant: 0});
|
|
}
|
|
|
|
// New player want to register with ETH
|
|
function register_eth() external payable newPlay {
|
|
require(msg.value == BUY_IN_AMOUNT, "Incorrect buy in amount");
|
|
weth.deposit{value: BUY_IN_AMOUNT}();
|
|
weth.approve(address(router), BUY_IN_AMOUNT);
|
|
ISwapRouter02.ExactInputSingleParams memory params = ISwapRouter02.ExactInputSingleParams({
|
|
tokenIn: WETH,
|
|
tokenOut: DAO_TOKEN,
|
|
fee: 10000,
|
|
recipient: address(this),
|
|
amountIn: BUY_IN_AMOUNT,
|
|
amountOutMinimum: 0,
|
|
sqrtPriceLimitX96: 0
|
|
});
|
|
router.exactInputSingle(params);
|
|
init_player(msg.sender);
|
|
}
|
|
|
|
// New player wants to register with dao
|
|
function register_dao() external payable newPlay {
|
|
//@notice this is not safe for arbitrary tokens, which may not follow the interface eg. USDT
|
|
//@notice but should be fine for the DAO token
|
|
require(
|
|
daoToken.transferFrom(msg.sender, address(this), BUY_IN_DAO_TOKEN_AMOUNT), "Failed to transfer DAO tokens"
|
|
);
|
|
// Init player
|
|
init_player(msg.sender);
|
|
}
|
|
|
|
// Override for default number of decimals
|
|
function decimals() public view virtual override returns (uint8) {
|
|
return 4;
|
|
}
|
|
|
|
// Allows the owner to withdraw DAO tokens
|
|
function withdraw() external onlyOwner {
|
|
uint256 amount = daoToken.balanceOf(address(this));
|
|
daoToken.approve(address(this), amount);
|
|
daoToken.transferFrom(address(this), owner(), amount);
|
|
}
|
|
|
|
// Manual minting for itchy fingers
|
|
function raid() external onlyActiveSession {
|
|
performRaid();
|
|
}
|
|
|
|
// Helper so we can use it when buying units too
|
|
function performRaid(address player) private {
|
|
uint256 time_past = block.timestamp - players[player].last_raided_at;
|
|
uint256 new_geld = armies[player].profit_per_second * time_past;
|
|
_mint(player, new_geld);
|
|
players[player].last_raided_at = block.timestamp;
|
|
players[player].total_minted += new_geld;
|
|
emit RaidPerformed(player, players[player].total_minted, balanceOf(player));
|
|
}
|
|
|
|
// Function to get Player struct
|
|
function getPlayer(address addr) public view returns (Player memory) {
|
|
return players[addr];
|
|
}
|
|
|
|
// Function to get Army struct
|
|
function getArmy(address addr) public view returns (Army memory) {
|
|
return armies[addr];
|
|
}
|
|
|
|
// Quick fn to check if user is registered
|
|
function isRegistered(address addr) public view returns (bool) {
|
|
return players[addr].created_at != 0;
|
|
}
|
|
|
|
// Add a unit to your army
|
|
function addUnit(uint8 unit, uint16 n_units) external onlyActiveSession {
|
|
require(unit <= 3, "Unknown unit");
|
|
|
|
Army storage army = armies[msg.sender];
|
|
uint16 currentLevel = 0;
|
|
if (unit == 0) {
|
|
// moloch_denier
|
|
currentLevel = army.moloch_denier.level;
|
|
} else if (unit == 1) {
|
|
// apprentice
|
|
currentLevel = army.apprentice.level;
|
|
} else if (unit == 2) {
|
|
// anointed
|
|
currentLevel = army.anointed.level;
|
|
} else if (unit == 3) {
|
|
// champion
|
|
currentLevel = army.champion.level;
|
|
}
|
|
|
|
uint256 cost = RaidGeldUtils.calculateUnitPrice(unit, currentLevel, n_units);
|
|
|
|
// First trigger a raid so player receives what he is due at to this moment
|
|
uint256 time_past = block.timestamp - players[msg.sender].last_raided_at;
|
|
uint256 new_geld = armies[msg.sender].profit_per_second * time_past;
|
|
require(balanceOf(msg.sender) + new_geld >= cost, "Not enough GELD to add this unit");
|
|
uint256 totalMinted = performRaid(msg.sender);
|
|
|
|
// Emit event
|
|
|
|
// TODO: Since we are first minting then burning the token, this could be simplified
|
|
// by first calculating the difference and then minting / burning in just one operation
|
|
|
|
// then burn the cost of the new army
|
|
_burn(msg.sender, cost);
|
|
|
|
// Increase level
|
|
if (unit == 0) {
|
|
// moloch_denier
|
|
army.moloch_denier.level += n_units;
|
|
} else if (unit == 1) {
|
|
// apprentice
|
|
army.apprentice.level += n_units;
|
|
} else if (unit == 2) {
|
|
// anointed
|
|
army.anointed.level += n_units;
|
|
} else if (unit == 3) {
|
|
// champion
|
|
army.champion.level += n_units;
|
|
}
|
|
|
|
// update profite per second
|
|
army.profit_per_second = RaidGeldUtils.calculateProfitsPerSecond(army);
|
|
|
|
// Emit event
|
|
emit UnitAdded(
|
|
msg.sender,
|
|
unit,
|
|
n_units,
|
|
cost,
|
|
balanceOf(msg.sender),
|
|
army.moloch_denier.level,
|
|
army.apprentice.level,
|
|
army.anointed.level,
|
|
army.champion.level
|
|
);
|
|
}
|
|
|
|
function battle_with_boss() external onlyActiveSession {
|
|
// first perform raid
|
|
performRaid();
|
|
Boss memory boss_to_attack = bosses[msg.sender];
|
|
// calculate how much the player will put into battle
|
|
uint256 geld_to_burn = balanceOf(msg.sender) >= RaidGeldUtils.BOSS_POWERS[boss_to_attack.level]
|
|
? RaidGeldUtils.BOSS_POWERS[boss_to_attack.level]
|
|
: balanceOf(msg.sender);
|
|
bool hasWonBattle = RaidGeldUtils.calculateBossFight(
|
|
boss_to_attack.level, geld_to_burn, block.timestamp, block.difficulty
|
|
);
|
|
if (hasWonBattle) {
|
|
// Burn geld, get some sweet DAO Token and continue
|
|
_burn(msg.sender, geld_to_burn);
|
|
uint256 reward = RaidGeldUtils.calculateBossReward(boss_to_attack.level);
|
|
players[msg.sender].total_rewards += reward;
|
|
daoToken.transferFrom(address(this), msg.sender, reward);
|
|
} else {
|
|
// Whoops u die
|
|
player_dies(msg.sender);
|
|
}
|
|
}
|
|
|
|
function player_dies(address player) private {
|
|
reset_player();
|
|
players[player].has_active_session = false;
|
|
_burn(msg.sender, balanceOf(player));
|
|
}
|
|
|
|
receive() external payable {
|
|
revert("No plain Ether accepted, use register() function to check in :)");
|
|
}
|
|
|
|
// Revert any non-function-call Ether transfers or calls to non-existent functions
|
|
fallback() external payable {
|
|
revert("No fallback calls accepted");
|
|
}
|
|
}
|
|
|
|
interface ISwapRouter02 {
|
|
struct ExactInputSingleParams {
|
|
address tokenIn;
|
|
address tokenOut;
|
|
uint24 fee;
|
|
address recipient;
|
|
uint256 amountIn;
|
|
uint256 amountOutMinimum;
|
|
uint160 sqrtPriceLimitX96;
|
|
}
|
|
|
|
function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
|
|
|
|
struct ExactOutputSingleParams {
|
|
address tokenIn;
|
|
address tokenOut;
|
|
uint24 fee;
|
|
address recipient;
|
|
uint256 amountOut;
|
|
uint256 amountInMaximum;
|
|
uint160 sqrtPriceLimitX96;
|
|
}
|
|
|
|
function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
|
|
}
|
|
|
|
interface IWETH is IERC20 {
|
|
function deposit() external payable;
|
|
function withdraw(uint256 amount) external;
|
|
}
|