太阳rpg编辑器.webp

TypeScript 的类

1. 基本类的定义和使用

// 定义一个基础的英雄类
class Hero {
    // 属性定义
    private unit: unit;           // 英雄单位
    private name: string;         // 英雄名称
    private level: number;        // 英雄等级
    private experience: number;   // 经验值
    
    // 构造函数
    constructor(player: player, heroId: number, x: number, y: number) {
        // 创建英雄单位
        this.unit = CreateUnit(player, heroId, x, y, 0);
        this.name = GetUnitName(this.unit);
        this.level = 1;
        this.experience = 0;
        
        // 初始化英雄
        this.initialize();
    }

    // 私有方法：初始化
    private initialize(): void {
        // 设置初始属性
        SetHeroLevel(this.unit, this.level, false);
        SetUnitState(this.unit, UNIT_STATE_MANA, 100);
    }

    // 公共方法：获取经验值
    public gainExperience(amount: number): void {
        this.experience += amount;
        // 检查是否可以升级
        this.checkLevelUp();
    }

    // 私有方法：检查升级
    private checkLevelUp(): void {
        let expNeeded = this.level * 100; // 简单的升级经验计算
        if (this.experience >= expNeeded) {
            this.levelUp();
        }
    }

    // 私有方法：升级
    private levelUp(): void {
        this.level++;
        this.experience = 0;
        SetHeroLevel(this.unit, this.level, true);
        // 显示升级特效
        let effect = AddSpecialEffect("Abilities\\Spells\\Other\\LevelUp\\LevelUpTarget.mdl", 
            GetUnitX(this.unit), GetUnitY(this.unit));
        DestroyEffect(effect);
    }
}

2. 继承和多态

// 基础英雄类
abstract class BaseHero {
    protected unit: unit;
    protected mana: number = 100;

    // 抽象方法：每个英雄都必须实现的技能
    abstract castSpell(target: unit): void;

    // 共享方法：所有英雄都可以使用的方法
    protected consumeMana(cost: number): boolean {
        if (this.mana >= cost) {
            this.mana -= cost;
            return true;
        }
        return false;
    }
}

// 战士英雄类
class WarriorHero extends BaseHero {
    // 实现战士的技能
    public castSpell(target: unit): void {
        if (this.consumeMana(50)) {
            // 战士的旋风斩
            let damage = 150;
            let effect = AddSpecialEffect("Abilities\\Spells\\Human\\Whirlwind\\WhirlwindTarget.mdl",
                GetUnitX(target), GetUnitY(target));
            UnitDamageTarget(this.unit, target, damage, true);
            DestroyEffect(effect);
        }
    }
}

// 法师英雄类
class MageHero extends BaseHero {
    // 实现法师的技能
    public castSpell(target: unit): void {
        if (this.consumeMana(80)) {
            // 法师的火球术
            let damage = 200;
            let effect = AddSpecialEffect("Abilities\\Spells\\Other\\Incinerate\\FireLordDeathExplode.mdl",
                GetUnitX(target), GetUnitY(target));
            UnitDamageTarget(this.unit, target, damage, true);
            DestroyEffect(effect);
        }
    }
}

3. 物品系统示例

// 物品类
class Item {
    private item: item;
    private charges: number;

    constructor(itemId: number, x: number, y: number) {
        this.item = CreateItem(itemId, x, y);
        this.charges = 1;
    }

    public use(target: unit): void {
        if (this.charges > 0) {
            this.applyEffect(target);
            this.charges--;
            if (this.charges <= 0) {
                RemoveItem(this.item);
            }
        }
    }

    protected applyEffect(target: unit): void {
        // 基础物品效果
    }
}

// 治疗药水类
class HealingPotion extends Item {
    protected applyEffect(target: unit): void {
        // 恢复生命值
        let healing = 150;
        SetUnitState(target, UNIT_STATE_LIFE,
            GetUnitState(target, UNIT_STATE_LIFE) + healing);
        
        // 显示治疗特效
        let effect = AddSpecialEffect("Abilities\\Spells\\Items\\HealingSalve\\HealingSalveTarget.mdl",
            GetUnitX(target), GetUnitY(target));
        DestroyEffect(effect);
    }
}

4. 游戏管理器类

class GameManager {
    private static instance: GameManager;
    private heroes: Map<player, Hero>;
    private items: Item[];

    private constructor() {
        this.heroes = new Map();
        this.items = [];
        this.initialize();
    }

