Transcendence Wiki

Documenting the Universe.

User Tools

Site Tools


game:source_diving

1.08b source code .... stuff ...

Random Data Obtained from the C++ Source Code

I just need a place to plonk this stuff for the moment, it really needs to go somewhere else later. -Weaver

AI States 1.08b

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,
        };

Distance

Having nothing to do with scale, but with positioning and travel distance.

From TSE/TSETypes.h

  • Light_Speed = Light_Second = 299792.5 km
  • Klicks_Per_Pixel = 12500.0
  • Therefore 1 light_second = 23.9834 pixels (how did I get 18.3something last time?)

Devices

From TSE/CShip.h, I think

  • Drive devices do replace both maxspeed and thrust, nothing is additive

Encounters

From TSE/CSystem.cpp

  • A system spawns an encounter every 6000 to 9000 ticks
  • There is a 10% chance of just reading from a level-based random encounter list
  • Otherwise a list of all the encounter tables and events attached to objests in the system is collated based on raritys given, and one is picked from that list.

Rarity

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.

System Map Grid

The map grid is 100 ls per square:

TSE/CSystem.cpp:3216: PaintViewportGrid(Dest, rcView, Trans, CVector(), 100.0 * LIGHT_SECOND);

Shield Regen Rates

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;
		}
	}

Enhancment

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
    };

DamageTypes

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
    };

SpecialDamageTypes

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)
    };

Sovereigns and Alignment

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 },
    };
game/source_diving.txt · Last modified: 2014/12/27 04:40 (external edit)