├── LICENSE
├── Examples
    ├── Figure.sk
    └── Hand.sk
├── README.md
└── sk.gml


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 Nik Sudan
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Examples/Figure.sk:
--------------------------------------------------------------------------------
  1 | [Skeleton]
  2 | id=Figure
  3 | joints=17
  4 | 
  5 | [1]
  6 | parent=0
  7 | xoffset=0
  8 | yoffset=-64
  9 | clampmin=-14.0362434679265
 10 | clampmax=14.0362434679265
 11 | 
 12 | [2]
 13 | parent=1
 14 | xoffset=0
 15 | yoffset=-64
 16 | clampmin=-14.0362434679265
 17 | clampmax=14.0362434679265
 18 | 
 19 | [3]
 20 | parent=2
 21 | xoffset=32
 22 | yoffset=0
 23 | clampmin=0
 24 | clampmax=0
 25 | 
 26 | [4]
 27 | parent=2
 28 | xoffset=-32
 29 | yoffset=0
 30 | clampmin=0
 31 | clampmax=0
 32 | 
 33 | [5]
 34 | parent=4
 35 | xoffset=-64
 36 | yoffset=0
 37 | clampmin=-63.434948822922
 38 | clampmax=56.3099324740202
 39 | 
 40 | [6]
 41 | parent=3
 42 | xoffset=64
 43 | yoffset=0
 44 | clampmin=-75.9637565320735
 45 | clampmax=63.434948822922
 46 | 
 47 | [7]
 48 | parent=6
 49 | xoffset=64
 50 | yoffset=0
 51 | clampmin=0
 52 | clampmax=104.036243467926
 53 | 
 54 | [8]
 55 | parent=5
 56 | xoffset=-64
 57 | yoffset=0
 58 | clampmin=-135
 59 | clampmax=0
 60 | 
 61 | [9]
 62 | parent=0
 63 | xoffset=-16
 64 | yoffset=0
 65 | clampmin=0
 66 | clampmax=0
 67 | 
 68 | [10]
 69 | parent=0
 70 | xoffset=16
 71 | yoffset=0
 72 | clampmin=0
 73 | clampmax=0
 74 | 
 75 | [11]
 76 | parent=10
 77 | xoffset=0
 78 | yoffset=64
 79 | clampmin=0
 80 | clampmax=45
 81 | 
 82 | [12]
 83 | parent=9
 84 | xoffset=0
 85 | yoffset=64
 86 | clampmin=-53.1301023541559
 87 | clampmax=0
 88 | 
 89 | [13]
 90 | parent=12
 91 | xoffset=0
 92 | yoffset=64
 93 | clampmin=0
 94 | clampmax=90
 95 | 
 96 | [14]
 97 | parent=11
 98 | xoffset=0
 99 | yoffset=64
100 | clampmin=-90
101 | clampmax=0
102 | 
103 | [15]
104 | parent=2
105 | xoffset=0
106 | yoffset=-16
107 | clampmin=-26.565051177078
108 | clampmax=26.565051177078
109 | 
110 | [16]
111 | parent=15
112 | xoffset=0
113 | yoffset=-16
114 | clampmin=0
115 | clampmax=0
116 | 
117 | 


--------------------------------------------------------------------------------
/Examples/Hand.sk:
--------------------------------------------------------------------------------
  1 | [Skeleton]
  2 | id=Hand
  3 | joints=22
  4 | 
  5 | [1]
  6 | parent=0
  7 | xoffset=2
  8 | yoffset=-50
  9 | clampmin=-42.7093899573615
 10 | clampmax=47.2906100426385
 11 | 
 12 | [2]
 13 | parent=1
 14 | xoffset=-44
 15 | yoffset=-39
 16 | clampmin=0
 17 | clampmax=0
 18 | 
 19 | [3]
 20 | parent=1
 21 | xoffset=-14
 22 | yoffset=-33
 23 | clampmin=0
 24 | clampmax=0
 25 | 
 26 | [4]
 27 | parent=1
 28 | xoffset=6
 29 | yoffset=-32
 30 | clampmin=0
 31 | clampmax=0
 32 | 
 33 | [5]
 34 | parent=1
 35 | xoffset=31
 36 | yoffset=-28
 37 | clampmin=0
 38 | clampmax=0
 39 | 
 40 | [6]
 41 | parent=1
 42 | xoffset=45
 43 | yoffset=-17
 44 | clampmin=0
 45 | clampmax=0
 46 | 
 47 | [7]
 48 | parent=2
 49 | xoffset=-15
 50 | yoffset=-38
 51 | clampmin=0
 52 | clampmax=0
 53 | 
 54 | [8]
 55 | parent=7
 56 | xoffset=-1
 57 | yoffset=-40
 58 | clampmin=0
 59 | clampmax=0
 60 | 
 61 | [9]
 62 | parent=3
 63 | xoffset=16
 64 | yoffset=-63
 65 | clampmin=0
 66 | clampmax=0
 67 | 
 68 | [10]
 69 | parent=9
 70 | xoffset=-2
 71 | yoffset=-46
 72 | clampmin=0
 73 | clampmax=0
 74 | 
 75 | [11]
 76 | parent=10
 77 | xoffset=-12
 78 | yoffset=-48
 79 | clampmin=0
 80 | clampmax=0
 81 | 
 82 | [12]
 83 | parent=4
 84 | xoffset=22
 85 | yoffset=-53
 86 | clampmin=0
 87 | clampmax=0
 88 | 
 89 | [13]
 90 | parent=12
 91 | xoffset=-2
 92 | yoffset=-54
 93 | clampmin=0
 94 | clampmax=0
 95 | 
 96 | [14]
 97 | parent=13
 98 | xoffset=-11
 99 | yoffset=-50
