🥮 mooncakes.io

abyssal_chord

深渊协奏 (Abyssal Chord) - A MoonBit card battle game engine with CLI demo

game
card-game
roguelike
battle
moon add sssssurf/abyssal_chord@0.1.0
Download zip
Author
Version
0.1.0
License
Apache-2.0
Repository
Last updated
last month
Downloads
16
README

#深渊协奏 (Abyssal Chord) — MoonBit 卡牌对战游戏引擎

#📋 项目申报信息

项目详情
项目名称深渊协奏 (Abyssal Chord) — MoonBit 卡牌对战游戏引擎
项目方向游戏引擎 / 卡牌策略游戏
适用场景单机卡牌对战、局域网多人对战、AI 难度挑战、生存模式
实现语言MoonBit（主要）+ TypeScript（前端可视化）
GitHubhttps://github.com/sssssurf/abyssal-chord
Gitlinkhttps://gitlink.org.cn/surf3/abyssal-chord
许可证Apache-2.0
原创性原创项目，卡牌体系与游戏机制为自主设计

#🎯 项目简介

深渊协奏是一款基于 MoonBit 语言开发的回合制卡牌对战游戏引擎。玩家扮演"调音师"，利用声波武器、护甲系统和永久能力与畸变体战斗。项目核心引擎完全使用 MoonBit 实现，同时提供 Next.js + React 的 Web 可视化前端，支持单人对战、局域网联机对战、生存模式和 Boss Rush 等多种玩法。

#为什么值得做？

  1. MoonBit 游戏开发生态空白 — 目前 MoonBit 生态中缺乏完整的游戏引擎参考实现，本项目可以作为 MoonBit 游戏开发的参考案例
  2. 卡牌策略的复杂逻辑验证 — 36张卡牌、4种流派、11种状态效果的组合逻辑，充分验证 MoonBit 在复杂业务逻辑中的表现力
  3. 完整的工程实践 — 从类型系统设计、状态管理、AI 系统到测试覆盖，展示了 MoonBit 工程最佳实践

#🎮 核心功能

#卡牌系统（55张卡牌）

  • 钟律牌库（20张）：低频堡垒流、过载冲击流
  • 弦音牌库（16张）：高频刺客流、回声幻影流
  • 扩展卡牌（15张）：通用卡牌补充
  • 中立卡牌（4张）：通用效果

#战斗引擎

  • HP/护甲/AP 资源管理系统
  • 5级污染度系统（影响全局战斗参数）
  • 声爆 Debuff 叠加与引爆机制
  • 永久能力牌（打出后整场生效）
  • 遗物系统（4个角色专属遗物）
  • 阵型系统（5种战术阵型）

#敌人 AI

  • 7种敌人（含2个Boss，支持二阶段转换）
  • 骰子驱动的行动选择算法
  • 4级 AI 难度（简单/普通/困难/噩梦）

#游戏模式

  • 快速对战（10种预设对局）
  • 生存模式（无尽波次+难度递增）
  • Boss Rush（连续挑战双Boss）
  • 训练模式（流派专项练习）
  • 本地联机对战（WebSocket 多人同步）

#辅助系统

  • 108个自动化测试（全部通过）
  • AI vs AI 战斗模拟器（平衡性测试）
  • 战斗回放系统（录制与回放）
  • 卡牌数据库查询系统
  • 自定义套牌构建器
  • 每日挑战系统
  • 40项成就系统
  • JSON 序列化（战斗状态导入/导出）

#🏗️ 技术架构

#核心引擎 (MoonBit 5,266行)

engine/
├── types.mbt              # 核心类型定义 (193行)
├── battle_effect.mbt      # 卡牌效果解析引擎 (255行)
├── battle_state.mbt       # 战斗状态管理 (124行)
├── enemy_ai.mbt           # 敌人AI系统 (96行)
├── ai_levels.mbt          # AI难度等级 (179行)
├── xian_yin_engine.mbt    # 弦音专属引擎 (202行)
├── relic_engine.mbt       # 遗物系统 (104行)
├── battle_formation.mbt   # 阵型系统 (133行)
├── survival_mode.mbt      # 生存模式 (159行)
├── multiplayer_engine.mbt # 多人对战引擎 (379行)
├── achievements.mbt       # 成就系统 (194行)
├── daily_challenge.mbt    # 每日挑战 (重建中)
├── card_database.mbt      # 卡牌数据库 (247行)
├── deck_builder.mbt       # 套牌构建器 (200行)
├── card_synergy.mbt       # 卡牌协同系统 (199行)
├── balance_calc.mbt       # 平衡性计算器 (249行)
├── battle_replay.mbt      # 战斗回放 (184行)
├── battle_simulator.mbt   # 战斗模拟器 (140行)
├── json_io.mbt            # JSON序列化 (171行)
├── game_guide.mbt         # 游戏攻略手册 (221行)
├── interactive_cli.mbt    # 交互CLI (331行)
├── card_data.mbt          # 卡牌数据 (38行)
├── more_cards.mbt         # 扩展卡牌 (56行)
├── card_rebalance.mbt     # 卡牌平衡分析 (149行)
├── character_data.mbt     # 角色数据 (28行)
├── enemy_data.mbt         # 敌人数据 (70行)
├── more_enemies.mbt       # 扩展敌人 (130行)
├── pollution.mbt          # 污染度系统 (41行)
├── engine_test.mbt # 自动化测试 (698行)
└── cmd/main/main.mbt      # CLI演示入口 (93行)

