Emanuele Feronato » Actionscript 2 http://www.emanueleferonato.com italian geek and PROgrammer Mon, 06 Feb 2012 14:28:18 +0000 en hourly 1 http://wordpress.org/?v= AS2 Games Pack released: source code of 12 commercial AS2 Flash games ready to be downloaded http://www.emanueleferonato.com/2011/09/30/as2-games-pack-released-source-code-of-12-commercial-as2-flash-games-ready-to-be-downloaded/ http://www.emanueleferonato.com/2011/09/30/as2-games-pack-released-source-code-of-12-commercial-as2-flash-games-ready-to-be-downloaded/#comments Fri, 30 Sep 2011 10:59:25 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=4710 Although I am not talking about AS2 for almost trhee years, I am receiving continuous requests to keep on posting AS2 tutorials.

While I have no plans about AS2 tutorials, there’s an interesting deal you can enjoy:

The AS2 Games Pack, that is the collection of the 12 Flash games I released during AS2 years, whith more than 50 million loads!

I am not talking about prototypes, but the full, complete games with source codes. The same games I published, are included here.

Getting the AS2 Games Pack is a must if you are Flash game developer because you can grab the source code of successful games, improve the gameplay, change the graphics and you will have a brand new game with a genuine addicting gameplay ready to be published.

Even if you abandoned AS2, you can easily convert the games on AS3 and publish them as AS3 games, or mobile games.

Since I am giving you the games exactly how I made them, in most games you will find more versions, with different APIs which could be outdated, but the source code is fully working.

Let’s have a look at the games:

1 – Circle Chain

The game which started it all. My first Flash game, the opener of the experiment which still continues. Reviewed on Jay is Games.

2 – Christmas Couples

Christmas themed game which can easily ported into mobile devices.

3 – Tileball

A space running game inspired by the classic C64 game Trailblazer. There are some sites selling the source code of a prototype of this game at an irrational amount of money.

4 – GuessNext

Card game which have been recently ported into an iPhone Web App

5 – Glomb

Grow-avoider game, the very first game to use MochiMedia‘s leaderboards.

6 – BallBalance

Addicting puzzle game sponsored by Kongregate, also featured in my book.

7 – Bees n’ Flowers

Puzzle game with experimental gameplay, interesting for a mobile porting

8 – Jamag

Jamag = Just Another Mouse Avoider Game, but with a twist.

9 – Summer Couples

Drawing/matching game, I’d love to see a mobile version of it

10 – Rrode

One-button game with 2 game modes and 51 levels, sponsored by Hallpass

11 – Halloween Couples

Drawing/matching game on an hexagonal playground

12 – Red Flowers

Touch and switch puzzle game with 28 levels

Today, you can have this complete collection of real commercial games for as low as $9.99

Selling full games source codes is another way to monetize a Flash game in its aftermath, and there are portals looking for source codes to buy, but I wanted to extend the deal to every reader/developer/fan at an extremely low price.

If you make money out of this package, share your experience and I will happy to publish it on the blog.

]]> http://www.emanueleferonato.com/2011/09/30/as2-games-pack-released-source-code-of-12-commercial-as2-flash-games-ready-to-be-downloaded/feed/ 61 Protect your work from ActionScript code theft with SWF Protector http://www.emanueleferonato.com/2010/03/05/protect-your-work-from-actionscript-code-theft-with-swf-protector/ http://www.emanueleferonato.com/2010/03/05/protect-your-work-from-actionscript-code-theft-with-swf-protector/#comments Fri, 05 Mar 2010 10:03:32 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=2480 « I’ve just found a site that won a top international online advertising award – and it’s been blatantly lifted from me!

Its a flash application that has the same vectors and almost certainly the same AS code. Is there anything I can do? I’m in the UK – they’re in Brazil. »

The guy who opened this thread looks quite desperate… now imagine this happening to your latest Flash game.

That’s why you must protect your code. You don’t want someone else stealing your work.

I am going to review DCOM Soft‘s SWF Protector.

SWF Protector

SWF Protector is an swf protector software working through actionscript encryption to secure your actionscript content. This means decompilers won’t be able to read your actionscript.

The most interesting SWF Protector features are:

* Inexpensive: only $59.95 for a Business License. You can earn twice in just one day with a single game.

* Simple and fast. You can encrypt your SWF with a couple of clicks.

* Cross-platform. Available for Windows, Mac and Linux.

* Mass protection. You can protect several SWFs at once.

This is the interface you’ll see when you are about to secure your flash content:

I am testing the software on the file created on Box2D Flash game creation tutorial – part 2 tutorial.

This is the original content of the custom_contact_listener.as file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package {
	import Box2D.Dynamics.*;
	import Box2D.Collision.*;
	import Box2D.Collision.Shapes.*;
	import Box2D.Dynamics.Joints.*;
	import Box2D.Dynamics.Contacts.*;
	import Box2D.Common.*;
	import Box2D.Common.Math.*;
	class custom_contact_listener extends b2ContactListener {
		override public function BeginContact(contact:b2Contact):void {
			// getting the fixtures that collided
			var fixtureA:b2Fixture=contact.GetFixtureA();
			var fixtureB:b2Fixture=contact.GetFixtureB();
			// if the fixture is a sensor, mark the parent body to be removed
			if (fixtureB.IsSensor()) {
				fixtureB.GetBody().SetUserData("remove");
			}
			if (fixtureA.IsSensor()) {
				fixtureA.GetBody().SetUserData("remove");
			}
		}
	}
}

Now, I will use a Flash decompiler to extract the same file from an unprotected version of the swf… here it is:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

//class custom_contact_listener
package 
{
    import Box2D.Dynamics.*;
    import Box2D.Dynamics.Contacts.*;
 
    internal class custom_contact_listener extends Box2D.Dynamics.b2ContactListener
    {
        public function custom_contact_listener()
        {
            super();
            return;
        }
 
        public override function BeginContact(arg1:Box2D.Dynamics.Contacts.b2Contact):void
        {
            var loc1:*=arg1.GetFixtureA();
            var loc2:*=arg1.GetFixtureB();
            if (loc2.IsSensor()) 
            {
                loc2.GetBody().SetUserData("remove");
            }
            if (loc1.IsSensor()) 
            {
                loc1.GetBody().SetUserData("remove");
            }
            return;
        }
    }
}

The code is amost more polished… and obviously it works.

Now let’s try to do the same on the obfuscated swf made by SWF Protector… that’s what I got (sorry for the italian screenshot: I’m currently running an italian version of Windows7)

The decompiler crashed… probably the amount of weird characters inserted by the flash obfuscator made it crash.

In the end, SWF Protector is simple to use and very fast. It has shown lightning-fast speeds of SWF files loading, processing and saving and uses four reliable protection algorithms.

You can download a trial version on the official site or win one of three business licenses I am giving away being the first to reply “I want one” when this post will be published on my Facebook Fanpage. This is a special giveaway for three of my Facebook fans. And won’t be the only one.

]]> http://www.emanueleferonato.com/2010/03/05/protect-your-work-from-actionscript-code-theft-with-swf-protector/feed/ 29 Goodbye AS2… http://www.emanueleferonato.com/2008/11/26/goodbye-as2/ http://www.emanueleferonato.com/2008/11/26/goodbye-as2/#comments Wed, 26 Nov 2008 11:02:22 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=672 If you noticed, my last post about AS2 coding is New tile based platform engine – part 11 – slopes part b, almost a month ago.

