mind-dex

;; title: MindDexq
;; version:
;; summary:
;; description:

;; 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))
  )
)