loaf/idle_moloch
1
0
Fork 0
forked from mico/idle_moloch
Code Pull Requests Activity

small refactors

Browse Source
This commit is contained in:
yellow 2024-10-31 04:21:08 +01:00
parent 86ad9c5e1a
commit 9e15e0eb2a
2 changed files with 37 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
src/RaidGeld.sol
View File

@ -10,8 +10,8 @@ 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 BUY_IN_AMOUNT = 0.00005 ether;
uint256 public BUY_IN_DAO_TOKEN_AMOUNT;
uint256 public constant INITIAL_GELD = 50 * MANTISSA;
mapping(address => Player) private players;
mapping(address => Army) private armies;
@ -28,6 +28,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
// Events
event PlayerRegistered(address indexed player, uint256 initialGeld);
event PleyerStrikesAgain(address indexed player, uint256 totalRewards, uint256 initialGeld);
event RaidPerformed(address indexed player, uint256 totalMinted, uint256 geldBalance);
event UnitAdded(
address indexed player,
@ -40,6 +41,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
uint16 anointedLevel,
uint16 championLevel
);
event DaoTokenBuyInAmountSet(address indexed owner, uint256 oldAmount, uint256 newAmount);
// Modifier for functions that should only be available to registered players
modifier onlyPlayer() {
@ -53,7 +55,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
}
modifier newPlay() {
Player memory player = players[msg.sender];
Player storage player = players[msg.sender];
bool notRegistered = player.created_at == 0;
bool returningPlayer = player.is_registered && !player.has_active_session;
require(notRegistered || returningPlayer, "Active session already in progress");
@ -72,44 +74,37 @@ contract RaidGeld is ERC20, Ownable, Constants {
// Mint some starting tokens to the player
_mint(player, INITIAL_GELD);
// Reset or set player
reset_player(player);
resetPlayer(player);
players[player].has_active_session = true;
players[player].is_registered = true;
players[player].n_runs += 1;
if (existing_player) {
// TODO: Emit new run
emit PleyerStrikesAgain(player, players[player].total_rewards, INITIAL_GELD);
} 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;
uint256 current_total_rewards = player.total_rewards;
bool current_is_registered = player.is_registered;
uint32 current_prestige_level = player.prestige_level;
function resetPlayer(address _playerAddress) private {
Player storage player = players[_playerAddress];
// Set initial states
players[addr] = Player({
total_minted: INITIAL_GELD,
created_at: block.timestamp,
last_raided_at: block.timestamp,
n_runs: current_n_runs,
total_rewards: current_total_rewards,
has_active_session: false,
is_registered: current_is_registered,
prestige_level: current_prestige_level
});
armies[addr] = Army({
player.total_minted = INITIAL_GELD;
player.created_at = block.timestamp;
player.last_raided_at = block.timestamp;
player.has_active_session = false;
armies[_playerAddress] = Army({
moloch_denier: Raider({level: 0}),
apprentice: Raider({level: 0}),
anointed: Raider({level: 0}),
champion: Raider({level: 0}),
profit_per_second: 0
});
bosses[addr] = Boss({level: 0, variants: RaidGeldUtils.generate_boss_variants(block.prevrandao)});
bosses[_playerAddress] = Boss({level: 0, variants: RaidGeldUtils.generate_boss_variants(block.prevrandao)});
}
// New player want to register with ETH
@ -202,14 +197,11 @@ contract RaidGeld is ERC20, Ownable, Constants {
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");
performRaid(msg.sender);
// 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
require(balanceOf(msg.sender) >= cost, "Not enough GELD to add this unit");
// then burn the cost of the new army
_burn(msg.sender, cost);
@ -278,11 +270,17 @@ contract RaidGeld is ERC20, Ownable, Constants {
}
function player_dies(address player) private {
reset_player(player);
resetPlayer(player);
players[player].has_active_session = false;
_burn(msg.sender, balanceOf(player));
}
function setDaoTokenBuyInAmount(uint256 newAmount) external onlyOwner {
require(newAmount > 0, "Amount must be greater than 0");
emit DaoTokenBuyInAmountSet(msg.sender, BUY_IN_DAO_TOKEN_AMOUNT, newAmount);
BUY_IN_DAO_TOKEN_AMOUNT = newAmount;
}
receive() external payable {
revert("No plain Ether accepted, use register() function to check in :)");
}

21
src/RaidGeldUtils.sol
View File

@ -22,6 +22,8 @@ library RaidGeldUtils {
uint256 constant RISK_BETA = 15e17;
uint256 constant NUMBER_OF_BOSSES = 7;
function getBossPower(uint8 level) internal pure returns (uint256 power) {
require(level <= 7, "Bosses only go to level 7");
if (level == 0) return 9000000;
@ -31,7 +33,6 @@ library RaidGeldUtils {
else if (level == 4) return 90000000000;
else if (level == 5) return 900000000000;
else if (level == 6) return 9000000000000;
else return 0;
}
function getBossCumulativeChance(uint8 level) internal pure returns (uint256 chance) {
@ -102,11 +103,11 @@ library RaidGeldUtils {
}
// Calculates whether user survives the fight
function calculateBossFight(uint8 bossLevel, uint256 geldBurnt, uint256 prevrandao) internal pure returns (bool) {
function calculateBossFight(uint8 bossLevel, uint256 geldBurnt, uint256 _randomSeed) internal pure returns (bool) {
uint256 bossPower = getBossPower(bossLevel);
uint256 bossRoll = getBossChance(bossLevel);
require(geldBurnt <= bossPower, "Cant try to defeat boss with more than what boss power is");
uint256 random_n = random(prevrandao, 1, 100);
uint256 random_n = random(_randomSeed, 1, 100);
// Relative power as in, you can only put in 800 geld to defeat 900 geld boss,
// but you will get exponentially worse chances
uint256 relativePower = ((geldBurnt ** 2) * 100) / bossPower ** 2;
@ -114,25 +115,25 @@ library RaidGeldUtils {
return roll < bossRoll;
}
function generate_boss_variants(uint256 prevrandao) internal pure returns (uint8[7] memory boss_variants) {
function generate_boss_variants(uint256 _randomSeed) internal pure returns (uint8[7] memory boss_variants) {
// We shuffle the possible variants so each run is a bit different
uint8[6] memory array = [0, 1, 2, 3, 4, 5];
for (uint256 i = array.length - 1; i > 0; i--) {
uint8[NUMBER_OF_BOSSES] memory array = [0, 1, 2, 3, 4, 5, 6];
for (uint256 i = NUMBER_OF_BOSSES - 2; i > 0; i--) {
// generate a pseudo-random index based on the prevrandao
uint256 j = uint256(keccak256(abi.encodePacked(prevrandao, i))) % (i + 1);
uint256 j = uint256(keccak256(abi.encodePacked(_randomSeed, i))) % (i + 1);
// swap elements at i and j
(array[i], array[j]) = (array[j], array[i]);
}
// Last boss is always the same old super Moloch
return [array[0], array[1], array[2], array[3], array[4], array[5], 6];
return array;
}
// TODO: Implement actual randomness
function random(uint256 prevrandao, uint256 min, uint256 max) internal pure returns (uint256) {
function random(uint256 _randomSeed, uint256 min, uint256 max) internal pure returns (uint256) {
// returns 0 - 100
require(max > min, "Max must be greater than min");
require(max < type(uint256).max, "Dont use largest possible uint");
uint256 range = max - min + 1;
return min + (uint256(keccak256(abi.encodePacked(prevrandao))) % range);
return min + (uint256(keccak256(abi.encodePacked(_randomSeed))) % range);
}
}