script_3.1.txt

// 新增怪物6 奖励系统 & 武器（炸弹枪/加特林/左轮/电击枪）升级奖励
import {build_game,
        update_loop,
        enable_debug,
        set_fps,
        set_dimensions,
        debug_log,
        
        create_sprite,
        get_loop_count,
        
        input_key_down,
        
        query_position,
        query_scale,
        
          update_to_top,
          update_scale,
          update_position,
          
          update_rotation,
          query_pointer_position,
          
          update_color,
          update_text,
          
          create_rectangle,
          create_text,
          input_left_mouse_down,
          
          gameobjects_overlap,
          
          create_audio,
          play_audio,
          loop_audio
          

 } from "arcade_2d";

//world properties
    //世界大小
    const height=720;
    const width=720*1.1;
    set_dimensions([width,height]); //设置大小
    //对象管理
    let objects=[];
    let enermys=[];
    let players=[];

    // 地图移动相关
    let tile_sprites = [];   // 所有 tile sprite
    let player_map_px = 0;   // 玩家在地图像素空间中的 X 坐标
    let player_map_py = 0;   // 玩家在地图像素空间中的 Y 坐标
    const tile_pixel = 40;   // 16 * 2.5


//basic settings
    //enable_debug();
    //帧数
    let fps=60;
    set_fps(fps);

//player
let player_speed=2.5;
let player_hp=5;  
const player_max_hp = 5;
const player_scale=2.5; //玩家贴图缩放
let player_hurt_cd = 0;
const player_hurt_interval = 120;
let player_hit_timer = 0;
let player_frame2 = undefined;
let player_anim_timer = 0;
let player_moving = false;
let player_dir_sign = 1;

const die_s1 = create_audio("https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/main/1.0.m4a", 0.8);
const die_s2 = create_audio("https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/main/2.0.m4a", 0.8);
const die_s3 = create_audio("https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/main/4.0.m4a", 0.8);
const bgm = create_audio("https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/battle.mp3", 0.5);
const shoot_sound = create_audio("https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/main/gun1.m4a", 0.8);

const hpBarWidth = 200;
const hpBarHeight = 14;
let hpBarBackground = undefined;
let hpBarFill = undefined;
let xpBarBackground = undefined;
let xpBarFill = undefined;
let gameover_active = false;
let gameover_card = undefined;
let gameover_text = undefined;
let player_level = 1;    // 等级
let player_kills = 0;    // 当前等级杀敌数
let total_kills = 0;     // 玩家总击杀数

// 右上角UI组件变量
let ui_level_text = undefined;
let ui_kills_text = undefined;

//level up
let levelup_active = false;
let levelup_click_lock = false;
let levelup_options = [];
const upgrade_names = ['Multishot -15%dmg','Range','FireRate','Size +40%dmg','Damage +50%','Move Speed','PrepareForBoth','KeepAway','Bloodlust','ClusterBomb','Homing','GatlingGun','Revolver','TaserGun'];
let has_backshot = false;

let has_knockback = false;
let has_bloodlust = false;
let blood_kills = 0;
let has_homing = false;

// 特殊武器模式变量
let is_bomb_mode = false;   // 炸弹武器模式
let bomb_ammo = 0;          // 炸弹剩余发数
let is_gatling_mode = false;// 加特林模式
let gatling_ammo = 0;       // 加特林剩余发数
let is_revolver_mode = false;// 左轮手枪模式
let revolver_ammo = 0;      // 左轮剩余发数
let is_taser_mode = false;  // 电击枪模式
let taser_ammo = 0;         // 电击枪剩余发数

// boss
let last_boss_level = 0;    // 上次生成boss的等级

let lv_title_card = undefined;
let lv_title_text = undefined;
let lv_cards = [];   // 卡牌矩形
let lv_texts = [];   // 卡牌文字

//gun
const gun_scale=0.6; //gun贴图缩放
let normal_gun_sprite = undefined; // 普通枪贴图
let bomb_gun_sprite = undefined;   // 炸弹枪贴图
let gatling_gun_sprite = undefined;// 加特林枪贴图
let revolver_gun_sprite = undefined;// 左轮枪贴图
let taser_gun_sprite = undefined;   // 电击枪贴图
let revolver_aim_line = undefined;  // 左轮辅助瞄准射线
let taser_aim_line = undefined;     // 电击枪辅助瞄准射线

//bullet
let bullet_radius = 4;       // 子弹半径
let bullet_speed = 8;        // 子弹初始速度（像素/帧）
let bullet_range = 200;      // 子弹射程 = 4瓦片距离（像素）
let bullets_per_shot = 1;    // 单次发射子弹数
let bullet_total_spread = 0.3; // 总散射角（弧度），约 17°
let bullet_fire_rate = 40;   // 射速（帧间隔）
let bullet_damage = 1;        // 子弹伤害倍率

const bullet_pool_size = 500;  // 预创建子弹池大小
let bullet_life = math_round(bullet_range / bullet_speed); // 存活帧数 = 射程/速度
let b_sprites = [];   // 子弹精灵（预创建，复用）
let b_active = [];    // 是否活跃
let b_vx = [];        // X速度
let b_vy = [];        // Y速度
let b_life = [];      // 已存活帧数
let b_type = [];      // 0: 普通, 1: 左轮, 2: 电击枪
let fire_cooldown = 0; // 射击冷却帧数

//enemy bullet
const eb_pool_size = 50;
const eb_speed = 3.5;
const eb_max_life = 120;
let eb_sprites = [];
let eb_active = [];
let eb_vx = [];
let eb_vy = [];
let eb_life = [];

//particle
const particle_pool_size = 200;     // 粒子池大小
const particle_count = 8;           // 每次爆炸粒子数
const particle_speed = 3;           // 粒子速度
const particle_life = 20;           // 粒子存活帧数
let p_sprites = [];   // 粒子精灵
let p_active = [];    // 是否活跃
let p_vx = [];        // X速度
let p_vy = [];        // Y速度
let p_life = [];      // 剩余帧数
let p_is_bomb = [];   // 是否为爆炸怪粒子
let p_is_heal = [];   // 是否为治疗粒子

// 开始界面相关
let game_started = false;
let start_bg = undefined;
let start_title = undefined;
let start_go_sprite = undefined;   // GO 按钮贴图

//fire light cover
let fireLightCoverTimer=0;

// ==========================================
// 独立的经验与升级管理函数
// ==========================================
function check_player_levelup(exp_amount) { //奖励怪掉落经验时也调用
    player_kills = player_kills + exp_amount;
    total_kills = total_kills + exp_amount;
    
    if (has_bloodlust) {
        blood_kills = blood_kills + exp_amount;
        if (blood_kills >= 5) {
            blood_kills = 0;
            if (player_hp < player_max_hp) { player_hp = player_hp + 1; }
        }
    }

    let need = 3 + 2 * player_level;
    if (player_kills >= need) {
        player_level = player_level + 1;
        player_kills = 0;
        if (player_level / 10 === math_floor(player_level / 10)) {
            player_hp = player_max_hp;
        }
        // 每5级生成Boss
        spawn_boss();
        show_levelup();
    }
}



function player() { //玩家类
    
    return message => {

        if (message === "create_player") {
            //不接受参数 创建玩家（贴图对象）（贴图放大了2.5倍）
            const player_ins= create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/main/npc_elf.png');
            return update_scale(player_ins,[player_scale,player_scale]);
        }
        
        if (message === "update_position") { 
            //接受一个object 即玩家 将其位置更新在屏幕中心
            return player=>update_position(player,[width/2,height/2]);
        }
        
        if (message === "damage") { 
            //接受一个number 受伤函数 使玩家hp减少 开启闪红
            return amount => {
                player_hp = player_hp - amount;
                player_hit_timer = 10;
            };
        }

        if (message === "update_color") {
            //根据闪红计时器更新玩家颜色
            return player_obj => {
                if (player_hit_timer > 0) {
                    player_hit_timer = player_hit_timer - 1;
                    update_color(player_obj, [255, 0, 0, 255]);
                } else {
                    update_color(player_obj, [255, 255, 255, 255]);
                }
            };
        }
        
        if (message === "determine_direction") { 
            //接受一个对象,和number 即玩家和x轴速度 结果是根据速度改变玩家朝向
            return (object,speed_x) => {
                if(speed_x>0){
                    player_dir_sign = 1;
                } else {
                    player_dir_sign = -1;
                }
            };
        }

    };

}

