Commit ae350e8460e54614332b3470ee7790f3008359fc - surgescript

+12

-0

.github/FUNDING.yml less more

	0	# These are supported funding model platforms
	1
	2	github: alemart # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
	3	patreon: # Replace with a single Patreon username
	4	open_collective: # Replace with a single Open Collective username
	5	ko_fi: # Replace with a single Ko-fi username
	6	tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
	7	community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
	8	liberapay: # Replace with a single Liberapay username
	9	issuehunt: # Replace with a single IssueHunt username
	10	otechie: # Replace with a single Otechie username
	11	custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

+6

-8

.gitignore less more

7	7	!.vscode/tasks.json
8	8	!.vscode/launch.json
9	9	!.vscode/extensions.json
	10
	11	# msvc
	12	.vs/
	13	out/
	14	CMakeSettings.json
10	15
11	16	# vim
12	17	# swap

21	26	*~
22	27
23	28	# mine
24		surgescript
25		*.a
26		*.so
27		.so.
28		*.dll
29		*.exe
30		*.pc
31		site/
	29	docs_html/
32	30	build/
33	31	private/
34	32	CMakeFiles/

+16

-0

CHANGES.md less more

0	0	# Release Notes
	1
	2	## 0.5.6 - September 1st, 2022
	3
	4	* Improved the SurgeScript CLI with a time limit option, the ability to run scripts from stdin and optional multithreading support
	5	* Added Visual Studio support (Cody Licorish)
	6	* Added Emscripten support
	7	* Updated docs
	8	* General improvements
	9
	10	## 0.5.5 - January 22nd, 2021
	11
	12	* Added the ability to pause the SurgeScript VM
	13	* Added utility macros for checking the SurgeScript version at compile time
	14	* Introduced a dedicated module for keeping track of time
	15	* Renamed Object.childCount to Object.__childCount
	16	* Updated docs
1	17
2	18	## 0.5.4.4 - April 16th, 2020
3	19

+73

-44

CMakeLists.txt less more

0	0	# ------------------------------------------------------------------------------
1	1	# SurgeScript
2	2	# A scripting language for games
3		# Copyright 2016-2020 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	# Copyright 2016-2022 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	# ------------------------------------------------------------------------------
5	5
6	6	# Project info
7	7	cmake_minimum_required(VERSION 3.2)
8	8	project(
9	9	surgescript
10		VERSION 0.5.4.4
	10	VERSION 0.5.6
11	11	LANGUAGES C
12	12	)
	13	include(GNUInstallDirs)
	14	include(CheckLibraryExists)
	15	set(PROJECT_YEARS "2016-2022")
13	16
14	17	# Default config
15		set(CMAKE_C_STANDARD 99)
	18	set(CMAKE_C_STANDARD 11)
16	19	if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
17	20	set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build: Debug \| Release \| MinSizeRel \| RelWithDebInfo" FORCE)
18	21	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
19	22	endif()
20		if(UNIX AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
21		set(CMAKE_INSTALL_PREFIX "/usr" CACHE PATH "Install path prefix (prepended onto install directories)" FORCE)
22		endif()
23	23
24	24	# User options
25	25	option(WANT_SHARED "Build SurgeScript as a shared library" ON)
26	26	option(WANT_STATIC "Build SurgeScript as a static library" ON)
27		option(WANT_EXECUTABLE "Build the surgescript executable" ON)
28		set(LIB_SUFFIX "" CACHE STRING "Suffix to append to 'lib' directories, e.g., '64'") # libs must be installed to "lib64" in some systems
29		set(PKGCONFIG_PATH "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/pkgconfig" CACHE PATH "Destination folder of the pkg-config (.pc) file")
	27	option(WANT_EXECUTABLE "Build the SurgeScript CLI" ON)
	28	option(WANT_EXECUTABLE_MULTITHREAD "Enable multithreading on the SurgeScript CLI" ON)
	29	set(PKGCONFIG_PATH "pkgconfig" CACHE PATH "Destination folder of the pkg-config (.pc) file")
30	30	if(UNIX)
31		set(METAINFO_PATH "/usr/share/metainfo" CACHE PATH "Destination folder of the metainfo file")
32		set(ICON_PATH "/usr/share/pixmaps" CACHE PATH "Destination folder of the icon file")
33		file(TO_CMAKE_PATH "${ICON_PATH}/surgescript.png" ICON_FILEPATH)
34		endif()
35
36		# Output folder
37		set(CMAKE_BINARY_DIR ${CMAKE_SOURCE_DIR})
38		set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR})
39		set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR})
	31	set(METAINFO_PATH "metainfo" CACHE PATH "Destination folder of the metainfo file")
	32	set(ICON_PATH "pixmaps" CACHE PATH "Destination folder of the icon file")
	33	endif()
	34
	35	# Library search
	36	CHECK_LIBRARY_EXISTS(m sqrt "${CMAKE_SYSTEM_LIBRARY_PATH}" SURGESCRIPT_libm_EXISTS)
40	37
41	38	# Sources
42	39	set(

74	71	src/surgescript/runtime/tag_system.c
75	72	src/surgescript/runtime/variable.c
76	73	src/surgescript/runtime/vm.c
	74	src/surgescript/runtime/vm_time.c
77	75	src/surgescript/util/transform.c
78	76	src/surgescript/util/utf8.c
79	77	src/surgescript/util/util.c
80	78	src/surgescript/util/xoroshiro128plus.c
81		${CMAKE_CURRENT_BINARY_DIR}/info.c
	79	${CMAKE_BINARY_DIR}/src/surgescript/misc/info.c
82	80	)
83	81
84	82	# Headers

102	100	src/surgescript/runtime/tag_system.h
103	101	src/surgescript/runtime/variable.h
104	102	src/surgescript/runtime/vm.h
	103	src/surgescript/runtime/vm_time.h
105	104	src/surgescript/util/fasthash.h
106	105	src/surgescript/util/ssarray.h
107	106	src/surgescript/util/transform.h

111	110	src/surgescript.h
112	111	)
113	112
	113	# Output folder
	114	set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR})
	115
114	116	# Generate files from templates
115	117	function(generate_file TEMPLATE)
116		configure_file(src/surgescript/misc/${TEMPLATE}.in ${TEMPLATE} @ONLY)
	118	configure_file(src/surgescript/${TEMPLATE}.in "${CMAKE_BINARY_DIR}/src/surgescript/${TEMPLATE}" @ONLY)
117	119	endfunction()
118	120
119	121	function(generate_pc_file LINKAGE)

122	124	set(LIB_LINKAGE "-static")
123	125	endif()
124	126	configure_file(src/surgescript/misc/surgescript.pc.in "${LIBRARY_OUTPUT_PATH}/surgescript${LIB_LINKAGE}.pc" @ONLY)
125		install(FILES "${LIBRARY_OUTPUT_PATH}/surgescript${LIB_LINKAGE}.pc" DESTINATION "${PKGCONFIG_PATH}")
	127	install(FILES "${LIBRARY_OUTPUT_PATH}/surgescript${LIB_LINKAGE}.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/${PKGCONFIG_PATH}")
126	128	endfunction()
127	129
128		generate_file("info.c")
129
130
131		# Library
	130	generate_file("misc/info.c")
	131	generate_file("util/version.h")
	132
	133	# Build the library
132	134	if(NOT WANT_SHARED AND NOT WANT_STATIC)
133	135	message(FATAL_ERROR "Options WANT_SHARED and WANT_STATIC are both set to OFF. Nothing to do.")
134	136	endif()
135	137
136	138	if(WANT_SHARED)
	139	set(LIB_SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}") # x.y.z: backwards compatibility
137	140	message(STATUS "Will build libsurgescript")
138	141	generate_pc_file("shared")
139	142	add_library(surgescript SHARED ${SURGESCRIPT_SOURCES} ${SURGESCRIPT_HEADERS})
140		target_link_libraries(surgescript m)
141		set_target_properties(surgescript PROPERTIES VERSION ${PROJECT_VERSION})
142		install(TARGETS surgescript DESTINATION "lib${LIB_SUFFIX}")
	143	if (SURGESCRIPT_libm_EXISTS)
	144	target_link_libraries(surgescript m)
	145	endif()
	146	set_target_properties(surgescript PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${LIB_SOVERSION})
	147	install(TARGETS surgescript DESTINATION "${CMAKE_INSTALL_LIBDIR}")
143	148	endif()
144	149
145	150	if(WANT_STATIC)
146	151	message(STATUS "Will build libsurgescript-static")
147	152	generate_pc_file("static")
148	153	add_library(surgescript-static STATIC ${SURGESCRIPT_SOURCES} ${SURGESCRIPT_HEADERS})
149		target_link_libraries(surgescript-static m)
	154	if (SURGESCRIPT_libm_EXISTS)
	155	target_link_libraries(surgescript-static m)
	156	endif ()
