C# value/reference passing?

Question

I have a declared entity of a class, and want to assign different pre-made templates to it without the templates ever changing. Using a const doesn't seem to do the trick.

Example:

Weapon w1;
w1 = Sword; // premade weapon.
w1.reducedamage(1); // for example a debuff

In this case the premade weapon's damage would be decreased, and it would no longer be available as a template. This problem becomes more profound with enemies.

Example:

Enemy enemy;
enemy = enemies[r] // r being a randomly generated integer and enemies a list of enemy templates
Fight(player,enemy); // this method would resolve a fight between the two entities of the type Character.

This problem would not be visible in the player class, since player is a single reference being passed along all the game methods - because there is only one player. Every time the player fights, an enemy template would be "corrupted".

How would I create templates or classes/structs in general that always pass by value, meaning that the properties of a first class would have the same values as a second, without any relationship between the two classes?

The only success I've gotten with this is to create a method that manually copies each attribute of every class that has a template onto another entity of the same class; but this is extremely unpractical since it needs constant upgrading whenever a new class is added, or an old one changed.

Answer 1

I wrote an answer answering your question directly. But now I see that all you want is to create items that are the same but not linked.

That's what happens anyway when you create an instance. You don’t have to do anything.

If you have:

class Class1
{
    public int i;
}

Then:

Class1 c1 = new Class1() { i = 1 };
Class1 c2 = new Class1() { i = 2 };
Text = c1.i.ToString();

Prints "1", not "2".

And if you mean you want a "Player" class with sub-classes "Friend" and "Foe" - That's what inheritance is for:

class Player
{

}

class Friend : Player
{

}
class Foe : Player
{

}

EDIT:

Perhaps this will make the task easier: (The "Duplicate" method)

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        Class1 c1 = new Class1() { i = 1, j = 2 };
        Class1 c2 = Duplicate(c1);
        c1.i = 3;
        Text = c2.i.ToString();//Prints "1";
    }

    public Class1 Duplicate(Class1 c)//Duplicates all public properties.
    {
        Class1 result = new Class1();
        PropertyInfo[] infos = typeof(Class1).GetProperties();
        foreach (PropertyInfo info in infos)
            info.SetValue(result, info.GetValue(c, null), null);
        return result;
    }
}

public class Class1
{
    public int i { get; set; }
    public int j { get; set; }
}

Answer 2

I must be missing something. This seems like a reasonably simple issue that is easily solved by inheritance, perhaps in conjunction with some sort of Factory. First, you don't want to use a reference to a single instance, you want to create a new instance each time so it is a unique object. I prefer classes over structs, but you could easily create a new struct as well. You could use a Factory to create various pre-configured instances of the objects that have pre-defined values. For example, the Sword of Damocles or the Sword of Destiny.

public static class WeaponFactory
{
       public static Weapon CreateSword(SwordType type)
       {
            var sword = new Sword(); // plain, old default sword

            // override properties based on type
            switch (type)
            {
                case SwordType.SwordOfDamocles:
                    sword.FallTime = GetRandomFutureTime();
                    break;
                case SwordType.SwordOfDestiny:
                    sword.Invincible = true;
                    break;
                ...
            }

            return sword;
        }

        ...
}

Alternative using Actions

public static class WeaponFactory
{
      public static Weapon Create<T>(Action<T> decorator) where T : IWeapon, new()
      {
           var weapon = new T();
           decorator(weapon);
           return weapon;
      }

      public static void SwordOfDamocles(Sword sword)
      {
           sword.FallTime = GetRandomFallTime();
      }

      public static void SwordOfDestiny(Sword sword)
      {
           sword.Invincible = true;
      }
}

var weapon = WeaponFactory.Create(WeaponFactory.SwordOfDamocles);

Answer 3

Contrary to copying objects to implement some kind of "applied object" pattern, it's good to keep in mind it's not the sword "base item" that is being altered, but the item your player is carrying.

For example, a given sword, say "rusty old sword", will always have a base damage of 50. Now if someone applies "old stuff gets better magic" to it, it's not the "rusty old sword" that gets more damage: if some other player that hasn't got that kind of magic picks up the item, it's back to its base damage of 50.

So if you implement some kind of EquippedWeapon (or even EquippedItem) class, you can let your player equip weapons and give it extended properties. Something like this to declare a Sword:

interface IWeapon
{
    int Damage { get; }
}

class Sword : IWeapon
{
    public int Damage { get; private set; }

    public Sword()
    {
        this.Damage = 50;
    }
}

Now we have a sword with a base damage of 50. Now to let the player carry this sword:

interface IDamageModifier
{
    int Damage { get; set; }
}

class EquippedWeapon : IWeapon
{
    public int Damage
    {
        get
        {
            return CalculateActualDamage();
        }
    }

    public List<IDamageModifier> DamageModifiers { get; set; }  
    private IWeapon _baseWeapon = null;

    public EquippedWeapon(IWeapon weapon)
    {
        _baseWeapon = weapon;       
    }

    private int CalulcateActualDamage()
    {
        int baseDamage = _baseWeapon.Damage;

        foreach (var modifier in this.DamageModifiers)
        {
            baseDamage += modifier.Damage;
        }

        return baseDamage;
    }
}

A weapon contains a list of active modifiers, that affect the damage of the carried item, but not the base item. This way you can share one Sword instance with many (non-)playable characters.

Now if the player gets attacked and that attack has a damage effect, you simply apply that to the item(s) the player is carrying, so each successive attack from that player will have those effects applied:

class Player
{
    public EquippedWeapon PrimaryWeapon { get; set; }

    public Player()
    {
        this.PrimaryWeapon = new EquippedWeapon(new Sword());
    }

    public void UnderAttack(Attack attack)
    {
        // TODO: implement

        if (attack.Buffs...)
        {
            this.EquippedWeapon.DamageModifiers.Add(attack.Buffs);
        }
    }
}

Answer 4

you could build a method to return multiple enemies in either a generic collection or array into your enemy class. Something like:

public shared function getEnemies(num as integer, type as string) as list(of clsEnemy) dim enemyGroup as list(of clsEnemy)

for i = 0 to num - 1 dim thisEnemy as new clsEnemy(type) enemyGroup.add(thisEnemy) next

return enemyGroup end function

Answer 5

You could do actual copying (e.g. provide a copy constructor as in http://msdn.microsoft.com/en-us/library/ms173116(v=vs.80).aspx ), but what I've seen most often in such cases is a factory pattern, e.g. Weapon w1 = Weapon.CreateSword(); or Enemy e=Enemy.CreateEnemyOfType(r);

Answer 6

What you want is object cloning. You can implement it via the ICloneable interface[1]. That requires that you implement your own cloning mechanism though--you have to do the heavy lifting.

However, what you probably should do instead is just have the constructor take a parameter that represents the template you want, and then fill the properties of the object in question based on that template. That's the direction I go when I want to make duplicate things with a base set of values.