#前端展示 (TypeScript/Next.js)

  • React + Framer Motion 动画
  • WebSocket 多人实时对战
  • 音效系统（战斗音效+BGM）
  • 污染度可视化、战斗记录面板

#🚀 快速开始

#环境要求

  • MoonBit 工具链（最新版）
  • pnpm（前端依赖管理）

#构建与运行

# MoonBit 引擎编译
cd engine
moon build              # 编译（0 errors）
moon test               # 运行测试（108/108 passed）
moon run cmd/main       # CLI 对战演示

# Web 前端运行
cd ../projects
pnpm install
pnpm dev                # 启动 http://localhost:5000

#可用路由

  • / — 主菜单
  • /battle — 单人突围
  • /lobby → /multiplayer — 局域网联机
  • /cards — 卡牌图鉴
  • /characters — 角色资料

#📊 项目统计

指标数值
MoonBit 源文件30个
MoonBit 代码行数5,266 行
TypeScript 代码行数~4,000 行（手写逻辑）
总卡牌数55 张
角色数2 个
敌人数7 个（含2 Boss）
游戏模式6 种
AI 难度等级4 级
自动化测试108 个（全部通过）
CI/CDGitHub Actions

#🎲 游戏机制说明

#污染度系统

等级范围效果
寂静期0-15无额外效果
低鸣期16-40敌人伤害+2
共振期41-70敌人伤害+4，每回合+3护甲
咆哮期71-90敌人伤害+6，每回合+5护甲，玩家穿透-3
终焉和弦91-100敌人伤害+10，玩家穿透-5

#流派体系

流派角色特点
低频堡垒钟律叠甲→转化伤害，以守为攻
过载冲击钟律自伤换超高爆发，血线换杀线
高频刺客弦音高频率低费攻击，声爆快速叠加
回声幻影弦音牌效翻倍，资源效率极致

#卡牌数值平衡

  • 基准：1AP = 5伤害 = 5护甲
  • 超模设计通过副作用平衡（自伤、污染代价、消耗）
  • 能力牌按投资回收期评估（1-3回合回本）

#🔧 开发历程

本项目使用 AI 工具（Claude Code）辅助开发，AI 负责：
  • 代码生成与调试
  • 卡牌平衡性分析
  • 测试用例编写
  • 文档生成

人类开发者负责：
  • 游戏机制与数值设计
  • 架构决策与代码审查
  • UI/UX 设计与实现
  • 最终质量把控

#📄 许可证

Apache-2.0 License

#
AIDifficulty

source
pub enum AIDifficulty {
  Easy_
  Normal_
  Hard_
  Nightmare_
} derive(Eq)

AI 难度等级 - 简单/普通/困难/噩梦

#
Achievement

source
pub struct Achievement {
  id : String
  name : String
  description : String
  category : AchievementCategory
  is_secret : Bool
  points : Int
}

#
AchievementCategory

source
pub enum AchievementCategory {
  Combat
  Collection
  Mastery
  Challenge
  Secret
} derive(Eq)

成就系统 - 40个可解锁的成就

#
ActiveAbility

source
pub struct ActiveAbility {
  id : String
  card_id : String
  name : String
  effect : String
}

#
ArchetypeGuide

source
pub struct ArchetypeGuide {
  name : String
  description : String
  key_cards : Array[String]
  playstyle : String
  strengths : String
  weaknesses : String
  recommended_relic : String
}

游戏攻略与数据手册 - Abyssal Chord 完整参考文档

#
BattleMetrics

source
pub struct BattleMetrics {
  turns_played : Int
  total_damage_dealt : Int
  total_damage_taken : Int
  total_armor_gained : Int
  total_sonic_boom_applied : Int
  cards_played : Int
  abilities_activated : Int
  pollution_peak : Int
  victory : Bool
}

#
BattlePhase

source
pub enum BattlePhase {
  PlayerTurn
  EnemyTurn
  Victory_
  Defeat_
} derive(Eq, Show)

#
BattleReplay

source
pub struct BattleReplay {
  character_id : String
  enemy_id : String
  frames : Array[ReplayFrame]
  total_frames : Int
  result : String
  duration : Int
  version : String
}

#
BattleState

source
pub struct BattleState {
  player : PlayerState
  enemy : EnemyState
  player_char : Character
  enemy_data : Enemy
  phase : BattlePhase
  turn_number : Int
  pollution : Int
  log : Array[String]
}

#
BossRushState

source
pub enum BossRushState {
  NotStarted
  InProgress
  Completed_
  Failed
} derive(Eq)

#
Card

source
pub struct Card {
  id : String
  name : String
  name_en : String
  card_type : CardType
  archetype : CardArchetype
  cost : Int
  target : CardTarget
  effect : String
  design_note : String
  base_damage : Int
  base_armor : Int
  self_damage : Int
  sonic_boom : Int
  pollution_modifier : Int
  exhaust : Bool
  retain : Bool
}

#
CardArchetype

source
pub enum CardArchetype {
  Basic
  Fortress
  Overload
} derive(Eq)

#
CardEfficiency

source
pub struct CardEfficiency {
  name : String
  ap_cost : Int
  raw_damage : Int
  raw_armor : Int
  self_damage : Int
  sonic_boom_value : Int
  utility_score : Double
  archetype_label : String
  tier : String
}

游戏平衡性计算器 - 卡牌数值模型与战斗模拟统计

#
CardQuery