150	157	set_target_properties(surgescript-static PROPERTIES VERSION ${PROJECT_VERSION})
151		install(TARGETS surgescript-static DESTINATION "lib${LIB_SUFFIX}")
152		endif()
153
154		install(DIRECTORY src/ DESTINATION include FILES_MATCHING PATTERN "*.h") # installing the headers
155
156		# Executable
	158	install(TARGETS surgescript-static DESTINATION "${CMAKE_INSTALL_LIBDIR}")
	159	endif()
	160
	161	# Install headers
	162	install(DIRECTORY src/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" FILES_MATCHING PATTERN "*.h")
	163	install(DIRECTORY "${CMAKE_BINARY_DIR}/src/" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" FILES_MATCHING PATTERN "*.h")
	164
	165	# Build the SurgeScript CLI
157	166	if(WANT_EXECUTABLE)
	167	message(STATUS "Will build the SurgeScript CLI")
	168
158	169	# Set the appropriate lib
159	170	set(LIBSURGESCRIPT "surgescript")
160	171	if(WANT_STATIC AND (NOT WANT_SHARED OR WIN32))
161	172	set(LIBSURGESCRIPT "surgescript-static")
162	173	endif()
163	174
	175	# Use multithreading?
	176	set(LIBTHREAD "")
	177	set(ENABLE_THREADS 0)
	178	if(WANT_EXECUTABLE_MULTITHREAD)
	179	message(STATUS "Will use multithreading on the SurgeScript CLI")
	180
	181	# hmmmm...
	182	set(LIBTHREAD "pthread")
	183	set(ENABLE_THREADS 1)
	184	endif()
	185
164	186	# Create the executable
165		message(STATUS "Will build surgescript")
166	187	add_executable(surgescript.bin src/main.c)
167		target_link_libraries(surgescript.bin ${LIBSURGESCRIPT})
	188	include_directories("${CMAKE_BINARY_DIR}/src")
	189	target_compile_definitions(surgescript.bin PUBLIC ENABLE_THREADS=${ENABLE_THREADS})
	190	target_link_libraries(surgescript.bin ${LIBSURGESCRIPT} ${LIBTHREAD})
168	191	target_include_directories(surgescript.bin PRIVATE src)
169	192	set_target_properties(surgescript.bin PROPERTIES OUTPUT_NAME surgescript)
	193
	194	# WebAssembly
	195	if(EMSCRIPTEN)
	196	target_link_options(surgescript.bin PRIVATE -Os --closure 1 -sMODULARIZE=1 -sMALLOC="emmalloc" -sEXPORTED_FUNCTIONS=["_main"]) # Reduce output size
	197	endif()
170	198
171	199	# Windows icon
172	200	if(WIN32 AND MINGW)
173	201	if(NOT CMAKE_RC_COMPILER)
174	202	set(CMAKE_RC_COMPILER windres)
175	203	endif()
176		execute_process(COMMAND "${CMAKE_RC_COMPILER}" -O coff -o "${CMAKE_CURRENT_BINARY_DIR}/iconwin.res" -i "${CMAKE_SOURCE_DIR}/src/surgescript/misc/iconwin.rc" -I "${CMAKE_SOURCE_DIR}")
177		set_target_properties(surgescript.bin PROPERTIES LINK_FLAGS "-static-libgcc \"${CMAKE_CURRENT_BINARY_DIR}/iconwin.res\"")
	204	execute_process(COMMAND "${CMAKE_RC_COMPILER}" -O coff -o "${CMAKE_BINARY_DIR}/iconwin.res" -i "${CMAKE_SOURCE_DIR}/src/surgescript/misc/iconwin.rc" -I "${CMAKE_SOURCE_DIR}")
	205	set_target_properties(surgescript.bin PROPERTIES LINK_FLAGS "-static-libgcc \"${CMAKE_BINARY_DIR}/iconwin.res\"")
178	206	endif()
179	207
180	208	# *nix metadata & icon
181	209	if(UNIX)
182		generate_file("surgescript.appdata.xml")
183		install(FILES ${CMAKE_CURRENT_BINARY_DIR}/surgescript.appdata.xml DESTINATION "${METAINFO_PATH}")
184		install(FILES src/surgescript/misc/surgescript.png DESTINATION "${ICON_PATH}")
	210	file(TO_CMAKE_PATH "${CMAKE_INSTALL_DATADIR}/${ICON_PATH}/surgescript.png" ICON_FILEPATH)
	211	generate_file("misc/surgescript.appdata.xml")
	212	install(FILES "${CMAKE_BINARY_DIR}/src/surgescript/misc/surgescript.appdata.xml" DESTINATION "${CMAKE_INSTALL_DATADIR}/${METAINFO_PATH}")
	213	install(FILES src/surgescript/misc/surgescript.png DESTINATION "${CMAKE_INSTALL_DATADIR}/${ICON_PATH}")
185	214	endif()
186	215
187	216	# Installing the executable
188		install(TARGETS surgescript.bin DESTINATION bin)
189		endif()
	217	install(TARGETS surgescript.bin DESTINATION "${CMAKE_INSTALL_BINDIR}")
	218	endif()

+44

-12

docs/engine/actor.md less more

51	51
52	52	Reference to the Animation object of the Actor.
53	53
54		#### alpha
55
56		`alpha`: number.
57
58		Opacity value, ranging from zero (0% opaque) to one (100% opaque). Defaults to 1.0.
59
60	54	#### entity
61	55
62	56	`entity`: object, read-only.
63	57
64	58	The entity associated with this component.
65
66		#### offset
67
68		`offset`: [Vector2](/engine/vector2) object.
69
70		A (x,y) offset relative to the parent object. Defaults to zero.
71	59
72	60	#### hflip
73	61

87	75
88	76	Should the actor be rendered? Defaults to `true`.
89	77
	78	#### alpha
	79
	80	`alpha`: number.
	81
	82	Opacity value, ranging from zero (0% opaque) to one (100% opaque). Defaults to 1.0.
	83
	84	#### offset
	85
	86	`offset`: [Vector2](/engine/vector2) object.
	87
	88	A (x,y) offset relative to the parent object. Defaults to zero.
	89
	90	#### anchor
	91
	92	`anchor`: [Vector2](/engine/vector2) object.
	93
	94	A shortcut to `animation.anchor`. See also: [anchor](/engine/animation#anchor).
	95
	96	Available since: Open Surge 0.6.0
	97
	98	#### hotSpot
	99
	100	`hotSpot`: [Vector2](/engine/vector2) object.
	101
	102	A shortcut to `animation.hotSpot`. See also: [hot spot](/engine/animation#hotspot).
	103
	104	Available since: Open Surge 0.6.0. In versions prior to 0.6.0, you may get the hot spot using the [Animation](/engine/animation#hotspot) object.
	105
	106	#### actionSpot
	107
	108	`actionSpot`: [Vector2](/engine/vector2) object.
	109
	110	A shortcut to `animation.actionSpot`. See also: [action spot](/engine/animation#actionspot).
	111
	112	Available since: Open Surge 0.6.0
	113
	114	#### actionOffset
	115
	116	`actionOffset`: [Vector2](/engine/vector2) object, read-only.
	117
	118	A shortcut to `animation.actionOffset`. See also: [action offset](/engine/animation#actionoffset).
	119
	120	Available since: Open Surge 0.6.0
	121
90	122	#### width
91	123
92	124	`width`: number, read-only.

+36

-10

docs/engine/animation.md less more

26	26
27	27	`id`: number.
28	28
29		The number of the current animation, defined in a .spr file.
	29	The number of the animation, defined in a .spr file.
30	30
31	31	#### sprite
32	32

38	38
39	39	`exists`: boolean, read-only.
40	40
41		Will be `true` if the current animation exists, i.e., if its sprite and its animation number have been defined in a .spr file.
	41	Will be `true` if the animation exists, i.e., if its sprite and its animation number have been defined in a .spr file.
42	42
43	43	Available since: Open Surge 0.5.1
44	44

46	46
47	47	`finished`: boolean, read-only.
48	48
49		Will be `true` if the current animation has finished playing.
	49	Will be `true` if the animation has finished playing.
50	50
51		#### hotspot
	51	#### anchor
52	52
53		`hotspot`: [Vector2](/engine/vector2) object, read-only.
	53	`anchor`: [Vector2](/engine/vector2) object, read-only.
54	54
55		The position of the hot spot of the current animation.
	55	The hot spot of the animation normalized to [0,1] x [0,1].
	56
	57	Available since: Open Surge 0.6.0
	58
	59	#### hotSpot
	60
	61	`hotSpot`: [Vector2](/engine/vector2) object, read-only.
	62
	63	The hot spot of the animation. Coordinates are given in pixels.
	64
	65	Note: prior to Open Surge 0.6.0, this property was called `hotspot`.
	66
	67	#### actionSpot
	68
	69	`actionSpot`: [Vector2](/engine/vector2) object, read-only.
	70
	71	The action spot of the animation. Coordinates are given in pixels. If the sprite is flipped, the action spot is automatically flipped relative to the [hot spot](#hotspot) of the animation.
	72
	73	Available since: Open Surge 0.6.0
	74
	75	#### actionOffset
	76
	77	`actionOffset`: [Vector2](/engine/vector2) object, read-only.
	78
	79	When this vector is added to the position of the sprite, you'll get the position of the [action spot](#actionspot). This is suitable to be used with [transform.localPosition](/engine/transform#localposition).
	80
	81	Available since: Open Surge 0.6.0
56	82
57	83	#### fps
58	84
59	85	`fps`: number, read-only.
60	86
61		Frames per second of the current animation.
	87	Frames per second of the animation.
62	88
63	89	#### repeats
64	90
65	91	`repeats`: boolean, read-only.
66	92
67		Does the current animation repeat itself?
	93	Does the animation repeat itself?
68	94
69	95	#### frameCount
70	96
71	97	`frameCount`: number, read-only.
72	98
73		The number of frames of the current animation.
	99	The number of frames of the animation.
74	100
75	101	#### frame
76	102

88	114
89	115	`sync`: boolean.
90	116
91		Is the current animation is synchronized? A synchronized animation is a repeating animation that displays the same frame across multiple sprites. Defaults to `false`.⏎
	117	Is the animation is synchronized? A synchronized animation is a repeating animation that displays the same frame across multiple sprites. Defaults to `false`.

+9

-1

docs/engine/collider.md less more

73	73
74	74	Is the collider visible? This is useful for debugging. The default value is `false`.
75	75
	76	#### anchor
	77
	78	`anchor`: [Vector2](/engine/vector2) object.
	79
	80	The anchor of the collider. See also: [setAnchor](#setanchor).
	81
	82	Available since: Open Surge 0.6.0
	83
76	84	Functions
77	85	---------
78	86

108	116
109	117	`setAnchor(x, y)`
110	118
111		Defines the anchor of the collider to be (`x`, `y`), where these values are (usually) numbers between 0.0 and 1.0. Imagine a bounding box of the collider. Point (0.5, 0.5) is the default, representing its center. Point (0.0, 0.0) is the top-left and (1,0, 1.0), the bottom-right. The anchor of the collider will be aligned to the hot spot of the sprite of the entity.
	119	Defines the anchor of the collider to be (`x`, `y`), where these values are (usually) numbers between 0.0 and 1.0. Imagine a bounding box of the collider. Point (0.5, 0.5) is the default, representing its center. Point (0.0, 0.0) is the top-left and (1,0, 1.0), the bottom-right. The anchor of the collider will be aligned to the hot spot of the sprite of the entity. See also: [anchor](#anchor).
112	120
113	121	Arguments
114	122

+4

-2

docs/engine/level.md less more

141	141
142	142	`gravity`: number, read-only.
143	143
144		A default value for the level gravity, in pixels per second squared.
	144	The acceleration of gravity, measured in pixels per second squared.
145	145
146	146	#### time
147	147
148		`time`: number, read-only.
	148	`time`: number.
149	149
150	150	Elapsed time in the level, given in seconds.
	151
	152	Note: this property is writable since Open Surge 0.6.0.
151	153
152	154	#### next
153	155

+51

-1

docs/engine/platformer.md less more

57	57
58	58	Jump speed, in pixels per second. The higher the value, the more intense the jump.
59	59
	60	#### gravityMultiplier
	61
	62	`gravityMultiplier`: number.
	63
	64	A multiplier used to modify how the Platformer is affected by gravity. When set to 1.0, the Platformer will subject to the [default acceleration of gravity](/engine/level#gravity). When set to 2.0 (0.5), the Platformer will be subject to twice (half) the default gravity, and so on. Zero means no gravity. Defaults to 1.0.
	65
	66	Available since: Open Surge 0.6.0
	67
60	68	#### direction
61	69
62	70	`direction`: number, read-only.

204	212
205	213	#### forceJump
206	214
207		`forceJump()`
	215	`forceJump(speed)`
208	216
209	217	Makes the platformer jump, regardless if it's touching the ground or not.
	218
	219	Arguments
	220
	221	* `speed`: number. Jump speed in pixels per second.
210	222
211	223	Returns
212	224

226	238	Returns
227	239
228	240	Returns the platformer itself.
	241
	242	#### showSensors
	243
	244	`showSensors()`
	245
	246	Displays the internal sensors of the platformer, which are invisible by default. For debugging only.
	247
	248	Available since: Open Surge 0.5.2
	249
	250	Returns
	251
	252	Returns the platformer itself.
	253
	254	Example
	255
	256	```
	257	using SurgeEngine.Actor;
	258	using SurgeEngine.Behaviors.Platformer;
	259
	260	object "Testing Stuff" is "entity"
	261	{
	262	actor = Actor("Testing Stuff");
	263	platformer = Platformer().showSensors();
	264	// ...
	265	}
	266	```
	267
	268	#### hideSensors
	269
	270	`hideSensors()`
	271
	272	Hides the internal sensors of the platformer. This is the default.
	273
	274	Available since: Open Surge 0.5.2
	275
	276	Returns
	277
	278	Returns the platformer itself.

+47

-7

docs/engine/player.md less more

176	176	}
177	177	```
178	178
	179	#### animation
	180
	181	`animation`: [Animation](/engine/animation) object, read-only.
	182
	183	Reference to the Animation object of the Player.
	184
179	185	#### anim
180	186
181	187	`anim`: number.
182	188
183		A shortcut to `animation.id`: an integer corresponding to the animation number.
184
185		#### animation
186
187		`animation`: [Animation](/engine/animation) object, read-only.
188
189		Reference to the Animation object of the Player.
	189	A shortcut to `animation.id`: an integer corresponding to the animation number. See also: [Animation](/engine/animation), [id](/engine/animation#id).
	190
	191	#### anchor
	192
	193	`anchor`: [Vector2](/engine/vector2) object.
	194
	195	A shortcut to `animation.anchor`. See also: [anchor](/engine/animation#anchor).
	196
	197	Available since: Open Surge 0.6.0
	198
	199	#### hotSpot
	200
	201	`hotSpot`: [Vector2](/engine/vector2) object.
	202
	203	A shortcut to `animation.hotSpot`. See also: [hot spot](/engine/animation#hotspot).
	204
	205	Available since: Open Surge 0.6.0. In versions prior to 0.6.0, you may get the hot spot using the [Animation](/engine/animation#hotspot) object.
	206
	207	#### actionSpot
	208
	209	`actionSpot`: [Vector2](/engine/vector2) object.
	210
	211	A shortcut to `animation.actionSpot`. See also: [action spot](/engine/animation#actionspot).
	212
	213	Available since: Open Surge 0.6.0
	214
	215	#### actionOffset
	216
	217	`actionOffset`: [Vector2](/engine/vector2) object, read-only.
	218
	219	A shortcut to `animation.actionOffset`. See also: [action offset](/engine/animation#actionoffset).
	220
	221	Available since: Open Surge 0.6.0
190	222
191	223	#### attacking
192	224

447	479	`angle`: number.
448	480
449	481	The angle of the player, in degrees. The same as `transform.angle`.
	482
	483	#### slope
	484
	485	`slope`: number, read-only.
	486
	487	The angle detected by the physics system, in degrees. Unlike [angle](#angle), slope is read-only and does not feature any smoothing for visual aesthetics. Its purpose is to be a helper for physics calculations.
	488
	489	Available since: Open Surge 0.5.2
450	490
451	491	#### width
452	492

+6

-0

docs/engine/prefs.md less more

14	14	{
15	15	Prefs["counter"] += 1;
16	16	Console.print("counter: " + Prefs["counter"]);
	17
	18	state = "idle";
	19	}
	20
	21	state "idle"
	22	{
17	23	}
18	24
19	25	fun constructor()

+1

-1

docs/engine/text.md less more

63	63
64	64	#### size
65	65
66		`size`: [Vector2](/engine/vector2) object.
	66	`size`: [Vector2](/engine/vector2) object, read-only.
67	67
68	68	The size, in pixels, of the rendered text.
69	69

+4

-4

docs/index.md less more

0	0	Welcome to SurgeScript!
1	1	=======================
2	2
3		<img src="img/surge.png" alt="Surge" align="right" width="384">
	3	<img src="img/surge.png" alt="Surge" align="right" width="256">
4	4
5	5	Unleash your creativity!
6	6	------------------------

12	12	How do I learn SurgeScript?
13	13	---------------------------
14	14
15		Check out the [SurgeScript Crash Course](/tutorials/hello)! Also take a look on the [video tutorials](https://youtube.com/alemart88) and on the examples folder that comes with the software.
	15	Check out the [SurgeScript Crash Course](/tutorials/hello)! Additionally, take a look at the [video tutorials](https://youtube.com/alemart88) and at the examples that come with the software.
16	16
17	17	SurgeScript in a nutshell
18	18	-------------------------

32	32
33	33	Unlike other programming languages, SurgeScript has been designed with the specific needs of games in mind. Its features include:
34	34
35		- The state-machine pattern: objects are state machines, making it easy to create in-game entities
	35	- The state-machine pattern: objects are state machines, making it easy to create game entities
36	36	- The composition approach: you may design complex objects and behaviors by means of composition
37	37	- The hierarchy system: objects have a parent and may have children, in a tree-like structure
38	38	- The game loop: it's defined implicitly
39	39	- Automatic garbage collection, object tagging and more!
40	40
41		SurgeScript is meant to be used in games and in interactive applications. It's easy to integrate it into existing code, it's easy to extend, it features a C-like syntax, and it's free and open-source software.
	41	SurgeScript is meant to be used in games and in interactive applications. It's easy to integrate it into existing code, it's easy to extend it, it features a C-like syntax, and it's free and open-source software.
42	42
43	43	SurgeScript has been designed based on the experience of its developer dealing with game engines, applications related to computer graphics and so on. Some of the best practices have been incorporated into the language itself, making things really easy for developers and modders.
44	44

+53

-36

docs/reference/object.md less more

11	11
12	12	Reference to the parent object.
13	13
14		#### childCount
15
16		`childCount`: number, read-only.
	14	#### __name
	15
	16	`__name`: string, read-only.
	17
	18	The name of the object.
	19
	20	#### __active
	21
	22	`__active`: boolean.
	23
	24	Indicates whether the object is active or not.
	25
	26	Objects are active by default. Whenever an object is set to be inactive, its state machine is paused. Additionally, the state machines of all its descendants are also paused.
	27
	28	#### __functions
	29
	30	`__functions`: [Array](/reference/array) object, read-only.
	31
	32	The functions of this object represented as a collection of strings.
	33
	34	#### __timespent
	35
	36	`__timespent`: number, read-only.
	37
	38	The approximate time spent in the current state (in seconds).
	39
	40	#### __file
	41
	42	`__file`: string, read-only.
	43
	44	The source file of this object.
	45
	46	Available since: SurgeScript 0.5.3
	47
	48	#### __children
	49
	50	`__children`: [Array](/reference/array) object, read-only.
	51
	52	The children of this object.
	53
	54	Available since: SurgeScript 0.5.4
	55
	56	Returns
	57
	58	A new array featuring all the children of this object. If there are no children, an empty array is returned.
	59
	60	#### __childCount
	61
	62	`__childCount`: number, read-only.
17	63
18	64	The number of children of the object.
19	65
20		#### __name
21
22		`__name`: string, read-only.
23
24		The name of the object.
25
26		#### __active
27
28		`__active`: boolean.
29
30		Indicates whether the object is active or not.
31
32		Objects are active by default. Whenever an object is set to be inactive, its state machine is paused. Additionally, the state machines of all its descendants are also paused.
33
34		#### __functions
35
36		`__functions`: [Array](/reference/array) object, read-only.
37
38		The functions of this object represented as a collection of strings.
39
40		#### __timespent
41
42		`__timespent`: number, read-only.
43
44		The approximate time spent in this object in the last frame (in seconds).
45
46		#### __file
47
48		`__file`: string, read-only.
49
50		The source file of this object.
51
52		Available since: SurgeScript 0.5.3
	66	Available since: SurgeScript 0.5.5
	67
	68	Note: prior to SurgeScript 0.5.5, you would use `object.childCount` instead. That form is now obsolete.
	69
53	70
54	71	Functions
55	72	---------

+1

-1

docs/tutorials/advanced_features.md less more

7	7
8	8	Some programming languages, such as C++, have a feature called operator overloading. It's a syntactic sugar that allows the programmer to attribute custom implementations to different operators.
9	9
10		In SurgeScript, the `[]` operator (also called the lookup operator), used by [Arrays](/reference/array) and [Dictionaries](/reference/dictionary), is used to get and set values from/to the data structure. In fact, the `[]` operator can be used with any object. It is necessary to define, in your object, functions `get()` and `set()` with the following signature:
	10	In SurgeScript, the `[]` operator (also called the lookup operator), used by [Arrays](/reference/array) and [Dictionaries](/reference/dictionary), is used to get and set values from/to the data structure. In fact, the `[]` operator can be used with any object. It is necessary to define, in your object, functions named `get()` and `set()` with the following signature:
11	11
12	12	```
13	13	fun get(key)

+1

-1

docs/tutorials/best_practices.md less more

4	4	- Follow the golden rule: objects should not mess with each others' internals!
5	5	- Objects should not change others' internal variables or states directly (not allowed!)
6	6	- Objects should define [functions](/tutorials/functions) that can be operated upon by the external world (API)
7		- Use a consistent style, e.g.,
	7	- Use a consistent coding style. Suggestion:
8	8	- Use camelCase names for both variables and functions.
9	9	- Use 4 spaces when indenting your code.
10	10	- Combine related [packages](/tutorials/packages) into a single one: don't pollute the global namespace.

+3

-3

docs/tutorials/expressions.md less more

108	108
109	109	Expression\|Result
110	110	----------\|------
111		`a && b` \|`true` only if both a and b are true
112		`a \|\| b` \| `true` if a is true or b is true
113		`!a` \| `true` if a is false, `false` if a is true
	111	`a && b` \|`true` only if both `a` and `b` are true
	112	`a \|\| b` \| `true` if `a` is true or `b` is true
	113	`!a` \| `true` if `a` is false, `false` if `a` is true
114	114
115	115	Notice that not has higher precedence than the other two operators. Examples:
116	116

+2

-2

docs/tutorials/object_tree.md less more

82	82	Function / property\|Description
83	83	-------------------\|-----------
84	84	`obj.parent` (read-only) \| The parent object
85		`obj.childCount` (read-only) \| Number of immediate children
86	85	`obj.child(name)` \| Gets a child object named `name`
87	86	`obj.findObject(name)` \| Finds a descendant named `name`
	87	`obj.__childCount` (read-only) \| Number of immediate children
88	88
89	89	Example:
90	90

96	96
97	97	state "main"
98	98	{
99		Console.print("This object has " + this.childCount + " children.");
	99	Console.print("This object has " + this.__childCount + " children.");
100	100	destroy();
101	101	}
102	102	}

+3

-2

mkdocs.yml less more

1	1	site_url: 'https://docs.opensurge2d.org/'
2	2	site_author: 'Alexandre Martins'
3	3	site_description: 'SurgeScript is a scripting language for games.'
4		copyright: 'SurgeScript is a scripting language for games. Copyright © 2016-2020 Alexandre Martins.'
	4	site_dir: 'docs_html/'
	5	copyright: 'SurgeScript is a scripting language for games. Copyright © 2016-2021 Alexandre Martins.'
5	6	google_analytics: ['UA-120511928-1', 'opensurge2d.org']
6	7	repo_url: 'https://github.com/alemart/surgescript'
7		strict: true
	8	strict: false
8	9	theme:
9	10	name: 'material'
10	11	nav:

+176

-27

src/main.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2020 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2022 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

15	15	* limitations under the License.
16	16	*
17	17	* runtime/main.c
18		* SurgeScript Runtime Engine entry point
	18	* SurgeScript CLI
19	19	*/
20	20
21	21	#include <surgescript.h>
22	22	#include <string.h>
23	23	#include <stdio.h>
24	24
25		static surgescript_vm_t* make_vm(int argc, char** argv);
	25	/* multithread support */
	26	#if ENABLE_THREADS
	27	# if __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__)
	28	# include <threads.h>
	29	# else
	30	# error "Can't compile the SurgeScript CLI: threads.h is not found on this environment. Please change the environment or disable multithreading."
	31	# endif
	32	#endif
	33
	34	static surgescript_vm_t* make_vm(int argc, char** argv, uint64_t* time_limit);
	35	static void run_vm(surgescript_vm_t* vm, uint64_t time_limit);
	36	static void destroy_vm(surgescript_vm_t* vm);
26	37	static void print_to_stdout(const char* message);
27	38	static void print_to_stderr(const char* message);
28	39	static void discard_message(const char* message);
29	40	static void show_help(const char* executable);
	41	static char* read_from_stdin();
	42	static int main_loop(void* arg);
	43
	44	/* default time limit, given in milliseconds */
	45	#define DEFAULT_TIME_LIMIT 30000
30	46
31	47	/*
32	48	* main()

34	50	*/
35	51	int main(int argc, char* argv[])
36	52	{
37		if(argc > 1) {
38		/* create the VM and compile the input file(s) */
39		surgescript_vm_t* vm = make_vm(argc, argv);
40		if(vm != NULL) {
41		/* run the VM */
42		while(surgescript_vm_update(vm)) {
43		;
44		}
45
46		/* destroy the VM */
47		surgescript_vm_destroy(vm);
48		}
49		}
50		else {
51		/* print usage */
52		show_help(surgescript_util_basename(argv[0]));
	53	uint64_t time_limit = DEFAULT_TIME_LIMIT;
	54
	55	/* Create the VM and compile the input file(s) */
	56	surgescript_vm_t* vm = make_vm(argc, argv, &time_limit);
	57
	58	/* got a VM? */
	59	if(vm != NULL) {
	60	/* run the VM */
	61	run_vm(vm, time_limit);
	62
	63	/* destroy the VM */
	64	destroy_vm(vm);
53	65	}
54	66
55	67	/* done! */
56	68	return 0;
	69	}
	70
	71	/**
	72	* run_vm()
	73	* Run the VM with a time limit
	74	*/
	75	void run_vm(surgescript_vm_t* vm, uint64_t time_limit)
	76	{
	77	uint64_t start_time = surgescript_util_gettickcount();
	78	#define show_time_limit_error() \
	79	fprintf(stderr, "Time limit of %.1lf seconds exceeded.\n", (double)time_limit * 0.001)
	80
	81	#if !ENABLE_THREADS
	82
	83	/* main loop */
	84	while(surgescript_vm_update(vm)) {
	85
	86	/* time limit */
	87	if(time_limit > 0 && surgescript_util_gettickcount() > start_time + time_limit) {
	88	show_time_limit_error();
	89	break;
	90	}
	91
	92	}
	93
	94	#else
	95
	96	/* run the SurgeScript VM on a separate thread */
	97	thrd_t thread;
	98	thrd_create(&thread, main_loop, vm);
	99
	100	/* handle the time limit, if it's been set */
	101	if(time_limit > 0) {
	102	while(surgescript_vm_is_active(vm)) {
	103	if(surgescript_util_gettickcount() > start_time + time_limit) {
	104	show_time_limit_error();
	105	exit(1); /* TODO we should kill the other thread instead */
	106	}
	107
	108	thrd_yield();
	109	}
	110	}
	111
	112	/* wait for the other thread to complete */
	113	thrd_join(thread, NULL);
	114
	115	#endif
	116
	117	}
	118
	119	/**
	120	* destroy_vm()
	121	* Destroy a SurgeScript VM
	122	*/
	123	void destroy_vm(surgescript_vm_t* vm)
	124	{
	125	surgescript_vm_destroy(vm);
	126	}
	127
	128	/**
	129	* main_loop()
	130	* Game loop for multithreaded execution
	131	*/
	132	int main_loop(void* arg)
	133	{
	134	#if !ENABLE_THREADS
	135
	136	(void)arg;
	137	return 0;
	138
	139	#else
	140
	141	surgescript_vm_t* vm = (surgescript_vm_t*)arg;
	142
	143	while(surgescript_vm_update(vm)) {
	144	thrd_yield();
	145	}
	146
	147	return 0;
	148
	149	#endif
57	150	}
58	151
59	152	/*

61	154	* Parses the command line arguments and creates a VM
62	155	* with the compiled scripts
63	156	*/
64		surgescript_vm_t* make_vm(int argc, char** argv)
	157	surgescript_vm_t* make_vm(int argc, char** argv, uint64_t* time_limit)
65	158	{
66	159	surgescript_vm_t* vm = NULL;
67	160	int i;

86	179	show_help(surgescript_util_basename(argv[0]));
87	180	return NULL;
88	181	}
	182	else if(strcmp(arg, "--timelimit") == 0 \|\| strcmp(arg, "-t") == 0) {
	183	/* set time limit (maximum execution time) */
	184	if(++i < argc && time_limit != NULL) {
	185	double seconds = atof(argv[i]);
	186	time_limit = (seconds > 0.0) ? (uint64_t)(seconds 1000.0) : 0;
	187	}
	188	}
	189	else if(strcmp(arg, "--") == 0) {
	190	/* user-specific command line arguments */
	191	break;
	192	}
89	193	else {
90		printf("Unrecognized option: '%s'.\nType '%s --help' for more information.\n", arg, surgescript_util_basename(argv[0]));
	194	/* unrecognized option */
	195	fprintf(stderr, "Unrecognized option: '%s'.\nType '%s --help' for more information.\n", arg, surgescript_util_basename(argv[0]));
91	196	return NULL;
92	197	}
93	198	}

96	201	vm = surgescript_vm_create();
97	202
98	203	/* compile the scripts */
99		for(; i < argc && strcmp(argv[i], "--") != 0; i++) {
100		const char* file = argv[i];
101		surgescript_vm_compile(vm, file);
	204	if(i < argc && strcmp(argv[i], "--") != 0) {
	205	/* read files */
	206	for(; i < argc && strcmp(argv[i], "--") != 0; i++) {
	207	const char* file = argv[i];
	208	surgescript_vm_compile(vm, file);
	209	}
	210	}
	211	else {
	212	fprintf(stderr, "Reading from stdin... Run '%s -h' for help.\n", surgescript_util_basename(argv[0]));
	213
	214	/* read from stdin */
	215	char* code = read_from_stdin();
	216	surgescript_vm_compile_code_in_memory(vm, code);
	217	ssfree(code);
102	218	}
103	219
104	220	/* launch the VM */
105		surgescript_vm_launch_ex(vm, argc, argv);
	221	if(i < argc && strcmp(argv[i], "--") == 0) {
	222	/* launch with user-specific command line arguments */
	223	++i;
	224	surgescript_vm_launch_ex(vm, argc - i, (char**)(argv + i));
	225	}
	226	else {
	227	/* launch without user-specific command line arguments */
	228	surgescript_vm_launch(vm);
	229	}
106	230
107	231	/* done! */
108	232	return vm;

125	249	"Options:\n"
126	250	" -v, --version shows the version of SurgeScript\n"
127	251	" -D, --debug prints debugging information\n"
	252	" -t, --timelimit sets a maximum execution time, in seconds (0 = no limit)\n"
128	253	" -h, --help shows this message\n"
129	254	"\n"
130	255	"Examples:\n"

132	257	" %s file1.ss file2.ss compiles and executes file1.ss and file2.ss\n"
133	258	" %s --debug test.ss compiles and runs test.ss with debugging information\n"
134	259	" %s file.ss -- -x -y passes custom arguments -x and -y to file.ss\n"
	260	" %s -t 5 runs a script read from stdin, with a time limit of 5 seconds\n"
135	261	"\n"
136		"Full documentation at: <%s>\n",
	262	"Full documentation available at: <%s>\n",
137	263	surgescript_util_version(),
138	264	surgescript_util_year(),
139	265	surgescript_util_authors(),

143	269	executable,
144	270	executable,
145	271	executable,
	272	executable,
146	273	surgescript_util_website()
147	274	);
148	275	}

172	299	void discard_message(const char* message)
173	300	{
174	301	;
175		}⏎
	302	}
	303
	304	/**
	305	* read_from_stdin()
	306	* Read data from stdin and store it in a string
	307	*/
	308	char* read_from_stdin()
	309	{
	310	const size_t BUFSIZE = 1024;
	311	char* data = NULL;
	312	size_t read_chars = 0, data_size = 0;
	313
	314	/* read to data[] */
	315	do {
	316	data_size += BUFSIZE;
	317	data = ssrealloc(data, data_size + 1);
	318	read_chars += fread(data + read_chars, sizeof(char), BUFSIZE, stdin);
	319	data[read_chars] = '\0';
	320	} while(read_chars == data_size);
	321
	322	/* done! */
	323	return data;
	324	}

+2

-2

src/surgescript/compiler/parser.c less more

190	190	{
191	191	FILE* fp = surgescript_util_fopen_utf8(absolute_path, "rb"); /* use binary mode, so offsets don't get messed up */
192	192	if(fp) {
193		static size_t BUFSIZE = 1024;
	193	const size_t BUFSIZE = 1024;
194	194	char* data = NULL;
195	195	size_t read_chars = 0, data_size = 0;
196	196

1104	1104	if(!is_state_context(context))
1105	1105	ssfatal("Compile Error: timeout can only be used inside a state (see %s:%d).", context.source_file, surgescript_token_linenumber(parser->previous));
1106	1106	match(parser, SSTOK_LPAREN);
1107		expr(parser, context);
	1107	assignexpr(parser, context);
1108	1108	emit_timeout(context);
1109	1109	match(parser, SSTOK_RPAREN);
1110	1110	}

+2

-2

src/surgescript/compiler/parser.h less more

76	76	* \| ! <unaryexpr>
77	77	* \| typeof <unaryexpr> \| typeof ( <expr> )
78	78	* \| ++ identifier \| -- identifier
79		* \| timeout ( <expr> )
	79	* \| timeout ( <assignexpr> )
80	80	* \| <postfixexpr>
81	81	* <postfixexpr> := identifier ++ \| identifier --
82	82	* \| <funcallexpr> <postfixexpr1>

154	154	void surgescript_parser_set_flags(surgescript_parser_t* parser, surgescript_parser_flags_t flags); /* set parser options (flags) */
155	155	surgescript_parser_flags_t surgescript_parser_get_flags(surgescript_parser_t* parser); /* get parser flags */
156	156
157		#endif⏎
	157	#endif

src/surgescript/misc/icon.png less more

Binary diff not shown

+10

-11

src/surgescript/misc/info.c.in less more

0		/* Project info */
	0	/* SurgeScript info */
	1	#include "../util/version.h"
	2
	3	#cmakedefine PROJECT_YEARS "@PROJECT_YEARS@"
	4	#if !defined(PROJECT_YEARS)
	5	#error Undefined PROJECT_YEARS
	6	#endif
	7
1	8	const char SURGESCRIPT_AUTHORS[] = "Alexandre Martins";
2		const char SURGESCRIPT_YEARS[] = "2016-2020";
3	9	const char SURGESCRIPT_WEBSITE[] = "https://github.com/alemart/surgescript";
4
5		/* compiled version of SurgeScript */
6		#cmakedefine PROJECT_VERSION "@PROJECT_VERSION@"
7
8		#if defined(PROJECT_VERSION)
9		const char SURGESCRIPT_VERSION[] = PROJECT_VERSION;
10		#else
11		#error "Undefined PROJECT_VERSION (major.minor.patch.tweak)"
12		#endif
	10	const char SURGESCRIPT_VERSION[] = SURGESCRIPT_VERSION_STR;
	11	const char SURGESCRIPT_YEARS[] = PROJECT_YEARS;⏎

+93

-0

src/surgescript/misc/pack-windows.sh less more

	0	#!/bin/bash
	1	# This utility packs the Windows build of SurgeScript
	2	# Copyright 2016-2021 Alexandre Martins
	3
	4	UNIX2DOS="todos" #"unix2dos"
	5	SOURCE_FOLDER="../../.."
	6	BUILD_FOLDER="$SOURCE_FOLDER/build"
	7	OUTPUT_FOLDER="/tmp"
	8
	9	# File surgescript.exe must be present before packaging
	10	if [ ! -f "$BUILD_FOLDER/surgescript.exe" ]; then
	11	echo "File surgescript.exe not found"
	12	exit 1
	13	fi
	14
	15	# Extract the SurgeScript version
	16	VERSION=$(wine "$BUILD_FOLDER/surgescript.exe" -v \| tr -cd [:digit:][:punct:])
	17	PACKAGE="surgescript-$VERSION-win"
	18	echo "Found SurgeScript version $VERSION."
	19
	20	# Create a temporary folder for packaging
	21	TMP_FOLDER="/tmp/$PACKAGE"
	22	rm -rf "$TMP_FOLDER" 2>/dev/null
	23	mkdir -p "$TMP_FOLDER"
	24
	25	# Write a README for Windows
	26	cat > "$TMP_FOLDER/README-Windows.txt" << EOF
	27	--------------------------------------------------
	28	SurgeScript
	29	A scripting language for games
	30	Copyright (C) 2016-$(date +%Y) Alexandre Martins
	31	--------------------------------------------------
	32	This is the Windows build of SurgeScript $VERSION.
	33
	34	To test SurgeScript, run the surgescript executable via the Command Prompt.
	35	Pass the scripts you want to test via the command line, as in the examples:
	36
	37	See the available options:
	38	C:\path\to\surgescript> surgescript
	39
	40	Run a test script:
	41	C:\path\to\surgescript> surgescript examples\hello.ss
	42
	43	Run another test script:
	44	C:\path\to\surgescript> surgescript examples\count_to_10.ss
	45
	46	There are many example scripts to try out. Check the examples folder for
	47	more information.
	48
	49	Visit the SurgeScript website at: https://github.com/alemart/surgescript/
	50	EOF
	51
	52	# Copy files
	53	for file in surgescript.exe libsurgescript-static.a libsurgescript.dll.a libsurgescript.dll surgescript.pc surgescript-static.pc; do
	54	echo "Copying $file..."
	55	cp "$BUILD_FOLDER/$file" "$TMP_FOLDER"
	56	done
	57
	58	for file in LICENSE README.md CHANGES.md CMakeLists.txt mkdocs.yml; do
	59	echo "Copying $file..."
	60	cp "$SOURCE_FOLDER/$file" "$TMP_FOLDER"
	61	done
	62
	63	for folder in examples src cmake; do
	64	echo "Copying $folder/ ..."
	65	cp -r "$SOURCE_FOLDER/$folder" "$TMP_FOLDER"
	66	done
	67
	68	mv "$TMP_FOLDER/LICENSE" "$TMP_FOLDER/LICENSE.txt"
	69
	70	# Converting newlines of all text files
	71	for f in `find "$TMP_FOLDER" -type f -exec grep -Iq . {} \; -print`; do
	72	${UNIX2DOS} $f
	73	done
	74
	75	# Generate the docs
	76	pushd "$SOURCE_FOLDER"
	77	mkdocs build
	78	popd
	79
	80	# Copying the docs
	81	for folder in docs docs_html; do
	82	echo "Copying $folder/ ..."
	83	cp -r "$SOURCE_FOLDER/$folder" "$TMP_FOLDER"
	84	done
	85
	86	# Create the .zip package
	87	pushd "$TMP_FOLDER"
	88	echo "Packaging..."
	89	zip -r "$OUTPUT_FOLDER/$PACKAGE.zip" ./*
	90	echo "Packaged to $OUTPUT_FOLDER/$PACKAGE.zip"
	91	popd
	92	#rm -rf "${TMP_FOLDER}"⏎

+1

-2

src/surgescript/misc/surgescript.appdata.xml.in less more

0	0	<?xml version="1.0" encoding="UTF-8"?>
1		<!-- Copyright 2020 Alexandre Martins -->
2	1	<component type="console-application">
3	2	<id>org.opensurge2d.SurgeScript</id>
4	3	<name>SurgeScript</name>
5	4	<developer_name>Alexandre Martins</developer_name>
6	5	<update_contact>alemartf_at_gmail.com</update_contact>
7		<metadata_license>MIT</metadata_license>
	6	<metadata_license>Apache-2.0</metadata_license>
8	7	<project_license>Apache-2.0</project_license>
9	8	<summary>A scripting language for games</summary>
10	9	<description>

src/surgescript/misc/surgescript.ico less more

Binary diff not shown

src/surgescript/misc/surgescript.png less more

Binary diff not shown

+13

-7

src/surgescript/runtime/object.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2019 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2019, 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

27	27	#include "heap.h"
28	28	#include "stack.h"
29	29	#include "renv.h"
	30	#include "vm_time.h"
30	31	#include "../util/transform.h"
31	32	#include "../util/ssarray.h"
32	33	#include "../util/util.h"

51	52	bool is_active; /* can i run programs? */
52	53	bool is_killed; /* am i scheduled to be destroyed? */
53	54	bool is_reachable; /* is this object reachable through some other? (garbage-collection) */
	55
	56	/* internal timer */
	57	const surgescript_vmtime_t* vmtime; /* VM time */
54	58	uint64_t last_state_change; /* moment of the last state change */
55	59	uint64_t time_spent; /* how much time did this object consume since the last state change */
56	60

88	92	* surgescript_object_create()
89	93	* Creates a new blank object
90	94	*/
91		surgescript_object_t* surgescript_object_create(const char* name, unsigned handle, surgescript_objectmanager_t* object_manager, surgescript_programpool_t* program_pool, surgescript_stack_t* stack, void* user_data)
	95	surgescript_object_t* surgescript_object_create(const char* name, unsigned handle, surgescript_objectmanager_t* object_manager, surgescript_programpool_t* program_pool, surgescript_stack_t* stack, const surgescript_vmtime_t* vmtime, void* user_data)
92	96	{
93	97	surgescript_object_t* obj = ssmalloc(sizeof *obj);
94	98

106	110
107	111	obj->state_name = ssstrdup(MAIN_STATE);
108	112	obj->current_state = get_state_program(obj, obj->state_name);
109		obj->last_state_change = surgescript_util_gettickcount();
110		obj->time_spent = 0;
111	113	obj->is_active = true;
112	114	obj->is_killed = false;
113	115	obj->is_reachable = false;
	116
	117	obj->vmtime = vmtime;
	118	obj->last_state_change = surgescript_vmtime_time(obj->vmtime);
	119	obj->time_spent = 0;
114	120
115	121	obj->transform = NULL;
116	122	obj->user_data = user_data;

573	579	ssfree(object->state_name);
574	580	object->state_name = ssstrdup(state_name ? state_name : MAIN_STATE);
575	581	object->current_state = get_state_program(object, object->state_name);
576		object->last_state_change = surgescript_util_gettickcount();
	582	object->last_state_change = surgescript_vmtime_time(object->vmtime);
577	583	object->time_spent = 0;
578	584	}
579	585	}

584	590	*/
585	591	double surgescript_object_elapsed_time(const surgescript_object_t* object)
586	592	{
587		return (surgescript_util_gettickcount() - object->last_state_change) * 0.001;
	593	return (surgescript_vmtime_time(object->vmtime) - object->last_state_change) * 0.001;
588	594	}
589	595
590	596	/*

835	841	{
836	842	uint64_t now = surgescript_util_gettickcount();
837	843	uint64_t dt = now > object->last_state_change ? now - object->last_state_change : 1;
838		return (double)(object->time_spent * 0.001) / dt;
	844	return ((double)(object->time_spent) * 0.001) / ((double)dt);
839	845	}
840	846
841	847	/*

+8

-5

src/surgescript/runtime/object_manager.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2018 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2018, 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

23	23	#include "object.h"
24	24	#include "program_pool.h"
25	25	#include "tag_system.h"
	26	#include "vm_time.h"
26	27	#include "stack.h"
27	28	#include "heap.h"
28	29	#include "variable.h"

42	43	surgescript_stack_t* stack; /* reference to the stack */
43	44	surgescript_tagsystem_t* tag_system; /* tag system */
44	45	surgescript_vmargs_t* args; /* VM command-line arguments (NULL-terminated array) */
	46	const surgescript_vmtime_t* vmtime; /* VM time */
45	47	SSARRAY(surgescript_objecthandle_t, objects_to_be_scanned); /* garbage collection */
46	48	int first_object_to_be_scanned; /* an index of objects_to_be_scanned */
47	49	int reachables_count; /* garbage-collector stuff */

79	81	}; /* this must be a NULL-terminated array */
80	82
81	83	/* object methods acessible by me */
82		extern surgescript_object_t* surgescript_object_create(const char* name, unsigned handle, struct surgescript_objectmanager_t* object_manager, struct surgescript_programpool_t* program_pool, struct surgescript_stack_t* stack, void* user_data); /* creates a new blank object */
	84	extern surgescript_object_t* surgescript_object_create(const char* name, unsigned handle, surgescript_objectmanager_t* object_manager, surgescript_programpool_t* program_pool, surgescript_stack_t* stack, const surgescript_vmtime_t* vmtime, void* user_data); /* creates a new blank object */
83	85	extern surgescript_object_t* surgescript_object_destroy(surgescript_object_t* object); /* destroys an object */
84	86
85	87	/* the life-cycle of the objects is handled by me */

110	112	* surgescript_objectmanager_create()
111	113	* Creates a new object manager
112	114	*/
113		surgescript_objectmanager_t* surgescript_objectmanager_create(surgescript_programpool_t* program_pool, surgescript_tagsystem_t* tag_system, surgescript_stack_t* stack, surgescript_vmargs_t* args)
	115	surgescript_objectmanager_t* surgescript_objectmanager_create(surgescript_programpool_t* program_pool, surgescript_tagsystem_t* tag_system, surgescript_stack_t* stack, surgescript_vmargs_t* args, const surgescript_vmtime_t* vmtime)
114	116	{
115	117	surgescript_objectmanager_t* manager = ssmalloc(sizeof *manager);
116	118

122	124	manager->tag_system = tag_system;
123	125	manager->stack = stack;
124	126	manager->args = args;
	127	manager->vmtime = vmtime;
125	128	manager->handle_ptr = ROOT_HANDLE;
126	129
127	130	ssarray_init(manager->objects_to_be_scanned);

161	164	{
162	165	surgescript_objecthandle_t handle = new_handle(manager);
163	166	surgescript_object_t *parent_object = surgescript_objectmanager_get(manager, parent);
164		surgescript_object_t *object = surgescript_object_create(object_name, handle, manager, manager->program_pool, manager->stack, user_data);
	167	surgescript_object_t *object = surgescript_object_create(object_name, handle, manager, manager->program_pool, manager->stack, manager->vmtime, user_data);
165	168
166	169	/* store the object */
167	170	if(handle >= ssarray_length(manager->data) && handle > ROOT_HANDLE) {

203	206	char data[] = { (char)SYSTEM_OBJECTS, plugins };
204	207
205	208	/* spawn the root object */
206		surgescript_object_t *object = surgescript_object_create(ROOT_OBJECT, ROOT_HANDLE, manager, manager->program_pool, manager->stack, data);
	209	surgescript_object_t *object = surgescript_object_create(ROOT_OBJECT, ROOT_HANDLE, manager, manager->program_pool, manager->stack, manager->vmtime, data);
207	210	ssarray_push(manager->data, object);
208	211	manager->count++;
209	212

+3

-2

src/surgescript/runtime/object_manager.h less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2018 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2018, 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

33	33	struct surgescript_stack_t;
34	34	struct surgescript_tagsystem_t;
35	35	struct surgescript_vmargs_t;
	36	struct surgescript_vmtime_t;
36	37
37	38
38	39	/* public methods */
39	40
40	41	/* life-cycle */
41		surgescript_objectmanager_t* surgescript_objectmanager_create(struct surgescript_programpool_t* program_pool, struct surgescript_tagsystem_t* tag_system, struct surgescript_stack_t* stack, struct surgescript_vmargs_t* args);
	42	surgescript_objectmanager_t* surgescript_objectmanager_create(struct surgescript_programpool_t* program_pool, struct surgescript_tagsystem_t* tag_system, struct surgescript_stack_t* stack, struct surgescript_vmargs_t* args, const struct surgescript_vmtime_t* vmtime);
42	43	surgescript_objectmanager_t* surgescript_objectmanager_destroy(surgescript_objectmanager_t* manager);
43	44
44	45	/* operations */

+9

-19

src/surgescript/runtime/program.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2019 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

517	517	break;
518	518
519	519	case SSOP_DIV:
520		if(fast_notzero(surgescript_var_get_number(t(b))))
521		surgescript_var_set_number(t(a), surgescript_var_get_number(t(a)) / surgescript_var_get_number(t(b)));
522		else if(fast_sign(surgescript_var_get_number(t(a))) >= 0)
523		surgescript_var_set_number(t(a), INFINITY * fast_sign1(surgescript_var_get_number(t(b))));
524		else
525		surgescript_var_set_number(t(a), -INFINITY * fast_sign1(surgescript_var_get_number(t(b))));
	520	/* division by zero should follow the IEEE-754 */
	521	surgescript_var_set_number(t(a), surgescript_var_get_number(t(a)) / surgescript_var_get_number(t(b)));
526	522	break;
527	523
528	524	case SSOP_MOD:

589	585	*ip = a.u;
590	586	return;
591	587	}
592		else
593		break;
	588	break;
594	589
595	590	case SSOP_JNE:
596	591	if(surgescript_var_get_rawbits(_t[2])) {
597	592	*ip = a.u;
598	593	return;
599	594	}
600		else
601		break;
	595	break;
602	596
603	597	case SSOP_JL:
604	598	if(surgescript_var_get_rawbits(_t[2]) < 0) {
605	599	*ip = a.u;
606	600	return;
607	601	}
608		else
609		break;
	602	break;
610	603
611	604	case SSOP_JG:
612	605	if(surgescript_var_get_rawbits(_t[2]) > 0) {
613	606	*ip = a.u;
614	607	return;
615	608	}
616		else
617		break;
	609	break;
618	610
619	611	case SSOP_JLE:
620	612	if(surgescript_var_get_rawbits(_t[2]) <= 0) {
621	613	*ip = a.u;
622	614	return;
623	615	}
624		else
625		break;
	616	break;
626	617
627	618	case SSOP_JGE:
628	619	if(surgescript_var_get_rawbits(_t[2]) >= 0) {
629	620	*ip = a.u;
630	621	return;
631	622	}
632		else
633		break;
	623	break;
634	624
635	625	/* function calls */
636	626	case SSOP_CALL:

+3

-2

src/surgescript/runtime/sslib/object.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2019 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2019, 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

78	78	surgescript_vm_bind(vm, "Object", "children", fun_children, 1);
79	79	surgescript_vm_bind(vm, "Object", "childWithTag", fun_childwithtag, 1);
80	80	surgescript_vm_bind(vm, "Object", "childrenWithTag", fun_childrenwithtag, 1);
81		surgescript_vm_bind(vm, "Object", "get_childCount", fun_childcount, 0);
82	81	surgescript_vm_bind(vm, "Object", "findObject", fun_findobject, 1);
83	82	surgescript_vm_bind(vm, "Object", "findObjects", fun_findobjects, 1);
84	83	surgescript_vm_bind(vm, "Object", "findObjectWithTag", fun_findobjectwithtag, 1);

100	99	surgescript_vm_bind(vm, "Object", "get___timespent", fun_timespent, 0);
101	100	surgescript_vm_bind(vm, "Object", "get___memspent", fun_memspent, 0);
102	101	surgescript_vm_bind(vm, "Object", "get___file", fun_file, 0);
	102	surgescript_vm_bind(vm, "Object", "get___childCount", fun_childcount, 0);
	103	surgescript_vm_bind(vm, "Object", "get_childCount", fun_childcount, 0); /* obsolete since 0.5.5 */
103	104	}
104	105
105	106

+1

-1

src/surgescript/runtime/sslib/time.c less more

67	67	ssassert(START_ADDR == surgescript_heap_malloc(heap));
68	68
69	69	surgescript_var_set_number(surgescript_heap_at(heap, TIME_ADDR), 0.0);
70		surgescript_var_set_number(surgescript_heap_at(heap, DELTA_ADDR), 0.016);
	70	surgescript_var_set_number(surgescript_heap_at(heap, DELTA_ADDR), 0.01667);
71	71	surgescript_var_set_number(surgescript_heap_at(heap, START_ADDR), surgescript_util_gettickcount() * 0.001);
72	72
73	73	return NULL;

+23

-8

src/surgescript/runtime/variable.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2019 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2019, 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

298	298	switch(var->type) {
299	299	case SSVAR_NULL:
300	300	return ssstrdup("null");
	301
301	302	case SSVAR_BOOL:
302	303	return ssstrdup(var->boolean ? "true" : "false");
	304
303	305	case SSVAR_STRING:
304	306	return ssstrdup(var->string);
	307
305	308	case SSVAR_NUMBER: {
306	309	char buf[32];
307	310	surgescript_var_to_string(var, buf, sizeof(buf));
308	311	return ssstrdup(buf);
309	312	}
	313
310	314	case SSVAR_OBJECTHANDLE: {
311	315	if(manager != NULL) {
312	316	surgescript_object_t* obj = surgescript_objectmanager_get(manager, var->handle);

319	323	else
320	324	return ssstrdup("[object]");
321	325	}
	326
322	327	case SSVAR_RAW:
323	328	return ssstrdup("<raw>");
	329
	330	default:
	331	return ssstrdup("<unknown>");
324	332	}
325	333	}
326	334

334	342	switch(var->type) {
335	343	case SSVAR_OBJECTHANDLE:
336	344	return var->handle;
	345
337	346	case SSVAR_NUMBER:
338	347	return surgescript_objectmanager_system_object(NULL, "Number");
	348
339	349	case SSVAR_STRING:
340	350	return surgescript_objectmanager_system_object(NULL, "String");
	351
341	352	case SSVAR_BOOL:
342	353	return surgescript_objectmanager_system_object(NULL, "Boolean");
343		case SSVAR_NULL:
344		return surgescript_objectmanager_null(NULL);
345		case SSVAR_RAW:
	354
	355	default:
346	356	return surgescript_objectmanager_null(NULL);
347	357	}
348	358	}

520	530	case SSVAR_NUMBER: {
521	531	/* encourage users to use approximatelyEqual() */
522	532	/* epsilon comparisons may cause underlying problems, e.g., with infinity */
523		return (a->number > b->number) - (a->number < b->number);
	533	return isgreater(a->number, b->number) - isless(a->number, b->number);
524	534	}
525	535	case SSVAR_RAW:
526	536	return (a->raw > b->raw) - (a->raw < b->raw);

559	569	unsigned long y = surgescript_var_get_objecthandle(b);
560	570	return (x > y) - (x < y);
561	571	}
562		else
563		return 0; /* this shouldn't happen */
564		}
	572	}
	573
	574	/* this shouldn't happen */
	575	return 0;
565	576	}
566	577
567	578	/*

747	758	/* Deallocates a bucket (must be fast) */
748	759	void free_bucket(surgescript_varbucket_t* bucket)
749	760	{
	761	/* can't free if not in use */
	762	ssassert(bucket->in_use);
	763
	764	/* put the bucket back in the pool */
750	765	bucket->in_use = false;
751	766	bucket->next = varpool_currbucket;
752	767	varpool_currbucket = bucket;

+96

-47

src/surgescript/runtime/vm.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2018 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2018, 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

26	26	#include "program_pool.h"
27	27	#include "tag_system.h"
28	28	#include "object_manager.h"
	29	#include "vm_time.h"
29	30	#include "sslib/sslib.h"
30	31	#include "../compiler/parser.h"
31	32	#include "../util/util.h"

61	62	surgescript_objectmanager_t* object_manager;
62	63	surgescript_parser_t* parser;
63	64	surgescript_vmargs_t* args;
64		double start_time;
	65	surgescript_vmtime_t* time;
	66	bool is_paused;
65	67	};
66	68
67	69	/* misc */
68		static void create_vm_components(surgescript_vm_t* vm);
69		static void destroy_vm_components(surgescript_vm_t* vm);
70		static void setup_sslib(surgescript_vm_t* vm);
	70	static void init_vm(surgescript_vm_t* vm);
	71	static void release_vm(surgescript_vm_t* vm);
71	72	static bool call_updater1(surgescript_object_t* object, void* updater);
72	73	static bool call_updater2(surgescript_object_t* object, void* updater);
73	74	static bool call_updater3(surgescript_object_t* object, void* updater);

88	89	/* set up the VM */
89	90	sslog("Creating the VM...");
90	91	surgescript_var_init_pool();
91		create_vm_components(vm);
92		setup_sslib(vm);
	92	init_vm(vm);
93	93
94	94	/* done! */
95	95	return vm;

102	102	surgescript_vm_t* surgescript_vm_destroy(surgescript_vm_t* vm)
103	103	{
104	104	sslog("Shutting down the VM...");
105		destroy_vm_components(vm);
	105	release_vm(vm);
106	106	surgescript_var_release_pool();
107	107	return ssfree(vm);
108	108	}

118	118	if(surgescript_vm_is_active(vm)) {
119	119	/* shut down */
120	120	sslog("Shutting down the VM...");
121		destroy_vm_components(vm);
	121	release_vm(vm);
122	122	surgescript_var_release_pool();
123	123
124	124	/* set up the VM again */
125	125	sslog("Starting the VM again...");
126	126	surgescript_var_init_pool();
127		create_vm_components(vm);
128		setup_sslib(vm);
	127	init_vm(vm);
129	128
130	129	/* done */
131	130	return true;

193	192
194	193	/*
195	194	* surgescript_vm_is_active()
196		* Is the VM active?
	195	* Is the VM active? (i.e., turned ON)
197	196	*/
198	197	bool surgescript_vm_is_active(surgescript_vm_t* vm)
199	198	{

203	202
204	203	/*
205	204	* surgescript_vm_update()
206		* Updates the VM
	205	* Updates the VM. Returns true if the VM is active after this update cycle
207	206	*/
208	207	bool surgescript_vm_update(surgescript_vm_t* vm)
209	208	{
210		if(surgescript_vm_is_active(vm)) {
211		surgescript_object_t* root = surgescript_vm_root_object(vm);
212		surgescript_object_traverse_tree(root, surgescript_object_update);
213		return surgescript_vm_is_active(vm);
214		}
215		else
216		return false;
	209	return surgescript_vm_update_ex(vm, NULL, NULL, NULL);
217	210	}
218	211
219	212	/*
220	213	* surgescript_vm_update_ex()
221		* Updates the VM, allowing user-defined callbacks as well
	214	* Updates the VM, allowing user-defined callbacks as well.
	215	* Returns true if the VM is active after this update cycle
222	216	*/
223	217	bool surgescript_vm_update_ex(surgescript_vm_t* vm, void* user_data, void (user_update)(surgescript_object_t,void), void (late_update)(surgescript_object_t,void))
224	218	{
225		if(surgescript_vm_is_active(vm)) {
	219	if(surgescript_vm_is_active(vm) && !vm->is_paused) {
226	220	surgescript_object_t* root = surgescript_vm_root_object(vm);
227	221	surgescript_vm_updater_t updater = { user_data, user_update, late_update };
	222
	223	/* update time */
	224	surgescript_vmtime_update(vm->time);
228	225
229	226	/* update */
230	227	if(user_update != NULL && late_update != NULL)

239	236	/* done! */
240	237	return surgescript_vm_is_active(vm);
241	238	}
242		else
243		return false;
	239	else {
	240	/* return true if the VM is still on */
	241	return surgescript_vm_is_active(vm);
	242	}
244	243	}
245	244
246	245	/*
247	246	* surgescript_vm_terminate()
248		* terminates the vm
	247	* Terminates the vm
249	248	*/
250	249	void surgescript_vm_terminate(surgescript_vm_t* vm)
251	250	{

254	253	}
255	254
256	255	/*
	256	* surgescript_vm_pause()
	257	* Pauses the VM, so that surgescript_vm_update_ex() does not update any objects
	258	*/
	259	void surgescript_vm_pause(surgescript_vm_t* vm)
	260	{
	261	/* nothing to do */
	262	if(vm->is_paused)
	263	return;
	264
	265	/* pause the VM */
	266	surgescript_vmtime_pause(vm->time);
	267	vm->is_paused = true;
	268	}
	269
	270	/*
	271	* surgescript_vm_resume()
	272	* Resumes a paused VM
	273	*/
	274	void surgescript_vm_resume(surgescript_vm_t* vm)
	275	{
	276	/* nothing to do */
	277	if(!vm->is_paused)
	278	return;
	279
	280	/* pause the VM */
	281	surgescript_vmtime_resume(vm->time);
	282	vm->is_paused = false;
	283	}
	284
	285	/*
	286	* surgescript_vm_is_paused()
	287	* Is the VM paused?
	288	*/
	289	bool surgescript_vm_is_paused(const surgescript_vm_t* vm)
	290	{
	291	return vm->is_paused;
	292	}
	293
	294	/*
257	295	* surgescript_vm_programpool()
258	296	* Gets the program pool
259	297	*/

293	331	* surgescript_vm_args()
294	332	* Gets the command-line arguments
295	333	*/
296		surgescript_vmargs_t* surgescript_vm_args(const surgescript_vm_t* vm)
	334	const surgescript_vmargs_t* surgescript_vm_args(const surgescript_vm_t* vm)
297	335	{
298	336	return vm->args;
	337	}
	338
	339	/*
	340	* surgescript_vm_time()
	341	* Gets the VM time
	342	*/
	343	const surgescript_vmtime_t* surgescript_vm_time(const surgescript_vm_t* vm)
	344	{
	345	return vm->time;
299	346	}
300	347
301	348	/*

352	399
353	400	/* ----- private ----- */
354	401
355		/* creates the VM components */
356		void create_vm_components(surgescript_vm_t* vm)
357		{
358		vm->start_time = 0.0;
	402	/* initializes the VM */
	403	void init_vm(surgescript_vm_t* vm)
	404	{
	405	vm->is_paused = false;
	406
	407	/* create the VM components */
359	408	vm->stack = surgescript_stack_create();
360	409	vm->program_pool = surgescript_programpool_create();
361	410	vm->tag_system = surgescript_tagsystem_create();
362	411	vm->args = surgescript_vmargs_create();
363		vm->object_manager = surgescript_objectmanager_create(vm->program_pool, vm->tag_system, vm->stack, vm->args);
	412	vm->time = surgescript_vmtime_create();
	413	vm->object_manager = surgescript_objectmanager_create(vm->program_pool, vm->tag_system, vm->stack, vm->args, vm->time);
364	414	vm->parser = surgescript_parser_create(vm->program_pool, vm->tag_system);
365		}
366
367		/* destroys the VM components */
368		void destroy_vm_components(surgescript_vm_t* vm)
369		{
370		surgescript_parser_destroy(vm->parser);
371		surgescript_objectmanager_destroy(vm->object_manager);
372		surgescript_vmargs_destroy(vm->args);
373		surgescript_tagsystem_destroy(vm->tag_system);
374		surgescript_programpool_destroy(vm->program_pool);
375		surgescript_stack_destroy(vm->stack);
376		}
377
378		/* load the SurgeScript library */
379		void setup_sslib(surgescript_vm_t* vm)
380		{
	415
	416	/* load the SurgeScript standard library */
381	417	surgescript_sslib_register_object(vm);
382	418	surgescript_sslib_register_string(vm);
383	419	surgescript_sslib_register_number(vm);

398	434	surgescript_sslib_register_system(vm);
399	435	}
400	436
	437	/* releases the VM */
	438	void release_vm(surgescript_vm_t* vm)
	439	{
	440	/* destroy the VM components */
	441	surgescript_parser_destroy(vm->parser);
	442	surgescript_objectmanager_destroy(vm->object_manager);
	443	surgescript_vmtime_destroy(vm->time);
	444	surgescript_vmargs_destroy(vm->args);
	445	surgescript_tagsystem_destroy(vm->tag_system);
	446	surgescript_programpool_destroy(vm->program_pool);
	447	surgescript_stack_destroy(vm->stack);
	448	}
	449
401	450	/* these auxiliary functions help traversing the object tree */
402	451	bool call_updater1(surgescript_object_t* object, void* updater)
403	452	{

+12

-6

src/surgescript/runtime/vm.h less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2018 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2018, 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

21	21	#ifndef _SURGESCRIPT_RUNTIME_VM_H
22	22	#define _SURGESCRIPT_RUNTIME_VM_H
23	23
	24	#include <stdint.h>
24	25	#include <stdbool.h>
25	26	#include "program.h"
26	27	#include "object.h"
27	28
28	29	/* types */
29	30	typedef struct surgescript_vm_t surgescript_vm_t;
30		struct surgescript_vmargs_t;
31	31	struct surgescript_parser_t;
32	32	struct surgescript_programpool_t;
	33	struct surgescript_objectmanager_t;
33	34	struct surgescript_tagsystem_t;
34		struct surgescript_objectmanager_t;
	35	struct surgescript_vmargs_t;
	36	struct surgescript_vmtime_t;
35	37
36	38	/* api */
37	39	surgescript_vm_t* surgescript_vm_create();

42	44	bool surgescript_vm_compile_code_in_memory(surgescript_vm_t* vm, const char* code); /* compiles the given code */
43	45
44	46	/* VM lifecycle */
45		bool surgescript_vm_is_active(surgescript_vm_t* vm); /* is the vm active? */
	47	bool surgescript_vm_is_active(surgescript_vm_t* vm); /* is the vm active? (i.e., turned on) */
46	48	void surgescript_vm_launch(surgescript_vm_t* vm); /* boots up the vm */
47	49	void surgescript_vm_launch_ex(surgescript_vm_t* vm, int argc, char** argv); /* boots up the vm with command line arguments */
48	50	void surgescript_vm_terminate(surgescript_vm_t* vm); /* terminates the vm */
	51	bool surgescript_vm_reset(surgescript_vm_t* vm); /* resets the VM, clearing up all its programs and objects */
49	52	bool surgescript_vm_update(surgescript_vm_t* vm); /* updates the vm */
50	53	bool surgescript_vm_update_ex(surgescript_vm_t* vm, void* user_data, void (user_update)(surgescript_object_t,void), void (late_update)(surgescript_object_t,void)); /* updates the vm and allows more callbacks */
	54	void surgescript_vm_pause(surgescript_vm_t* vm); /* pause the VM */
	55	void surgescript_vm_resume(surgescript_vm_t* vm); /* resume a paused VM */
	56	bool surgescript_vm_is_paused(const surgescript_vm_t* vm); /* is the VM paused? */
51	57
52	58	/* VM components */
53	59	struct surgescript_programpool_t* surgescript_vm_programpool(const surgescript_vm_t* vm); /* gets the program pool */
54	60	struct surgescript_tagsystem_t* surgescript_vm_tagsystem(const surgescript_vm_t* vm); /* gets the tag system */
55	61	struct surgescript_objectmanager_t* surgescript_vm_objectmanager(const surgescript_vm_t* vm); /* gets the object manager */
56	62	struct surgescript_parser_t* surgescript_vm_parser(const surgescript_vm_t* vm); /* gets the parser */
57		struct surgescript_vmargs_t* surgescript_vm_args(const surgescript_vm_t* vm); /* gets the command-line arguments */
	63	const struct surgescript_vmargs_t* surgescript_vm_args(const surgescript_vm_t* vm); /* gets the command-line arguments */
	64	const struct surgescript_vmtime_t* surgescript_vm_time(const surgescript_vm_t* vm); /* gets the VM time */
58	65
59	66	/* utilities */
60	67	surgescript_object_t* surgescript_vm_root_object(surgescript_vm_t* vm); /* root object */

62	69	surgescript_object_t* surgescript_vm_find_object(surgescript_vm_t* vm, const char* object_name); /* finds an object */
63	70	void surgescript_vm_bind(surgescript_vm_t* vm, const char* object_name, const char* fun_name, surgescript_program_cfunction_t cfun, int num_params); /* binds a C function to an object */
64	71	void surgescript_vm_install_plugin(surgescript_vm_t* vm, const char* object_name); /* sets a certain object as a plugin */
65		bool surgescript_vm_reset(surgescript_vm_t* vm); /* resets a VM, clearing up all its programs and objects */
66	72
67	73	#endif

+114

-0

src/surgescript/runtime/vm_time.c less more

	0	/*
	1	* SurgeScript
	2	* A scripting language for games
	3	* Copyright 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
	4	*
	5	* Licensed under the Apache License, Version 2.0 (the "License");
	6	* you may not use this file except in compliance with the License.
	7	* You may obtain a copy of the License at
	8	*
	9	* http://www.apache.org/licenses/LICENSE-2.0
	10	*
	11	* Unless required by applicable law or agreed to in writing, software
	12	* distributed under the License is distributed on an "AS IS" BASIS,
	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	14	* See the License for the specific language governing permissions and
	15	* limitations under the License.
	16	*
	17	* runtime/vm_time.c
	18	* SurgeScript Virtual Machine Time - this is used to count time
	19	*/
	20
	21	#include "vm_time.h"
	22	#include "../util/util.h"
	23
	24	/* VM time */
	25	struct surgescript_vmtime_t {
	26	uint64_t time; /* in ms */
	27	uint64_t ticks_at_last_update;
	28	bool is_paused;
	29	};
	30
	31	/*
	32	* surgescript_vmtime_create()
	33	* Create a VM time object
	34	*/
	35	surgescript_vmtime_t* surgescript_vmtime_create()
	36	{
	37	surgescript_vmtime_t* vmtime = ssmalloc(sizeof *vmtime);
	38
	39	vmtime->time = 0;
	40	vmtime->ticks_at_last_update = surgescript_util_gettickcount();
	41	vmtime->is_paused = false;
	42
	43	return vmtime;
	44	}
	45
	46	/*
	47	* surgescript_vmtime_destroy()
	48	* Destroy a VM time object
	49	*/
	50	surgescript_vmtime_t* surgescript_vmtime_destroy(surgescript_vmtime_t* vmtime)
	51	{
	52	ssfree(vmtime);
	53	return NULL;
	54	}
	55
	56	/*
	57	* surgescript_vmtime_update()
	58	* Update the VM time object
	59	*/
	60	void surgescript_vmtime_update(surgescript_vmtime_t* vmtime)
	61	{
	62	uint64_t now = surgescript_util_gettickcount();
	63	uint64_t delta_time = now > vmtime->ticks_at_last_update ? now - vmtime->ticks_at_last_update : 0;
	64	vmtime->time += vmtime->is_paused ? 0 : delta_time;
	65	vmtime->ticks_at_last_update = now;
	66	}
	67
	68	/*
	69	* surgescript_vmtime_pause()
	70	* Pause the VM time
	71	*/
	72	void surgescript_vmtime_pause(surgescript_vmtime_t* vmtime)
	73	{
	74	/* nothing to do */
	75	if(vmtime->is_paused)
	76	return;
	77
	78	/* pause the time */
	79	vmtime->is_paused = true;
	80	}
	81
	82	/*
	83	* surgescript_vmtime_resume()
	84	* Resume the VM time
	85	*/
	86	void surgescript_vmtime_resume(surgescript_vmtime_t* vmtime)
	87	{
	88	/* nothing to do */
	89	if(!vmtime->is_paused)
	90	return;
	91
	92	/* resume the time */
	93	vmtime->ticks_at_last_update = surgescript_util_gettickcount();
	94	vmtime->is_paused = false;
	95	}
	96
	97	/*
	98	* surgescript_vmtime_time()
	99	* Get the time, in milliseconds, at the beginning of the current update cycle
	100	*/
	101	uint64_t surgescript_vmtime_time(const surgescript_vmtime_t* vmtime)
	102	{
	103	return vmtime->time;
	104	}
	105
	106	/*
	107	* surgescript_vmtime_is_paused()
	108	* Is the VM time paused?
	109	*/
	110	bool surgescript_vmtime_is_paused(const surgescript_vmtime_t* vmtime)
	111	{
	112	return vmtime->is_paused;
	113	}⏎

+40

-0

src/surgescript/runtime/vm_time.h less more

	0	/*
	1	* SurgeScript
	2	* A scripting language for games
	3	* Copyright 2021 Alexandre Martins <alemartf(at)gmail(dot)com>
	4	*
	5	* Licensed under the Apache License, Version 2.0 (the "License");
	6	* you may not use this file except in compliance with the License.
	7	* You may obtain a copy of the License at
	8	*
	9	* http://www.apache.org/licenses/LICENSE-2.0
	10	*
	11	* Unless required by applicable law or agreed to in writing, software
	12	* distributed under the License is distributed on an "AS IS" BASIS,
	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	14	* See the License for the specific language governing permissions and
	15	* limitations under the License.
	16	*
	17	* runtime/vm_time.h
	18	* SurgeScript Virtual Machine Time - this is used to count time
	19	*/
	20
	21	#ifndef _SURGESCRIPT_RUNTIME_VM_TIME_H
	22	#define _SURGESCRIPT_RUNTIME_VM_TIME_H
	23
	24	#include <stdint.h>
	25	#include <stdbool.h>
	26
	27	typedef struct surgescript_vmtime_t surgescript_vmtime_t;
	28
	29	surgescript_vmtime_t* surgescript_vmtime_create(); /* create a VM time object */
	30	surgescript_vmtime_t* surgescript_vmtime_destroy(surgescript_vmtime_t* vmtime); /* destroy a VM time object */
	31
	32	void surgescript_vmtime_update(surgescript_vmtime_t* vmtime); /* update the VM time object */
	33	void surgescript_vmtime_pause(surgescript_vmtime_t* vmtime); /* pause the VM time */
	34	void surgescript_vmtime_resume(surgescript_vmtime_t* vmtime); /* resume the VM time */
	35
	36	uint64_t surgescript_vmtime_time(const surgescript_vmtime_t* vmtime); /* the time at the beginning of the current update cycle */
	37	bool surgescript_vmtime_is_paused(const surgescript_vmtime_t* vmtime); /* is the VM time paused? */
	38
	39	#endif⏎

+1

-1

src/surgescript/util/ssarray.h less more

27	27	* SSARRAY()
28	28	* declares an array of a certain type
29	29	*/
30		#define SSARRAY(type, arr) type* arr; size_t arr##_len, arr##_cap;
	30	#define SSARRAY(type, arr) type* arr; size_t arr##_len, arr##_cap
31	31
32	32	/*
33	33	* ssarray_init()

+18

-15

src/surgescript/util/util.c less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2020 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

34	34	#endif
35	35
36	36	/* private stuff */
37		static void mem_crash(const char* location);
	37	static void mem_crash(const char* file, int line);
38	38	static void my_log(const char* message);
39	39	static void my_fatal(const char* message);
40	40	static void (log_function)(const char message) = my_log;

50	50	* surgescript_util_malloc()
51	51	* Memory allocation routine
52	52	*/
53		void* surgescript_util_malloc(size_t bytes, const char* location)
	53	void* surgescript_util_malloc(size_t bytes, const char* file, int line)
54	54	{
55	55	void *m = malloc(bytes);
56	56
57	57	if(m == NULL)
58		mem_crash(location);
	58	mem_crash(file, line);
59	59
60	60	return m;
61	61	}

64	64	* surgescript_util_realloc()
65	65	* Memory reallocation routine
66	66	*/
67		void* surgescript_util_realloc(void* ptr, size_t bytes, const char* location)
	67	void* surgescript_util_realloc(void* ptr, size_t bytes, const char* file, int line)
68	68	{
69	69	void *m = realloc(ptr, bytes);
70	70
71	71	if(m == NULL)
72		mem_crash(location);
	72	mem_crash(file, line);
73	73
74	74	return m;
75	75	}

80	80	*/
81	81	void* surgescript_util_free(void* ptr)
82	82	{
83		if(ptr)
	83	if(ptr != NULL)
84	84	free(ptr);
85	85
86	86	return NULL;

219	219	* surgescript_util_strdup()
220	220	* Copies a string into another, allocating the required memory
221	221	*/
222		char* surgescript_util_strdup(const char* src, const char* location)
223		{
224		char* str = surgescript_util_malloc(sizeof(char) * (1 + strlen(src)), location);
	222	char* surgescript_util_strdup(const char* src, const char* file, int line)
	223	{
	224	char* str = surgescript_util_malloc(sizeof(char) * (1 + strlen(src)), file, line);
225	225	return strcpy(str, src);
226	226	}
227	227

377	377	fprintf(stderr, "%s\n", message);
378	378	}
379	379
380		void mem_crash(const char* location) /* out of memory error */
381		{
382		static char buf[128] = "Out of memory in ";
383		surgescript_util_strncpy(buf + 17, location, sizeof(buf) - 17);
	380	void mem_crash(const char* file, int line) /* out of memory error */
	381	{
	382	static char buf[1024] = "Out of memory in ";
	383	static const int prefix_len = 17;
	384
	385	snprintf(buf + prefix_len, sizeof(buf) - prefix_len, "%s:%d", file, line);
384	386	fatal_function(buf);
	387
385	388	exit(1); /* just in case */
386		}
	389	}⏎

+8

-8

src/surgescript/util/util.h less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2020 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

32	32	#define sssign(x) ((x) >= 0 ? 1 : -1)
33	33	#define sstok(x) #x
34	34	#define ssstr(x) sstok(x)
35		#define ssassert(expr) do { if(!(expr)) ssfatal("%s", "In " __FILE__ ":" ssstr(__LINE__) ": assertion `" sstok(expr) "` failed."); } while(0)
	35	#define ssassert(expr) do { if(!(expr)) ssfatal("In %s:%d: %s", __FILE__, __LINE__, ": assertion `" sstok(expr) "` failed."); } while(0)
36	36
37	37	/* common aliases */
38		#define ssmalloc(n) surgescript_util_malloc((n), __FILE__ ":" ssstr(__LINE__))
39		#define ssrealloc(p, n) surgescript_util_realloc((p), (n), __FILE__ ":" ssstr(__LINE__))
	38	#define ssmalloc(n) surgescript_util_malloc((n), __FILE__, __LINE__)
	39	#define ssrealloc(p, n) surgescript_util_realloc((p), (n), __FILE__, __LINE__)
40	40	#define ssfree surgescript_util_free
41	41	#define sslog surgescript_util_log
42	42	#define ssfatal surgescript_util_fatal
43		#define ssstrdup(str) surgescript_util_strdup((str), __FILE__ ":" ssstr(__LINE__))
	43	#define ssstrdup(str) surgescript_util_strdup((str), __FILE__, __LINE__)
44	44
45	45	/* constants */
46	46	#define SS_NAMEMAX 63 /* names can't be larger than this (computes hashes quickly) */

52	52	const char* surgescript_util_website(); /* project website */
53	53	const char* surgescript_util_authors(); /* project authors */
54	54
55		void* surgescript_util_malloc(size_t bytes, const char* location); /* memory allocation */
56		void* surgescript_util_realloc(void* ptr, size_t bytes, const char* location); /* memory reallocation */
	55	void* surgescript_util_malloc(size_t bytes, const char* file, int line); /* memory allocation */
	56	void* surgescript_util_realloc(void* ptr, size_t bytes, const char* file, int line); /* memory reallocation */
57	57	void* surgescript_util_free(void* ptr); /* memory deallocation */
58	58
59	59	void surgescript_util_log(const char* fmt, ...); /* logs a message */

61	61	void surgescript_util_set_error_functions(void (log)(const char), void (fatal)(const char)); /* set custom error functions */
62	62
63	63	char* surgescript_util_strncpy(char* dst, const char* src, size_t n); /* strcpy */
64		char* surgescript_util_strdup(const char* src, const char* location); /* strdup */
	64	char* surgescript_util_strdup(const char* src, const char* file, int line); /* strdup */
65	65	const char* surgescript_util_basename(const char* path); /* basename */
66	66	char* surgescript_util_accessorfun(const char* prefix, const char* text); /* getter/setter prefixing function */
67	67

+57

-0

src/surgescript/util/version.h.in less more

	0	/*
	1	* SurgeScript
	2	* A scripting language for games
	3	* Copyright 2016-2021 Alexandre Martins <alemartf(at)gmail(dot)com>
	4	*
	5	* Licensed under the Apache License, Version 2.0 (the "License");
	6	* you may not use this file except in compliance with the License.
	7	* You may obtain a copy of the License at
	8	*
	9	* http://www.apache.org/licenses/LICENSE-2.0
	10	*
	11	* Unless required by applicable law or agreed to in writing, software
	12	* distributed under the License is distributed on an "AS IS" BASIS,
	13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	14	* See the License for the specific language governing permissions and
	15	* limitations under the License.
	16	*
	17	* util/version.h
	18	* SurgeScript version: available at compile time
	19	*/
	20
	21	#ifndef _SURGESCRIPT_VERSION_H
	22	#define _SURGESCRIPT_VERSION_H
	23
	24	/* Import SurgeScript version */
	25	#define SURGESCRIPT_VERSION_SUP @PROJECT_VERSION_MAJOR@
	26	#define SURGESCRIPT_VERSION_SUB @PROJECT_VERSION_MINOR@
	27	#define SURGESCRIPT_VERSION_WIP @PROJECT_VERSION_PATCH@
	28	#cmakedefine SURGESCRIPT_VERSION_FIX @PROJECT_VERSION_TWEAK@
	29
	30	#if !defined(SURGESCRIPT_VERSION_FIX)
	31	#define SURGESCRIPT_VERSION_FIX 0
	32	#endif
	33
	34	/* Generate version string */
	35	#define SURGESCRIPT_VERSION_STR "@PROJECT_VERSION@"
	36
	37	/* Convert a version tuple into an integer */
	38	#define SURGESCRIPT_VERSION_CODE(x, y, z, w) \
	39	(((x) << 24) \| ((y) << 16) \| ((z) << 8) \| (w))
	40
	41	/* Compare a version tuple to the current version of SurgeScript */
	42	#define SURGESCRIPT_VERSION_COMPARE(x, y, z, w) ( \
	43	SURGESCRIPT_VERSION_CODE( \
	44	SURGESCRIPT_VERSION_SUP, \
	45	SURGESCRIPT_VERSION_SUB, \
	46	SURGESCRIPT_VERSION_WIP, \
	47	SURGESCRIPT_VERSION_FIX \
	48	) - \
	49	SURGESCRIPT_VERSION_CODE((x), (y), (z), (w)) \
	50	)
	51
	52	/* Check if the current version of SurgeScript is x.y.z.w or newer */
	53	#define SURGESCRIPT_VERSION_IS_AT_LEAST(x, y, z, w) \
	54	(SURGESCRIPT_VERSION_COMPARE((x), (y), (z), (w)) >= 0)
	55
	56	#endif⏎

+5

-3

src/surgescript.h less more

0	0	/*
1	1	* SurgeScript
2	2	* A scripting language for games
3		* Copyright 2016-2020 Alexandre Martins <alemartf(at)gmail(dot)com>
	3	* Copyright 2016-2021 Alexandre Martins <alemartf(at)gmail(dot)com>
4	4	*
5	5	* Licensed under the Apache License, Version 2.0 (the "License");
6	6	* you may not use this file except in compliance with the License.

29	29	#include "surgescript/runtime/program.h"
30	30	#include "surgescript/runtime/object.h"
31	31	#include "surgescript/runtime/program_pool.h"
	32	#include "surgescript/runtime/object_manager.h"
32	33	#include "surgescript/runtime/tag_system.h"
33		#include "surgescript/runtime/object_manager.h"
	34	#include "surgescript/runtime/vm_time.h"
34	35	#include "surgescript/runtime/heap.h"
35	36	#include "surgescript/runtime/stack.h"
36	37	#include "surgescript/runtime/variable.h"

38	39	#include "surgescript/util/transform.h"
39	40	#include "surgescript/util/ssarray.h"
40	41	#include "surgescript/util/util.h"
	42	#include "surgescript/util/version.h"
41	43
42	44	#ifdef __cplusplus
43	45	}
44	46	#endif
45	47
46		#endif⏎
	48	#endif