before camera logic

Author: SeiferTim

assets/images/enemies.png

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<TextureAtlas imagePath="002a-sprites.png">
+	<!--
+	Created with ShoeBox
+	http://renderhjs.net/shoebox/
+	-->
+	<SubTexture name="001a.png"	x="18"	y="15"	width="11"	height="13" frameX="-2" frameY="-3" frameWidth="16" frameHeight="16"/>
+	<SubTexture name="001b.png"	x="18"	y="0"	width="12"	height="13" frameX="-2" frameY="-3" frameWidth="16" frameHeight="16"/>
+	<SubTexture name="002a.png"	x="0"	y="0"	width="16"	height="16" frameX="-0" frameY="-0" frameWidth="16" frameHeight="16"/>
+	<SubTexture name="002b.png"	x="0"	y="18"	width="16"	height="15" frameX="-0" frameY="-1" frameWidth="16" frameHeight="16"/>
+</TextureAtlas>

assets/images/enemies.xml

@@ -0,0 +1,7 @@
+package;
+
+class Constants
+{
+	// Global tile size used throughout the game (pixels)
+	public static inline var TILE_SIZE:Int = 16;
+}

source/Constants.hx

@@ -0,0 +1,93 @@
+package;
+
+import flixel.FlxG;
+import flixel.graphics.frames.FlxAtlasFrames;
+import haxe.ds.StringMap;
+
+class Enemy extends GameObject
+{
+	// shared frames and variant list (initialized once)
+	public static var SHARED_FRAMES:FlxAtlasFrames = null;
+	public static var VARIANTS:Array<String> = [];
+	// map from variant id -> array of frame names (as present in the atlas)
+	public static var VARIANT_FRAMES:StringMap<Array<String>> = null;
+
+	private static function ensureFrames():Void
+	{
+		if (SHARED_FRAMES != null)
+			return;
+		SHARED_FRAMES = FlxAtlasFrames.fromSparrow("assets/images/enemies.png", "assets/images/enemies.xml");
+		VARIANTS = [];
+		VARIANT_FRAMES = new StringMap<Array<String>>();
+
+		// Iterate atlas frames and collect prefixes where frame names end with a single letter suffix (a,b,c...)
+		for (f in 0...SHARED_FRAMES.numFrames)
+		{
+			var rawName:String = SHARED_FRAMES.getByIndex(f).name;
+			// strip extension if present
+			var base = rawName;
+			var dot = base.lastIndexOf('.');
+			if (dot >= 0)
+				base = base.substr(0, dot);
+			if (base.length < 2)
+				continue;
+			var lastChar = base.charAt(base.length - 1);
+			if (lastChar >= 'a' && lastChar <= 'z')
+			{
+				var prefix = base.substr(0, base.length - 1);
+				var list = VARIANT_FRAMES.get(prefix);
+				if (list == null)
+				{
+					list = [];
+					VARIANT_FRAMES.set(prefix, list);
+					VARIANTS.push(prefix);
+				}
+				// store the atlas frame name (use rawName as that's what the atlas uses)
+				list.push(rawName);
+			}
+		}
+	}
+
+	public static function pickVariant():String
+	{
+		ensureFrames();
+		if (VARIANTS == null || VARIANTS.length == 0)
+			return null;
+		var idx:Int = Std.int(FlxG.random.float() * VARIANTS.length);
+		if (idx < 0)
+			idx = 0;
+		if (idx >= VARIANTS.length)
+			idx = VARIANTS.length - 1;
+		return VARIANTS[idx];
+	}
+
+	public function new(tileX:Int, tileY:Int, ?variant:String)
+	{
+		super(tileX, tileY);
+		speed = 50;
+	}
+
+	public override function buildGraphics():Void
+	{
+		ensureFrames();
+		if (SHARED_FRAMES != null)
+		{
+			this.frames = SHARED_FRAMES;
+			var variant:String = pickVariant();
+			if (variant != null)
+			{
+				var names = VARIANT_FRAMES.get(variant);
+				if (names != null && names.length > 0)
+				{
+					animation.addByNames(variant, names, 12, true);
+					animation.play(variant);
+				}
+				else
+				{
+					animation.addByPrefix(variant, variant, 12, true);
+					animation.play(variant);
+				}
+			}
+		}
+	}
+}