I decided to quit talking about AS2 because I am not using it anymore, excluding a couple of games I am about to complete.

I am not that happy I had to learn a language I won’t use anymore, but this happened a lot of times in my life… from Commodore Basic to AS2, including AMOS, Pascal and some more.

When a programmer quits a language, it’s not a big problem, but when a blogger does it, he should think about his readers that don’t want to migrate to a new language.

While I don’t want to force anybody, let me share some thoughts:

You can get the latest Flash version, the so called CS4, for $699, and you can download a complete trial working for 30 days.

Even if you don’t have the money, I suggest you to download the trial, make a couple of simple games in a month and raise the funds to buy the license.

All new cool libraries are written in AS3, just think about BOX2D and the games you can make with it.

A PROgrammer **must** know the latest languages, not the old ones. Soon you won’t find any AS2 tutorial around the web.

Last but not least, you can make your own custom tombstone at tombstonebuilder.com.

What about old AS2 tutorials? Well, the most successful ones will be translated into AS3 using classes. Which one would you like to see first?

]]> http://www.emanueleferonato.com/2008/11/26/goodbye-as2/feed/ 37 Platform engine variation with hangable tiles http://www.emanueleferonato.com/2008/11/24/platform-engine-variation-with-hangable-tiles/ http://www.emanueleferonato.com/2008/11/24/platform-engine-variation-with-hangable-tiles/#comments Mon, 24 Nov 2008 11:36:49 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=666 This is another version of my platform engine made by Bryan Devlin introducing some graphics, a visual death and hangable roofs.

Bryan spread out the code to follow and understand it a bit better.

This is what you’ll get:

Notice the hangable tiles, that’s the major improvement.

You can download source code here.

Also, Bryan is working on a game probably started from my engine but with some new features like climbable walls, scrolling maps and timer, and would like some feedback… here it is the game:

Thanks Bryan!

]]> http://www.emanueleferonato.com/2008/11/24/platform-engine-variation-with-hangable-tiles/feed/ 13 How to ask for help: the Philippines example http://www.emanueleferonato.com/2008/11/09/how-to-ask-for-help-the-philippines-example/ http://www.emanueleferonato.com/2008/11/09/how-to-ask-for-help-the-philippines-example/#comments Sun, 09 Nov 2008 19:32:37 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=639 Normally everyday I receive about 10 emails asking for help.

They all seem to be made with a template, something like this: “hey this script does not work. Can you fix it?”

Obviously I cannot fix someone else’s scripts, but sometimes I got really impressed by an help request.

It happened about one year ago and it’s happening today.

This is an email from Jv Caalim from Philippines, in trouble with his computer science thesis…

« Hello Sir, and Good day.

Im Jv Caalim from the Philippines and im a computer science student from AMA computer college (a really crappy school if you ask me..), recently ive been basing my entire Thesis heavily on your tile-based tutorials (which is really really great btw im a fanboy of your site now lol).

My thesis entitled “Asian Museum” is an eduactional game aim for highschool students about, some limited scopes on a few Asian countries, it will be like a clone of castlevania (the player defeats an enemy using a linear weapon not by jumping on them) and along the way the player will recieve hints on how to open the door leading to the next level like ex:”Player battles a monster and gets
Chrysanthemun which is also a name for the national flower of Japan”, the door will be asking questions about asian countries like, “what is the national flower of Japan?”. the boss battle is a turn base system (which is only shown graphically) where random questions about asian history appears on the screen if the player answer it correctly the boss monster gets damaged

As of now i can only say that im still learning on what engine to use, ive also been reading about tonypa’s tile-based tutorials and it was quite helpfull but still there is one thing thats always leaving me confuse, the Collision engine that was used on tile based platforms engine, and if ever i tried experimenting with the collision engines it always ends messing up the collisions… sure the collision works if the “player” is smaller than the tiles but,

What if the player is bigger than the tiles?? lets say i have a 50×50 tile and the player is 49 pixels in width and 98 pixels in height (so that right = 24, left = -24, top = -49, bottom = 49) so its like the player is 2 tiles high and 1 tile wide, or what if the tile size is 25×25 meaning the player is 4 tiles high and 2 tiles wide? how can i make a collision engine for that?

i already know how all the basic movements of the character works and already applied that to a non tile based platform engine that i made (which has a lot of frustrating collision bugs). im not at all a beginner on programming nor a pro but, i have background on programing on VB and C++ on simple programs, and the basics on programming on AS2 (but im still confuse on AS3).

so i would like to ask for some help or at least a detailed explenantion on how i can fix my collision problems. i know that you are a very busy person and im sorry if i have to ask too much of a favor, im still a student i dont have a job yet so im sorry if i cant pay you anything but, i could at least give you all the rights on the game(thesis), most specially the “player sprite” i made by hand (its still not finish but i will give you all of it if its finished), you can also ask me to make you some sprites on your game for free if you like, so pls im begging for help… the submission for the thesis will be on Dec 6, and i havent really made anything that could be usefull to the game except the sprites.

P.S sorry if my sentences sounds as if i was demanding (or commanding you), my english is a bit bad.

Hoping for your relpy and more power to your site
(some of my recent experiments on .fla is attach on this email pls do scan it first for precausions) »

You will find the files here.

I hope Jv (I am really curious to know does it sound this name) can get some help, maybe someone can save his thesis.

]]> http://www.emanueleferonato.com/2008/11/09/how-to-ask-for-help-the-philippines-example/feed/ 4 ActionScript 2.0 to 3.0 Migration Cheatsheet http://www.emanueleferonato.com/2008/11/02/actionscript-20-to-30-migration-cheatsheet/ http://www.emanueleferonato.com/2008/11/02/actionscript-20-to-30-migration-cheatsheet/#comments Sun, 02 Nov 2008 12:08:26 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=615 If you are worried about the changes introduced by AS3 and would like a cheatsheet for a quick reference of most of them, then you should take a look at http://actionscriptcheatsheet.com/

This site provides some interesting printable quick reference cards for the ActionScript language. AS3, Flex, AIR, Papervision, and more.

Unfortunately the site seems to be inactive for almost a year, so I suggest you to download them quickly.

This is the ActionScript 2.0 to 3.0 migration cheatsheet

In the downloads page you will find more.

Hope this will help you in the migration.

]]> http://www.emanueleferonato.com/2008/11/02/actionscript-20-to-30-migration-cheatsheet/feed/ 2 New tile based platform engine – part 11 – slopes part b http://www.emanueleferonato.com/2008/10/24/new-tile-based-platform-engine-part-11-slopes-part-b/ http://www.emanueleferonato.com/2008/10/24/new-tile-based-platform-engine-part-11-slopes-part-b/#comments Fri, 24 Oct 2008 11:44:23 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=594 As said in New tile based platform engine – part 11 – slopes part a, the game needed a fix for the jump from/on slope bug.

In part b the bug becomes a glitch… now you can jump from/on the slope but sometimes there is a “rebounce” glitch.

It’s very easy to determine why it’s happening and fix it… I am just leaving the explication for next time because I just got my computer repaired and need to do a lot of things.

I just wanted to answer a question about senseless slopes and N game mechanics.

There is a lot of difference between my tile based engine and a raycasting one.

Maybe I’ll cover it in next future.

Meanwhile, you are invited to take a look at the source code and fix the glitch at line 338

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363

