Data types - Revision history

Thrawcheld: /* See also */ fix broken link

2025-01-27T01:19:10Z

Thrawcheld: /* Properties */ (gah!) ARM supports big-endian mode, I meant to write. Also all popular architectures use two's complement since about the 1970s

2025-01-27T00:56:32Z

Properties: (gah!) ARM supports big-endian mode, I meant to write. Also all popular architectures use two's complement since about the 1970s

← Older revision		Revision as of 00:56, 27 January 2025
Line 6:		Line 6:

	=== Signedness ===		=== Signedness ===
	Another property of multi-byte data types is its signedness. Please see the [https://en.wikipedia.org/wiki/Signedness Wikipedia entry]. Data types without a 'u-' prefix are signed, and '''those marked with a 'u-' prefixed are unsigned'''. ~~I'm not certain which type of signedness Factorio uses – perhaps it is machine dependent, but for me, it always appears to be~~ [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].		Another property of multi-byte data types is its signedness. Please see the [https://en.wikipedia.org/wiki/Signedness Wikipedia entry]. Data types without a 'u-' prefix are signed, and '''those marked with a 'u-' prefixed are unsigned'''. Negative numbers are represented by [https://en.wikipedia.org/wiki/Two%27s_complement two's complement], since that representation is used in the processors supported by Factorio.

	=== Space-optimized ===		=== Space-optimized ===

Thrawcheld: /* Properties */ The Mac version of Factorio can run on ARM professors which support big-endurance mics

2025-01-27T00:52:26Z

Properties: The Mac version of Factorio can run on ARM professors which support big-endurance mics

← Older revision		Revision as of 00:52, 27 January 2025
Line 3:		Line 3:
	== Properties ==		== Properties ==
	=== Endianness ===		=== Endianness ===
	All data stored in computers are stored in a single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as its "endianness". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel ~~favored~~ little endian ~~processors in the ancient times~~). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often referred to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].		All data stored in computers are stored in a single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as its "endianness". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel processors are little-endian and Apple Silicon, though it supports big-endian mode, defaults to little-endian). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often referred to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].

	=== Signedness ===		=== Signedness ===
	Another property of multi-byte data types is its signedness. Please see the [https://en.wikipedia.org/wiki/Signedness Wikipedia entry]. Data types without a 'u-' prefix are signed, and '''those marked with a 'u-' prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses – perhaps it is machine dependent, but for me, it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].		Another property of multi-byte data types is its signedness. Please see the [https://en.wikipedia.org/wiki/Signedness Wikipedia entry]. Data types without a 'u-' prefix are signed, and '''those marked with a 'u-' prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses – perhaps it is machine dependent, but for me, it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].

	=== Space ~~Optimized~~ ===		=== Space-optimized ===
	Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is ≥ 255 the value 255 as an [[~~Data_types~~#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases, it saves 3 bytes of space.		Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is ≥ 255 the value 255 as an [[Data types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases, it saves 3 bytes of space.

	== Data Types ==		== Data Types ==

Thrawcheld: /* Endianness */ possessive "its" has no apostrophe

2025-01-26T11:00:31Z

Endianness: possessive "its" has no apostrophe

← Older revision		Revision as of 11:00, 26 January 2025
Line 3:		Line 3:
	== Properties ==		== Properties ==
	=== Endianness ===		=== Endianness ===
	All data stored in computers are stored in a single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as ~~it's~~ "endianness". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often referred to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].		All data stored in computers are stored in a single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as its "endianness". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often referred to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].

	=== Signedness ===		=== Signedness ===

Ickputzdirwech: Removed {{Languages}}

2023-11-12T09:03:21Z

Removed {{Languages}}

← Older revision		Revision as of 09:03, 12 November 2023
Line 1:		Line 1:
	~~{{Languages}} [[Category:Technical]]~~

	This page describes common binary data types used by Factorio, and most modern-day computer applications, internally.		This page describes common binary data types used by Factorio, and most modern-day computer applications, internally.

	== Properties ==		== Properties ==

	=== Endianness ===		=== Endianness ===

	All data stored in computers are stored in a single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as it's "endianness". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often referred to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].		All data stored in computers are stored in a single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as it's "endianness". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often referred to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].

	=== Signedness ===		=== Signedness ===

	Another property of multi-byte data types is its signedness. Please see the [https://en.wikipedia.org/wiki/Signedness Wikipedia entry]. Data types without a 'u-' prefix are signed, and '''those marked with a 'u-' prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses – perhaps it is machine dependent, but for me, it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].		Another property of multi-byte data types is its signedness. Please see the [https://en.wikipedia.org/wiki/Signedness Wikipedia entry]. Data types without a 'u-' prefix are signed, and '''those marked with a 'u-' prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses – perhaps it is machine dependent, but for me, it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].

	=== Space Optimized ===		=== Space Optimized ===

	Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is ≥ 255 the value 255 as an [[Data_types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases, it saves 3 bytes of space.		Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is ≥ 255 the value 255 as an [[Data_types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases, it saves 3 bytes of space.

	== Data Types ==		== Data Types ==

	=== bool ===		=== bool ===

	1 byte value. Considered True if and only if value equals 1, otherwise it is considered False.		1 byte value. Considered True if and only if value equals 1, otherwise it is considered False.

	=== byte ===		=== byte ===

	1 byte long signed integer.		1 byte long signed integer.

	=== unsigned byte ===		=== unsigned byte ===

	1 byte long unsigned integer.		1 byte long unsigned integer.

	=== short ===		=== short ===

	2 byte long signed integer.		2 byte long signed integer.

	=== unsigned short ===		=== unsigned short ===

	2 byte long unsigned integer.		2 byte long unsigned integer.

	=== int ===		=== int ===

	4 byte long signed integer.		4 byte long signed integer.

	=== unsigned int ===		=== unsigned int ===

	4 byte long unsigned integer.		4 byte long unsigned integer.

	=== long ===		=== long ===

	8 byte long signed integer.		8 byte long signed integer.

	=== unsigned long ===		=== unsigned long ===

	8 byte long unsigned integer.		8 byte long unsigned integer.

	=== float ===		=== float ===

	A 4 byte (32 bit) long [https://en.wikipedia.org/wiki/Floating-point_arithmetic floating point number] stored in a special format with two fields - the number's exponent, and it's [https://en.wikipedia.org/wiki/Significand mantissa]. This format is described by the [https://en.wikipedia.org/wiki/Single-precision_floating-point_format 32-bit data type in IEEE 754].		A 4 byte (32 bit) long [https://en.wikipedia.org/wiki/Floating-point_arithmetic floating point number] stored in a special format with two fields - the number's exponent, and it's [https://en.wikipedia.org/wiki/Significand mantissa]. This format is described by the [https://en.wikipedia.org/wiki/Single-precision_floating-point_format 32-bit data type in IEEE 754].

	=== double ===		=== double ===

	An 8 byte (64 bit) long [https://en.wikipedia.org/wiki/Floating-point_arithmetic floating point number] stored in a special format with two fields - the number's exponent, and it's [https://en.wikipedia.org/wiki/Significand mantissa]. This format is described by the [https://en.wikipedia.org/wiki/Double-precision_floating-point_format 64-bit data type in IEEE 754].		An 8 byte (64 bit) long [https://en.wikipedia.org/wiki/Floating-point_arithmetic floating point number] stored in a special format with two fields - the number's exponent, and it's [https://en.wikipedia.org/wiki/Significand mantissa]. This format is described by the [https://en.wikipedia.org/wiki/Double-precision_floating-point_format 64-bit data type in IEEE 754].

	=== string ===		=== string ===

	Strings in Factorio are stored [https://en.wikipedia.org/wiki/String_(computer_science)#Length-prefixed Pascal-style] – they're a variable length data type with two fields: an [[#unsigned int\|unsigned int]] describing how many bytes long the string data is, and then the string data itself.		Strings in Factorio are stored [https://en.wikipedia.org/wiki/String_(computer_science)#Length-prefixed Pascal-style] – they're a variable length data type with two fields: an [[#unsigned int\|unsigned int]] describing how many bytes long the string data is, and then the string data itself.

	=== array ===		=== array ===

	<code>array<element type></code>		<code>array<element type></code>

Line 74:		Line 54:

	=== dict ===		=== dict ===

	<code>dict<key type, value type></code>		<code>dict<key type, value type></code>

Line 82:		Line 61:
	== See also ==		== See also ==
	* [http://lua-api.factorio.com/latest/Builtin-Types.html Factorios Lua API documentation about its builtin types]		* [http://lua-api.factorio.com/latest/Builtin-Types.html Factorios Lua API documentation about its builtin types]

			[[Category:Technical]]

Jlucktay: Some grammar and spelling

2019-06-17T20:08:00Z

Some grammar and spelling

← Older revision		Revision as of 20:08, 17 June 2019
Line 1:		Line 1:
	{{Languages}} [[Category:Technical]]		{{Languages}} [[Category:Technical]]

	This page describes common binary data types used by Factorio, and most modern day computer applications, internally.		This page describes common binary data types used by Factorio, and most modern-day computer applications, internally.

	== Properties ==		== Properties ==
Line 7:		Line 7:
	=== Endianness ===		=== Endianness ===

	All data stored in computers are stored in single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as it's "~~endianess~~". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often ~~refered~~ to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].		All data stored in computers are stored in a single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as it's "endianness". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often referred to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].

	=== Signedness ===		=== Signedness ===

	Another property of multi-byte data types is ~~it's~~ signedness. Please see the [https://en.wikipedia.org/wiki/Signedness ~~wikipedia~~ entry]. Data types without a u- prefix are signed, and '''those marked with a u- prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses – perhaps it is machine ~~dependant~~, but for me it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].		Another property of multi-byte data types is its signedness. Please see the [https://en.wikipedia.org/wiki/Signedness Wikipedia entry]. Data types without a 'u-' prefix are signed, and '''those marked with a 'u-' prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses – perhaps it is machine dependent, but for me, it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].

	=== Space Optimized ===		=== Space Optimized ===

	Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is ≥ 255 the value 255 as an [[Data_types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases it saves 3 bytes of space.		Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is ≥ 255 the value 255 as an [[Data_types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases, it saves 3 bytes of space.

	== Data Types ==		== Data Types ==
Line 21:		Line 21:
	=== bool ===		=== bool ===

	A 1 byte value. Considered True if and only if value equals 1, otherwise it is considered False.		1 byte value. Considered True if and only if value equals 1, otherwise it is considered False.

	=== byte ===		=== byte ===
Line 57:		Line 57:
	=== float ===		=== float ===

	An 4 byte (32 bit) long [https://en.wikipedia.org/wiki/Floating-point_arithmetic floating point number] stored in a special format with two fields - the number's exponent, and it's [https://en.wikipedia.org/wiki/Significand mantissa]. This format is described by the [https://en.wikipedia.org/wiki/Single-precision_floating-point_format 32-bit data type in IEEE 754].		A 4 byte (32 bit) long [https://en.wikipedia.org/wiki/Floating-point_arithmetic floating point number] stored in a special format with two fields - the number's exponent, and it's [https://en.wikipedia.org/wiki/Significand mantissa]. This format is described by the [https://en.wikipedia.org/wiki/Single-precision_floating-point_format 32-bit data type in IEEE 754].

	=== double ===		=== double ===

TomFryers: /* Data Types */ Replaced "iff" with the clearer "if and only if" and n-dashed some hyphens.

2018-04-29T16:22:49Z

Data Types: Replaced "iff" with the clearer "if and only if" and n-dashed some hyphens.

← Older revision		Revision as of 16:22, 29 April 2018
Line 21:		Line 21:
	=== bool ===		=== bool ===

	A 1 byte value. Considered True ~~iff~~ value equals 1, otherwise it is considered False.		A 1 byte value. Considered True if and only if value equals 1, otherwise it is considered False.

	=== byte ===		=== byte ===
Line 65:		Line 65:
	=== string ===		=== string ===

	Strings in Factorio are stored [https://en.wikipedia.org/wiki/String_(computer_science)#Length-prefixed Pascal-style] - they're a variable length data type with two fields: an [[#unsigned int\|unsigned int]] describing how many bytes long the string data is, and then the string data itself.		Strings in Factorio are stored [https://en.wikipedia.org/wiki/String_(computer_science)#Length-prefixed Pascal-style] – they're a variable length data type with two fields: an [[#unsigned int\|unsigned int]] describing how many bytes long the string data is, and then the string data itself.

	=== array ===		=== array ===
Line 78:		Line 78:

	Dictionaries (or "dict"s for short) are like [[#array\|arrays]], but their elements consist of (key, value) pairs that map their key (usually a string, or a number) to their value. Just like [[#array\|arrays]], they're prefixed with an [[#unsigned int\|unsigned int]] describing how many (key, value) pairs are in the dict, followed by that many (key, value) pairs.		Dictionaries (or "dict"s for short) are like [[#array\|arrays]], but their elements consist of (key, value) pairs that map their key (usually a string, or a number) to their value. Just like [[#array\|arrays]], they're prefixed with an [[#unsigned int\|unsigned int]] describing how many (key, value) pairs are in the dict, followed by that many (key, value) pairs.
	Each key should be unique and only appear once. In a few esoteric languages, if a key is provided multiple times then only the last value is used - but in Factorio, assume any dict with multiple identical keys is malformed and error.		Each key should be unique and only appear once. In a few esoteric languages, if a key is provided multiple times then only the last value is used – but in Factorio, assume any dict with multiple identical keys is malformed and error.

	== See also ==		== See also ==
	* [http://lua-api.factorio.com/latest/Builtin-Types.html Factorios Lua API documentation about its builtin types]		* [http://lua-api.factorio.com/latest/Builtin-Types.html Factorios Lua API documentation about its builtin types]

TomFryers: /* Properties */ >=, !! and - changed to ≥, ! and –

2018-04-29T16:21:31Z

Properties: >=, !! and - changed to ≥, ! and –

← Older revision		Revision as of 16:21, 29 April 2018
Line 7:		Line 7:
	=== Endianness ===		=== Endianness ===

	All data stored in computers are stored in single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as it's "endianess". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often refered to as "network"-endian). (Please correct any of this if I'm wrong!!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].		All data stored in computers are stored in single, small unit of data called a "byte". Larger units of data are split into multiple bytes. The order in which sequential bytes are assembled together to form a larger unit of data is referred to as it's "endianess". '''All data saved locally by Factorio is stored in "little"-endian format''' (because Intel favored little endian processors in the ancient times). All data transferred over the network by Factorio is done in "big"-endian format (the standard for network stuffs, so much so that it's often refered to as "network"-endian). (Please correct any of this if I'm wrong!) For more information about endianness, please see the [https://en.wikipedia.org/wiki/Endianness Wikipedia entry].

	=== Signedness ===		=== Signedness ===

	Another property of multi-byte data types is it's signedness. Please see the [https://en.wikipedia.org/wiki/Signedness wikipedia entry]. Data types without a u- prefix are signed, and '''those marked with a u- prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses - perhaps it is machine dependant, but for me it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].		Another property of multi-byte data types is it's signedness. Please see the [https://en.wikipedia.org/wiki/Signedness wikipedia entry]. Data types without a u- prefix are signed, and '''those marked with a u- prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses – perhaps it is machine dependant, but for me it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].

	=== Space Optimized ===		=== Space Optimized ===

	Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is >= 255 the value 255 as an [[Data_types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases it saves 3 bytes of space.		Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is ≥ 255 the value 255 as an [[Data_types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases it saves 3 bytes of space.

	== Data Types ==		== Data Types ==

Rseding91: Added space optimized info.

2018-03-20T20:04:34Z

Added space optimized info.

← Older revision		Revision as of 20:04, 20 March 2018
Line 12:		Line 12:

	Another property of multi-byte data types is it's signedness. Please see the [https://en.wikipedia.org/wiki/Signedness wikipedia entry]. Data types without a u- prefix are signed, and '''those marked with a u- prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses - perhaps it is machine dependant, but for me it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].		Another property of multi-byte data types is it's signedness. Please see the [https://en.wikipedia.org/wiki/Signedness wikipedia entry]. Data types without a u- prefix are signed, and '''those marked with a u- prefixed are unsigned'''. I'm not certain which type of signedness Factorio uses - perhaps it is machine dependant, but for me it always appears to be [https://en.wikipedia.org/wiki/Two%27s_complement two's complement].

			=== Space Optimized ===

			Some integer values are save using a "space optimized" system where instead of always writing out the full multi-byte integer Factorio will check if the integer size is < 255 and if so a single [[Data_types#unsigned byte\|unsigned byte]] is written. If the integer size is >= 255 the value 255 as an [[Data_types#unsigned byte\|unsigned byte]] is written and then the full data type is written. This is mainly used when saving strings, arrays, and dictionaries because their size is almost always < 255 bytes and in those cases it saves 3 bytes of space.

	== Data Types ==		== Data Types ==

Rseding91: Added signed vs unsigned

2018-03-20T19:49:55Z

Added signed vs unsigned

← Older revision		Revision as of 19:49, 20 March 2018
Line 21:		Line 21:
	=== byte ===		=== byte ===

	1 byte long integer.		1 byte long signed integer.

			=== unsigned byte ===

			1 byte long unsigned integer.

	=== short ===		=== short ===

	2 byte long integer.		2 byte long signed integer.

			=== unsigned short ===

			2 byte long unsigned integer.

	=== int ===		=== int ===

	4 byte long integer.		4 byte long signed integer.

			=== unsigned int ===

			4 byte long unsigned integer.

	=== long ===		=== long ===

	8 byte long integer.		8 byte long signed integer.

			=== unsigned long ===

			8 byte long unsigned integer.

	=== float ===		=== float ===
Line 45:		Line 61:
	=== string ===		=== string ===

	Strings in Factorio are stored [https://en.wikipedia.org/wiki/String_(computer_science)#Length-prefixed Pascal-style] - they're a variable length data type with two fields: an [[#int\|int]] describing how many bytes long the string data is, and then the string data itself.		Strings in Factorio are stored [https://en.wikipedia.org/wiki/String_(computer_science)#Length-prefixed Pascal-style] - they're a variable length data type with two fields: an [[#unsigned int\|unsigned int]] describing how many bytes long the string data is, and then the string data itself.

	=== array ===		=== array ===
Line 51:		Line 67:
	<code>array<element type></code>		<code>array<element type></code>

	Arrays are a container type. Like a [[#string\|string]], they're prefixed with an [[#int\|int]] describing how many elements are in the array, followed by that many elements of the specified element type back to back.		Arrays are a container type. Like a [[#string\|string]], they're prefixed with an [[#unsigned int\|unsigned int]] describing how many elements are in the array, followed by that many elements of the specified element type back to back.

	=== dict ===		=== dict ===
Line 57:		Line 73:
	<code>dict<key type, value type></code>		<code>dict<key type, value type></code>

	Dictionaries (or "dict"s for short) are like [[#array\|arrays]], but their elements consist of (key, value) pairs that map their key (usually a string, or a number) to their value. Just like [[#array\|arrays]], they're prefixed with an [[#int\|int]] describing how many (key, value) pairs are in the dict, followed by that many (key, value) pairs.		Dictionaries (or "dict"s for short) are like [[#array\|arrays]], but their elements consist of (key, value) pairs that map their key (usually a string, or a number) to their value. Just like [[#array\|arrays]], they're prefixed with an [[#unsigned int\|unsigned int]] describing how many (key, value) pairs are in the dict, followed by that many (key, value) pairs.
	Each key should be unique and only appear once. In a few esoteric languages, if a key is provided multiple times then only the last value is used - but in Factorio, assume any dict with multiple identical keys is malformed and error.		Each key should be unique and only appear once. In a few esoteric languages, if a key is provided multiple times then only the last value is used - but in Factorio, assume any dict with multiple identical keys is malformed and error.

	== See also ==		== See also ==
	* [http://lua-api.factorio.com/latest/Builtin-Types.html Factorios Lua API documentation about its builtin types]		* [http://lua-api.factorio.com/latest/Builtin-Types.html Factorios Lua API documentation about its builtin types]

← Older revision		Revision as of 01:19, 27 January 2025
Line 60:		Line 60:

	== See also ==		== See also ==
	* [~~http~~://lua-api.factorio.com/latest/~~Builtin-Types~~.html Factorios Lua API documentation about its builtin types]		* [https://lua-api.factorio.com/latest/concepts.html Factorios Lua API documentation about its basic concepts, including builtin types]

	[[Category:Technical]]		[[Category:Technical]]