Hulp bij overerving C# Unity

[Cynni]

Hallo mensjes,

Ik heb een opdracht voor school dat ik een spel moet maken in unity (ik maak een 2D platformer game).
Ik moet dan een paar klasses laten overerven, maar ik weet niet hoe ik er aan moet beginnen. Ook heb ik al liggen zoeken op Google maar niets dat mij echt verder kon helpen, want ik wat overerving is. Ik kan simpele overervingen maken maar dit is wat moeilijker en ik zou hier graag hulp bij hebben (en dat zou super zijn moest iemand mij kunnen helpen)

Wat ik graag wil is een superklasse met daarin de charactercontrols en dan 2 subklasses die er dan van overerven (player en enemy).
Of eventueel iets anders verzinnen dat ik kan toevoegen aan de game en dit dan weer laten overerven van iets.

Als iemand mij erbij zou kunnen helpen? Ik heb al scripts voor zowel de player als de enemy.
Dit is een link naar de scripts: (ik heb ook de scripts in de bijlage gezet)
https://drive.google.com/file/d/0B1CULRSSRUrHM1puU19VS002aWc/view?usp=sharing


Alvast bedankt
Cynni

 

[wampier]

Wat is de precieze opdracht dan?

Hoewel ik niet weet wat je gaat maken, baart je beschrijving me nu al zorgen. Het feit dat je "player" en "enemy" als grotendeels aparte objecten lijkt te zien en controls af wil handelen in aparte classes lijkt me juist onhandig.

grafische oefeningen zijn erg goed om naar objecten en overerving te kijken, als je goede basisobjecten kiest (ff raar voorbeeld):

<ding_op_scherm>
--<stilstaand_ding_op_scherm>
--<bewegend_ding_op_scherm>
-----<speler_bewegend_ding_op_scherm>
-----<monster_bewegend_ding_op_scherm>

Je loopt snel het gevaar om alles eerst procedureel op te zetten en dan vervolgens je objecten niet meer kloppen. Overigens is het veel moeilijker om voor een klein project een goed objectmodel te doen dan voor een complex project.

 

[Cynni]

Wat is de precieze opdracht dan?

Hoewel ik niet weet wat je gaat maken, baart je beschrijving me nu al zorgen. Het feit dat je "player" en "enemy" als grotendeels aparte objecten lijkt te zien en controls af wil handelen in aparte classes lijkt me juist onhandig.

grafische oefeningen zijn erg goed om naar objecten en overerving te kijken, als je goede basisobjecten kiest (ff raar voorbeeld):

<ding_op_scherm>
--<stilstaand_ding_op_scherm>
--<bewegend_ding_op_scherm>
-----<speler_bewegend_ding_op_scherm>
-----<monster_bewegend_ding_op_scherm>

Je loopt snel het gevaar om alles eerst procedureel op te zetten en dan vervolgens je objecten niet meer kloppen. Overigens is het veel moeilijker om voor een klein project een goed objectmodel te doen dan voor een complex project.

Bedankt voor je antwoord, maar ik snap niet goed wat je bedoelt met ding op scherm en dan bewegend en stilstaand.
Hoe kan ik het beste de controls dan maken? Mijn opdracht is zo dat ik een spel moet maken en er moet minstens 2 klasses overerven van een superklasse, maakt niet uit welke. Ik dacht dan om dan de charactercontrol op een of andere manier te laten overerven?

 

[wampier]

Maar is de charactercontrol anders dan? werkelijk? Als je een project goed opzet moet het geen probleem zijn om inheritance toe te passen, je moet alleen goed kijken waar je anders code zou dupliceren.

Mijn voorbeeld gaat over hoe en waarom je abstractie zou kunnen doen:

<ding_op_scherm> kan functies hebben als: "toon_op_scherm", "zichtbaar/onzichtbaar", bufferopslag, systeemreserveringen, etc. Zeg maar alle dingen die iets wat op het scherm getoond moet worden moet kunnen. Het is niet de bedoeling om het object direct te gebruiken, maar om deze functionaliteit te bieden aan alles wat op het scherm komt.