//enemy
function enemy(initial_hp, initial_speed, texture_url, behavior, if_reward) { //敌人类

    let max_hp = initial_hp;
    let hp = 0;
    const speed = initial_speed;
    let sprite = undefined;
    const enemy_scale = 2.5;
    let hit_timer = 0;
    let move_timer = 0;
    let fire_timer = 30;
    let stun_timer = 0; // 静止电击计时器

    return message => {
        if (message === "init") {
            //只在初始化时调用 创建隐藏的敌人贴图
            return () => {
                sprite = create_sprite(texture_url);
                update_scale(sprite, [0, 0]);
                update_position(sprite, [-9999, -9999]);
                return sprite;
            };
        }

        if (message === "spawn") {
            //激活沉睡的敌人 传送到出生点 hp随玩家等级动态变化
            return (start_x, start_y) => {
                hp = math_round(max_hp * (player_level + 1) / 7); //基于玩家等级赋予血量
                if (hp < 1) { hp = 1; }
                hit_timer = 0;
                stun_timer = 0;
                move_timer = math_floor(math_random() * 100);
                update_rotation(sprite, 0);
                
                if (behavior === 6) {
                    update_color(sprite, [255, 215, 0, 255]); // 金色寻宝怪
                } else {
                    update_color(sprite, [255, 255, 255, 255]);
                }

                if (behavior === 8) {
                    update_scale(sprite, [-5.0, 5.0]); // Boss体型2倍大
                } else {
                    update_scale(sprite, [-enemy_scale, enemy_scale]);
                }
                update_position(sprite, [start_x, start_y]);
            };
        }

        if (message === "is_alive") {
            //查询敌人是否存活
            return () => hp > 0;
        }

        if (message === "stun") {
            //接受一个number 电击枪效果：使敌人静止若干帧并变为湛蓝色
            return duration => {
                if (hp > 0) {
                    if (behavior === 8) {
                        stun_timer = math_floor(duration / 4); // Boss抗性高
                    } else {
                        stun_timer = duration;
                    }
                    update_color(sprite, [0, 150, 255, 255]); // 变成湛蓝色
                }
            };
        }

        if (message === "set_hp") {
            //接受一个number 电击枪效果：将敌人生命值设为指定数值
            return amount => { if (hp > 0) {
                if (behavior === 8) {
                    hp = math_floor(max_hp / 2); // Boss免疫秒杀，仅半血
                } else {
                    hp = amount;
                }
            } };
        }

        if (message === "damage") {
            //接受一个number 使敌人hp减少 hp归零时隐藏 受伤闪红
            return amount => {
                if (hp > 0) {
                    hp = hp - amount;
                    hit_timer = 10;
                    update_color(sprite, [255, 0, 0, 255]);
                    
                    //如果死亡
                    if (hp <= 0) { //随机播放dead音效
                        let rs = math_random();
                        if (rs < 0.3) { play_audio(die_s1); }
                        else if (rs < 0.6) { play_audio(die_s2); }
                        else { play_audio(die_s3); }
                        //粒子特效
                        let die_x = query_position(sprite)[0];
                        let die_y = query_position(sprite)[1];
                         particles()('emit')(die_x, die_y);
                        //掉落奖励
                        if (if_reward === 1) {
                            game_rewards()('spawn')(die_x, die_y);
                        }
                        
                        //爆炸怪 死亡AOE
                        if (behavior === 5) {
                            particles()('bomb_emit')(die_x, die_y);
                            for (let i = 0; i < array_length(enermys); i = i + 1) {
                                if (enermys[i]('is_alive')()) {
                                    let ep = query_position(enermys[i]('get_sprite')());
                                    let edx = die_x - ep[0];
                                    let edy = die_y - ep[1];
                                    if (math_sqrt(edx*edx + edy*edy) < 53) {
                                        enermys[i]('damage')(math_round(max_hp * 2 / 3));
                                    }
                                }
                            }
                            if (math_abs(die_x - width/2) < 53 && math_abs(die_y - height/2) < 53 &&
                                (die_x-width/2)*(die_x-width/2) + (die_y-height/2)*(die_y-height/2) < 2809) {
                                player()('damage')(2);
                            }
                        }
                        //加经验升级
                        if (behavior === 8) {
                            check_player_levelup(8); // Boss给8倍经验
                            // Boss死亡多爆些粒子
                            particles()('bomb_emit')(die_x, die_y);
                        } else {
                            check_player_levelup(1);
                        }
                        //缩放到0 放到地图外
                        update_scale(sprite, [0, 0]);
                        update_position(sprite, [-9999, -9999]);
                    }
                }
            };
        }

        if (message === "chase_player") {
            //行为模式+行走动画 遇墙分轴滑动 闪红
            return () => {
                if (sprite !== undefined && hp > 0) {
                    if (hit_timer > 0) {
                        hit_timer = hit_timer - 1;
                        if (hit_timer <= 0) {
                            if (behavior === 6) {
                                update_color(sprite, [255, 215, 0, 255]); // 金色寻宝怪
                            } else {
                                update_color(sprite, [255, 255, 255, 255]);
                            }
                        }
                    }
                    // 电击眩晕：静止不动，计时器倒计数
                    if (stun_timer > 0) {
                        stun_timer = stun_timer - 1;
                        if (stun_timer <= 0 && behavior === 6) {
                            update_color(sprite, [255, 215, 0, 255]);
                        } else if (stun_timer <= 0) {
                            update_color(sprite, [255, 255, 255, 255]);
                        }
                    } else {
                    move_timer = move_timer + 1;
                    let pos = query_position(sprite);
                    let ex = pos[0];
                    let ey = pos[1];
                    let dx = (width / 2) - ex;
                    let dy = (height / 2) - ey;
                    let dist = math_sqrt(dx * dx + dy * dy);
                    // 视野机制：超出width/2的敌人不追踪
                    if (dist > 0 && dist <= width / 2 * 1.5) { // 视野1.5倍
                        let dir_x = dx / dist;
                        let dir_y = dy / dist;
                        let mx = 0;
                        let my = 0;
                        let cur_sp = speed;
                        let cycle = 0;
                        if (behavior === 1) {
                            mx = dir_x * speed;
                            my = dir_y * speed;
                        } else if (behavior === 2) {
                            let wave = math_sin(move_timer * 0.08) * 1.5;
                            mx = dir_x * speed + (-dir_y * wave);
                            my = dir_y * speed + (dir_x * wave);
                        } else if (behavior === 3) {
                            cycle = move_timer % 100;
                            if (cycle < 20) { cur_sp = speed * 16; }
                            else if (cycle < 85) { cur_sp = speed; }
                            else { cur_sp = 0; }
                            mx = dir_x * cur_sp;
                            my = dir_y * cur_sp;
                        } else if (behavior === 4) {
                            if (dist > 400) { mx = 0; my = 0; }
                            else if (dist > 300) { mx = dir_x * speed; my = dir_y * speed; }
                            else { mx = 0; my = 0; }
                            fire_timer = fire_timer - 1;
                            if (fire_timer <= 0 && dist <= 300) {
                                enemy_bullets()('fire')(ex, ey, width / 2, height / 2);
                                fire_timer = 60;
                            }
                        } else if (behavior === 5) {
                            mx = dir_x * speed;
                            my = dir_y * speed;
                        } else if (behavior === 6) {
                            // 寻宝怪：急速远离玩家
                            if (dist < 200) {
                                mx = -dir_x * speed * 1.5;
                                my = -dir_y * speed * 1.5;
                            }
                        } else if (behavior === 7) {
                            // 治疗师：缓慢靠近，定期治疗附近怪物
                            mx = dir_x * speed * 0.4;
                            my = dir_y * speed * 0.4;
                            fire_timer = fire_timer - 1;
                            if (fire_timer <= 0) {
                                fire_timer = 300;
                                particles()('heal_emit')(ex, ey);
                                for (let h = 0; h < array_length(enermys); h = h + 1) {
                                    if (enermys[h]('is_alive')()) {
                                        let hp_pos = query_position(enermys[h]('get_sprite')());
                                        let hdx = hp_pos[0] - ex;
                                        let hdy = hp_pos[1] - ey;
                                        if (hdx*hdx + hdy*hdy < 14400) {
                                            enermys[h]('heal')(2);
                                            particles()('heal_emit')(hp_pos[0], hp_pos[1]);
                                        }
                                    }
                                }
                            }
                        } else if (behavior === 8) {
                            // Boss：追击玩家，速度中等，体型庞大
                            mx = dir_x * speed;
                            my = dir_y * speed;
                        }
                        let wobble = 0;
                        let boss_scale = 5.0;
                        let cur_scale = behavior === 8 ? boss_scale : enemy_scale;
                        let sy_anim = cur_scale;
                        if (cur_sp > 0) {
                            let freq = (behavior === 3 && cycle < 20) ? 0.26 : 0.2;
                            wobble = math_sin(move_timer * freq) * 0.10;
                            sy_anim = cur_scale + math_abs(math_sin(move_timer * freq)) * (behavior === 8 ? 0.5 : 0.3);
                        }
                        update_rotation(sprite, wobble);
                        let empx = player_map_px + (ex - width / 2);
                        let empy = player_map_py + (ey - height / 2);
                        let nx = ex;
                        let ny = ey;
                        let tx = math_floor(empx / tile_pixel);
                        let ty = math_floor(empy / tile_pixel);
                        if (!is_wall(tile_map, math_floor((empx + mx) / tile_pixel), ty)) {
                            nx = ex + mx;
                        }
                        if (!is_wall(tile_map, tx, math_floor((empy + my) / tile_pixel))) {
                            ny = ey + my;
                        }
                        update_position(sprite, [nx, ny]);
                        if (dx > 0) {
                            update_scale(sprite, [-enemy_scale, sy_anim]);
                        } else {
                            update_scale(sprite, [enemy_scale, sy_anim]);
                        }
                    }
                }
                } // end of stun else
            };
        }

        if (message === "update_map_offset") {
            //接受两个number 地图移动时敌人同步偏移
            return (dx, dy) => {
                if (sprite !== undefined && hp > 0) {
                    let pos = query_position(sprite);
                    update_position(sprite, [pos[0] - dx, pos[1] - dy]);
                }
            };
        }

        if (message === "get_sprite") {
            //返回敌人sprite 用于碰撞检测
            return () => sprite;
        }

        if (message === "get_behavior") {
            //返回敌人行为模式 用于击退判断
            return () => behavior;
        }
        
        if (message === "heal") { //治疗师专用
            return amount => { if (hp > 0) { hp = hp + amount; if (hp > max_hp) { hp = max_hp; } } };
        }

        if (message === "push") {
            //接受两个number 推开敌人（敌人间碰撞用） 遇墙则取消
            return (dx, dy) => {
                if (sprite !== undefined && hp > 0) {
                    let pos = query_position(sprite);
                    let nx = pos[0] + dx;
                    let ny = pos[1] + dy;
                    let mpx = player_map_px + (nx - width / 2);
                    let mpy = player_map_py + (ny - height / 2);
                    let tl = math_floor((mpx - 20) / tile_pixel);
                    let tr = math_floor((mpx + 19) / tile_pixel);
                    let tt = math_floor((mpy - 20) / tile_pixel);
                    let tb = math_floor((mpy + 19) / tile_pixel);
                    if (!is_wall(tile_map, tl, tt) && !is_wall(tile_map, tr, tt) &&
                        !is_wall(tile_map, tl, tb) && !is_wall(tile_map, tr, tb)) {
                        update_position(sprite, [nx, ny]);
                    }
                }
            };
        }
    };
}

//spawner
function enemy_spawner(spawn_amount, spawn_rate) { //刷怪器

    let spawn_cooldown = spawn_rate;

    return message => {
        if (message === "update") {
            //每帧调用 冷却完毕时从池中激活沉睡敌人 数量随等级动态
            return () => {
                spawn_cooldown = spawn_cooldown - 1;
                if (spawn_cooldown <= 0) {
                    // 1-6级倍率增长，7级起每级+1只而非*1.2
                    let mult = 1;
                    if (player_level <= 6) {
                        for (let k = 1; k < player_level; k = k + 1) { mult = mult * 1.2; }
                    } else {
                        for (let k = 1; k <= 5; k = k + 1) { mult = mult * 1.2; }
                    }
                    let amount = math_round(spawn_amount * mult);
                    if (player_level > 6) { amount = amount + (player_level - 6); }
                    if (player_level <= 2) { amount = amount + 6; }
                    let spawned = 0;
                    for (let i = 0; i < array_length(enermys); i = i + 1) {
                        if (spawned < amount) {
                            if (!enermys[i]('is_alive')()) {
                                let tries = 0;
                                let ok = false;
                                let sx = 0;
                                let sy = 0;
                                while (!ok && tries < 10) {
                                    let a = math_random() * 2 * math_PI;
                                    let r = 600;
                                    sx = width / 2 + r * math_cos(a);
                                    sy = height / 2 + r * math_sin(a);
                                    let mpx = player_map_px + (sx - width / 2);
                                    let mpy = player_map_py + (sy - height / 2);
                                    let tx = math_floor(mpx / tile_pixel);
                                    let ty = math_floor(mpy / tile_pixel);
                                    if (!is_wall(tile_map, tx, ty)) { ok = true; }
                                    tries = tries + 1;
                                }
                                if (ok) {
                                    enermys[i]('spawn')(sx, sy);
                                    spawned = spawned + 1;
                                }
                            }
                        }
                    }
                    spawn_cooldown = spawn_rate;
                }
            };
        }
    };
}