source
pub struct CardQuery {
  card_type : String
  archetype : String
  min_cost : Int
  max_cost : Int
  target : String
  keyword : String
  has_special : Bool
  character : String
}
卡牌数据库 — 查询、过滤、搜索全部55张卡牌

#
CardTarget

source
pub enum CardTarget {
  Single
  Self
  Aoe
} derive(Eq)

#
CardType

source
pub enum CardType {
  Attack
  Skill
  Ability
} derive(Eq)

核心类型定义 - 卡牌、角色、敌人、污染系统的基础数据类型

#
Character

source
pub struct Character {
  id : String
  name : String
  name_en : String
  title : String
  title_en : String
  max_hp : Int
  relic : String
  relic_en : String
  relic_effect : String
  lore : String
}

#
CharacterComparison

source
pub struct CharacterComparison {
  aspect : String
  zhong_lv_value : String
  xian_yin_value : String
}

#
ChatMessage

source
pub struct ChatMessage {
  sender_id : String
  sender_name : String
  content : String
  turn : Int
  is_emote : Bool
}

#
Debuff

source
pub struct Debuff {
  debuff_type : DebuffType
  stacks : Int
}

#
DebuffType

source
pub enum DebuffType {
  SonicBoom
  Vulnerable
  Weak
  Poison
  Strength
  Thorn
} derive(Eq)

#
DeckConfig

source
pub struct DeckConfig {
  name : String
  character_id : String
  card_ids : Array[String]
  max_cards : Int
  min_cards : Int
  description : String
  total_cost : Int
}
自定义牌组构建器 — 赛前配置30张出战卡牌

#
DeckStats

source
pub struct DeckStats {
  total_cards : Int
  total_damage_potential : Int
  total_armor_potential : Int
  average_ap_cost : Double
  attack_ratio : Double
  skill_ratio : Double
  ability_ratio : Double
  s_tier_cards : Int
  a_tier_cards : Int
  b_tier_cards : Int
  c_tier_cards : Int
}

#
DifficultyConfig

source
pub struct DifficultyConfig {
  level : AIDifficulty
  label : String
  enemy_hp_mult : Double
  enemy_dmg_bonus : Int
  dice_bias : Int
  pollution_rate_bonus : Int
  player_ap_penalty : Int
}

#
Enemy

source
pub struct Enemy {
  id : String
  name : String
  name_en : String
  lore : String
  hp_1p : Int
  hp_2p : Int
  hp_3p : Int
  hp_4p : Int
  actions : Array[EnemyAction]
  is_boss : Bool
  has_phase2 : Bool
  phase2_actions : Array[EnemyAction]
  phase2_trigger : String
  phase2_effect : String
}

#
EnemyAction

source
pub struct EnemyAction {
  dice_min : Int
  dice_max : Int
  name : String
  name_en : String
  action_type : EnemyActionType
  effect : String
  damage : Int
  armor : Int
  sonic_boom : Int
  pollution_increase : Int
  piercing : Bool
  special : String
}

#
EnemyActionType

source
pub enum EnemyActionType {
  Attack_
  AttackDebuff
  Buff_
  Aoe_
  Special_
  Summon_
} derive(Eq)

#
EnemyState

source
pub struct EnemyState {
  id : String
  name : String
  hp : Int
  max_hp : Int
  armor : Int
  is_boss : Bool
  is_phase2 : Bool
  phase2_triggered : Bool
  summoned_minion : Bool
  reflect_active : Bool
  debuffs : Array[Debuff]
}

#
EnemyStrategy

source
pub struct EnemyStrategy {
  enemy_name : String
  threat_level : String
  recommended_approach : String
  dangerous_moves : Array[String]
  tips : Array[String]
}

#
Formation

source
pub struct Formation {
  name : String
  name_en : String
  formation_type : FormationType
  attack_bonus : Int
  armor_bonus : Int
  sonic_boom_multiplier : Double
  pollution_resistance : Int
  ap_bonus : Int
}

#
FormationType

source
pub enum FormationType {
  Vanguard
  Phalanx
  Assault
  Resonant
  Adaptive
} derive(Eq)

战斗阵型系统 - 多角色编队与协同作战

#
GameMode

source
pub enum GameMode {
  QuickBattle
  SurvivalMode
  BossRush
  Training
} derive(Eq)

交互式CLI模式 - 玩家可选择敌人、难度和流派

#
HighScore

source
pub struct HighScore {
  name : String
  score : Int
  wave : Int
  date : String
}

#
MatchResult

source
pub struct MatchResult {
  room_id : String
  winner_name : String
  loser_names : Array[String]
  total_turns : Int
  final_pollution : Int
  mvp_player : String
}

#
MultiplayerSlot

source
pub struct MultiplayerSlot {
  player_id : String
  name : String
  character : Character
  player_state : PlayerState
  is_connected : Bool
  is_ready : Bool
  is_eliminated : Bool
}

#
MultiplayerState

source
pub struct MultiplayerState {
  room_id : String
  players : Array[MultiplayerSlot]
  current_player_index : Int
  turn_number : Int
  pollution : Int
  is_active : Bool
  winner_id : String
  log : Array[String]
}

多人对战引擎 - 支持2-4人本地/网络对战

#
NetworkPacket

source
pub struct NetworkPacket {
  packet_type : String
  room_id : String
  player_id : String
  data : String
  sequence : Int
}

#
PlayerAchievement

source
pub struct PlayerAchievement {
  achievement_id : String
  unlocked : Bool
  unlocked_at : String
  progress : Int
  target : Int
}