walkable_tiles = Array(0, 5, 6, 7, 10, 11);
tile_size = 20;
ground_acceleration = 1;
ground_friction = 0.8;
air_acceleration = 0.5;
air_friction = 0.7;
ice_acceleration = 0.15;
ice_friction = 0.95;
treadmill_speed = 2;
max_speed = 3;
xspeed = 0;
yspeed = 0;
falling = false;
jumping = false;
on_slope = false;
gravity = 0.5;
jump_speed = 6;
climbing = false;
climb_speed = 0.8;
level = new Array();
enemy = new Array();
coin = new Array();
key = new Array();
level[0] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
level[1] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
level[2] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 1];
level[3] = [1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
level[4] = [1, 0, 1, 2, 2, 1, 0, 4, 4, 8, 3, 3, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
level[5] = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 1];
level[6] = [1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 0, 1];
level[7] = [1, 1, 1, 0, 0, 1, 0, 0, 0, 10, 1, 11, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1];
level[8] = [1, 1, 1, 1, 0, 9, 0, 0, 10, 1, 1, 1, 11, 0, 7, 0, 0, 6, 0, 0, 0, 0, 7, 0, 1];
level[9] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 4, 4, 1, 8, 1, 8, 1];
player = [10, 6];
enemy[0] = [10, 3, -2];
enemy[1] = [3, 3, -2];
coin[0] = [2, 2];
coin[1] = [23, 4];
key[0] = [1, 5, 5, 8];
function create_level(l) {
	_root.createEmptyMovieClip("level_container",1);
	level_height = l.length;
	level_width = l[0].length;
	for (y=0; y<level_height; y++) {
		for (x=0; x<level_width; x++) {
			if (l[y][x] != 0) {
				t = level_container.attachMovie("tile", "t"+y+"_"+x, _root.level_container.getNextHighestDepth(), {_x:x*tile_size, _y:y*tile_size});
				t.gotoAndStop(l[y][x]);
			}
		}
	}
	place_player();
	for (x=0; x<coin.length; x++) {
		coin_mc = level_container.attachMovie("coin", "coin_"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:coin[x][0]*tile_size+tile_size/2, _y:coin[x][1]*tile_size+tile_size/2+1});
		coin_mc.onEnterFrame = function() {
			if (this.hitTest(level_container.hero._x, level_container.hero._y, true)) {
				this.removeMovieClip();
			}
		};
	}
	for (x=0; x<key.length; x++) {
		key_mc = level_container.attachMovie("key", "key"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:key[x][0]*tile_size+tile_size/2, _y:key[x][1]*tile_size+tile_size/2+1});
		key_mc.ind = x;
		key_mc.onEnterFrame = function() {
			if (this.hitTest(level_container.hero._x, level_container.hero._y, true)) {
				open_x = [key[this.ind][2]];
				open_y = [key[this.ind][3]];
				level[open_y][open_x] = 0;
				_root.level_container["t"+open_y+"_"+open_x].removeMovieClip();
				this.removeMovieClip();
			}
		};
	}
	for (x=0; x<enemy.length; x++) {
		foe = level_container.attachMovie("patrol", "patrol_"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:enemy[x][0]*tile_size+tile_size/2, _y:enemy[x][1]*tile_size+tile_size/2+1});
		foe.speed = enemy[x][2];
		foe.onEnterFrame = function() {
			this.x_pos = this._x;
			this.y_pos = this._y;
			this.x_pos += this.speed;
			this.left_foot_x = Math.floor((this.x_pos-6)/tile_size);
			this.right_foot_x = Math.floor((this.x_pos+5)/tile_size);
			this.foot_y = Math.floor((this.y_pos+9)/tile_size);
			this.bottom = Math.floor((this.y_pos+8)/tile_size);
			this.left_foot = level[this.foot_y][this.left_foot_x];
			this.right_foot = level[this.foot_y][this.right_foot_x];
			this.left = level[this.bottom][this.left_foot_x];
			this.right = level[this.bottom][this.right_foot_x];
			if (this.left_foot != 0 and this.right_foot != 0 and this.left == 0 and this.right == 0) {
				this._x = this.x_pos;
			} else {
				this.speed *= -1;
			}
		};
	}
}
create_level(level);
_root.onEnterFrame = function() {
	ground_under_feet();
	walking = false;
	climbing = false;
	if (Key.isDown(Key.LEFT)) {
		xspeed -= speed;
		walking = true;
	}
	if (Key.isDown(Key.RIGHT)) {
		xspeed += speed;
		walking = true;
	}
	if (Key.isDown(Key.UP)) {
		get_edges();
		if (top_right == 6 or bottom_right == 6 or top_left == 6 or bottom_left == 6) {
			jumping = false;
			falling = false;
			climbing = true;
			climbdir = -1;
		}
	}
	if (Key.isDown(Key.DOWN)) {
		get_edges();
		if ((over == "ladder") or (top_right == 6 or bottom_right == 6 or top_left == 6 or bottom_left == 6)) {
			jumping = false;
			falling = false;
			climbing = true;
			climbdir = 1;
		}
	}
	if (Key.isDown(Key.SPACE)) {
		//get_edges();
		if (!falling and !jumping) {
			jumping = true;
			yspeed = -jump_speed;
		}
	}
	if (!walking) {
		xspeed *= friction;
		if (Math.abs(xspeed)<0.5) {
			xspeed = 0;
		}
	}
	if (xspeed>max_speed) {
		xspeed = max_speed;
	}
	if (xspeed<max_speed*-1) {
		xspeed = max_speed*-1;
	}
	if (falling or jumping) {
		yspeed += gravity;
	}
	if (climbing) {
		yspeed = climb_speed*climbdir;
	}
	if (!falling and !jumping and !climbing) {
		yspeed = 0;
	}
	xspeed += bonus_speed;
	check_collisions();
	level_container.hero._x = x_pos;
	level_container.hero._y = y_pos;
	xspeed -= bonus_speed;
};
function ground_under_feet() {
	bonus_speed = 0;
	left_foot_x = Math.floor((x_pos-6)/tile_size);
	right_foot_x = Math.floor((x_pos+5)/tile_size);
	foot_y = Math.floor((y_pos+9)/tile_size);
	left_foot = level[foot_y][left_foot_x];
	right_foot = level[foot_y][right_foot_x];
	if (left_foot != 0) {
		current_tile = left_foot;
	} else {
		current_tile = right_foot;
	}
	switch (current_tile) {
		case 0 :
			over = "air";
			speed = air_acceleration;
			friction = air_friction;
			falling = true;
			break;
		case 1 :
			over = "ground";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 2 :
			over = "ice";
			speed = ice_acceleration;
			friction = ice_friction;
			break;
		case 3 :
			over = "treadmill";
			speed = ground_acceleration;
			friction = ground_friction;
			bonus_speed = -treadmill_speed;
			break;
		case 4 :
			over = "treadmill";
			speed = ground_acceleration;
			friction = ground_friction;
			bonus_speed = treadmill_speed;
			break;
		case 5 :
			over = "cloud";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 6 :
			over = "ladder";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 7 :
			over = "trampoline";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 8 :
			over = "spikes";
			if (left_foot == 8 and right_foot == 8) {
				place_player();
			}
		default :
			over = "ground";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
	}
}
function check_collisions() {
	get_edges();
	is_on_slope();
	y_pos += yspeed;
	get_edges();
	// collision to the bottom 
	if (yspeed>0 and !on_slope) {
		if ((bottom_right != 0 and bottom_right != 6 and bottom_right != 10 and bottom_right != 11) or (bottom_left != 0 and bottom_left != 6 and bottom_left != 10 and bottom_left != 11)) {
			// not a cloud...
			if (bottom_right != 5 and bottom_left != 5) {
				// a trampoline
				if ((bottom_right == 7 or bottom_left == 7) and (Math.abs(yspeed)>1)) {
					yspeed = yspeed*-1;
					jumping = true;
					falling = true;
				} else {
					y_pos = bottom*tile_size-9;
					yspeed = 0;
					falling = false;
					jumping = false;
				}
			} else {
				//cloud
				if (prev_bottom<bottom) {
					y_pos = bottom*tile_size-9;
					yspeed = 0;
					falling = false;
					jumping = false;
				}
			}
		}
	}
	// collision to the top                                                                                                               
	if (yspeed<0) {
		if ((top_right != 0 and top_right != 5 and top_right != 6) or (top_left != 0 and top_left != 5 and top_left != 6)) {
			y_pos = bottom*tile_size+1+8;
			yspeed = 0;
			falling = false;
			jumping = false;
		}
	}
	x_pos += xspeed;
	get_edges();
	// collision to the left           
	if (xspeed<0) {
		if (!is_walkable(top_left) or !is_walkable(bottom_left)) {
			x_pos = (left+1)*tile_size+6;
			xspeed = 0;
		}
	}
	// collision to the right                                                                                                                                      
	if (xspeed>0) {
		if (!is_walkable(top_right) or !is_walkable(bottom_right)) {
			x_pos = right*tile_size-6;
			xspeed = 0;
		}
	}
	prev_bottom = bottom;
}
function get_edges() {
	// right edge
	right = Math.floor((x_pos+5)/tile_size);
	// left edge   
	left = Math.floor((x_pos-6)/tile_size);
	// bottom edge
	bottom = Math.floor((y_pos+8)/tile_size);
	// top edge
	top = Math.floor((y_pos-9)/tile_size);
	// adjacent tiles
	top_right = level[top][right];
	top_left = level[top][left];
	bottom_left = level[bottom][left];
	bottom_right = level[bottom][right];
}
function place_player() {
	level_container.hero.removeMovieClip();
	x_pos = player[0]*tile_size+tile_size/2;
	y_pos = player[1]*tile_size+tile_size/2+1;
	level_container.attachMovie("hero","hero",_root.level_container.getNextHighestDepth(),{_x:x_pos, _y:y_pos});
}
function is_walkable(tile) {
	walkable = false;
	if (!on_slope) {
		for (x=0; x<walkable_tiles.length; x++) {
			if (tile == walkable_tiles[x]) {
				walkable = true;
				break;
			}
		}
	} else {
		walkable = true;
	}
	return (walkable);
}
function is_on_slope() {
	on_slope = false;
	x_slope_detector = Math.floor(x_pos/tile_size);
	y_slope_detector = Math.floor(y_pos/tile_size);
	if (jumping or falling) {
		if (level[y_slope_detector][x_slope_detector] == 10 or level[y_slope_detector][x_slope_detector] == 11) {
			if (level[y_slope_detector][x_slope_detector] == 10) {
				x_offset = tile_size-x_pos%tile_size;
			}
			// could be an "else"...               
			if (level[y_slope_detector][x_slope_detector] == 11) {
				x_offset = x_pos%tile_size;
			}
			if (y_pos>Math.floor(y_pos/tile_size)*tile_size-9+x_offset) {
				// rebounce fix here
			}
		}
	}
	// could NOT be an else  
	if (!jumping and !falling) {
		if (level[y_slope_detector+1][x_slope_detector] == 10 or level[y_slope_detector+1][x_slope_detector] == 11) {
			y_pos = (y_slope_detector+1)*tile_size+tile_size/2+1;
			y_slope_detector += 1;
		}
		if (level[y_slope_detector][x_slope_detector] == 10 or level[y_slope_detector][x_slope_detector] == 11) {
			if (level[y_slope_detector][x_slope_detector] == 10) {
				x_offset = tile_size-x_pos%tile_size;
			}
			// could be an "else"...               
			if (level[y_slope_detector][x_slope_detector] == 11) {
				x_offset = x_pos%tile_size;
			}
			y_pos = Math.floor(y_pos/tile_size)*tile_size-9+x_offset;
			on_slope = true;
		}
	}
	if (!jumping and !falling and !on_slope and over != "ladder") {
		y_pos = (y_slope_detector)*tile_size+tile_size/2+1;
	}
}