//boss spawn
function spawn_boss() {
    if (player_level <= last_boss_level) { return 0; }
    if (player_level / 5 !== math_floor(player_level / 5)) { return 0; }
    for (let i = max_pool_size; i < max_pool_size + boss_pool_size; i = i + 1) {
        if (!enermys[i]('is_alive')()) {
            let tries = 0;
            let ok = false;
            let sx = 0;
            let sy = 0;
            while (!ok && tries < 20) {
                let a = math_random() * 2 * math_PI;
                let r = 500 + math_random() * 200;
                sx = width / 2 + r * math_cos(a);
                sy = height / 2 + r * math_sin(a);
                let mpx = player_map_px + (sx - width / 2);
                let mpy = player_map_py + (sy - height / 2);
                let tx = math_floor(mpx / tile_pixel);
                let ty = math_floor(mpy / tile_pixel);
                if (!is_wall(tile_map, tx, ty)) { ok = true; }
                tries = tries + 1;
            }
            if (ok) {
                enermys[i]('spawn')(sx, sy);
                last_boss_level = player_level;
            }
            break;
        }
    }
}

//reward
// ==========================================
// 掉落物单体函数
// ==========================================
function reward(texture_url) { //奖励怪掉落物品
    let active = false;
    let sprite = undefined;
    let type = 0; // 0: 恢复HP, 1: 获得经验

    return message => {
        if (message === "init") {
            return () => {
                sprite = create_sprite(texture_url);
                update_scale(sprite, [0, 0]);
                update_position(sprite, [-9999, -9999]);
                return sprite;
            };
        }

        if (message === "spawn") {
            return (x, y) => {
                active = true;
                type = math_random() < 0.3 ? 0 : 1; 
                
                update_position(sprite, [x, y]);
                update_scale(sprite, [2.0, 2.0]);
                
                if (type === 0) {
                    update_color(sprite, [255, 0, 0, 255]); // 红色 = 血包
                } else {
                    update_color(sprite, [0, 200, 255, 255]); // 浅蓝色 = 经验晶体
                }
            };
        }

        if (message === "update") {
            return () => {
                if (active && sprite !== undefined) {
                    let pos = query_position(sprite);
                    let dx = (width / 2) - pos[0];
                    let dy = (height / 2) - pos[1];
                    let dist_sq = dx * dx + dy * dy;

                    if (dist_sq < 1225) { // 35*35范围内自动吸
                        active = false;
                        update_scale(sprite, [0, 0]);
                        update_position(sprite, [-9999, -9999]);
                        
                        if (type === 0) {
                            player_hp = player_hp + 1;
                            if (player_hp > player_max_hp) { 
                                player_hp = player_max_hp; 
                            }
                        } else {
                            check_player_levelup(12); // 捡到经验包获得12点经验(3倍)
                        }
                    }
                }
            };
        }

        if (message === "update_map_offset") {
            return (dx, dy) => {
                if (active && sprite !== undefined) {
                    let pos = query_position(sprite);
                    update_position(sprite, [pos[0] - dx, pos[1] - dy]);
                }
            };
        }

        if (message === "is_active") {
            return () => active;
        }
    };
}

// ==========================================
// 掉落物对象池
// ==========================================
const reward_pool_size = 30; //预创建掉落物池
const global_rewards = [];
const reward_texture = "https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/HPreward.png";

function game_rewards() { //掉落物管理
    return message => {
        if (message === "spawn") {
            return (x, y) => {
                for (let i = 0; i < reward_pool_size; i = i + 1) {
                    if (!global_rewards[i]("is_active")()) {
                        global_rewards[i]("spawn")(x, y);
                        break; // 只 spawn 一个 避免全部重叠
                    }
                }
            };
        }
        if (message === "update") {
            return () => {
                for (let i = 0; i < reward_pool_size; i = i + 1) {
                    global_rewards[i]("update")();
                }
            };
        }
        if (message === "update_map_offset") {
            return (dx, dy) => {
                for (let i = 0; i < reward_pool_size; i = i + 1) {
                    global_rewards[i]("update_map_offset")(dx, dy);
                }
            };
        }
    };
}


//map
const floor_texture_density = 0.3; // 纹理地板密度（0~1），0=纯地板，1=全纹理
function generateTileMap(width, height) { 
    //接受两个number 生成2D数组 这个数组被用于生成瓦片地图
    const border = 8;
    let map = [];
    
    for (let y = 0; y < height; y = y + 1) {
        map[y] = [];
        for (let x = 0; x < width; x = x + 1) {
            if (y < border || y >= height - border ||
                x < border || x >= width - border) {
                map[y][x] = 'wallTop';
            } else if (y === border) {
                if (x === border) {
                    map[y][x] = 'wallLeftBottom';
                } else if (x === width - border - 1) {
                    map[y][x] = 'bottomRightWall';
                } else {
                    map[y][x] = 'bottomWall';
                }
            } else if (y === height - border - 1) {
                if (x === border) {
                    map[y][x] = 'topLeftWall';
                } else if (x === width - border - 1) {
                    map[y][x] = 'topRightWall';
                } else {
                    map[y][x] = 'topWall';
                }
            } else if (x === border) {
                map[y][x] = 'rightWall';
            } else if (x === width - border - 1) {
                map[y][x] = 'LeftWall';
            } else if (y === border + 1 || y === border + 2) {
                map[y][x] = 'wallCenter';
            } else {
                let r = math_random();
                if (r < floor_texture_density / 2) {
                    map[y][x] = 'texture1Floor';
                } else if (r < floor_texture_density) {
                    map[y][x] = 'texture2Floor';
                } else {
                    map[y][x] = 'floor';
                }
            }
        }
    }
    return map;
}

function map(){ //地图类
    

    function choose_tile_according_to_tilemap(tile_name){
        //接受一个string 根据tile_name的名字 返回 地图图片
        if (tile_name === 'LeftWall') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/LeftWall.png');
        }
        if (tile_name === 'bottomRightWall') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/bottomRightWall.png');
        }
        if (tile_name === 'bottomWall') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/bottomWall.png');
        }
        if (tile_name === 'floor') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/floor.png');
        }
        if (tile_name === 'rightWall') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/rightWall.png');
        }
        if (tile_name === 'texture1Floor') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/texture1Floor.png');
        }
        if (tile_name === 'texture2Floor') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/texture2Floor.png');
        }
        if (tile_name === 'topLeftWall') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/topLeftWall.png');
        }
        if (tile_name === 'topRightWall') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/topRightWall.png');
        }
        if (tile_name === 'topWall') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/topWall.png');
        }
        if (tile_name === 'wallCenter') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/wallCenter.png');
        }
        if (tile_name === 'wallLeftBottom') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/wallLeftBottom.png');
        }
        if (tile_name === 'wallRoot') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/wallRoot.png');
        }
        if (tile_name === 'wallTop') {
            return create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%88%87%E5%A5%BD%E7%9A%84%E5%A2%99%E5%92%8C%E5%9C%B0%E6%9D%BFpng/wallTop.png');
        }
        
    }
    
    return message => {
        
        if (message==='generate_map') {
            //接受一个2D数组 根据数组生成瓦片地图
            return tile_map=>{
                tile_sprites = [];
                for (let y=0;y< array_length(tile_map) ; y=y+1){
                    for (let x=0 ; x < array_length(tile_map[y]) ; x=x+1){
                        let tile=choose_tile_according_to_tilemap(tile_map[y][x]);
                        update_position(tile,[
                            width/2 + 16*2.5*(x - (array_length(tile_map[0]) - 1) / 2),
                            height/2 + 16*2.5*(y - (array_length(tile_map) - 1) / 2)]);
                        tile_sprites[array_length(tile_sprites)] = tile;
                    }
                }
                player_map_px = ((array_length(tile_map[0]) - 1) / 2) * tile_pixel;
                player_map_py = ((array_length(tile_map) - 1) / 2) * tile_pixel;
            };
        }
        
        
    };
}

//particle
//levelup
function show_levelup() { //升级UI：随机选3个选项 显示卡牌 每三级多一张武器卡
    let picked = [];
    let pool_size = array_length(upgrade_names);
    let weapon_level = (player_level / 3 === math_floor(player_level / 3));
    let card_count = weapon_level ? 4 : 3;
    //抽卡
    for (let i = 0; i < card_count; i = i + 1) {
        let found = false;
        let r = 0;
        while (!found) {
            r = math_floor(math_random() * pool_size);
            found = true;
            if (bullet_fire_rate <= 2 && r === 2) { found = false; }
            if (has_backshot && r === 6) { found = false; }
            if (has_knockback && r === 7) { found = false; }
            if (has_bloodlust && r === 8) { found = false; }
            if (has_homing && r === 10) { found = false; }
            if (is_bomb_mode && r === 9) { found = false; }
            if (is_gatling_mode && r === 11) { found = false; }
            if (is_revolver_mode && r === 12) { found = false; }
            if (is_taser_mode && r === 13) { found = false; }
            // 前3张普通卡：不能是武器类型
            if (i < 3 && (r === 9 || r === 11 || r === 12 || r === 13)) { found = false; }
            // 第4张武器卡：只能是武器类型，加特林低概率
            if (i === 3 && r !== 9 && r !== 11 && r !== 12 && r !== 13) { found = false; }
            if (i === 3 && r === 11 && math_random() > 0.3) { found = false; }
            for (let j = 0; j < array_length(picked); j = j + 1) {
                if (picked[j] === r) { found = false; }
            }
        }
        picked[array_length(picked)] = r;
    }
    //创建矩形选项
    update_position(lv_title_card, [width / 2, height / 2 - 80]);
    update_scale(lv_title_card, [3, 0.8]);
    update_color(lv_title_card, [80, 80, 80, 255]);
    update_to_top(lv_title_card);
    update_text(lv_title_text, 'LEVEL UP!');
    update_position(lv_title_text, [width / 2, height / 2 - 80]);
    update_scale(lv_title_text, [1, 1]);
    update_to_top(lv_title_text);
    for (let i = 0; i < card_count; i = i + 1) {
        let cx = width / 2 + (i - (card_count - 1) / 2) * 180;
        let cy = height / 2;
        update_position(lv_cards[i], [cx, cy]);
        update_scale(lv_cards[i], [3.2, 1.2]);
        update_color(lv_cards[i], [50, 50, 50, 255]);
        update_to_top(lv_cards[i]);
        update_text(lv_texts[i], upgrade_names[picked[i]]);
        update_color(lv_texts[i], [255, 255, 255, 255]);
        let on = upgrade_names[picked[i]];
        // 武器卡红色标记，其他稀有卡金色
        let is_weapon = (on === 'ClusterBomb' || on === 'GatlingGun' || on === 'Revolver' || on === 'TaserGun');
        let is_rare = (on === 'Multishot -15%dmg' || on === 'FireRate' || on === 'PrepareForBoth' || on === 'KeepAway' || on === 'Homing');
        if (is_weapon) {
            update_color(lv_texts[i], [255, 40, 40, 255]); // 红色
        } else if (is_rare) {
            update_color(lv_texts[i], [255, 200, 0, 255]); // 金色
        }
        update_position(lv_texts[i], [cx, cy]);
        update_scale(lv_texts[i], [1, 1]);
        update_to_top(lv_texts[i]);
        levelup_options[i] = picked[i];
    }
    levelup_active = true;
    levelup_click_lock = true;
}

function hide_levelup() { //隐藏升级卡牌
    update_position(lv_title_card, [-9999, -9999]);
    update_scale(lv_title_card, [0, 0]);
    update_position(lv_title_text, [-9999, -9999]);
    update_scale(lv_title_text, [0, 0]);
    for (let i = 0; i < 4; i = i + 1) {
        update_position(lv_cards[i], [-9999, -9999]);
        update_scale(lv_cards[i], [0, 0]);
        update_position(lv_texts[i], [-9999, -9999]);
        update_scale(lv_texts[i], [0, 0]);
    }
    levelup_active = false;
}

