Il y a quelques temps, je me suis lancé dans le développement d'un Tower Defense. Mais voilà, avec le boulot, et les projets qui s'accumulent, je ne suis pas allé bien loin.

Toutes fois, j'avais implémenté la création du niveau, des monstres, et leurs déplacements.

Ce code peut toujours vous servir de point de départ.

Voici les sources (commentées), mais si toutes fois, vous avez besoin de compléments d'infos, laissez un commentaire.

Main.hx

class Main {
	public static function main():Void {
		new TowerDefense(flash.Lib.current);
	}
}

TowerDefense.hx

import flash.display.Sprite;
import flash.display.MovieClip;
import flash.events.Event;
import Monster;
	
class TowerDefense extends Sprite {
	
	private var _root : MovieClip;
	
	private static inline var nbMonsters : Int = 10; // nombre de monstre sur le niveau
	
	private static inline var tileSize : Int = 40; // taille d'une tuile
	// le tableau du niveau
	private static inline var map : Array< Int> = [  [0,1,0,0,0,0,0,0,0],
                                                         [0,1,1,1,0,1,1,1,0],
                                                         [0,0,0,1,0,1,0,1,0],
                                                         [0,0,0,1,1,1,0,1,0],
                                                         [0,0,0,0,0,0,0,1,0] ];

	// suite des différents points (x et y) determinant le chemin que doivent emprunter les monstres
	private static inline var waypoint_x : Array = [60, 140, 140, 220, 220, 300, 300];
	private static inline var waypoint_y : Array = [60, 60, 140, 140, 60, 60, 240];
		
	// List dans laquelle nous allons stocker tous les monstres
	private var _listMonster : List;
		
	/**
	 * Constructeur
	 */
	public function new(parent:MovieClip):Void {
		super();
		_root = parent;
		_root.addChild(this);
		startGame();
	}
	
	private function startGame():Void {
		initMap();
		initGame();
		// création de l'ecouteur principal
		addEventListener(Event.ENTER_FRAME, loopGame);
	}
	
	/**
	 * Initialisation du niveau, création des tuiles via les méthodes de dessin
	 * Pour chaque case du tableau, si elle est égale à 1, 
	 * nous colorons la case en blanc, ce qui correspond au chemin,
	 * sinon, en noir
	 */
	private function initMap():Void {
		var map_width : Int = map[0].length;
		var map_height : Int = map.length;
		var _x : Int;
		var _y : Int;
		var color : UInt;
		for(_y in 0...map_height) {
			for(_x in 0...map_width) {
				if(map[_y][_x] == 1) {
					color = 0xFFFFFF; // soucis car ne lis pas le tableau comme il faut
				}
				else
					color = 0x000000;
				graphics.beginFill(color);
				graphics.drawRect(tileSize*_x, tileSize*_y, tileSize, tileSize);
				graphics.endFill();
			}
		}
	}
	
	/**
	 * Initialisation du jeu, création des différents monstres, 
	 * et ajout sur la liste d'affichage
	 */
	private function initGame():Void {
		_listMonster = new List();
		var i : Int;
		var monster : Monster;
		for(i in 0...nbMonsters) {
			monster = new Monster(60, -40*i);
			addChild(monster);
			_listMonster.add(monster);
		}
	}
	
	/**
	 * Boucle principale du jeu, déplacements des monstres
	 */
	private function loopGame(evt:Event):Void {
		var monster : Monster;
		// pour chaque monstre
		for (monster in _listMonster){
			monster.move(waypoint_x[monster.point_to_reach], waypoint_y[monster.point_to_reach]);
			// gestion de la sortie
			if(monster.x > map[0].length * tileSize || monster.y > map.length * tileSize ) {
				removeChild(monster);
				_listMonster.remove(monster);
			}
		}
	}
	
}

Monster.hx

import flash.display.Sprite;

class Monster extends Sprite {
	private var _speed : Float;
        // position dans le tableau du prochain point de destination
	private var _point_to_reach : Int; 
	private var _size : Int;
	
	/**
	 * @params : Points initials
	 */
	public function new(init_x: Int, init_y:Int):Void {
		super();
                init(init_x, init_y);
	}
	
	// Accesseurs
	public var point_to_reach(getPoint, setPoint) : Int;
	private function getPoint(): Int { return _point_to_reach; }
	private function setPoint(value : Int):Int { 
		_point_to_reach = value;
		return _point_to_reach;
	}
	
	/**
	 * Initialisation du monstre, et dessin de celui-ci 
	 * (un triangle rouge)
	 */
	private function init(_x:Int, _y:Int):Void {
		_size = 20;
		x = _x;
		y = _y;
		_speed = 0.5;
		_point_to_reach = 0;
		graphics.beginFill(0xFF0000);
		graphics.lineStyle(1, 0xFF0000);
		graphics.moveTo(-_size/2, -_size/2);
                graphics.lineTo(_size/2, -_size/2);
		graphics.lineTo(0, _size/2);
		graphics.lineTo(-_size/2, -_size/2);
		graphics.endFill();
	}
	
	/**
	 * Déplacement du monstre :
	 *		On détermine la distance entre celui-ci et le point a attendre
	 *		On vérifi que le monstre n'ai pas deja atteind le point, si c'est le cas, on passe au suivant
	 *		On determine l'angle que doit emprunter le monstre pour atteindre le point
	 */
	public function move(point_x : Int, point_y : Int):Void {
		var dist_x : Float = point_x - x;
		var dist_y : Float = point_y - y;
		
		if ((Math.abs(dist_x)+Math.abs(dist_y)) < 1) _point_to_reach++;
		
		var angle : Float = Math.atan2(dist_y, dist_x);
		x += _speed*Math.cos(angle);
		y += _speed*Math.sin(angle);
		rotation = angle/Math.PI*180-90;
	}
}

Et pour finir, un petit aperçu du rendu :