Enjoy the result

Download the source code and have fun

]]> http://www.emanueleferonato.com/2008/10/24/new-tile-based-platform-engine-part-11-slopes-part-b/feed/ 27 New tile based platform engine – part 11 – slopes part a http://www.emanueleferonato.com/2008/10/19/new-tile-banew-tile-based-platform-engine-part-11-slopes-part-ased-platform-engine-part-11-slopes/ http://www.emanueleferonato.com/2008/10/19/new-tile-banew-tile-based-platform-engine-part-11-slopes-part-ased-platform-engine-part-11-slopes/#comments Sun, 19 Oct 2008 17:14:16 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=583 You asked for it, I made it… ladies and gentlemen… SLOPES! (applause).

I decided to split slopes in two parts, because they are a bit more difficult than other tile types.

In this part, you can walk on slopes but you can’t jump on/from them. Oh, well, you can actually jump or land on them, but without the second part of the code, there could be some glitches.

Obviously if you want to suggest your jumping routine, you’re welcome.

Slopes need a lot of rules in order to work, that can be summarized in one big rule: don’t make senseless slopes.

For senseless slopes I mean everything… senseless… refer to the picture:

Green shapes show some possible slopes while red ones show impossible ones.

Then the is_on_slope function solves slope walking.

Once I’ll publish jumping routine, I’ll write a detailed slope tutorial.

Meanwhile take the source code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354

