spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C#-Quelltext

public class FriendlyUnit  {

void Update() {
       checkCommands(); 
       // Sonstiges Unit Gedöhns
}


// wird vom Animator aufgerufen
void attack() {
     currentTarget.SendMessage("receiveDamage", unitDamage);
}

void receiveDamage(int damage) {
     unitHealth -= damage;
}

void checkCommands() {
    switch(unitcurrentCommand) {
         case(Commands.Attack):
       // unit-spezifisches Verhalten
       // ...
    }
    // ...
}

// ...

C#-Quelltext

public class SkillResult : ScriptableObject {
    // enums

    public enum SkillTargetType {
        Unit,
        UnitGroup,
        None
    }

    public enum SkillType {
        Damage,
        Heal,
        Buff,
        Debuff,
        RemoveBuff,
        Other
    }

    public enum SkillAttribute {
        AttackRange,
        AttackSpeed,
        AttackDamage,
        HealthRegeneration,
        ShieldRegenration,
        MovementSpeed,
        VisionRange,
        Health,
        Shield,
        None
    }

    public enum SkillPowerType {
        Absolute,
        Percantage
    }

    // Flags
    public static string flag_recentlyHealed = "RecentlyHealed";

    // Skill Data
    public SkillType skillType = SkillType.Heal;
    public SkillAttribute skillAttribute = SkillAttribute.Health;
    public SkillPowerType skillPowerType = SkillPowerType.Absolute;

    public string skillFlag = "";
    public string skillFlagUnique = "";
    public float skillFlagTimer = 0.0f;

    public float skillPower = 0.0f;
}

C#-Quelltext

public class SkillCalculator : MonoBehaviour {

    public static void passSkillResult(GameObject attacker, GameObject target, SkillResult skillResult) {
        if(target != null) {
            target.SendMessage("OnSkillResult", skillResult, SendMessageOptions.DontRequireReceiver);
        }
        
    }

}

C#-Quelltext

    void OnSkillResult(SkillResult skillresult) {
        if(skillresult.skillType == SkillResult.SkillType.Damage) {
            float removedFromShield = 0;

            if(CurrentShield > 0) {
                removedFromShield = Mathf.Abs(CurrentShield - skillresult.skillPower);
            }

            CurrentHealth = Mathf.Clamp(CurrentHealth - (skillresult.skillPower - removedFromShield), -1.0f, BaseHealth);
        }

        else if(skillresult.skillType == SkillResult.SkillType.Heal) {
            CurrentHealth = Mathf.Clamp(CurrentHealth + skillresult.skillPower, -1.0f, BaseHealth);
        }

        else if(skillresult.skillType == SkillResult.SkillType.Buff) {
            if(skillresult.skillAttribute == SkillResult.SkillAttribute.Shield) {
                BaseShield += skillresult.skillPower;
                CurrentShield = BaseShield;
            }

            if(skillresult.skillAttribute == SkillResult.SkillAttribute.Health) {
                BaseHealth += skillresult.skillPower;
                CurrentHealth = BaseHealth;
            }
        }

        checkDeath();
    } 

C#-Quelltext

public class Skill : MonoBehaviour {

    public int skillType { get; set; } 
    public UnitScript unitScript;
    public UnitGroupScript unitGroupScript;

    public int researchTime { get; set }
    public int costA_research { get; set}
    public int costB_research { get; set }

    public int costA_equip { get; set; }
    public int costB_equip { get; set;}

    public int manaCost { get; set; }
}

C#-Quelltext

public class AutomaticCast : MonoBehaviour {

    public float castCooldown;
    private float nextCast;
    // Use this for initialization
    void Start () {
        nextCast = Time.time + castCooldown;
    }
    
    // Update is called once per frame
    void FixedUpdate () {
        if(Time.time > nextCast) {
            SendMessage("OnFire");
            nextCast = Time.time + castCooldown;
        }
    }
}

C#-Quelltext

public class AreaHeal : MonoBehaviour {
    public Skill skill;

    public float healpower;
    public float healrange;
    
    public float flagCooldown;

    public UnitFaction targetFaction;
    public int numTargets;

    public void Start() {
        skill = GetComponent<Skill>();
    }

    void OnFire() {
        List<UnitScript> targetUnits = new List<UnitScript>();

        // alle möglichen TargetUnits durchgehen. Hier alle Units innerhalb der Gruppenreichweite, etwas länger darum rausgeschnitten

                // das Script regelt seine Regeln selbst: die Einheiten mit geringster Höhe werden bevorzugt
        sortByLowestHealth(ref targetUnits); 
                // Das SkillResult wird erstellt
        SkillResult skillResult = new SkillResult();
        
        skillResult.skillType = SkillResult.SkillType.Heal;
        skillResult.skillPower = healpower;
        skillResult.skillFlag = SkillResult.flag_recentlyHealed;
        skillResult.skillFlagTimer = Time.time + flagCooldown;
                // Und dann 1:1 an die entsprechende Anzahl Targets gesendet
        for(int i = 0; i < numTargets; i++) {
            SkillCalculator.passSkillResult(this.gameObject, targetUnits[i].gameObject, skillResult);
        }
    }

    void sortByLowestHealth(ref List<UnitScript> list) {
            list = list.OrderBy(x=>x.healthScript.CurrentHealth).ToList();
    }
}

C#-Quelltext

[SerializeField]
float irgendeinWert = 0.0f;

// ....

public float irgendeinWert 
    {
        get
        {
            return irgendeinWert;
        }
    }