function apply_upgrade(index) { //应用升级选项
    let opt = upgrade_names[index];
    if (opt === 'Multishot -15%dmg'){ bullets_per_shot = bullets_per_shot + 2; bullet_damage = bullet_damage * 0.85; bullet_total_spread = bullet_total_spread + 0.15; }
    if (opt === 'Range')            { bullet_range = bullet_range + 120; bullet_life = math_round(bullet_range / bullet_speed); }
    if (opt === 'FireRate')        { bullet_fire_rate = bullet_fire_rate - 8; if (bullet_fire_rate < 2) { bullet_fire_rate = 2; } }
    if (opt === 'Size +40%dmg')     { bullet_radius = bullet_radius + 2; bullet_damage = bullet_damage * 1.4; }
    if (opt === 'Damage +50%')      { bullet_damage = bullet_damage * 1.5; }
    if (opt === 'Move Speed')       { player_speed = player_speed + 1.5; }
    if (opt === 'PrepareForBoth')        { has_backshot = true; }
    if (opt === 'KeepAway')        { has_knockback = true; }
    if (opt === 'Bloodlust')        { has_bloodlust = true; }
    if (opt === 'ClusterBomb')      { is_gatling_mode = false; is_revolver_mode = false; is_taser_mode = false; is_bomb_mode = true; bomb_ammo = 10; }
    if (opt === 'Homing')           { has_homing = true; }
    if (opt === 'GatlingGun')        { is_bomb_mode = false; is_revolver_mode = false; is_taser_mode = false; is_gatling_mode = true; gatling_ammo = 200; }
    if (opt === 'Revolver')          { is_bomb_mode = false; is_gatling_mode = false; is_taser_mode = false; is_revolver_mode = true; revolver_ammo = 10; }
    if (opt === 'TaserGun')          { is_bomb_mode = false; is_gatling_mode = false; is_revolver_mode = false; is_taser_mode = true; taser_ammo = 3; }
}

//enemy bullet
function enemy_bullets(){ //敌方子弹类

    return message => {
        if (message === "fire") {
            //接受四个number 从起点射向目标点
            return (fx, fy, tx, ty) => {
                let dx = tx - fx;
                let dy = ty - fy;
                let dist = math_sqrt(dx * dx + dy * dy);
                if (dist > 0) {
                    let done = false;
                    for (let i = 0; i < eb_pool_size && !done; i = i + 1) {
                        if (!eb_active[i]) {
                            update_position(eb_sprites[i], [fx, fy]);
                            update_color(eb_sprites[i], [255, 100, 100, 255]);
                            update_scale(eb_sprites[i], [1, 1]);
                             eb_active[i] = true;
                            eb_vx[i] = (dx / dist) * eb_speed;
                            eb_vy[i] = (dy / dist) * eb_speed;
                            eb_life[i] = 0;
                            done = true;
                        }
                    }
                }
            };
        }

        if (message === "update_all") {
            //遍历活跃子弹 移动、碰玩家扣血、越界/碰墙停用
            return () => {
                for (let i = 0; i < eb_pool_size; i = i + 1) {
                    if (eb_active[i]) {
                        eb_life[i] = eb_life[i] + 1;
                        let pos = query_position(eb_sprites[i]);
                        let nx = pos[0] + eb_vx[i];
                        let ny = pos[1] + eb_vy[i];
                        update_position(eb_sprites[i], [nx, ny]);
                        let pdx = nx - width / 2;
                        let pdy = ny - height / 2;
                        let hit = false;
                        if (math_abs(pdx) < 15 && math_abs(pdy) < 15 &&
                            pdx * pdx + pdy * pdy < 225) {
                            hit = true;
                            if (player_hurt_cd <= 0) {
                                player()('damage')(1);
                                player_hurt_cd = player_hurt_interval;
                            }
                        }
                        let mpx = player_map_px + (nx - width / 2);
                        let mpy = player_map_py + (ny - height / 2);
                        let tx = math_floor(mpx / tile_pixel);
                        let ty = math_floor(mpy / tile_pixel);
                        if (eb_life[i] >= eb_max_life || is_wall(tile_map, tx, ty) || hit) {
                            eb_active[i] = false;
                            update_scale(eb_sprites[i], [0, 0]);
                            update_position(eb_sprites[i], [-9999, -9999]);
                        }
                    }
                }
            };
        }

        if (message === "update_map_offset") {
            //接受两个number 地图移动时eb同步偏移
            return (dx, dy) => {
                for (let i = 0; i < eb_pool_size; i = i + 1) {
                    if (eb_active[i]) {
                        let pos = query_position(eb_sprites[i]);
                        update_position(eb_sprites[i], [pos[0] - dx, pos[1] - dy]);
                    }
                }
            };
        }
    };
}

// 武器集束炸弹类 (短射程 + 三散射连发)
// ==========================================
function bomb(shrapnel_count, explosion_damage, projectile_texture, weapon_texture) {
    const bomb_pool_size = 5;
    let sprites = [];
    let actives = [];
    let vxs = [];
    let vys = [];
    let timers = [];
    const max_timer = 22;

    return message => {
        if (message === "init") {
            return () => {
                for (let i = 0; i < bomb_pool_size; i = i + 1) {
                    sprites[i] = create_sprite(projectile_texture);
                    update_scale(sprites[i], [0, 0]);
                    update_position(sprites[i], [-9999, -9999]);
                    actives[i] = false;
                    vxs[i] = 0;
                    vys[i] = 0;
                    timers[i] = 0;
                }

                bomb_gun_sprite = create_sprite(weapon_texture);
                update_scale(bomb_gun_sprite, [0, 0]);
                update_position(bomb_gun_sprite, [-9999, -9999]);

                return sprites[0];
            };
        }

        if (message === "fire") {
            return (start_x, start_y, base_angle) => {
                const bomb_count = 3;
                const spread_angle = 0.25;
                let fired = 0;

                for (let i = 0; i < bomb_pool_size && fired < bomb_count; i = i + 1) {
                    if (!actives[i]) {
                        let offset = (fired - 1) * (spread_angle / 2);
                        let a = base_angle + offset;

                        actives[i] = true;
                        timers[i] = max_timer;

                        let bomb_speed = 7;
                        vxs[i] = bomb_speed * math_cos(a);
                        vys[i] = bomb_speed * math_sin(a);

                        update_position(sprites[i], [start_x, start_y]);
                        update_scale(sprites[i], [1.3, 1.3]);
                        update_rotation(sprites[i], a);

                        fired = fired + 1;
                    }
                }
                return 0;
            };
        }

        if (message === "explode") {
            return index => {
                if (!actives[index]) { return 0; }

                let pos = query_position(sprites[index]);
                let bx = pos[0];
                let by = pos[1];

                particles()('bomb_emit')(bx, by);

                let ec = array_length(enermys);
                for (let i = 0; i < ec; i = i + 1) {
                    if (enermys[i]('is_alive')()) {
                        let ep = query_position(enermys[i]('get_sprite')());
                        let edx = bx - ep[0];
                        let edy = by - ep[1];
                        if (math_sqrt(edx * edx + edy * edy) < 70) {
                            enermys[i]('damage')(explosion_damage);
                        }
                    }
                }

                for (let k = 0; k < shrapnel_count; k = k + 1) {
                    let a = (2 * math_PI / shrapnel_count) * k;
                    let bs_idx = -1;
                    for (let b = 0; b < bullet_pool_size; b = b + 1) {
                        if (!b_active[b]) { bs_idx = b; break; }
                    }
                    if (bs_idx !== -1) {
                        b_active[bs_idx] = true;
                        b_type[bs_idx] = 0;
                        update_position(b_sprites[bs_idx], [bx, by]);
                        let bs = bullet_radius / 4;
                        update_scale(b_sprites[bs_idx], [bs, bs]);
                        b_vx[bs_idx] = bullet_speed * math_cos(a);
                        b_vy[bs_idx] = bullet_speed * math_sin(a);
                        b_life[bs_idx] = 0;
                    }
                }

                actives[index] = false;
                update_scale(sprites[index], [0, 0]);
                return update_position(sprites[index], [-9999, -9999]);
            };
        }

        if (message === "update") {
            return () => {
                for (let i = 0; i < bomb_pool_size; i = i + 1) {
                    if (actives[i]) {
                        let pos = query_position(sprites[i]);
                        let nx = pos[0] + vxs[i];
                        let ny = pos[1] + vys[i];
                        let mpx = player_map_px + (nx - width / 2);
                        let mpy = player_map_py + (ny - height / 2);
                        let tx = math_floor(mpx / tile_pixel);
                        let ty = math_floor(mpy / tile_pixel);

                        if (is_wall(tile_map, tx, ty)) {
                            this_bomb('explode')(i);
                        } else {
                            update_position(sprites[i], [nx, ny]);
                            timers[i] = timers[i] - 1;
                            if (timers[i] <= 0) {
                                this_bomb('explode')(i);
                            }
                        }
                    }
                }
                return 0;
            };
        }

        if (message === "update_map_offset") {
            return (dx, dy) => {
                for (let i = 0; i < bomb_pool_size; i = i + 1) {
                    if (actives[i]) {
                        let pos = query_position(sprites[i]);
                        update_position(sprites[i], [pos[0] - dx, pos[1] - dy]);
                    }
                }
                return 0;
            };
        }

        return 0;
    };
}

// ==========================================
// 武器加特林类 (Gatling Gun)
// ==========================================
function gatling(damage_mult, weapon_texture) {
    const gatling_fire_rate = 5;
    
    return message => {
        if (message === "init") {
            return () => {
                gatling_gun_sprite = create_sprite(weapon_texture);
                update_scale(gatling_gun_sprite, [0, 0]);
                update_position(gatling_gun_sprite, [-9999, -9999]);
                return gatling_gun_sprite;
            };
        }

        if (message === "fire") {
            return (start_x, start_y, base_angle) => {
                let step = bullets_per_shot > 1
                    ? bullet_total_spread / (bullets_per_shot - 1)
                    : 0;
                let half = bullet_total_spread / 2;
                let fired = 0;
                for (let s = 0; s < bullet_pool_size && fired < bullets_per_shot; s = s + 1) {
                    if (!b_active[s]) {
                        let spread = (math_random() - 0.5) * 0.2;
                        let a = base_angle - half + fired * step + spread;

                        let gatling_bullet_speed = 12;
                        b_active[s] = true;
                        b_type[s] = 0;
                        update_position(b_sprites[s], [start_x, start_y]);
                        update_rotation(b_sprites[s], a + math_PI / 2);
                        update_color(b_sprites[s], [255, 255, 255, 255]);
                        
                        let bs = (bullet_radius / 4) * 0.9;
                        update_scale(b_sprites[s], [bs, bs]);
                        
                        b_vx[s] = gatling_bullet_speed * math_cos(a);
                        b_vy[s] = gatling_bullet_speed * math_sin(a);
                        b_life[s] = 0;
                        fired = fired + 1;
                    }
                }
                return 0;
            };
        }

        if (message === "get_fire_rate") {
            return () => gatling_fire_rate;
        }

        return 0;
    };
}

