TiledParser

TiledParser.java

package wow.game.world;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import wow.game.WoW;
import wow.net.util.Logger;

/**
 * Used for TiledMap(tmx) parsing.
 * @author Xolitude (November 9, 2018)
 *
 */
public class TiledParser implements Runnable {
	
	private final File mapDirectory = new File("resources/maps");
	private final File tilesetDirectory = new File(mapDirectory+"/tilesets/");
	
	private ArrayList<File> mapsToParse = new ArrayList<File>();
	private ArrayList<File> parsedMaps = new ArrayList<File>();
	private ArrayList<File> tilesetList =  new ArrayList<File>();
	
	private Thread thread;
	
	public TiledParser() {
		for (File f : mapDirectory.listFiles()) {
			if (f.isFile()) {
				mapsToParse.add(f);
			}
		}
		for (File f : tilesetDirectory.listFiles()) {
			if (f.isFile()) {
				tilesetList.add(f);
			}
		}
	}
	
	public void start() {
		Logger.write(String.format("Starting to parse %s maps...", mapsToParse.size()));
		
		thread = new Thread(this, "parser_thread");
		thread.start();
	}

	@Override
	public void run() {
		long start = System.currentTimeMillis();
		do {
			File mapFile = mapsToParse.get(0);
			TiledMap map = new TiledMap();
			
			Document mapDoc = null;
			try {
				DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
				DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
				mapDoc = dBuilder.parse(mapFile);
				mapDoc.getDocumentElement().normalize();
				
				map.Width = Integer.valueOf(mapDoc.getDocumentElement().getAttribute("width"));
				map.Height = Integer.valueOf(mapDoc.getDocumentElement().getAttribute("height"));
				
				/** tileW+H used in the tileset generation. **/
				map.TileWidth = Integer.valueOf(mapDoc.getDocumentElement().getAttribute("tilewidth"));
				map.TileHeight = Integer.valueOf(mapDoc.getDocumentElement().getAttribute("tileheight"));
			} catch (SAXException | IOException e) {
				e.printStackTrace();
			} catch (ParserConfigurationException e) {
				e.printStackTrace();
			}
			
			NodeList tilesetNodeList = mapDoc.getElementsByTagName("tileset");
			for (int i = 0; i < tilesetNodeList.getLength(); i++) {
				Tileset tileset = new Tileset();
				
				Node tilesetNode = tilesetNodeList.item(i);
				if (tilesetNode.getNodeType() == Node.ELEMENT_NODE) {
					Element tilesetNodeElement = (Element) tilesetNode;
					tileset.FirstGridID = Integer.valueOf(tilesetNodeElement.getAttribute("firstgid"));
					tileset.TileWidth = map.TileWidth;
					tileset.TileHeight = map.TileHeight;
					tileset.TileCount = Integer.valueOf(tilesetNodeElement.getAttribute("tilecount"));
					tileset.Columns = Integer.valueOf(tilesetNodeElement.getAttribute("columns"));
				}
				Node tilesetImageData = tilesetNode.getChildNodes().item(1);
				if (tilesetImageData.getNodeType() == Node.ELEMENT_NODE) {
					Element tilesetImageDataElement = (Element) tilesetImageData;
					
					for (File f : tilesetList) {
						if (f.getName().equalsIgnoreCase(tilesetImageDataElement.getAttribute("source"))) {
							tileset.ImageSrc = f;
							tileset.ImageWidth = Integer.valueOf(tilesetImageDataElement.getAttribute("width"));
							tileset.ImageHeight = Integer.valueOf(tilesetImageDataElement.getAttribute("height"));
						}
					}
				}
				map.addTileset(tileset);
			}
			
			NodeList layerNodeList = mapDoc.getElementsByTagName("layer");
			for (int i = 0; i < layerNodeList.getLength(); i++) {
				TiledLayer layer = new TiledLayer();
				ArrayList<Integer> tileGridIds = new ArrayList<Integer>();
				
				Node layerNode = layerNodeList.item(i);
				if (layerNode.getNodeType() == Node.ELEMENT_NODE) {
					Element layerNodeElement = (Element) layerNode;
					
					layer.Name = layerNodeElement.getAttribute("name");
					layer.Width = Integer.valueOf(layerNodeElement.getAttribute("width"));
					layer.Height = Integer.valueOf(layerNodeElement.getAttribute("height"));
					
					NodeList layerTileNodeList = layerNodeElement.getElementsByTagName("tile");
					for (int ii = 0; ii < layerTileNodeList.getLength(); ii++) {
						Node layerTileNode = layerTileNodeList.item(ii);
						
						if (layerTileNode.getNodeType() == Node.ELEMENT_NODE) {
							Element layerTileElement = (Element) layerTileNode;
							tileGridIds.add(Integer.valueOf(layerTileElement.getAttribute("gid")));
						}
					}
					layer.TileGridIDs = tileGridIds;
				}
				map.addLayer(layer);
			}
			WoW.addMap(map);
			mapsToParse.remove(mapFile);
		} while (mapsToParse.size() > 0);
		long stop = System.currentTimeMillis();
		System.out.println(String.format("Loaded maps in %sms", stop - start));
	}
}