create-dubhe 1.2.0-pre.98 → 2.0.0

package/templates/nextjs/sui-farm/packages/contracts/src/harvest/sources/systems/crow_system.move

@@ -0,0 +1,96 @@
+module harvest::crow_system {
+    use sui::clock::Clock;
+    use dubhe::dapp_service::{DappStorage, UserStorage, ScenePermit};
+    use dubhe::dapp_service;
+    use dubhe::dapp_system;
+    use harvest::dapp_key::DappKey;
+    use harvest::migrate;
+    use harvest::error;
+    use harvest::gold;
+    use harvest::crow_charges;
+    use harvest::crow_damage;
+    use harvest::scarecrow;
+    use harvest::profile;
+    use harvest::world::World;
+
+    const CROW_CHARGE_REFILL_MS: u64 = 60 * 60 * 1000;
+    const MAX_CROW_CHARGES:      u8  = 3;
+    const CROW_DAMAGE_PCT:       u8  = 30;
+    const CROW_DEBUFF_DURATION:  u64 = 4 * 60 * 60 * 1000;
+    const SCARECROW_DURATION:    u64 = 4 * 60 * 60 * 1000;
+    const SCARECROW_COST:        u64 = 10;
+
+    #[error]
+    const ESelfAttack: vector<u8> = b"Cannot attack yourself";
+
+    /// Attack a target player with crows.  Consumes 1 crow charge and sets a
+    /// 30% harvest-debuff on the target for 4 hours via reactive write.
+    public entry fun attack(
+        dapp_storage:     &DappStorage,
+        attacker_storage: &mut UserStorage,
+        target_storage:   &mut UserStorage,
+        world_permit:     &mut ScenePermit<World>,
+        clock:            &Clock,
+        ctx:              &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        error::not_registered(profile::has(attacker_storage));
+        error::not_registered(profile::has(target_storage));
+
+        let now = sui::clock::timestamp_ms(clock);
+        let attacker = ctx.sender();
+        let target_addr = dapp_service::canonical_owner(target_storage);
+        assert!(attacker != target_addr, ESelfAttack);
+
+        maybe_refill_charges(attacker_storage, now, ctx);
+
+        let charges = crow_charges::get_count(attacker_storage);
+        error::crow_no_charges(charges > 0);
+
+        let target_protected = scarecrow::has(target_storage) &&
+            now < scarecrow::get(target_storage);
+        error::crow_target_protected(!target_protected);
+
+        crow_charges::set_count(attacker_storage, charges - 1, ctx);
+
+        crow_damage::set_reactive(
+            world_permit,
+            attacker_storage,
+            target_storage,
+            now + CROW_DEBUFF_DURATION,
+            CROW_DAMAGE_PCT,
+            ctx,
+        );
+    }
+
+    /// Place a scarecrow to protect your farm for 4 hours.
+    public entry fun place_scarecrow(
+        dapp_storage:  &DappStorage,
+        user_storage:  &mut UserStorage,
+        clock:         &Clock,
+        ctx:           &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        error::not_registered(profile::has(user_storage));
+        error::insufficient_gold(gold::get(user_storage) >= SCARECROW_COST);
+
+        let now = sui::clock::timestamp_ms(clock);
+        gold::sub(user_storage, SCARECROW_COST, ctx);
+        scarecrow::set(user_storage, now + SCARECROW_DURATION, ctx);
+    }
+
+    // ─── Helpers ──────────────────────────────────────────────────────────────
+
+    fun maybe_refill_charges(user_storage: &mut UserStorage, now: u64, ctx: &mut TxContext) {
+        if (!crow_charges::has(user_storage)) { return };
+        let last_refill = crow_charges::get_last_refill_at(user_storage);
+        let current = crow_charges::get_count(user_storage);
+        if (current >= MAX_CROW_CHARGES || last_refill == 0) { return };
+        let elapsed = now - last_refill;
+        let earned = ((elapsed / CROW_CHARGE_REFILL_MS) as u8);
+        if (earned == 0) { return };
+        let new_count = current + earned;
+        let clamped = if (new_count > MAX_CROW_CHARGES) { MAX_CROW_CHARGES } else { new_count };
+        crow_charges::set(user_storage, clamped, now, ctx);
+    }
+}

package/templates/nextjs/sui-farm/packages/contracts/src/harvest/sources/systems/farm_system.move