#
PlayerState

source
pub struct PlayerState {
  id : String
  name : String
  hp : Int
  max_hp : Int
  armor : Int
  ap : Int
  max_ap : Int
  hand : Array[Card]
  deck : Array[Card]
  discard : Array[Card]
  exiled : Array[Card]
  permanent_abilities : Array[ActiveAbility]
  damage_bonus : Int
  armor_per_turn : Int
  extra_damage_per_armor : Double
  cards_played_this_turn : Int
  has_taken_self_damage : Bool
  next_attack_bonus : Int
  harmonic_active : Bool
  free_second_attack : Bool
  debuffs : Array[Debuff]
}

#
PollutionGuide

source
pub struct PollutionGuide {
  tier_name : String
  threshold : String
  what_to_do : String
  danger_warning : String
}

#
PollutionLevel

source
pub struct PollutionLevel {
  min_val : Int
  max_val : Int
  name : String
  name_en : String
  damage_bonus : Int
  armor_per_turn : Int
  player_piercing_dmg : Int
}

#
Relic

source
pub struct Relic {
  id : String
  relic_type : RelicType
  name : String
  name_en : String
  effect : String
  owner_id : String
}

#
RelicType

source
pub enum RelicType {
  OverloadFork
  SnappedString
  AnchorShard
  ResonanceCore
} derive(Eq)

遗物系统 - 角色专属遗物效果引擎

#
ReplayFrame

source
pub struct ReplayFrame {
  frame_id : Int
  action_type : String
  player_hp : Int
  player_armor : Int
  player_ap : Int
  enemy_hp : Int
  enemy_armor : Int
  pollution : Int
  card_id : String
  card_name : String
  enemy_action_name : String
  damage_dealt : Int
  damage_taken : Int
  armor_gained : Int
}
战斗回放系统 - 录制与回放完整的战斗历史

#
SimulationResult

source
pub struct SimulationResult {
  battles_run : Int
  player_wins : Int
  enemy_wins : Int
  avg_turns : Double
  avg_player_hp : Double
  avg_pollution : Double
  fastest_win : Int
  slowest_win : Int
  total_cards_played : Int
  total_damage_dealt : Int
  total_armor_gained : Int
}
AI vs AI 战斗模拟器 — 用于自动测试平衡性

#
SpectatorSlot

source
pub struct SpectatorSlot {
  spectator_id : String
  name : String
  joined_at_turn : Int
}

#
SurvivalState

source
pub struct SurvivalState {
  battle : BattleState
  wave : Int
  score : Int
  enemies_defeated : Int
  is_active : Bool
  difficulty_multiplier : Double
}

生存模式 - 无尽波次挑战

#
Synergy

source
pub struct Synergy {
  card_a_id : String
  card_b_id : String
  synergy_type : SynergyType
  description : String
  power_rating : Int
}

#
SynergyType

source
pub enum SynergyType {
  DirectCombo
  Conditional
  PassiveBoost
  ArchetypeCore
} derive(Eq)

卡牌协同系统 - 分析卡牌间combo和流派配合

#
TeamConfig

source
pub struct TeamConfig {
  leader : Character
  formation : Formation
  difficulty : Int
  enemy_id : String
}

#
TrainingSession

source
pub struct TrainingSession {
  target_enemy : Enemy
  target_archetype : String
  tips : Array[String]
  practice_attempts : Int
}

#
ability_name

source
fn ability_name(a : ActiveAbility) -> String

#
abyssal_shrieker

source
fn abyssal_shrieker() -> Enemy

#
achievement_score

source
fn achievement_score(achievements : Array[PlayerAchievement]) -> Int

#
adaptive

source
fn adaptive() -> Formation

#
add_card_to_deck

source
fn add_card_to_deck(config : DeckConfig, card_id : String) -> DeckConfig

#
add_enemy_armor

source
fn add_enemy_armor(state : BattleState, amount : Int) -> BattleState

#
add_log

source
fn add_log(state : BattleState, msg : String) -> BattleState

#
add_player_armor

source
fn add_player_armor(state : BattleState, amount : Int) -> BattleState

#
add_sonic_boom

source
fn add_sonic_boom(state : BattleState, stacks : Int) -> BattleState

#
add_spectator

source
fn add_spectator(spectators : Array[SpectatorSlot], name : String, turn : Int) -> Array[SpectatorSlot]

#
all_achievements

source
fn all_achievements() -> Array[Achievement]

#
all_cards

source
fn all_cards() -> Array[Card]

#
all_cards_with_expansion

source
fn all_cards_with_expansion() -> Array[Card]

#
all_characters

source
fn all_characters() -> Array[Character]

#
all_difficulty_labels

source
fn all_difficulty_labels() -> Array[String]

#
all_enemies

source
fn all_enemies() -> Array[Enemy]

#
all_enemies_full

source
fn all_enemies_full() -> Array[Enemy]

#
all_enemy_names

source
fn all_enemy_names() -> Array[String]

#
all_formations

source
fn all_formations() -> Array[Formation]

#
all_game_modes

source
fn all_game_modes() -> Array[GameMode]

#
all_guides

source
fn all_guides() -> Array[ArchetypeGuide]

#
all_relics

source
fn all_relics() -> Array[Relic]

#
all_strategies

source
fn all_strategies() -> Array[EnemyStrategy]

#
all_synergies

source
fn all_synergies() -> Array[Synergy]

#
analyze_deck

source
fn analyze_deck(cards : Array[Card]) -> DeckStats

