Hi,
vorweg: Ich entschuldige mich für den miesen Titel, aber mir fiel kein besserer ein.
Meine Klassen sind Teil eines Brettspiels, ähnlich "Risiko".
Jeder Spieler hat verschiedene Einheiten ("Units"), die Einheiten wiederum können verschieden Eigenschaften haben, welche z.B. den Angriff oder die Lebenspunkte beeinflussen.
Eine dieser Eigenschaften heißt "LifeThief". Greift eine Einheit mit dieser Eigenschaft an, wird der Schaden beim Gegner abgezogen und bei den eigenen Lebenspunkten draufgeschlagen.
Bei allen anderen Eigenschaften wird einfach nur berechnet, um wieviel sich durch sie der Schaden verändert und dementsprechend mit dem Gesamtschaden verrechnet.
So viel zur Vorgeschichte.
Mein Problem ist jetzt, dass die beiden geposteten Abschnitte für mich ziemlich dreckig aussehen, zumal in Unit.getAttacked und LifeThief.executeSkill ein Abschnitt fast dasselbe macht.
Hat von euch vielleicht jemand eine Idee, wie man das sauberer umsetzen könnte?
vorweg: Ich entschuldige mich für den miesen Titel, aber mir fiel kein besserer ein.
Meine Klassen sind Teil eines Brettspiels, ähnlich "Risiko".
Jeder Spieler hat verschiedene Einheiten ("Units"), die Einheiten wiederum können verschieden Eigenschaften haben, welche z.B. den Angriff oder die Lebenspunkte beeinflussen.
Eine dieser Eigenschaften heißt "LifeThief". Greift eine Einheit mit dieser Eigenschaft an, wird der Schaden beim Gegner abgezogen und bei den eigenen Lebenspunkten draufgeschlagen.
Bei allen anderen Eigenschaften wird einfach nur berechnet, um wieviel sich durch sie der Schaden verändert und dementsprechend mit dem Gesamtschaden verrechnet.
So viel zur Vorgeschichte.
Mein Problem ist jetzt, dass die beiden geposteten Abschnitte für mich ziemlich dreckig aussehen, zumal in Unit.getAttacked und LifeThief.executeSkill ein Abschnitt fast dasselbe macht.
Hat von euch vielleicht jemand eine Idee, wie man das sauberer umsetzen könnte?
Java:
abstract class Unit{
/**
* Attacks single unit. Consideres armor and skills of both parties.
*
* @param enemy
*/
public void attack(final Unit enemy) {
int damage = this.damage.getPower();
for (Skill skill : this.skills) {
if (skill instanceof StatusSkill) {
damage += skill.executeSkill(this, enemy);
}
}
enemy.getAttacked(damage, this);
}
/**
* Lowers enemy's damage by own protection and skills if possible.
* @param damage
* @param enemy
*/
public void getAttacked(final int damage, final Unit enemy) {
int receivedDamage = damage;
for (Skill ownSkill : this.getSkills()) {
if (ownSkill instanceof StatusSkill) {
receivedDamage += ownSkill.executeSkill(this, enemy);
}
}
receivedDamage -= this.armor.getProtection();
this.lifepoints -= receivedDamage;
if (this.lifepoints <= 0) {
this.isAlive = false;
}
}
}
Java:
/**
* Interface StatusSkill. Represent skills that change enemy's or own status
* values. Effect may occurs during attacks but can't be called explicitly.
*
*/
interface StatusSkill extends Skill{}
/**
* Class LifeThief.
* Adds given damage to own lifepoints.
*
*/
class LifeThief implements StatusSkill{
@Override
public int executeSkill(Unit self, Unit enemy) {
int ownLifepoints = self.getLifepoints();
int damage = self.getDamage().getPower();
for (Skill enemySkill : enemy.getSkills()) {
if (enemySkill instanceof StatusSkill
&& !(enemySkill instanceof LifeThief)) {
damage -= enemySkill.executeSkill(enemy, self);
}
}
damage -= enemy.getArmor().getProtection();
self.setLifepoints(ownLifepoints + damage);
return 0;
}
}
// Nur Beispiel für eine andere Implementierung einer Skill-Klasse
/**
* Class Magic. Ignores enemy's armor on attack.
*
*/
public class Magic implements StatusSkill {
/**
* Enemy's armor is considered in {@link Unit}, this method reverts the
* effect.
*/
@Override
public int executeSkill(final Unit self, final Unit enemy) {
return enemy.getArmor().getProtection();
}
}
Zuletzt bearbeitet: