Euer Kampfsys ?

Ich hab zurzeit noch kein Kampfsys und hab auch noch keine Idee da ich nur 2 Werte zur verfügung hab: Die Verteidigung der Einheiten und der Angriff der Einheiten.. also keine Health-Points oda so

koennt ihr ma erklären wie euer kampfsys funktioniert? bin völlig ideenlos zurzeit

Ohne HP stellt sich das natürlich als etwas schwierig heraus, aber spontan würde ich folgendes vorschlagen:

Die HP kannst du aus den Verteidigungspunkten dynamisch berechnen (vielleicht auch noch ein wenig ATK dabei), evtl. 4*[VERT]+ATK = HP oder so. Dann hast du deine HP und kannst ein paar Runden wie in jedem anderen Kampfsystem den Schaden berechnen, bis einer draufgeht...

soll ich für jede einzelne Einheit alles Berechnen oder soll ich zum beispiel alle Speerträger zählen als eine Einheit die dann alle Angriffs und Verteidigungspunkte zusammen kriegt von den einzelnen

there is more than one way to do it...

Kommt auf dein Spiel an.

Geht es dir um große Armeen und nicht um "Persönlichkeit", der Einheiten, kannst du es dir theoretisch sehr einfach machen und einfach Angriffswert der Angreifer gegen Verteidigungswert der Verteidiger aufsummieren und je nach Verhältnis dann eine Seite gewinnen lassen. Entsprechend der Differenz könnten sich die Verluste berechnen oder der Verteidiger verliert alles und er Angreifer gewinnt alles.
Das wären die allereinfachsten Varianten.

Dann gibt es die Möglichkeit zu rundenbasierten Kämpfen, vielleicht sogar mit Taktikoptionen und Interaktionsmöglichkeit während des Kampfes...

Möchtest du es möglich machen, dass deine Einheiten "Charakter" bekommen, also wenn jede Einheit einen eigenen Eintrag in der DB hat, dann solltest du es vielleicht nicht einfach alles aufsummieren, sondern zB immer abwechselnd eine Einheit "schießen" lassen...

Überleg dir einfach ein Konzept, was zu deinem Spiel passt und dir gefällt. Es gibt keine optimale Lösung.

Hinzufügend sollte man noch erwähnen, dass sich die erwähnten "Massenkämpfe" (alles aussummieren) besonders bei größeren Einheitenmengen eignen (wenn der Server bei jedem Kampf die Zukunft von 2000 einzelnen Charakteren berechnen muss hat er eine Menge zu tun). Ab 100 Einheiten würde ich Massenkämpfe bevorzugen...

Eigentlich gibt es bei allen Kampfsystemen die ich kenne, auf irgend eine direkte oder indirkte Weise Healthpoints. Mir fällt momentan keine andere Methode ein, um Verluste zu berechnen. Ob die ein unabhängiger Wert sind oder abhängig von einem allgemeinen verteidigungswert ist dabei zweitrangig.

Sogil, wenn es nur Angriff und Verteidigung gibt und jede Menge Einheiten:

Angreifer gewinnt, wenn er mehr Angriffspunkte hat, als der Verteidiger Verteidigungspunkte.

Verluste des Verteidigers = alles
Verluste des Angreifers = SummeVerteidigungspunkte / SummeAngriffspunkte * Einheitenzahl.

Dann entweder zufällig oder nach Formation oder Stärke der Schiffe die Verluste verteilen, für Verteidigungs- und Angriffspunkte kann man vorher Modifikatoren laufen lassen, die die normalen Werte ein wenig zufälliger oder Strategieangepasster machen.

Im Verlustfall des Angreifers anders herum...

Wäre ein simples Beispiel. ;-)

Wenn du das schon als indirekte Healthpoints siehst, dann gibt es natürlich keinen Weg, außer den totalen Zufall.

Ja, sowas wüde ich schon als indirekte Healthpoints ansehen.

In diesem Fall sind halt Schaden und Healthpoints identisch, und halt bei angriff und verteidigung verschieden. (Wobei ich es allerdings nicht so logisch finde, wenn Eine Einheit bei der verteidigung andere HP als beim Angriff hat.)