#
analyze_efficiency

source
fn analyze_efficiency(replay : BattleReplay) -> String

#
anchor_shard

source
fn anchor_shard() -> Relic

#
apply_formation

source
fn apply_formation(state : BattleState, formation : Formation) -> BattleState

#
apply_relic_turn_start

source
fn apply_relic_turn_start(state : BattleState, relic : Relic) -> BattleState

#
apply_xian_yin_effect

source
fn apply_xian_yin_effect(state : BattleState, card : Card) -> BattleState

#
apply_xian_yin_relic

source
fn apply_xian_yin_relic(state : BattleState, cards_played : Int) -> BattleState

#
archetype_menu

source
fn archetype_menu() -> String

#
assassin_guide

source
fn assassin_guide() -> ArchetypeGuide

#
assassin_synergies

source
fn assassin_synergies() -> Array[Synergy]

#
assault

source
fn assault() -> Formation

#
balance_check

source
fn balance_check(char_id : String, enemy_id : String) -> String

#
battle_summary_to_json

source
fn battle_summary_to_json(state : BattleState) -> String

#
battle_ui

source
fn battle_ui(state : BattleState) -> String

#
benchmark_speed

source
fn benchmark_speed() -> String

#
boss_rush_enemies

source
fn boss_rush_enemies() -> Array[String]

#
can_start_game

source
fn can_start_game(state : MultiplayerState) -> Bool

#
card_statistics

source
fn card_statistics() -> String

#
card_to_json

source
fn card_to_json(card : Card) -> String

JSON 序列化 - 战斗状态导入/导出

#
cards_to_json

source
fn cards_to_json(cards : Array[Card]) -> String

#
challenge_achievements

source
fn challenge_achievements() -> Array[Achievement]

#
character_comparisons

source
fn character_comparisons() -> Array[CharacterComparison]

#
character_select_menu

source
fn character_select_menu() -> String

#
character_to_json

source
fn character_to_json(char : Character) -> String

#
check_achievement_progress

source
fn check_achievement_progress(achievements : Array[PlayerAchievement], achievement_id : String, progress : Int, target : Int) -> Array[PlayerAchievement]

#
check_defeat

source
fn check_defeat(state : BattleState) -> BattleState

#
check_multiplayer_game_over

source
fn check_multiplayer_game_over(state : MultiplayerState) -> Bool

#
check_overload_fork

source
fn check_overload_fork(state : BattleState, card_cost : Int) -> BattleState

#
check_resonance_core

source
fn check_resonance_core(state : BattleState, sonic_boom_stacks : Int) -> BattleState

#
check_snapped_string

source
fn check_snapped_string(state : BattleState, card_type : CardType, cards_played : Int) -> BattleState

#
check_victory

source
fn check_victory(state : BattleState) -> BattleState

#
collection_achievements

source
fn collection_achievements() -> Array[Achievement]

#
color_blue

source
fn color_blue() -> String

#
color_green

source
fn color_green() -> String

#
color_purple

source
fn color_purple() -> String

#
color_red

source
fn color_red() -> String

#
color_reset

source
fn color_reset() -> String

#
color_yellow

source
fn color_yellow() -> String

#
combat_achievements

source
fn combat_achievements() -> Array[Achievement]

#
compare_cards

source
fn compare_cards(card_a : Card, card_b : Card) -> String

#
compare_characters

source
fn compare_characters(enemy_id : String) -> String

#
compare_decks

source
fn compare_decks(deck_a : DeckConfig, deck_b : DeckConfig) -> String

#
count_cards_by_type

source
fn count_cards_by_type() -> String

#
count_enemy_actions

source
fn count_enemy_actions(replay : BattleReplay) -> Int

#
count_player_cards

source
fn count_player_cards(replay : BattleReplay) -> Int

#
create_message

source
fn create_message(sender_id : String, sender_name : String, content : String, turn : Int, is_emote : Bool) -> ChatMessage

#
create_packet

source
fn create_packet(packet_type : String, room_id : String, player_id : String, data : String, seq : Int) -> NetworkPacket

#
create_room

source
fn create_room(room_id : String, host_name : String, char_id : String) -> MultiplayerState

#
create_team_config

source
fn create_team_config(char_id : String, formation_type : FormationType, difficulty : Int, enemy_id : String) -> TeamConfig

#
create_training

source
fn create_training(archetype : String) -> TrainingSession

#
database_summary

source
fn database_summary() -> String

#
deal_damage_to_enemy

source
fn deal_damage_to_enemy(state : BattleState, raw_damage : Int, piercing : Bool) -> BattleState
Card effect resolution engine

#
deal_damage_to_player

source
fn deal_damage_to_player(state : BattleState, damage : Int, piercing : Bool) -> BattleState

#
deck_average_cost

source
fn deck_average_cost(config : DeckConfig) -> Double

#
deck_cost_distribution

source
fn deck_cost_distribution(config : DeckConfig) -> String

#
deck_statistics

source
fn deck_statistics(config : DeckConfig) -> String

#
deck_type_distribution

source
fn deck_type_distribution(config : DeckConfig) -> String

#
default_high_scores

source
fn default_high_scores() -> Array[HighScore]

#
defeat_text

source
fn defeat_text(state : BattleState) -> String

#
difficulty_from_id

source
fn difficulty_from_id(id : Int) -> AIDifficulty

#
difficulty_menu

source
fn difficulty_menu() -> String

#
draw_cards

source
fn draw_cards(state : BattleState, count : Int) -> BattleState

