Schiffsausstattung/-eigenschaften/-Fähigkeiten

[permutator]

Auf Fließkomma zu wechseln halte ich für Problematisch. Einerseits wegen der vervielfachten Rechenzeit, andererseits weil man diese nicht einfach vergleichen kann (ich sehe schwer verfolgbare Bugs).

Auch wenn ich das Performance Argument verstehen denke ich es ist Vernachlässgibar solange man keine extrem großen Flotten hat oder aber den Schiffen mehrere Hundert Beams gibt.

DAMAGE_TO_HULL = 0.1

ist schonmal kein integer. Also sollte,
beamDamage * DAMAGE_TO_HULL,
auch kein integer sein.

Wir können folgendes machen. Wir speichern den Beamschaden für non-piercing Waffen in eine Variable, dann multiplizieren wir alle Beams und die Hülle und Schilde mit 10 (alles bleibt integer und wir haben die 10% vorher gespeichert). Den toHull schaden speichern wir als Eigenschaft des Angreifenden Schiffes.

Kann jemand den Combat Simulator compilen (Windows mit Microsoft Visual Studio)? Und via SVN auf Codeplex ein und Ausschecken? Zum Auschecken braucht man kein passwort. Für den Commit weiss ich es nicht.

EDIT: der Vorgeschlagene Fix mit

toHull = (int)(beamDamage * DAMAGE_TO_HULL);

Wir müssen uns eine Funktion definieren die so aussieht:

int round(double d)
{
return (int)(floor(d + 0.5));
}

Bedeutet das jeder strahl wird gerundet wird. Beams mit Schäden kleiner 5 gehen so nicht auf die Hülle.

[Nobody6]

DAMAGE_TO_HULL = 0.1

ist schonmal kein integer. Also sollte,
beamDamage * DAMAGE_TO_HULL,
auch kein integer sein.

Möglich. Ich hätte erwartet das "direct_to_hull = damage div 10" ist und danach "damage = damage - direct_to_hull". Wobei letzteres dann zuerst von den Schilden und der Rest von der Hülle abgezogen wird.

Die Werte von DAMAGE_TO_HULL aber auch die Multiplikatoren für die Hüllenstärke und Doppelhülle sind übrigens auch Werte in Data-Files besser aufgehoben wären.

P.S.:
DIV bezeichnet in manchen Programmiersprachen eine Integerdivision, in C heißt es aber wahrscheinlich einfach "/".

[HerrderGezeiten]

Wenn du jetzt auf anhieb einen Programmierer findest bin ich neidisch,...

-> Falls ja, schick in gleich rüber zu mir, hab da ein paar "Kleinigkeiten" , Anpassung bei Planeten Bevölkerungszahlen, Karten Erstellung,.... die ich gerne mal testen würde.
Versuche es selber anzupassen sind leider gescheitert, wegen mangelden Wissen,..
(Vielleicht später mal sogar eine Einstellung mit der man entscheiden kann ob es ein Bevölkerungsreiches oder armes Universum ist bzw. Ressourcen reiches/armes Universum erstellt wird. )

Sollte kaum/keine Bugs erzeugen, da es sich nur auf die Planeten Generierung beschränkt. ( so meine Idee zumindest)

[rainer]

diesen Thread überfliege ich meist nur (zuviel Text )...aber vll. kann ich irgendwie helfen (habe etwas zu langsam geschrieben)..

zu Damage_to_Hull: Diese Variable ist in Constant.h fix mit 0.1 (=10%) definiert.

Eine neue Funktion definieren, weiß ich nicht, wie es geht, aber ansonsten kann ich in (meinem lokalen) Code rumpfuschen.

bzw. habe ich gemacht: ich rechne jetzt immer 1 dazu, d.h. Schäden bis 9 ergeben Schaden=1, 10-19 = 2, 100 jetzt 11 anstatt zuvor 10. [EDIT: muß ich noch testen]

Code: Alles auswählen

	// rainer: +1, d.h. Schäden unter 10 gehen nicht unter
	if (m_pTarget->m_pShip->GetHull()->GetAblative() == FALSE)
		toHull = (int)(beamDamage * DAMAGE_TO_HULL +1);