    // 单例模式获取实例
    public static getInstance(): GameManager {
        if (!GameManager.instance) {
            GameManager.instance = new GameManager();
        }
        return GameManager.instance;
    }

    // 初始化游戏
    private initialize(): void {
        // 为每个玩家创建英雄
        for (let i = 0; i < bj_MAX_PLAYERS; i++) {
            let player = Player(i);
            if (GetPlayerController(player) == MAP_CONTROL_USER) {
                this.createHeroForPlayer(player);
            }
        }

        // 创建初始物品
        this.spawnInitialItems();
    }

    // 为玩家创建英雄
    private createHeroForPlayer(player: player): void {
        // 让玩家选择英雄类型
        let heroType = this.getPlayerHeroChoice(player);
        let hero: Hero;

        if (heroType === "warrior") {
            hero = new WarriorHero(player, WARRIOR_ID, 0, 0);
        } else {
            hero = new MageHero(player, MAGE_ID, 0, 0);
        }

        this.heroes.set(player, hero);
    }

    // 生成初始物品
    private spawnInitialItems(): void {
        // 在地图上生成一些治疗药水
        for (let i = 0; i < 5; i++) {
            let x = GetRandomReal(-500, 500);
            let y = GetRandomReal(-500, 500);
            this.items.push(new HealingPotion(POTION_ID, x, y));
        }
    }
}

5. 使用示例

// 游戏开始时初始化
function initGame(): void {
    let game = GameManager.getInstance();
    
    // 注册物品使用触发器
    let trigger = CreateTrigger();
    TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_USE_ITEM);
    TriggerAddAction(trigger, () => {
        let unit = GetTriggerUnit();
        let item = GetManipulatedItem();
        // 处理物品使用
        if (item instanceof HealingPotion) {
            item.use(unit);
        }
    });
}

关键点总结：

类可以封装相关的数据和行为
继承允许创建专门化的类
私有成员（private）可以保护数据不被外部直接访问
公共方法（public）提供了与类交互的接口
静态成员可以在不创建实例的情况下使用
抽象类和方法可以定义通用行为

TypeScript 的对象

1. 基本对象的创建和使用

// 创建一个英雄属性对象
let heroStats = {
    strength: 20,
    agility: 15,
    intelligence: 18,
    health: 550,
    mana: 300,
    
    // 对象方法
    calculateDamage(): number {
        return this.strength * 2;
    },
    
    calculateArmor(): number {
        return this.agility * 0.2;
    }
};

// 使用对象属性
console.log(heroStats.strength);        // 访问属性
console.log(heroStats.calculateDamage()); // 调用方法

2. 游戏配置对象

// 游戏常量配置对象
const GameConfig = {
    // 英雄相关
    HERO: {
        START_LEVEL: 1,
        MAX_LEVEL: 25,
        BASE_HEALTH: 500,
        BASE_MANA: 200,
        HEALTH_PER_LEVEL: 50,
        MANA_PER_LEVEL: 25
    },
    
    // 物品相关
    ITEMS: {
        POTION_HEAL: 150,
        POTION_MANA: 100,
        SWORD_DAMAGE: 25,
        ARMOR_DEFENSE: 5
    },
    
    // 游戏机制
    MECHANICS: {
        EXP_PER_LEVEL: 100,
        GOLD_BOUNTY: 50,
        RESPAWN_TIME: 30
    }
};

// 使用配置对象
let heroHealth = GameConfig.HERO.BASE_HEALTH + 
    (level - 1) * GameConfig.HERO.HEALTH_PER_LEVEL;

3. 物品系统对象

// 物品模板对象
interface ItemTemplate {
    id: number;
    name: string;
    cost: number;
    icon: string;
    description: string;
    effect: (unit: unit) => void;
}

// 物品数据对象
const ItemData = {
    // 治疗药水
    healingPotion: {
        id: FourCC('hpot'),
        name: "治疗药水",
        cost: 100,
        icon: "ReplaceableTextures\\CommandButtons\\BTNHealingPotion.blp",
        description: "恢复150点生命值",
        effect: (unit: unit) => {
            SetUnitState(unit, UNIT_STATE_LIFE,
                GetUnitState(unit, UNIT_STATE_LIFE) + 150);
        }
    },
    
    // 魔法药水
    manaPotion: {
        id: FourCC('mpot'),
        name: "魔法药水",
        cost: 100,
        icon: "ReplaceableTextures\\CommandButtons\\BTNManaPotion.blp",
        description: "恢复100点魔法值",
        effect: (unit: unit) => {
            SetUnitState(unit, UNIT_STATE_MANA,
                GetUnitState(unit, UNIT_STATE_MANA) + 100);
        }
    }
};

