parse static method

Layer parse(Parser parser)

Implementation

static Layer parse(Parser parser) {
  final type = parser.formatSpecificParsing(
    (json) => json.getLayerType('type'),
    (xml) => LayerTypeExtension.parseFromTmx(xml.element.name.toString()),
  );

  final id = parser.getIntOrNull('id');
  final name = parser.getString('name', defaults: '');
  final class_ = parser.getStringOrNull('class');
  final x = parser.getInt('x', defaults: 0);
  final y = parser.getInt('y', defaults: 0);
  final offsetX = parser.getDouble('offsetx', defaults: 0);
  final offsetY = parser.getDouble('offsety', defaults: 0);
  final parallaxX = parser.getDouble('parallaxx', defaults: 1);
  final parallaxY = parser.getDouble('parallaxy', defaults: 1);
  final startX = parser.getIntOrNull('startx');
  final startY = parser.getIntOrNull('starty');
  final tintColorHex = parser.getStringOrNull('tintcolor');
  final tintColor = parser.getColorOrNull('tintcolor');
  final opacity = parser.getDouble('opacity', defaults: 1);
  final visible = parser.getBool('visible', defaults: true);
  final properties = parser.getProperties();

  final Layer layer;
  switch (type) {
    case LayerType.tileLayer:
      final width = parser.getInt('width');
      final height = parser.getInt('height');
      final dataNode = parser.formatSpecificParsing(
        (json) => null, // data is just a string or list of int on JSON
        (xml) => xml.getSingleChildOrNull('data'),
      );
      final compression = parser.getCompressionOrNull('compression') ??
          dataNode?.getCompressionOrNull('compression');
      final encoding = parser.getFileEncodingOrNull('encoding') ??
          dataNode?.getFileEncodingOrNull('encoding') ??
          FileEncoding.csv;
      Chunk parseChunk(Parser e) => Chunk.parse(e, encoding, compression);
      final chunks = parser.getChildrenAs('chunks', parseChunk) +
          (dataNode?.getChildrenAs('chunk', parseChunk) ?? []);
      final data = dataNode != null
          ? parseLayerData(dataNode, encoding, compression)
          : null;
      layer = TileLayer(
        id: id,
        name: name,
        class_: class_,
        x: x,
        y: y,
        offsetX: offsetX,
        offsetY: offsetY,
        parallaxX: parallaxX,
        parallaxY: parallaxY,
        startX: startX,
        startY: startY,
        tintColorHex: tintColorHex,
        tintColor: tintColor,
        opacity: opacity,
        visible: visible,
        properties: properties,
        width: width,
        height: height,
        compression: compression,
        encoding: encoding,
        chunks: chunks,
        data: data,
      );
      break;
    case LayerType.objectGroup:
      final drawOrder = parser.getDrawOrder(
        'draworder',
        defaults: DrawOrder.topDown,
      );
      final colorHex =
          parser.getString('color', defaults: ObjectGroup.defaultColorHex);
      final color =
          parser.getColor('color', defaults: ObjectGroup.defaultColor);
      final objects = parser.getChildrenAs('object', TiledObject.parse);
      layer = ObjectGroup(
        id: id,
        name: name,
        class_: class_,
        x: x,
        y: y,
        offsetX: offsetX,
        offsetY: offsetY,
        parallaxX: parallaxX,
        parallaxY: parallaxY,
        startX: startX,
        startY: startY,
        tintColorHex: tintColorHex,
        tintColor: tintColor,
        opacity: opacity,
        visible: visible,
        properties: properties,
        drawOrder: drawOrder,
        objects: objects,
        colorHex: colorHex,
        color: color,
      );
      break;
    case LayerType.imageLayer:
      final transparentColorHex = parser.getStringOrNull('transparentcolor');
      final transparentColor = parser.getColorOrNull('transparentcolor');
      final image = parser.getSingleChildAs('image', TiledImage.parse);
      final repeatX = parser.getBool('repeatx', defaults: false);
      final repeatY = parser.getBool('repeaty', defaults: false);
      layer = ImageLayer(
        id: id,
        name: name,
        class_: class_,
        x: x,
        y: y,
        offsetX: offsetX,
        offsetY: offsetY,
        parallaxX: parallaxX,
        parallaxY: parallaxY,
        repeatX: repeatX,
        repeatY: repeatY,
        startX: startX,
        startY: startY,
        tintColorHex: tintColorHex,
        tintColor: tintColor,
        opacity: opacity,
        visible: visible,
        properties: properties,
        image: image,
        transparentColorHex: transparentColorHex,
        transparentColor: transparentColor,
      );
      break;
    case LayerType.group:
      final layers = parseLayers(parser);
      layer = Group(
        id: id,
        name: name,
        class_: class_,
        x: x,
        y: y,
        offsetX: offsetX,
        offsetY: offsetY,
        parallaxX: parallaxX,
        parallaxY: parallaxY,
        startX: startX,
        startY: startY,
        tintColorHex: tintColorHex,
        tintColor: tintColor,
        opacity: opacity,
        visible: visible,
        properties: properties,
        layers: layers,
      );
      break;
  }

  return layer;
}