QM TileDObjects MV

//=============================================================================
// QM TileDObjects
//=============================================================================

if (!Imported.QMovement || !QPlus.versionCheck(Imported.QMovement, '1.2.0')) {
  alert('Error: QM+ColliderMap requires QMovement 1.2.0 or newer to work.');
  throw new Error('Error: QM+ColliderMap requires QMovement 1.2.0 or newer to work.');
}

Imported.QMTileDObjects = '1.0.0';

//=============================================================================
/*:
 * @plugindesc <QMTileDObjects>
 * QMovement Addon: Allows you to use Colliders from TileD
 * @version 1.0.0
 * @author Gamepeon  | Version 1.0.0
 * @site https://quxios.github.io/
 * @updateurl https://quxios.github.io/data/pluginsMin.json
 *
 * @requires QMovement
 *
 * @help
 * ============================================================================
 * ## About
 * ============================================================================
 * This is an addon to QMovement plugin. This addon adds a feature that lets
 * you use collision created in TileD.
 */
 //=============================================================================

//=============================================================================
// QM TileD

(function() {
  var _PROPS = [
    'note',
    'isTile', 'terrain', 'color',
    'isWater1', 'isWater2',
    'isLadder', 'isBush', 'isCounter', 'isDamage'
  ]

var Alias_Game_Map_reloadTileMap = Game_Map.prototype.reloadTileMap;
	Game_Map.prototype.reloadTileMap = function() {
	Alias_Game_Map_reloadTileMap.call(this);
	this.setupColliderMap();
};



Game_Map.prototype.addTileDCollisionObject = function( x, y, object, tileWidth, tileHeight) {

	var collider = null;

	x += object.x;
	y += object.y;
	if ( object.polygon ) {

		// Polygon
		if (object.polygon === undefined || object.polygon.length < 3)
			return;

		collider = new Polygon_Collider(object.polygon, x, y);



	} else if ( object.polyline ) {

		/*
		// Polyline
		var polylines;
		if ( object.polyline.length == 2 ) {
		  polylines = Collider.createPolygon( [
			[x + ( object.polyline[0].x / tileWidth ), y + ( object.polyline[0].y / tileWidth )],
			[x + ( object.polyline[1].x / tileHeight ), y + ( object.polyline[1].y / tileHeight )]
		  ] );
		} else {
		  polylines = Collider.createList();
		  for ( var ii = 0; ii < ( object.polyline.length - 1 ); ii++ ) {
			Collider.addToList( polylines, Collider.createPolygon( [
			  [x + ( object.polyline[ii].x / tileWidth ), y + ( object.polyline[ii].y / tileWidth )],
			  [x + ( object.polyline[ii + 1].x / tileHeight ), y + ( object.polyline[ii + 1].y / tileHeight )]
			] ) );
		  }
		}

		colliders.push( polylines );
		*/
	} else if ( object.ellipse ) {

		console.log("Object is ellipse collider at x: " + x + " y:" + y + " w:" + tileWidth + " h:" + tileHeight);

		// Ellipse
		collider = new Circle_Collider(object.width, object.height, x, y);

	} else {

		console.log("Object is rect collider at x: " + x + " y:" + y + " w:" + tileWidth + " h:" + tileHeight);

		// Rect
		collider = new Box_Collider(object.width, object.height, x, y);

	}

	if(collider != null)
		ColliderManager.addCollider(collider, -1);

};


Game_Map.prototype.setupColliderMap = function() {
	var tileWidth = $gameMap.tileWidth();
	var tileHeight = $gameMap.tileHeight();
	var tilesetColliders = [];

	// Build tile colliders

	if($gameMap.tiledData == undefined)
		return;

	var tilesets = $gameMap.tiledData.tilesets;

	for ( var ii = 0; ii < tilesets.length; ii++ ) {
	  tilesetColliders[ii] = {};

	  var tiles = tilesets[ii].tiles;
	  for ( var key in tiles ) {
		if ( tiles[key].objectgroup ) {
		  tilesetColliders[ii][key] = tiles[key].objectgroup.objects;
		}
	  }
	}

	// Place tile colliders
	for ( var ii = 0; ii < $gameMap.tiledData.layers.length; ii++ ) {
	  var layer = $gameMap.tiledData.layers[ii];
	  for ( var yy = 0; yy < layer.height; yy++ ) {
		var row = yy * layer.width;
		for ( var xx = 0; xx < layer.width; xx++ ) {
		  var tileId = layer.data[row + xx];
		  if ( tileId === 0 ) {
			continue;
		  }
		  tileId++;

		  // Find tileset belonging to tileId
		  var tilesetId = -1;
		  var firstId = 0;
		  for ( var jj = 0; jj < $gameMap.tiledData.tilesets.length; jj++ ) {
			firstId = $gameMap.tiledData.tilesets[jj].firstgid;
			var lastId = firstId + $gameMap.tiledData.tilesets[jj].tilecount;
			if ( tileId >= firstId && tileId <= lastId ) {
			  tilesetId = jj;
			  break;
			}
		  }
		  if ( tilesetId < 0 ) {
			continue;
		  }

		  // Get objectGroup for this tileId
		  var tileSet = tilesetColliders[tilesetId];
		  var objectGroup = tileSet['' + ( tileId - firstId - 1 )];
		  if ( objectGroup ) {
			for ( var jj = 0; jj < objectGroup.length; jj++ ) {
			  var object = objectGroup[jj];
			  var x = xx * scale;
			  var y = yy * scale;
			  this.addTileDCollisionObject( x, y, object, tileWidth, tileHeight);
			}
		  }
		}
	  }
	}

	// Find collision mesh layers
	for ( var ii = 0; ii < $gameMap.tiledData.layers.length; ii++ ) {
	  var layer = $gameMap.tiledData.layers[ii];
	  if ( layer.type == "objectgroup" && layer.properties && layer.properties.collision == "mesh" ) {
		for ( var jj = 0; jj < layer.objects.length; jj++ ) {
		  this.addTileDCollisionObject( 0, 0, layer.objects[jj], tileWidth, tileHeight);
		}
	  }
	}


  };
})()