// ==========================================
// 武器左轮手枪类 (Revolver - 999伤害+瞄准射线)
// ==========================================
function revolver(damage_mult, weapon_texture) {
    const fire_rate = 18; // 连射间隔

    return message => {
        if (message === "init") {
            return () => {
                revolver_gun_sprite = create_sprite(weapon_texture);
                update_scale(revolver_gun_sprite, [0, 0]);
                update_position(revolver_gun_sprite, [-9999, -9999]);

                // 创建红色辅助瞄准射线
                revolver_aim_line = create_rectangle(600, 2);
                update_color(revolver_aim_line, [255, 0, 0, 160]);
                update_scale(revolver_aim_line, [0, 0]);
                update_position(revolver_aim_line, [-9999, -9999]);

                return revolver_gun_sprite;
            };
        }

        if (message === "update_aim_line") {
            return (start_x, start_y, angle) => {
                if (is_revolver_mode && revolver_aim_line !== undefined) {
                    let line_length = 600;
                    let center_x = start_x + (line_length / 2) * math_cos(angle);
                    let center_y = start_y + (line_length / 2) * math_sin(angle);

                    update_scale(revolver_aim_line, [1, 1]);
                    update_position(revolver_aim_line, [center_x, center_y]);
                    update_rotation(revolver_aim_line, angle);
                } else if (revolver_aim_line !== undefined) {
                    update_scale(revolver_aim_line, [0, 0]);
                }
                return 0;
            };
        }

        if (message === "fire") {
            return (start_x, start_y, angle) => {
                let step = bullets_per_shot > 1
                    ? bullet_total_spread / (bullets_per_shot - 1)
                    : 0;
                let half = bullet_total_spread / 2;
                let fired = 0;
                for (let s = 0; s < bullet_pool_size && fired < bullets_per_shot; s = s + 1) {
                    if (!b_active[s]) {
                        let a = angle - half + fired * step;
                        let revolver_speed = 20;
                        let revolver_life = 35;

                        b_active[s] = true;
                        b_type[s] = 1; // 左轮 999 威力子弹
                        update_position(b_sprites[s], [start_x, start_y]);
                        update_rotation(b_sprites[s], a + math_PI / 2);
                        
                        update_color(b_sprites[s], [255, 30, 30, 255]);
                        let bs = (bullet_radius / 4) * 1.5;
                        update_scale(b_sprites[s], [bs, bs]);
                        
                        b_vx[s] = revolver_speed * math_cos(a);
                        b_vy[s] = revolver_speed * math_sin(a);
                        
                        b_life[s] = bullet_life - revolver_life;
                        fired = fired + 1;
                    }
                }
                return 0;
            };
        }

        if (message === "get_fire_rate") {
            return () => fire_rate;
        }

        return 0;
    };
}

// ==========================================
// 武器电击枪类 (Taser - 单发大范围控制)
// ==========================================
function taser(weapon_texture) {
    const fire_rate = 30;

    return message => {
        if (message === "init") {
            return () => {
                taser_gun_sprite = create_sprite(weapon_texture);
                update_scale(taser_gun_sprite, [0, 0]);
                update_position(taser_gun_sprite, [-9999, -9999]);

                // 蓝色瞄准射线
                taser_aim_line = create_rectangle(600, 2);
                update_color(taser_aim_line, [0, 200, 255, 160]);
                update_scale(taser_aim_line, [0, 0]);
                update_position(taser_aim_line, [-9999, -9999]);

                return taser_gun_sprite;
            };
        }

        if (message === "update_aim_line") {
            return (start_x, start_y, angle) => {
                if (is_taser_mode && taser_aim_line !== undefined) {
                    let line_length = 600;
                    let center_x = start_x + (line_length / 2) * math_cos(angle);
                    let center_y = start_y + (line_length / 2) * math_sin(angle);

                    update_scale(taser_aim_line, [1, 1]);
                    update_position(taser_aim_line, [center_x, center_y]);
                    update_rotation(taser_aim_line, angle);
                } else if (taser_aim_line !== undefined) {
                    update_scale(taser_aim_line, [0, 0]);
                }
                return 0;
            };
        }

        if (message === "fire") {
            return (start_x, start_y, angle) => {
                let step = bullets_per_shot > 1
                    ? bullet_total_spread / (bullets_per_shot - 1)
                    : 0;
                let half = bullet_total_spread / 2;
                let fired = 0;
                for (let s = 0; s < bullet_pool_size && fired < bullets_per_shot; s = s + 1) {
                    if (!b_active[s]) {
                        let a = angle - half + fired * step;
                        let taser_speed = 18;
                        let taser_life = 35;

                        b_active[s] = true;
                        b_type[s] = 2; // 电击枪子弹
                        update_position(b_sprites[s], [start_x, start_y]);
                        update_rotation(b_sprites[s], a + math_PI / 2);
                        
                        update_color(b_sprites[s], [0, 200, 255, 255]); // 湛蓝色发光子弹
                        let bs = (bullet_radius / 4) * 1.8;
                        update_scale(b_sprites[s], [bs, bs]);
                        
                        b_vx[s] = taser_speed * math_cos(a);
                        b_vy[s] = taser_speed * math_sin(a);
                        
                        b_life[s] = bullet_life - taser_life;
                        fired = fired + 1;
                    }
                }
                return 0;
            };
        }

        if (message === "get_fire_rate") {
            return () => fire_rate;
        }

        return 0;
    };
}

function particles(){ //粒子类

    return message => {
        if (message === "bomb_emit") {
            //爆炸怪专用 大范围粒子
            return (x, y) => {
                let emitted = 0;
                for (let i = 0; i < particle_pool_size && emitted < 24; i = i + 1) {
                    if (!p_active[i]) {
                        let a = math_random() * 2 * math_PI;
                        let sp = 4 * math_random();
                        update_position(p_sprites[i], [x, y]);
                        update_color(p_sprites[i], [255, 100, 20, 255]);
                        update_scale(p_sprites[i], [1.5, 1.5]);
                        p_active[i] = true;
                        p_vx[i] = sp * math_cos(a);
                        p_vy[i] = sp * math_sin(a);
                        p_life[i] = 30;
                        p_is_bomb[i] = true; p_is_heal[i] = false;
                        emitted = emitted + 1;
                    }
                }
            };
        }

        if (message === "emit") {
            //接受两个number x,y 在该位置生成爆炸粒子
            return (x, y) => {
                let emitted = 0;
                for (let i = 0; i < particle_pool_size && emitted < particle_count; i = i + 1) {
                    if (!p_active[i]) {
                        let a = math_random() * 2 * math_PI;
                        let sp = particle_speed * math_random();
                        update_position(p_sprites[i], [x, y]);
                        update_color(p_sprites[i], [255, 255, 255, 255]);
                        update_scale(p_sprites[i], [1, 1]);
                        p_active[i] = true;
                        p_vx[i] = sp * math_cos(a);
                        p_vy[i] = sp * math_sin(a);
                        p_life[i] = particle_life;
                        p_is_bomb[i] = false; p_is_heal[i] = false;
                        emitted = emitted + 1;
                    }
                }
            };
        }

        if (message === "heal_emit") { //治疗怪专用
            return (x, y) => {
                let emitted = 0;
                for (let i = 0; i < particle_pool_size && emitted < 12; i = i + 1) {
                    if (!p_active[i]) {
                        let a = math_random() * 2 * math_PI;
                        let sp = 2 * math_random();
                        update_position(p_sprites[i], [x, y]);
                        update_color(p_sprites[i], [0, 255, 0, 255]);
                        update_scale(p_sprites[i], [2.5, 2.5]);
                        p_active[i] = true; p_vx[i] = sp*math_cos(a); p_vy[i] = sp*math_sin(a);
                        p_life[i] = 25; p_is_bomb[i] = false; p_is_heal[i] = true;
                        emitted = emitted + 1;
                    }
                }
            };
        }

        if (message === "update_all") {
            //遍历活跃粒子 移动、衰减、归零后停用
            return () => {
                for (let i = 0; i < particle_pool_size; i = i + 1) {
                    if (p_active[i]) {
                        let pos = query_position(p_sprites[i]);
                        let nx = pos[0] + p_vx[i];
                        let ny = pos[1] + p_vy[i];
                        update_position(p_sprites[i], [nx, ny]);
                        p_life[i] = p_life[i] - 1;
                        let max_life = particle_life;
                        if (p_is_bomb[i]) { max_life = 30; }
                        let a = math_round(255 * p_life[i] / max_life);
                        if (p_is_bomb[i]) {
                            update_color(p_sprites[i], [255, 100, 20, a]);
                        } else if (p_is_heal[i]) {
                            update_color(p_sprites[i], [50, 255, 50, a]);
                        } else {
                            update_color(p_sprites[i], [255, 255, 255, a]);
                        }
                        if (p_life[i] <= 0) {
                            p_active[i] = false;
                            update_position(p_sprites[i], [-9999, -9999]);
                            update_scale(p_sprites[i], [0, 0]);
                        }
                    }
                }
            };
        }
    };
}

function gun(){ //枪类
    
    const gun_offset = 20; // 枪离屏幕中心的距离（像素）
    
    return message => {
        if (message === "create_gun") {
            //不接受参数 创建普通枪贴图对象
            normal_gun_sprite = create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/AK47.png');
            return update_scale(normal_gun_sprite,[gun_scale,gun_scale]);
        }
        
        if (message === "update_gun") {
            //根据当前武器模式切换显示对应枪贴图 并旋转指向鼠标
            return gun_unused => {
                let mouse_pos = query_pointer_position();
                let dx = mouse_pos[0] - width / 2;
                let dy = mouse_pos[1] - height / 2;
                let angle = math_atan2(dy, dx);
                let gun_x = width / 2 + gun_offset * math_cos(angle);
                let gun_y = height / 2 + gun_offset * math_sin(angle);

                // 先将所有武器隐形
                update_scale(normal_gun_sprite, [0, 0]);
                if (bomb_gun_sprite !== undefined) { update_scale(bomb_gun_sprite, [0, 0]); }
                if (gatling_gun_sprite !== undefined) { update_scale(gatling_gun_sprite, [0, 0]); }
                if (revolver_gun_sprite !== undefined) { update_scale(revolver_gun_sprite, [0, 0]); }
                if (taser_gun_sprite !== undefined) { update_scale(taser_gun_sprite, [0, 0]); }

                // 根据模式显隐对应的武器
                if (is_bomb_mode && bomb_gun_sprite !== undefined) {
                    update_scale(bomb_gun_sprite, [gun_scale * 2.5, gun_scale * 2.5]);
                    update_position(bomb_gun_sprite, [gun_x, gun_y]);
                    update_rotation(bomb_gun_sprite, angle);
                } else if (is_gatling_mode && gatling_gun_sprite !== undefined) {
                    update_scale(gatling_gun_sprite, [gun_scale * 1.5, gun_scale * 1.5]);
                    update_position(gatling_gun_sprite, [gun_x, gun_y]);
                    update_rotation(gatling_gun_sprite, angle);
                } else if (is_revolver_mode && revolver_gun_sprite !== undefined) {
                    update_scale(revolver_gun_sprite, [gun_scale * 1.2, gun_scale * 1.2]);
                    update_position(revolver_gun_sprite, [gun_x, gun_y]);
                    update_rotation(revolver_gun_sprite, angle);
                } else if (is_taser_mode && taser_gun_sprite !== undefined) {
                    update_scale(taser_gun_sprite, [gun_scale * 1.3, gun_scale * 1.3]);
                    update_position(taser_gun_sprite, [gun_x, gun_y]);
                    update_rotation(taser_gun_sprite, angle);
                } else {
                    update_scale(normal_gun_sprite, [gun_scale, gun_scale]);
                    update_position(normal_gun_sprite, [gun_x, gun_y]);
                    update_rotation(normal_gun_sprite, angle);
                }
                return 0;
            };
        }
    };
}