<stilstaand_ding_op_scherm> (een plaatje, bitmap, stilstaand obstakel, etc.) Is een specifieke implementatie van <ding_op_scherm>. Omdat het een "kind" is, heeft het alle functies en resources die al eerder gemaakt zijn. Een specieke extra functie zou kunnen zijn: "load external resource", maar heeft waarschijnlijk niet zoveel nodig.

<bewegend_ding_op_scherm> heeft behalve een laadfunctie mogelijk ook dingen nodig als bounderies, beweegsnelheid, etc. etc. maar wel ook de originele functies gemaakt in <ding_op_scherm>

Het "kind" moet altijd een toevoeging zijn op dingen van een parent.

 

[Cynni]

Maar is de charactercontrol anders dan? werkelijk? Als je een project goed opzet moet het geen probleem zijn om inheritance toe te passen, je moet alleen goed kijken waar je anders code zou dupliceren.

Mijn voorbeeld gaat over hoe en waarom je abstractie zou kunnen doen:

<ding_op_scherm> kan functies hebben als: "toon_op_scherm", "zichtbaar/onzichtbaar", bufferopslag, systeemreserveringen, etc. Zeg maar alle dingen die iets wat op het scherm getoond moet worden moet kunnen. Het is niet de bedoeling om het object direct te gebruiken, maar om deze functionaliteit te bieden aan alles wat op het scherm komt.

<stilstaand_ding_op_scherm> (een plaatje, bitmap, stilstaand obstakel, etc.) Is een specifieke implementatie van <ding_op_scherm>. Omdat het een "kind" is, heeft het alle functies en resources die al eerder gemaakt zijn. Een specieke extra functie zou kunnen zijn: "load external resource", maar heeft waarschijnlijk niet zoveel nodig.

<bewegend_ding_op_scherm> heeft behalve een laadfunctie mogelijk ook dingen nodig als bounderies, beweegsnelheid, etc. etc. maar wel ook de originele functies gemaakt in <ding_op_scherm>

Het "kind" moet altijd een toevoeging zijn op dingen van een parent.

Ik zie niet veel hetzelfde in de klasses die ik heb. Het is daarom dat ik niet weet wat ik moet veranderen voor het wel te kunnen laten overerven.
Wat ze nu alleen gemeen hebben is dat ze allebei geanimeerd zijn en dat ze een layermask hebben.

 

[Bloodshed]

Misschien dat je hier een idee van krijgt:

Alles dat kan kan vechten kun je een base class voor maken en de basis methode 'Attack' gebruiken. En bij een boss kun je dan er voor zorgen dat als de boss aanvalt dat ook de minions dezelfde persoon aanvallen. (puur voorbeeld)
En een player dat ook kan vechten kun je de private message method geven die andere monsters bijvoorbeeld niet gebruiken.

[CPP]
public abstract class CombatantBase
{
protected CombatantBase(string name)
{
DisplayName = name;
}

public string DisplayName { get; set; }

public virtual void Attack(CombatantBase combatant)
{
//perform attack
Console.WriteLine("{0} attacks {1}", this.DisplayName, combatant.DisplayName);
}
}

public class Monster : CombatantBase
{
public Monster(string name)
: base(name)
{

}
}

public class Boss : CombatantBase
{
public Boss(string name)
: base(name)
{

}

public IEnumerable<Monster> Minions { get; set; }

public override void Attack(CombatantBase combatant)
{
base.Attack(combatant);

foreach (var minion in this.Minions)
{
minion.Attack(combatant);
}
}
}

public class Player : CombatantBase
{
public Player(string name)
: base(name)
{

}

public void PrivateMessage(Player receivingPlayer, string message)
{
//send receivingPlayer a private message
}
}
[/CPP]



[CPP]
namespace ConsoleApplication
{
class Program
{
static void Main(string[] args)
{
var bill = new Player("Bill");

var captain = new Boss("Pirate Captain");

var jim = new Monster("Pirate Jim");
var jack = new Monster("Pirate Jack");

captain.Minions = new List<Monster>()
{
jim,
jack
};

captain.Attack(bill);

Console.ReadLine();
}
}
}[/CPP]