Über http://forum.birth-of-the-empires.de/vi ... 471#p31471 habe ich ja BotE angezapft, um zu sehen, was BotE rechnet...vll. hilft das (nachfolgend Auszug aus meinen -alten- BotE.log's)

Code: Alles auswählen

DEBUG	shipdetails	Ship.cpp: Offensiv: dCloak=1 (1.25=CloakOn, 1.0=NoCloak), dMan=1
DEBUG	shipdetails	Ship.cpp: Offensiv: beamDmg=39, torpedoDmg=264
---------
DEBUG	shipdetails	SHIPINFO.CPP: m_iNeededIndustryWithGetCompleteOffensivePower=415,(CompleteOffensivePower=303)
DEBUG	shipdetails	SHIP.CPP: defence=600, (m_Hull.GetMaxHull()=600)
DEBUG	shipdetails	SHIP.CPP: defence=600 (x 1,3 if Hull=Ablative)
DEBUG	shipdetails	SHIP.CPP: defence=780 (x 1,3 if Hull=Polarisation)
DEBUG	shipdetails	SHIP.CPP: defence=1560 (x 2 -always, because Hull is double to shields)
DEBUG	shipdetails	SHIP.CPP: defence=2060, (MaxShields()=400), Shieldtype=0
DEBUG	shipdetails	Ship.cpp: Defensiv: dCloak=1 (1.25=CloakOn, 1.0=NoCloak), m_byManeuverability=4(-4/10*1.75+1)=->dMan=1
DEBUG	shipdetails	Ship.cpp: Defensiv=2060, dMan=1, dCloak=1
---------
DEBUG	shipdetails	SHIPINFO.CPP: m_iNeededIndustry+dblHull=1445,(CompleteDefensivePower=2060 / 1,5, with NoDblHull /2)
DEBUG	shipdetails	SHIPINFO.CPP: m_iNeededIndustry+Shields=1445,(MaxShields/200*SType, 2.5f), MaxShield=400, pow=0
DEBUG	shipdetails	##### RESULT #####: SHIPINFO.CPP: m_iNeededIndustry/2=722 #####################

Code: Alles auswählen

DEBUG	logships	Ship has Polarisation: multi = 0.1
DEBUG	logships	m_iCurrentHull = 1161, Ship has HULL-Damage = -3
DEBUG	logcombat	CombatShip.cpp: beamDamage= -1.58481e-294
DEBUG	logships	Ship has Polarisation: multi = 0.1
DEBUG	logships	m_iCurrentHull = 1131, Ship has HULL-Damage = -30

Code: Alles auswählen

DEBUG	shipdetails	m_iCurrentHull = 175, Repair = 20

[permutator]

Ich würde am liebsten den Combat Simulator separat tunen. Dann kann die Shiplist.data optimiert werden ohne jedesmal mehrere Runden BotE zu spielen.

Wenn du alles mit 1 addierst würde ein Beam mit Schaden 0 immer mit Schaden eins auf die Hülle gehen, oder?

Ich kann den Combat Simulator code ändern und dir Schicken. Ob's Fehlerfrei compiled weiss ich dann nicht

[HerrderGezeiten]

Was passiert, wenn ein Schiff sagen wir zwischen 1 und 99 Hülle hat und Hüllenpolarisation?
10% Schadensreduzierung sollte ja auch hir gerundet werden auf 0?
Somit wirkungslos für Schiffe unter 100 Hülle?
Eher auch nicht zu erwarten aber rein die Neugier mal von mir.

[permutator]

Was passiert, wenn ein Schiff sagen wir zwischen 1 und 99 Hülle hat und Hüllenpolarisation?
10% Schadensreduzierung sollte ja auch hir gerundet werden auf 0?
Somit wirkungslos für Schiffe unter 100 Hülle?
Eher auch nicht zu erwarten aber rein die Neugier mal von mir.

also im code (Datei Hull.cpp Funktion CHull::SetCurrentHull)
add -= int(add * multi);

