Quelltext der Seite RGSS/Tutorials/Rubykurs 2 - OOP Loesungen

==Einstieg==

===Aufgabe 1===

In dieser Aufgabe ist nur eure Fantasie gefragt. Die folgende Tabelle ist nur ein Vorschlag. Eure eigenen Ideen könnten auch völlig anders aussehen. Es geht lediglich darum, dass ihr euch Gedanken macht, was Objekte sind, und das ihr den Zusammenhang zwischen Objekten im Computer und in der wirklichen Welt erkennt.

{| border="1" cellspacing="0" cellpadding="5" style="border-collapse:collapse;"
! colspan="4" bgcolor="#D9E7FF"|Objektbeschreibung
|-width="75"
! Objekt:
|width="200"| Vampires Dawn
|width="200"| Roter Drache
|width="200"| Heiltrank
|-
! Klasse:
|width="200"| Computerspiel
|width="200"| Monster
|width="200"| Item
|-
! Unterobjekte:
|width="200"| Titel, Beschreibung, Charaktere, Hardwarevoraussetzungen, Autor, ... 
|width="200"| Name, Kampfattribute, Skills, Elementarressistenzen, Beschreibung, ...
|width="200"| Name, Beschreibung, Kaufpreis, Heilkraft, ... 
|-
! Methoden:
|width="200"| zeige_review, starte_spiel, installiere_spiel, ...
|width="200"| greife_an, werde_angegriffen, ist_tot?, werde_geheilt, ...
|width="200"| wende_an, werde_gekauft, ist_anwendbar_auf?, werde_verbraucht, ... 
|}

===Aufgabe 2===

Nein, Valnar kann keine Methode verwandlung_in_fledermaus() besitzen. Wir haben zuvor festgestellt, dass Objekte der gleichen Klasse zwar unterschiedliche Teilobjekte haben, dafür aber immer die selben Methoden und Instanzvariablen. Valnar und Grandy besitzen beide einen Namen (=Instanzvariable), aber einen unterschiedlichen (=Unterobjekt bzw. Wert der Instanzvariable). Sie müssen aber beide die selben Methoden besitzen. Wenn Valnar sich also in eine Fledermaus verwandeln könnte, müsste Grandy dies auch. Dieser ist aber ein gewöhnlicher Mensch und kein Vampir.

Eine mögliche Lösung des Problems wäre, beiden eine Instanzvariable Fertigkeiten zu geben. Valnar könnte dann als Fertigkeit Fledermausverwandlung haben, während Grandy dieses Unterobjekt nicht besitzt. In diesem Fall besitzen beide weiterhin dieselben Methoden, aber unterschiedliche Unterobjekte, was ja zwischen zwei verschiedenen Objekten durchaus möglich ist.

Wer für "Ja" gestimmt hat, möge nicht enttäuscht sein. Tatsächlich ist diese Antwort ebenfalls richtig, da es in Ruby Möglichkeiten gibt, dass auch Objekte unterschiedliche Methoden haben. Das gehört aber nicht zum Standard der Klassengesteuerten Objektorientierung, mit der wir uns hier beschäftigen wollen und kommt auch in der RGSS an keiner Stelle vor!

==Klassen und Objekte==

===Aufgabe 1===

Begriffe:
* Inventarobjekt, Questitem, Waffe, Valnars Langschwert, Heilitem, Schwert, Phönixfeder, Rüstung, Drachenlederharnisch, Ausrüstungsobjekt 

Von den Begriffen sind folgende keine Klassen: Valnars Langschwert, Phönixfeder, Drachenlederharnisch. Sicher ist das reine Definitionssache, aber in einem Spiel haben normalerweise z.B. alle Phönixfedern die selben Eigenschaften, so dass es keinen Sinn macht, eine eigene Klasse dafür anzulegen.

Die restlichen Klassen lassen sich in folgende Vererbungshierarchie bringen:

<source lang="ruby">
Objekt -> Inventarobjekt -> Heilitem
                         -> Questitem
                         -> Ausrüstungsobjekt -> Rüstung
                                              -> Waffe  -> Schwert
</source>
Die gemeinsame Superklasse ist natürlich Object, wie es bei allen Objekten der Fall ist. Inventarobjekt erbt von Objekt und beschreibt alle Gegenstände, die man im Inventar tragen kann. Das sind Heilitems, Questitems und Ausrüstungsobjekte, die alle Subklassen von Inventarobjekt sind. Ausrüstungsobjekte kann man noch einmal unterteilen in Rüstungen und Waffen. Eine Subklasse von Waffe ist z.B. die Klasse für alle Schwerter.

===Aufgabe 2===