@@ -0,0 +1,182 @@
+module harvest::farm_system {
+    use sui::clock::Clock;
+    use dubhe::dapp_service::{DappStorage, UserStorage};
+    use dubhe::dapp_system;
+    use harvest::dapp_key::DappKey;
+    use harvest::migrate;
+    use harvest::error;
+    use harvest::wheat_seed;
+    use harvest::corn_seed;
+    use harvest::carrot_seed;
+    use harvest::pumpkin_seed;
+    use harvest::wheat;
+    use harvest::corn;
+    use harvest::carrot;
+    use harvest::pumpkin;
+    use harvest::farm_plot;
+    use harvest::profile;
+    use harvest::season_config;
+    use harvest::season_stats;
+    use harvest::crow_damage;
+
+    const CROP_NONE:    u8 = 0;
+    const CROP_WHEAT:   u8 = 1;
+    const CROP_CORN:    u8 = 2;
+    const CROP_CARROT:  u8 = 3;
+    const CROP_PUMPKIN: u8 = 4;
+
+    // Growth durations
+    const WHEAT_MS:   u64 = 1 * 60 * 1000;
+    const CORN_MS:    u64 = 2 * 60 * 1000;
+    const CARROT_MS:  u64 = 4 * 60 * 1000;
+    const PUMPKIN_MS: u64 = 5 * 60 * 1000;
+
+    // Harvest yield per seed planted (cheap crops = more yield, expensive = less)
+    const WHEAT_YIELD:   u64 = 6;   // cheap & fast  → 6x
+    const CORN_YIELD:    u64 = 4;   // medium        → 4x
+    const CARROT_YIELD:  u64 = 3;   // expensive     → 3x
+    const PUMPKIN_YIELD: u64 = 3;   // medium-exp    → 3x
+
+    const SEASON_BONUS_PCT: u64 = 200;
+
+    /// Plant seeds on farm plot `plot_id`.
+    /// Consumes exactly 1 seed from the dedicated seed inventory.
+    /// The stored count equals the crop's yield multiplier,
+    /// so harvesting returns yield_per_seed crops.
+    public entry fun plant(
+        dapp_storage:  &DappStorage,
+        user_storage:  &mut UserStorage,
+        plot_id:       u8,
+        crop_type:     u8,
+        clock:         &Clock,
+        ctx:           &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        error::not_registered(profile::has(user_storage));
+        error::invalid_crop_type(crop_type >= CROP_WHEAT && crop_type <= CROP_PUMPKIN);
+
+        let plots_owned = profile::get_plots_owned(user_storage);
+        error::plot_not_found(plot_id < plots_owned);
+
+        if (farm_plot::has(user_storage, plot_id)) {
+            let existing_crop = farm_plot::get_crop_type(user_storage, plot_id);
+            error::plot_already_planted(existing_crop == CROP_NONE);
+        };
+
+        // Check seed balance before deducting
+        error::insufficient_seeds(seed_balance(user_storage, crop_type) >= 1);
+
+        // Deduct exactly 1 seed from the seed-specific resource
+        deduct_seeds(user_storage, crop_type, 1, ctx);
+
+        let now = sui::clock::timestamp_ms(clock);
+        let duration = crop_duration(crop_type);
+        // Store the yield amount — harvest will return this many crops
+        let harvest_count = crop_yield(crop_type);
+        farm_plot::set(user_storage, plot_id, crop_type, harvest_count, now, now + duration, ctx);
+    }
+
+    /// Harvest a ready crop from farm plot `plot_id`.
+    /// Yields crops (not seeds) into the crop-specific resource.
+    public entry fun harvest(
+        dapp_storage:  &DappStorage,
+        user_storage:  &mut UserStorage,
+        plot_id:       u8,
+        clock:         &Clock,
+        ctx:           &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        error::not_registered(profile::has(user_storage));
+        error::plot_not_found(farm_plot::has(user_storage, plot_id));
+
+        let crop_type = farm_plot::get_crop_type(user_storage, plot_id);
+        error::plot_is_empty(crop_type != CROP_NONE);
+
+        let now = sui::clock::timestamp_ms(clock);
+        let harvest_at = farm_plot::get_harvest_at(user_storage, plot_id);
+        error::plot_not_ready(now >= harvest_at);
+
+        let base_count = farm_plot::get_count(user_storage, plot_id);
+
+        // Apply season bonus if the planted crop matches the active bonus crop.
+        let season_end  = season_config::get_end_ms(dapp_storage);
+        let bonus_crop  = season_config::get_bonus_crop(dapp_storage);
+        let season_id   = season_config::get_season_id(dapp_storage);
+        let boosted = season_id > 0 && now < season_end && crop_type == bonus_crop;
+        let after_bonus = if (boosted) { base_count * SEASON_BONUS_PCT / 100 } else { base_count };
+
+        // Apply crow_damage debuff if active.
+        let final_count = if (crow_damage::has(user_storage)) {
+            let cd_expires = crow_damage::get_expires_at(user_storage);
+            if (now < cd_expires) {
+                let dmg_pct = (crow_damage::get_damage_pct(user_storage) as u64);
+                after_bonus * (100 - dmg_pct) / 100
+            } else {
+                after_bonus
+            }
+        } else {
+            after_bonus
+        };
+
+        // Yield goes into the crop resource (not seeds)
+        mint_crop(user_storage, crop_type, final_count, ctx);
+
+        // Track earnings for season leaderboard.
+        let gold_value = crop_gold_value(crop_type) * final_count;
+        if (season_stats::has(user_storage)) {
+            let prev = season_stats::get(user_storage);
+            season_stats::set(user_storage, prev + gold_value, ctx);
+        } else {
+            season_stats::set(user_storage, gold_value, ctx);
+        };
+        let prev_total = profile::get_total_earned(user_storage);
+        profile::set_total_earned(user_storage, prev_total + gold_value, ctx);
+
+        // Clear the plot.
+        farm_plot::set(user_storage, plot_id, CROP_NONE, 0, 0, 0, ctx);
+    }
+
+    // ─── Helpers ──────────────────────────────────────────────────────────────
+
+    fun crop_duration(crop_type: u8): u64 {
+        if      (crop_type == CROP_WHEAT)   { WHEAT_MS   }
+        else if (crop_type == CROP_CORN)    { CORN_MS    }
+        else if (crop_type == CROP_CARROT)  { CARROT_MS  }
+        else                                { PUMPKIN_MS }
+    }
+
+    fun crop_yield(crop_type: u8): u64 {
+        if      (crop_type == CROP_WHEAT)   { WHEAT_YIELD   }
+        else if (crop_type == CROP_CORN)    { CORN_YIELD    }
+        else if (crop_type == CROP_CARROT)  { CARROT_YIELD  }
+        else                                { PUMPKIN_YIELD }
+    }
+
+    fun crop_gold_value(crop_type: u8): u64 {
+        if      (crop_type == CROP_WHEAT)   { 8   }
+        else if (crop_type == CROP_CORN)    { 35  }
+        else if (crop_type == CROP_CARROT)  { 120 }
+        else                                { 100 }
+    }
+
+    fun seed_balance(user_storage: &UserStorage, crop_type: u8): u64 {
+        if      (crop_type == CROP_WHEAT)   { if (wheat_seed::has(user_storage))   { wheat_seed::get(user_storage) }   else { 0 } }
+        else if (crop_type == CROP_CORN)    { if (corn_seed::has(user_storage))    { corn_seed::get(user_storage) }    else { 0 } }
+        else if (crop_type == CROP_CARROT)  { if (carrot_seed::has(user_storage))  { carrot_seed::get(user_storage) }  else { 0 } }
+        else                                { if (pumpkin_seed::has(user_storage)) { pumpkin_seed::get(user_storage) } else { 0 } }
+    }
+
+    fun deduct_seeds(user_storage: &mut UserStorage, crop_type: u8, amount: u64, ctx: &mut TxContext) {
+        if      (crop_type == CROP_WHEAT)   { wheat_seed::sub(user_storage, amount, ctx)   }
+        else if (crop_type == CROP_CORN)    { corn_seed::sub(user_storage, amount, ctx)    }
+        else if (crop_type == CROP_CARROT)  { carrot_seed::sub(user_storage, amount, ctx)  }
+        else                                { pumpkin_seed::sub(user_storage, amount, ctx) }
+    }
+
+    fun mint_crop(user_storage: &mut UserStorage, crop_type: u8, amount: u64, ctx: &mut TxContext) {
+        if      (crop_type == CROP_WHEAT)   { wheat::add(user_storage, amount, ctx)   }
+        else if (crop_type == CROP_CORN)    { corn::add(user_storage, amount, ctx)    }
+        else if (crop_type == CROP_CARROT)  { carrot::add(user_storage, amount, ctx)  }
+        else                                { pumpkin::add(user_storage, amount, ctx) }
+    }
+}

package/templates/nextjs/sui-farm/packages/contracts/src/harvest/sources/systems/market_system.move

@@ -0,0 +1,172 @@
+/// Public entry wrappers for the listable crop market.
+///
+/// The framework's `take_fungible_record` (list) and `buy_fungible_record`
+/// (buy) both enforce `ctx.sender() == canonical_owner(user_storage)`, so
+/// session keys are rejected at the framework level — no extra check needed
+/// here.
+///
+/// CoinType = 0x2::sui::SUI  (price denominated in MIST)
+module harvest::market_system {
+    use sui::sui::SUI;
+    use sui::coin::{Self, Coin};
+    use dubhe::dapp_service::{DappHub, DappStorage, UserStorage};
+    use dubhe::dapp_system;
+    use harvest::dapp_key::DappKey;
+    use harvest::migrate;
+    use harvest::wheat;
+    use harvest::corn;
+    use harvest::carrot;
+    use harvest::pumpkin;
+
+    const CROP_WHEAT:   u8 = 1;
+    const CROP_CORN:    u8 = 2;
+    const CROP_CARROT:  u8 = 3;
+    const CROP_PUMPKIN: u8 = 4;
+
+    // ── List a crop batch for sale ─────────────────────────────────────────────
+
+    public entry fun list_wheat(
+        dapp_storage: &DappStorage,
+        user_storage: &mut UserStorage,
+        amount:       u64,
+        price:        u64,   // total price in MIST
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        wheat::list<SUI>(user_storage, amount, price, std::option::none(), ctx);
+    }
+
+    public entry fun list_corn(
+        dapp_storage: &DappStorage,
+        user_storage: &mut UserStorage,
+        amount:       u64,
+        price:        u64,
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        corn::list<SUI>(user_storage, amount, price, std::option::none(), ctx);
+    }
+
+    public entry fun list_carrot(
+        dapp_storage: &DappStorage,
+        user_storage: &mut UserStorage,
+        amount:       u64,
+        price:        u64,
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        carrot::list<SUI>(user_storage, amount, price, std::option::none(), ctx);
+    }
+
+    public entry fun list_pumpkin(
+        dapp_storage: &DappStorage,
+        user_storage: &mut UserStorage,
+        amount:       u64,
+        price:        u64,
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        pumpkin::list<SUI>(user_storage, amount, price, std::option::none(), ctx);
+    }
+
+    // ── Buy a listing ──────────────────────────────────────────────────────────
+    // The `listing` argument is the shared Listing object.
+    // `payment` must be a Coin<SUI> with value >= listing.price.
+    // Any overpayment is returned to the buyer.
+
+    public entry fun buy_wheat(
+        dh:           &DappHub,
+        dapp_storage: &mut DappStorage,
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        payment:      Coin<SUI>,
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        let change = wheat::buy<SUI>(dh, dapp_storage, listing, user_storage, payment, ctx);
+        return_change(change, ctx);
+    }
+
+    public entry fun buy_corn(
+        dh:           &DappHub,
+        dapp_storage: &mut DappStorage,
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        payment:      Coin<SUI>,
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        let change = corn::buy<SUI>(dh, dapp_storage, listing, user_storage, payment, ctx);
+        return_change(change, ctx);
+    }
+
+    public entry fun buy_carrot(
+        dh:           &DappHub,
+        dapp_storage: &mut DappStorage,
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        payment:      Coin<SUI>,
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        let change = carrot::buy<SUI>(dh, dapp_storage, listing, user_storage, payment, ctx);
+        return_change(change, ctx);
+    }
+
+    public entry fun buy_pumpkin(
+        dh:           &DappHub,
+        dapp_storage: &mut DappStorage,
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        payment:      Coin<SUI>,
+        ctx:          &mut TxContext,
+    ) {
+        dapp_system::ensure_latest_version<DappKey>(dapp_storage, migrate::on_chain_version());
+        let change = pumpkin::buy<SUI>(dh, dapp_storage, listing, user_storage, payment, ctx);
+        return_change(change, ctx);
+    }
+
+    // ── Cancel a listing (seller only) ────────────────────────────────────────
+
+    public entry fun cancel_wheat(
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        wheat::cancel_listing<SUI>(listing, user_storage, ctx);
+    }
+
+    public entry fun cancel_corn(
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        corn::cancel_listing<SUI>(listing, user_storage, ctx);
+    }
+
+    public entry fun cancel_carrot(
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        carrot::cancel_listing<SUI>(listing, user_storage, ctx);
+    }
+
+    public entry fun cancel_pumpkin(
+        listing:      dubhe::dapp_service::Listing<SUI>,
+        user_storage: &mut UserStorage,
+        ctx:          &TxContext,
+    ) {
+        pumpkin::cancel_listing<SUI>(listing, user_storage, ctx);
+    }
+
+    // ── Helper ────────────────────────────────────────────────────────────────
+
+    fun return_change(change: Coin<SUI>, ctx: &TxContext) {
+        if (coin::value(&change) > 0) {
+            sui::transfer::public_transfer(change, ctx.sender());
+        } else {
+            coin::destroy_zero(change);
+        }
+    }
+}