4. 技能系统对象

// 技能效果对象
const SpellEffects = {
    // 火球术
    fireball: {
        damage: 200,
        manaCost: 80,
        range: 600,
        cooldown: 8,
        effect: "Abilities\\Spells\\Other\\Incinerate\\FireLordDeathExplode.mdl",
        
        cast: (caster: unit, target: unit) => {
            let damage = 200 + GetHeroInt(caster, true) * 2;
            UnitDamageTarget(caster, target, damage, true);
            
            // 创建特效
            let effect = AddSpecialEffect(SpellEffects.fireball.effect,
                GetUnitX(target), GetUnitY(target));
            DestroyEffect(effect);
        }
    },
    
    // 治疗术
    heal: {
        healing: 250,
        manaCost: 100,
        range: 500,
        cooldown: 12,
        effect: "Abilities\\Spells\\Human\\Heal\\HealTarget.mdl",
        
        cast: (caster: unit, target: unit) => {
            let healing = 250 + GetHeroInt(caster, true) * 1.5;
            SetUnitState(target, UNIT_STATE_LIFE,
                GetUnitState(target, UNIT_STATE_LIFE) + healing);
            
            // 创建特效
            let effect = AddSpecialEffect(SpellEffects.heal.effect,
                GetUnitX(target), GetUnitY(target));
            DestroyEffect(effect);
        }
    }
};

5. 游戏状态对象

// 游戏状态管理对象
const GameState = {
    // 游戏状态数据
    data: {
        isGameStarted: false,
        currentWave: 0,
        totalScore: 0,
        activePlayers: new Set<player>(),
        heroUnits: new Map<player, unit>()
    },
    
    // 状态更新方法
    startGame(): void {
        this.data.isGameStarted = true;
        this.data.currentWave = 1;
        this.initializePlayers();
    },
    
    initializePlayers(): void {
        for (let i = 0; i < bj_MAX_PLAYERS; i++) {
            let player = Player(i);
            if (GetPlayerController(player) == MAP_CONTROL_USER) {
                this.data.activePlayers.add(player);
                this.createHeroForPlayer(player);
            }
        }
    },
    
    createHeroForPlayer(player: player): void {
        let hero = CreateUnit(player, FourCC('Hpal'), 0, 0, 0);
        this.data.heroUnits.set(player, hero);
    },
    
    // 获取游戏状态
    getGameStatus(): string {
        return `当前波数: ${this.data.currentWave}\n` +
               `总分: ${this.data.totalScore}\n` +
               `活跃玩家: ${this.data.activePlayers.size}`;
    }
};

6. 实际使用示例

// 初始化游戏系统
function initializeGame(): void {
    // 使用游戏配置
    SetMapFlag(MAP_FOG_ALWAYS_VISIBLE, true);
    
    // 创建物品
    let potion = CreateItem(ItemData.healingPotion.id, 0, 0);
    
    // 注册物品使用事件
    let trigger = CreateTrigger();
    TriggerRegisterAnyUnitEventBJ(trigger, EVENT_PLAYER_UNIT_USE_ITEM);
    TriggerAddAction(trigger, () => {
        let unit = GetTriggerUnit();
        let item = GetManipulatedItem();
        let itemId = GetItemTypeId(item);
        
        // 查找并使用物品效果
        for (let itemKey in ItemData) {
            if (ItemData[itemKey].id === itemId) {
                ItemData[itemKey].effect(unit);
                break;
            }
        }
    });
    
    // 开始游戏
    GameState.startGame();
}

// 技能释放示例
function onSpellCast(): void {
    let caster = GetTriggerUnit();
    let target = GetSpellTargetUnit();
    let spellId = GetSpellAbilityId();
    
    // 火球术
    if (spellId === FourCC('fire')) {
        SpellEffects.fireball.cast(caster, target);
    }
    // 治疗术
    else if (spellId === FourCC('heal')) {
        SpellEffects.heal.cast(caster, target);
    }
}

关键点总结：

对象可以组织相关的数据和功能
对象属性可以存储数据
对象方法可以定义行为
对象可以用于配置管理
对象可以实现模块化设计
对象可以方便地共享数据和功能

#太阳编辑器