Allerdings kann man das noch weiter vereinfachen, wenn man eine Einheit nur noch auf die "Kampfstärke" als einzige Variable reduziert. So ein Kampfsystem hat duchaus nen Vorteil: Es kapiert jeder.

Ich hab des ma rundenbasiert gemacht, wird halt jede runde gewürfelt mit nem sechsseiten würfel (mt_rand(1,6) für alle die nit wissen was gemeint is) und der mit der höheren Zahl macht den ersten Schlag

ihr könnt ja ma bissel rumprobieren und ggf. tipps geben wenn euch was störendes auffällt :-)

cool geiles sscript

wenn niemand gegen keien kämpft ist es ne endlos schleife

ähm
Armee1
Angriff:1665 | Verteidigung:1650 | HP:8265
Armee2
Angriff:1900 | Verteidigung:2580 | HP:12220

Runde 1
Armee 2 greift an und macht Armee 2 1746.5 | verbleibende HP von Armee 1 6518.5
Armee1 greift an und macht Armee2 1623 | verbleibende HP von Armee2 10597

Runde 2
Armee 2 greift an und macht Armee 2 1654.5 | verbleibende HP von Armee 1 4864
Armee1 greift an und macht Armee2 1609 | verbleibende HP von Armee2 8988


greift armee 2 sich selbst an?

Armee1 greift an und macht Armee2 1609
was macht Armme 1 bei Armee 2, sie greifen an und das wars schon, müsste da nicht noch das Word schaden hin so
Armee1 greift an und macht Armee2 1609 schaden


Ich weiß ich sollte eigendlich nichts schreiben, da ich selbst nichts kann. Sind nur Schönheitsfehler.

Die Idee find ich net mal schlecht.

Aber:

1. Warum würfeln? Mach doch nen Zufallswert zwischen 1 und 2, wer anfängt.

2.

Runde 1
Armee1 greift an und macht Armee2 332 | verbleibende HP von Armee2 -332Warum -332?
Armee 2 greift an und macht Armee 2 -17.25 | verbleibende HP von Armee 1 1727.25

Aber die Idee gefällt mir.

Ich stell meins auch bald on, ich muss nur erst ein paar (eigentlich sehr viele) Debug-Ausgaben rausnehmen.

bei zwischenwelt haben wir unser kampfsystem mit aspekten von den beiden angesprochenen methoden gemacht

armee kaempft gegen armee, also geht immer gesamter angriff der armee gegen die gesamte verteidigung

die armeen sind aus einzelnen truppenverbaenden aufgebaut, wo zu jedem typ eine anzahl (in float) angegeben ist. das float wird benutzt um quasi HP's zu simulieren halt immer der naechsten sterbenden einheit

das ganze is noch sehr unfertig also es wird gekämpft bis eine armee nen minus wert erreicht an hp
und mit dem Armee1 greift Armee 1 an
das is noch en fehler
hab was falsch geschrieben
is auch alles bisschen flüchtig gemacht weil ich zurzeit nit dazu komme/kam


--Das ganze is nur en Test-script, sicherheitsvorkehrungen wie Endlosenschleifen-detektor und son krams hab ich nicht eingebaut! wenn ihr mir helfen wollt dann macht feedback zum kampf und nit zum script das da ne endlosschleife drinne is --

Ich hab mir das ganze jetz nochma angeguckt und irgendwie isses total blöd...
Angriff und Verteidung aller Einheiten wird zusammen gezählt und dann als eine Armee berechnet und gekämpft aber wie soll ich dann am ende sagen wieviel von welcher Einheit übriggeblieben is?

und ma angenommen ich lass die einheiten einzeln kämpfen wie soll ichen machen "wer wen angreift" ?

danke im vorraus für hilfe ;-)

Ich denke, dass du da sehr schnell ein Problem mit der Performance haben wirst, da du extrem viele Einzelberechnungen ausführen musst.

Bei mir wird jede einzelne Einheit im Kampf nachsimuliert und kann etwa 2.000.000 Einheiten in einer Sekunde durchsimulieren. Da diese Kämpfe nicht all zu oft vorkommen, finde ich dieses eine akzeptable Zeit.