walkable_tiles = Array(0, 5, 6, 7, 10, 11);
tile_size = 20;
ground_acceleration = 1;
ground_friction = 0.8;
air_acceleration = 0.5;
air_friction = 0.7;
ice_acceleration = 0.15;
ice_friction = 0.95;
treadmill_speed = 2;
max_speed = 3;
xspeed = 0;
yspeed = 0;
falling = false;
on_slope = false;
gravity = 0.5;
jump_speed = 6;
climbing = false;
climb_speed = 0.8;
level = new Array();
enemy = new Array();
coin = new Array();
key = new Array();
level[0] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
level[1] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
level[2] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 1];
level[3] = [1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
level[4] = [1, 0, 1, 2, 2, 1, 0, 4, 4, 8, 3, 3, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
level[5] = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 1];
level[6] = [1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 0, 1];
level[7] = [1, 1, 1, 0, 0, 1, 0, 0, 0, 10, 1, 11, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1];
level[8] = [1, 1, 1, 1, 0, 9, 0, 0, 10, 1, 1, 1, 11, 0, 7, 0, 0, 6, 0, 0, 0, 0, 7, 0, 1];
level[9] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 4, 4, 1, 8, 1, 8, 1];
player = [10, 6];
enemy[0] = [10, 3, -2];
enemy[1] = [3, 3, -2];
coin[0] = [2, 2];
coin[1] = [23, 4];
key[0] = [1, 5, 5, 8];
function create_level(l) {
	_root.createEmptyMovieClip("level_container",1);
	level_height = l.length;
	level_width = l[0].length;
	for (y=0; y<level_height; y++) {
		for (x=0; x<level_width; x++) {
			if (l[y][x] != 0) {
				t = level_container.attachMovie("tile", "t"+y+"_"+x, _root.level_container.getNextHighestDepth(), {_x:x*tile_size, _y:y*tile_size});
				t.gotoAndStop(l[y][x]);
			}
		}
	}
	place_player();
	for (x=0; x<coin.length; x++) {
		coin_mc = level_container.attachMovie("coin", "coin_"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:coin[x][0]*tile_size+tile_size/2, _y:coin[x][1]*tile_size+tile_size/2+1});
		coin_mc.onEnterFrame = function() {
			if (this.hitTest(level_container.hero._x, level_container.hero._y, true)) {
				this.removeMovieClip();
			}
		};
	}
	for (x=0; x<key.length; x++) {
		key_mc = level_container.attachMovie("key", "key"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:key[x][0]*tile_size+tile_size/2, _y:key[x][1]*tile_size+tile_size/2+1});
		key_mc.ind = x;
		key_mc.onEnterFrame = function() {
			if (this.hitTest(level_container.hero._x, level_container.hero._y, true)) {
				open_x = [key[this.ind][2]];
				open_y = [key[this.ind][3]];
				level[open_y][open_x] = 0;
				_root.level_container["t"+open_y+"_"+open_x].removeMovieClip();
				this.removeMovieClip();
			}
		};
	}
	for (x=0; x<enemy.length; x++) {
		foe = level_container.attachMovie("patrol", "patrol_"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:enemy[x][0]*tile_size+tile_size/2, _y:enemy[x][1]*tile_size+tile_size/2+1});
		foe.speed = enemy[x][2];
		foe.onEnterFrame = function() {
			this.x_pos = this._x;
			this.y_pos = this._y;
			this.x_pos += this.speed;
			this.left_foot_x = Math.floor((this.x_pos-6)/tile_size);
			this.right_foot_x = Math.floor((this.x_pos+5)/tile_size);
			this.foot_y = Math.floor((this.y_pos+9)/tile_size);
			this.bottom = Math.floor((this.y_pos+8)/tile_size);
			this.left_foot = level[this.foot_y][this.left_foot_x];
			this.right_foot = level[this.foot_y][this.right_foot_x];
			this.left = level[this.bottom][this.left_foot_x];
			this.right = level[this.bottom][this.right_foot_x];
			if (this.left_foot != 0 and this.right_foot != 0 and this.left == 0 and this.right == 0) {
				this._x = this.x_pos;
			}
			else {
				this.speed *= -1;
			}
		};
	}
}
create_level(level);
_root.onEnterFrame = function() {
	ground_under_feet();
	walking = false;
	climbing = false;
	if (Key.isDown(Key.LEFT)) {
		xspeed -= speed;
		walking = true;
	}
	if (Key.isDown(Key.RIGHT)) {
		xspeed += speed;
		walking = true;
	}
	if (Key.isDown(Key.UP)) {
		get_edges();
		if (top_right == 6 or bottom_right == 6 or top_left == 6 or bottom_left == 6) {
			jumping = false;
			falling = false;
			climbing = true;
			climbdir = -1;
		}
	}
	if (Key.isDown(Key.DOWN)) {
		get_edges();
		if ((over == "ladder") or (top_right == 6 or bottom_right == 6 or top_left == 6 or bottom_left == 6)) {
			jumping = false;
			falling = false;
			climbing = true;
			climbdir = 1;
		}
	}
	if (Key.isDown(Key.SPACE)) {
		//get_edges();
		if (!falling and !jumping) {
			jumping = true;
			yspeed = -jump_speed;
		}
	}
	if (!walking) {
		xspeed *= friction;
		if (Math.abs(xspeed)<0.5) {
			xspeed = 0;
		}
	}
	if (xspeed>max_speed) {
		xspeed = max_speed;
	}
	if (xspeed<max_speed*-1) {
		xspeed = max_speed*-1;
	}
	if (falling or jumping) {
		yspeed += gravity;
	}
	if (climbing) {
		yspeed = climb_speed*climbdir;
	}
	if (!falling and !jumping and !climbing) {
		yspeed = 0;
	}
	xspeed += bonus_speed;
	check_collisions();
	level_container.hero._x = x_pos;
	level_container.hero._y = y_pos;
	xspeed -= bonus_speed;
};
function ground_under_feet() {
	bonus_speed = 0;
	left_foot_x = Math.floor((x_pos-6)/tile_size);
	right_foot_x = Math.floor((x_pos+5)/tile_size);
	foot_y = Math.floor((y_pos+9)/tile_size);
	left_foot = level[foot_y][left_foot_x];
	right_foot = level[foot_y][right_foot_x];
	if (left_foot != 0) {
		current_tile = left_foot;
	}
	else {
		current_tile = right_foot;
	}
	switch (current_tile) {
		case 0 :
			over = "air";
			speed = air_acceleration;
			friction = air_friction;
			falling = true;
			break;
		case 1 :
			over = "ground";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 2 :
			over = "ice";
			speed = ice_acceleration;
			friction = ice_friction;
			break;
		case 3 :
			over = "treadmill";
			speed = ground_acceleration;
			friction = ground_friction;
			bonus_speed = -treadmill_speed;
			break;
		case 4 :
			over = "treadmill";
			speed = ground_acceleration;
			friction = ground_friction;
			bonus_speed = treadmill_speed;
			break;
		case 5 :
			over = "cloud";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 6 :
			over = "ladder";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 7 :
			over = "trampoline";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
		case 8 :
			over = "spikes";
			if (left_foot == 8 and right_foot == 8) {
				place_player();
			}
		default :
			over = "ground";
			speed = ground_acceleration;
			friction = ground_friction;
			break;
	}
}
function check_collisions() {
	get_edges();
	is_on_slope();
	y_pos += yspeed;
	get_edges();
	// collision to the bottom 
	if (yspeed>0 and !on_slope) {
		if ((bottom_right != 0 and bottom_right != 6 and bottom_right != 10) or (bottom_left != 0 and bottom_left != 6 and bottom_left != 10)) {
			// not a cloud...
			if (bottom_right != 5 and bottom_left != 5) {
				// a trampoline
				if ((bottom_right == 7 or bottom_left == 7) and (Math.abs(yspeed)>1)) {
					yspeed = yspeed*-1;
					jumping = true;
					falling = true;
				}
				else {
					y_pos = bottom*tile_size-9;
					yspeed = 0;
					falling = false;
					jumping = false;
				}
			}
			else {
				//cloud
				if (prev_bottom<bottom) {
					y_pos = bottom*tile_size-9;
					yspeed = 0;
					falling = false;
					jumping = false;
				}
			}
		}
	}
	// collision to the top                                                                                                   
	if (yspeed<0 and !on_slope) {
		if ((top_right != 0 and top_right != 5 and top_right != 6) or (top_left != 0 and top_left != 5 and top_left != 6)) {
			y_pos = bottom*tile_size+1+8;
			yspeed = 0;
			falling = false;
			jumping = false;
		}
	}
	x_pos += xspeed;
	get_edges();
	// collision to the left           
	if (xspeed<0) {
		if (!is_walkable(top_left) or !is_walkable(bottom_left)) {
			x_pos = (left+1)*tile_size+6;
			xspeed = 0;
		}
	}
	// collision to the right                                                                                                                          
	if (xspeed>0) {
		if (!is_walkable(top_right) or !is_walkable(bottom_right)) {
			x_pos = right*tile_size-6;
			xspeed = 0;
		}
	}
	prev_bottom = bottom;
}
function get_edges() {
	// right edge
	right = Math.floor((x_pos+5)/tile_size);
	// left edge   
	left = Math.floor((x_pos-6)/tile_size);
	// bottom edge
	bottom = Math.floor((y_pos+8)/tile_size);
	// top edge
	top = Math.floor((y_pos-9)/tile_size);
	// adjacent tiles
	top_right = level[top][right];
	top_left = level[top][left];
	bottom_left = level[bottom][left];
	bottom_right = level[bottom][right];
}
function place_player() {
	level_container.hero.removeMovieClip();
	x_pos = player[0]*tile_size+tile_size/2;
	y_pos = player[1]*tile_size+tile_size/2+1;
	level_container.attachMovie("hero","hero",_root.level_container.getNextHighestDepth(),{_x:x_pos, _y:y_pos});
}
function is_walkable(tile) {
	walkable = false;
	if (!on_slope) {
		for (x=0; x<walkable_tiles.length; x++) {
			if (tile == walkable_tiles[x]) {
				walkable = true;
				break;
			}
		}
	}
	else {
		walkable = true;
	}
	return (walkable);
}
function is_on_slope() {
	x_slope_detector = Math.floor(x_pos/tile_size);
	y_slope_detector = Math.floor(y_pos/tile_size);
	if (!jumping and !falling) {
		if (level[y_slope_detector+1][x_slope_detector] == 10 or level[y_slope_detector+1][x_slope_detector] == 11) {
			y_pos = (y_slope_detector+1)*tile_size+tile_size/2+1;
			y_slope_detector += 1;
		}
		if (level[y_slope_detector][x_slope_detector] == 10 or level[y_slope_detector][x_slope_detector] == 11) {
			if (level[y_slope_detector][x_slope_detector] == 10) {
				x_offset = tile_size-x_pos%tile_size;
			}
			// could be an "else"...   
			if (level[y_slope_detector][x_slope_detector] == 11) {
				x_offset = x_pos%tile_size;
			}
			y_pos = Math.floor(y_pos/tile_size)*tile_size-9+x_offset;
			on_slope = true;
		}
		else {
			on_slope = false;
		}
	}
	if (!jumping and !falling and !on_slope and over != "ladder") {
		y_pos = (y_slope_detector)*tile_size+tile_size/2+1;
	}
}