#
echo_guide

source
fn echo_guide() -> ArchetypeGuide

#
echo_remnant

source
fn echo_remnant() -> Enemy

更多敌人 - 扩展敌人图鉴

#
echo_synergies

source
fn echo_synergies() -> Array[Synergy]

#
end_player_turn

source
fn end_player_turn(state : BattleState) -> BattleState

#
enemy_statistics

source
fn enemy_statistics() -> String

#
enemy_to_json

source
fn enemy_to_json(enemy : Enemy) -> String

#
evaluate_card

source
fn evaluate_card(card : Card) -> CardEfficiency

#
evaluate_deck

source
fn evaluate_deck(cards : Array[Card]) -> Array[CardEfficiency]

#
execute_enemy_turn

source
fn execute_enemy_turn(state : BattleState) -> BattleState

#
execute_enemy_turn_with_ai

source
fn execute_enemy_turn_with_ai(state : BattleState, config : DifficultyConfig) -> BattleState

#
execute_query

source
fn execute_query(query : CardQuery) -> Array[Card]

#
expansion_card_count

source
fn expansion_card_count() -> Int

#
expansion_cards

source
fn expansion_cards() -> Array[Card]

卡牌平衡分析与新卡牌补充 - 基于数值模型进行平衡调整

#
export_deck

source
fn export_deck(config : DeckConfig) -> String

#
export_replay_json

source
fn export_replay_json(replay : BattleReplay) -> String

#
extra_enemies

source
fn extra_enemies() -> Array[Enemy]

#
find_card_by_id

source
fn find_card_by_id(card_id : String) -> Card

#
find_cards_by_name

source
fn find_cards_by_name(name : String) -> Array[Card]

#
find_synergies_for_card

source
fn find_synergies_for_card(card_id : String) -> Array[Synergy]

#
format_hand

source
fn format_hand(state : BattleState) -> String

#
formation_names

source
fn formation_names() -> Array[String]

#
fortress_guide

source
fn fortress_guide() -> ArchetypeGuide

#
fortress_synergies

source
fn fortress_synergies() -> Array[Synergy]

#
full_battle_report

source
fn full_battle_report(state : BattleState) -> String

#
game_mode_name

source
fn game_mode_name(mode : GameMode) -> String

#
game_statistics_summary

source
fn game_statistics_summary() -> String

#
generate_match_result

source
fn generate_match_result(state : MultiplayerState) -> MatchResult

#
get_ability_cards

source
fn get_ability_cards() -> Array[Card]

#
get_aoe_cards

source
fn get_aoe_cards() -> Array[Card]

#
get_attack_cards

source
fn get_attack_cards() -> Array[Card]

#
get_cards_by_cost

source
fn get_cards_by_cost(cost : Int) -> Array[Card]

#
get_character_by_id

source
fn get_character_by_id(char_id : String) -> Character

#
get_current_player

source
fn get_current_player(state : MultiplayerState) -> MultiplayerSlot

#
get_difficulty_config

source
fn get_difficulty_config(diff : AIDifficulty) -> DifficultyConfig

#
get_enemy_by_id

source
fn get_enemy_by_id(id : String) -> Enemy

#
get_fortress_cards

source
fn get_fortress_cards() -> Array[Card]

#
get_frame_at

source
fn get_frame_at(replay : BattleReplay, index : Int) -> ReplayFrame

#
get_hand

source
fn get_hand(state : BattleState) -> Array[Card]

#
get_highest_cost_card

source
fn get_highest_cost_card() -> Card

#
get_lowest_cost_card

source
fn get_lowest_cost_card() -> Card

#
get_most_armor_card

source
fn get_most_armor_card() -> Card

#
get_most_damage_card

source
fn get_most_damage_card() -> Card

#
get_opponents

source
fn get_opponents(state : MultiplayerState) -> Array[MultiplayerSlot]

#
get_overload_cards

source
fn get_overload_cards() -> Array[Card]

#
get_playable_cards

source
fn get_playable_cards(state : BattleState) -> Array[Card]

#
get_pollution_level

source
fn get_pollution_level(pollution : Int) -> PollutionLevel

#
get_relic_for_character

source
fn get_relic_for_character(char_id : String) -> Relic

#
get_skill_cards

source
fn get_skill_cards() -> Array[Card]

#
get_sonic_boom_multiplier

source
fn get_sonic_boom_multiplier(formation : Formation) -> Double

#
get_survival_summary

source
fn get_survival_summary(state : SurvivalState) -> String

#
get_training_tip

source
fn get_training_tip(session : TrainingSession) -> String

#
harmonic_construct

source
fn harmonic_construct() -> Enemy

#
harmonic_construct_strategy

source
fn harmonic_construct_strategy() -> EnemyStrategy

#
help_text

source
fn help_text() -> String

#
highest_rated_synergy

source
fn highest_rated_synergy() -> Synergy

#
howling_drifter

source
fn howling_drifter() -> Enemy

敌人数据

#
howling_drifter_strategy

source
fn howling_drifter_strategy() -> EnemyStrategy

#
import_deck

source
fn import_deck(data : String, name : String, character_id : String) -> DeckConfig

#
increase_pollution

source
fn increase_pollution(state : BattleState, amount : Int) -> BattleState

#
init_battle

source
fn init_battle(player_char : Character, enemy_data : Enemy) -> BattleState

#
init_boss_rush

source
fn init_boss_rush() -> (BattleState, BossRushState)

#
init_enemy