Gespeichert werden die Schadenspunkte in einer Matrix, bei der die Kampfkraft der einzelnen Einheiten zueinander gespeichert werden. Damit lässt sich ohne großen Aufwand das Stein/Schere/Papier-Prinzip umsetzen.

könnt ihr nichma nen beispiel script posten?
ich hab kein plan wie ich das realisieren soll

Ich hab jetzt auch mahl eins gemacht
http://cossron.command-and-destroy.de/kampfsystem.php
nur das Problem ist, dass ein Fehler kommt wenn jemand keine Einheiten hat.
Was meint ihr dazu, also ich bin stolz auf mich?

Mein (Rollenspiel-)Kampfsystem hat aus Performancegründen den langen Weg von PHP über Java nach C++ gemacht, weil es mit steigenden Spielerzahlen immer zu langsam wurde. Es arbeitet aber auch nicht mit Angriffs- und Verteidigungswerten, sondern bietet dem Charakter Wahl und Wechsel verschiedener Waffen, Zauber, Rüstungen etc. Angriff und Verteidigung werden aus den Eigenschaften des Helden, verrechnet mit Sondergegenständen, Gewichtsbelastung, Effektzaubern und so ermittelt.
Dazu noch die (beliebte) Funktion, die einzelnen Runden in einem Bericht mit auszugeben, da kommt man schon mal auf ne größere Serverbelastung, gerade wenn die wieder mal alle gleichzeitig kämpfen gehen. So komme ich in C++ auf insgesamt 14 Klassen und Unmengen an Code.
Ich kann jedem nur empfehlen, das so einfach wie möglich zu halten - ich hab mir damit viel unnötige Arbeit und schlaflose Nächte gemacht *seufz*

Original von Mays
Ich hab jetzt auch mahl eins gemacht
http://cossron.command-and-destroy.de/kampfsystem.php
nur das Problem ist, dass ein Fehler kommt wenn jemand keine Einheiten hat.
Was meint ihr dazu, also ich bin stolz auf mich?

Ich hab ne gleiche Anzahl von Einheiten aufeinandertreffen lassen:

Resteinheiten:

Type Angreifer Verteidiger
Dieb 455 435
Spion 273 261
Schläger 137 131
Big Mama 273 261
Meuchler 637 618


Und es kommt immer wieder exakt das gleiche raus. Nicht sehr realistisch, oder?

Division by zero...

Mmh ist noch ne Alphaversion oder ?

Wenn ich wüsste wie ich es anders machen könnte hätte ichs gemacht, dabei bin ich eigendlich jemand der es hasst wenn nicht immer das selbe bei raus kommt.


mahl was von vorher

Gespeichert werden die Schadenspunkte in einer Matrix, bei der die Kampfkraft der einzelnen Einheiten zueinander gespeichert werden. Damit lässt sich ohne großen Aufwand das Stein/Schere/Papier-Prinzip umsetzen.


kann mir das mahl jemand erklähren, ich weiß noch nicht mahl richtig was ne Matrix ist

Ich versuche es mal zu erklären:

Eine Matrix ist normalerweise eine zweidimensionale Darstellung von Zahlen in einer Tabelle. (sehr schwache und schlechte Definition). Beispiele findest du bei Wikipedia: http://de.wikipedia.org/wiki/Matrix_(Mathematik)

Mein interessanter Code sieht konkret folgendermaßen aus:

Definition einer Schadenspunkt-Matrix

DamagePoints = new int [ 3, 3 ]
{
{
8, 5, 10 // Attacker: Militiaman
},
{
15, 15, 20 // Attacker: Infanterie
},
{
0, 0, 0 // Attacker: Kleiner Transporter
}
};

Berechnung der Schadenspunkte:

public void GetShoot(IPlayer iPlayer1, IUnitConfiguration iUnit1, IPlayer iPlayer2, IUnitConfiguration iUnit2, IShoot iShootResult)
{
int nUnitID1 = ( ( FightUnit ) iUnit1 ).Unit.UnitType.ID;
int nUnitID2 = ( ( FightUnit ) iUnit2 ).Unit.UnitType.ID;

iShootResult.Damage = UnitType.DamagePoints [ nUnitID1, nUnitID2 ];
}



Evtl konnte ich dir helfen.