And the final example:

Download the source code.

]]> http://www.emanueleferonato.com/2008/10/19/new-tile-banew-tile-based-platform-engine-part-11-slopes-part-ased-platform-engine-part-11-slopes/feed/ 21 New tile based platform engine – part 10 – optimization, doors n’ keys http://www.emanueleferonato.com/2008/10/13/new-tile-based-platform-engine-part-10-optimization-doors-n-keys/ http://www.emanueleferonato.com/2008/10/13/new-tile-based-platform-engine-part-10-optimization-doors-n-keys/#comments Mon, 13 Oct 2008 13:48:27 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=569 Here we are with some optimization, as well as a feature some people requested: doors and keys.

Let’s start with the first optimization step.

Optimization

See how does the script at step 9 determine if a tile is walkable (player can pass through it):

if ((top_right != 0 and top_right != 5 and top_right != 6 and top_right != 7) or (bottom_right != 0 and bottom_right != 5 and bottom_right != 6 and bottom_right != 7)) {

I have to check if all values are different from 0, 5, 6 and 7 because 0 = empty, 5 = cloud, 6 = ladder and 7 = trampoline.

Nothing difficult at this point, but let’s imagine I am going to add another walkable tile… I should update the and formula by adding the new tile type.

The more walkable tiles I add, the more the probability of making errors or forgetting something.

So I created an array with all walkable tiles this way:

walkable_tiles = Array(0, 5, 6, 7);

Then the old code becomes

if (!is_walkable(top_right) or !is_walkable(bottom_right)) {

Where is_walkable is basically an in_array function (not included in AS2!!)

1
2
3
4
5
6
7
8
9
10

function is_walkable(tile) {
	walkable = false;
	for (x=0; x<walkable_tiles.length; x++) {
		if (tile == walkable_tiles[x]) {
			walkable = true;
			break;
		}
	}
	return (walkable);
}

Doors and keys

A door is a unwalkable tile that becomes a walkable one when the player takes its key.

Every key is an array made this way:

[key x pos, key y pos, door x pos, door y pos]

Meaning that the key is located at (key x pos, key y pos) and once collected opens the door at (door x pos, door y pos).

Let’s see the source:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310

walkable_tiles = Array(0, 5, 6, 7);
tile_size = 20;
ground_acceleration = 1;
ground_friction = 0.8;
air_acceleration = 0.5;
air_friction = 0.7;
ice_acceleration = 0.15;
ice_friction = 0.95;
treadmill_speed = 2;
max_speed = 3;
xspeed = 0;
yspeed = 0;
falling = false;
gravity = 0.5;
jump_speed = 6;
climbing = false;
climb_speed = 0.8;
level = new Array();
enemy = new Array();
coin = new Array();
key = new Array();
level[0] = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
level[1] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
level[2] = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 1];
level[3] = [1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
level[4] = [1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
level[5] = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1];
level[6] = [1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 1, 0, 0, 0, 0, 0, 1];
level[7] = [1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 1];
level[8] = [1, 1, 1, 1, 0, 9, 0, 0, 0, 5, 5, 0, 0, 0, 7, 0, 0, 6, 0, 0, 0, 0, 7, 0, 1];
level[9] = [1, 1, 1, 1, 1, 1, 1, 2, 2, 8, 8, 8, 8, 1, 1, 3, 3, 1, 4, 4, 1, 8, 1, 8, 1];
player = [4, 8];
enemy[0] = [10, 3, -2];
enemy[1] = [3, 3, -2];
coin[0] = [2, 2];
coin[1] = [23, 4];
key[0] = [1, 5, 5, 8];
function create_level(l) {
	_root.createEmptyMovieClip("level_container", 1);
	level_height = l.length;
	level_width = l[0].length;
	for (y=0; y<level_height; y++) {
		for (x=0; x<level_width; x++) {
			if (l[y][x] != 0) {
				t = level_container.attachMovie("tile", "t"+y+"_"+x, _root.level_container.getNextHighestDepth(), {_x:x*tile_size, _y:y*tile_size});
				t.gotoAndStop(l[y][x]);
			}
		}
	}
	place_player();
	for (x=0; x<coin.length; x++) {
		coin_mc = level_container.attachMovie("coin", "coin_"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:coin[x][0]*tile_size+tile_size/2, _y:coin[x][1]*tile_size+tile_size/2+1});
		coin_mc.onEnterFrame = function() {
			if (this.hitTest(level_container.hero._x, level_container.hero._y, true)) {
				this.removeMovieClip();
			}
		};
	}
	for (x=0; x<key.length; x++) {
		key_mc = level_container.attachMovie("key", "key"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:key[x][0]*tile_size+tile_size/2, _y:key[x][1]*tile_size+tile_size/2+1});
		key_mc.ind = x;
		key_mc.onEnterFrame = function() {
			if (this.hitTest(level_container.hero._x, level_container.hero._y, true)) {
				open_x = [key[this.ind][2]];
				open_y = [key[this.ind][3]];
				level[open_y][open_x] = 0;
				_root.level_container["t"+open_y+"_"+open_x].removeMovieClip();
				this.removeMovieClip();
			}
		};
	}
	for (x=0; x<enemy.length; x++) {
		foe = level_container.attachMovie("patrol", "patrol_"+_root.level_container.getNextHighestDepth(), _root.level_container.getNextHighestDepth(), {_x:enemy[x][0]*tile_size+tile_size/2, _y:enemy[x][1]*tile_size+tile_size/2+1});
		foe.speed = enemy[x][2];
		foe.onEnterFrame = function() {
			this.x_pos = this._x;
			this.y_pos = this._y;
			this.x_pos += this.speed;
			this.left_foot_x = Math.floor((this.x_pos-6)/tile_size);
			this.right_foot_x = Math.floor((this.x_pos+5)/tile_size);
			this.foot_y = Math.floor((this.y_pos+9)/tile_size);
			this.bottom = Math.floor((this.y_pos+8)/tile_size);
			this.left_foot = level[this.foot_y][this.left_foot_x];
			this.right_foot = level[this.foot_y][this.right_foot_x];
			this.left = level[this.bottom][this.left_foot_x];
			this.right = level[this.bottom][this.right_foot_x];
			if (this.left_foot != 0 and this.right_foot != 0 and this.left == 0 and this.right == 0) {
				this._x = this.x_pos;
			} else {
				this.speed *= -1;
			}
		};
	}
}
create_level(level);
_root.onEnterFrame = function() {
	ground_under_feet();
	walking = false;
	climbing = false;
	if (Key.isDown(Key.LEFT)) {
		xspeed -= speed;
		walking = true;
	}
	if (Key.isDown(Key.RIGHT)) {
		xspeed += speed;
		walking = true;
	}
	if (Key.isDown(Key.UP)) {
		get_edges();
		if (top_right == 6 or bottom_right == 6 or top_left == 6 or bottom_left == 6) {
			jumping = false;
			falling = false;
			climbing = true;
			climbdir = -1;
		}
	}
	if (Key.isDown(Key.DOWN)) {
		get_edges();
		if ((over == "ladder") or (top_right == 6 or bottom_right == 6 or top_left == 6 or bottom_left == 6)) {
			jumping = false;
			falling = false;
			climbing = true;
			climbdir = 1;
		}
	}
	if (Key.isDown(Key.SPACE)) {
		get_edges();
		if (!falling and !jumping) {
			jumping = true;
			yspeed = -jump_speed;
		}
	}
	if (!walking) {
		xspeed *= friction;
		if (Math.abs(xspeed)<0.5) {
			xspeed = 0;
		}
	}
	if (xspeed>max_speed) {
		xspeed = max_speed;
	}
	if (xspeed<max_speed*-1) {
		xspeed = max_speed*-1;
	}
	if (falling or jumping) {
		yspeed += gravity;
	}
	if (climbing) {
		yspeed = climb_speed*climbdir;
	}
	if (!falling and !jumping and !climbing) {
		yspeed = 0;
	}
	xspeed += bonus_speed;
	check_collisions();
	level_container.hero._x = x_pos;
	level_container.hero._y = y_pos;
	xspeed -= bonus_speed;
};
function ground_under_feet() {
	bonus_speed = 0;
	left_foot_x = Math.floor((x_pos-6)/tile_size);
	right_foot_x = Math.floor((x_pos+5)/tile_size);
	foot_y = Math.floor((y_pos+9)/tile_size);
	left_foot = level[foot_y][left_foot_x];
	right_foot = level[foot_y][right_foot_x];
	if (left_foot != 0) {
		current_tile = left_foot;
	} else {
		current_tile = right_foot;
	}
	switch (current_tile) {
	case 0 :
		over = "air";
		speed = air_acceleration;
		friction = air_friction;
		falling = true;
		break;
	case 1 :
		over = "ground";
		speed = ground_acceleration;
		friction = ground_friction;
		break;
	case 2 :
		over = "ice";
		speed = ice_acceleration;
		friction = ice_friction;
		break;
	case 3 :
		over = "treadmill";
		speed = ground_acceleration;
		friction = ground_friction;
		bonus_speed = -treadmill_speed;
		break;
	case 4 :
		over = "treadmill";
		speed = ground_acceleration;
		friction = ground_friction;
		bonus_speed = treadmill_speed;
		break;
	case 5 :
		over = "cloud";
		speed = ground_acceleration;
		friction = ground_friction;
		break;
	case 6 :
		over = "ladder";
		speed = ground_acceleration;
		friction = ground_friction;
		break;
	case 7 :
		over = "trampoline";
		speed = ground_acceleration;
		friction = ground_friction;
		break;
	case 8 :
		over = "spikes";
		if (left_foot == 8 and right_foot == 8) {
			place_player();
		}
	}
}
function check_collisions() {
	y_pos += yspeed;
	get_edges();
	// collision to the bottom 
	if (yspeed>0) {
		if ((bottom_right != 0 and bottom_right != 6) or (bottom_left != 0 and bottom_left != 6)) {
			// not a cloud...
			if (bottom_right != 5 and bottom_left != 5) {
				// a trampoline
				if ((bottom_right == 7 or bottom_left == 7) and (Math.abs(yspeed)>1)) {
					yspeed = yspeed*-1;
					jumping = true;
					falling = true;
				} else {
					y_pos = bottom*tile_size-9;
					yspeed = 0;
					falling = false;
					jumping = false;
				}
			} else {
				//cloud
				if (prev_bottom<bottom) {
					y_pos = bottom*tile_size-9;
					yspeed = 0;
					falling = false;
					jumping = false;
				}
			}
		}
	}
	// collision to the top                                                                
	if (yspeed<0) {
		if ((top_right != 0 and top_right != 5 and top_right != 6) or (top_left != 0 and top_left != 5 and top_left != 6)) {
			y_pos = bottom*tile_size+1+8;
			yspeed = 0;
			falling = false;
			jumping = false;
		}
	}
	x_pos += xspeed;
	get_edges();
	// collision to the left           
	if (xspeed<0) {
		if (!is_walkable(top_left) or !is_walkable(bottom_left)) {
			x_pos = (left+1)*tile_size+6;
			xspeed = 0;
		}
	}
	// collision to the right                                                                                       
	if (xspeed>0) {
		if (!is_walkable(top_right) or !is_walkable(bottom_right)) {
			x_pos = right*tile_size-6;
			xspeed = 0;
		}
	}
	prev_bottom = bottom;
}
function get_edges() {
	// right edge
	right = Math.floor((x_pos+5)/tile_size);
	// left edge   
	left = Math.floor((x_pos-6)/tile_size);
	// bottom edge
	bottom = Math.floor((y_pos+8)/tile_size);
	// top edge
	top = Math.floor((y_pos-9)/tile_size);
	// adjacent tiles
	top_right = level[top][right];
	top_left = level[top][left];
	bottom_left = level[bottom][left];
	bottom_right = level[bottom][right];
}
function place_player() {
	level_container.hero.removeMovieClip();
	x_pos = player[0]*tile_size+tile_size/2;
	y_pos = player[1]*tile_size+tile_size/2+1;
	level_container.attachMovie("hero", "hero", _root.level_container.getNextHighestDepth(), {_x:x_pos, _y:y_pos});
}
function is_walkable(tile) {
	walkable = false;
	for (x=0; x<walkable_tiles.length; x++) {
		if (tile == walkable_tiles[x]) {
			walkable = true;
			break;
		}
	}
	return (walkable);
}

