I just need a place to plonk this stuff for the moment, it really needs to go somewhere else later. -Weaver
This might be useful for debuggery? Also a full list of hardcoded controllers because the states vary per controller. From TSE/TSEShipControllersImpl.h
class CStandardShipAI : public CBaseShipAI
enum StateTypes
{
0 stateAttackingOnPatrol, // Attacking m_pTarget while on patrol
1 stateAttackingTarget, // Attacking m_pTarget
2 stateAttackingThreat, // Attacking m_pTarget to protect principal
3 stateDeterTarget, // Attack m_pTarget, but stop if target doesn't attack back
4 stateDeterTargetNoChase, // Attack m_pTarget, but don't chase it
5 stateEscorting, // Escorting m_pDest
6 stateHolding, // Doing nothing indefinitely
7 stateLookingForLoot, // Looking for loot in the system
8 stateLooting, // Looting stuff from station
9 stateLootingOnce, // Looting stuff from station
10 stateMaintainBearing, // Move in m_rDistance (angle) direction
// until we run into enemies.
11 stateNone, // Ship needs to consult orders
12 stateOnCourseForDocking, // Heading for m_pDest to dock
13 stateOnCourseForStargate, // Heading for m_pDest to gate out
14 stateOnPatrolOrbit, // Orbiting m_pDest at m_rDistance
15 stateReturningFromThreat, // Dock with m_pDest
16 stateWaiting, // Waiting for countdown (m_iCountdown)
17 stateWaitingForThreat, // Waiting for a threat to m_pDest
18 stateWaitingUnarmed, // If threat shows up, we gate out
19 stateWaitForPlayerAtGate, // Waiting for player at gate
20 stateFollowing,
21 stateOnCourseForLootDocking, // Going to dock with loot
22 stateDeterTargetWhileLootDocking, // Attack the target, but continue towards loot
23 stateFollowNavPath, // Follow current nav path
24 stateReturningViaNavPath, // Follow current nav path
25 stateOnCourseForDockingViaNavPath, // Follow current nav path
26 stateOnCourseForPatrolViaNavPath, // Follow current nav path
27 stateOnCourseForPoint, // Going to a given point
28 stateWaitingForTarget, // Waiting for m_pTarget
29 stateWaitingForEnemy, // Waiting for an enemy
30 stateAttackingTargetAndAvoiding, // Attacking m_pTarget and avoiding enemy stations
31 stateAvoidingEnemyStation, // Attacking m_pTarget and avoiding m_pDest
32 stateOnCourseForPointViaNavPath, // Follow current nav path
33 stateBombarding, // Attacking m_pTarget while holding
34 stateApproaching, // Get within m_rDistance of m_pDest
35 stateAimingAtTarget, // Aiming at m_pTarget
36 stateOnCourseForOrbitViaNavPath, // Follow current nav path
37 stateOrbit, // Orbit m_pTarget
38 stateReturningToEscort, // Return to m_pDest from an attack
39 stateHoldingCourse, // Hold course
40 stateAttackingPrincipalThreat, // Attacking m_pTarget, which attacked principal
41 stateTurningTo, // Turning to angle
42 stateAttackingTargetAndHolding, // Attacking m_pTarget while holding position
};
class CAutonAI : public CBaseShipAI
enum StateTypes
{
0 stateNone,
1 stateEscorting,
2 stateAttackingTarget,
3 stateOnCourseForStargate,
4 stateFollowing,
5 stateWaiting,
};
class CFerianShipAI : public CBaseShipAI
enum StateTypes
{
0 stateNone,
1 stateOnCourseForMine,
2 stateMining,
3 stateAttackingThreat,
4 stateOnCourseForStargate,
5 stateAvoidThreat,
6 stateAttackingTarget,
7 stateWaitForPlayerAtGate,
};
class CFleetCommandAI : public CBaseShipAI
enum StateTypes
{
0 stateNone,
1 stateAttackAtWill,
2 stateChargeInFormation,
3 stateFormAtRallyPoint,
4 stateAttackFromRallyPoint,
5 stateOnCourseForStargate,
6 stateWaiting,
7 stateWaitingForThreat,
};
class CFleetShipAI : public CBaseShipAI
enum StateTypes
{
0 stateNone,
1 stateKeepFormation,
2 stateAttackAtWill,
3 stateAttackInFormation,
4 stateAttackTarget,
5 stateOnCourseForStargate, // Heading for m_pDest to gate out
6 stateOnCourseForDocking, // Heading for m_pDest to dock
7 stateWaitForPlayerAtGate,
8 stateOnPatrolOrbit,
9 stateAttackOnPatrol,
10 stateWaiting,
};
class CGaianProcessorAI : public CBaseShipAI
enum StateTypes
{
0 stateNone,
1 stateLookingForWreck,
2 statePulverizingWreck,
3 stateConsumingWreck
};
class CGladiatorAI : public CBaseShipAI
enum StateTypes
{
0 stateNone,
1 stateAttackingTarget,
2 stateOnCourseForDocking,
3 stateOnCourseForStargate,
};
class CZoanthropeAI : public CBaseShipAI
enum StateTypes
{
0 stateNone,
1 stateAttackingThreat,
2 stateOnCourseForStargate,
3 stateReturningFromThreat,
4 stateWaitingForThreat,
5 stateOnPatrolOrbit,
6 stateAttackingOnPatrol,
7 stateOnEscortCourse,
8 stateWaiting,
};
Having nothing to do with scale, but with positioning and travel distance.
From TSE/TSETypes.h
From TSE/CShip.h, I think
From TSE/CSystem.cpp
From TSE/TSETypes.h
I think george may have said this already, but I looked it up in relation to the last exploration anyway
enum FrequencyTypes
{
ftCommon = 20,
ftUncommon = 10,
ftRare = 4,
ftVeryRare = 1,
ftNotRandom = 0
};
I believe this is generally used by the game by creating a list with [rarity] copies of each item, and then rolling against that list.
The map grid is 100 ls per square:
TSE/CSystem.cpp:3216: PaintViewportGrid(Dest, rcView, Trans, CVector(), 100.0 * LIGHT_SECOND);
Shield regen in the xml seems to be based on hp per 6 seconds, but is broken down into different actual periods of no more than 3 seconds via a rather complicated wad of math in CShieldClas.cpp:
// Load regen value
int iRegen;
if (pDesc->FindAttributeInteger(REGEN_ATTRIB, &iRegen))
{
// Regen specified in hp per 180 ticks. We need to convert that to RegenHP and RegenRate
if ((iRegen % 12) == 0)
pShield->m_iRegenRate = 15;
else if ((iRegen % 10) == 0)
pShield->m_iRegenRate = 18;
else if ((iRegen % 9) == 0)
pShield->m_iRegenRate = 20;
else if ((iRegen % 6) == 0)
pShield->m_iRegenRate = 30;
else if ((iRegen % 5) == 0)
pShield->m_iRegenRate = 36;
else if ((iRegen % 4) == 0)
pShield->m_iRegenRate = 45;
else if ((iRegen % 3) == 0)
pShield->m_iRegenRate = 60;
else
pShield->m_iRegenRate = 90;
pShield->m_iRegenHP = iRegen * pShield->m_iRegenRate / 180;
int iDepletion;
if (pDesc->FindAttributeInteger(DEPLETION_DELAY_ATTRIB, &iDepletion))
pShield->m_iDepletionDelay = iDepletion / pShield->m_iRegenRate;
else
pShield->m_iDepletionDelay = 360 / pShield->m_iRegenRate;
}
else
{
pShield->m_iRegenHP = pDesc->GetAttributeInteger(REGEN_HP_ATTRIB);
pShield->m_iRegenRate = (int)((pDesc->GetAttributeInteger(REGEN_TIME_ATTRIB) / STD_SECONDS_PER_UPDATE) + 0.5);
pShield->m_iDepletionDelay = pDesc->GetAttributeInteger(DEPLETION_DELAY_ATTRIB);
if (pShield->m_iRegenRate == 0)
{
pShield->m_iRegenRate = 15;
pShield->m_iRegenHP = 0;
}
}
From TSE/TSEDesign.h … think this is more complete that the data we have in legend?
enum ItemEnhancementTypes
{
etNone = 0x0000,
etBinaryEnhancement = 0x0001,
etLoseEnhancement = 0x0002, // Lose enhancements
etStrengthen = 0x0100, // +hp, data1 = %increase (10% increments)
etRegenerate = 0x0200, // data1 = rate
etReflect = 0x0300, // data2 = damage type reflected
etRepairOnHit = 0x0400, // repair damage on hit, data2 = damage type of hit
etResist = 0x0500, // -damage, data1 = %damage adj
etResistEnergy = 0x0600, // -energy damage, data1 = %damage adj (90%, 80%, etc)
etResistMatter = 0x0700, // -matter damage, data1 = %damage adj (90%, 80%, etc)
etResistByLevel = 0x0800, // -damage, data1 = %damage adj, data2 = damage type
etResistByDamage = 0x0900, // -damage, data1 = %damage adj, data2 = damage type
etResistByDamage2 = 0x0a00, // -damage, data1 = %damage adj, data2 = damage type
etSpecialDamage = 0x0b00, // Immunity to damage effects:
// data2 = 0: immune to radiation
// data2 = 1: immune to blinding
// ... see SpecialDamageTypes
etImmunityIonEffects = 0x0c00, // Immunity to ion effects (blinding, EMP, etc.)
// (if disadvantage, interferes with shields)
etPhotoRegenerate = 0x0d00, // regen near sun
etPhotoRecharge = 0x0e00, // refuel near sun
etPowerEfficiency = 0x0f00, // power usage decrease, 01 = 90%/110%, 02 = 80%/120%
etSpeed = 0x1000, // decrease cycle time
etTurret = 0x1100, // weapon turret, data1 is angle
etMultiShot = 0x1200, // multiple shots, data2 = count, data1 = %weakening
etData1Mask = 0x000f, // 4-bits of data (generally for damage adj)
etData2Mask = 0x00f0, // 4-bits of data (generally for damage type)
etTypeMask = 0x7f00, // Type
etDisadvantage = 0x8000, // If set, this is a disadvantage
};
They're refrenced above, and this contains george's comments on them. TSE/TSEDesign.h
enum DamageTypes
{
damageError = -100, // invalid damage
damageGeneric = -1, // generic damage
damageLaser = 0, // standard lasers
damageKinetic = 1, // mass drivers
damageParticle = 2, // charged particle beam
damageBlast = 3, // chemical explosives
damageIonRadiation = 4, // ionizing radiation
damageThermonuclear = 5, // hydrogen bomb
damagePositron = 6, // anti-matter charged particles
damagePlasma = 7, // fusion weapons
damageAntiMatter = 8, // anti-matter torpedo
damageNano = 9, // nano-machines
damageGravitonBeam = 10, // graviton beam
damageSingularity = 11, // spacetime weapons
damageDarkAcid = 12, // exotics
damageDarkSteel = 13, // exotics
damageDarkLightning = 14, // exotics
damageDarkFire = 15, // exotics
damageCount = 16
};
Wormhole? TSE/TSEDesign.h
enum SpecialDamageTypes
{
specialRadiation = 0,
specialBlinding = 1,
specialEMP = 2,
specialDeviceDamage = 3,
specialDisintegration = 4,
specialMomentum = 5,
specialShieldDisrupt = 6,
specialWMD = 7,
specialMining = 8,
specialDeviceDisrupt= 9,
specialWormhole = 10,
specialFuel = 11,
specialShatter = 12,
// max 15 (because it is used in CItemEnhancement)
};
Oh, RPC must have added this for me, cool. This is from TSE/CSoverign.cpp and TSE/TSEDesign.h … I think. soverign and some header file anyway.
enum DispositionClasses
{
alignNone = -1,
alignConstructiveChaos = 0,
alignConstructiveOrder = 1,
alignNeutral = 2,
alignDestructiveOrder = 3,
alignDestructiveChaos = 4,
};
class CSovereign : public CDesignType
{
public:
enum Alignments
{
alignUnknown = -1,
alignRepublic = 0, // constructive community knowledge evolution (constructive chaos)
alignFederation = 1, // constructive community knowledge tradition (constructive order)
alignUplifter = 2, // constructive community spirituality evolution (constructive chaos)
alignFoundation = 3, // constructive community spirituality tradition (neutral)
alignCompetitor = 4, // constructive independence knowledge evolution (neutral)
alignArchivist = 5, // constructive independence knowledge tradition (constructive order)
alignSeeker = 6, // constructive independence spirituality evolution (constructive chaos)
alignHermit = 7, // constructive independence spirituality tradition (constructive order)
alignCollective = 8, // destructive community knowledge evolution (destructive chaos)
alignEmpire = 9, // destructive community knowledge tradition (destructive order)
alignSterelizer = 10, // destructive community spirituality evolution (destructive chaos)
alignCorrector = 11, // destructive community spirituality tradition (destructive order)
alignMegalomaniac = 12, // destructive independence knowledge evolution (destructive chaos)
alignCryptologue = 13, // destructive independence knowledge tradition (destructive order)
alignPerversion = 14, // destructive independence spirituality evolution (destructive chaos)
alignSolipsist = 15, // destructive independence spirituality tradition (destructive order)
alignUnorganized = 16, // unorganized group of beings (neutral)
alignSubsapient = 17, // animals, zoanthropes, cyberorgs, and other creatures (neutral)
alignCount = 18,
};
enum Disposition
{
dispEnemy = 0,
dispNeutral = 1,
dispFriend = 2,
};
CSovereign (void);
~CSovereign (void);
void DeleteRelationships (void);
inline void FlushEnemyObjectCache (void) { m_pEnemyObjectsSystem = NULL; }
Disposition GetDispositionTowards (CSovereign *pSovereign);
inline const CSpaceObjectList &GetEnemyObjectList (CSystem *pSystem) { InitEnemyObjectList(pSystem); return m_EnemyObjects; }
CString GetText (MessageTypes iMsg);
inline bool IsEnemy (CSovereign *pSovereign) { return (m_bSelfRel || (pSovereign != this)) && (GetDispositionTowards(pSovereign) == dispEnemy); }
inline bool IsFriend (CSovereign *pSovereign) { return (!m_bSelfRel && (pSovereign == this)) || (GetDispositionTowards(pSovereign) == dispFriend); }
static Alignments ParseAlignment (const CString &sAlign);
void SetDispositionTowards (CSovereign *pSovereign, Disposition iDisp);
// CDesignType overrides
static CSovereign *AsType (CDesignType *pType) { return ((pType && pType->GetType() == designSovereign) ? (CSovereign *)pType : NULL); }
virtual bool FindDataField (const CString &sField, CString *retsValue);
virtual DesignTypes GetType (void) { return designSovereign; }
CSovereign::Disposition g_DispositionTable[5][5] =
{
// WE are constructive chaos...
{
CSovereign::dispFriend, // THEY are constructive chaos
CSovereign::dispFriend, // THEY are constructive order
CSovereign::dispNeutral, // THEY are neutral
CSovereign::dispEnemy, // THEY are destructive order
CSovereign::dispEnemy, // THEY are destructive chaos
},
// WE are constructive order...
{
CSovereign::dispNeutral, // THEY are constructive chaos
CSovereign::dispFriend, // THEY are constructive order
CSovereign::dispNeutral, // THEY are neutral
CSovereign::dispEnemy, // THEY are destructive order
CSovereign::dispEnemy, // THEY are destructive chaos
},
// WE are neutral...
{
CSovereign::dispNeutral, // THEY are constructive chaos
CSovereign::dispNeutral, // THEY are constructive order
CSovereign::dispNeutral, // THEY are neutral
CSovereign::dispNeutral, // THEY are destructive order
CSovereign::dispEnemy, // THEY are destructive chaos
},
// WE are destructive order...
{
CSovereign::dispEnemy, // THEY are constructive chaos
CSovereign::dispEnemy, // THEY are constructive order
CSovereign::dispNeutral, // THEY are neutral
CSovereign::dispNeutral, // THEY are destructive order
CSovereign::dispEnemy, // THEY are destructive chaos
},
// WE are destructive chaos...
{
CSovereign::dispEnemy, // THEY are constructive chaos
CSovereign::dispEnemy, // THEY are constructive order
CSovereign::dispEnemy, // THEY are neutral
CSovereign::dispEnemy, // THEY are destructive order
CSovereign::dispEnemy, // THEY are destructive chaos
},
};
const DWORD ALIGN_FLAG_CONSTRUCTIVE = 0x00000001;
const DWORD ALIGN_FLAG_DESTRUCTIVE = 0x00000002;
const DWORD ALIGN_FLAG_COMMUNITY = 0x00000004;
const DWORD ALIGN_FLAG_INDEPENDENCE = 0x00000008;
const DWORD ALIGN_FLAG_KNOWLEDGE = 0x00000010;
const DWORD ALIGN_FLAG_SPIRITUALITY = 0x00000020;
const DWORD ALIGN_FLAG_EVOLUTION = 0x00000040;
const DWORD ALIGN_FLAG_TRADITION = 0x00000080;
struct SAlignData
{
int iNameLen;
char pszName[32];
DispositionClasses iDispClass;
DWORD dwFlags;
};
static SAlignData ALIGN_DATA[CSovereign::alignCount] =
{
{ CONSTDEF("republic"), alignConstructiveChaos, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("federation"), alignConstructiveOrder, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
{ CONSTDEF("uplifter"), alignConstructiveChaos, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("foundation"), alignNeutral, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
{ CONSTDEF("competitor"), alignNeutral, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("archivist"), alignConstructiveOrder, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
{ CONSTDEF("seeker"), alignConstructiveChaos, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("hermit"), alignConstructiveOrder, ALIGN_FLAG_CONSTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
{ CONSTDEF("collective"), alignDestructiveChaos, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("empire"), alignDestructiveOrder, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
{ CONSTDEF("sterilizer"), alignDestructiveChaos, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("corrector"), alignDestructiveOrder, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_COMMUNITY | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
{ CONSTDEF("megalomaniac"), alignDestructiveChaos, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("cryptologue"), alignDestructiveOrder, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_KNOWLEDGE | ALIGN_FLAG_TRADITION },
{ CONSTDEF("perversion"), alignDestructiveChaos, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_EVOLUTION },
{ CONSTDEF("solipsist"), alignDestructiveOrder, ALIGN_FLAG_DESTRUCTIVE | ALIGN_FLAG_INDEPENDENCE | ALIGN_FLAG_SPIRITUALITY | ALIGN_FLAG_TRADITION },
{ CONSTDEF("unorganized"), alignNeutral, 0 },
{ CONSTDEF("subsapient"), alignNeutral, 0 },
};