source
fn init_enemy(enemy_data : Enemy) -> EnemyState

#
init_player

source
fn init_player(character : Character) -> PlayerState

#
init_player_achievements

source
fn init_player_achievements() -> Array[PlayerAchievement]

#
init_quick_battle

source
fn init_quick_battle(config_id : Int, difficulty_id : Int) -> BattleState

#
init_survival

source
fn init_survival(char : Character) -> SurvivalState

#
init_xian_yin_player

source
fn init_xian_yin_player() -> PlayerState

弦音（频率猎手）专属引擎 - 高频刺客流 & 回声幻影流

#
initial_hand

source
fn initial_hand() -> Array[Card]

#
initial_pollution

source
fn initial_pollution() -> Int

#
intermission_heal

source
fn intermission_heal(state : SurvivalState) -> SurvivalState

#
is_pollution_max

source
fn is_pollution_max(pollution : Int) -> Bool

#
is_sonic_boom

source
fn is_sonic_boom(d : Debuff) -> Bool

#
is_survival_over

source
fn is_survival_over(state : SurvivalState) -> Bool

#
is_valid_json_summary

source
fn is_valid_json_summary(json_str : String) -> Bool

#
join_room

source
fn join_room(state : MultiplayerState, name : String, char_id : String) -> MultiplayerState

#
list_all_card_names

source
fn list_all_card_names() -> Array[String]

#
main_menu_text

source
fn main_menu_text() -> String

#
mark_replay_end

source
fn mark_replay_end(replay : BattleReplay, result : String) -> BattleReplay

#
mastery_achievements

source
fn mastery_achievements() -> Array[Achievement]

#
max_pollution

source
fn max_pollution() -> Int

#
merge_replays

source
fn merge_replays(replay_a : BattleReplay, replay_b : BattleReplay) -> BattleReplay

#
metrics_report

source
fn metrics_report(metrics : BattleMetrics) -> String

#
most_efficient_card

source
fn most_efficient_card(cards : Array[Card]) -> String

#
multiplayer_end_turn

source
fn multiplayer_end_turn(state : MultiplayerState) -> MultiplayerState

#
multiplayer_play_card

source
fn multiplayer_play_card(state : MultiplayerState, card_idx : Int) -> MultiplayerState

#
multiplayer_summary

source
fn multiplayer_summary(state : MultiplayerState) -> String

#
mutos

source
fn mutos() -> Enemy

#
mutos_strategy

source
fn mutos_strategy() -> EnemyStrategy

#
neutral_cards

source
fn neutral_cards() -> Array[Card]

#
new_deck

source
fn new_deck(name : String, character_id : String) -> DeckConfig

#
new_metrics

source
fn new_metrics() -> BattleMetrics

#
new_query

source
fn new_query() -> CardQuery

#
new_replay

source
fn new_replay(character_id : String, enemy_id : String) -> BattleReplay

#
new_simulation

source
fn new_simulation() -> SimulationResult

#
next_boss_rush

source
fn next_boss_rush(current_index : Int, player_hp : Int) -> (BattleState, BossRushState)

#
on_enemy_defeated

source
fn on_enemy_defeated(state : SurvivalState) -> SurvivalState

#
overload_guide

source
fn overload_guide() -> ArchetypeGuide

#
overload_synergies

source
fn overload_synergies() -> Array[Synergy]

#
overload_tuning_fork

source
fn overload_tuning_fork() -> Relic

#
parse_quick_battle

source
fn parse_quick_battle(config_id : Int) -> (String, String)

#
phalanx

source
fn phalanx() -> Formation

#
phase_is_defeat

source
fn phase_is_defeat(state : BattleState) -> Bool

#
phase_is_enemy_turn

source
fn phase_is_enemy_turn(state : BattleState) -> Bool

#
phase_is_player_turn

source
fn phase_is_player_turn(state : BattleState) -> Bool

#
phase_is_victory

source
fn phase_is_victory(state : BattleState) -> Bool

#
play_card

source
fn play_card(state : BattleState, card_index : Int) -> BattleState

#
player_ready

source
fn player_ready(state : MultiplayerState, player_id : String) -> MultiplayerState

#
pollution_guides

source
fn pollution_guides() -> Array[PollutionGuide]

#
pollution_levels

source
fn pollution_levels() -> Array[PollutionLevel]

污染度系统 - 5个等级

#
preset_emotes

source
fn preset_emotes() -> Array[String]

#
query_by_archetype

source
fn query_by_archetype(query : CardQuery, archetype : String) -> CardQuery

#
query_by_cost

source
fn query_by_cost(query : CardQuery, min : Int, max : Int) -> CardQuery

#
query_by_keyword

source
fn query_by_keyword(query : CardQuery, keyword : String) -> CardQuery

#
query_by_target

source
fn query_by_target(query : CardQuery, target : String) -> CardQuery

#
query_by_type

source
fn query_by_type(query : CardQuery, card_type : String) -> CardQuery

#
quick_battle_configs

source
fn quick_battle_configs() -> Array[String]

#
quick_start_guide

source
fn quick_start_guide() -> String

#
recommend_cards_for_archetype

source
fn recommend_cards_for_archetype(archetype : String) -> Array[String]

#
recommend_deck

source
fn recommend_deck(character_id : String, archetype : String) -> DeckConfig

#
recommend_formation

source
fn recommend_formation(pollution : Int) -> Formation

#
record_card_play

source
fn record_card_play(metrics : BattleMetrics, card : Card) -> BattleMetrics