Der erste Teil is klar - beim 2. Teil kann man nur aus den Klassennamen nicht wirklich schlau werden. N bisserl was dazu erzählen wär net übel )

hatte gedacht, dass nur das Matrix-Prinzip interessant war ;-)

Das gezeigte Interface ist eine implementierte Interface-Methode, die von der Kampf-Engine bei jedem simulierten Schuss aufgerufen wird, um zu ermitteln, welchen Schaden die Einheit ermittelt hat.

Die Kampfengine macht nichts anderes als die Einheiten aufstellen und gegeneinander schießen lassen. Um den Schaden an der feindlichen Einheit zu ermitteln, werden die zuvor übermittelten Kampfregeln befragt. Damit lassen sich verschiedene Regeln dieses Typs von Kampf (Ogame-Prinzip) mit einer zentralen Engine festlegen.

Eine Implementation der Kampfregeln sieht man oben.

IPlayer iPlayer1 ist der schießende Spieler, IUnitConfiguration iUnit1 der Typ der schießenden Einheit
IPlayer iPlayer2 ist der verteidigende Spieler, IUnitConfiguration iUnit2 der Typ der verteidigenden Einheit
In iShootResult wird das Ergebnis geschrieben. Zusätzlich kann dort noch die Wahrscheinlichkeit eines weiteren Schussen angegeben werden.

using System;

namespace BurnSystems.BGE.Fighting
{
///
/// The rules of the fight.
///
public interface IFightRules
{
///
/// Number of rounds in fight
///
int Rounds
{
get;
}

///
/// Checks, if these player do fight against each other.
/// This method has to be commutative, so DoFight ( i1, i2 )
/// should alway be equal to DoFight ( i2, i1 );
///
/// First Player
/// Second Player
/// true, if these player do fight against eachother, otherwise false
bool DoFight ( IPlayer iPlayer1, IPlayer iPlayer2 );

///
/// Calculates shoot between unit iUnit1 of player iPlayer1
/// against unit iUnit2 of player iPlayer2. The Result of
/// that shoot should be stored in iShootResult and is evaluated
/// equally
///
/// Attacking player
/// Attacking unit
/// Defending player
/// Defending unit
/// Result of that shoot is stored here. This
/// is not a return value because of performance issues
void GetShoot ( IPlayer iPlayer1, IUnitConfiguration iUnit1, IPlayer iPlayer2, IUnitConfiguration iUnit2, IShoot iShootResult );

}


///
/// This interface has to be returned by
/// the shoot calculator implemented by user of this fightengine
///
public interface IShoot
{
///
/// Damage which is done to the unit. The shoot generator
/// writes damage in this field.
///
int Damage
{
get;
set;
}

///
/// Propability from 0.0 to 1.0, if shooting unit can shoot
/// again. 1.0 means that this unit will shoot again
///
double RepeatPropability
{
get;
set;
}
}
}


In IUnitConfiguration ist die ID des Einheitentyps gespeichert. Dieser passt zur oben definierten Matrix.

Um ehrlich zu sein ist das ganze etwas zu hoch für mich, ich versteh zwar jetzt ungefähr was eine Matrix ist, aber mit dem Code kann ich nichts anfangen, ich kann zwar Sachen vermuten, aber das bring eh nichts.

Mahl zu den Einheiten, habt ihr eigendlich eine Tabelle in der DB nur für die Einheiten, wo dann alle Werte von ihnen gespeichert sind? oder sind die Werte nur im Script?

ist eigentlich egal

aber eigendlich ist man doch blöd wenn man es nicht macht, weil die Werte von den Einheiten braucht man meistens an mehreren stellen und nicht nur im Kampfsystem. Wenn sich dann was ändert, braucht man nur in der Tabelle was ändern und nicht überalle wo die Werte stehen.

Du kannst doch mit dem Befehl 'require_once ( "Die Werte deiner Einheiten.php" );' die Kampfwerte aus einer zentralen Datei einladen.

& sparst dir damit datenbank querys

mal ne kleine Frage zwischendurch. Wie löst ihr das wenn 2 Unterschiedliche klassen gegen einander kämpfen ?

Bei uns z.B:

Angreifen
100 Messer + Schläger ( die noch nix zu tun haben außer das Messer halten ^^ )