add ist der Schaden an der Hülle, mulit=0.1 für Hüllenpolarisation
Bsp: add = 10 -> add*0.1 = 1
Wäre die Hülle 99 dann wird am Ender der Funktion 99-1 also 98 rauskommen.

ABER: add = 9 -> add*0.1 = 0.9
int schneidet hier den Nachkommateil ab, d.h. Wenn weniger als 10 Schadenspunkte durch die Schilde kämen kommt mit Hüllenpolarisation gar nichts durch !!!

[rainer]

CombatSim-Code: immer her damit ... ich probier's einfach

PS: habe nochmal den Code geändert - die "b"-Version von heute ist die aktuelle:

habe (beamDamage * DAMAGE_TO_HULL) nochmal in Klammern gesetzt, und erst dann +1.

Code: Alles auswählen

   // rainer: +1, d.h. Schäden unter 10 gehen nicht unter
   if (m_pTarget->m_pShip->GetHull()->GetAblative() == FALSE)
      toHull = (int)((beamDamage * DAMAGE_TO_HULL) +1);

[rainer]

Die Frage ist, ob wir wirklich hier etwas ändern sollten, weil der Schaden ja überhaupt nicht verloren geht, sondern dann auf die Schilde geht:

Code: Alles auswählen

	// der restliche Beamschaden ermitteln, welcher nicht direkt auf die Hülle ging
	beamDamage -= toHull;

Raumschiffchen, die erfolglos feuern und nicht die Schilde durchdringen...insofern sind unsere Änderungen eigentlich Unsinn , meine ich

[permutator]

toHull = (int)((beamDamage * DAMAGE_TO_HULL) +1);

ersetzen durch:

toHull = (int)((beamDamage * DAMAGE_TO_HULL) +0.5);

dann würde es richtig runden. (int) sollte wie floor wirken ist aber evtl. schneller? Und wir brauchen keinen neue Funktion. Beams unter 5 Schaden wirken dann aber immer noch nicht. Aber es wäre ein Anfang.

[permutator]

Die Frage ist, ob wir wirklich hier etwas ändern sollten, weil der Schaden ja überhaupt nicht verloren geht, sondern dann auf die Schilde geht:

Also bleibt der Gesamtschaden erhalten. Allerdings machen es die 10% Hüllenschaden möglich das Schiffe mit noch aktiven Schilden zerstört werden. Und Schilde können im Kampf regenerieren, oder? Das muss ich noch nachprüfen.

[Darkness]

Nur mal so dazwischengeworfen. Das Problem der Beams, die unter 10dmg keine Schadenspunkte auf der Hülle machen, entstand hauptsächlich aus der Tatsache heraus, das die Schilde viel zu stark regenerieren.
Wenn die Schildreg angepasst wird gibt es keinen Grund dafür das sämtliche Waffen quasi Schilddurchdringende Eigenschaften besitzen (was anderes ist ja der -10% Schaden durch Schilde- Effekt nicht)
Bin mir auch gar nicht sicher ob das tatsächlich ein Rundungsfehler in der Formel ist oder einfach beabsichtigt wurde das es Rassen gibt die halt mehr beamdmg auf die Schilde machen und dafür diese nicht durchdringen (viele schwache beams) und andere, die halt weniger machen dafür aber die Hülle leicht ankratzen (wenige starke beams).

[HerrderGezeiten]

Naja zum Teil hast du da recht, nur falls Schilde wieder mit erhöhten Schildtyp "zuschnell" regenerieren bzw. zuviel Zeit zwischen den Treffern vergeht, sind solche Beams in Schlachtschiffen halt einfach Schrott und das gab es halt leider.
Auch wenn ein Schiff 5-8 Runden mit intakten Schilden durchhält, merkt man schon den Unterschied deutlich bzw. manche platzen schon bei wenig Hülle da einfach Hülle nicht dem Schildwert entspricht. (und es auch nicht sollte)
Meiner Ansicht, sollte das über Hüllenpolarisation gehandhabt werden und nicht durch ein rundungs "Problem".

Ich hätte ja die Beams angepast (Schaden einfach auf über 10/Tick) damit hat sich das Problem "sofort" gelöst und man könnte sogar die "Wirkungslosen" bei einigen Anfangsschiffen Scouts und Jäger Frigaten niederer Techstufe lassen, falls gewollt.