source/Enemy.hx

@@ -41,7 +41,7 @@ class GameMap extends FlxGroup
 
 	public function generate():Void
 	{
-		var TILE_SIZE:Int = 16;
+		var TILE_SIZE:Int = Constants.TILE_SIZE;
 		var tilesWide:Int = Std.int(FlxG.width / TILE_SIZE);
 		var tilesHigh:Int = Std.int(FlxG.height / TILE_SIZE);
 		var totalW:Int = Std.int(Math.max(48, tilesWide * 4));
@@ -187,8 +187,36 @@ class GameMap extends FlxGroup
 			// increase room fraction so rooms are larger (65% - 90% of partition)
 			var rW = Std.int(Math.max(3, maxRW * (0.65 + FlxG.random.float() * 0.25)));
 			var rH = Std.int(Math.max(3, maxRH * (0.65 + FlxG.random.float() * 0.25)));
-			var rx = leaf.x + margin + Std.int(FlxG.random.float() * Math.max(0, leaf.w - rW - margin * 2));
-			var ry = leaf.y + margin + Std.int(FlxG.random.float() * Math.max(0, leaf.h - rH - margin * 2));
+			// Try to pick a room position that keeps some separation from existing rooms
+			var minRoomSeparation:Int = 6; // tiles
+			var attemptsPos:Int = 0;
+			var rx:Int = 0;
+			var ry:Int = 0;
+			var maxPosAttempts:Int = 12;
+			while (attemptsPos < maxPosAttempts)
+			{
+				attemptsPos++;
+				rx = leaf.x + margin + Std.int(FlxG.random.float() * Math.max(0, leaf.w - rW - margin * 2));
+				ry = leaf.y + margin + Std.int(FlxG.random.float() * Math.max(0, leaf.h - rH - margin * 2));
+				var cxTry = rx + Std.int(rW / 2);
+				var cyTry = ry + Std.int(rH / 2);
+				var okPos:Bool = true;
+				// check against already placed rooms' centroids
+				for (existingRoom in roomsInfo)
+				{
+					if (existingRoom == null)
+						continue;
+					var exC:Int = Std.int(existingRoom.centroid.x);
+					var eyC:Int = Std.int(existingRoom.centroid.y);
+					if (Math.abs(exC - cxTry) <= minRoomSeparation && Math.abs(eyC - cyTry) <= minRoomSeparation)
+					{
+						okPos = false;
+						break;
+					}
+				}
+				if (okPos)
+					break;
+			}
 
 			var cx = rx + Std.int(rW / 2);
 			var cy = ry + Std.int(rH / 2);
@@ -496,17 +524,48 @@ class GameMap extends FlxGroup
 					walkableTiles.push(yy * totalW + xx);
 
 		// --- pick a random room as the portal room and a random tile within it ---
+		// Prefer small-to-medium rooms so the player doesn't start in a huge empty room.
 		portalRoomIndex = -1;
 		portalTileX = portalTileY = -1;
 		portalPixelX = portalPixelY = -1;
-		var candidateRooms:Array<Int> = [];
+		// Build list of valid rooms (non-corridor, positive area)
+		var validRooms:Array<Int> = [];
 		for (i in 0...roomsInfo.length)
 		{
-			if (roomsInfo[i].area > 0)
-				candidateRooms.push(i);
+			var rr:RoomInfo = roomsInfo[i];
+			if (rr != null && rr.area > 0 && !rr.isCorridor)
+				validRooms.push(i);
 		}
-		if (candidateRooms.length > 0)
+		if (validRooms.length > 0)
 		{
+			// Compute a size cutoff around the 60th percentile to prefer small/medium rooms
+			var areas:Array<Int> = [];
+			for (idx in validRooms)
+				areas.push(roomsInfo[idx].area);
+			areas.sort(function(a:Int, b:Int):Int
+			{
+				return a - b;
+			});
+			var cutoffIndex:Int = Std.int(Math.floor(validRooms.length * 0.6));
+			if (cutoffIndex < 0)
+				cutoffIndex = 0;
+			if (cutoffIndex >= areas.length)
+				cutoffIndex = areas.length - 1;
+			var cutoffArea:Int = areas[cutoffIndex];
+
+			// Choose candidate rooms that are <= cutoffArea but not trivially small
+			var candidateRooms:Array<Int> = [];
+			for (idx in validRooms)
+			{
+				var rr2:RoomInfo = roomsInfo[idx];
+				if (rr2.area <= cutoffArea && rr2.area >= 6)
+					candidateRooms.push(idx);
+			}
+
+			// Fallback: if none match the heuristic, use all valid rooms
+			if (candidateRooms.length == 0)
+				candidateRooms = validRooms;
+
 			var ri:Int = Std.int(FlxG.random.float() * candidateRooms.length);
 			if (ri < 0)
 				ri = 0;

source/GameMap.hx

@@ -2,24 +2,59 @@ package;
 
 import flixel.FlxSprite;
 
+
 class GameObject extends FlxSprite
 {
-	public var speed:Float = 80;
+	public var speed(default, set):Float = 80;
 	public var moveAngle:Float = 0;
 
-	public function new(X:Float = 0, Y:Float = 0)
+	// Constructor expects pixel coordinates (top-left). `x`/`y` are pixel
+	// positions where the object should spawn (commonly tileX * TILE_SIZE).
+	// GameObject will call `buildGraphics()` and apply the standard inset
+	// hitbox so subclasses only need to override `buildGraphics()`.
+	public function new(x:Int = 0, y:Int = 0)
+	{
+		// call FlxSprite with a 1px inset so sprite sits inside the tile
+		super(x + 1, y + 1);
+		// initialize maxVelocity via the speed setter
+		speed = speed;
+
+		// Let subclass set up graphics/frames, then apply the standard inset hitbox
+		buildGraphics();
+		setOffsetAmount(1);
+	}
+
+	// Set a symmetric inset (in pixels) from each tile edge. For Size=1 and
+	// TILE_SIZE=16 this gives width=height=14 and offset=1.
+	public function setOffsetAmount(Size:Int):Void
 	{
-		super(X, Y);
-		maxVelocity.set(speed, speed);
+		var ts = Constants.TILE_SIZE;
+		var w = ts - Size * 2;
+		this.width = w;
+		this.height = w;
+		this.offset.x = Size;
+		this.offset.y = Size;
 	}
 
+	// Subclasses should override this to load graphics/animations. It is not
+	// called automatically so they can control ordering (e.g. pick a variant
+	// then load frames). Callers should call `buildGraphics()` and then
+	// `setOffsetAmount(1)` from the subclass constructor.
+	public function buildGraphics():Void {}
+
 	public function move(angleDegrees:Float):Void
 	{
 		moveAngle = angleDegrees;
 		var rad:Float = angleDegrees * Math.PI / 180.0;
 		velocity.set(Math.cos(rad) * speed, Math.sin(rad) * speed);
 	}
 
+	private function set_speed(Value:Float):Float
+	{
+		maxVelocity.set(Value, Value);
+		return Value;
+	}
+
 	public function stop():Void
 	{
 		velocity.set(0, 0);

source/GameObject.hx

@@ -8,6 +8,6 @@ class Main extends Sprite
 	public function new()
 	{
 		super();
-		addChild(new FlxGame(640, 480, PlayState));
+		addChild(new FlxGame(320, 240, PlayState));
 	}
 }