100 | clampmin=0
101 | clampmax=0
102 | 
103 | [15]
104 | parent=5
105 | xoffset=20
106 | yoffset=-51
107 | clampmin=0
108 | clampmax=0
109 | 
110 | [16]
111 | parent=15
112 | xoffset=2
113 | yoffset=-53
114 | clampmin=0
115 | clampmax=0
116 | 
117 | [17]
118 | parent=16
119 | xoffset=-10
120 | yoffset=-40
121 | clampmin=0
122 | clampmax=0
123 | 
124 | [18]
125 | parent=6
126 | xoffset=29
127 | yoffset=-53
128 | clampmin=0
129 | clampmax=0
130 | 
131 | [19]
132 | parent=18
133 | xoffset=11
134 | yoffset=-49
135 | clampmin=0
136 | clampmax=0
137 | 
138 | [20]
139 | parent=19
140 | xoffset=-3
141 | yoffset=-31
142 | clampmin=0
143 | clampmax=0
144 | 
145 | [21]
146 | parent=8
147 | xoffset=10
148 | yoffset=-20
149 | clampmin=0
150 | clampmax=0
151 | 
152 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <p align="center">
 2 |     <img src="http://i.imgur.com/gagL1bk.png" alt="Game Maker skeleton system" width="350" title="Credit to Michael Blue" />
 3 | </a>
 4 | 
 5 | <h1 align="center">sk</h1>
 6 | 
 7 | sk is an easy to use skeletal system for [Game Maker](http://yoyogames.com) Language by Nik Sudan. Please give credit when used, that's all I ask of you!
 8 | 
 9 | Massive thanks to [Michael Savchuk](https://twitter.com/ThePixelRobin) for the sk icon!
10 | 
11 | ![Demo](http://i.imgur.com/twQfr0Q.gif)
12 | 
13 | ## Creating Skeletons
14 | 
15 | You cannot define a skeleton within Game Maker, sk loads in skeletons externally, using .sk files. These are structured like .ini files, and contain information about each joint's properties. [A GUI for creating skeletons is available on itch.io for a very small fee for Windows only](http://nik.itch.io/sk-creator).
16 | 
17 | ![GUI](http://i.imgur.com/ktp9Kwz.png)
18 | 
19 | ## Setting Up The Skeleton
20 | 
21 | Simply import the .gml file into your project - preferably a folder within your scripts. Nothing else is needed with you and the scripts, you're done.
22 | 
23 | Skeletons are loaded using <code>sk_import</code> and return the skeleton's data for use with skeleton systems. This way you can load one skeleton that'll be used by loads of entities. Calling this in the **Game Start** or **Room Start** events are recommended. Use this function:
24 | 
25 |     data = sk_import('pathToFile');
26 |     
27 | Once you've initialised the skeleton, you can now use with objects. You can set an object to become a skeleton by using the following function in it's **Create** event:
28 | 
29 |     sk_create( data );
30 |     
31 | Now you've set it up, but the skeleton won't move. You need to update it, and this can be done with the **Begin Step** event. You can use an **Alarm** event if you want to call it less often, but it's a lot smoother when you don't do that. Simply call this function:
32 | 
33 |     sk_update();
34 |     
35 | And that's it!
36 | 
37 | ## Making Joints Move
38 | 
39 | I take it you want to manipulate the joints and give it a cool, smooth animation. You can move a joint by calling the following function:
40 | 
41 |     sk_setTargetAngle( jointID, angle );
42 |     
43 | The angle the skeleton is imported in at will be the zero value for <code>angle</code>. You can find out the <code>jointID</code> from your sk file or the creator.
44 | 
45 | **Note:** There is a function called <code>sk_setAngle()</code> in the library - this will immediately change the angle of the joint. The joint will move back to the target angle after you call this, so don't use it for animation.
46 | 
47 | You can then set the rotation speed of the joint with the following function:
48 | 
49 |     sk_setRotationSpeed( jointID, speed );
50 | 
51 | The bigger the <code>speed</code> is, the faster it'll move (duh).
52 | 
53 | ## Drawing Stuff
54 | 
55 | Ok, you'll want to see your skeleton, right? You can call a little debugging function to see the skeleton in action:
56 | 
57 |     sk_draw();
58 |     
59 | I wouldn't recommend using that for your final product. You can get the position and angle of each joint by calling these respective functions:
60 | 
61 |     jointX = sk_getX( jointID );
62 |     jointY = sk_gety( jointID );
63 |     jointAngle = sk_getAngle( jointID );
64 |     
65 | Draw whatever you want on these, I won't hold you back.
66 | 
67 | ## Examples Of Use
68 | 
69 | ![Demo](http://i.imgur.com/Yh7LZNp.gif)
70 | 
71 | ![Demo](http://i.imgur.com/pz6awr5.gif)
72 | 
73 | ![Demo](http://i.imgur.com/iT6KS7U.gif)
74 | 
75 | ![Demo](http://i.imgur.com/89flKEe.gif)
76 | 


--------------------------------------------------------------------------------
/sk.gml:
--------------------------------------------------------------------------------
  1 | #define nearestPoint
  2 | ///nearestPoint(x, y)
  3 | //x,y
  4 | near = 0;
  5 | for (i=0; i<ds_list_find_value(data,1); i+=1) {
  6 |     if point_distance(sk_getX(i),sk_getY(i),argument0,argument1) <= point_distance(sk_getX(near),sk_getY(near),argument0,argument1)
  7 |         near = i;
  8 | }
  9 | return near;
 10 | 
 11 | #define pointDirection
 12 | ///pointDirection(x1, y1, x2, y2)
 13 | /*
 14 | 
 15 | argument0   x1
 16 | argument1   y1
 17 | argument2   x2
 18 | argument3   y2
 19 | 
 20 | */
 21 | return ((((arctan2(argument0-argument2,argument1-argument3)* (180/pi))) + 450) mod 360);
 22 | 
 23 | #define sk_create
 24 | ///sk_create(data)
 25 | 
 26 | /***************************************************
 27 |   Create Skeleton Structure
 28 |  ***************************************************
 29 |  
 30 |  sk_create(Skeleton Data);
 31 | 
 32 |  Creates the actual skeleton structure the system uses
 33 | 
 34 |  Reference:
 35 |  
 36 |     Skeleton Structure Data:
 37 |     0   parent
 38 |     1   x
 39 |     2   y
 40 |     3   x offset
 41 |     4   y offset
 42 |     5   angle
 43 |     6   target angle
 44 |     7   rotation speed
 45 |     8   clamp min
 46 |     9   clamp max
 47 | */
 48 | 
 49 | var iData, pData;
 50 | 
 51 | iData = argument0;
 52 | 
 53 | if iData != -1 {
 54 |     pData = ds_list_find_value(iData,2);
 55 |     SK_DATA = ds_grid_create(ds_list_find_value(iData,1),10);
 56 |     SK_SCALE = 1;
 57 |     sk_setX(0,x);
 58 |     sk_setY(0,y);
 59 |     for (i=1; i<ds_list_find_value(iData,1); i+=1) {
 60 |         sk_setX(i,0);
 61 |         sk_setY(i,0);
 62 |     }
 63 |     for (i=0; i<ds_list_find_value(iData,1); i+=1) {
 64 |         sk_setParent(i,ds_grid_get(pData,i,0));
 65 |         sk_setXOffset(i,ds_grid_get(pData,i,1));
 66 |         sk_setYOffset(i,ds_grid_get(pData,i,2));
 67 |         sk_setClampMin(i,ds_grid_get(pData,i,3));
 68 |         sk_setClampMax(i,ds_grid_get(pData,i,4));
 69 |         sk_setAngle(i,0);
 70 |         sk_setTargetAngle(i,0);
 71 |         sk_setRotationSpeed(i,10);
 72 |         
 73 |         sk_updateJoint(i);
 74 |     }
 75 | }
 76 | 
 77 | #define sk_draw
 78 | ///sk_draw()
 79 | 
 80 | /***************************************************
 81 |   Draw Skeleton
 82 |  ***************************************************
 83 |  
 84 |  sk_draw();
 85 |  
 86 |  Draws the skeleton using the Skeleton Structure Data
 87 |  
 88 | */
 89 | 
 90 | var xval, yval, par;
 91 | 
 92 | for (i=0; i<ds_grid_width(SK_DATA); i+=1) {
 93 |     xval = sk_getX(i);
 94 |     yval = sk_getY(i);
 95 |     draw_circle(xval,yval,5,false);
 96 |     if i > 0 {
 97 |         par = sk_getParent(i);
 98 |         draw_line(xval,yval,sk_getX(par),sk_getY(par));
 99 |     }
100 | }
101 | 
102 | #define sk_getAngle
103 | return ds_grid_get(SK_DATA,argument0,5);
104 | 
105 | #define sk_getClampMax
106 | return ds_grid_get(SK_DATA,argument0,9);
107 | 
108 | #define sk_getClampMin
109 | return ds_grid_get(SK_DATA,argument0,8);
110 | 
111 | #define sk_getParent
112 | return ds_grid_get(SK_DATA,argument0,0);
113 | 
114 | #define sk_getRotationSpeed
115 | return ds_grid_get(SK_DATA,argument0,7);
116 | 
117 | #define sk_getTargetAngle
118 | return ds_grid_get(SK_DATA,argument0,6);
119 | 
120 | #define sk_getX
121 | return ds_grid_get(SK_DATA,argument0,1);
122 | 
123 | #define sk_getXOffset
124 | return ds_grid_get(SK_DATA,argument0,3);
125 | 
126 | #define sk_getY
127 | return ds_grid_get(SK_DATA,argument0,2);
128 | 
129 | #define sk_getYOffset
130 | return ds_grid_get(SK_DATA,argument0,4);
131 | 
132 | #define sk_import
133 | ///sk_import(filename)
134 | 
135 | 
136 | /***************************************************
137 |   Import Skeleton Data
138 |  ***************************************************
139 |  
140 |  sk_import(filename);
141 |  Returns: Skeleton Data
142 | 
143 |  Imports a skeleton from a .sk file and converts it to Skeleton Data
144 |  Skeleton Data can be used to create many skeletons
145 |  Skeleton Data is used in sk_create
146 | 
147 |  Reference:
148 |  
149 |     Skeleton Data:
150 |     0   name
151 |     1   number of joints
152 |     2   point data (Point ID, Value ID)
153 |     
154 |     Value ID:
155 |     0   parent (-1 = root joint)
156 |     1   x offset from parent at angle 0
157 |     2   y offset from parent at angle 0
158 |     3   minimum clamp range
159 |     4   maximum clamp range
160 | */
161 | 
162 | var name, noOfJoints, points, data;
163 | 
164 | if file_exists(argument0) {
165 |     ini_open(argument0);
166 |     
167 |     name = ini_read_string("Skeleton","id","Skeleton");
168 |     noOfJoints = ini_read_real("Skeleton","joints",0);
169 |     points = ds_grid_create(noOfJoints,5);
170 |     
171 |     ds_grid_set(points,0,0,-1);
172 |     for (i=1; i<5; i+=1)
173 |         ds_grid_set(points,0,i,0);
174 |     
175 |     for (i=1; i<noOfJoints; i+=1) {
176 |         ds_grid_set(points,i,0,ini_read_real(string(i),"parent",0));
177 |         ds_grid_set(points,i,1,ini_read_real(string(i),"xoffset",0));
178 |         ds_grid_set(points,i,2,ini_read_real(string(i),"yoffset",0));
179 |         ds_grid_set(points,i,3,ini_read_real(string(i),"clampmin",0));
180 |         ds_grid_set(points,i,4,ini_read_real(string(i),"clampmax",0));
181 |     }
182 |     ini_close();
183 |     
184 |     data = ds_list_create();
185 |     ds_list_insert(data,0,name);
186 |     ds_list_insert(data,1,noOfJoints);
187 |     ds_list_insert(data,2,points);
188 |     
189 |     return data;
190 | } else {
191 |     show_message("Error - Could not open skeleton file "+argument0);
192 |     return -1;
193 | }
194 | 
195 | #define sk_pointX
196 | ///sk_pointX(parent x, x offset, y offset, angle)
197 | return ((argument1*cos(degtorad(-argument3)))-(argument2*sin(degtorad(-argument3))))+argument0;
198 | 
199 | #define sk_pointY
200 | ///sk_pointY(parent y, x offset, y offset, angle)
201 | return ((argument1*sin(degtorad(-argument3)))+(argument2*cos(degtorad(-argument3))))+argument0;
202 | 
203 | #define sk_rotate
204 | ///sk_rotate(angle, target, speed)
205 | 
206 | //angle = sk_rotate(angle,target angle,speed)
207 | return (argument0+(sin(degtorad((argument1)-argument0))*argument2));
208 | 
209 | #define sk_setAngle
210 | ///sk_setAngle(id, angle)
211 | ds_grid_set(SK_DATA,argument0,5,argument1);
212 | 
213 | #define sk_setClampMax
214 | ///sk_setClampMax(id, clampMax)
215 | ds_grid_set(SK_DATA,argument0,9,argument1);
216 | 
217 | #define sk_setClampMin
218 | ///sk_setClampMin(id, clampMin)
219 | ds_grid_set(SK_DATA,argument0,8,argument1);
220 | 
221 | #define sk_setParent
222 | ///sk_setParent(id, parentId)
223 | ds_grid_set(SK_DATA,argument0,0,argument1);
224 | 
225 | #define sk_setRotationSpeed
226 | ///sk_setRotationSpeed(id, rotationSpeed)
227 | ds_grid_set(SK_DATA,argument0,7,argument1);
228 | 
229 | #define sk_setTargetAngle
230 | ///sk_setTargetAngle(id, targetAngle)
231 | ds_grid_set(SK_DATA,argument0,6,argument1);
232 | 
233 | #define sk_setX
234 | ///sk_setX(id, x)
235 | ds_grid_set(SK_DATA,argument0,1,argument1);
236 | 
237 | #define sk_setXOffset
238 | ///sk_setXOffset(id, xOffset)
239 | ds_grid_set(SK_DATA,argument0,3,argument1);
240 | 
241 | #define sk_setY
242 | ///sk_setY(id, y)
243 | ds_grid_set(SK_DATA,argument0,2,argument1);
244 | 
245 | #define sk_setYOffset
246 | ///sk_setYOffset(id, yOffset)
247 | ds_grid_set(SK_DATA,argument0,4,argument1);
248 | 
249 | #define sk_update
250 | ///sk_update()
251 | 
252 | /***************************************************
253 |   Update Skeleton Structure
254 |  ***************************************************
255 |  
256 |  sk_update();
257 |  
258 |  Used in the step event of an object with a skeleton in it
259 |  It keeps the structure updated due to rotations
260 |  
261 | */
262 | 
263 | sk_setX(0,x);
264 | sk_setY(0,y);
265 | for (i=0; i<ds_grid_width(SK_DATA); i+=1) {
266 |     sk_updateJoint(i);
267 | }
268 | 
269 | #define sk_updateJoint
270 | ///sk_updateJoint(id)
271 | 
272 | /***************************************************
273 |   Update a Joint
274 |  ***************************************************
275 | 
276 |  sk_updateJoint(point ID);
277 |  
278 |  Updates an individual joint's positioning and angle
279 |  
280 | */
281 | 
282 | var point, par, xoff, yoff, xpar, ypar;
283 | 
284 | point = argument0;
285 | par = sk_getParent(point);
286 | xoff = sk_getXOffset(point)*SK_SCALE;
287 | yoff = sk_getYOffset(point)*SK_SCALE;
288 | xpar = sk_getX(par);
289 | ypar = sk_getY(par);
290 | curAng = sk_getAngle(point);
291 | parAng = sk_getAngle(par);
292 | 
293 | if (is_undefined(parAng)) {
294 |     parAng = 0;
295 | }
296 | 
297 | sk_setAngle(point,sk_rotate(curAng,sk_getTargetAngle(point)+parAng,sk_getRotationSpeed(point)));
298 | 
299 | if point != 0 {
300 |     sk_setX(point,sk_pointX(xpar,xoff,yoff,curAng));
301 |     sk_setY(point,sk_pointY(ypar,xoff,yoff,curAng));
302 |     sk_setTargetAngle(point,clamp(sk_getTargetAngle(point),sk_getClampMin(point),sk_getClampMax(point)));
303 | } else {
304 |     sk_setX(0,x);
305 |     sk_setY(0,y);
306 | }
307 | 


--------------------------------------------------------------------------------