[Vuto]

Könntest bitte auch mal nach der Berechnung der Schildwiederaufladung gucken? Die ist momentan ein noch größeres "Problem"...

Die Regeneration wird in der Shield.cpp berechnet. Nicht von der alten Kommentierung verwirren lassen, die stimmt nicht mit dem Code überein.

Code: Alles auswählen

// Diese Funktion lädt die Schilde entsprechend ihrem Schildtyp wieder auf
void CShield::RechargeShields(int nMulti)
{
	// Die Schilde werden um multi * Schildtyp / 300 + 2*Schildtyp aufgeladen.
	int maxRecharge = m_iMaxShield - m_iCurrentShield;
	//int Recharge = multi * m_iMaxShield / 300 + 2 * m_iShieldType;
	int Recharge = nMulti * (int)(max(m_iMaxShield * 0.001f, 1) * m_iShieldType);
	if (Recharge > maxRecharge)
		Recharge = maxRecharge;
	m_iCurrentShield += Recharge;

Bisher ist die minimale Regeneration also gleich der Schildtyp, das erklärt die Typ 0 Schilde ohne Reg. Maximal werden also: 0,1% MaxSchild * Schildtyp regeneriert. Das sieht gar nicht nach so viel aus, aber es täuscht offenbar.

Falls ihr statt der Formel den Multiplikator ändern wollt, der ist in der Shield.h (auf int achten)

Code: Alles auswählen

/**
	* Diese Funktion lädt die Schilde entsprechend ihrem Schildtyp wieder auf. Der Multiplikator gibt an, mit
	* welcher Zahl der Wert der Aufladung multiplitiert werden soll. Standardmäßig ist hat dieser den Wert EINS.
	*/
	void RechargeShields(int nMulti = 1);

Wie stark wollt ihr die Rate verringern? Ich würde einfach mal 0.001f auf 0.0005f halbieren (oder den Multiplikator) und dann testen, aber ihr habt ja bestimmt schon genauere Vorstellungen.

[HerrderGezeiten]

Genauere Vorstellungen ,.. ja ein bischen.
Bis du dir sicher das es nicht multi *m_iMaxShield / 300 + 2 * m_iShieldType ist?

Ist die Regeneration auf 100Ticks oder pro Tick bezogen?
Kann es sein das es per Tick geht?

Problem ist halt das bei besseren Schiffen beides steigt -> 1% der Schilde sind bei 10.000 schon 100 Schild
Dazu bessere Schild Tech Bsp. 10 wird es recht schnell recht viel.

Bei 0,1% Reg * Schildtyp, mir kommt es so vor als würde das nicht dem ganz entsprechen was ich im Combat Simulator sehe bzw. muß ich wohl mal die Ticks mit der realen Zeit besser vergleichen,...

Zur Zeit laden sich Schiffe mit ~2000 Schilden Typ 3 bei ~30% Schaden auf im Normalfall, bevor eine neue Kampfhandlung stattfindet.
Also gewollte Regeneration sollte zu keiner Zeit mehr als 25% in 100Ticks sein, egal wie groß Schilde oder Schildtyp bis 10.

0,1% * Typ = % von den Max Schilden regeneriert
Würde bedeuten 20*3 =60 , bei 600 Schaden (30%) würde das 10 Runden dauern zu regenerieren was nicht zutrifft,...
Kommt nicht hin, auch nicht mit der Anzeige des Shipeditors.

Problem ist halt das eine geradlinige Formel auch bedeutet das man die Wirkung des Schildtyps eher gering halten sollte.
Vielleicht 1/2 Multiplikator
Ein Schiff mit 1000 Schild und Typ 1 würde fast keine erkennbare Regeneration bedeuten oder man hat bei 10.000 Schilden und Typ 10 einfach gewaltige Werte,..

10fache Schilde und 10 facher Multiplikator = 100fache Regeneration ansonst

Aber versuchen wir es mal -> wenn du genug Geduld hast immer wieder neue Werte einzutragen können wir uns ja da spielen,..