Unser Würfel ist ziemlich einfach aufgebaut. Er hat keine initialize Methode und keine Variablen. Wichtig ist die Methode rand(n), die eine Zahl von 0 bis n-1 zurückgibt. Ein Würfel hat 6 mögliche Ergebnisse. rand(6) gibt aber eine Zahl von 0 bis 5, statt eine Zahl von 1 bis 6 zurück. Daher müssen wir zu rand(6) noch eine 1 hinzuaddieren.

<source lang="ruby">class Wuerfel
  
  def einmal_werfen()
    rand(6) + 1
  end
  
  #iterative Definition:
  def mehrmals_werfen(n)
    array = []
    while n > 0
      array << einmal_werfen
      n -= 1
    end
    array
  end
  
  # oder die kürzere rekursive Definition:
  def mehrmals_werfen(n)
    if n <= 0 then
      [] # Trivialfall
    else
      mehrmals_werfen(n-1) << einmal_werfen # Rekursionsfall
    end
  end
  
end</source>

===Aufgabe 3===

Beim gezinkten Würfel brauchen wir nur die Methode einmal_werfen() verändern, da die Methode mehrmals_werfen() ja auf einmal_werfen() basiert. Wir fragen diesmal mit rand(2) ab ob der Würfel genauso würfelt wie ein Ungezinkter (in dem Fall wird super aufgerufen, also das Würfelergebnis eines gewöhnlichen Würfels), oder ob eine 6 gewürfelt wird.

<source lang="ruby">class Gezinkter_Wuerfel < Wuerfel
  
  def einmal_werfen()
    if rand(2) == 1 then
      super()
    else
      6
    end
  end
  
end</source>

===Aufgabe 4===

Die letzte Aufgabe ist eher was für Mathematiker. Die Prozentrechnung kennt eigentlich nur eine wichtige Formel: das Ganze / 100 = Ein Teil / Prozentwert
Wobei Prozentwert den prozentualen Anteil des Teils vom Ganzen darstellt.

Zuerst müssen wir in einer Schleife 1000 Mal würfeln und die Ergebnisse in einen Array eintragen. Dabei interessiert uns nur, welcher Würfelwert wie oft gewürfelt wird. Wir haben also einen Array mit 6 Elementen, wobei jedes Element für eine Seite des Würfels steht. Wird diese Seite gewürfelt, erhöht sich der Wert des Elements um 1.

"Das Ganze" ist in unserem Fall die Anzahl aller Würfe. Also 1000. Der Teil ist nun jeweils die Würfelseite. Wir berechnen den Prozentualen Anteil einer Würfelseite an der Gesamtzahl aller Würfel mit der Formel: Prozentwert = Würfe dieser Würfelseite * 100 / Gesamtzahl aller Würfe 
Das machen wir für jede Würfelseite (entweder hartgecodet, also in dem wir für jede Würfelseite diese Formel hinschreiben, oder in einer Schleife. Letzteres ist komplizierter, aber wir müssen dann die Formel nur einmal hinschreiben).

<source lang="ruby">class Wuerfel
  
  def verteilung
    array = [0, 0, 0, 0, 0, 0]
    n = 1000
    while n > 0 do
      zahl = einmal_werfen
      array[zahl-1] += 1
      n -= 1
    end
    gesamt = 1000.0
    n = 0
    while n < 6 do
      array[n] *=  100
      array[n] /= gesamt
      n += 1
    end
    array
  end

end

w1 = Wuerfel.new
w2 = Gezinkter_Wuerfel.new
p w1.verteilung
p w2.verteilung</source>

Beim Endergebnis sollten wir feststellen, dass 1000 Mal würfeln nicht ausreicht, um ein signifikantes Ergebnis zu erhalten. Führen wir die Methode verteilung() mehrmals aus, so kommt jedes Mal ein etwas anderes Ergebnis raus. Erst ab einer Millionen Würfen pendeln sich die Prozentzahlen auf einen festen Wert ein. Allerdings fällt auch so auf: Beim fairen Würfel werden alle 6 Zahlen ungefähr gleich oft geworfen. Beim gezinkten Würfel ist mehr als jeder zweite Wurf eine 6.

==Attribute==

===Aufgabe 1===

Am einfachsten sollten die Klassen Item, Waffe und Trank sein. Hier haben wir nur eine initialize-Methode und die entsprechenden Attribute zu definieren. In der Klasse Item schreiben wir zudem noch eine to_s Methode hinein, damit wir Items in lesbarer Form ausgeben können.
<source lang="ruby">class Item
  attr_reader :name, :preis
  def initialize(name, preis)
    @name = name
    @preis = preis
  end
  def to_s
    @name
  end
end

class Waffe < Item
  attr_reader :schaden
  def initialize(name, preis, schaden)
    super(name, preis)
    @schaden = schaden
  end
end