And this is the game:

Download the source code and give feedback.

]]> http://www.emanueleferonato.com/2008/10/13/new-tile-based-platform-engine-part-10-optimization-doors-n-keys/feed/ 21 Create a Flash game like Gold Miner – step 2 http://www.emanueleferonato.com/2008/10/10/create-a-flash-game-like-gold-miner-step-2/ http://www.emanueleferonato.com/2008/10/10/create-a-flash-game-like-gold-miner-step-2/#comments Fri, 10 Oct 2008 14:02:17 +0000 Emanuele Feronato http://www.emanueleferonato.com/?p=565 I received a lot of emails asking me to add left-right movement to my Gold Miner clone and requiring more information about manually placing the boulders.

In order to add left-right movement, you need to check for left and right arrow keys and move the hook in the proper direction.

Just remember you don’t have to let the hook move out of the stage and to update the starting/ending points of the rope.

When you want to manually place boulders, you need an array.

In the one I created, every boulder is an array made this way

[x position, y position, diameter]

Then I created an array containing n boulder arrays where n is the number of boulder I wanted to be in the stage.

Here it is the commented code:

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

// boulders are stored in an array
// [0] is x pos
// [1] is y pos
// [2] is the width
// don't make boulders too large (<50) or the rewind won't work
// until you change slowdown formula
boulders = [[100, 100, 30], [200, 100, 40], [300, 100, 40], [400, 100, 30], [100, 200, 30], [200, 200, 40], [300, 200, 40], [400, 200, 30], [100, 300, 30], [200, 300, 40], [300, 300, 40], [400, 300, 30]];
for (x=0; x<boulders.length; x++) {
	// creating the boulders
	bould = _root.attachMovie("boulder", "boulder_"+_root.getNextHighestDepth(), _root.getNextHighestDepth());
	// placing them in random positions and with random dimensions
	bould._x = boulders[x][0];
	bould._y = boulders[x][1];
	bould._width = boulders[x][2];
	bould._height = boulders[x][2];
	// setting picked attribute as false
	// picked = false => the boulder has not been picked by the hook
	// picked = true => the boulder has been picked
	bould.picked = false;
	// function to be executed at every frame for the boulder
	bould.onEnterFrame = function() {
		// if it's not been picked...
		if (!this.picked) {
			// check if the hook is in shoot mode and touched the boulder
			// you'll see later what do hot_spot_x and hot_spot_y mean
			if (pod_status == "shoot" and this.hitTest(hot_spot_x, hot_spot_y, true)) {
				// set the hook on rewind mode
				pod_status = "rewind";
				// mark this boulder as picked
				this.picked = true;
				// determining the slowdown according to boulder size
				slowdown = Math.floor(this._width/5);
			}
		} else {
			// the boulder has been picked, so move it as the hook moves
			this._x = hot_spot_x;
			this._y = hot_spot_y;
			// if the hook status changed to rotate
			// (this means: if the hook took a boulder and pulled it out to surface...
			if (pod_status == "rotate") {
				// remove the boulder
				this.removeMovieClip();
			}
		}
	};
}
// placing the hook on stage
_root.attachMovie("pod", "pod", _root.getNextHighestDepth(), {_x:250});
// creating an empty movie clip to draw the rope
_root.createEmptyMovieClip("rod", _root.getNextHighestDepth());
// this is the rotation direction and speed
rotation_dir = 2;
// hook initial status
pod_status = "rotate";
// slowdown malus
slowdown = 0;
// hook movement speed
pod_speed = 4;
// function the hook will execute at every frame
pod.onEnterFrame = function() {
	// getting pod status
	switch (pod_status) {
	case "rotate" :
		// moving the hook to the left if player presses left
		if (Key.isDown(Key.LEFT)) {
			this._x -= pod_speed;
			if (this._x<20) {
				this._x = 20;
			}
		}
		// moving the hook to the right if player presses left   
		if (Key.isDown(Key.RIGHT)) {
			this._x += pod_speed;
			if (this._x>480) {
				this._x = 480;
			}
		}
		// if the status is rotate, just rotate the hook according to rotation_dir      
		this._rotation += rotation_dir;
		if (this._rotation == 80 or this._rotation == -80) {
			// invert rotation_dir if the hook reaches its minimum (or maximum) rotation allowed
			rotation_dir *= -1;
		}
		break;
	case "shoot" :
		// the hook has ben shoot
		// (re)set slowdown malus to zero
		slowdown = 0;
		// moving the hook using trigonometry
		this._x += 10*Math.cos(dir);
		this._y += 10*Math.sin(dir);
		// determining the hot spot of the hook
		// the hot spot is the lowest corner of the hook (that acts like an harpoon in this case)
		hot_spot_x = this._x+40*Math.cos(dir);
		hot_spot_y = this._y+40*Math.sin(dir);
		// if the hot spot goes off the stage
		if (hot_spot_y>400 or hot_spot_x<0 or hot_spot_x>500) {
			// then rewind the hook
			pod_status = "rewind";
		}
		// draw a line from the hook starting position to its actual position       
		// this will simulate the rope
		rod.clear();
		rod.lineStyle(1, 0x000000);
		// once it started from (250,0), now that hook can move I am starting from (start_rope_x, 0)
		rod.moveTo(start_rope_x, 0);
		rod.lineTo(this._x, this._y);
		break;
	case "rewind" :
		// clearing the rope
		rod.clear();
		// rewinding the hook...
		// it may seem a nonsense determining the hot spot now, but I need id
		// to move the boulder (if I have any boulder attached to the hook)
		hot_spot_x = this._x+40*Math.cos(dir);
		hot_spot_y = this._y+40*Math.sin(dir);
		// moving the hook with slowdown malus (if any)
		this._x -= (10-slowdown)*Math.cos(dir);
		this._y -= (10-slowdown)*Math.sin(dir);
		// if the hook returns in its initial position...
		if (this._y<0) {
			// then reset its position and set its status to rotate
			this._y = 0;
			this._x = start_rope_x;
			pod_status = "rotate";
		} else {
			// drawing a line as seen in shoot status, but only if the hook is still in the air   
			rod.lineStyle(1, 0x000000);
			rod.moveTo(start_rope_x, 0);
			rod.lineTo(this._x, this._y);
		}
		break;
	}
};
// when the mouse is clicked...
_root.onMouseDown = function() {
	// if the status is rotate...
	if (pod_status == "rotate") {
		// save hook heading and convert it to radians
		dir = (pod._rotation+90)*0.0174532925;
		// setting rope start position... the last hook position
		start_rope_x = pod._x;
		// set pod status to shoot
		pod_status = "shoot";
	}
};

And here it is the result…

Left/right arrows to move, mousebutton to fire.

Download the source code and enjoy

]]> http://www.emanueleferonato.com/2008/10/10/create-a-flash-game-like-gold-miner-step-2/feed/ 15