function bullets(){ //子弹类

    const spawn_dist = 30; // 子弹生成点离屏幕中心的距离

    return message => {

        if (message === "fire") {
            //接受鼠标位置 按bullets_per_shot散射发射多颗子弹
            return mouse_pos => {
                let dx = mouse_pos[0] - width / 2;
                let dy = mouse_pos[1] - height / 2;
                let base = math_atan2(dy, dx);
                let step = bullets_per_shot > 1
                    ? bullet_total_spread / (bullets_per_shot - 1)
                    : 0;
                let half = bullet_total_spread / 2;
                let fired = 0;
                for (let i = 0; i < bullet_pool_size && fired < bullets_per_shot; i = i + 1) {
                    if (!b_active[i]) {
                        let a = base - half + fired * step;
                        let sx = width / 2 + spawn_dist * math_cos(a);
                        let sy = height / 2 + spawn_dist * math_sin(a);
                        let bs = bullet_radius / 4;
                        update_scale(b_sprites[i], [bs, bs]);
                        update_rotation(b_sprites[i], a + math_PI / 2);
                        update_position(b_sprites[i], [sx, sy]);
                        b_active[i] = true;
                        b_type[i] = 0;
                        b_vx[i] = bullet_speed * math_cos(a);
                        b_vy[i] = bullet_speed * math_sin(a);
                        b_life[i] = 0;
                        fired = fired + 1;
                    }
                }
                if (has_backshot) {
                    let done = false;
                    for (let i = 0; i < bullet_pool_size && !done; i = i + 1) {
                        if (!b_active[i]) {
                            let ba = base + math_PI;
                            let bs = bullet_radius / 4;
                            let sx2 = width / 2 + spawn_dist * math_cos(ba);
                            let sy2 = height / 2 + spawn_dist * math_sin(ba);
                            update_scale(b_sprites[i], [bs, bs]);
                            update_rotation(b_sprites[i], ba + math_PI / 2);
                            update_position(b_sprites[i], [sx2, sy2]);
                            b_active[i] = true;
                            b_type[i] = 0;
                            b_vx[i] = bullet_speed * math_cos(ba);
                            b_vy[i] = bullet_speed * math_sin(ba);
                            b_life[i] = 0;
                            done = true;
                        }
                    }
                }
            };
        }

        if (message === "update_all") {
            //遍历池中活跃子弹 移动、衰减、碰撞、越界则停用
            return () => {
                let ec3 = array_length(enermys);
                for (let i = 0; i < bullet_pool_size; i = i + 1) {
                    if (b_active[i]) {
                        b_life[i] = b_life[i] + 1;
                        let sf = (b_type[i] === 1) ? 1 : (1 - b_life[i] / bullet_life); // 左轮子弹无速度衰减
                        // 追踪：每帧向最近敌人拐弯（左轮子弹不追踪）
                        if (has_homing && b_type[i] !== 1) {
                            let pos0 = query_position(b_sprites[i]);
                            let ndist = 99999;
                            let tdx = 0;
                            let tdy = 0;
                            for (let j = 0; j < ec3; j = j + 1) {
                                if (enermys[j]('is_alive')()) {
                                    let ep = query_position(enermys[j]('get_sprite')());
                                    let edx2 = ep[0] - pos0[0];
                                    let edy2 = ep[1] - pos0[1];
                                    let edsq2 = edx2 * edx2 + edy2 * edy2;
                                    if (edsq2 < ndist) { ndist = edsq2; tdx = edx2; tdy = edy2; }
                                }
                            }
                            if (ndist < 99999) {
                                let tdist = math_sqrt(tdx * tdx + tdy * tdy);
                                if (tdist > 0) {
                                    let hs = 0.12;
                                    b_vx[i] = b_vx[i] * (1 - hs) + (tdx / tdist) * bullet_speed * hs;
                                    b_vy[i] = b_vy[i] * (1 - hs) + (tdy / tdist) * bullet_speed * hs;
                                    update_rotation(b_sprites[i], math_atan2(b_vy[i], b_vx[i]) + math_PI / 2);
                                }
                            }
                        }
                        let cvx = b_vx[i] * sf;
                        let cvy = b_vy[i] * sf;
                        let pos = query_position(b_sprites[i]);
                        let nx = pos[0] + cvx;
                        let ny = pos[1] + cvy;
                        update_position(b_sprites[i], [nx, ny]);
                        let mpx = player_map_px + (nx - width / 2);
                        let mpy = player_map_py + (ny - height / 2);
                        let tx = math_floor(mpx / tile_pixel);
                        let ty = math_floor(mpy / tile_pixel);
                        let hit = false;
                        for (let j = 0; j < ec3 && !hit; j = j + 1) {
                            if (enermys[j]('is_alive')()) {
                                let ep = query_position(enermys[j]('get_sprite')());
                                let edx = nx - ep[0];
                                let edy = ny - ep[1];
                                // AABB粗筛 + 平方距节省math_sqrt
                                let bhit_r = enermys[j]('get_behavior')() === 8 ? 48 : 24;
                                let bhit_rsq = bhit_r * bhit_r;
                                if (math_abs(edx) < bhit_r && math_abs(edy) < bhit_r &&
                                    edx * edx + edy * edy < bhit_rsq) {
                                    // 伤害判别与电击手枪特化效果
                                    hit = true;
                                    if (b_type[i] === 2) { 
                                        // 【电击枪效果】：大范围内所有怪物静止180帧(3秒) 生命值削至1
                                        let stun_radius = 250;
                                        for (let k = 0; k < ec3; k = k + 1) {
                                            if (enermys[k]('is_alive')()) {
                                                let target_p = query_position(enermys[k]('get_sprite')());
                                                let tdx = ep[0] - target_p[0];
                                                let tdy = ep[1] - target_p[1];
                                                if (tdx * tdx + tdy * tdy < stun_radius * stun_radius) {
                                                    enermys[k]('stun')(180);
                                                    enermys[k]('set_hp')(1);
                                                }
                                            }
                                        }
                                        enermys[j]('damage')(math_round(bullet_damage));
                                    } else if (b_type[i] === 1) {
                                        enermys[j]('damage')(math_round(999 * bullet_damage)); // 左轮秒杀
                                    } else {
                                        enermys[j]('damage')(math_round(bullet_damage));
                                    }
                                    if (has_knockback) {
                                        let bv = enermys[j]('get_behavior')();
                                        let kstr = 15;
                                        if (bv === 3 || bv === 4) { kstr = 5; }
                                        let pdx = ep[0] - width / 2;
                                        let pdy = ep[1] - height / 2;
                                        let pdist = math_sqrt(pdx * pdx + pdy * pdy);
                                        if (pdist > 0) {
                                            enermys[j]('push')(pdx / pdist * kstr, pdy / pdist * kstr);
                                        }
                                    }
                                }
                            }
                        }
                        if (sf <= 0 || is_wall(tile_map, tx, ty) || hit) {
                            b_active[i] = false;
                            update_scale(b_sprites[i], [0, 0]);
                            update_position(b_sprites[i], [-9999, -9999]);
                        }
                    }
                }
            };
        }

    };
}

//枪口火光
function fireLightCover(){
    return message =>{
        if (message==='create_fire_ligheter'){
            const lighter= update_scale(create_sprite("https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/fireLight-cover.png"),[3,2]);
            return update_color(lighter,[255,255,255,0]);
        }
        
         if (message === 'update_fire_light'){
            return lighter =>{
                let mp = query_pointer_position();
                let mpx = mp[0] - width / 2;
                let mpy = mp[1] - height / 2;
                let a = math_atan2(mpy, mpx);
                let fx = width / 2 + 16 * math_cos(a);
                let fy = height / 2 + 16 * math_sin(a);
                update_position(lighter, [fx, fy]);
                let Hypotenuse_length = math_sqrt(math_pow(mpx,2)+math_pow(mpy,2));
                update_rotation(lighter, a);
                
            
                if (fireLightCoverTimer>0){
                    update_color(lighter,[255,255,255,100]);       
                    fireLightCoverTimer=fireLightCoverTimer-1;
                } else {
                    update_color(lighter,[255,255,255,0]);       
                }
            };
        }
    };
}





//移动
//以下三个函数为阻止玩家离开边界的函数
function is_wall(tile_map, x, y) { //无需在意
    if (x < 0 || x >= array_length(tile_map[0]) ||
        y < 0 || y >= array_length(tile_map)) {
        return true;
    }
    let t = tile_map[y][x];
    return t === 'wallTop' ||
           t === 'wallCenter' ||
           t === 'wallLeftBottom' || t === 'bottomWall' ||
           t === 'bottomRightWall' || t === 'rightWall' ||
           t === 'LeftWall' ||
           t === 'topLeftWall' || t === 'topWall' ||
           t === 'topRightWall';
}

function can_move_x(tile_map, px, py, dx) { //无需在意
    if (dx > 0) {
        let check_x = math_floor((px + dx + tile_pixel - 1) / tile_pixel);
        let top_y   = math_floor(py / tile_pixel);
        let bot_y   = math_floor((py + tile_pixel - 1) / tile_pixel);
        return !(is_wall(tile_map, check_x, top_y) ||
                 is_wall(tile_map, check_x, bot_y));
    } else if (dx < 0) {
        let check_x = math_floor((px + dx) / tile_pixel);
        let top_y   = math_floor(py / tile_pixel);
        let bot_y   = math_floor((py + tile_pixel - 1) / tile_pixel);
        return !(is_wall(tile_map, check_x, top_y) ||
                 is_wall(tile_map, check_x, bot_y));
    }
    return true;
}

function can_move_y(tile_map, px, py, dy) { //无需在意
    if (dy > 0) {
        let left_x  = math_floor(px / tile_pixel);
        let right_x = math_floor((px + tile_pixel - 1) / tile_pixel);
        let check_y = math_floor((py + dy + tile_pixel - 1) / tile_pixel);
        return !(is_wall(tile_map, left_x, check_y) ||
                 is_wall(tile_map, right_x, check_y));
    } else if (dy < 0) {
        let left_x  = math_floor(px / tile_pixel);
        let right_x = math_floor((px + tile_pixel - 1) / tile_pixel);
        let check_y = math_floor((py + dy) / tile_pixel);
        return !(is_wall(tile_map, left_x, check_y) ||
                 is_wall(tile_map, right_x, check_y));
    }
    return true;
}

//输入
function input_listener(){ 
    let dx = 0;
    let dy = 0;
    
    if (input_key_down('w')) { dy = dy - player_speed; }
    if (input_key_down('s')) { dy = dy + player_speed; }
    if (input_key_down('a')) { 
        dx = dx - player_speed; 
        player()('determine_direction')(player_instance,dx);
    }
    if (input_key_down('d')) {
        dx = dx + player_speed;
        player()('determine_direction')(player_instance,dx);
    }
    
    if (dx !== 0 && dy !== 0) {
        let diag = player_speed / math_sqrt(2);
        dx = dx > 0 ? diag : -diag;
        dy = dy > 0 ? diag : -diag;
    }
    
    player_moving = (dx !== 0 || dy !== 0);
    
    let ec = array_length(enermys);
    let tc = array_length(tile_sprites);
    
    if (dx !== 0 && can_move_x(tile_map, player_map_px, player_map_py, dx)) {
        let was_hit = false;
        for (let i = 0; i < ec && !was_hit; i = i + 1) { // 找到重叠即退出
            if (enermys[i]('is_alive')() &&
                gameobjects_overlap(player_instance, enermys[i]('get_sprite')())) {
                was_hit = true;
            }
        }
        player_map_px = player_map_px + dx;
        for (let i = 0; i < tc; i = i + 1) {
            let pos = query_position(tile_sprites[i]);
            update_position(tile_sprites[i], [pos[0] - dx, pos[1]]);
        }
        for (let i = 0; i < ec; i = i + 1) {
            enermys[i]('update_map_offset')(dx, 0);
        }
        enemy_bullets()('update_map_offset')(dx, 0);
        game_rewards()('update_map_offset')(dx, 0);
        this_bomb('update_map_offset')(dx, 0);
        let now_hit = false;
        for (let i = 0; i < ec && !now_hit; i = i + 1) { // 找到重叠即退出
            if (enermys[i]('is_alive')() &&
                gameobjects_overlap(player_instance, enermys[i]('get_sprite')())) {
                now_hit = true;
            }
        }
        if (!was_hit && now_hit) {
            player_map_px = player_map_px - dx;
            for (let i = 0; i < tc; i = i + 1) {
                let pos = query_position(tile_sprites[i]);
                update_position(tile_sprites[i], [pos[0] + dx, pos[1]]);
            }
            for (let i = 0; i < ec; i = i + 1) {
                enermys[i]('update_map_offset')(-dx, 0);
            }
            enemy_bullets()('update_map_offset')(-dx, 0);
            game_rewards()('update_map_offset')(-dx, 0);
            this_bomb('update_map_offset')(-dx, 0);
        }
    }
    
    if (dy !== 0 && can_move_y(tile_map, player_map_px, player_map_py, dy)) {
        let was_hit = false;
        for (let i = 0; i < ec && !was_hit; i = i + 1) { // 找到重叠即退出
            if (enermys[i]('is_alive')() &&
                gameobjects_overlap(player_instance, enermys[i]('get_sprite')())) {
                was_hit = true;
            }
        }
        player_map_py = player_map_py + dy;
        for (let i = 0; i < tc; i = i + 1) {
            let pos = query_position(tile_sprites[i]);
            update_position(tile_sprites[i], [pos[0], pos[1] - dy]);
        }
        for (let i = 0; i < ec; i = i + 1) {
            enermys[i]('update_map_offset')(0, dy);
        }
        enemy_bullets()('update_map_offset')(0, dy);
        game_rewards()('update_map_offset')(0, dy);
        this_bomb('update_map_offset')(0, dy);
        let now_hit = false;
        for (let i = 0; i < ec && !now_hit; i = i + 1) { // 找到重叠即退出
            if (enermys[i]('is_alive')() &&
                gameobjects_overlap(player_instance, enermys[i]('get_sprite')())) {
                now_hit = true;
            }
        }
        if (!was_hit && now_hit) {
            player_map_py = player_map_py - dy;
            for (let i = 0; i < tc; i = i + 1) {
                let pos = query_position(tile_sprites[i]);
                update_position(tile_sprites[i], [pos[0], pos[1] + dy]);
            }
            for (let i = 0; i < ec; i = i + 1) {
                enermys[i]('update_map_offset')(0, -dy);
            }
            enemy_bullets()('update_map_offset')(0, -dy);
            game_rewards()('update_map_offset')(0, -dy);
            this_bomb('update_map_offset')(0, -dy);
        }
    }
    
}