class Trank < Item
  attr_reader :hp_heilung, :mp_heilung
  def initialize(name, preis, hp, mp)
    super(name, preis)
    @mp_heilung = mp
    @hp_heilung = hp
  end
end</source>

Die Shop-Klasse wird schon wesentlich schwieriger. Beginnen wir mit den einfachen Methoden. initialize ist wie bei den Item-Klassen auch nur eine Zuweisung von Parametern an Instanzvariablen. Außerdem definieren wir noch die Attribute. Die Variable @geld muss dabei sowohl mit einem Lese- als auch Schreibzugriff ausgestattet werden.

Die Methode hat_item?(item) ist auch leicht zu implementieren. Wir nutzen hierfür entweder die Methode Array#include?, welche true zurückgibt, wenn ein Array das gesuchte Element enthält. Oder wir verwenden Array#index. Die Methode gibt nil zurück, wenn der Array das Element nicht enthält, ansonsten die Position des Elements im Array.

Schwierig ist allein die Methode kaufe. Hier fragen wir zuerst ab, ob der Verkäufer überhaupt das Item besitzt und ob der Händler genug Geld hat um es zu bezahlen. Ist dies der Fall, so ziehen wir vom Geld des Händlers den Kaufpreis ab und addieren das Geld zum Vermögen des Verkäufers. Ähnlich verfahren wir mit dem Item. Mit der Methode Array#<< fügen wir das Item in das Inventar des Händlers ein. Das Löschen des Items aus dem Inventar des Verkäufers geht schwieriger. Hier verwenden wir die Methode Array#delete_at, die ein Element an einer bestimmten Position des Arrays löscht. Mit Array#index bestimmen wir die Position des gesuchten Items, um anschließend genau diese Position aus dem Array zu löschen.

Die verkaufe Methode dagegen ist ganz einfach. Wenn Händler A ein Item an Händler B verkauft, ist das nichts anderes als wenn Händler B ein Item von Händler A kauft. Genau so implementieren wir das auch:

<source lang="ruby">class Shop
  attr_accessor :geld
  attr_reader :items
  def initialize(items, geld)
    @items = items
    @geld = geld
  end
  
  def hat_item?(item)
    @items.include?(item)
  end
  
  def kaufe(item, haendler)
    if @geld >= item.preis && haendler.hat_item?(item) then
      @geld -= item.preis
      haendler.geld += item.preis
      @items << item
      haendler.items.delete_at(haendler.items.index(item))
    end
  end
  
  def verkaufe(item, haendler)
    haendler.kaufe(item)
  end
end</source>

Zuletzt fügen wir den Code aus der Übungsaufgabe ein und testen ob die Ergebnisse identisch sind.

===Aufgabe 2===

Das Preis-Leistungs-Verhältnis kann im Grunde genommen mit einer beliebigen Formel ausgerechnet werden. Wir wollen eine möglichst einfache Formel benutzen. Bei einer Waffe ist das Verhältnis gleich Schaden / Preis. Bei einem Trank ist es (HP-Heilung + MP-Heilung) / Preis. Bei einem Item gibt es keine Werte, die man ins Verhältnis stellen könnte. Daher setzen wir dort den Rückgabewert der Methode leistung() einfach auf 0.

<source lang="ruby">class Item
  def leistung
    0
  end
end

class Waffe < Item
  
  def leistung
    @schaden.to_f / @preis
  end
  
end
class Trank < Item
  
  def leistung
    (@hp_heilung + @mp_heilung).to_f / @preis
  end
  
end</source>

Nun muss noch die Methode empfehlung() für den Händler geschrieben werden. Dabei gehen wir in einer Schleife einfach jedes Item durch und schauen, ob es ein besseres Preis-Leistungsverhältnis hat als das beste Item, welches wir bereits gefunden haben.

<source lang="ruby">class Shop
  
  def empfehlung
    n = @items.size - 1
    bestes_item = nil
    beste_leistung = 0
    while n > 0 do
      if beste_leistung < @items[n].leistung then
        beste_leistung = @items[n].leistung
        bestes_item = @items[n]
      end
      n -= 1
    end
    bestes_item
  end
  
end</source>

Wenn wir danach überprüfen, was die besten Items in Angebot der beiden Händler sind, kommen wir auf folgendes Ergebnis: Der Alchemist hat als Empfehlung den Trank Heiltrank, der Schmied die Waffe Lanze.

===Aufgabe 3===

Wir müssen lediglich die Methode kaufe() in den Subklassen Schmied und Alchemist abändern.

<source lang="ruby">class Schmied
  def kaufe(item, haendler)
    if item.kind_of?(Waffe) then
      super(item, haendler)
    end
  end
end

class Alchemist
  def kaufe(item, haendler)
    if item.kind_of?(Trank) then
      super(item, haendler)
    end
  end
end</source>