Verteidiger
1 Springfield + Schläger ( "" )

Bei uns sehen sie die einheiten atm noch garnicht weil ich keine idee hab wie ich das lösen soll.

Unser aktuelles ( welches am Wochenende ausgetauscht wird ) läuft nach dem Pinzip:

Angriffswerte / Deffwerte * Angreifende Einheiten = Globalverlust
Der Globalverlust wird jetzt von allen Angreifenden Einheiten abgezogen.

Vorteil

Einfach

Nachteile

Ein Verlust für alle Einheiten

Unausgewogen Waffenklassen übergreifen

Das Neue KS läuft derzeit nach einem Hier genannten Prinzip:

Angreifer gewinnt, wenn er mehr Angriffspunkte hat, als der Verteidiger Verteidigungspunkte.
Verluste des Verteidigers = alles
Verluste des Angreifers = SummeVerteidigungspunkte / SummeAngriffspunkte * Einheitenzahl.
Sonnst andersrum


Sind halt noch nen paar rand() drin damit das nicht ganz monoton immer gleich ist. So verliert der Verteidiger nicht zwingen alles. Hierbei dachte ich mir das ganze in Waffenklassen aufzuteilen ( Nahkampf / Schusswaffen [ Fernkampf ] ) und zusätzlich Munition.

Vorteil

Unterschiedliche Verluste

(Monotone + Züfällige) Kämpfe

Nachteile

Nur gleiche Waffen kämpfen gegeneinander

Bei unterschiedlichen Waffen keine Verluste

Irgendwer ne idee wie die Nachteile im "Neuen" KS zu ändern ?

Crasher

Ein neuer Versuch,
http://cossron.command-and-destroy.de/kampfsystem3.php

diesmal lass ich jede Einheit einzeln kämpfen, also die angreifenden Einheiten haben eine Wahrscheinlichkeit von 60%, die Verteidigten 65%, das sie Schaden machen.
Ich lass duch eine Schleife jede Einheit laufen, der Angriffs und Verteidigungswert wird wieder zusammen gezählt, nur am ende kommt fast das Gleiche raus, das versteh ich nicht.
Irgendwo denke ich falsch, sind die Wahrscheinlichkeitswerte zu hoch?

Angreiferangriffspunkte 14
Angreiferenergiepunkte 0
Verteidigerverteidigungspunkte 78
Verteidigerenergiepunkte 0


Angreifer greift mit 14 Angriffspunkte an. Verteidiger hat noch 0 Engeriepunkte
Verteiger schlägt mit 78 zurück. Der Angreifer hat noch 0 Energiepunkte

Warning: Division by zero in /home/c/command-and-destroy.de/public_html/subdomains/cossron/kampfsystem3.php on line 170

Warning: Division by zero in /home/c/command-and-destroy.de/public_html/subdomains/cossron/kampfsystem3.php on line 174
Angreifer hat 100 Prozent von jedem seiner Einheitentypen verloren
Verteidiger hat 100 Prozent von jedem seiner Einheittypen verloren

Das zeigt er an wenn ich keine Werte angebe...
Und er will irgendetwas durch null dividieren,
was natürlich nicht geht mit PHP.

Also mein Kampfsystem ist anderes den meine einheiten haben gerademal 1 wert.

Das ist die Waffen klasse von 1 bis 7.
So bei einen angriff werden erstmal durch zufall geschaut welche einheiten kämpfen also ob ein Soldat mit der klasse 4 gegen ein 5 oder 3 gegen 2 ist halt zufall.
dann nochmal radom von 1 bis 14.
wen der "würfel" 1 bis 7 anzeigt so hat der verteidiger gewonen
und 8 bis 14 so der angreifer.
Doch vorher werden die waffenklassen bei Verteidiger dazu addiert und dann wieder minus gerechnet vom angreifer.
Also wen dann der Verteidiger einen Soldaten hat der die Waffenklasse 4 hat und der Angreifer 5 so hat der Verteidiger beim Radom von 1 bis 6 gewonnen und der angreifer bei 7 bis 14

Hoffe ihr habts verstanden

Sind das Massenkämpfe oder einzelne Einheiten? Für Massenkämpfe ist das mehr als unfair.