#
record_defeat

source
fn record_defeat(metrics : BattleMetrics) -> BattleMetrics

#
record_enemy_frame

source
fn record_enemy_frame(replay : BattleReplay, state : BattleState, action_name : String) -> BattleReplay

#
record_frame

source
fn record_frame(replay : BattleReplay, state : BattleState, action_type : String, card_id : String, card_name : String) -> BattleReplay

#
record_training_attempt

source
fn record_training_attempt(session : TrainingSession) -> TrainingSession

#
record_turn

source
fn record_turn(metrics : BattleMetrics, state : BattleState) -> BattleMetrics

#
record_victory

source
fn record_victory(metrics : BattleMetrics) -> BattleMetrics

#
remove_card_from_deck

source
fn remove_card_from_deck(config : DeckConfig, index : Int) -> DeckConfig

#
rename_deck

source
fn rename_deck(config : DeckConfig, new_name : String) -> DeckConfig

#
replay_frame_count

source
fn replay_frame_count(replay : BattleReplay) -> Int

#
replay_summary

source
fn replay_summary(replay : BattleReplay) -> String

#
replay_timeline

source
fn replay_timeline(replay : BattleReplay) -> Array[String]

#
resolve_deck_cards

source
fn resolve_deck_cards(config : DeckConfig) -> Array[Card]

#
resonance_core

source
fn resonance_core() -> Relic

#
resonance_crystal

source
fn resonance_crystal() -> Enemy

#
resonant

source
fn resonant() -> Formation

#
roll_dice_with_difficulty

source
fn roll_dice_with_difficulty(config : DifficultyConfig) -> Int

#
run_single_simulation

source
fn run_single_simulation(char_id : String, enemy_id : String) -> (BattleState, Int)

#
scale_battle_for_difficulty

source
fn scale_battle_for_difficulty(battle : BattleState, config : DifficultyConfig) -> BattleState

#
scale_enemy_for_difficulty

source
fn scale_enemy_for_difficulty(enemy : Enemy, config : DifficultyConfig) -> Enemy

#
search_cards

source
fn search_cards(search_term : String) -> Array[Card]

#
search_frames_by_type

source
fn search_frames_by_type(replay : BattleReplay, action_type : String) -> Array[Int]

#
secret_achievements

source
fn secret_achievements() -> Array[Achievement]

#
settle_echo_mark

source
fn settle_echo_mark(state : BattleState) -> BattleState

#
settle_sonic_boom

source
fn settle_sonic_boom(state : BattleState) -> BattleState

#
shuffle_deck

source
fn shuffle_deck(state : BattleState) -> BattleState

#
silent_mimic

source
fn silent_mimic() -> Enemy

#
silent_mimic_strategy

source
fn silent_mimic_strategy() -> EnemyStrategy

#
simulate_all_enemies

source
fn simulate_all_enemies(n : Int, char_id : String) -> Array[SimulationResult]

#
simulate_n_battles

source
fn simulate_n_battles(n : Int, char_id : String, enemy_id : String) -> SimulationResult

#
simulation_report

source
fn simulation_report(result : SimulationResult) -> String

#
snapped_string

source
fn snapped_string() -> Relic

#
spawn_next_wave

source
fn spawn_next_wave(state : SurvivalState) -> SurvivalState

#
start_game

source
fn start_game(state : MultiplayerState) -> MultiplayerState

#
start_new_turn

source
fn start_new_turn(state : BattleState) -> BattleState

#
start_team_battle

source
fn start_team_battle(config : TeamConfig) -> BattleState

#
suggest_opening_hand

source
fn suggest_opening_hand(cards : Array[Card]) -> Array[Int]

#
surrender_player

source
fn surrender_player(state : MultiplayerState, player_id : String) -> MultiplayerState

#
synergy_count_by_type

source
fn synergy_count_by_type(syn_type : SynergyType) -> Int

#
team_config_summary

source
fn team_config_summary(config : TeamConfig) -> String

#
top_synergies

source
fn top_synergies() -> Array[Synergy]

#
total_achievement_count

source
fn total_achievement_count() -> Int

#
total_achievement_points

source
fn total_achievement_points() -> Int

#
total_card_count

source
fn total_card_count() -> Int

#
total_enemy_count

source
fn total_enemy_count() -> Int

#
total_synergy_count

source
fn total_synergy_count() -> Int

#
unique_card_names

source
fn unique_card_names() -> Array[String]

#
unlocked_count

source
fn unlocked_count(achievements : Array[PlayerAchievement]) -> Int

#
update_high_scores

source
fn update_high_scores(scores : Array[HighScore], new_score : HighScore) -> Array[HighScore]

#
updated_total_card_count

source
fn updated_total_card_count() -> Int

#
validate_deck

source
fn validate_deck(config : DeckConfig) -> String

#
validate_replay

source
fn validate_replay(replay : BattleReplay) -> Bool

#
vanguard

source
fn vanguard() -> Formation

#
version_info

source
fn version_info() -> String

#
victory_text

source
fn victory_text(state : BattleState) -> String

#
xian_yin

source
fn xian_yin() -> Character

#
xian_yin_cards

source
fn xian_yin_cards() -> Array[Card]

弦音（频率猎手）专属牌库 - 高频刺客 & 回声幻影流

#
zhong_lv

source
fn zhong_lv() -> Character

角色数据

#
zhong_lv_cards

source
fn zhong_lv_cards() -> Array[Card]

钟律牌库 - 26张卡牌

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io