Logcontrol.plist

Latest.log output

The logcontrol.plist allows one to select the output to the Latest.log

Current logcontrol.plist

/*	This file controls the visibility of various error messages and groups of error messages, or “message classes”. It can be selectively overridden using a separate logcontrol.plist file in your AddOns folder, or a dictionary called “logging-enable” in Oolite’s preferences.

Message classes can be enabled or disabled temporarily using the debug console macros :logOn and :logOff, as in “:logOn $scriptDebugOn”.

Classes which are related, but not hierarchically, can be controlled using metaclasses, whose names start with a $. See $error etc. below for examples.

Log output can be modified using the following preference keys:
               logging-show-class
               logging-show-function
               logging-show-file-and-line
               logging-echo-to-stderr

       “logging-show-class” defaults to YES. The others default to NO.
       “logging-echo-to-stderr” causes log information to be printed to the standard error file in addition to the log file.
*/

{
       /*** Special message classes ***/
       _default			= yes;			// Fallback value for otherwise undefined classes. Must be yes or no.
       // _override		= yes;			// Use to force display of all messages (or suppress all messages). Must be yes or no.


       /*** Metaclasses ***/
       $aiError			= $scriptError;
       $entityState			= no;
       $error				= yes;			// Most errors, ranging from minor to major. Should probably always be enabled.
       $oxpDevelopment                  = no;                   // Warnings useful to OXP writers but not in general play
       $scriptDebugOn			= no;			// This metaclass is set by the debugOn and debugOff script actions.
       $scriptError			= $error;
       $shaderDebugOn			= no;			// Enabled by 's' key while paused, disabled by 'n' while paused.
       $shaderError			= $error;
       $troubleShootingDump		= yes;


       /*** Common programming problems ***/
       general.error				= $error;
       general.error.subclassResponsibility	= inherit;
       general.error.parameterError		= inherit;
       general.error.deprecatedMethod		= inherit;
       general.error.inconsistentState		= inherit;


       exception				= yes;
       exception.backtrace     		= no;


       files.notFound				= $error;	// Failure to load a file.
       files.notLoaded				= $error;	// A file should have been loaded at some earlier point, but wasn’t.


       /*** Module-specific message classes ***/
       ai		= yes;		// AI messages are shown if a ship's reportAIMessages property is set, for instance through the JavaScript console.
       ai.message.receive			= inherit;
       ai.takeAction				= inherit;
       ai.takeAction.noAction			= inherit;
       ai.takeAction.orphaned			= $aiError;
       ai.takeAction.debugMessage		= inherit;
       ai.takeAction.badSelector		= inherit;
       ai.error				= $aiError;
       ai.error.recursion			= inherit;
       ai.error.recursion.stackTrace		= inherit;
       ai.error.stackOverflow			= inherit;
       ai.error.stackOverflow.dump		= inherit;
       ai.setTakeOffFromPlanet.noPlanet	= $aiError;
       ai.suggestEscort			= inherit;
       ai.suggestEscort.refused		= inherit;
       ai.rollD.invalidValue			= $aiError;
       ai.syntax.setCoordinates		= $aiError;
       ai.scanForNearestShipMatchingPredicate.compile.failed 		= $aiError;
       ai.invalidFormat			= $aiError;
       ai.invalidFormat.state			= inherit;
       ai.invalidFormat.handler		= inherit;
       ai.invalidFormat.action			= inherit;
       ai.unpermittedMethod			= $aiError;
       ai.load					= no;
       ai.load.failed.unknownAI		= $aiError;
       ai.invalid.notAStation			= $aiError;		// Warning when station AI message is used on non-station.


       asyncWorkManager.dispatchMethod		= no;


       beacon.list				= $scriptDebugOn;


       character				= yes;
       character.load.unknownSystem		= $error;
	
       $dataCacheStatus						= no;
       $dataCacheError							= $error;
       $dataCacheDebug							= no;
       dataCache.found							= $dataCacheStatus;
       dataCache.upToDate						= $dataCacheStatus;
       dataCache.notFound						= $dataCacheError;
       dataCache.profile						= no;
       dataCache.rebuild						= yes;
       dataCache.rebuild.pathsChanged			= inherit;
       dataCache.rebuild.datesChanged			= inherit;
       dataCache.rebuild.explicitFlush			= inherit;
       dataCache.willWrite						= $dataCacheStatus;
       dataCache.write.success					= $dataCacheStatus;
       dataCache.write.buildPath.failed		= $dataCacheError;
       dataCache.write.failed					= $dataCacheError;
       dataCache.write.serialize.failed		= $dataCacheError;
       dataCache.retrieve.success				= $dataCacheDebug;
       dataCache.retrieve.failed				= $dataCacheDebug;
       dataCache.set.success					= $dataCacheDebug;
       dataCache.set.failed					= $dataCacheError;
       dataCache.remove.success				= $dataCacheDebug;
       dataCache.clear.success					= $dataCacheDebug;
       dataCache.prune							= $dataCacheDebug;

       display.context.create.failed			= $error;
       display.mode.found						= no;
       display.mode.found.failed				= $error;
       display.mode.list						= no;
       display.mode.list.none					= $error;
       display.mode.list.native				= yes;
       display.mode.list.native.failed			= $error;
       display.mode.switch.failed				= $error;
       display.mode.unknown					= $error;
       display.initGL							= no;

       display.macLegacy						= no;	// TEMP

       effectData.load.progress				= no;
       effectData.load.done					= no;

       $linkedListError						= $error;
       entity.behaviour.changed				= $entityState;
       entity.linkedList				= $scriptDebugOn;	// Management/verification of the lists used to track the relative position of entities.
       entity.linkedList.add					= inherit;
       entity.linkedList.add.error				= $linkedListError;
       entity.linkedList.remove				= inherit;
       entity.linkedList.remove.error			= $linkedListError;
       entity.linkedList.verify				= no;	//$linkedListError;	// Non-fatal errors that look scary.
       entity.linkedList.verify.error			= inherit;
       entity.linkedList.verify.rebuild		= inherit;
       entity.linkedList.update.error			= $linkedListError;

       equip.buy.mounted						= no;
       equip.buy.mounted.failed				= $scriptError;

       exit.context					= yes;		// Log why game quit, for debugging cases of game quitting in an orderly yet unexpected way.

       fuelPrices								= no;

       gui.reset								= no;

       input.keyMapping						= no;
       input.keyMapping.codeOutOfRange			= inherit;
       input.keyMapping.keyPress				= no;
       input.keyMapping.keyPress.keyDown		= inherit;
       input.keyMapping.keyPress.keyUp			= inherit;
       input.mouseMode.changed					= no;

       interface.missingCallback				= $scriptError;

       joystick.init							= yes;	// SDL only
       joystick.connect						= yes;	// Rest are Mac only
       joystick.connect.element				= no;
       joystick.remove							= no;
       joystick.reject							= no;	// Lists HID devices that are not considered joysticks.

       material.canonicalForm					= no;	// Extremely verbose logging of normalized material specifier dictionaries.

       mesh.load								= no;
       mesh.load.cached						= inherit;
       mesh.load.uncached						= inherit;
       mesh.load.octree.size					= no;

       mesh.load.error							= $error;
       mesh.load.error.badCacheData			= inherit;

       mesh.load.failed						= $error;
       mesh.load.failed.fileNotFound			= inherit;
       mesh.load.failed.tooManyVertices		= inherit;
       mesh.load.failed.tooManyFaces			= inherit;

       missile.damage.calc						= no; // Debugging of missile damage curves

       oxp.versionMismatch						= $error;

       player.ship								= no;
       player.ship.damage						= no;
       player.equipmentScript					= $scriptDebugOn;

       $plistError								= $error;
       plist.parse.failed						= $plistError;
       plist.wrongType							= $plistError;

       rendering.opengl.error					= no;					// Test for and display OpenGL errors
       rendering.opengl.version				= $troubleShootingDump;	// Display renderer version information at startup
       rendering.opengl.extensions				= $troubleShootingDump;	// List OpenGL extensions at startup
       rendering.opengl.shader					= $troubleShootingDump;
       rendering.opengl.shader.mode			= inherit;
       rendering.opengl.shader.support			= inherit;				// Messages about factors influencing availability of OpenGL shaders
       rendering.opengl.shader.uniform			= $shaderDebugOn;

       rendering.reset							= yes;
       rendering.reset.start					= inherit;
       rendering.reset.end						= no;

       resourceManager.foundFile				= no;					// Tells you where all assets (models, textures, sounds) are found. Very verbose!

       save.failed								= $error;
       save.success							= no;
       quickSave.failed						= $error;
       load.failed								= $error;

       setup.ship.badEntry.subentities			= inherit;

       screenshot								= yes;

       script.addShips.failed					= $scriptError;
       script.missionDescription				= $scriptError;
       script.missionDescription.noMissionText	= inherit;
       script.missionDescription.noMissionKey	= inherit;

       script.debug							= $scriptDebugOn;
       script.debug.message					= inherit;				// debugMessage: script action
       script.debug.onOff						= inherit;				// debugOn/debugOff script actions
       script.debug.setSunNovaIn				= inherit;

       script.debug.note						= inherit;
       script.debug.note.awardCargo			= inherit;
       script.debug.note.removeAllCargo		= inherit;
       script.debug.note.useSpecialCargo		= inherit;
       script.debug.note.addShips				= inherit;
       script.debug.note.set					= inherit;
       script.debug.note.showShipyardModel		= inherit;
       script.debug.note.showShipModel			= inherit;
       script.debug.note.setFuelLeak			= inherit;
       script.debug.note.addPlanet				= inherit;

       script.debug.syntax						= $scriptError;			// Messages relating to script formatting
       script.debug.syntax.badConditional		= inherit;
       script.debug.syntax.badComparison		= inherit;
       script.debug.syntax.action				= inherit;
       script.debug.syntax.action.noneSpecified = inherit;
       script.debug.syntax.action.badSelector	= inherit;
       script.debug.syntax.action.badElement	= inherit;
       script.debug.syntax.scriptCondition.noneSpecified = inherit;
       script.debug.syntax.setPlanetInfo		= inherit;
       script.debug.syntax.awardCargo			= inherit;
       script.debug.syntax.messageShipAIs		= inherit;
       script.debug.syntax.addShips			= inherit;
       script.debug.syntax.set					= inherit;
       script.debug.syntax.reset				= inherit;
       script.debug.syntax.subtract			= inherit;

       script.error							= $scriptError;
       script.error.addPlanet.keyNotFound		= inherit;
       script.error.addPlanet.noPosition		= inherit;
       script.error.exception					= inherit;
       script.error.fallthrough				= inherit;
       script.error.removeAllCargo.notDocked	= inherit;
       script.error.unexpectedOperator			= inherit;

       script.javaScript.load.success			= $scriptDebugOn;
       script.javaScript.load.failed			= $scriptError;
       script.javaScript.init.success			= no;
       script.javaScript.init.error			= $error;				// Fatal start-up error
       script.javaScript.timeLimit				= yes;					// Script ran for too long and has been killed.
       script.javaScript.willLoad				= no;

       script.load								= no;
       script.load.badName						= $scriptError;
       script.load.exception					= $error;
       script.load.notFound					= $scriptError;
       script.load.parseOK						= inherit;
       script.load.unnamed						= $scriptError;
       script.load.world.listAll				= $troubleShootingDump;	// List names and versions of all loaded world scripts at startup.

       // These messages are logged whenever Oolite calls a JS script method or runs a legacy script, respectively.
       $reportScriptEntry						= no;
       script.javaScript.call					= $reportScriptEntry;
       script.legacy.run						= $reportScriptEntry;

       script.legacy.run.badTarget				= $error;

       script.deprecated.scriptActionOnTarget	= $scriptError;			// Warning not to use scriptActionOnTarget:

       script.unpermittedMethod				= $scriptError;

       sdl										= no;
       sdl.init.failed							= $error;
       sdl.init.audio.failed					= $error;

       searchPaths.dumpAll						= $troubleShootingDump;

       $shaderDebug							= $shaderDebugOn;
       $shaderError							= $error;
       shader.load.noShader					= $error;
       shader.uniform							= $shaderDebug;
       shader.uniform.set						= inherit;				// Successfully set a uniform.
       shader.uniform.unSet					= inherit;				// A uniform went unset or was cleared (either because there was no matching uniform in the shader, or the new uniform could not be set up).
       shader.uniform.badDescription			= inherit;				// A uniform specified in shipdata.plist could not be set up, because the configuration could not be understood.
       shader.uniform.bind.failed				= inherit;				// Problem setting up uniform bound to an object property.
       shader.uniform.unpermittedMethod		= $shaderError;

       // Auditing note: these next four are constructed and do not occur as literals.
       shader.compile.failure					= $shaderError;
       shader.compile.validationFailure		= $shaderError;
       shader.link.failure						= $shaderError;
       shader.link.validationFailure			= $shaderError;

       ship.noPrimaryRole						= no;
       ship.escort								= no;
       ship.escort.accept						= inherit;
       ship.escort.reject						= inherit;

       ship.setup.docks              = $oxpDevelopment; // Warnings for old-style virtual docks. Generally harmless in actual play.
       ship.setUp.missiles						= no;					// Warnings when doing extra work to set up missiles without equipment.plist or shipdata.plist entries. Disabled because lots of OXPs trigger them, and there are fallbacks.

       shipData.load.shipyard.unknown			= yes;					// Warning for when shipyard.plist entries do not have matching shipdata.plist entry.
       shipData.load.begin						= yes;
       shipData.load.progress					= no;
       shipData.load.done						= no;
       shipData.load.error						= $error;
       shipData.load.warning					= $error;
       shipData.load.warning.badFlasher		= inherit;
       shipData.load.warning.flasher.badColor	= inherit;
       shipData.load.warning.flasher.badSize	= inherit;
       shipData.load.warning.flasher.badFraction = inherit;
       shipData.load.warning.turret.badFireRate = inherit;
       shipData.load.warning.turret.badWeaponRange = inherit;
       shipData.load.warning.turret.badWeaponEnergy = inherit;
       shipData.translateSubentity				= no;
       shipData.translateSubentity.flasher		= inherit;
       shipData.translateSubentity.standard	= inherit;

       sky.setup								= no;

       $soundError								= $error;
       $soundDebug								= no;
       $soundDebugVerbose						= $soundDebug;
       sound.customSounds						= $soundDebug;
       sound.customSounds.recursion			= $soundError;			// Circular dependency in customsounds.plist, e.g. [foo] = [bar], [bar] = [foo].
       sound.load.success						= $soundDebug;

       // Mac-specific sound messages
       sound.channel.cleanup.success			= $soundDebugVerbose;
       sound.channel.cleanup.failed			= $soundError;
       sound.channel.cleanup.failed.broken		= inherit;
       sound.channel.cleanup.failed.badState	= inherit;
       sound.channel.machPortError				= $soundError;
       sound.initialization.error				= $soundError;
       sound.mixer.outOfChannels				= $soundError;
       sound.mixer.inspector.loadFailed		= $soundError;
       sound.mixer.replacingBrokenChannel		= $soundDebug;
       sound.mixer.failedToConnectChannel		= $soundError;
       sound.music.iTunesIntegration.failed	= $error;
       sound.play.success						= $soundDebugVerbose;
       sound.play.failed						= $soundError;
       sound.play.failed.badReuse				= inherit;
       sound.play.failed.setupFailed			= inherit;
       sound.play.failed.auError				= inherit;
       sound.render.undexpectedNull			= $soundError;
       sound.streaming.refill					= $soundDebugVerbose;
       sound.streaming.loop					= $soundDebug;
       sound.streaming.underflow				= $soundError;
       sound.virtualringbuffer					= $soundError;
       sound.streaming.releaseContext			= $soundDebug;

       // SDL-specific sound messages
       sound.load.failed						= $soundError;	

       $speechDebug							= $soundDebug;
       speech.setup							= $speechDebug;
       speech.synthesis						= $speechDebug;

       startup.progress						= no;					// Startup progress stages.
       loading.complete						= yes;

       station.launchShip.impossible			= no;					// generally cancelled launches due to station having no launch docks are uninteresting	

       strings.conversion						= $scriptError;			// Conversion of text to values (vectors, quaternions etc)
       strings.conversion.vector				= inherit;
       strings.conversion.quaternion			= inherit;
       strings.conversion.vectorAndQuaternion	= inherit;
       strings.conversion.randomSeed			= inherit;

       strings.expand							= $scriptError;			// Errors encountered when converting [key] and %X-type markers in strings.
       strings.expand.invalidData				= inherit;
       strings.expand.invalidJEscape			= inherit;
       strings.expand.invalidJEscape.range		= inherit;
       strings.expand.invalidSelector			= inherit;
       strings.expand.warning					= yes;
       strings.expand.warning.emptyKey			= inherit;
       strings.expand.warning.invalidOverride	= inherit;
       strings.expand.warning.outOfRangeKey	= inherit;
       strings.expand.warning.unbalancedClosingBracket = inherit;
       strings.expand.warning.unbalancedOpeningBracket = inherit;
       strings.expand.warning.unknownExpansion	= inherit;
       strings.expand.warning.unknownPercentEscape = inherit;

       sun.nova								= no;					// Debug messages for nova
       sun.nova.start							= inherit;
       sun.nova.end							= inherit;

       $textureDebug							= no;
       texture.dealloc							= $textureDebug;
       texture.planet.generate					= $textureDebug;
       texture.upload							= $textureDebug;

       texture.generator.queue					= $textureDebug;
       texture.generator.queue.failed			= $error;

       texture.load.asyncLoad					= $textureDebug;
       texture.load.asyncLoad.done				= inherit;
       texture.load.asyncLoad.exception		= $error;
       texture.load.noName						= $error;
       texture.load.rescale					= $textureDebug;
       texture.load.rescale.maxSize			= inherit;
       texture.load.unknownType				= $error;

       texture.reload							= $textureDebug;

       universe.findSystems.badDistance		= $error;

       universe.populate						= no;				// “Populating a system with…” message when generating a star system
       universe.populate.witchspace			= inherit;
       universe.setup.badStation				= $scriptError;		// Message generated if the main station turns out not to be a station (for instance, this could happen if a non-station ship had the role coriolis).
       universe.maxEntitiesDump				= no;				// Dumps all entities when universe is full (Can be quite verbose)

       universe.profile = no;
       universe.profile.update = inherit;
       universe.profile.draw = inherit;

       verifyOXP.verbose						= yes;
}

Examples

• There are examples to be found in the SOTL Altmap and the New Cargoes OXPs

Links

• Latest.log
• Ahruman's creation of the Logcontrol.plist (2007)