// 游戏初始化
    
    //map
    const tile_map=generateTileMap(60,55);
    map()('generate_map')(tile_map);
    //player
    const player_instance = player()('create_player');
    player()('update_position')(player_instance);
    player_frame2 = create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/player_frame2.png');
    update_scale(player_frame2, [0, 0]);
    update_position(player_frame2, [width / 2, height / 2]);
    //gun
    const gun_instance = gun()('create_gun');
    //levelup cards
    lv_title_card = create_rectangle(50, 50);
    update_position(lv_title_card, [-9999, -9999]);
    update_scale(lv_title_card, [0, 0]);
    lv_title_text = create_text('');
    update_position(lv_title_text, [-9999, -9999]);
    update_scale(lv_title_text, [0, 0]);
    for (let i = 0; i < 4; i = i + 1) {
        lv_cards[i] = create_rectangle(50, 50);
        update_position(lv_cards[i], [-9999, -9999]);
        update_scale(lv_cards[i], [0, 0]);
        lv_texts[i] = create_text('');
        update_position(lv_texts[i], [-9999, -9999]);
        update_scale(lv_texts[i], [0, 0]);
    }
    //bullet pool
    const bullet_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E5%AD%90%E5%BC%B9.png';
    for (let i = 0; i < bullet_pool_size; i = i + 1) {
        b_sprites[i] = create_sprite(bullet_url);
        update_scale(b_sprites[i], [0, 0]);
        update_position(b_sprites[i], [-100, -100]);
        b_active[i] = false;
        b_type[i] = 0;
        b_vx[i] = 0;
        b_vy[i] = 0;
    }
    //bomb
    const bomb_projectile_texture = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/%E9%AC%BC%E5%86%85.png';
    const bomb_weapon_texture = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/gun1/gun%20(4).png';
    const this_bomb = bomb(10, 8, bomb_projectile_texture, bomb_weapon_texture);
    this_bomb('init')();
    //gatling
    const gatling_weapon_texture = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/gun1/gun%20(2).png';
    const this_gatling = gatling(1.0, gatling_weapon_texture);
    this_gatling('init')();
    //revolver
    const revolver_weapon_texture = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/gun1/gun%20(12).png';
    const this_revolver = revolver(999.0, revolver_weapon_texture);
    this_revolver('init')();
    //taser
    const taser_weapon_texture = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/gun1/gun%20(6).png';
    const this_taser = taser(taser_weapon_texture);
    this_taser('init')();

    //reward pool
    for (let i = 0; i < reward_pool_size; i = i + 1) {
        global_rewards[i] = reward(reward_texture);
        global_rewards[i]("init")();
    }
    //enemy bullet pool
    for (let i = 0; i < eb_pool_size; i = i + 1) {
        eb_sprites[i] = create_rectangle(6, 6);
        update_position(eb_sprites[i], [-9999, -9999]);
        update_scale(eb_sprites[i], [0, 0]);
        eb_active[i] = false;
        eb_vx[i] = 0;
        eb_vy[i] = 0;
        eb_life[i] = 0;
    }
    //enemy pool
    const elf_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/monster/monster_chort.png';
    const slime_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/monster/monster_bat.png';
    const orc_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/monster/monster_ogre.png';
    const mage_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/monster/monster_necromancer.png';
    const bomb_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/monster_elemental_fire.png';
    const reward_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/monster/monster_elemental_water.png';  
    const heal_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/main/monster/monster_elemental_plant.png';
    const boss_url = 'https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/monster/monster_tentackle.png';
    const max_pool_size = 100;
    const boss_pool_size = 5;
    for (let i = 0; i < max_pool_size; i = i + 1) {
        let rand = math_random();
        let new_enemy = undefined;
        if (rand < 0.20) {
            new_enemy = enemy(5, 1.5, elf_url, 1, 0);
        } else if (rand < 0.30) {
            // 治疗师：缓慢靠近，定期治疗周围怪物
            new_enemy = enemy(3, 0.6, heal_url, 7, 0);
        } else if (rand < 0.4) {
            new_enemy = enemy(2, 1.8, slime_url, 2, 0);
        } else if (rand < 0.6) {
            new_enemy = enemy(10, 0.2, orc_url, 3, 0);
        } else if (rand < 0.75) {
            new_enemy = enemy(4, 0.8, mage_url, 4, 0);
        } else if (rand < 0.88) {
            new_enemy = enemy(5, 1.5, bomb_url, 5, 0);
        } else {
            // 【新怪物】：金色寻宝怪！移速快，行为6(逃跑)，击杀必掉落奖励(1)
            new_enemy = enemy(5, 0.8, reward_url, 6, 1);
        }
        new_enemy('init')();
        enermys[i] = new_enemy;
    }
    for (let i = max_pool_size - 1; i > 0; i = i - 1) {
        let j = math_floor(math_random() * (i + 1));
        let tmp = enermys[i];
        enermys[i] = enermys[j];
        enermys[j] = tmp;
    }
    // Boss敌人池：behavior 8, 高血量, 慢速, 贴图为触手怪, 击杀必掉落
    for (let i = 0; i < boss_pool_size; i = i + 1) {
        let boss = enemy(80, 0.8, boss_url, 8, 1);
        boss('init')();
        enermys[max_pool_size + i] = boss;
    }
    const spawner_instance = enemy_spawner(4, 360);
    for (let i = 0; i < 3; i = i + 1) {
        let a = math_random() * 2 * math_PI;
        let sx = width / 2 + 600 * math_cos(a);
        let sy = height / 2 + 600 * math_sin(a);
        enermys[i]('spawn')(sx, sy);
    }
    //UI
    hpBarBackground = create_rectangle(hpBarWidth, hpBarHeight);
    update_color(hpBarBackground, [15, 15, 15, 255]);
    hpBarFill = create_rectangle(hpBarWidth, hpBarHeight);
    update_color(hpBarFill, [255, 20, 20, 255]);
    xpBarBackground = create_rectangle(width, 8);
    update_color(xpBarBackground, [15, 15, 15, 255]);
    xpBarFill = create_rectangle(width, 8);
    update_color(xpBarFill, [20, 200, 20, 255]);
    gameover_card = create_rectangle(200, 60);
    update_position(gameover_card, [-9999, -9999]);
    update_scale(gameover_card, [0, 0]);
    gameover_text = create_text('');
    update_position(gameover_text, [-9999, -9999]);
    update_scale(gameover_text, [0, 0]);
    //右上角UI
    ui_level_text = create_text('LV: 1');
    update_color(ui_level_text, [255, 255, 255, 255]);
    update_scale(ui_level_text, [1.2, 1.2]);

    ui_kills_text = create_text('KILLS: 0');
    update_color(ui_kills_text, [255, 215, 0, 255]);
    update_scale(ui_kills_text, [1.2, 1.2]);
    //particle pool
    for (let i = 0; i < particle_pool_size; i = i + 1) {
        p_sprites[i] = create_rectangle(4, 4);
        update_position(p_sprites[i], [-9999, -9999]);
        update_scale(p_sprites[i], [0, 0]);
        p_active[i] = false;
        p_vx[i] = 0;
        p_vy[i] = 0;
        p_life[i] = 0; p_is_bomb[i] = false; p_is_heal[i] = false;
    }
    // lightCover
    const lightCover=update_scale(create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/TEST/lightCover.png'),[2.25,2.25]);
    update_position(lightCover,[width/2,height/2]);

    //fireligher
    const fireLighterCover = fireLightCover()('create_fire_ligheter');

    // 开始界面
    start_bg = create_rectangle(width, height);
    update_color(start_bg, [0, 0, 0, 180]);   // 半透明黑色遮罩
    update_position(start_bg, [width / 2, height / 2]);
    update_to_top(start_bg);

    start_title = create_text('The Punishment of the Peanut Butter God');
    update_color(start_title, [255, 255, 255, 255]);
    update_position(start_title, [width / 2, height / 2 - 50]);
    update_scale(start_title, [2, 2]);
    update_to_top(start_title);

    start_go_sprite = create_sprite('https://raw.githubusercontent.com/StoreManager-Riddle/SourceAcademyProject/refs/heads/main/%E5%B1%8F%E5%B9%95%E6%88%AA%E5%9B%BE%202026-07-22%20160430.png');
    update_scale(start_go_sprite, [0.3, 0.2]);
    update_position(start_go_sprite, [width / 2, height / 2 + 100]);
    update_to_top(start_go_sprite);


//游戏主循环
update_loop((game_state) => {
    if (!game_started) {
        // 确保开始界面元素始终置顶
        update_to_top(start_bg);
        update_to_top(start_title);
        update_to_top(start_go_sprite);

        // 检测鼠标点击 GO 按钮
        if (input_left_mouse_down()) {
            const mp = query_pointer_position();
            const btnPos = query_position(start_go_sprite);
            const btnW = 200;
            const btnH = 100;
            if (mp[0] > btnPos[0] - btnW && mp[0] < btnPos[0] + btnW &&
                mp[1] > btnPos[1] - btnH && mp[1] < btnPos[1] + btnH) {
                // 点击 GO：切换状态，隐藏开始界面
                game_started = true;
                update_position(start_bg, [-9999, -9999]);
                update_scale(start_bg, [0, 0]);
                update_position(start_title, [-9999, -9999]);
                update_scale(start_title, [0, 0]);
                update_position(start_go_sprite, [-9999, -9999]);
                update_scale(start_go_sprite, [0, 0]);
            }
        }
    } else {
        if (player_hp <= 0) {
        gameover_active = true;
    }
    if (gameover_active) {
        update_position(gameover_card, [width / 2, height / 2]);
        update_scale(gameover_card, [4, 1.2]);
        update_color(gameover_card, [30, 30, 30, 255]);
        update_to_top(gameover_card);
        update_text(gameover_text, 'GAME OVER');
        update_position(gameover_text, [width / 2, height / 2]);
        update_scale(gameover_text, [1, 1]);
        update_to_top(gameover_text);
    }
    if (!levelup_active && !gameover_active) {
        const barX = 25;
        const barY = 25;
        
        //fireLighter
        fireLightCover()('update_fire_light')(fireLighterCover);
        
        update_position(hpBarBackground, [barX, barY]);
        update_position(hpBarFill, [barX, barY]);
        update_to_top(hpBarBackground);
        update_to_top(hpBarFill);
        let hpRatio = player_hp / player_max_hp;
        update_scale(hpBarFill, [hpRatio, 1]);
        let xpNeed = 3 + 2 * player_level;
        let xpRatio = player_kills / xpNeed;
        update_position(xpBarBackground, [width / 2, 4]);
        update_position(xpBarFill, [width / 2, 4]);
        update_to_top(xpBarBackground);
        update_to_top(xpBarFill);
        update_scale(xpBarFill, [xpRatio, 1]);

        // 右上角UI
        const ui_right_x = width - 90;
        update_text(ui_level_text, 'LV: ' + stringify(player_level));
        update_position(ui_level_text, [ui_right_x, 25]);
        update_to_top(ui_level_text);

        update_text(ui_kills_text, 'KILLS: ' + stringify(total_kills));
        update_position(ui_kills_text, [ui_right_x, 50]);
        update_to_top(ui_kills_text);

        if (player_hurt_cd > 0) { player_hurt_cd = player_hurt_cd - 1; }
        player()('update_color')(player_instance);

        if (player_moving) {
            player_anim_timer = player_anim_timer + 1;
            if (player_anim_timer >= 25) {
                player_anim_timer = 0;
                if (query_scale(player_instance)[0] !== 0) {
                    update_scale(player_instance, [0, 0]);
                    update_scale(player_frame2, [player_dir_sign * player_scale, player_scale]);
                } else {
                    update_scale(player_instance, [player_dir_sign * player_scale, player_scale]);
                    update_scale(player_frame2, [0, 0]);
                }
            }
        } else {
            update_scale(player_instance, [player_dir_sign * player_scale, player_scale]);
            update_scale(player_frame2, [0, 0]);
        }
        player()('update_color')(player_frame2);

        input_listener();

        spawner_instance('update')();
        game_rewards()('update')(); // 掉落物捡起碰撞检测
        
        gun()('update_gun')(gun_instance);

        // 获取鼠标方向并实时更新左轮/电击枪射线位置
        let mp_aim = query_pointer_position();
        let aim_dx = mp_aim[0] - width / 2;
        let aim_dy = mp_aim[1] - height / 2;
        let aim_angle = math_atan2(aim_dy, aim_dx);
        this_revolver('update_aim_line')(width / 2, height / 2, aim_angle);
        this_taser('update_aim_line')(width / 2, height / 2, aim_angle);
    
    if (fire_cooldown > 0) {
        fire_cooldown = fire_cooldown - 1;
    }

    // 【武器开火与模式判定】
    if (input_left_mouse_down() && fire_cooldown <= 0) {
        fireLightCoverTimer=3;
        play_audio(shoot_sound);
        let mp = query_pointer_position();

        if (is_bomb_mode && bomb_ammo > 0) {
            let dx2 = mp[0] - width / 2;
            let dy2 = mp[1] - height / 2;
            let angle = math_atan2(dy2, dx2);
            this_bomb('fire')(width / 2, height / 2, angle);
            bomb_ammo = bomb_ammo - 1;
            if (bomb_ammo <= 0) { 
                is_bomb_mode = false; 
                bomb_ammo = 0; 
            }
            fire_cooldown = bullet_fire_rate;
        } else if (is_gatling_mode && gatling_ammo > 0) {
            let dx2 = mp[0] - width / 2;
            let dy2 = mp[1] - height / 2;
            let angle = math_atan2(dy2, dx2);
            
            this_gatling('fire')(width / 2, height / 2, angle);
            gatling_ammo = gatling_ammo - 1;
            
            if (gatling_ammo <= 0) { 
                is_gatling_mode = false; 
                gatling_ammo = 0; 
            }
            fire_cooldown = this_gatling('get_fire_rate')();
        } else if (is_revolver_mode && revolver_ammo > 0) {
            this_revolver('fire')(width / 2, height / 2, aim_angle);
            
            revolver_ammo = revolver_ammo - 1;
            if (revolver_ammo <= 0) {
                is_revolver_mode = false;
                revolver_ammo = 0;
                this_revolver('update_aim_line')(0, 0, 0); // 隐藏射线
            }
            
            fire_cooldown = this_revolver('get_fire_rate')();
        } else if (is_taser_mode && taser_ammo > 0) {
            this_taser('fire')(width / 2, height / 2, aim_angle);
            
            taser_ammo = taser_ammo - 1;
            if (taser_ammo <= 0) {
                is_taser_mode = false;
                taser_ammo = 0;
                this_taser('update_aim_line')(0, 0, 0); // 隐藏射线
            }
            
            fire_cooldown = this_taser('get_fire_rate')();
        } else {
            bullets()('fire')(mp);
            fire_cooldown = bullet_fire_rate;
        }
    }
    bullets()('update_all')();
    this_bomb('update')();
    
    particles()('update_all')();
    
    enemy_bullets()('update_all')();
    
    let ec2 = array_length(enermys);
    for (let i = 0; i < ec2; i = i + 1) {
        enermys[i]('chase_player')();
    }
    for (let i = 0; i < ec2; i = i + 1) {
        for (let j = i + 1; j < ec2; j = j + 1) {
            if (enermys[i]('is_alive')() && enermys[j]('is_alive')()) {
                let p1 = query_position(enermys[i]('get_sprite')());
                let p2 = query_position(enermys[j]('get_sprite')());
                let edx = p1[0] - p2[0];
                let edy = p1[1] - p2[1];
                let push_r = (enermys[i]('get_behavior')() === 8 || enermys[j]('get_behavior')() === 8) ? 70 : 40;
                let push_rsq = push_r * push_r;
                if (math_abs(edx) < push_r && math_abs(edy) < push_r) {
                    let edsq = edx * edx + edy * edy;
                    if (edsq < push_rsq && edsq > 0) {
                        let ed = math_sqrt(edsq);
                        let overlap = (push_r - ed) / 2;
                        let px = (edx / ed) * overlap;
                        let py = (edy / ed) * overlap;
                        enermys[i]('push')(px, py);
                        enermys[j]('push')(-px, -py);
                    }
                }
            }
        }
    }
    
    for (let i = 0; i < ec2; i = i + 1) {
        if (enermys[i]('is_alive')()) {
            let p_enemy = query_position(enermys[i]('get_sprite')());
            let edx = p_enemy[0] - width / 2;
            let edy = p_enemy[1] - height / 2;
            let edsq = edx * edx + edy * edy;
            let pdmg_r = enermys[i]('get_behavior')() === 8 ? 55 : 30;
            let pdmg_rsq = pdmg_r * pdmg_r;
            if (edsq < pdmg_rsq && edsq > 0) {
                let ed = math_sqrt(edsq);
                let overlap = pdmg_r - ed;
                let px = (edx / ed) * overlap;
                let py = (edy / ed) * overlap;
                enermys[i]('push')(px, py);
                if (player_hurt_cd <= 0) {
                    player()('damage')(1);
                    player_hurt_cd = player_hurt_interval;
                }
            }
        }
    }
    }
    
    if (levelup_click_lock && !input_left_mouse_down()) {
        levelup_click_lock = false;
    }
    if (levelup_active && !levelup_click_lock && input_left_mouse_down()) {
        let mp = query_pointer_position();
        let opt_count = array_length(levelup_options);
        for (let i = 0; i < opt_count; i = i + 1) {
            let cx = width / 2 + (i - (opt_count - 1) / 2) * 180;
            let cy = height / 2;
            if (mp[0] > cx - 80 && mp[0] < cx + 80 &&
                mp[1] > cy - 30 && mp[1] < cy + 30) {
                apply_upgrade(levelup_options[i]);
                hide_levelup();
            }
        }
    }
    } // end of game_started else

    // Using game_state as a counter
    if (game_state[0] === undefined) {
        game_state[0] = 0;
    }
    game_state[0] = game_state[0] + 1;
});

play_audio(loop_audio(bgm));
build_game();