Contract Name:
MowseDungeonPlayerClassAttackFacet
Contract Source Code:
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1, "Math: mulDiv overflow");
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.12;
import "hardhat/console.sol";
/*************************************************************************
___ ___
| \/ | ___
| . . | _____ _____ ___ _ _ .-' '-.
| |\/| |/ _ \ \ /\ / / __|/ _ \ (.)(.)/ \
| | | | (_) \ V V /\__ \ __/ /@@ ;
\_| |_/\___/ \_/\_/ |___/\___| o_\\-mm-......-mm`~~~~~~~~~~~~~~~~`
/*************************************************************************/
import "@openzeppelin/contracts/utils/Strings.sol";
import {GameStorage, MowseDungeonClassEnum, MowseDungeonActionTypeEnum, MowseDungeonSimpleMonster, MowseDungeonBattleSimulation, STAT_DEXTERITY, STAT_STRENGTH, STAT_INTELLIGENCE, STAT_CONSTITUTION, STAT_CHARISMA, STAT_LUCK, STAT_WISDOM, MowseDungeonBattleLog, MowseDungeonBattleLogSourceEnum, MowseDungeonBattleLogTypeEnum} from "../../libraries/LibStorage.sol";
import {LibDiamond} from "../../libraries/LibDiamond.sol";
import "../../libraries/Base64.sol";
import "../../libraries/LibDungeon.sol";
contract MowseDungeonPlayerClassAttackFacet {
using Strings for uint256;
GameStorage internal gs;
function playerClassAttack(
MowseDungeonBattleSimulation memory _battleSimulation,
MowseDungeonSimpleMonster memory _monster
) external pure returns (MowseDungeonBattleSimulation memory, MowseDungeonSimpleMonster memory) {
MowseDungeonSimpleMonster memory updatedMonster;
// Calculate damage of player attack to monster
_battleSimulation.player.tempAttack = (_battleSimulation.player.tempAttack * _classBasicAttackRatio(_battleSimulation.player.class)) / 100;
// Slingshot only for max health damage
if (_battleSimulation.player.trinkets.slingshot > 0) {
if (_monster.currentHealth == _monster.maxHealth) {
_battleSimulation.player.damageMultiplier = 110 + 10 * _battleSimulation.player.trinkets.slingshot;
}
}
if (_monster.statusEffects.bulk > 0) {
_battleSimulation.player.damageMultiplier -= 30;
}
if (_monster.statusEffects.frail > 0) {
_battleSimulation.player.damageMultiplier += 30;
}
if (_monster.statusEffects.sleep > 0) {
_battleSimulation.player.damageMultiplier += 50;
_monster.statusEffects.sleep = 0;
}
_battleSimulation.player.tempAttack = (_battleSimulation.player.tempAttack * _battleSimulation.player.damageMultiplier) / 100;
_battleSimulation.player.numberOfHits = 1;
if (_battleSimulation.player.class == MowseDungeonClassEnum.WARRIOR && _battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
// Warrior
if (_battleSimulation.monster1.currentHealth > 0) {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _battleSimulation.monster1, 0);
_battleSimulation.monster1 = updatedMonster;
if (_battleSimulation.targetIndex == 0) {
_monster = updatedMonster;
}
}
if (_battleSimulation.monster2.currentHealth > 0) {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _battleSimulation.monster2, 1);
_battleSimulation.monster2 = updatedMonster;
if (_battleSimulation.targetIndex == 1) {
_monster = updatedMonster;
}
}
if (_battleSimulation.monster3.currentHealth > 0) {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _battleSimulation.monster3, 2);
_battleSimulation.monster3 = updatedMonster;
if (_battleSimulation.targetIndex == 2) {
_monster = updatedMonster;
}
}
} else if (
// Mage
_battleSimulation.player.class == MowseDungeonClassEnum.MAGE &&
_battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY
) {
// Deal damage based off base attack
_battleSimulation.player.tempAttack = _battleSimulation.player.attack * 2;
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
// Apply burn stack
if (updatedMonster.statusEffects.fireResist == 0) {
_battleSimulation = LibDungeon._addToBattleLogForMonsterIndex(_battleSimulation, 0, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_BURN, 1);
updatedMonster.statusEffects.burn++;
}
_monster = updatedMonster;
} else if (
// Archer
_battleSimulation.player.class == MowseDungeonClassEnum.ARCHER &&
_battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY
) {
_battleSimulation = LibDungeon._addStatusEffectToBattleLogForPlayer(_battleSimulation, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_EAGLE_EYE, 2);
_battleSimulation.player.statusEffects.eagleEye += 2;
// First do a basic attack
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
// Then do while loop for every 20 dex, 50% chance to hit again
if (_battleSimulation.player.stats[STAT_DEXTERITY] > 0) {
uint256 numberOfTries = LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_DEXTERITY]) / 20 + 1;
while(numberOfTries > 0) {
_battleSimulation.seed = LibDungeon.updateNewSeed(_battleSimulation.dungeonId, _battleSimulation.seed);
if (_battleSimulation.seed % 2 == 0) {
console.log('Hit again!');
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, updatedMonster, _battleSimulation.targetIndex);
_battleSimulation.player.numberOfHits++;
}
numberOfTries--;
}
} else {
// Else only one chance of an additional hit
_battleSimulation.seed = LibDungeon.updateNewSeed(_battleSimulation.dungeonId, _battleSimulation.seed);
if (_battleSimulation.seed % 2 == 0) {
console.log('Hit Again!');
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
_battleSimulation.player.numberOfHits++;
}
}
_monster = updatedMonster;
} else if (_battleSimulation.player.class == MowseDungeonClassEnum.ROGUE) {
// Rogue
if (_battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
_battleSimulation = LibDungeon._addStatusEffectToBattleLogForPlayer(_battleSimulation, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_DODGE, 2);
_battleSimulation.player.statusEffects.dodge += 2;
}
_battleSimulation.player.numberOfHits = 2;
for (uint256 i = 0; i < 2; i++) {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
// Apply POISON stack
if (updatedMonster.statusEffects.poisonResist == 0) {
_battleSimulation = LibDungeon._addToBattleLogForMonsterIndex(_battleSimulation, 0, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_POISON, 1);
updatedMonster.statusEffects.poison++;
}
}
_monster = updatedMonster;
} else if (_battleSimulation.player.class == MowseDungeonClassEnum.PALADIN && _battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
// Paladin
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
// Try to heal
if (_battleSimulation.player.statusEffects.healBlock == 0) {
uint256 maxHealthToRestore = 30;
if (_battleSimulation.player.stats[STAT_STRENGTH] > 0) {
maxHealthToRestore += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_STRENGTH]) / 10 + 1;
}
if (_battleSimulation.player.stats[STAT_INTELLIGENCE] > 0) {
maxHealthToRestore += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_INTELLIGENCE]) / 10 + 1;
}
_battleSimulation = LibDungeon._addToBattleLog(_battleSimulation, MowseDungeonBattleLogTypeEnum.HEAL, MowseDungeonBattleLogSourceEnum.PLAYER, MowseDungeonBattleLogSourceEnum.PLAYER, maxHealthToRestore * _battleSimulation.player.maxHealth / 100);
_battleSimulation.player.currentHealth += maxHealthToRestore * _battleSimulation.player.maxHealth / 100;
// Make sure health doesn't exceed maxHealth
if (_battleSimulation.player.currentHealth > _battleSimulation.player.maxHealth) {
_battleSimulation.player.currentHealth = _battleSimulation.player.maxHealth;
}
_battleSimulation.achievementProgress.healthHealed += maxHealthToRestore * _battleSimulation.player.maxHealth / 100;
} else {
_battleSimulation.player.statusEffects.healBlock--;
}
_monster = updatedMonster;
} else if (_battleSimulation.player.class == MowseDungeonClassEnum.GUARDIAN) {
if (_battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
// Guardian Shield Bash
// Double shield, then deal damage based on shield value
_battleSimulation.player.shield *= 2;
_battleSimulation.player.tempAttack += _battleSimulation.player.shield;
} else {
// Guardian basic attack
// Gain small shield on attack
uint256 shieldToGain = _battleSimulation.player.attack / 10;
if (_battleSimulation.player.stats[STAT_STRENGTH] > 0) {
shieldToGain += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_STRENGTH]) / 10 + 1;
}
if (_battleSimulation.player.stats[STAT_CONSTITUTION] > 0) {
shieldToGain += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_CONSTITUTION]) / 5 + 1;
}
}
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
_monster = updatedMonster;
} else if (_battleSimulation.player.class == MowseDungeonClassEnum.BERSERKER) {
if (_battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
// Berserker RAGE
_battleSimulation.player.statusEffects.strengthen += 2;
_battleSimulation.player.statusEffects.frail++;
_battleSimulation.player.statusEffects.lastHope++;
_battleSimulation.player.statusEffects.silence += 2;
_battleSimulation = LibDungeon._addStatusEffectToBattleLogForPlayer(_battleSimulation, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_STRENGTHEN, 2);
_battleSimulation = LibDungeon._addStatusEffectToBattleLogForPlayer(_battleSimulation, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_FRAIL, 1);
_battleSimulation = LibDungeon._addStatusEffectToBattleLogForPlayer(_battleSimulation, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_LAST_HOPE, 1);
_battleSimulation = LibDungeon._addStatusEffectToBattleLogForPlayer(_battleSimulation, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_SILENCE, 2);
}
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
_monster = updatedMonster;
} else if (_battleSimulation.player.class == MowseDungeonClassEnum.CLERIC && _battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
// Cleric Heal
// Heal based on intelligence & wisdom
uint256 healthToRestore = _battleSimulation.player.attack;
if (_battleSimulation.player.stats[STAT_INTELLIGENCE] > 0) {
healthToRestore += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_INTELLIGENCE]) / 10 + 1;
}
if (_battleSimulation.player.stats[STAT_WISDOM] > 0) {
healthToRestore += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_WISDOM]) / 5 + 1;
}
_battleSimulation = LibDungeon._addToBattleLog(_battleSimulation, MowseDungeonBattleLogTypeEnum.HEAL, MowseDungeonBattleLogSourceEnum.PLAYER, MowseDungeonBattleLogSourceEnum.PLAYER, healthToRestore);
_battleSimulation.player.currentHealth += healthToRestore;
// Make sure health doesn't exceed maxHealth
if (_battleSimulation.player.currentHealth > _battleSimulation.player.maxHealth) {
_battleSimulation.player.currentHealth = _battleSimulation.player.maxHealth;
}
_battleSimulation.achievementProgress.healthHealed += healthToRestore;
} else if (_battleSimulation.player.class == MowseDungeonClassEnum.NECROMANCER) {
if (_battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
// Necromancer Life tap
// Deal damage to monster, if monster dies, then permanently gain attack
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
if (updatedMonster.currentHealth == 0) {
_battleSimulation.player.attack += _battleSimulation.player.attack / 10;
}
} else {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
// Life Steal on basic attack
uint256 healthToRestore = _battleSimulation.player.attack / 10;
if (_battleSimulation.player.stats[STAT_INTELLIGENCE] > 0) {
healthToRestore += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_INTELLIGENCE]) / 10 + 1;
}
if (_battleSimulation.player.stats[STAT_WISDOM] > 0) {
healthToRestore += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_WISDOM]) / 10 + 1;
}
_battleSimulation = LibDungeon._addToBattleLog(_battleSimulation, MowseDungeonBattleLogTypeEnum.HEAL, MowseDungeonBattleLogSourceEnum.PLAYER, MowseDungeonBattleLogSourceEnum.PLAYER, healthToRestore);
_battleSimulation.player.currentHealth += healthToRestore;
// Make sure health doesn't exceed maxHealth
if (_battleSimulation.player.currentHealth > _battleSimulation.player.maxHealth) {
_battleSimulation.player.currentHealth = _battleSimulation.player.maxHealth;
}
_battleSimulation.achievementProgress.healthHealed += healthToRestore;
_monster = updatedMonster;
}
} else if (_battleSimulation.player.class == MowseDungeonClassEnum.BARD && _battleSimulation.actionType == MowseDungeonActionTypeEnum.SPECIAL_ABILITY) {
// Bard CHARM all monsters
_battleSimulation.player.tempAttack = _battleSimulation.player.attack;
if (_battleSimulation.player.stats[STAT_CHARISMA] > 0) {
_battleSimulation.player.tempAttack += LibDungeon._int32ToUint256(_battleSimulation.player.stats[STAT_CHARISMA]) / 5 + 1;
}
// Deal damage to all monsters
if (_battleSimulation.monster1.currentHealth > 0) {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _battleSimulation.monster1, 0);
_battleSimulation = LibDungeon._addToBattleLogForMonsterIndex(_battleSimulation, 0, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_CHARM, 2);
updatedMonster.statusEffects.charm += 2;
_battleSimulation.monster1 = updatedMonster;
if (_battleSimulation.targetIndex == 0) {
_monster = updatedMonster;
}
}
if (_battleSimulation.monster2.currentHealth > 0) {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _battleSimulation.monster2, 1);
_battleSimulation = LibDungeon._addToBattleLogForMonsterIndex(_battleSimulation, 1, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_CHARM, 2);
updatedMonster.statusEffects.charm += 2;
_battleSimulation.monster2 = updatedMonster;
if (_battleSimulation.targetIndex == 1) {
_monster = updatedMonster;
}
}
if (_battleSimulation.monster3.currentHealth > 0) {
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _battleSimulation.monster3, 2);
_battleSimulation = LibDungeon._addToBattleLogForMonsterIndex(_battleSimulation, 2, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_CHARM, 2);
updatedMonster.statusEffects.charm += 2;
_battleSimulation.monster3 = updatedMonster;
if (_battleSimulation.targetIndex == 2) {
_monster = updatedMonster;
}
}
} else {
// Default
(_battleSimulation, updatedMonster) = LibDungeon._dealPlayerDamageToMonster(_battleSimulation, _monster, _battleSimulation.targetIndex);
_monster = updatedMonster;
}
return (_battleSimulation, _monster);
}
function _classBasicAttackRatio(MowseDungeonClassEnum _class) internal pure returns (uint256) {
if (_class == MowseDungeonClassEnum.WARRIOR) {
return 100;
} else if (_class == MowseDungeonClassEnum.MAGE) {
return 60;
} else if (_class == MowseDungeonClassEnum.ARCHER) {
return 80;
} else if (_class == MowseDungeonClassEnum.ROGUE) {
return 50;
} else if (_class == MowseDungeonClassEnum.PALADIN) {
return 70;
} else if (_class == MowseDungeonClassEnum.GUARDIAN) {
return 50;
} else if (_class == MowseDungeonClassEnum.BERSERKER) {
return 120;
} else if (_class == MowseDungeonClassEnum.CLERIC) {
return 40;
} else if (_class == MowseDungeonClassEnum.NECROMANCER) {
return 55;
} else if (_class == MowseDungeonClassEnum.BARD) {
return 60;
} else {
return 50;
}
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/
interface IDiamondCut {
enum FacetCutAction {Add, Replace, Remove}
// Add=0, Replace=1, Remove=2
struct FacetCut {
address facetAddress;
FacetCutAction action;
bytes4[] functionSelectors;
}
/// @notice Add/replace/remove any number of functions and optionally execute
/// a function with delegatecall
/// @param _diamondCut Contains the facet addresses and function selectors
/// @param _init The address of the contract or facet to execute _calldata
/// @param _calldata A function call, including function selector and arguments
/// _calldata is executed with delegatecall on _init
function diamondCut(
FacetCut[] calldata _diamondCut,
address _init,
bytes calldata _calldata
) external;
event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);
}
// SPDX-License-Identifier: MIT
// Credit https://github.com/derekchiang/loot-name/blob/main/contracts/LootName.sol
pragma solidity ^0.8.12;
/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
bytes internal constant TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
/// @notice Encodes some bytes to the base64 representation
function encode(bytes memory data) internal pure returns (string memory) {
uint256 len = data.length;
if (len == 0) return '';
// multiply by 4/3 rounded up
uint256 encodedLen = 4 * ((len + 2) / 3);
// Add some extra buffer at the end
bytes memory result = new bytes(encodedLen + 32);
bytes memory table = TABLE;
assembly {
let tablePtr := add(table, 1)
let resultPtr := add(result, 32)
for {
let i := 0
} lt(i, len) {
} {
i := add(i, 3)
let input := and(mload(add(data, i)), 0xffffff)
let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF))
out := shl(8, out)
out := add(out, and(mload(add(tablePtr, and(input, 0x3F))), 0xFF))
out := shl(224, out)
mstore(resultPtr, out)
resultPtr := add(resultPtr, 4)
}
switch mod(len, 3)
case 1 {
mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
}
case 2 {
mstore(sub(resultPtr, 1), shl(248, 0x3d))
}
mstore(result, encodedLen)
}
return string(result);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/
import { IDiamondCut } from "../interfaces/IDiamondCut.sol";
// Remember to add the loupe functions from DiamondLoupeFacet to the diamond.
// The loupe functions are required by the EIP2535 Diamonds standard
error InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);
library LibDiamond {
bytes32 constant DIAMOND_STORAGE_POSITION = keccak256("diamond.standard.diamond.storage");
struct FacetAddressAndPosition {
address facetAddress;
uint96 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array
}
struct FacetFunctionSelectors {
bytes4[] functionSelectors;
uint256 facetAddressPosition; // position of facetAddress in facetAddresses array
}
struct DiamondStorage {
// maps function selector to the facet address and
// the position of the selector in the facetFunctionSelectors.selectors array
mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;
// maps facet addresses to function selectors
mapping(address => FacetFunctionSelectors) facetFunctionSelectors;
// facet addresses
address[] facetAddresses;
// Used to query if a contract implements an interface.
// Used to implement ERC-165.
mapping(bytes4 => bool) supportedInterfaces;
// owner of the contract
address contractOwner;
}
function diamondStorage() internal pure returns (DiamondStorage storage ds) {
bytes32 position = DIAMOND_STORAGE_POSITION;
assembly {
ds.slot := position
}
}
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function setContractOwner(address _newOwner) internal {
DiamondStorage storage ds = diamondStorage();
address previousOwner = ds.contractOwner;
ds.contractOwner = _newOwner;
emit OwnershipTransferred(previousOwner, _newOwner);
}
function contractOwner() internal view returns (address contractOwner_) {
contractOwner_ = diamondStorage().contractOwner;
}
function enforceIsContractOwner() internal view {
require(msg.sender == diamondStorage().contractOwner, "LibDiamond: Must be contract owner");
}
event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
// Internal function version of diamondCut
function diamondCut(
IDiamondCut.FacetCut[] memory _diamondCut,
address _init,
bytes memory _calldata
) internal {
for (uint256 facetIndex; facetIndex < _diamondCut.length; facetIndex++) {
IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;
if (action == IDiamondCut.FacetCutAction.Add) {
addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);
} else if (action == IDiamondCut.FacetCutAction.Replace) {
replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);
} else if (action == IDiamondCut.FacetCutAction.Remove) {
removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);
} else {
revert("LibDiamondCut: Incorrect FacetCutAction");
}
}
emit DiamondCut(_diamondCut, _init, _calldata);
initializeDiamondCut(_init, _calldata);
}
function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
require(_functionSelectors.length > 0, "LibDiamondCut: No selectors in facet to cut");
DiamondStorage storage ds = diamondStorage();
require(_facetAddress != address(0), "LibDiamondCut: Add facet can't be address(0)");
uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);
// add new facet address if it does not exist
if (selectorPosition == 0) {
addFacet(ds, _facetAddress);
}
for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;
require(oldFacetAddress == address(0), "LibDiamondCut: Can't add function that already exists");
addFunction(ds, selector, selectorPosition, _facetAddress);
selectorPosition++;
}
}
function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
require(_functionSelectors.length > 0, "LibDiamondCut: No selectors in facet to cut");
DiamondStorage storage ds = diamondStorage();
require(_facetAddress != address(0), "LibDiamondCut: Add facet can't be address(0)");
uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);
// add new facet address if it does not exist
if (selectorPosition == 0) {
addFacet(ds, _facetAddress);
}
for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;
require(oldFacetAddress != _facetAddress, "LibDiamondCut: Can't replace function with same function");
removeFunction(ds, oldFacetAddress, selector);
addFunction(ds, selector, selectorPosition, _facetAddress);
selectorPosition++;
}
}
function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
require(_functionSelectors.length > 0, "LibDiamondCut: No selectors in facet to cut");
DiamondStorage storage ds = diamondStorage();
// if function does not exist then do nothing and return
require(_facetAddress == address(0), "LibDiamondCut: Remove facet address must be address(0)");
for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; selectorIndex++) {
bytes4 selector = _functionSelectors[selectorIndex];
address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;
removeFunction(ds, oldFacetAddress, selector);
}
}
function addFacet(DiamondStorage storage ds, address _facetAddress) internal {
enforceHasContractCode(_facetAddress, "LibDiamondCut: New facet has no code");
ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = ds.facetAddresses.length;
ds.facetAddresses.push(_facetAddress);
}
function addFunction(DiamondStorage storage ds, bytes4 _selector, uint96 _selectorPosition, address _facetAddress) internal {
ds.selectorToFacetAndPosition[_selector].functionSelectorPosition = _selectorPosition;
ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(_selector);
ds.selectorToFacetAndPosition[_selector].facetAddress = _facetAddress;
}
function removeFunction(DiamondStorage storage ds, address _facetAddress, bytes4 _selector) internal {
require(_facetAddress != address(0), "LibDiamondCut: Can't remove function that doesn't exist");
// an immutable function is a function defined directly in a diamond
require(_facetAddress != address(this), "LibDiamondCut: Can't remove immutable function");
// replace selector with last selector, then delete last selector
uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;
uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;
// if not the same then replace _selector with lastSelector
if (selectorPosition != lastSelectorPosition) {
bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];
ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;
ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint96(selectorPosition);
}
// delete the last selector
ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();
delete ds.selectorToFacetAndPosition[_selector];
// if no more selectors for facet address then delete the facet address
if (lastSelectorPosition == 0) {
// replace facet address with last facet address and delete last facet address
uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;
uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;
if (facetAddressPosition != lastFacetAddressPosition) {
address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];
ds.facetAddresses[facetAddressPosition] = lastFacetAddress;
ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = facetAddressPosition;
}
ds.facetAddresses.pop();
delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;
}
}
function initializeDiamondCut(address _init, bytes memory _calldata) internal {
if (_init == address(0)) {
return;
}
enforceHasContractCode(_init, "LibDiamondCut: _init address has no code");
(bool success, bytes memory error) = _init.delegatecall(_calldata);
if (!success) {
if (error.length > 0) {
// bubble up error
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(error)
revert(add(32, error), returndata_size)
}
} else {
revert InitializationFunctionReverted(_init, _calldata);
}
}
}
function enforceHasContractCode(address _contract, string memory _errorMessage) internal view {
uint256 contractSize;
assembly {
contractSize := extcodesize(_contract)
}
require(contractSize > 0, _errorMessage);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;
import "hardhat/console.sol";
import {
MowseDungeonSimplePlayer,
MowseDungeonSimpleMonster,
MowseDungeonBattleSimulation,
MowseDungeonBattleLog,
MowseDungeonBattleLogTypeEnum,
MowseDungeonBattleLogSourceEnum
} from "../libraries/LibStorage.sol";
library LibDungeon {
function _int32ToUint256(int32 _stat) internal pure returns (uint256) {
return uint256(int256(_stat));
}
function getNewSeed(uint256 seed, uint256 newSeed) internal pure returns (uint256) {
return uint256(keccak256(abi.encodePacked(seed, newSeed)));
}
function updateNewSeed(uint256 seed, uint256 newSeed) internal pure returns (uint256) {
if (newSeed >> 2 == 0) {
newSeed = getNewSeed(seed, newSeed);
} else {
newSeed >>= 2;
}
return newSeed;
}
function _damageShieldAndHealth(uint256 _damage, uint256 _enemyHealth, uint256 _enemyShield) internal pure returns (uint256, uint256) {
if (_damage > _enemyShield) {
if (_damage - _enemyShield > _enemyHealth) {
_enemyHealth = 0;
} else {
_enemyHealth = _enemyHealth - (_damage - _enemyShield);
}
_enemyShield = 0;
} else {
_enemyShield = _enemyShield - _damage;
}
return (_enemyHealth, _enemyShield);
}
// For true damage/pierce attacks
function _damageHealth(uint256 _damage, uint256 _enemyHealth) internal pure returns (uint256) {
if (_damage > _enemyHealth) {
return 0;
} else {
return _enemyHealth - _damage;
}
}
function _checkPlayerRevive(MowseDungeonSimplePlayer memory _player) internal pure returns (MowseDungeonSimplePlayer memory) {
// Check if player has died
if (_player.currentHealth == 0) {
// Revive
if (_player.statusEffects.revive > 0) {
_player.currentHealth = _player.maxHealth;
_player.statusEffects.revive = 0;
}
// LAST_HOPE
if (_player.statusEffects.lastHope > 0) {
_player.currentHealth = 1;
_player.statusEffects.lastHope = 0;
}
}
return _player;
}
function _checkMonsterRevive(MowseDungeonSimpleMonster memory _monster) internal pure returns (MowseDungeonSimpleMonster memory) {
// Check if monster has died
if (_monster.currentHealth == 0) {
// Revive
if (_monster.statusEffects.revive > 0) {
_monster.currentHealth = _monster.maxHealth;
_monster.statusEffects.revive = 0;
}
// LAST_HOPE
if (_monster.statusEffects.lastHope > 0) {
_monster.currentHealth = 1;
_monster.statusEffects.lastHope = 0;
}
}
return _monster;
}
function _applyStatusEffectsFromTrinketsToMonster(
MowseDungeonBattleSimulation memory _battleSimulation,
MowseDungeonSimpleMonster memory _monster,
uint256 _monsterIndex
) internal pure returns (MowseDungeonBattleSimulation memory, MowseDungeonSimpleMonster memory) {
if (_battleSimulation.player.trinkets.poisonDab > 0) {
if (_monster.statusEffects.poisonResist == 0) {
_monster.statusEffects.poison += _battleSimulation.player.trinkets.poisonDab * (_battleSimulation.player.statusEffects.doubleUp + 1);
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_POISON, _battleSimulation.player.trinkets.poisonDab * (_battleSimulation.player.statusEffects.doubleUp + 1));
}
}
if (_battleSimulation.player.trinkets.kindle > 0) {
if (_monster.statusEffects.fireResist == 0) {
_monster.statusEffects.burn += _battleSimulation.player.trinkets.kindle * (_battleSimulation.player.statusEffects.doubleUp + 1);
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_BURN, _battleSimulation.player.trinkets.kindle * (_battleSimulation.player.statusEffects.doubleUp + 1));
}
}
if (_battleSimulation.player.trinkets.bloodLetter > 0) {
_monster.statusEffects.bleed += _battleSimulation.player.trinkets.bloodLetter * (_battleSimulation.player.statusEffects.doubleUp + 1);
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_BLEED, _battleSimulation.player.trinkets.bloodLetter * (_battleSimulation.player.statusEffects.doubleUp + 1));
}
if (_battleSimulation.player.trinkets.cursedRing > 0) {
_monster.statusEffects.curse += _battleSimulation.player.trinkets.cursedRing * (_battleSimulation.player.statusEffects.doubleUp + 1);
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_CURSE, _battleSimulation.player.trinkets.cursedRing * (_battleSimulation.player.statusEffects.doubleUp + 1));
}
if (_battleSimulation.player.trinkets.stunRod > 0) {
if (_monster.statusEffects.stunResist == 0 && _monster.statusEffects.unstoppable == 0 && _monster.isBoss == false) {
_battleSimulation.seed = updateNewSeed(_battleSimulation.dungeonId, _battleSimulation.seed);
if (_battleSimulation.seed % 100 < 20 + _battleSimulation.player.trinkets.stunRod * 20) {
_monster.statusEffects.stun++;
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_STUN, 1);
}
}
}
if (_battleSimulation.player.trinkets.silenceBell > 0) {
if (_monster.statusEffects.unstoppable == 0 && _monster.isBoss == false) {
_battleSimulation.seed = updateNewSeed(_battleSimulation.dungeonId, _battleSimulation.seed);
if (_battleSimulation.seed % 100 < 20 + _battleSimulation.player.trinkets.silenceBell * 20) {
_monster.statusEffects.silence++;
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_SILENCE, 1);
}
}
}
if (_battleSimulation.player.trinkets.strengthBelt > 0) {
_battleSimulation.player.statusEffects.strengthen +=
_battleSimulation.player.trinkets.strengthBelt *
(_battleSimulation.player.statusEffects.doubleUp + 1);
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_STRENGTHEN, _battleSimulation.player.trinkets.strengthBelt * (_battleSimulation.player.statusEffects.doubleUp + 1));
}
if (_battleSimulation.player.trinkets.weakenedChain > 0) {
_monster.statusEffects.weaken += _battleSimulation.player.trinkets.weakenedChain * (_battleSimulation.player.statusEffects.doubleUp + 1);
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_WEAKEN, _battleSimulation.player.trinkets.weakenedChain * (_battleSimulation.player.statusEffects.doubleUp + 1));
}
if (_battleSimulation.player.trinkets.leech > 0) {
_battleSimulation.player.currentHealth +=
((_battleSimulation.player.tempAttack * (10 * _battleSimulation.player.trinkets.leech)) / 100) *
(_battleSimulation.player.statusEffects.doubleUp + 1);
_battleSimulation = _addToBattleLog(_battleSimulation, MowseDungeonBattleLogTypeEnum.HEAL, MowseDungeonBattleLogSourceEnum.TRINKET_LEECH, MowseDungeonBattleLogSourceEnum.PLAYER, ((_battleSimulation.player.tempAttack * (10 * _battleSimulation.player.trinkets.leech)) / 100) * (_battleSimulation.player.statusEffects.doubleUp + 1));
// Make sure health doesn't exceed maxHealth
if (_battleSimulation.player.currentHealth > _battleSimulation.player.maxHealth) {
_battleSimulation.player.currentHealth = _battleSimulation.player.maxHealth;
}
_battleSimulation.achievementProgress.healthHealed +=
((_battleSimulation.player.tempAttack * (10 * _battleSimulation.player.trinkets.leech)) / 100) *
(_battleSimulation.player.statusEffects.doubleUp + 1);
}
return (_battleSimulation, _monster);
}
function _monsterRetaliate(
MowseDungeonBattleSimulation memory _battleSimulation,
MowseDungeonSimpleMonster memory _monster,
uint256 _monsterIndex
) internal pure returns (MowseDungeonBattleSimulation memory) {
if (_monster.statusEffects.counter > 0) {
(_battleSimulation.player.currentHealth, _battleSimulation.player.shield) = _damageShieldAndHealth(
_monster.attack,
_battleSimulation.player.currentHealth,
_battleSimulation.player.shield
);
_battleSimulation.achievementProgress.damageTaken += _monster.attack;
_battleSimulation = _addToBattleLogForPlayerFromMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.DAMAGE, _monster.attack);
_battleSimulation.player = _checkPlayerRevive(_battleSimulation.player);
}
if (_monster.statusEffects.thorns > 0) {
(_battleSimulation.player.currentHealth, _battleSimulation.player.shield) = _damageShieldAndHealth(
5 * _monster.statusEffects.thorns,
_battleSimulation.player.currentHealth,
_battleSimulation.player.shield
);
_battleSimulation.achievementProgress.damageTaken += 5 * _monster.statusEffects.thorns;
_battleSimulation = _addToBattleLog(_battleSimulation, MowseDungeonBattleLogTypeEnum.DAMAGE, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_THORNS, MowseDungeonBattleLogSourceEnum.PLAYER, 5 * _monster.statusEffects.thorns);
_battleSimulation.player = _checkPlayerRevive(_battleSimulation.player);
}
if (_monster.statusEffects.wrathfulReprisal > 0) {
(_battleSimulation.player.currentHealth, _battleSimulation.player.shield) = _damageShieldAndHealth(
_battleSimulation.player.attack,
_battleSimulation.player.currentHealth,
_battleSimulation.player.shield
);
_battleSimulation = _addToBattleLog(_battleSimulation, MowseDungeonBattleLogTypeEnum.DAMAGE, MowseDungeonBattleLogSourceEnum.STATUS_EFFECT_WRATHFUL_REPRISAL, MowseDungeonBattleLogSourceEnum.PLAYER, _battleSimulation.player.attack);
_battleSimulation.achievementProgress.damageTaken += _battleSimulation.player.attack;
_battleSimulation.player = _checkPlayerRevive(_battleSimulation.player);
}
return _battleSimulation;
}
function _dealPlayerDamageToMonster(MowseDungeonBattleSimulation memory _battleSimulation, MowseDungeonSimpleMonster memory _monster, uint256 _monsterIndex) internal pure returns (MowseDungeonBattleSimulation memory, MowseDungeonSimpleMonster memory) {
if (_monster.statusEffects.invincible == 0) {
if (_battleSimulation.player.statusEffects.pierce > 0) {
_monster.currentHealth = _damageHealth(_battleSimulation.player.tempAttack, _monster.currentHealth);
} else {
(_monster.currentHealth, _monster.shield) = _damageShieldAndHealth(
_battleSimulation.player.tempAttack,
_monster.currentHealth,
_monster.shield
);
}
_battleSimulation = _addToBattleLogForMonsterIndex(_battleSimulation, _monsterIndex, MowseDungeonBattleLogTypeEnum.DAMAGE, MowseDungeonBattleLogSourceEnum.PLAYER, _battleSimulation.player.tempAttack);
_battleSimulation.achievementProgress.damageDealt += _battleSimulation.player.tempAttack;
_monster = _checkMonsterRevive(_monster);
}
(_battleSimulation, _monster) = _applyStatusEffectsFromTrinketsToMonster(_battleSimulation, _monster, _monsterIndex);
if (_monster.currentHealth > 0) {
_battleSimulation = _monsterRetaliate(_battleSimulation, _monster, _monsterIndex);
}
return (_battleSimulation, _monster);
}
function _addToBattleLogForMonsterIndex(MowseDungeonBattleSimulation memory _battleSimulation, uint256 _monsterIndex, MowseDungeonBattleLogTypeEnum _logType, MowseDungeonBattleLogSourceEnum _source, uint256 _amount) internal pure returns (MowseDungeonBattleSimulation memory) {
if (_monsterIndex == 0) {
_battleSimulation = _addToBattleLog(_battleSimulation, _logType, _source, MowseDungeonBattleLogSourceEnum.MONSTER_1, _amount);
} else if (_monsterIndex == 1) {
_battleSimulation = _addToBattleLog(_battleSimulation, _logType, _source, MowseDungeonBattleLogSourceEnum.MONSTER_2, _amount);
} else {
_battleSimulation = _addToBattleLog(_battleSimulation, _logType, _source, MowseDungeonBattleLogSourceEnum.MONSTER_3, _amount);
}
return _battleSimulation;
}
function _addToBattleLogForPlayerFromMonsterIndex(MowseDungeonBattleSimulation memory _battleSimulation, uint256 _monsterIndex, MowseDungeonBattleLogTypeEnum _logType, uint256 _amount) internal pure returns (MowseDungeonBattleSimulation memory) {
if (_monsterIndex == 0) {
_battleSimulation = _addToBattleLog(_battleSimulation, _logType, MowseDungeonBattleLogSourceEnum.MONSTER_1, MowseDungeonBattleLogSourceEnum.PLAYER, _amount);
} else if (_monsterIndex == 1) {
_battleSimulation = _addToBattleLog(_battleSimulation, _logType, MowseDungeonBattleLogSourceEnum.MONSTER_2, MowseDungeonBattleLogSourceEnum.PLAYER, _amount);
} else {
_battleSimulation = _addToBattleLog(_battleSimulation, _logType, MowseDungeonBattleLogSourceEnum.MONSTER_3, MowseDungeonBattleLogSourceEnum.PLAYER, _amount);
}
return _battleSimulation;
}
function _addStatusEffectToBattleLogForPlayer(MowseDungeonBattleSimulation memory _battleSimulation, MowseDungeonBattleLogSourceEnum _source, uint256 _amount) internal pure returns (MowseDungeonBattleSimulation memory) {
_battleSimulation = _addToBattleLog(_battleSimulation, MowseDungeonBattleLogTypeEnum.APPLY_STATUS_EFFECT, _source, MowseDungeonBattleLogSourceEnum.PLAYER, _amount);
return _battleSimulation;
}
function _addToBattleLog(MowseDungeonBattleSimulation memory _battleSimulation, MowseDungeonBattleLogTypeEnum _logType, MowseDungeonBattleLogSourceEnum _source, MowseDungeonBattleLogSourceEnum _target, uint256 _amount) internal pure returns (MowseDungeonBattleSimulation memory) {
if (_battleSimulation.battleLogCount >= 100) return _battleSimulation;
_battleSimulation.battleLog[_battleSimulation.battleLogCount++] = (MowseDungeonBattleLog({logType: _logType, source: _source, target: _target, amount: _amount}));
return _battleSimulation;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import { LibDiamond } from "./LibDiamond.sol";
uint256 constant SKILL_TYPE_NUM = 7;
uint256 constant STAT_CHARISMA = 0;
uint256 constant STAT_CONSTITUTION = 1;
uint256 constant STAT_DEXTERITY = 2;
uint256 constant STAT_INTELLIGENCE = 3;
uint256 constant STAT_LUCK = 4;
uint256 constant STAT_STRENGTH = 5;
uint256 constant STAT_WISDOM = 6;
uint256 constant EQUIPPED_WEARABLE_SLOTS = 12;
bytes32 constant MOWSE_ADMIN_ROLE = keccak256('MOWSE_ADMIN_ROLE');
bytes32 constant MOWSEWEAR_MINTER_ROLE = keccak256('MOWSEWEAR_MINTER_ROLE');
bytes32 constant MOWSE_MINTER_ROLE = keccak256('MOWSE_MINTER_ROLE');
bytes32 constant MOWSEWEAR_ADMIN_ROLE = keccak256('MOWSEWEAR_ADMIN_ROLE');
bytes32 constant MOWSEGAME_ADMIN_ROLE = keccak256('MOWSEGAME_ADMIN_ROLE');
bytes32 constant MOWSEBANK_CREATE2_SALT = keccak256('MOWSEBANK_CREATE2_SALT');
bytes32 constant MOWSELOOTBOX_MINTER_ROLE = keccak256('MOWSELOOTBOX_MINTER_ROLE');
bytes32 constant MOWSEJOB_ADMIN_ROLE = keccak256('MOWSEJOB_ADMIN_ROLE');
struct GameStorage {
address diamondAddress;
address mowseAvatarContractAddress;
address mowseGoldContractAddress;
address mowseBankContractAddress;
address mowseLootboxContractAddress;
bool paused;
// Mowse = id > 10,000
uint256 mowseMintPrice;
uint256 mowseTokenIdCounter; // Current tokenId of Mowse for minting purposes
uint256 mowseWearTotalCount; // Total Count of MowseWear minted
uint256 mowseWearTokenIdCounter; // Current tokenId of MowseWear for minting purposes
mapping(address => bool) isMowse; // maps Mowse address to bool if it is a mowse address or not
mapping(address => uint256) mainMowse; // map address to mowseTokenId
mapping(uint256 => Mowse) mowses; // map mowseAvatar tokenId to Mowse struct
mapping(uint256 => MowseWear) mowsewears; // map mowsewear tokenId to MowseWear struct
// mapping(uint256 => MowseLineage) mowselineages;
mapping(uint8 => mapping(uint16 => MowseWearMetadata)) mowseWearDictionary; // map equippable wearable slot index to dictionary index to get unique mowsewear
mapping(uint256 => MowseWearMetadata) mowseWearDictionaryByDictionaryIndex; // map dictionary index to mowsewear (for lootbox)
uint256 mowseWearDictionaryCount; // Counts how many items are in the mowseWearDictionary (for lootbox)
uint16[EQUIPPED_WEARABLE_SLOTS] mowseWearDictionaryTraitCount; // count of each trait (11 shirts, 10 eyeWear, etc), used for incrementing next traitIndex
mapping(uint8 => mapping(uint16 => uint256)) mowseWearCountByTraitIndex; // Counts how many mowsewear are minted per traitIndex (3 Blue Headbands)
mapping(uint8 => uint256) mowseWearCountByTraitType; // Counts how many shirts were minted
mapping(uint16 => string) possibleTraitTypes; // mapping of all possible traitTypes to strings
string[] initTraitNames; // used in DiamondInit
// MowseWear
uint256 mowseWearHemPrice;
// Initial merkel MGOLD aidrop
// mapping(address => uint256) initialMowseGoldClaimList; // Used for merkel airdrop
// MowseLootbox
// lootbox index is the loot pool index; [0-11] are trait type specific, [12] is general pool, 13+ are any other specific pools (weekly chests or seasonal chests)
mapping(uint64 => MowseLootboxPool) mowselootboxes; // map lootbox index (traitType + a few more) to MowseLootbox
// count of current lootbox index
uint64 mowseLootboxIndexCount;
// Current tokenId of MowseLootbox for minting purposes
uint256 mowseLootboxTokenIdCounter;
// map tokenId to LootboxIndex to get the lootbox data
mapping(uint256 => uint64) mowseLootboxIndexByTokenId;
// large prime used for VDF
uint256 mowseLootboxPrime;
// iterations for VDF
uint256 mowseLootboxIterations;
// nonce for VDF
uint256 mowseLootboxNonce;
// mapping to get seed from tokenId if minted through mowseLootbox
mapping(uint256 => uint256) mowseLootboxTokenIdToSeed;
// random seed for pseudo-rng
uint256 mowsePrngSeed;
uint256 mowseJobPrngSeed;
uint256 mowseWearPrngSeed;
uint256 prngNonce;
// DonationTree
uint256 totalWishCount;
uint256 donationTreePrime;
uint256 donationTreeIterations;
uint256 donationTreeNonce;
mapping(uint256 => uint256) donationTreeWishCountToSeed;
mapping(uint256 => uint256) mowseNextWish;
mapping(address => uint256) nextWish;
mapping(address => uint256) wishCount;
// MowseGame
mapping(uint256 => MowseGames) mowsegames;
uint256 mowseGamesCount;
uint256 activeMowseGamesCount; // Needed
mapping(string => uint256) getMowseGameByName;
uint8 maxFreeGameSubmits;
// Normal base token payout
uint256 baseGamePayout;
// Pay for users' gas but it ain't free yo. After x number of submits, purchase MowseGold to continue forever
mapping(address => uint256) freeMowseGameSubmits;
mapping(address => bool) hasPurchasedMowseGold;
// For suspicious gaming activity, temporary ban
mapping(address => bool) mowseGameUserBanned;
// MowseBank and MowseWallet
address mowseBankWalletImplementation;
mapping(address => uint256) mowseBankBalances;
mapping(address => uint256) mowseBankTokenIdForWallet;
// Withdrawal
address payable devRoyaltyAddress;
address payable teamAddress;
address payable backendAddress;
address payable treasuryAddress;
uint256 devRoyaltyTaxBasisPoints;
uint256 teamTaxBasisPoints;
uint256 backendTaxBasisPoints;
uint256 developerTaxBasisPoints;
// For testnet purposes and rewarding testers
uint256 testPatchCount;
mapping(uint256 => TestPatch) testPatches; // Maps patchVersion to testPatch
// GatherAndGarnishFacet
uint256 gatherGarnishPrngSeed;
uint256 gatherGarnishSeasonStart;
uint256 gatherGarnishSeasonEnd;
uint256 gatherGarnishSeasonCount;
// Maps season count -> season reward (mowse wear dictionary index)
mapping(uint256 => uint256) gatherGarnishSeasonReward; // MowseWearDictionaryIndex
// Maps player address -> season count -> stats
mapping(address => mapping(uint256 => GatherAndGarnishPlayerStats)) gatherGarnishPlayerStats;
// What day index did the first winner win
uint256 gatherGarnishDayOfFirstWinner;
// Maps season count -> first winners count index -> player address for season first winners
mapping(uint256 => mapping(uint256 => address)) gatherGarnishSeasonFirstWinners;
uint256 gatherGarnishSeasonFirstWinnersCount;
// Maps season count -> winners count index -> player address for season winners
mapping(uint256 => mapping(uint256 => address)) gatherGarnishSeasonWinners;
uint256 gatherGarnishSeasonWinnersCount;
// Maps season count -> winners address -> bool if they have won and claimed their rewards
mapping(uint256 => mapping(address => bool)) gatherGarnishClaimedRewards;
// Maps season count -> mainMowseId -> bool if the mowseId has received rewards for this season (to prevent transferring main mowse and claiming multiple exp rewards)
mapping(uint256 => mapping(uint256 => bool)) gatherGarnishMainMowseClaimedRewards;
// Maps season count -> winners address -> bool if they have won
mapping(uint256 => mapping(address => bool)) gatherGarnishHasPlayerWon;
// Maps season count -> day index -> scavenge hunt count
mapping(uint256 => mapping(uint256 => GatherAndGarnishScavenge)) gatherGarnishScavenge;
// Maps season count -> day index -> resource type [1-4, wood/rock/gem/food]
mapping(uint256 => mapping(uint256 => uint256)) gatherGarnishDailyResource;
// Maps season count -> day index -> investment resource type [1-4]
mapping(uint256 => mapping(uint256 => uint256)) gatherGarnishInvestmentResource;
// Maps season count -> pointsStructureCost
mapping(uint256 => uint256[4]) gatherGarnishFirstPointsStructureCost;
mapping(uint256 => uint256[4]) gatherGarnishSecondPointsStructureCost;
mapping(uint256 => uint256[4]) gatherGarnishThirdPointsStructureCost;
// MowseDungeonFacet
uint256 statusEffectCount;
// VDF for initial dungeon hash
uint256 mowseDungeonPrime;
uint256 mowseDungeonIterations;
uint256 mowseDungeonNonce;
// pRNG for smaller pseudo random actions
uint256 mowseDungeonPrngSeed;
// Maps mowseTokenId -> dungeonRunCount -> MowseDungeon
mapping(uint256 => mapping(uint256 => MowseDungeon)) mowsedungeons;
// Maps monsterIdCount -> mapping of statusEffects
mapping(uint256 => mapping(MowseDungeonStatusEffectEnum => uint256)) mowseDungeonMonsterStatusEffects;
// Count of Monster Ids
// uint256 mowseDungeonMonsterIdCount;
// Maps roomId -> MowseDungeonRoom
// mapping(uint256 => MowseDungeonRoom) mowseDungeonRoom;
// Count of rooms
// uint256 mowseDungeonRoomCount;
// Maps mowseTokenId -> Current Player stats
mapping(uint256 => MowseDungeonPlayer) mowseDungeonPlayer;
// Maps mowseTokenId -> AchievementEnum -> threshold
mapping(uint256 => mapping(MowseDungeonAchievementsEnum => uint256)) mowseDungeonAchievementProgress;
// Maps mowseTokenId -> Companion Enum -> Companion
mapping(uint256 => mapping(MowseDungeonCompanionEnum => MowseDungeonCompanion)) mowseDungeonPlayerCompanion;
// Maps mowseTokenId -> dungeonRunCount -> DungeonRewards
mapping(uint256 => mapping(uint256 => MowseDungeonDungeonRewards)) mowseDungeonDungeonRewards;
// Maps Monster Enum -> Monster for default values
mapping(MowseDungeonMonsterEnum => MowseDungeonMonsterAttributes) mowseDungeonMonsterDefaults;
uint256 mowseDungeonMonsterDefaultsCount;
// Maps Room Enum -> Room for default values
mapping(MowseDungeonRoomEnum => MowseDungeonRoom) mowseDungeonRoomDefaults;
uint256 mowseDungeonRoomDefaultsCount;
mapping(MowseDungeonTrinketEnum => MowseDungeonTrinket) mowseDungeonTrinketDefaults;
// Keeps track of number of different trinkets exist
uint256 mowseDungeonTrinketDefaultsCount;
// Maps mowseTokenId to dungeon run count to vdf seed
mapping(uint256 => mapping(uint256 => uint256)) mowseDungeonRunCountToSeed;
// Maps mowseTokenId to dungeon run count
mapping(uint256 => uint256) mowseDungeonRunCount;
// RandomFortuneFacet
mapping(address => uint256) randomFortuneCount;
// large prime used for VDF
uint256 randomFortunePrime;
// iterations for VDF
uint256 randomFortuneIterations;
// nonce for VDF
uint256 randomFortuneNonce;
// mapping to get seed from timestamp
mapping(address => mapping(uint256 => uint256)) randomFortuneTimestampToSeed;
// MowseSpin
// uint256 mowseSpinPrime;
// uint256 mowseSpinIterations;
// uint256 mowseSpinNonce;
// // Maps mowseTokenId to current mowse spin game
// mapping(uint256 => MowseSpinStorage) mowseSpinStorage;
// // Maps mowseTokenId to player stats
// mapping(uint256 => MowseSpinPlayer) mowseSpinPlayer;
}
// MowseSpin
// struct MowseSpinStorage {
// uint256 mowseId;
// uint256 stageCount;
// uint256 spinCount;
// uint256 mowseSpinId;
// uint256 seed;
// uint256 recountTokens;
// uint256 trashTokens;
// uint256 coins;
// MowseSpinSimplePlayer player;
// MowseSpinPlayerAchievementsProgress achievementProgress;
// MowseSpinLog[] spinLog;
// uint256 spinLogCount;
// uint256 grid;
// }
// struct MowseSpinPlayer {
// uint256 mowseId;
// // Number of times a player has created a game
// uint256 spinRunCount;
// // MowseDungeonSimplePlayerAchievementsUnlocked achievements;
// // // Used for quickly checking if an achievement is unlocked
// // mapping(MowseDungeonAchievementsEnum => bool) achievementsUnlocked;
// // mapping(MowseDungeonAchievementsEnum => bool) achievementsClaimed;
// // MowseDungeonSimplePlayerAchievementsProgress achievementsProgress;
// }
enum MowseDungeonStatusEffectEnum {
NONE,
BLIND, // 1/2 chance of missing attack
EAGLE_EYE, // double chance of hitting atttack
POISON, // Damage per turn, pre attack
BURN, // Damage per turn, post attack
BLEED, // Damage per turn, post attack
CURSE, // % Damage per turn, pre attack
STUN, // Skip damage step
SILENCE, // Disable special ability
FREEZE, // Skip damage step, +50% damage taken from fire damage
STRENGTHEN, // Damage Up
WEAKEN, // Damage Down
BULK, // Defense Up
FRAIL, // Defense Down
THORNS, // Return damage on hit
REGEN, // Heal, pre attack
SLEEP, // Skip damage step, +150% damage taken, wakes up after damage taken
DEATH, // Kill player after x turns
INVINCIBLE, // Player does not receive damage
LAST_HOPE, // If player would die, set health to 1
DODGE, // Increase dodge chance
HEAL_BLOCK, // Disable healing
CHARM, // Skip damage step
COUNTER, // Basic attack after getting hit by a basic/special attack
PIERCE, // Attack through shield
CLEAVE, // Every attack hits all monsters
REVIVE, // After dying, revive with full health
UNSTOPPABLE,// Debuffs cannot be applied (existing ones still damage)
PETRIFY, // Skip damage step, can't receive damage from enemy attack
FIRE_RESIST, // Resist application of burn
POISON_RESIST,
FREEZE_RESIST,
STUN_RESIST,
SLEEP_RESIST,
CHARGED, // Used for boss abilities that take wind up time
DOUBLE_UP, // Apply double status effects
RAMPAGE, // Increase monster damage per turn
LONE_SURVIVOR,// If all other monsters are dead, increase damage
ROYAL_DECREE,// Cannot be directly targeted until all other monsters are dead
WRATHFUL_REPRISAL// Counter attack based off player attack
}
enum MowseDungeonSpecialAbilityEnum {
DEFEND, // Apply thorns/counter/shield+5 to self
POISON_GAS, // Apply poison to enemy
BOULDER_TOSS, // Charge up and deal 3x damage + stun
RAGE, // Apply STRENGTHEN to self
SUMMON_CLUCKO, // Summon a Clucko in an empty monster slot
THIN_STICK, // 80% dodge chance
BADMOUTH, // Apply SILENCE, WEAKEN, FRAIL to enemy
SUMMON_PUNK, // Summon up to 2 WRAT_PUNK in empty monster slots
CURSED_SLIME, // Apply CURSE to enemy
BLEEDING_SLIME, // Apply BLEED to enemy
IRON_GRASP, // Charge up and double shield. Next turn add shield to damage
IRON_PRAYER, // Grant shield to monsters other than self
JESTER_DANCE, // Apply CURSE/BLEED/BURN/POISON/STUN/SLEEP/CHARM/freeze to enemy
KNIGHTS_HONOR, // Apply STRENGTHEN to self and shield to self
QUEENS_GRACE, // Apply REGEN,STRENGTHEN,BULK to all monsters
KINGS_AUTHORITY, // Apply stun and charge up 2 turns, at end, deal damage equal to players coins
ROYAL_DECREE, // Summon up to 2 copper squire, then charge for 2 turns
HOARDERS_STASH, // Steal 25% of player's coins, add amount to current & max health
WRATHFUL_REPRISAL,// Apply WRATHFUL_REPRISAL to self
DESTRUCTIVE_ENVY,// Charge up 1 turn, copy player's attack
SEDUCTIVE_GAZE, // Apply CHARM +2 to player
INSATIABLE_FEAST,// Charge 1 turn, Consume all debuffs from self and all buffs from player, heal for 10% per debuff
ANTI_SONIC_SPEED,// Apply SLEEP to all players for 2 turns
NONE
}
enum MowseDungeonCompanionEnum {
NONE,
DIAMOND_BACK,
DEVILISH, // Get Copper Squire Achievement
WONDER_CHILD, // Get Novice Achievement
INVALID_COMPANION
}
enum MowseDungeonTrinketEnum {
DAGGER, // +10% attack
SLINGSHOT, // increase damage when enemy at max health
PENDANT_OF_LIFE, // +5 health pre attack
LEECH, // +10% lifesteal per stack
POISON_DAB, // +1 apply poison stack after attack
KINDLE, // +1 burn stack
BLOOD_LETTER, // +1 bleed stack
CURSED_RING, // +1 curse stack
STUN_ROD, // chance to apply +1 stun stack
SILENCE_BELL, // chance to apply +1 silence stack
STRENGTH_BELT, // +1 strengthen stack (2x damage)
WEAKENED_CHAIN, // +1 weaken stack (1/2 damage)
EMBLEM_OF_INITIATIVE, // +1 action
GOLD_RING, // increase coin drop 10% + 10% per stack
NONE
}
enum MowseDungeonRoomEnum {
MERCHANT, // Merchant
COIN_LOOT_ROOM,
TRINKET_LOOT_ROOM,
FOREST_SLIME_1, // 1 Green Slime
FOREST_SLIME_2, // 2 Green Slime
FOREST_SLIME_3, // 3 Green Slime
FOREST_MUSHY, // 2 Red Mushy
FOREST_PEBBLE, // 1 Pebble Golem 1 DUCKY
FOREST_TOAD, // 3 Spiny Toad
FOREST_ROOSTA, // 1 Roosta 2 Clucko
FOREST_STICK, // 3 Stick Bug
FOREST_WRAT_PUNK, // 2 WRAT_PUNK
FOREST_WRAT_GANG_LEADER, // 1 Wrat Gang Leader
RAIN_OF_FROGS, // 3 Spiny Toad
STICKY_SITUATION, // 2 Green Slime 1 Stick Bug
MEDIEVAL_SLIME_INTRO, // 1 Helmet Slime
MEDIEVAL_SQUIRE_INTRO, // 1 Copper Squire
MEDIEVAL_PRIEST_INTRO, // 2 Iron Priest
MEDIEVAL_SLIME, // 3 Helmet Slime
MEDIEVAL_SQUIRE, // 2 Copper Squire
MEDIEVAL_JESTER, // 2 Pyrite Jester
MEDIEVAL_KNIGHT, // 2 Steel Knight
MEDIEVAL_KNIGHT_PRIEST, // 1 Steel Knight 1 Iron Priest
MEDIEVAL_KNIGHT_SQUIRE, // 1 Steel Knight 1 CopperSquire
MEDIEVAL_MAIDEN, // 1 Iron Maiden 2 Iron Priest
MEDIEVAL_QUEEN, // 1 Silver Queen 1 SteelKnight
MEDIEVAL_KING, // 1 Gold King 1 SteelKnight
MEDIEVAL_ROYAL, // 1 Silver Queen 1 Gold King
BOSS_LIONS_PRIDE,
BOSS_GOBLINS_GREED,
BOSS_LICHS_WRATH,
BOSS_WRATS_ENVY,
BOSS_LUSTFUL_HEIRESS,
BOSS_GLUTTONOUS_PIG,
BOSS_SLOTHFUL_HEDGEHOG
}
enum MowseDungeonMonsterEnum {
// Forest
SPINY_TOAD,
GREEN_SLIME,
RED_MUSHY,
PEBBLE_GOLEM,
CLUCKO,
ROOSTA,
STICK_BUG,
DUCKY,
WRAT_PUNK,
WRAT_GANG_LEADER,
BLUE_SLIME,
RED_SLIME,
// Metal Medieval theme
HELMET_SLIME,
COPPER_SQUIRE,
IRON_MAIDEN,
IRON_PRIEST,
PYRITE_JESTER,
STEEL_KNIGHT,
SILVER_QUEEN,
GOLD_KING,
// Bosses
// 7 Deadly Sins
LIONS_PRIDE,
GOBLINS_GREED,
LICHS_WRATH,
WRATS_ENVY,
LUSTFUL_HEIRESS,
GLUTTONOUS_PIG,
SLOTHFUL_HEDGEHOG,
NONE
}
enum MowseDungeonClassEnum {
// Base Classes
WARRIOR, // Basic 100% damage Special ability whirlwind (apply cleave to self)
MAGE, // Basic 60% Special ability fireball (2x base attack, apply burn to enemy)
ARCHER, // Basic 80% damage, Special ability Hawkshot (apply eagle eye, deal damage x # of times)
ROGUE, // Basic 50% x 2 apply poison Special ability backstab (apply dodge 2x)
// Advanced Classes
PALADIN, // Basic 70% damage, Special ability Judgement Of Light (heal 30% max health + 1% per 10 int + 1% per 10 str)
GUARDIAN, // Basic 50% damage, gain shield Special ability shieldbash (gain extra shield, damage equal to shield)
BERSERKER,// Basic 120% Special ability rage (deal basic attack damage, apply strengthen, lastHope, silence to self)
CLERIC, // Basic 40% Special ability heal (apply regen to self)
NECROMANCER,// Basic 55% Special ability life tap (deal basic attack damage, if monster dies, permanently gain 10% attack)
BARD, // Basic 60% Special ability charm (apply charm to enemy)
// T2 Classes
INVALID_CLASS
}
enum MowseDungeonRoomTypeEnum {
MONSTER,
COIN_LOOT,
TRINKET_LOOT,
BOSS,
MERCHANT,
INVALID_ROOM
}
// Complete Achievements to unlock Companions
enum MowseDungeonAchievementsEnum {
NOVICE, // Complete the forest-0 dungeon
FOREST_MASTER, // Complete the forest-10 dungeon
COPPER_SQUIRE, // Complete the medieval-0 dungeon
IRON_MAIDEN, // Complete the medieval-3 dungeon
STEEL_KNIGHT, // Complete the medieval-6 dungeon
GOLD_KING, // Complete the medieval-9 dungeon
MASTER_OF_DEADLY_SINS,// Complete the medieval-10 dungeon
UNTOUCHABLE, // Defeat a boss without taking damage
POISON_MASTER, // Apply 99 stacks of poison in one dungeon
LOOT_GOBLIN, // Steal successfully more than 5 times in a single run
COIN_GOBLIN, // Have at least 500 coins in inventory
ONE_MAN_ARMY, // Deal 1000 damage in a single run
LEARN_THE_ROPES, // Complete any dungeon with all 4 base classes
WARRIOR, // Complete any dungeon with Warrior
MAGE, // Complete any dungeon with Mage
ARCHER, // Complete any dungeon with Archer
ROGUE, // Complete any dungeon with Rogue
PALADIN, // Complete any dungeon with Paladin
GUARDIAN, // Complete any dungeon with Guardian
BERSERKER, // Complete any dungeon with Berserker
CLERIC, // Complete any dungeon with Cleric
NECROMANCER, // Complete any dungeon with Necromancer
BARD, // Complete any dungeon with Bard
INVALID_ACHIEVEMENT
}
enum MowseDungeonActionTypeEnum {
BASIC_ATTACK,
SPECIAL_ABILITY,
STEAL,
DEFEND,
INVALID_ACTION
}
enum MowseDungeonBattleStatusEnum {
VICTORY,
DEFEAT,
ONGOING
}
enum MowseDungeonDungeonTypeEnum {
FOREST,
MEDIEVAL
}
enum MowseDungeonBattleLogTypeEnum {
INVALID_LOG_TYPE,
DAMAGE,
APPLY_STATUS_EFFECT,
HEAL,
SUMMON,
STEAL_SUCCESS,
STEAL_FAILURE
}
enum MowseDungeonBattleLogSourceEnum {
PLAYER,
MONSTER_1,
MONSTER_2,
MONSTER_3,
TARGET_INDEX_MONSTER, // Target a Monster according to targetIndex
COMPANION,
TRINKET_PENDANT_OF_LIFE,
TRINKET_LEECH,
STATUS_EFFECT_BLIND,
STATUS_EFFECT_EAGLE_EYE,
STATUS_EFFECT_POISON,
STATUS_EFFECT_BURN,
STATUS_EFFECT_BLEED,
STATUS_EFFECT_CURSE,
STATUS_EFFECT_STUN,
STATUS_EFFECT_SILENCE,
STATUS_EFFECT_FREEZE,
STATUS_EFFECT_STRENGTHEN,
STATUS_EFFECT_WEAKEN,
STATUS_EFFECT_BULK,
STATUS_EFFECT_FRAIL,
STATUS_EFFECT_THORNS,
STATUS_EFFECT_REGEN,
STATUS_EFFECT_SLEEP,
STATUS_EFFECT_DEATH,
STATUS_EFFECT_INVINCIBLE,
STATUS_EFFECT_LAST_HOPE,
STATUS_EFFECT_DODGE,
STATUS_EFFECT_HEAL_BLOCK,
STATUS_EFFECT_CHARM,
STATUS_EFFECT_COUNTER,
STATUS_EFFECT_PIERCE,
STATUS_EFFECT_CLEAVE,
STATUS_EFFECT_REVIVE,
STATUS_EFFECT_UNSTOPPABLE,
STATUS_EFFECT_PETRIFY,
STATUS_EFFECT_FIRE_RESIST,
STATUS_EFFECT_POISON_RESIST,
STATUS_EFFECT_FREEZE_RESIST,
STATUS_EFFECT_STUN_RESIST,
STATUS_EFFECT_SLEEP_RESIST,
STATUS_EFFECT_CHARGED,
STATUS_EFFECT_DOUBLE_UP,
STATUS_EFFECT_RAMPAGE,
STATUS_EFFECT_LONE_SURVIVOR,
STATUS_EFFECT_ROYAL_DECREE,
STATUS_EFFECT_WRATHFUL_REPRISAL
}
struct MowseDungeonSimpleTrinkets {
uint256 dagger;
uint256 slingshot;
uint256 pendantOfLife;
uint256 leech;
uint256 poisonDab;
uint256 kindle;
uint256 bloodLetter;
uint256 cursedRing;
uint256 stunRod;
uint256 silenceBell;
uint256 strengthBelt;
uint256 weakenedChain;
uint256 emblemOfInitiative;
uint256 goldRing;
}
struct MowseDungeonSimpleStatusEffect {
uint256 blind;
uint256 eagleEye;
uint256 poison;
uint256 burn;
uint256 bleed;
uint256 curse;
uint256 stun;
uint256 silence;
uint256 freeze;
uint256 strengthen;
uint256 weaken;
uint256 bulk;
uint256 frail;
uint256 thorns;
uint256 regen;
uint256 sleep;
uint256 death;
uint256 invincible;
uint256 lastHope;
uint256 dodge;
uint256 healBlock;
uint256 charm;
uint256 counter;
uint256 pierce;
uint256 cleave;
uint256 revive;
uint256 unstoppable;
uint256 petrify;
uint256 fireResist;
uint256 poisonResist;
uint256 freezeResist;
uint256 stunResist;
uint256 sleepResist;
uint256 charged;
uint256 doubleUp;
uint256 rampage;
uint256 loneSurvivor;
uint256 royalDecree;
uint256 wrathfulReprisal;
}
struct MowseDungeonSimplePlayerAchievementsUnlocked {
bool novice;
bool forestMaster;
bool copperSquire;
bool ironMaiden;
bool steelKnight;
bool goldKing;
bool masterOfDeadlySins;
bool untouchable;
bool poisonMaster;
bool lootGoblin;
bool coinGoblin;
bool oneManArmy;
bool learnTheRopes;
bool warrior;
bool mage;
bool archer;
bool rogue;
bool paladin;
bool guardian;
bool berserker;
bool cleric;
bool necromancer;
bool bard;
}
struct MowseDungeonSimplePlayerAchievementsProgress {
uint256 damageDealt;
uint256 damageTaken;
uint256 healthHealed;
uint256 burnDamageDealt;
uint256 poisonDamageDealt;
uint256 bleedDamageDealt;
uint256 curseDamageDealt;
uint256 trinketsStolen;
}
struct MowseDungeonBattleLog {
MowseDungeonBattleLogTypeEnum logType;
MowseDungeonBattleLogSourceEnum source;
MowseDungeonBattleLogSourceEnum target;
uint256 amount;
}
struct MowseDungeonBattleSimulation {
MowseDungeonSimplePlayer player;
MowseDungeonSimpleMonster monster1;
MowseDungeonSimpleMonster monster2;
MowseDungeonSimpleMonster monster3;
uint256 dungeonId;
uint256 seed;
MowseDungeonActionTypeEnum actionType;
uint8 targetIndex;
uint256 actionsRun;
MowseDungeonTrinketEnum[] stolenTrinkets;
uint256 stolenTrinketCount;
bool isStealSuccessful;
MowseDungeonBattleStatusEnum status;
MowseDungeonSimplePlayerAchievementsProgress achievementProgress;
uint256 descentLevel;
MowseDungeonBattleLog[] battleLog;
uint256 battleLogCount;
}
struct MowseDungeonBattleResults {
MowseDungeonBattleSimulation simulation;
MowseDungeonPostBattleResults postBattleResults;
bytes32 actionsRunHash;
bytes32 postBattleResultsHash;
}
struct MowseDungeonPostBattleResults {
uint256 mowseId;
uint256 coins;
MowseDungeonMonsterEnum monster1;
MowseDungeonMonsterEnum monster2;
MowseDungeonMonsterEnum monster3;
MowseDungeonTrinketEnum[] stolenTrinkets;
uint256 stolenTrinketCount;
MowseDungeonBattleStatusEnum status;
MowseDungeonSimplePlayerAchievementsProgress achievementProgress;
uint256 descentLevel;
}
struct MowseDungeonDungeonRewards {
bool hasRewards;
uint256 mgoldMintAmount;
uint256 xpGainedAmount;
uint256 companionXpGained;
uint256 completionPercentage;
uint256 additionalFactor;
}
// Used for _performAction to calculate damage
struct MowseDungeonSimplePlayer {
uint256 mowseId;
int32[SKILL_TYPE_NUM] stats;
uint256 maxHealth;
uint256 currentHealth;
uint256 shield;
uint256 attack;
bool canHit;
uint256 accuracy;
uint256 tempAttack;
uint256 damageMultiplier;
uint256 action;
uint256 numberOfHits;
MowseDungeonClassEnum class;
MowseDungeonSimpleStatusEffect statusEffects;
MowseDungeonSimpleTrinkets trinkets;
MowseDungeonCompanion companion;
MowseDungeonDescentLevel descentLevel;
// MowseDungeonSimplePlayerAchievementsUnlocked achievements;
uint256 coins;
uint256 currentDungeonRunCount;
uint256 currentRoomIndex;
}
struct MowseDungeonPlayer {
uint256 mowseId;
int32[SKILL_TYPE_NUM] stats;
uint256 maxHealth;
uint256 currentHealth;
uint256 shield;
uint256 attack;
// uint256 maxAction; // Special Ability points
uint256 action;
// Maps StatusEffect to statusEffect value (ex: 1 (poison) => 2 is equal to 2 stacks of poison)
mapping(MowseDungeonStatusEffectEnum => uint256) statusEffects;
// Maps trinketIndex to MowseDungeonTrinketEnum
mapping(MowseDungeonTrinketEnum => MowseDungeonTrinket) trinkets;
// uint256 trinketCount;
mapping(MowseDungeonCompanionEnum => MowseDungeonCompanion) companions;
MowseDungeonCompanion currentCompanion;
uint256 coins;
MowseDungeonClassEnum class;
// Number of times a player has run a dungeon
uint256 dungeonRunCount;
MowseDungeonSimplePlayerAchievementsUnlocked achievements;
// Used for quickly checking if an achievement is unlocked
mapping(MowseDungeonAchievementsEnum => bool) achievementsUnlocked;
mapping(MowseDungeonAchievementsEnum => bool) achievementsClaimed;
MowseDungeonSimplePlayerAchievementsProgress achievementsProgress;
MowseDungeonDescentLevel descentLevel;
}
struct MowseDungeonPerformAction {
MowseDungeonActionTypeEnum actionType;
uint256 targetIndex;
}
// Used for _performAction to calculate damage
struct MowseDungeonSimpleMonster {
MowseDungeonMonsterEnum monsterType;
uint256 monsterId;
uint256 maxHealth;
uint256 currentHealth;
uint256 shield;
uint256 attack;
bool canHit;
uint256 accuracy;
uint256 tempAttack;
uint256 damageMultiplier;
MowseDungeonSpecialAbilityEnum specialAbility;
bool isBoss;
bool hasBeenStolen;
bool usedSpecialAbility;
MowseDungeonSimpleStatusEffect statusEffects;
string image;
}
// Used for setting default monster values
struct MowseDungeonMonsterAttributes {
bool isActive;
MowseDungeonMonsterEnum monsterType;
uint256 monsterId;
uint256 maxHealth;
uint256 shield;
uint256 attack;
MowseDungeonSpecialAbilityEnum specialAbility;
MowseDungeonSimpleStatusEffect statusEffects;
bool isBoss;
uint256 coins;
string name;
string image;
}
struct MowseDungeonMonster {
MowseDungeonMonsterEnum monsterType;
uint256 monsterId;
uint256 maxHealth;
uint256 currentHealth;
uint256 shield;
uint256 attack;
MowseDungeonSpecialAbilityEnum specialAbility;
mapping(MowseDungeonStatusEffectEnum => uint256) statusEffects;
// Bosses cannot be stunned, slept, etc.
bool isBoss;
// Maps monsterDropIndex to MowseDungeonTrinket
mapping(uint256 => MowseDungeonTrinket) monsterDrops;
uint256 monsterDropCount;
uint256 coins;
// Players can only use steal once per monster
bool hasBeenStolen;
string name;
}
// Trinkets are passive boosts to the player they can select after battle
// Trinkets do not carry over between dungeon run, however, you can enhance trinkets so they are stronger the next run
// Use MowseDungeonTrinketEnum id to conditionally apply statusEffects
struct MowseDungeonTrinket {
MowseDungeonTrinketEnum trinketId;
uint256 level;
// mapping(MowseDungeonStatusEffectEnum => uint256) statusEffects;
uint256 health;
uint256 shield;
uint256 attack;
}
// Should always have 5 items
struct MowseDungeonMerchantRoom {
MowseDungeonMerchantItem[] items;
}
struct MowseDungeonMerchantItem {
MowseDungeonTrinketEnum trinketId;
MowseDungeonTrinket trinket;
uint256 cost;
bool hasPurchased;
}
// Unlike Trinkets, Companions carry over between dungeon runs
// Companions can level up before a dungeon run
struct MowseDungeonCompanion {
MowseDungeonCompanionEnum companionId;
bool isUnlocked;
uint256 level;
uint256 experience;
}
struct MowseDungeonRoom {
MowseDungeonRoomEnum id;
MowseDungeonRoomTypeEnum roomType;
MowseDungeonMonsterEnum[] monsters;
}
struct MowseDungeon {
uint256 id; // Should be the VDF hash
MowseDungeonRoom[] rooms;
uint256 currentRoomIndex;
bool active;
MowseDungeonDungeonTypeEnum dungeonType;
MowseDungeonMerchantRoom merchantRoom;
uint256 descentLevel;
}
// 0 - normal
// 1 - +25% hp/shield
// 2 - +25% attack
// 3 - +25% attack, -25% coin
// 4 - +25% attack/hp/shield
// 5 - +25% attack/hp/shield, items cost 10% more
// 6 - +25% attack, +50% hp/shield
// 7 - +25% attack, +50% hp/shield, -25% coins
// 8 - +25% attack, +50% hp/shield, -25% coins, items cost 10% more
// 9 - +100% hp/shield, rampage
// 10 - +100% hp/shield, rampage, -25% coins, items cost 10% more
struct MowseDungeonDescentLevel {
uint256 forestDungeon;
uint256 medievalDungeon;
}
// Gather and Garnish
struct GatherAndGarnishScavenge {
uint256 woodCount;
uint256 rockCount;
uint256 gemCount;
uint256 foodCount;
}
struct GatherAndGarnishPlayerStats {
// Maps season day index -> action index taken [1 - gather, 2 - predict, 3 - build, 4 - invest]
mapping(uint256 => uint256) dailyAction;
uint256 woodStorage;
uint256 woodStorageLevel;
uint256 rockStorage;
uint256 rockStorageLevel;
uint256 gemStorage;
uint256 gemStorageLevel;
uint256 foodStorage;
uint256 foodStorageLevel;
uint256 investmentCount;
// Maps whether the player has built the first/second/third points structure
mapping(uint256 => bool) hasBuiltPointsStructure;
// Maps season day index -> resource type prediction [1-4, wood/rock/gem/food]
mapping(uint256 => uint256) prediction;
uint256 latestPredictionDay;
uint256 seasonFirstWinnerIndex;
}
struct TestPatch {
uint256 testPatchVersion;
uint256 uniqueInteractionCount; // Unique address interactions
address[] interactedAddresses; // Addresses that interacted
mapping(address => uint256) numberOfInteractions; // maps addresses -> number of times interacted
}
struct Mowse {
uint256 tokenId; // Mowse asset tokenId counter, also used to check if exists
address ownerAddress; // Owner Address
// BaseTraits required on all Mowse
uint16 generation;
MowseWearMetadata baseBackgroundColor; // Index 0
MowseWearMetadata baseSkinColor; // Index 2
MowseWearMetadata baseEarType; // Index 3
MowseWearMetadata baseBodyType; // Index 5
MowseWearMetadata baseMouth; // Index 6
MowseWearMetadata baseEyeType; // Index 8
// MowseJob
int32[SKILL_TYPE_NUM] skillLevelBoosts; // Additional Skill LEVEL modifiers
int32[SKILL_TYPE_NUM] skillLevel; // Base Skill LEVEL, increases as ExperiencePoints caps [charisma, constitution, dexterity, intelligence, luck, strength, wisdom]
// uint32[SKILL_TYPE_NUM] skillExperiencePoints; // Skill EXPERIENCE points
// uint16[SKILL_TYPE_NUM] skillExperiencePointsBoosts; // Additional Skill EXPERIENCE points boosts
uint8 primarySkillType; // Primary skill preference from birth (should be 0-6), cannot change
uint8 secondarySkillType; // Secondary skill preference from birth (should be 0-6, can be the same as primary skill), cannot change
uint8 profession; // Career (should be 0-7), can change.
// 0 = no profession
// 1 = Agriculture and Food
// 2 = Finance and Marketing
// 3 = Art and Manufacturing
// 4 = Science and Medicine
// 5 = Military
// 6 = Politics (Law and Government)
// 7 = Nursing and Childcare (Family-focused)
// MowseLife
uint16 lifeLevel; // LIFE Experience level
uint256 lifeExperiencePoints; // Life Experience points (as life level goes up, skill level can be increased)
uint256 prngNonce; // Used in Mowse PRNG (level up to randomly distribute stat points and onMint)
// MowseWear
uint256[EQUIPPED_WEARABLE_SLOTS] equippedMowseWearByTokenIds; // Currently equipped mowsewear tokenIds
// [backgroundColor, backgroundFeature, skinColor, earType, shirt, bodyType, mouth, eyeBrow, eyeType, eyeWear, headWear, jewelry]
}
// 1 Background Color
// 2 Background Feature
// 3 Skin Color
// 4 Ear Type
// 5 Shirt
// 6 Body Type
// 7 Mouth
// 8 Eye Brow Type
// 9 Eye Type
// 10 Eye Wear
// 11 Head Wear
// 12 Jewelry
struct MowseWear {
uint256 tokenId; // MowseWear asset tokenId counter, also used to check if exists
bool isEquipped; // Quick way to know if a MowseWear is equipped
uint256 equippedBy; // track which Mowse tokenId is equipped by
uint256 durability; // Durability time after stitching
uint256 alterCount; // Number of times a MowseWear has been altered (stitched or hemmed)
uint256 maxAlterCount; // Max number of times a MowseWear can be altered (stitched or hemmed)
MowseWearMetadata metadata;
MowseWearDimensions dimensions;
MowseWearBonuses bonuses;
}
struct MowseWearMetadata {
uint8 traitType; // Type of MowseWear (backgroundColor, shirt, eyeWear, etc) (should be 0-11)
string traitName; // MowseWear item name ("Blue Headband")
uint16 traitIndex; // MowseWear trait index (12th headband)
uint256 dictionaryIndex; // MowseWear dictionary index (12th item in dictionary)
bool nonTransferrable; // MowseWear can be traded or not (soulbound)
string svgFilter; // Any overrides on the svgFilter
MowseWearDimensions baseDimensions; // Base SVG Dimensions
}
struct MowseWearBonuses {
uint256 randomness; // Random seed for MowseWear
uint256 itemRarityIV; // Item Rarity inherent value (pseudorandom number between 0-4294967294)
uint8 itemRarity; // Item Rarity (common, uncommon, rare, epic, legendary, unique) (should be 0-5)
int32[SKILL_TYPE_NUM] baseSkillLevelBoosts; // Base Skill LEVEL modifiers from IV
int32[SKILL_TYPE_NUM] additionalSkillLevelBoosts; // Additional Skill LEVEL modifiers from other factors (set bonuses?)
}
struct MowseSkillTypes {
int32 charisma;
int32 constitution;
int32 dexterity;
int32 intelligence;
int32 luck;
int32 strength;
int32 wisdom;
}
struct MowseWearDimensions {
uint16 width;
uint16 height;
string transform;
string style;
string image;
uint16 weight;
}
struct MowseLootboxPool {
bool active; // Is lootbox active and can be minted from?
uint256 price; // Price per MowseGold (generic loot pool cheapest -> specific trait type more expensive -> event specific)
string name;
uint16 width; // Goes with image to create on-chain SVG
uint16 height; // Goes with image to create on-chain SVG
string image;
mapping(uint16 => uint256) lootPool; // TraitTypes & TraitIndexes in the lootPool for minting
uint16 itemCount; // Number of items in lootpool
uint256 dateAdded; // When the lootbox was added; Ex: Earlier lootboxes might have rarer items
uint256 index; // Index of the lootbox
}
// This struct is used by MowseLootboxFacet.getMowseLootboxData to return the lootPool mapping as well
struct MowseLootboxPoolData {
bool active;
uint256 price;
string name;
string image;
SimpleMowseLootboxPoolItem[] lootPool;
uint16 itemCount;
uint256 dateAdded;
uint64 index;
}
struct SimpleMowseLootboxPoolItem {
uint16 traitType;
uint16 traitIndex;
string traitName;
string image;
}
struct MowseLineage {
uint16 generation;
uint256 parent1;
uint256 parent2;
uint256[] children;
}
struct MowseBankStruct {
address _walletImplementation;
mapping(address => uint256) balances;
mapping(address => uint256) getTokenIdForWallet;
}
struct MowseGames {
string name;
bool active; // Game is active or disabled (disable if game updates or something. idk. Bad developer)
bytes32 gameHash;
uint256 totalNumberOfSubmits;
mapping(address => uint256) uniqueSubmitsByAddress;
address[] uniqueAddressesList;
uint256 uniqueAddressesCount;
mapping(address => uint256[3]) dailySubmits;
// Minimum score to pass to get the max payout MGOLD
uint256 minScoreForMaxPayout;
// For granting additional bonuses for special event days
bool rewardBonus;
// For paying game developers
address payable developerAddress;
}
library LibStorage {
function gameStorage() internal pure returns (GameStorage storage gs) {
assembly {
gs.slot := 0
}
}
function skillTypeToString(uint16 x) internal pure returns (string memory skillTypeString) {
require(x < SKILL_TYPE_NUM, "LibStorage: Invalid Skill Type");
if (x == 0) return "charisma";
if (x == 1) return "constitution";
if (x == 2) return "dexterity";
if (x == 3) return "intelligence";
if (x == 4) return "luck";
if (x == 5) return "strength";
if (x == 6) return "wisdom";
}
function equippableWearableSlotToString(uint8 traitType) internal pure returns (string memory wearableSlotString) {
require(traitType < EQUIPPED_WEARABLE_SLOTS, "LibStorage: Invalid Trait Type");
if (traitType == 0) return "backgroundColor";
if (traitType == 1) return "backgroundFeature";
if (traitType == 2) return "skinColor";
if (traitType == 3) return "earType";
if (traitType == 4) return "shirt";
if (traitType == 5) return "bodyType";
if (traitType == 6) return "mouth";
if (traitType == 7) return "eyeBrow";
if (traitType == 8) return "eyeType";
if (traitType == 9) return "eyeWear";
if (traitType == 10) return "headWear";
if (traitType == 11) return "jewelry";
}
function itemRarityToString(uint8 itemRarity) internal pure returns (string memory itemRarityString) {
if (itemRarity == 0) return "common";
if (itemRarity == 1) return "uncommon";
if (itemRarity == 2) return "rare";
if (itemRarity == 3) return "epic";
if (itemRarity == 4) return "legendary";
if (itemRarity == 5) return "unique";
}
}
contract WithStorage {
function skillTypeToString(uint16 skillType) internal pure returns (string memory) {
return LibStorage.skillTypeToString(skillType);
}
function equippedWearableSlotToString(uint8 traitType) internal pure returns (string memory) {
return LibStorage.equippableWearableSlotToString(traitType);
}
function itemRarityToString(uint8 itemRarity) internal pure returns (string memory) {
return LibStorage.itemRarityToString(itemRarity);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
library console {
address constant CONSOLE_ADDRESS =
0x000000000000000000636F6e736F6c652e6c6f67;
function _sendLogPayloadImplementation(bytes memory payload) internal view {
address consoleAddress = CONSOLE_ADDRESS;
/// @solidity memory-safe-assembly
assembly {
pop(
staticcall(
gas(),
consoleAddress,
add(payload, 32),
mload(payload),
0,
0
)
)
}
}
function _castToPure(
function(bytes memory) internal view fnIn
) internal pure returns (function(bytes memory) pure fnOut) {
assembly {
fnOut := fnIn
}
}
function _sendLogPayload(bytes memory payload) internal pure {
_castToPure(_sendLogPayloadImplementation)(payload);
}
function log() internal pure {
_sendLogPayload(abi.encodeWithSignature("log()"));
}
function logInt(int256 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
}
function logUint(uint256 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
}
function logString(string memory p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function logBool(bool p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function logAddress(address p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function logBytes(bytes memory p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
}
function logBytes1(bytes1 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
}
function logBytes2(bytes2 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
}
function logBytes3(bytes3 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
}
function logBytes4(bytes4 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
}
function logBytes5(bytes5 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
}
function logBytes6(bytes6 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
}
function logBytes7(bytes7 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
}
function logBytes8(bytes8 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
}
function logBytes9(bytes9 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
}
function logBytes10(bytes10 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
}
function logBytes11(bytes11 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
}
function logBytes12(bytes12 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
}
function logBytes13(bytes13 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
}
function logBytes14(bytes14 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
}
function logBytes15(bytes15 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
}
function logBytes16(bytes16 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
}
function logBytes17(bytes17 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
}
function logBytes18(bytes18 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
}
function logBytes19(bytes19 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
}
function logBytes20(bytes20 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
}
function logBytes21(bytes21 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
}
function logBytes22(bytes22 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
}
function logBytes23(bytes23 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
}
function logBytes24(bytes24 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
}
function logBytes25(bytes25 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
}
function logBytes26(bytes26 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
}
function logBytes27(bytes27 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
}
function logBytes28(bytes28 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
}
function logBytes29(bytes29 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
}
function logBytes30(bytes30 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
}
function logBytes31(bytes31 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
}
function logBytes32(bytes32 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
}
function log(uint256 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
}
function log(string memory p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function log(bool p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function log(address p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function log(uint256 p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
}
function log(uint256 p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
}
function log(uint256 p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
}
function log(uint256 p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
}
function log(string memory p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
}
function log(string memory p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
function log(string memory p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
}
function log(string memory p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
}
function log(bool p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
}
function log(bool p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
}
function log(bool p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
}
function log(bool p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
}
function log(address p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
}
function log(address p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
}
function log(address p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
}
function log(address p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
}
function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
}
function log(uint256 p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
}
function log(uint256 p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
}
function log(uint256 p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
}
function log(uint256 p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
}
function log(uint256 p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
}
function log(uint256 p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
}
function log(uint256 p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
}
function log(uint256 p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
}
function log(string memory p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
}
function log(string memory p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
}
function log(string memory p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
}
function log(string memory p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
}
function log(string memory p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
}
function log(string memory p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
}
function log(string memory p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
}
function log(string memory p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
}
function log(string memory p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
}
function log(string memory p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
}
function log(string memory p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
}
function log(string memory p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
}
function log(bool p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
}
function log(bool p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
}
function log(bool p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
}
function log(bool p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
}
function log(bool p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
}
function log(bool p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
}
function log(bool p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
}
function log(bool p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
}
function log(bool p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
}
function log(bool p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
}
function log(bool p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
}
function log(bool p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
}
function log(bool p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
}
function log(bool p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
}
function log(bool p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
}
function log(bool p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
}
function log(address p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
}
function log(address p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
}
function log(address p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
}
function log(address p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
}
function log(address p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
}
function log(address p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
}
function log(address p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
}
function log(address p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
}
function log(address p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
}
function log(address p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
}
function log(address p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
}
function log(address p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
}
function log(address p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
}
function log(address p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
}
function log(address p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
}
function log(address p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
}
}