BlockRaider2

;;BlockRaid Game Contract

;; title: quest
;; version:
;; summary:
;; description:
;; Constants
(define-constant ERR-NOT-ADMIN (err u100))
(define-constant ERR-NOT-FOUND (err u101))
(define-constant ERR-INVALID-PARAMS (err u102))
(define-constant ERR-UNAUTHORIZED (err u103))
(define-constant ERR-INVALID-PRICE (err u104))
(define-constant ERR-INVALID-LEVEL (err u105))
(define-constant ERR-INVALID-TEAM (err u106))

;; traits
;;
;; Data Variables
(define-data-var admin principal tx-sender)
(define-data-var min-price uint u1)
(define-data-var max-price uint u1000000000)
(define-data-var max-level uint u100)

;; token definitions
;;
;; Non-Fungible Token Definition
(define-non-fungible-token game-item uint)

;; constants
;;
;; Maps
(define-map players 
    principal 
    {
        level: uint,
        experience: uint,
        inventory: (list 10 uint),
        achievements: (list 5 uint)
    }
)

;; data vars
;;
(define-map teams 
    uint 
    { 
        leader: principal,
        members: (list 4 principal)
    }
)

;; data maps
;;
(define-map market-listings
    uint
    {
        price: uint,
        seller: principal,
        active: bool
    }
)


;; Private functions
;;
(define-private (is-valid-item (item-id uint))
    (is-some (nft-get-owner? game-item item-id))
)

(define-private (validate-price (price uint))
    (and (>= price (var-get min-price))
         (<= price (var-get max-price)))
)

(define-private (validate-level (level uint))
    (<= level (var-get max-level))
)


(define-private (own-item (item-id uint))
    (is-eq (some tx-sender) (nft-get-owner? game-item item-id))
)

;; Read-Only Functions
(define-read-only (get-player-data (player principal))
    (map-get? players player)
)

(define-read-only (get-team-data (team-id uint))
    (map-get? teams team-id)
)

(define-read-only (get-market-listing (item-id uint))
    (map-get? market-listings item-id)
)

;; Player Management
(define-public (register-player)
    (begin
        (asserts! (is-none (map-get? players tx-sender)) ERR-INVALID-PARAMS)
        (ok (map-set players 
            tx-sender
            {
                level: u1,
                experience: u0,
                inventory: (list u0 u0 u0 u0 u0 u0 u0 u0 u0 u0),
                achievements: (list u0 u0 u0 u0 u0)
            }
        ))
    )
)

;; Team System
(define-public (create-team (team-id uint))
    (begin
        (asserts! (is-none (map-get? teams team-id)) ERR-INVALID-TEAM)
        (asserts! (is-some (map-get? players tx-sender)) ERR-NOT-FOUND)
        (ok (map-set teams 
            team-id 
            {
                leader: tx-sender,
                members: (list tx-sender tx-sender tx-sender tx-sender)
            }
        ))
    )
)

;; Marketplace System
(define-public (list-item-for-sale (item-id uint) (price uint))
    (begin
        (asserts! (validate-price price) ERR-INVALID-PRICE)
        (asserts! (own-item item-id) ERR-UNAUTHORIZED)
        (asserts! (is-valid-item item-id) ERR-NOT-FOUND)
        (ok (map-set market-listings
            item-id
            { 
                price: price, 
                seller: tx-sender,
                active: true 
            }
        ))
    )
)

(define-public (buy-item (item-id uint))
    (let (
        (listing (unwrap! (map-get? market-listings item-id) ERR-NOT-FOUND))
        (price (get price listing))
        (seller (get seller listing))
        (active (get active listing))
    )
        (begin
            (asserts! active ERR-NOT-FOUND)
            (asserts! (is-valid-item item-id) ERR-NOT-FOUND)
            (try! (stx-transfer? price tx-sender seller))
            (try! (nft-transfer? game-item item-id seller tx-sender))
            (map-set market-listings item-id
                (merge listing { active: false }))
            (ok true)
        )
    )
)

;; Game Item Management
(define-public (mint-item (item-id uint) (recipient principal))
    (begin
        (asserts! (is-eq tx-sender (var-get admin)) ERR-NOT-ADMIN)
        (asserts! (is-some (map-get? players recipient)) ERR-NOT-FOUND)
        (asserts! (not (is-valid-item item-id)) ERR-INVALID-PARAMS)
        (nft-mint? game-item item-id recipient)
    )
)

;; Player Progress
(define-public (gain-experience (amount uint))
    (let (
        (player-data (unwrap! (map-get? players tx-sender) ERR-NOT-FOUND))
        (current-exp (get experience player-data))
        (new-exp (+ current-exp amount))
    )
        (ok (map-set players 
            tx-sender
            (merge player-data { experience: new-exp })
        ))
    )
)

;; Level System
(define-public (level-up)
    (let (
        (player-data (unwrap! (map-get? players tx-sender) ERR-NOT-FOUND))
        (current-exp (get experience player-data))
        (current-level (get level player-data))
        (next-level (+ current-level u1))
    )
        (begin
            (asserts! (validate-level next-level) ERR-INVALID-LEVEL)
            (asserts! (>= current-exp (* current-level u100)) ERR-INVALID-PARAMS)
            (ok (map-set players 
                tx-sender
                (merge player-data
                    { 
                        level: next-level,
                        experience: u0
                    }
                )
            ))
        )
    )
)

;; Admin Functions
(define-public (set-admin (new-admin principal))
    (begin
        (asserts! (is-eq tx-sender (var-get admin)) ERR-NOT-ADMIN)
        (asserts! (not (is-eq new-admin (var-get admin))) ERR-INVALID-PARAMS)
        (ok (var-set admin new-admin))
    )
)