xlxin il y a 1 an
Parent
commit
4e5e053f39

BIN
TileFamily/TileLevelScript/.DS_Store


+ 328 - 0
TileFamily/TileLevelScript/jsonToProto.py

@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*-
+import os
+import os.path
+import sys
+import json
+import levelData_pb2
+import csv
+
+# 获取当前工作目录
+current_dir = os.getcwd()
+# 获取脚本所在的目录
+script_dir = os.path.dirname(os.path.abspath(__file__))
+# 改变当前工作目录
+os.chdir(script_dir)
+
+jsDir = "./loadable/"
+
+# 所有关卡文件的信息,key为关卡文件名,value是一个dict,包含关卡文件的信息
+lvFileInfo = {}
+templateInfo = {}    # 模版信息
+
+# 所有关卡的信息,key为关卡id,value是一个dict,包含关卡的信息
+lvInfo = {}
+
+def parseLvid():
+    global lvFileInfo, lvInfo
+    with open("../config_level.csv", 'r') as lcf:
+        # csv 文件,格式如下:
+        # LevelId,Des,TemplateId,RandomType,DupPara1,DupPara2,DupPara3,DupPara4,DupPara5,DupPara6,DupPara7,DupPara8,DupPara9,DupPara10
+        # string,string,string,int,array,array,array,array,array,array,array,array,array,array
+        # 关卡 id,备注,模板 id,0=固定按第n次玩来取副本,1=随机取,第1次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第2次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第3次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第4次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第5次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第6次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第7次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第8次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第9次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数),第10次及之后玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数)
+        # toolguide01,,undo01,0,1|0|100|1,1|0|100|1,1|0|100|1,1|0|100|1,1|0|100|1,1|0|100|1,1|0|100|1,1|0|100|1,1|0|100|1,1|0|100|1
+        # 将 csv 文件转为 dict,存放到 lvFileInfo 中;忽略前两行,并将第3行作为 dict 的 key,后面的行作为 value
+        lcf.readline()
+        lcf.readline()
+        keys = lcf.readline().strip().split(',')
+        for line in lcf:
+            line = line.strip()
+            if len(line) == 0:
+                continue
+            if line[0] == '#':
+                continue
+            line = line.split(',')
+            lvFileInfo[line[0]] = dict(zip(keys, line))
+    with open("../config_level_list.csv") as cllf:
+        # csv 文件,格式如下:
+        # LevelIndex,LevelType,LevelCoin,RewardCoinMultiple,LevelId,DDALevelId1,DDALevelId2,DDALevelId3,DDAType,DDAMatrix,LevelDuration,LevelCoinPercentage
+        # int,int,int,int,array,array,array,array,int,array,int,int
+        # 第几关,关卡类型,0=普通,1=Hard,2=SuperHard,3=金币,基础金币奖励值。结算金币数=0时不显示。,用户看完广告后获得的金币倍数,关卡 id,关卡 id,关卡 id,关卡 id,DDA 类型,0=不走DDA(取 LevelId 列),1=走DDA,2=考试关(取 LevelId 列),DDA 参数,金币关的关卡时长(单位秒),最高100分钟,即6000s,金币tile的比例(单位为%,取值0-100)
+        # 1,0,0,0,tempnm0017,tempnm0017,tempnm0017,tempnm0017,0,0|100,,
+        # 将 csv 文件转为 dict,存放到 lvInfo 中;忽略前两行,并将第3行作为 dict 的 key,后面的行作为 value
+        cllf.readline()
+        cllf.readline()
+        keys = cllf.readline().strip().split(',')
+        for line in cllf:
+            line = line.strip()
+            if len(line) == 0:
+                continue
+            if line[0] == '#':
+                continue
+            line = line.split(',')
+            lvInfo[line[0]] = dict(zip(keys, line))
+    pass
+
+# 解析关卡的种子信息
+lvSeedInfo = {}
+def parseSeed():
+    global lvSeedInfo
+    with open("../lv_seed.txt") as cllf:
+        # TileManor输出的文件
+        # 每一行的格式:[Tile] resovler id: 30,735680|69576|719549|907289|550748|399652|246018|611094|979453|303995|269635|
+        # 去掉头部:"[Tile] resovler id: " 之后的数据分成两部分,第一部分是lvid,后面是一系列种子的列表
+        # 将这些数据存放到 lvSeedInfo 中,key为lvid,value为种子列表
+        for line in cllf:
+            line = line.strip()
+            if len(line) == 0:
+                continue
+            if line[0] == '#':
+                continue
+            fs = line.split(':')[1].split(',')
+            lvid = fs[0].strip()
+            seeds = fs[1].split('|')
+            lvSeedInfo[lvid] = seeds
+    pass
+
+def converJosnToProto(tDir, tFileName, leveId):
+    global lvFileInfo, lvInfo
+    jsonFile = os.path.join(tDir, tFileName + '.json')
+
+    with open(jsonFile, 'r') as f:#, encoding='utf-8'
+        jsonData = json.load(f)
+
+    levelData = levelData_pb2.LevelData()
+
+    levelData.tileWidth = jsonData['LevelWidth']
+    levelData.tileHeight = jsonData['LevelHeight']
+    cntUndefined = 0
+    tilesByPos = {}
+    maxZ = 0
+    maxX = 0
+    maxY = 0
+    for item in jsonData['LevelData']:
+        tile = levelData.tiles.add()
+        tile.x = int(item['X'])
+        tile.y = int(item['Y'])
+        tile.z = int(item['Z'])
+        tiledata = tile.tileData
+        tiledata.zv = 0
+        tiledata.weight = 0
+        tiledata.id = int(item['TileId'])
+        if tiledata.id == -10:
+            cntUndefined += 1
+        tiledata.type = 1
+        tiledata.subtype = 0
+        # 一些统计信息
+        tilesByPos[(tile.x, tile.y, tile.z)] = tile
+        if tile.z > maxZ:
+            maxZ = tile.z
+        if tile.x > maxX:
+            maxX = tile.x
+        if tile.y > maxY:
+            maxY = tile.y
+    # 根据上面的布局信息,计算每个tile的几个信息:
+    # 1. 每个tile的视觉层级(不同于上面z的信息,那是一个布局信息,相同的z可能出在不同的视觉层级)
+    # 从maxZ开始,逐层向下计算;对于每一个位置,如果该位置有tile,则计算该tile的视觉层级
+    # 对于每一个tile,如果其上方(从该tile的z+1层,一直到maxZ层)有tile,则其视觉层级为上方tile的视觉层级+1
+    for z in range(0, maxZ+1):
+        z = maxZ - z
+        for x in range(0, maxX+1):
+            for y in range(0, maxY+1):
+                if (x,y,z) in tilesByPos:
+                    tile = tilesByPos[(x, y, z)]
+                    adjs = [(x,y),(x,y+1),(x,y-1),(x+1,y),(x+1,y+1),(x+1,y-1),(x-1,y),(x-1,y-1),(x-1,y+1)]
+                    # 确定视觉层级
+                    zvMax = -1
+                    for zup in range(z+1, maxZ+1):
+                        for adj in adjs:
+                            if (adj[0],adj[1],zup) in tilesByPos:
+                                zv = tilesByPos[adj[0],adj[1],zup].tileData.zv
+                                if zv > zvMax:
+                                    zvMax = zv
+                    tile.tileData.zv = zvMax + 1
+    # 计算权重
+    # 从最底下开始,逐层向上计算
+    # 每个tile的初始权重为4,然后加上其下方压住的tile的权重:如果压了全部,则该加上被压住的tile权重;
+    # 如果压住了一半,则加上被压住的tile权重的一半;如果是压住1/4,则加上被压住的tile权重的1/4
+    for z in range(0, maxZ+1): 
+        for x in range(0, maxX+1):
+            for y in range(0, maxY+1):
+                if (x,y,z) in tilesByPos:
+                    tile = tilesByPos[(x,y,z)]
+                    adjs = [(x,y,1.0),(x,y+1,0.5),(x,y-1,0.5),(x+1,y,0.5),(x+1,y+1,0.25),(x+1,y-1,0.25),(x-1,y,0.5),(x-1,y-1,0.25),(x-1,y+1,0.25)]
+                    weight = 4
+                    for adj in adjs:
+                        # 从临近层往下,在某个位置找到了tile,则该tile被压住了,就不再找了
+                        for zb in range(0, z):
+                            zb = z-1-zb
+                            if (adj[0], adj[1], zb) in tilesByPos:
+                                tileB = tilesByPos[(adj[0], adj[1], zb)]
+                                weight += tileB.tileData.weight * adj[2]
+                                break
+                    tile.tileData.weight = int(weight)
+        pass
+
+    for item in jsonData['StackData']:
+        stack_data = levelData.stacks.add()
+        stack_data.x = int(item['X'])
+        stack_data.y = int(item['Y'])
+        stack_data.direction = int(item['Direction'])
+
+    templateInfo[tFileName] = {}
+    if cntUndefined == 0:
+        templateInfo[tFileName]['无未定义的tile'] = '1'
+    elif cntUndefined == len(jsonData['LevelData']):
+        templateInfo[tFileName]['所有tile都未被定义'] = '1'
+    else:
+        templateInfo[tFileName]['部分tile被定义'] = '1'
+    if len(jsonData['StackData']) > 0:
+        templateInfo[tFileName]['有stack数据'] = '1'
+    
+    # 数据序列化
+    level_protobuf_data = levelData.SerializeToString()
+    protoFile = os.path.join(jsDir, tFileName + '.bin')
+    with open(protoFile, 'w+b') as f:
+        f.write(level_protobuf_data)
+
+#关卡数据拼接map+trcuk
+def mergeLeveldata3(group = None):
+    lvelsIndex = levelData_pb2.LevelsIndex()
+    if group is not None:
+        protoDataTrunk = os.path.join(jsDir, 'levels-' + str(group) + '.bin')
+        protoDataIndex = os.path.join(jsDir, 'levelsIndex-' + str(group) + '.bin')
+    else:
+        protoDataTrunk = os.path.join(jsDir, 'levels' + '.bin')
+        protoDataIndex = os.path.join(jsDir, 'levelsIndex' + '.bin')
+
+    offset = 0
+    for filename in os.listdir(jsDir):
+        my_message = levelData_pb2.LevelData()
+        binFile = os.path.splitext(filename)[0] + '.bin'
+        binFile = os.path.join(jsDir, binFile)
+        if os.path.exists(binFile) :    
+            # print(binFile)        
+            with open(binFile, "rb") as f:
+                binary_data = f.read()
+                my_message.ParseFromString(binary_data)
+            with open(protoDataTrunk, 'ab') as f:
+                f.write(binary_data)
+            lvelsIndex.LevelsIndex[os.path.splitext(filename)[0]].len = len(binary_data)
+            lvelsIndex.LevelsIndex[os.path.splitext(filename)[0]].offset = offset
+            offset += len(binary_data)
+        
+    level_protobuf_index = lvelsIndex.SerializePartialToString()
+    with open(protoDataIndex, 'w+b') as f:
+        f.write(level_protobuf_index)
+
+if __name__ == '__main__':
+    parseLvid()
+    parseSeed()
+
+    folder_path = '../level_data2'
+    for filename in os.listdir(folder_path):
+        # 获取文件的绝对路径
+        file_path = os.path.join(folder_path, filename)
+
+        # 检查是否是文件而不是文件夹
+        if os.path.isfile(file_path):
+            base_name = os.path.splitext(filename)
+            # 在文件转为bin
+            converJosnToProto(folder_path, base_name[0],1)
+    mergeLeveldata3()
+            
+    # 将关卡id和模板的对应关系输出到文件
+    lv_stat = {}
+    got = False
+    for k, v in lvInfo.items():
+        levelId = v["关卡 id"]
+        templateId = lvFileInfo[levelId]["模板 id"]
+        if templateId not in templateInfo:
+            templateId += '_m'
+        if templateId in templateInfo:
+            # 将所有信息综合到一块
+            lv_stat[k] = lvFileInfo[levelId].copy()
+            for key in templateInfo[templateId].keys():
+                lv_stat[k][key] = templateInfo[templateId][key]
+            lv_stat[k]["关卡 id"] = levelId
+            lv_stat[k]["关卡类型"] = v["关卡类型,0=普通,1=Hard,2=SuperHard,3=金币"]
+            lv_stat[k]["dda_type"] = v["DDA 类型,0=不走DDA(取 LevelId 列),1=走DDA,2=考试关(取 LevelId 列)"]
+            lv_stat[k]["dda_para"] = v["DDA 参数"]
+            lv_stat[k]["模板 id"] = templateId
+    # 关卡与模版的对应关系,以及关卡本身的一些控制参数
+    with open("levelInfo.csv", 'w+') as f:
+        fieldnames = ["lvid","lvinst","type(normal=0,hard=1,superHard=2)","dda_type","dda_para"]
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for lvid in sorted(lv_stat.keys(), key=lambda x:int(x)):
+            d = {"lvid":lvid, "lvinst":"","type(normal=0,hard=1,superHard=2)":"","dda_type":"","dda_para":""}
+            d["lvinst"] = lv_stat[lvid]["关卡 id"]
+            d["type(normal=0,hard=1,superHard=2)"] = lv_stat[lvid]["关卡类型"]
+            d["dda_type"] = lv_stat[lvid]["dda_type"]
+            d["dda_para"] = lv_stat[lvid]["dda_para"]
+            writer.writerow(d)
+    # 模版的信息
+    with open("levelInstInfo.csv", 'w+') as f:
+        all_insts = set()
+        fieldnames = ["lvinst","template",
+                      "try1(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try2(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try3(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try4(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try5(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try6(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try7(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try8(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try9(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)",
+                      "try10(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)"]
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for lvid in sorted(lv_stat.keys(), key=lambda x:int(x)):
+            inst_id = lv_stat[lvid]["关卡 id"]
+            if inst_id not in all_insts:
+                all_insts.add(inst_id)
+            else:
+                continue
+            d = {"lvinst":"", "template":"",
+                  "try1(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try2(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try3(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try4(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try5(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try6(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try7(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try8(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try9(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":"",
+                  "try10(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)":""}
+            d["lvinst"] = lv_stat[lvid]["关卡 id"]
+            d["template"] = lv_stat[lvid]["模板 id"]
+            seeds = []
+            if lvid in lvSeedInfo:
+                seeds = lvSeedInfo[lvid]
+            for tried in range(1,11):
+                k1 = "第" + str(tried) + "次玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数)"
+                if tried == 10:
+                    k1 = "第10次及之后玩(ATile种类数 | 随机种子 | 塔副本幸运值 | BTile种类数)"
+                if k1 in lv_stat[lvid]:
+                    try1 = lv_stat[lvid][k1]
+                    tileA = try1.split('|')[0]
+                    tileB = try1.split('|')[3]
+                    tileCnt = tileA if int(tileA) > int(tileB) else tileB
+                    ps=[tileCnt,"0","0","100","100"]
+                    if tried <= len(seeds):
+                        ps.append(seeds[tried-1])
+                    else:
+                        ps.append("100")
+                    d["try" + str(tried)+"(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)"] = "|".join(ps)
+                else:
+                    d["try" + str(tried)+"(tileA|tileB|tileVar|indexTop3|indexPlusByZ|seed)"] = ""
+            writer.writerow(d)
+
+
+    # 导出关卡id和模板的对应关系,并输出模板的信息
+else:
+    print('ohoh')
+
+
+
+# 恢复原来的工作目录
+os.chdir(current_dir)

+ 1796 - 0
TileFamily/TileLevelScript/levelData.pb.cc

@@ -0,0 +1,1796 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: levelData.proto
+
+#include "levelData.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+constexpr LevelsIndex_LevelsIndexEntry_DoNotUse::LevelsIndex_LevelsIndexEntry_DoNotUse(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
+struct LevelsIndex_LevelsIndexEntry_DoNotUseDefaultTypeInternal {
+  constexpr LevelsIndex_LevelsIndexEntry_DoNotUseDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~LevelsIndex_LevelsIndexEntry_DoNotUseDefaultTypeInternal() {}
+  union {
+    LevelsIndex_LevelsIndexEntry_DoNotUse _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LevelsIndex_LevelsIndexEntry_DoNotUseDefaultTypeInternal _LevelsIndex_LevelsIndexEntry_DoNotUse_default_instance_;
+constexpr LevelsIndex::LevelsIndex(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : levelsindex_(){}
+struct LevelsIndexDefaultTypeInternal {
+  constexpr LevelsIndexDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~LevelsIndexDefaultTypeInternal() {}
+  union {
+    LevelsIndex _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LevelsIndexDefaultTypeInternal _LevelsIndex_default_instance_;
+constexpr t_offeset_len::t_offeset_len(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : offset_(0)
+  , len_(0){}
+struct t_offeset_lenDefaultTypeInternal {
+  constexpr t_offeset_lenDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~t_offeset_lenDefaultTypeInternal() {}
+  union {
+    t_offeset_len _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT t_offeset_lenDefaultTypeInternal _t_offeset_len_default_instance_;
+constexpr LevelData::LevelData(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : tiles_()
+  , stacks_()
+  , tilewidth_(0)
+  , tileheight_(0){}
+struct LevelDataDefaultTypeInternal {
+  constexpr LevelDataDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~LevelDataDefaultTypeInternal() {}
+  union {
+    LevelData _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT LevelDataDefaultTypeInternal _LevelData_default_instance_;
+constexpr t_tile::t_tile(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : tiledata_(nullptr)
+  , x_(0)
+  , y_(0)
+  , z_(0){}
+struct t_tileDefaultTypeInternal {
+  constexpr t_tileDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~t_tileDefaultTypeInternal() {}
+  union {
+    t_tile _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT t_tileDefaultTypeInternal _t_tile_default_instance_;
+constexpr t_tile_data::t_tile_data(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : type_(0)
+  , subtype_(0)
+  , id_(0)
+  , zv_(0)
+  , weight_(0){}
+struct t_tile_dataDefaultTypeInternal {
+  constexpr t_tile_dataDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~t_tile_dataDefaultTypeInternal() {}
+  union {
+    t_tile_data _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT t_tile_dataDefaultTypeInternal _t_tile_data_default_instance_;
+constexpr t_stack::t_stack(
+  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+  : tiledatas_()
+  , x_(0)
+  , y_(0)
+  , direction_(0)
+  , depth_(0){}
+struct t_stackDefaultTypeInternal {
+  constexpr t_stackDefaultTypeInternal()
+    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+  ~t_stackDefaultTypeInternal() {}
+  union {
+    t_stack _instance;
+  };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT t_stackDefaultTypeInternal _t_stack_default_instance_;
+
+// ===================================================================
+
+LevelsIndex_LevelsIndexEntry_DoNotUse::LevelsIndex_LevelsIndexEntry_DoNotUse() {}
+LevelsIndex_LevelsIndexEntry_DoNotUse::LevelsIndex_LevelsIndexEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+    : SuperType(arena) {}
+void LevelsIndex_LevelsIndexEntry_DoNotUse::MergeFrom(const LevelsIndex_LevelsIndexEntry_DoNotUse& other) {
+  MergeFromInternal(other);
+}
+
+// ===================================================================
+
+class LevelsIndex::_Internal {
+ public:
+};
+
+LevelsIndex::LevelsIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
+  levelsindex_(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:LevelsIndex)
+}
+LevelsIndex::LevelsIndex(const LevelsIndex& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  levelsindex_.MergeFrom(from.levelsindex_);
+  // @@protoc_insertion_point(copy_constructor:LevelsIndex)
+}
+
+void LevelsIndex::SharedCtor() {
+}
+
+LevelsIndex::~LevelsIndex() {
+  // @@protoc_insertion_point(destructor:LevelsIndex)
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+void LevelsIndex::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+}
+
+void LevelsIndex::ArenaDtor(void* object) {
+  LevelsIndex* _this = reinterpret_cast< LevelsIndex* >(object);
+  (void)_this;
+}
+void LevelsIndex::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void LevelsIndex::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void LevelsIndex::Clear() {
+// @@protoc_insertion_point(message_clear_start:LevelsIndex)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  levelsindex_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* LevelsIndex::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // map<string, .t_offeset_len> LevelsIndex = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(&levelsindex_, ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<std::string>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* LevelsIndex::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:LevelsIndex)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // map<string, .t_offeset_len> LevelsIndex = 1;
+  if (!this->_internal_levelsindex().empty()) {
+    typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >::const_pointer
+        ConstPtr;
+    typedef ConstPtr SortItem;
+    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByDerefFirst<SortItem> Less;
+    struct Utf8Check {
+      static void Check(ConstPtr p) {
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+          p->first.data(), static_cast<int>(p->first.length()),
+          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+          "LevelsIndex.LevelsIndexEntry.key");
+      }
+    };
+
+    if (stream->IsSerializationDeterministic() &&
+        this->_internal_levelsindex().size() > 1) {
+      ::std::unique_ptr<SortItem[]> items(
+          new SortItem[this->_internal_levelsindex().size()]);
+      typedef ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >::size_type size_type;
+      size_type n = 0;
+      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >::const_iterator
+          it = this->_internal_levelsindex().begin();
+          it != this->_internal_levelsindex().end(); ++it, ++n) {
+        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
+      }
+      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
+      for (size_type i = 0; i < n; i++) {
+        target = LevelsIndex_LevelsIndexEntry_DoNotUse::Funcs::InternalSerialize(1, items[static_cast<ptrdiff_t>(i)]->first, items[static_cast<ptrdiff_t>(i)]->second, target, stream);
+        Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)]));
+      }
+    } else {
+      for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >::const_iterator
+          it = this->_internal_levelsindex().begin();
+          it != this->_internal_levelsindex().end(); ++it) {
+        target = LevelsIndex_LevelsIndexEntry_DoNotUse::Funcs::InternalSerialize(1, it->first, it->second, target, stream);
+        Utf8Check::Check(&(*it));
+      }
+    }
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:LevelsIndex)
+  return target;
+}
+
+size_t LevelsIndex::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:LevelsIndex)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // map<string, .t_offeset_len> LevelsIndex = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_levelsindex_size());
+  for (::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >::const_iterator
+      it = this->_internal_levelsindex().begin();
+      it != this->_internal_levelsindex().end(); ++it) {
+    total_size += LevelsIndex_LevelsIndexEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void LevelsIndex::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LevelsIndex*>(
+      &from));
+}
+
+void LevelsIndex::MergeFrom(const LevelsIndex& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:LevelsIndex)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  levelsindex_.MergeFrom(from.levelsindex_);
+}
+
+void LevelsIndex::CopyFrom(const LevelsIndex& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:LevelsIndex)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LevelsIndex::IsInitialized() const {
+  return true;
+}
+
+void LevelsIndex::InternalSwap(LevelsIndex* other) {
+  using std::swap;
+  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
+  levelsindex_.Swap(&other->levelsindex_);
+}
+
+std::string LevelsIndex::GetTypeName() const {
+  return "LevelsIndex";
+}
+
+
+// ===================================================================
+
+class t_offeset_len::_Internal {
+ public:
+};
+
+t_offeset_len::t_offeset_len(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:t_offeset_len)
+}
+t_offeset_len::t_offeset_len(const t_offeset_len& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&offset_, &from.offset_,
+    static_cast<size_t>(reinterpret_cast<char*>(&len_) -
+    reinterpret_cast<char*>(&offset_)) + sizeof(len_));
+  // @@protoc_insertion_point(copy_constructor:t_offeset_len)
+}
+
+void t_offeset_len::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&offset_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&len_) -
+    reinterpret_cast<char*>(&offset_)) + sizeof(len_));
+}
+
+t_offeset_len::~t_offeset_len() {
+  // @@protoc_insertion_point(destructor:t_offeset_len)
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+void t_offeset_len::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+}
+
+void t_offeset_len::ArenaDtor(void* object) {
+  t_offeset_len* _this = reinterpret_cast< t_offeset_len* >(object);
+  (void)_this;
+}
+void t_offeset_len::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void t_offeset_len::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void t_offeset_len::Clear() {
+// @@protoc_insertion_point(message_clear_start:t_offeset_len)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&offset_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&len_) -
+      reinterpret_cast<char*>(&offset_)) + sizeof(len_));
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* t_offeset_len::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // int32 offset = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+          offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 len = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<std::string>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* t_offeset_len::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:t_offeset_len)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 offset = 1;
+  if (this->offset() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target);
+  }
+
+  // int32 len = 2;
+  if (this->len() != 0) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_len(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:t_offeset_len)
+  return target;
+}
+
+size_t t_offeset_len::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:t_offeset_len)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 offset = 1;
+  if (this->offset() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_offset());
+  }
+
+  // int32 len = 2;
+  if (this->len() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->_internal_len());
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void t_offeset_len::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const t_offeset_len*>(
+      &from));
+}
+
+void t_offeset_len::MergeFrom(const t_offeset_len& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:t_offeset_len)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.offset() != 0) {
+    _internal_set_offset(from._internal_offset());
+  }
+  if (from.len() != 0) {
+    _internal_set_len(from._internal_len());
+  }
+}
+
+void t_offeset_len::CopyFrom(const t_offeset_len& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:t_offeset_len)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool t_offeset_len::IsInitialized() const {
+  return true;
+}
+
+void t_offeset_len::InternalSwap(t_offeset_len* other) {
+  using std::swap;
+  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(t_offeset_len, len_)
+      + sizeof(t_offeset_len::len_)
+      - PROTOBUF_FIELD_OFFSET(t_offeset_len, offset_)>(
+          reinterpret_cast<char*>(&offset_),
+          reinterpret_cast<char*>(&other->offset_));
+}
+
+std::string t_offeset_len::GetTypeName() const {
+  return "t_offeset_len";
+}
+
+
+// ===================================================================
+
+class LevelData::_Internal {
+ public:
+  using HasBits = decltype(std::declval<LevelData>()._has_bits_);
+  static void set_has_tilewidth(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_tileheight(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+};
+
+LevelData::LevelData(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
+  tiles_(arena),
+  stacks_(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:LevelData)
+}
+LevelData::LevelData(const LevelData& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_),
+      tiles_(from.tiles_),
+      stacks_(from.stacks_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&tilewidth_, &from.tilewidth_,
+    static_cast<size_t>(reinterpret_cast<char*>(&tileheight_) -
+    reinterpret_cast<char*>(&tilewidth_)) + sizeof(tileheight_));
+  // @@protoc_insertion_point(copy_constructor:LevelData)
+}
+
+void LevelData::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&tilewidth_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&tileheight_) -
+    reinterpret_cast<char*>(&tilewidth_)) + sizeof(tileheight_));
+}
+
+LevelData::~LevelData() {
+  // @@protoc_insertion_point(destructor:LevelData)
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+void LevelData::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+}
+
+void LevelData::ArenaDtor(void* object) {
+  LevelData* _this = reinterpret_cast< LevelData* >(object);
+  (void)_this;
+}
+void LevelData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void LevelData::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void LevelData::Clear() {
+// @@protoc_insertion_point(message_clear_start:LevelData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  tiles_.Clear();
+  stacks_.Clear();
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    ::memset(&tilewidth_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&tileheight_) -
+        reinterpret_cast<char*>(&tilewidth_)) + sizeof(tileheight_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* LevelData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // repeated .t_tile tiles = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_tiles(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else goto handle_unusual;
+        continue;
+      // repeated .t_stack stacks = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_stacks(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
+        } else goto handle_unusual;
+        continue;
+      // int32 tileWidth = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+          _Internal::set_has_tilewidth(&has_bits);
+          tilewidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 tileHeight = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+          _Internal::set_has_tileheight(&has_bits);
+          tileheight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<std::string>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* LevelData::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:LevelData)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .t_tile tiles = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_tiles_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_tiles(i), target, stream);
+  }
+
+  // repeated .t_stack stacks = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_stacks_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(2, this->_internal_stacks(i), target, stream);
+  }
+
+  // int32 tileWidth = 3;
+  if (_internal_has_tilewidth()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_tilewidth(), target);
+  }
+
+  // int32 tileHeight = 4;
+  if (_internal_has_tileheight()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_tileheight(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:LevelData)
+  return target;
+}
+
+size_t LevelData::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:LevelData)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .t_tile tiles = 1;
+  total_size += 1UL * this->_internal_tiles_size();
+  for (const auto& msg : this->tiles_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  // repeated .t_stack stacks = 2;
+  total_size += 1UL * this->_internal_stacks_size();
+  for (const auto& msg : this->stacks_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    // int32 tileWidth = 3;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_tilewidth());
+    }
+
+    // int32 tileHeight = 4;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_tileheight());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void LevelData::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LevelData*>(
+      &from));
+}
+
+void LevelData::MergeFrom(const LevelData& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:LevelData)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  tiles_.MergeFrom(from.tiles_);
+  stacks_.MergeFrom(from.stacks_);
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x00000003u) {
+    if (cached_has_bits & 0x00000001u) {
+      tilewidth_ = from.tilewidth_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      tileheight_ = from.tileheight_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void LevelData::CopyFrom(const LevelData& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:LevelData)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LevelData::IsInitialized() const {
+  return true;
+}
+
+void LevelData::InternalSwap(LevelData* other) {
+  using std::swap;
+  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  tiles_.InternalSwap(&other->tiles_);
+  stacks_.InternalSwap(&other->stacks_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(LevelData, tileheight_)
+      + sizeof(LevelData::tileheight_)
+      - PROTOBUF_FIELD_OFFSET(LevelData, tilewidth_)>(
+          reinterpret_cast<char*>(&tilewidth_),
+          reinterpret_cast<char*>(&other->tilewidth_));
+}
+
+std::string LevelData::GetTypeName() const {
+  return "LevelData";
+}
+
+
+// ===================================================================
+
+class t_tile::_Internal {
+ public:
+  using HasBits = decltype(std::declval<t_tile>()._has_bits_);
+  static void set_has_x(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_y(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_z(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static const ::t_tile_data& tiledata(const t_tile* msg);
+  static void set_has_tiledata(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+};
+
+const ::t_tile_data&
+t_tile::_Internal::tiledata(const t_tile* msg) {
+  return *msg->tiledata_;
+}
+t_tile::t_tile(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:t_tile)
+}
+t_tile::t_tile(const t_tile& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  if (from._internal_has_tiledata()) {
+    tiledata_ = new ::t_tile_data(*from.tiledata_);
+  } else {
+    tiledata_ = nullptr;
+  }
+  ::memcpy(&x_, &from.x_,
+    static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+    reinterpret_cast<char*>(&x_)) + sizeof(z_));
+  // @@protoc_insertion_point(copy_constructor:t_tile)
+}
+
+void t_tile::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&tiledata_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+    reinterpret_cast<char*>(&tiledata_)) + sizeof(z_));
+}
+
+t_tile::~t_tile() {
+  // @@protoc_insertion_point(destructor:t_tile)
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+void t_tile::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+  if (this != internal_default_instance()) delete tiledata_;
+}
+
+void t_tile::ArenaDtor(void* object) {
+  t_tile* _this = reinterpret_cast< t_tile* >(object);
+  (void)_this;
+}
+void t_tile::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void t_tile::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void t_tile::Clear() {
+// @@protoc_insertion_point(message_clear_start:t_tile)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x00000001u) {
+    if (GetArena() == nullptr && tiledata_ != nullptr) {
+      delete tiledata_;
+    }
+    tiledata_ = nullptr;
+  }
+  if (cached_has_bits & 0x0000000eu) {
+    ::memset(&x_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&z_) -
+        reinterpret_cast<char*>(&x_)) + sizeof(z_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* t_tile::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // int32 x = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+          _Internal::set_has_x(&has_bits);
+          x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 y = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          _Internal::set_has_y(&has_bits);
+          y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 z = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+          _Internal::set_has_z(&has_bits);
+          z_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // .t_tile_data tileData = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
+          ptr = ctx->ParseMessage(_internal_mutable_tiledata(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<std::string>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* t_tile::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:t_tile)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 x = 1;
+  if (_internal_has_x()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target);
+  }
+
+  // int32 y = 2;
+  if (_internal_has_y()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_y(), target);
+  }
+
+  // int32 z = 3;
+  if (_internal_has_z()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_z(), target);
+  }
+
+  // .t_tile_data tileData = 4;
+  if (_internal_has_tiledata()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(
+        4, _Internal::tiledata(this), target, stream);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:t_tile)
+  return target;
+}
+
+size_t t_tile::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:t_tile)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // .t_tile_data tileData = 4;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          *tiledata_);
+    }
+
+    // int32 x = 1;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_x());
+    }
+
+    // int32 y = 2;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_y());
+    }
+
+    // int32 z = 3;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_z());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void t_tile::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const t_tile*>(
+      &from));
+}
+
+void t_tile::MergeFrom(const t_tile& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:t_tile)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      _internal_mutable_tiledata()->::t_tile_data::MergeFrom(from._internal_tiledata());
+    }
+    if (cached_has_bits & 0x00000002u) {
+      x_ = from.x_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      y_ = from.y_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      z_ = from.z_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void t_tile::CopyFrom(const t_tile& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:t_tile)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool t_tile::IsInitialized() const {
+  return true;
+}
+
+void t_tile::InternalSwap(t_tile* other) {
+  using std::swap;
+  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(t_tile, z_)
+      + sizeof(t_tile::z_)
+      - PROTOBUF_FIELD_OFFSET(t_tile, tiledata_)>(
+          reinterpret_cast<char*>(&tiledata_),
+          reinterpret_cast<char*>(&other->tiledata_));
+}
+
+std::string t_tile::GetTypeName() const {
+  return "t_tile";
+}
+
+
+// ===================================================================
+
+class t_tile_data::_Internal {
+ public:
+  using HasBits = decltype(std::declval<t_tile_data>()._has_bits_);
+  static void set_has_type(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_subtype(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_id(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_zv(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+  static void set_has_weight(HasBits* has_bits) {
+    (*has_bits)[0] |= 16u;
+  }
+};
+
+t_tile_data::t_tile_data(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:t_tile_data)
+}
+t_tile_data::t_tile_data(const t_tile_data& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&type_, &from.type_,
+    static_cast<size_t>(reinterpret_cast<char*>(&weight_) -
+    reinterpret_cast<char*>(&type_)) + sizeof(weight_));
+  // @@protoc_insertion_point(copy_constructor:t_tile_data)
+}
+
+void t_tile_data::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&type_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&weight_) -
+    reinterpret_cast<char*>(&type_)) + sizeof(weight_));
+}
+
+t_tile_data::~t_tile_data() {
+  // @@protoc_insertion_point(destructor:t_tile_data)
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+void t_tile_data::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+}
+
+void t_tile_data::ArenaDtor(void* object) {
+  t_tile_data* _this = reinterpret_cast< t_tile_data* >(object);
+  (void)_this;
+}
+void t_tile_data::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void t_tile_data::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void t_tile_data::Clear() {
+// @@protoc_insertion_point(message_clear_start:t_tile_data)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    ::memset(&type_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&weight_) -
+        reinterpret_cast<char*>(&type_)) + sizeof(weight_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* t_tile_data::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // int32 type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+          _Internal::set_has_type(&has_bits);
+          type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 subtype = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          _Internal::set_has_subtype(&has_bits);
+          subtype_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 id = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+          _Internal::set_has_id(&has_bits);
+          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 zv = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+          _Internal::set_has_zv(&has_bits);
+          zv_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 weight = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
+          _Internal::set_has_weight(&has_bits);
+          weight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<std::string>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* t_tile_data::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:t_tile_data)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 type = 1;
+  if (_internal_has_type()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_type(), target);
+  }
+
+  // int32 subtype = 2;
+  if (_internal_has_subtype()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_subtype(), target);
+  }
+
+  // int32 id = 3;
+  if (_internal_has_id()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_id(), target);
+  }
+
+  // int32 zv = 4;
+  if (_internal_has_zv()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_zv(), target);
+  }
+
+  // int32 weight = 5;
+  if (_internal_has_weight()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_weight(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:t_tile_data)
+  return target;
+}
+
+size_t t_tile_data::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:t_tile_data)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    // int32 type = 1;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_type());
+    }
+
+    // int32 subtype = 2;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_subtype());
+    }
+
+    // int32 id = 3;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_id());
+    }
+
+    // int32 zv = 4;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_zv());
+    }
+
+    // int32 weight = 5;
+    if (cached_has_bits & 0x00000010u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_weight());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void t_tile_data::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const t_tile_data*>(
+      &from));
+}
+
+void t_tile_data::MergeFrom(const t_tile_data& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:t_tile_data)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x0000001fu) {
+    if (cached_has_bits & 0x00000001u) {
+      type_ = from.type_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      subtype_ = from.subtype_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      id_ = from.id_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      zv_ = from.zv_;
+    }
+    if (cached_has_bits & 0x00000010u) {
+      weight_ = from.weight_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void t_tile_data::CopyFrom(const t_tile_data& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:t_tile_data)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool t_tile_data::IsInitialized() const {
+  return true;
+}
+
+void t_tile_data::InternalSwap(t_tile_data* other) {
+  using std::swap;
+  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(t_tile_data, weight_)
+      + sizeof(t_tile_data::weight_)
+      - PROTOBUF_FIELD_OFFSET(t_tile_data, type_)>(
+          reinterpret_cast<char*>(&type_),
+          reinterpret_cast<char*>(&other->type_));
+}
+
+std::string t_tile_data::GetTypeName() const {
+  return "t_tile_data";
+}
+
+
+// ===================================================================
+
+class t_stack::_Internal {
+ public:
+  using HasBits = decltype(std::declval<t_stack>()._has_bits_);
+  static void set_has_x(HasBits* has_bits) {
+    (*has_bits)[0] |= 1u;
+  }
+  static void set_has_y(HasBits* has_bits) {
+    (*has_bits)[0] |= 2u;
+  }
+  static void set_has_direction(HasBits* has_bits) {
+    (*has_bits)[0] |= 4u;
+  }
+  static void set_has_depth(HasBits* has_bits) {
+    (*has_bits)[0] |= 8u;
+  }
+};
+
+t_stack::t_stack(::PROTOBUF_NAMESPACE_ID::Arena* arena)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
+  tiledatas_(arena) {
+  SharedCtor();
+  RegisterArenaDtor(arena);
+  // @@protoc_insertion_point(arena_constructor:t_stack)
+}
+t_stack::t_stack(const t_stack& from)
+  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
+      _has_bits_(from._has_bits_),
+      tiledatas_(from.tiledatas_) {
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::memcpy(&x_, &from.x_,
+    static_cast<size_t>(reinterpret_cast<char*>(&depth_) -
+    reinterpret_cast<char*>(&x_)) + sizeof(depth_));
+  // @@protoc_insertion_point(copy_constructor:t_stack)
+}
+
+void t_stack::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+    reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
+    0, static_cast<size_t>(reinterpret_cast<char*>(&depth_) -
+    reinterpret_cast<char*>(&x_)) + sizeof(depth_));
+}
+
+t_stack::~t_stack() {
+  // @@protoc_insertion_point(destructor:t_stack)
+  SharedDtor();
+  _internal_metadata_.Delete<std::string>();
+}
+
+void t_stack::SharedDtor() {
+  GOOGLE_DCHECK(GetArena() == nullptr);
+}
+
+void t_stack::ArenaDtor(void* object) {
+  t_stack* _this = reinterpret_cast< t_stack* >(object);
+  (void)_this;
+}
+void t_stack::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void t_stack::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+
+void t_stack::Clear() {
+// @@protoc_insertion_point(message_clear_start:t_stack)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  tiledatas_.Clear();
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    ::memset(&x_, 0, static_cast<size_t>(
+        reinterpret_cast<char*>(&depth_) -
+        reinterpret_cast<char*>(&x_)) + sizeof(depth_));
+  }
+  _has_bits_.Clear();
+  _internal_metadata_.Clear<std::string>();
+}
+
+const char* t_stack::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  _Internal::HasBits has_bits{};
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // repeated .t_tile_data tileDatas = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(_internal_add_tiledatas(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
+        } else goto handle_unusual;
+        continue;
+      // int32 x = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          _Internal::set_has_x(&has_bits);
+          x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 y = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+          _Internal::set_has_y(&has_bits);
+          y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 direction = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+          _Internal::set_has_direction(&has_bits);
+          direction_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 depth = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
+          _Internal::set_has_depth(&has_bits);
+          depth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag,
+            _internal_metadata_.mutable_unknown_fields<std::string>(),
+            ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  _has_bits_.Or(has_bits);
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* t_stack::_InternalSerialize(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+  // @@protoc_insertion_point(serialize_to_array_start:t_stack)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .t_tile_data tileDatas = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->_internal_tiledatas_size()); i < n; i++) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessage(1, this->_internal_tiledatas(i), target, stream);
+  }
+
+  // int32 x = 2;
+  if (_internal_has_x()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_x(), target);
+  }
+
+  // int32 y = 3;
+  if (_internal_has_y()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_y(), target);
+  }
+
+  // int32 direction = 4;
+  if (_internal_has_direction()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_direction(), target);
+  }
+
+  // int32 depth = 5;
+  if (_internal_has_depth()) {
+    target = stream->EnsureSpace(target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_depth(), target);
+  }
+
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
+        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:t_stack)
+  return target;
+}
+
+size_t t_stack::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:t_stack)
+  size_t total_size = 0;
+
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .t_tile_data tileDatas = 1;
+  total_size += 1UL * this->_internal_tiledatas_size();
+  for (const auto& msg : this->tiledatas_) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
+  }
+
+  cached_has_bits = _has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    // int32 x = 2;
+    if (cached_has_bits & 0x00000001u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_x());
+    }
+
+    // int32 y = 3;
+    if (cached_has_bits & 0x00000002u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_y());
+    }
+
+    // int32 direction = 4;
+    if (cached_has_bits & 0x00000004u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_direction());
+    }
+
+    // int32 depth = 5;
+    if (cached_has_bits & 0x00000008u) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+          this->_internal_depth());
+    }
+
+  }
+  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
+  }
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void t_stack::CheckTypeAndMergeFrom(
+    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
+  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const t_stack*>(
+      &from));
+}
+
+void t_stack::MergeFrom(const t_stack& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:t_stack)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  tiledatas_.MergeFrom(from.tiledatas_);
+  cached_has_bits = from._has_bits_[0];
+  if (cached_has_bits & 0x0000000fu) {
+    if (cached_has_bits & 0x00000001u) {
+      x_ = from.x_;
+    }
+    if (cached_has_bits & 0x00000002u) {
+      y_ = from.y_;
+    }
+    if (cached_has_bits & 0x00000004u) {
+      direction_ = from.direction_;
+    }
+    if (cached_has_bits & 0x00000008u) {
+      depth_ = from.depth_;
+    }
+    _has_bits_[0] |= cached_has_bits;
+  }
+}
+
+void t_stack::CopyFrom(const t_stack& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:t_stack)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool t_stack::IsInitialized() const {
+  return true;
+}
+
+void t_stack::InternalSwap(t_stack* other) {
+  using std::swap;
+  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
+  swap(_has_bits_[0], other->_has_bits_[0]);
+  tiledatas_.InternalSwap(&other->tiledatas_);
+  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+      PROTOBUF_FIELD_OFFSET(t_stack, depth_)
+      + sizeof(t_stack::depth_)
+      - PROTOBUF_FIELD_OFFSET(t_stack, x_)>(
+          reinterpret_cast<char*>(&x_),
+          reinterpret_cast<char*>(&other->x_));
+}
+
+std::string t_stack::GetTypeName() const {
+  return "t_stack";
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::LevelsIndex_LevelsIndexEntry_DoNotUse* Arena::CreateMaybeMessage< ::LevelsIndex_LevelsIndexEntry_DoNotUse >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::LevelsIndex_LevelsIndexEntry_DoNotUse >(arena);
+}
+template<> PROTOBUF_NOINLINE ::LevelsIndex* Arena::CreateMaybeMessage< ::LevelsIndex >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::LevelsIndex >(arena);
+}
+template<> PROTOBUF_NOINLINE ::t_offeset_len* Arena::CreateMaybeMessage< ::t_offeset_len >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::t_offeset_len >(arena);
+}
+template<> PROTOBUF_NOINLINE ::LevelData* Arena::CreateMaybeMessage< ::LevelData >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::LevelData >(arena);
+}
+template<> PROTOBUF_NOINLINE ::t_tile* Arena::CreateMaybeMessage< ::t_tile >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::t_tile >(arena);
+}
+template<> PROTOBUF_NOINLINE ::t_tile_data* Arena::CreateMaybeMessage< ::t_tile_data >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::t_tile_data >(arena);
+}
+template<> PROTOBUF_NOINLINE ::t_stack* Arena::CreateMaybeMessage< ::t_stack >(Arena* arena) {
+  return Arena::CreateMessageInternal< ::t_stack >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>

+ 1841 - 0
TileFamily/TileLevelScript/levelData.pb.h

@@ -0,0 +1,1841 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: levelData.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_levelData_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_levelData_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3015000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3015008 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry_lite.h>
+#include <google/protobuf/map_field_lite.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_levelData_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_levelData_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+class LevelData;
+struct LevelDataDefaultTypeInternal;
+extern LevelDataDefaultTypeInternal _LevelData_default_instance_;
+class LevelsIndex;
+struct LevelsIndexDefaultTypeInternal;
+extern LevelsIndexDefaultTypeInternal _LevelsIndex_default_instance_;
+class LevelsIndex_LevelsIndexEntry_DoNotUse;
+struct LevelsIndex_LevelsIndexEntry_DoNotUseDefaultTypeInternal;
+extern LevelsIndex_LevelsIndexEntry_DoNotUseDefaultTypeInternal _LevelsIndex_LevelsIndexEntry_DoNotUse_default_instance_;
+class t_offeset_len;
+struct t_offeset_lenDefaultTypeInternal;
+extern t_offeset_lenDefaultTypeInternal _t_offeset_len_default_instance_;
+class t_stack;
+struct t_stackDefaultTypeInternal;
+extern t_stackDefaultTypeInternal _t_stack_default_instance_;
+class t_tile;
+struct t_tileDefaultTypeInternal;
+extern t_tileDefaultTypeInternal _t_tile_default_instance_;
+class t_tile_data;
+struct t_tile_dataDefaultTypeInternal;
+extern t_tile_dataDefaultTypeInternal _t_tile_data_default_instance_;
+PROTOBUF_NAMESPACE_OPEN
+template<> ::LevelData* Arena::CreateMaybeMessage<::LevelData>(Arena*);
+template<> ::LevelsIndex* Arena::CreateMaybeMessage<::LevelsIndex>(Arena*);
+template<> ::LevelsIndex_LevelsIndexEntry_DoNotUse* Arena::CreateMaybeMessage<::LevelsIndex_LevelsIndexEntry_DoNotUse>(Arena*);
+template<> ::t_offeset_len* Arena::CreateMaybeMessage<::t_offeset_len>(Arena*);
+template<> ::t_stack* Arena::CreateMaybeMessage<::t_stack>(Arena*);
+template<> ::t_tile* Arena::CreateMaybeMessage<::t_tile>(Arena*);
+template<> ::t_tile_data* Arena::CreateMaybeMessage<::t_tile_data>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+
+// ===================================================================
+
+class LevelsIndex_LevelsIndexEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<LevelsIndex_LevelsIndexEntry_DoNotUse, 
+    std::string, ::t_offeset_len,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
+public:
+  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<LevelsIndex_LevelsIndexEntry_DoNotUse, 
+    std::string, ::t_offeset_len,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
+  LevelsIndex_LevelsIndexEntry_DoNotUse();
+  explicit constexpr LevelsIndex_LevelsIndexEntry_DoNotUse(
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+  explicit LevelsIndex_LevelsIndexEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  void MergeFrom(const LevelsIndex_LevelsIndexEntry_DoNotUse& other);
+  static const LevelsIndex_LevelsIndexEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const LevelsIndex_LevelsIndexEntry_DoNotUse*>(&_LevelsIndex_LevelsIndexEntry_DoNotUse_default_instance_); }
+  static bool ValidateKey(std::string* s) {
+    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "LevelsIndex.LevelsIndexEntry.key");
+ }
+  static bool ValidateValue(void*) { return true; }
+};
+
+// -------------------------------------------------------------------
+
+class LevelsIndex PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:LevelsIndex) */ {
+ public:
+  inline LevelsIndex() : LevelsIndex(nullptr) {}
+  virtual ~LevelsIndex();
+  explicit constexpr LevelsIndex(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LevelsIndex(const LevelsIndex& from);
+  LevelsIndex(LevelsIndex&& from) noexcept
+    : LevelsIndex() {
+    *this = ::std::move(from);
+  }
+
+  inline LevelsIndex& operator=(const LevelsIndex& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LevelsIndex& operator=(LevelsIndex&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const LevelsIndex& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LevelsIndex* internal_default_instance() {
+    return reinterpret_cast<const LevelsIndex*>(
+               &_LevelsIndex_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(LevelsIndex& a, LevelsIndex& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LevelsIndex* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LevelsIndex* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LevelsIndex* New() const final {
+    return CreateMaybeMessage<LevelsIndex>(nullptr);
+  }
+
+  LevelsIndex* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LevelsIndex>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
+    final;
+  void CopyFrom(const LevelsIndex& from);
+  void MergeFrom(const LevelsIndex& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(LevelsIndex* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "LevelsIndex";
+  }
+  protected:
+  explicit LevelsIndex(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLevelsIndexFieldNumber = 1,
+  };
+  // map<string, .t_offeset_len> LevelsIndex = 1;
+  int levelsindex_size() const;
+  private:
+  int _internal_levelsindex_size() const;
+  public:
+  void clear_levelsindex();
+  private:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >&
+      _internal_levelsindex() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >*
+      _internal_mutable_levelsindex();
+  public:
+  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >&
+      levelsindex() const;
+  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >*
+      mutable_levelsindex();
+
+  // @@protoc_insertion_point(class_scope:LevelsIndex)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
+      LevelsIndex_LevelsIndexEntry_DoNotUse,
+      std::string, ::t_offeset_len,
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> levelsindex_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_levelData_2eproto;
+};
+// -------------------------------------------------------------------
+
+class t_offeset_len PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:t_offeset_len) */ {
+ public:
+  inline t_offeset_len() : t_offeset_len(nullptr) {}
+  virtual ~t_offeset_len();
+  explicit constexpr t_offeset_len(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  t_offeset_len(const t_offeset_len& from);
+  t_offeset_len(t_offeset_len&& from) noexcept
+    : t_offeset_len() {
+    *this = ::std::move(from);
+  }
+
+  inline t_offeset_len& operator=(const t_offeset_len& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline t_offeset_len& operator=(t_offeset_len&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const t_offeset_len& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const t_offeset_len* internal_default_instance() {
+    return reinterpret_cast<const t_offeset_len*>(
+               &_t_offeset_len_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(t_offeset_len& a, t_offeset_len& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(t_offeset_len* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(t_offeset_len* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline t_offeset_len* New() const final {
+    return CreateMaybeMessage<t_offeset_len>(nullptr);
+  }
+
+  t_offeset_len* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<t_offeset_len>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
+    final;
+  void CopyFrom(const t_offeset_len& from);
+  void MergeFrom(const t_offeset_len& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(t_offeset_len* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "t_offeset_len";
+  }
+  protected:
+  explicit t_offeset_len(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOffsetFieldNumber = 1,
+    kLenFieldNumber = 2,
+  };
+  // int32 offset = 1;
+  void clear_offset();
+  ::PROTOBUF_NAMESPACE_ID::int32 offset() const;
+  void set_offset(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_offset() const;
+  void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 len = 2;
+  void clear_len();
+  ::PROTOBUF_NAMESPACE_ID::int32 len() const;
+  void set_len(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_len() const;
+  void _internal_set_len(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:t_offeset_len)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::int32 offset_;
+  ::PROTOBUF_NAMESPACE_ID::int32 len_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_levelData_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LevelData PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:LevelData) */ {
+ public:
+  inline LevelData() : LevelData(nullptr) {}
+  virtual ~LevelData();
+  explicit constexpr LevelData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LevelData(const LevelData& from);
+  LevelData(LevelData&& from) noexcept
+    : LevelData() {
+    *this = ::std::move(from);
+  }
+
+  inline LevelData& operator=(const LevelData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LevelData& operator=(LevelData&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const LevelData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LevelData* internal_default_instance() {
+    return reinterpret_cast<const LevelData*>(
+               &_LevelData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(LevelData& a, LevelData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LevelData* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LevelData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LevelData* New() const final {
+    return CreateMaybeMessage<LevelData>(nullptr);
+  }
+
+  LevelData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LevelData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
+    final;
+  void CopyFrom(const LevelData& from);
+  void MergeFrom(const LevelData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(LevelData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "LevelData";
+  }
+  protected:
+  explicit LevelData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTilesFieldNumber = 1,
+    kStacksFieldNumber = 2,
+    kTileWidthFieldNumber = 3,
+    kTileHeightFieldNumber = 4,
+  };
+  // repeated .t_tile tiles = 1;
+  int tiles_size() const;
+  private:
+  int _internal_tiles_size() const;
+  public:
+  void clear_tiles();
+  ::t_tile* mutable_tiles(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile >*
+      mutable_tiles();
+  private:
+  const ::t_tile& _internal_tiles(int index) const;
+  ::t_tile* _internal_add_tiles();
+  public:
+  const ::t_tile& tiles(int index) const;
+  ::t_tile* add_tiles();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile >&
+      tiles() const;
+
+  // repeated .t_stack stacks = 2;
+  int stacks_size() const;
+  private:
+  int _internal_stacks_size() const;
+  public:
+  void clear_stacks();
+  ::t_stack* mutable_stacks(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_stack >*
+      mutable_stacks();
+  private:
+  const ::t_stack& _internal_stacks(int index) const;
+  ::t_stack* _internal_add_stacks();
+  public:
+  const ::t_stack& stacks(int index) const;
+  ::t_stack* add_stacks();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_stack >&
+      stacks() const;
+
+  // int32 tileWidth = 3;
+  bool has_tilewidth() const;
+  private:
+  bool _internal_has_tilewidth() const;
+  public:
+  void clear_tilewidth();
+  ::PROTOBUF_NAMESPACE_ID::int32 tilewidth() const;
+  void set_tilewidth(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_tilewidth() const;
+  void _internal_set_tilewidth(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 tileHeight = 4;
+  bool has_tileheight() const;
+  private:
+  bool _internal_has_tileheight() const;
+  public:
+  void clear_tileheight();
+  ::PROTOBUF_NAMESPACE_ID::int32 tileheight() const;
+  void set_tileheight(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_tileheight() const;
+  void _internal_set_tileheight(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:LevelData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile > tiles_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_stack > stacks_;
+  ::PROTOBUF_NAMESPACE_ID::int32 tilewidth_;
+  ::PROTOBUF_NAMESPACE_ID::int32 tileheight_;
+  friend struct ::TableStruct_levelData_2eproto;
+};
+// -------------------------------------------------------------------
+
+class t_tile PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:t_tile) */ {
+ public:
+  inline t_tile() : t_tile(nullptr) {}
+  virtual ~t_tile();
+  explicit constexpr t_tile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  t_tile(const t_tile& from);
+  t_tile(t_tile&& from) noexcept
+    : t_tile() {
+    *this = ::std::move(from);
+  }
+
+  inline t_tile& operator=(const t_tile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline t_tile& operator=(t_tile&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const t_tile& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const t_tile* internal_default_instance() {
+    return reinterpret_cast<const t_tile*>(
+               &_t_tile_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(t_tile& a, t_tile& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(t_tile* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(t_tile* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline t_tile* New() const final {
+    return CreateMaybeMessage<t_tile>(nullptr);
+  }
+
+  t_tile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<t_tile>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
+    final;
+  void CopyFrom(const t_tile& from);
+  void MergeFrom(const t_tile& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(t_tile* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "t_tile";
+  }
+  protected:
+  explicit t_tile(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTileDataFieldNumber = 4,
+    kXFieldNumber = 1,
+    kYFieldNumber = 2,
+    kZFieldNumber = 3,
+  };
+  // .t_tile_data tileData = 4;
+  bool has_tiledata() const;
+  private:
+  bool _internal_has_tiledata() const;
+  public:
+  void clear_tiledata();
+  const ::t_tile_data& tiledata() const;
+  ::t_tile_data* release_tiledata();
+  ::t_tile_data* mutable_tiledata();
+  void set_allocated_tiledata(::t_tile_data* tiledata);
+  private:
+  const ::t_tile_data& _internal_tiledata() const;
+  ::t_tile_data* _internal_mutable_tiledata();
+  public:
+  void unsafe_arena_set_allocated_tiledata(
+      ::t_tile_data* tiledata);
+  ::t_tile_data* unsafe_arena_release_tiledata();
+
+  // int32 x = 1;
+  bool has_x() const;
+  private:
+  bool _internal_has_x() const;
+  public:
+  void clear_x();
+  ::PROTOBUF_NAMESPACE_ID::int32 x() const;
+  void set_x(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_x() const;
+  void _internal_set_x(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 y = 2;
+  bool has_y() const;
+  private:
+  bool _internal_has_y() const;
+  public:
+  void clear_y();
+  ::PROTOBUF_NAMESPACE_ID::int32 y() const;
+  void set_y(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_y() const;
+  void _internal_set_y(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 z = 3;
+  bool has_z() const;
+  private:
+  bool _internal_has_z() const;
+  public:
+  void clear_z();
+  ::PROTOBUF_NAMESPACE_ID::int32 z() const;
+  void set_z(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_z() const;
+  void _internal_set_z(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:t_tile)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::t_tile_data* tiledata_;
+  ::PROTOBUF_NAMESPACE_ID::int32 x_;
+  ::PROTOBUF_NAMESPACE_ID::int32 y_;
+  ::PROTOBUF_NAMESPACE_ID::int32 z_;
+  friend struct ::TableStruct_levelData_2eproto;
+};
+// -------------------------------------------------------------------
+
+class t_tile_data PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:t_tile_data) */ {
+ public:
+  inline t_tile_data() : t_tile_data(nullptr) {}
+  virtual ~t_tile_data();
+  explicit constexpr t_tile_data(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  t_tile_data(const t_tile_data& from);
+  t_tile_data(t_tile_data&& from) noexcept
+    : t_tile_data() {
+    *this = ::std::move(from);
+  }
+
+  inline t_tile_data& operator=(const t_tile_data& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline t_tile_data& operator=(t_tile_data&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const t_tile_data& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const t_tile_data* internal_default_instance() {
+    return reinterpret_cast<const t_tile_data*>(
+               &_t_tile_data_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(t_tile_data& a, t_tile_data& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(t_tile_data* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(t_tile_data* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline t_tile_data* New() const final {
+    return CreateMaybeMessage<t_tile_data>(nullptr);
+  }
+
+  t_tile_data* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<t_tile_data>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
+    final;
+  void CopyFrom(const t_tile_data& from);
+  void MergeFrom(const t_tile_data& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(t_tile_data* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "t_tile_data";
+  }
+  protected:
+  explicit t_tile_data(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTypeFieldNumber = 1,
+    kSubtypeFieldNumber = 2,
+    kIdFieldNumber = 3,
+    kZvFieldNumber = 4,
+    kWeightFieldNumber = 5,
+  };
+  // int32 type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::PROTOBUF_NAMESPACE_ID::int32 type() const;
+  void set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_type() const;
+  void _internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 subtype = 2;
+  bool has_subtype() const;
+  private:
+  bool _internal_has_subtype() const;
+  public:
+  void clear_subtype();
+  ::PROTOBUF_NAMESPACE_ID::int32 subtype() const;
+  void set_subtype(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_subtype() const;
+  void _internal_set_subtype(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 id = 3;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  ::PROTOBUF_NAMESPACE_ID::int32 id() const;
+  void set_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_id() const;
+  void _internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 zv = 4;
+  bool has_zv() const;
+  private:
+  bool _internal_has_zv() const;
+  public:
+  void clear_zv();
+  ::PROTOBUF_NAMESPACE_ID::int32 zv() const;
+  void set_zv(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_zv() const;
+  void _internal_set_zv(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 weight = 5;
+  bool has_weight() const;
+  private:
+  bool _internal_has_weight() const;
+  public:
+  void clear_weight();
+  ::PROTOBUF_NAMESPACE_ID::int32 weight() const;
+  void set_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_weight() const;
+  void _internal_set_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:t_tile_data)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int32 type_;
+  ::PROTOBUF_NAMESPACE_ID::int32 subtype_;
+  ::PROTOBUF_NAMESPACE_ID::int32 id_;
+  ::PROTOBUF_NAMESPACE_ID::int32 zv_;
+  ::PROTOBUF_NAMESPACE_ID::int32 weight_;
+  friend struct ::TableStruct_levelData_2eproto;
+};
+// -------------------------------------------------------------------
+
+class t_stack PROTOBUF_FINAL :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:t_stack) */ {
+ public:
+  inline t_stack() : t_stack(nullptr) {}
+  virtual ~t_stack();
+  explicit constexpr t_stack(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  t_stack(const t_stack& from);
+  t_stack(t_stack&& from) noexcept
+    : t_stack() {
+    *this = ::std::move(from);
+  }
+
+  inline t_stack& operator=(const t_stack& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline t_stack& operator=(t_stack&& from) noexcept {
+    if (GetArena() == from.GetArena()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const t_stack& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const t_stack* internal_default_instance() {
+    return reinterpret_cast<const t_stack*>(
+               &_t_stack_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(t_stack& a, t_stack& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(t_stack* other) {
+    if (other == this) return;
+    if (GetArena() == other->GetArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(t_stack* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetArena() == other->GetArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline t_stack* New() const final {
+    return CreateMaybeMessage<t_stack>(nullptr);
+  }
+
+  t_stack* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<t_stack>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
+    final;
+  void CopyFrom(const t_stack& from);
+  void MergeFrom(const t_stack& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(t_stack* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "t_stack";
+  }
+  protected:
+  explicit t_stack(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTileDatasFieldNumber = 1,
+    kXFieldNumber = 2,
+    kYFieldNumber = 3,
+    kDirectionFieldNumber = 4,
+    kDepthFieldNumber = 5,
+  };
+  // repeated .t_tile_data tileDatas = 1;
+  int tiledatas_size() const;
+  private:
+  int _internal_tiledatas_size() const;
+  public:
+  void clear_tiledatas();
+  ::t_tile_data* mutable_tiledatas(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile_data >*
+      mutable_tiledatas();
+  private:
+  const ::t_tile_data& _internal_tiledatas(int index) const;
+  ::t_tile_data* _internal_add_tiledatas();
+  public:
+  const ::t_tile_data& tiledatas(int index) const;
+  ::t_tile_data* add_tiledatas();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile_data >&
+      tiledatas() const;
+
+  // int32 x = 2;
+  bool has_x() const;
+  private:
+  bool _internal_has_x() const;
+  public:
+  void clear_x();
+  ::PROTOBUF_NAMESPACE_ID::int32 x() const;
+  void set_x(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_x() const;
+  void _internal_set_x(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 y = 3;
+  bool has_y() const;
+  private:
+  bool _internal_has_y() const;
+  public:
+  void clear_y();
+  ::PROTOBUF_NAMESPACE_ID::int32 y() const;
+  void set_y(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_y() const;
+  void _internal_set_y(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 direction = 4;
+  bool has_direction() const;
+  private:
+  bool _internal_has_direction() const;
+  public:
+  void clear_direction();
+  ::PROTOBUF_NAMESPACE_ID::int32 direction() const;
+  void set_direction(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_direction() const;
+  void _internal_set_direction(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // int32 depth = 5;
+  bool has_depth() const;
+  private:
+  bool _internal_has_depth() const;
+  public:
+  void clear_depth();
+  ::PROTOBUF_NAMESPACE_ID::int32 depth() const;
+  void set_depth(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_depth() const;
+  void _internal_set_depth(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:t_stack)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile_data > tiledatas_;
+  ::PROTOBUF_NAMESPACE_ID::int32 x_;
+  ::PROTOBUF_NAMESPACE_ID::int32 y_;
+  ::PROTOBUF_NAMESPACE_ID::int32 direction_;
+  ::PROTOBUF_NAMESPACE_ID::int32 depth_;
+  friend struct ::TableStruct_levelData_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// LevelsIndex
+
+// map<string, .t_offeset_len> LevelsIndex = 1;
+inline int LevelsIndex::_internal_levelsindex_size() const {
+  return levelsindex_.size();
+}
+inline int LevelsIndex::levelsindex_size() const {
+  return _internal_levelsindex_size();
+}
+inline void LevelsIndex::clear_levelsindex() {
+  levelsindex_.Clear();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >&
+LevelsIndex::_internal_levelsindex() const {
+  return levelsindex_.GetMap();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >&
+LevelsIndex::levelsindex() const {
+  // @@protoc_insertion_point(field_map:LevelsIndex.LevelsIndex)
+  return _internal_levelsindex();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >*
+LevelsIndex::_internal_mutable_levelsindex() {
+  return levelsindex_.MutableMap();
+}
+inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::t_offeset_len >*
+LevelsIndex::mutable_levelsindex() {
+  // @@protoc_insertion_point(field_mutable_map:LevelsIndex.LevelsIndex)
+  return _internal_mutable_levelsindex();
+}
+
+// -------------------------------------------------------------------
+
+// t_offeset_len
+
+// int32 offset = 1;
+inline void t_offeset_len::clear_offset() {
+  offset_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_offeset_len::_internal_offset() const {
+  return offset_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_offeset_len::offset() const {
+  // @@protoc_insertion_point(field_get:t_offeset_len.offset)
+  return _internal_offset();
+}
+inline void t_offeset_len::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  
+  offset_ = value;
+}
+inline void t_offeset_len::set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_offset(value);
+  // @@protoc_insertion_point(field_set:t_offeset_len.offset)
+}
+
+// int32 len = 2;
+inline void t_offeset_len::clear_len() {
+  len_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_offeset_len::_internal_len() const {
+  return len_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_offeset_len::len() const {
+  // @@protoc_insertion_point(field_get:t_offeset_len.len)
+  return _internal_len();
+}
+inline void t_offeset_len::_internal_set_len(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  
+  len_ = value;
+}
+inline void t_offeset_len::set_len(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_len(value);
+  // @@protoc_insertion_point(field_set:t_offeset_len.len)
+}
+
+// -------------------------------------------------------------------
+
+// LevelData
+
+// repeated .t_tile tiles = 1;
+inline int LevelData::_internal_tiles_size() const {
+  return tiles_.size();
+}
+inline int LevelData::tiles_size() const {
+  return _internal_tiles_size();
+}
+inline void LevelData::clear_tiles() {
+  tiles_.Clear();
+}
+inline ::t_tile* LevelData::mutable_tiles(int index) {
+  // @@protoc_insertion_point(field_mutable:LevelData.tiles)
+  return tiles_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile >*
+LevelData::mutable_tiles() {
+  // @@protoc_insertion_point(field_mutable_list:LevelData.tiles)
+  return &tiles_;
+}
+inline const ::t_tile& LevelData::_internal_tiles(int index) const {
+  return tiles_.Get(index);
+}
+inline const ::t_tile& LevelData::tiles(int index) const {
+  // @@protoc_insertion_point(field_get:LevelData.tiles)
+  return _internal_tiles(index);
+}
+inline ::t_tile* LevelData::_internal_add_tiles() {
+  return tiles_.Add();
+}
+inline ::t_tile* LevelData::add_tiles() {
+  // @@protoc_insertion_point(field_add:LevelData.tiles)
+  return _internal_add_tiles();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile >&
+LevelData::tiles() const {
+  // @@protoc_insertion_point(field_list:LevelData.tiles)
+  return tiles_;
+}
+
+// repeated .t_stack stacks = 2;
+inline int LevelData::_internal_stacks_size() const {
+  return stacks_.size();
+}
+inline int LevelData::stacks_size() const {
+  return _internal_stacks_size();
+}
+inline void LevelData::clear_stacks() {
+  stacks_.Clear();
+}
+inline ::t_stack* LevelData::mutable_stacks(int index) {
+  // @@protoc_insertion_point(field_mutable:LevelData.stacks)
+  return stacks_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_stack >*
+LevelData::mutable_stacks() {
+  // @@protoc_insertion_point(field_mutable_list:LevelData.stacks)
+  return &stacks_;
+}
+inline const ::t_stack& LevelData::_internal_stacks(int index) const {
+  return stacks_.Get(index);
+}
+inline const ::t_stack& LevelData::stacks(int index) const {
+  // @@protoc_insertion_point(field_get:LevelData.stacks)
+  return _internal_stacks(index);
+}
+inline ::t_stack* LevelData::_internal_add_stacks() {
+  return stacks_.Add();
+}
+inline ::t_stack* LevelData::add_stacks() {
+  // @@protoc_insertion_point(field_add:LevelData.stacks)
+  return _internal_add_stacks();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_stack >&
+LevelData::stacks() const {
+  // @@protoc_insertion_point(field_list:LevelData.stacks)
+  return stacks_;
+}
+
+// int32 tileWidth = 3;
+inline bool LevelData::_internal_has_tilewidth() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LevelData::has_tilewidth() const {
+  return _internal_has_tilewidth();
+}
+inline void LevelData::clear_tilewidth() {
+  tilewidth_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LevelData::_internal_tilewidth() const {
+  return tilewidth_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LevelData::tilewidth() const {
+  // @@protoc_insertion_point(field_get:LevelData.tileWidth)
+  return _internal_tilewidth();
+}
+inline void LevelData::_internal_set_tilewidth(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  tilewidth_ = value;
+}
+inline void LevelData::set_tilewidth(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_tilewidth(value);
+  // @@protoc_insertion_point(field_set:LevelData.tileWidth)
+}
+
+// int32 tileHeight = 4;
+inline bool LevelData::_internal_has_tileheight() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LevelData::has_tileheight() const {
+  return _internal_has_tileheight();
+}
+inline void LevelData::clear_tileheight() {
+  tileheight_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LevelData::_internal_tileheight() const {
+  return tileheight_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LevelData::tileheight() const {
+  // @@protoc_insertion_point(field_get:LevelData.tileHeight)
+  return _internal_tileheight();
+}
+inline void LevelData::_internal_set_tileheight(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  tileheight_ = value;
+}
+inline void LevelData::set_tileheight(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_tileheight(value);
+  // @@protoc_insertion_point(field_set:LevelData.tileHeight)
+}
+
+// -------------------------------------------------------------------
+
+// t_tile
+
+// int32 x = 1;
+inline bool t_tile::_internal_has_x() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool t_tile::has_x() const {
+  return _internal_has_x();
+}
+inline void t_tile::clear_x() {
+  x_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile::_internal_x() const {
+  return x_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile::x() const {
+  // @@protoc_insertion_point(field_get:t_tile.x)
+  return _internal_x();
+}
+inline void t_tile::_internal_set_x(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  x_ = value;
+}
+inline void t_tile::set_x(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_x(value);
+  // @@protoc_insertion_point(field_set:t_tile.x)
+}
+
+// int32 y = 2;
+inline bool t_tile::_internal_has_y() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool t_tile::has_y() const {
+  return _internal_has_y();
+}
+inline void t_tile::clear_y() {
+  y_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile::_internal_y() const {
+  return y_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile::y() const {
+  // @@protoc_insertion_point(field_get:t_tile.y)
+  return _internal_y();
+}
+inline void t_tile::_internal_set_y(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  y_ = value;
+}
+inline void t_tile::set_y(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_y(value);
+  // @@protoc_insertion_point(field_set:t_tile.y)
+}
+
+// int32 z = 3;
+inline bool t_tile::_internal_has_z() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool t_tile::has_z() const {
+  return _internal_has_z();
+}
+inline void t_tile::clear_z() {
+  z_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile::_internal_z() const {
+  return z_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile::z() const {
+  // @@protoc_insertion_point(field_get:t_tile.z)
+  return _internal_z();
+}
+inline void t_tile::_internal_set_z(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  z_ = value;
+}
+inline void t_tile::set_z(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_z(value);
+  // @@protoc_insertion_point(field_set:t_tile.z)
+}
+
+// .t_tile_data tileData = 4;
+inline bool t_tile::_internal_has_tiledata() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || tiledata_ != nullptr);
+  return value;
+}
+inline bool t_tile::has_tiledata() const {
+  return _internal_has_tiledata();
+}
+inline void t_tile::clear_tiledata() {
+  if (GetArena() == nullptr && tiledata_ != nullptr) {
+    delete tiledata_;
+  }
+  tiledata_ = nullptr;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::t_tile_data& t_tile::_internal_tiledata() const {
+  const ::t_tile_data* p = tiledata_;
+  return p != nullptr ? *p : reinterpret_cast<const ::t_tile_data&>(
+      ::_t_tile_data_default_instance_);
+}
+inline const ::t_tile_data& t_tile::tiledata() const {
+  // @@protoc_insertion_point(field_get:t_tile.tileData)
+  return _internal_tiledata();
+}
+inline void t_tile::unsafe_arena_set_allocated_tiledata(
+    ::t_tile_data* tiledata) {
+  if (GetArena() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tiledata_);
+  }
+  tiledata_ = tiledata;
+  if (tiledata) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:t_tile.tileData)
+}
+inline ::t_tile_data* t_tile::release_tiledata() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::t_tile_data* temp = tiledata_;
+  tiledata_ = nullptr;
+  if (GetArena() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+  return temp;
+}
+inline ::t_tile_data* t_tile::unsafe_arena_release_tiledata() {
+  // @@protoc_insertion_point(field_release:t_tile.tileData)
+  _has_bits_[0] &= ~0x00000001u;
+  ::t_tile_data* temp = tiledata_;
+  tiledata_ = nullptr;
+  return temp;
+}
+inline ::t_tile_data* t_tile::_internal_mutable_tiledata() {
+  _has_bits_[0] |= 0x00000001u;
+  if (tiledata_ == nullptr) {
+    auto* p = CreateMaybeMessage<::t_tile_data>(GetArena());
+    tiledata_ = p;
+  }
+  return tiledata_;
+}
+inline ::t_tile_data* t_tile::mutable_tiledata() {
+  // @@protoc_insertion_point(field_mutable:t_tile.tileData)
+  return _internal_mutable_tiledata();
+}
+inline void t_tile::set_allocated_tiledata(::t_tile_data* tiledata) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
+  if (message_arena == nullptr) {
+    delete tiledata_;
+  }
+  if (tiledata) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tiledata);
+    if (message_arena != submessage_arena) {
+      tiledata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, tiledata, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  tiledata_ = tiledata;
+  // @@protoc_insertion_point(field_set_allocated:t_tile.tileData)
+}
+
+// -------------------------------------------------------------------
+
+// t_tile_data
+
+// int32 type = 1;
+inline bool t_tile_data::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool t_tile_data::has_type() const {
+  return _internal_has_type();
+}
+inline void t_tile_data::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::_internal_type() const {
+  return type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::type() const {
+  // @@protoc_insertion_point(field_get:t_tile_data.type)
+  return _internal_type();
+}
+inline void t_tile_data::_internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  type_ = value;
+}
+inline void t_tile_data::set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:t_tile_data.type)
+}
+
+// int32 subtype = 2;
+inline bool t_tile_data::_internal_has_subtype() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool t_tile_data::has_subtype() const {
+  return _internal_has_subtype();
+}
+inline void t_tile_data::clear_subtype() {
+  subtype_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::_internal_subtype() const {
+  return subtype_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::subtype() const {
+  // @@protoc_insertion_point(field_get:t_tile_data.subtype)
+  return _internal_subtype();
+}
+inline void t_tile_data::_internal_set_subtype(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  subtype_ = value;
+}
+inline void t_tile_data::set_subtype(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_subtype(value);
+  // @@protoc_insertion_point(field_set:t_tile_data.subtype)
+}
+
+// int32 id = 3;
+inline bool t_tile_data::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool t_tile_data::has_id() const {
+  return _internal_has_id();
+}
+inline void t_tile_data::clear_id() {
+  id_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::_internal_id() const {
+  return id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::id() const {
+  // @@protoc_insertion_point(field_get:t_tile_data.id)
+  return _internal_id();
+}
+inline void t_tile_data::_internal_set_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  id_ = value;
+}
+inline void t_tile_data::set_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:t_tile_data.id)
+}
+
+// int32 zv = 4;
+inline bool t_tile_data::_internal_has_zv() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool t_tile_data::has_zv() const {
+  return _internal_has_zv();
+}
+inline void t_tile_data::clear_zv() {
+  zv_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::_internal_zv() const {
+  return zv_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::zv() const {
+  // @@protoc_insertion_point(field_get:t_tile_data.zv)
+  return _internal_zv();
+}
+inline void t_tile_data::_internal_set_zv(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  zv_ = value;
+}
+inline void t_tile_data::set_zv(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_zv(value);
+  // @@protoc_insertion_point(field_set:t_tile_data.zv)
+}
+
+// int32 weight = 5;
+inline bool t_tile_data::_internal_has_weight() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool t_tile_data::has_weight() const {
+  return _internal_has_weight();
+}
+inline void t_tile_data::clear_weight() {
+  weight_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::_internal_weight() const {
+  return weight_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_tile_data::weight() const {
+  // @@protoc_insertion_point(field_get:t_tile_data.weight)
+  return _internal_weight();
+}
+inline void t_tile_data::_internal_set_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  weight_ = value;
+}
+inline void t_tile_data::set_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_weight(value);
+  // @@protoc_insertion_point(field_set:t_tile_data.weight)
+}
+
+// -------------------------------------------------------------------
+
+// t_stack
+
+// repeated .t_tile_data tileDatas = 1;
+inline int t_stack::_internal_tiledatas_size() const {
+  return tiledatas_.size();
+}
+inline int t_stack::tiledatas_size() const {
+  return _internal_tiledatas_size();
+}
+inline void t_stack::clear_tiledatas() {
+  tiledatas_.Clear();
+}
+inline ::t_tile_data* t_stack::mutable_tiledatas(int index) {
+  // @@protoc_insertion_point(field_mutable:t_stack.tileDatas)
+  return tiledatas_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile_data >*
+t_stack::mutable_tiledatas() {
+  // @@protoc_insertion_point(field_mutable_list:t_stack.tileDatas)
+  return &tiledatas_;
+}
+inline const ::t_tile_data& t_stack::_internal_tiledatas(int index) const {
+  return tiledatas_.Get(index);
+}
+inline const ::t_tile_data& t_stack::tiledatas(int index) const {
+  // @@protoc_insertion_point(field_get:t_stack.tileDatas)
+  return _internal_tiledatas(index);
+}
+inline ::t_tile_data* t_stack::_internal_add_tiledatas() {
+  return tiledatas_.Add();
+}
+inline ::t_tile_data* t_stack::add_tiledatas() {
+  // @@protoc_insertion_point(field_add:t_stack.tileDatas)
+  return _internal_add_tiledatas();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::t_tile_data >&
+t_stack::tiledatas() const {
+  // @@protoc_insertion_point(field_list:t_stack.tileDatas)
+  return tiledatas_;
+}
+
+// int32 x = 2;
+inline bool t_stack::_internal_has_x() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool t_stack::has_x() const {
+  return _internal_has_x();
+}
+inline void t_stack::clear_x() {
+  x_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::_internal_x() const {
+  return x_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::x() const {
+  // @@protoc_insertion_point(field_get:t_stack.x)
+  return _internal_x();
+}
+inline void t_stack::_internal_set_x(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  x_ = value;
+}
+inline void t_stack::set_x(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_x(value);
+  // @@protoc_insertion_point(field_set:t_stack.x)
+}
+
+// int32 y = 3;
+inline bool t_stack::_internal_has_y() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool t_stack::has_y() const {
+  return _internal_has_y();
+}
+inline void t_stack::clear_y() {
+  y_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::_internal_y() const {
+  return y_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::y() const {
+  // @@protoc_insertion_point(field_get:t_stack.y)
+  return _internal_y();
+}
+inline void t_stack::_internal_set_y(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  y_ = value;
+}
+inline void t_stack::set_y(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_y(value);
+  // @@protoc_insertion_point(field_set:t_stack.y)
+}
+
+// int32 direction = 4;
+inline bool t_stack::_internal_has_direction() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool t_stack::has_direction() const {
+  return _internal_has_direction();
+}
+inline void t_stack::clear_direction() {
+  direction_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::_internal_direction() const {
+  return direction_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::direction() const {
+  // @@protoc_insertion_point(field_get:t_stack.direction)
+  return _internal_direction();
+}
+inline void t_stack::_internal_set_direction(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  direction_ = value;
+}
+inline void t_stack::set_direction(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_direction(value);
+  // @@protoc_insertion_point(field_set:t_stack.direction)
+}
+
+// int32 depth = 5;
+inline bool t_stack::_internal_has_depth() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool t_stack::has_depth() const {
+  return _internal_has_depth();
+}
+inline void t_stack::clear_depth() {
+  depth_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::_internal_depth() const {
+  return depth_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 t_stack::depth() const {
+  // @@protoc_insertion_point(field_get:t_stack.depth)
+  return _internal_depth();
+}
+inline void t_stack::_internal_set_depth(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  depth_ = value;
+}
+inline void t_stack::set_depth(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_depth(value);
+  // @@protoc_insertion_point(field_set:t_stack.depth)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_levelData_2eproto

+ 43 - 0
TileFamily/TileLevelScript/levelData.proto

@@ -0,0 +1,43 @@
+syntax = "proto3";
+option optimize_for = LITE_RUNTIME;
+
+//采用index+truck形式
+message LevelsIndex {
+     map<string, t_offeset_len> LevelsIndex = 1;
+}
+
+message t_offeset_len {
+     int32 offset =1;
+     int32 len = 2;
+}
+
+message LevelData {
+     repeated t_tile tiles = 1;
+     repeated t_stack stacks = 2;
+     optional int32 tileWidth = 3;
+     optional int32 tileHeight = 4;
+}
+
+message t_tile {
+     optional int32 x = 1;
+     optional int32 y = 2;
+     optional int32 z = 3;
+     optional t_tile_data tileData = 4;
+}
+
+message t_tile_data {
+     optional int32 type = 1;
+     optional int32 subtype = 2;
+     optional int32 id = 3;
+     optional int32 zv = 4;
+     optional int32 weight = 5;
+}
+
+message t_stack {
+     repeated t_tile_data tileDatas = 1;
+     optional int32 x = 2;
+     optional int32 y = 3;
+     optional int32 direction = 4;
+     optional int32 depth = 5;
+}
+

+ 550 - 0
TileFamily/TileLevelScript/levelData_pb2.py

@@ -0,0 +1,550 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: levelData.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='levelData.proto',
+  package='',
+  syntax='proto3',
+  serialized_options=b'H\003',
+  create_key=_descriptor._internal_create_key,
+  serialized_pb=b'\n\x0flevelData.proto\"\x85\x01\n\x0bLevelsIndex\x12\x32\n\x0bLevelsIndex\x18\x01 \x03(\x0b\x32\x1d.LevelsIndex.LevelsIndexEntry\x1a\x42\n\x10LevelsIndexEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\x1d\n\x05value\x18\x02 \x01(\x0b\x32\x0e.t_offeset_len:\x02\x38\x01\",\n\rt_offeset_len\x12\x0e\n\x06offset\x18\x01 \x01(\x05\x12\x0b\n\x03len\x18\x02 \x01(\x05\"\x8b\x01\n\tLevelData\x12\x16\n\x05tiles\x18\x01 \x03(\x0b\x32\x07.t_tile\x12\x18\n\x06stacks\x18\x02 \x03(\x0b\x32\x08.t_stack\x12\x16\n\ttileWidth\x18\x03 \x01(\x05H\x00\x88\x01\x01\x12\x17\n\ntileHeight\x18\x04 \x01(\x05H\x01\x88\x01\x01\x42\x0c\n\n_tileWidthB\r\n\x0b_tileHeight\"|\n\x06t_tile\x12\x0e\n\x01x\x18\x01 \x01(\x05H\x00\x88\x01\x01\x12\x0e\n\x01y\x18\x02 \x01(\x05H\x01\x88\x01\x01\x12\x0e\n\x01z\x18\x03 \x01(\x05H\x02\x88\x01\x01\x12#\n\x08tileData\x18\x04 \x01(\x0b\x32\x0c.t_tile_dataH\x03\x88\x01\x01\x42\x04\n\x02_xB\x04\n\x02_yB\x04\n\x02_zB\x0b\n\t_tileData\"\x9b\x01\n\x0bt_tile_data\x12\x11\n\x04type\x18\x01 \x01(\x05H\x00\x88\x01\x01\x12\x14\n\x07subtype\x18\x02 \x01(\x05H\x01\x88\x01\x01\x12\x0f\n\x02id\x18\x03 \x01(\x05H\x02\x88\x01\x01\x12\x0f\n\x02zv\x18\x04 \x01(\x05H\x03\x88\x01\x01\x12\x13\n\x06weight\x18\x05 \x01(\x05H\x04\x88\x01\x01\x42\x07\n\x05_typeB\n\n\x08_subtypeB\x05\n\x03_idB\x05\n\x03_zvB\t\n\x07_weight\"\x9a\x01\n\x07t_stack\x12\x1f\n\ttileDatas\x18\x01 \x03(\x0b\x32\x0c.t_tile_data\x12\x0e\n\x01x\x18\x02 \x01(\x05H\x00\x88\x01\x01\x12\x0e\n\x01y\x18\x03 \x01(\x05H\x01\x88\x01\x01\x12\x16\n\tdirection\x18\x04 \x01(\x05H\x02\x88\x01\x01\x12\x12\n\x05\x64\x65pth\x18\x05 \x01(\x05H\x03\x88\x01\x01\x42\x04\n\x02_xB\x04\n\x02_yB\x0c\n\n_directionB\x08\n\x06_depthB\x02H\x03\x62\x06proto3'
+)
+
+
+
+
+_LEVELSINDEX_LEVELSINDEXENTRY = _descriptor.Descriptor(
+  name='LevelsIndexEntry',
+  full_name='LevelsIndex.LevelsIndexEntry',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='key', full_name='LevelsIndex.LevelsIndexEntry.key', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='value', full_name='LevelsIndex.LevelsIndexEntry.value', index=1,
+      number=2, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=b'8\001',
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=87,
+  serialized_end=153,
+)
+
+_LEVELSINDEX = _descriptor.Descriptor(
+  name='LevelsIndex',
+  full_name='LevelsIndex',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='LevelsIndex', full_name='LevelsIndex.LevelsIndex', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[_LEVELSINDEX_LEVELSINDEXENTRY, ],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=20,
+  serialized_end=153,
+)
+
+
+_T_OFFESET_LEN = _descriptor.Descriptor(
+  name='t_offeset_len',
+  full_name='t_offeset_len',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='offset', full_name='t_offeset_len.offset', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='len', full_name='t_offeset_len.len', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=155,
+  serialized_end=199,
+)
+
+
+_LEVELDATA = _descriptor.Descriptor(
+  name='LevelData',
+  full_name='LevelData',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='tiles', full_name='LevelData.tiles', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='stacks', full_name='LevelData.stacks', index=1,
+      number=2, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='tileWidth', full_name='LevelData.tileWidth', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='tileHeight', full_name='LevelData.tileHeight', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='_tileWidth', full_name='LevelData._tileWidth',
+      index=0, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_tileHeight', full_name='LevelData._tileHeight',
+      index=1, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+  ],
+  serialized_start=202,
+  serialized_end=341,
+)
+
+
+_T_TILE = _descriptor.Descriptor(
+  name='t_tile',
+  full_name='t_tile',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='x', full_name='t_tile.x', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='y', full_name='t_tile.y', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='z', full_name='t_tile.z', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='tileData', full_name='t_tile.tileData', index=3,
+      number=4, type=11, cpp_type=10, label=1,
+      has_default_value=False, default_value=None,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='_x', full_name='t_tile._x',
+      index=0, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_y', full_name='t_tile._y',
+      index=1, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_z', full_name='t_tile._z',
+      index=2, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_tileData', full_name='t_tile._tileData',
+      index=3, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+  ],
+  serialized_start=343,
+  serialized_end=467,
+)
+
+
+_T_TILE_DATA = _descriptor.Descriptor(
+  name='t_tile_data',
+  full_name='t_tile_data',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='type', full_name='t_tile_data.type', index=0,
+      number=1, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='subtype', full_name='t_tile_data.subtype', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='id', full_name='t_tile_data.id', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='zv', full_name='t_tile_data.zv', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='weight', full_name='t_tile_data.weight', index=4,
+      number=5, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='_type', full_name='t_tile_data._type',
+      index=0, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_subtype', full_name='t_tile_data._subtype',
+      index=1, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_id', full_name='t_tile_data._id',
+      index=2, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_zv', full_name='t_tile_data._zv',
+      index=3, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_weight', full_name='t_tile_data._weight',
+      index=4, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+  ],
+  serialized_start=470,
+  serialized_end=625,
+)
+
+
+_T_STACK = _descriptor.Descriptor(
+  name='t_stack',
+  full_name='t_stack',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='tileDatas', full_name='t_stack.tileDatas', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='x', full_name='t_stack.x', index=1,
+      number=2, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='y', full_name='t_stack.y', index=2,
+      number=3, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='direction', full_name='t_stack.direction', index=3,
+      number=4, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='depth', full_name='t_stack.depth', index=4,
+      number=5, type=5, cpp_type=1, label=1,
+      has_default_value=False, default_value=0,
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+    _descriptor.OneofDescriptor(
+      name='_x', full_name='t_stack._x',
+      index=0, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_y', full_name='t_stack._y',
+      index=1, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_direction', full_name='t_stack._direction',
+      index=2, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+    _descriptor.OneofDescriptor(
+      name='_depth', full_name='t_stack._depth',
+      index=3, containing_type=None,
+      create_key=_descriptor._internal_create_key,
+    fields=[]),
+  ],
+  serialized_start=628,
+  serialized_end=782,
+)
+
+_LEVELSINDEX_LEVELSINDEXENTRY.fields_by_name['value'].message_type = _T_OFFESET_LEN
+_LEVELSINDEX_LEVELSINDEXENTRY.containing_type = _LEVELSINDEX
+_LEVELSINDEX.fields_by_name['LevelsIndex'].message_type = _LEVELSINDEX_LEVELSINDEXENTRY
+_LEVELDATA.fields_by_name['tiles'].message_type = _T_TILE
+_LEVELDATA.fields_by_name['stacks'].message_type = _T_STACK
+_LEVELDATA.oneofs_by_name['_tileWidth'].fields.append(
+  _LEVELDATA.fields_by_name['tileWidth'])
+_LEVELDATA.fields_by_name['tileWidth'].containing_oneof = _LEVELDATA.oneofs_by_name['_tileWidth']
+_LEVELDATA.oneofs_by_name['_tileHeight'].fields.append(
+  _LEVELDATA.fields_by_name['tileHeight'])
+_LEVELDATA.fields_by_name['tileHeight'].containing_oneof = _LEVELDATA.oneofs_by_name['_tileHeight']
+_T_TILE.fields_by_name['tileData'].message_type = _T_TILE_DATA
+_T_TILE.oneofs_by_name['_x'].fields.append(
+  _T_TILE.fields_by_name['x'])
+_T_TILE.fields_by_name['x'].containing_oneof = _T_TILE.oneofs_by_name['_x']
+_T_TILE.oneofs_by_name['_y'].fields.append(
+  _T_TILE.fields_by_name['y'])
+_T_TILE.fields_by_name['y'].containing_oneof = _T_TILE.oneofs_by_name['_y']
+_T_TILE.oneofs_by_name['_z'].fields.append(
+  _T_TILE.fields_by_name['z'])
+_T_TILE.fields_by_name['z'].containing_oneof = _T_TILE.oneofs_by_name['_z']
+_T_TILE.oneofs_by_name['_tileData'].fields.append(
+  _T_TILE.fields_by_name['tileData'])
+_T_TILE.fields_by_name['tileData'].containing_oneof = _T_TILE.oneofs_by_name['_tileData']
+_T_TILE_DATA.oneofs_by_name['_type'].fields.append(
+  _T_TILE_DATA.fields_by_name['type'])
+_T_TILE_DATA.fields_by_name['type'].containing_oneof = _T_TILE_DATA.oneofs_by_name['_type']
+_T_TILE_DATA.oneofs_by_name['_subtype'].fields.append(
+  _T_TILE_DATA.fields_by_name['subtype'])
+_T_TILE_DATA.fields_by_name['subtype'].containing_oneof = _T_TILE_DATA.oneofs_by_name['_subtype']
+_T_TILE_DATA.oneofs_by_name['_id'].fields.append(
+  _T_TILE_DATA.fields_by_name['id'])
+_T_TILE_DATA.fields_by_name['id'].containing_oneof = _T_TILE_DATA.oneofs_by_name['_id']
+_T_TILE_DATA.oneofs_by_name['_zv'].fields.append(
+  _T_TILE_DATA.fields_by_name['zv'])
+_T_TILE_DATA.fields_by_name['zv'].containing_oneof = _T_TILE_DATA.oneofs_by_name['_zv']
+_T_TILE_DATA.oneofs_by_name['_weight'].fields.append(
+  _T_TILE_DATA.fields_by_name['weight'])
+_T_TILE_DATA.fields_by_name['weight'].containing_oneof = _T_TILE_DATA.oneofs_by_name['_weight']
+_T_STACK.fields_by_name['tileDatas'].message_type = _T_TILE_DATA
+_T_STACK.oneofs_by_name['_x'].fields.append(
+  _T_STACK.fields_by_name['x'])
+_T_STACK.fields_by_name['x'].containing_oneof = _T_STACK.oneofs_by_name['_x']
+_T_STACK.oneofs_by_name['_y'].fields.append(
+  _T_STACK.fields_by_name['y'])
+_T_STACK.fields_by_name['y'].containing_oneof = _T_STACK.oneofs_by_name['_y']
+_T_STACK.oneofs_by_name['_direction'].fields.append(
+  _T_STACK.fields_by_name['direction'])
+_T_STACK.fields_by_name['direction'].containing_oneof = _T_STACK.oneofs_by_name['_direction']
+_T_STACK.oneofs_by_name['_depth'].fields.append(
+  _T_STACK.fields_by_name['depth'])
+_T_STACK.fields_by_name['depth'].containing_oneof = _T_STACK.oneofs_by_name['_depth']
+DESCRIPTOR.message_types_by_name['LevelsIndex'] = _LEVELSINDEX
+DESCRIPTOR.message_types_by_name['t_offeset_len'] = _T_OFFESET_LEN
+DESCRIPTOR.message_types_by_name['LevelData'] = _LEVELDATA
+DESCRIPTOR.message_types_by_name['t_tile'] = _T_TILE
+DESCRIPTOR.message_types_by_name['t_tile_data'] = _T_TILE_DATA
+DESCRIPTOR.message_types_by_name['t_stack'] = _T_STACK
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+LevelsIndex = _reflection.GeneratedProtocolMessageType('LevelsIndex', (_message.Message,), {
+
+  'LevelsIndexEntry' : _reflection.GeneratedProtocolMessageType('LevelsIndexEntry', (_message.Message,), {
+    'DESCRIPTOR' : _LEVELSINDEX_LEVELSINDEXENTRY,
+    '__module__' : 'levelData_pb2'
+    # @@protoc_insertion_point(class_scope:LevelsIndex.LevelsIndexEntry)
+    })
+  ,
+  'DESCRIPTOR' : _LEVELSINDEX,
+  '__module__' : 'levelData_pb2'
+  # @@protoc_insertion_point(class_scope:LevelsIndex)
+  })
+_sym_db.RegisterMessage(LevelsIndex)
+_sym_db.RegisterMessage(LevelsIndex.LevelsIndexEntry)
+
+t_offeset_len = _reflection.GeneratedProtocolMessageType('t_offeset_len', (_message.Message,), {
+  'DESCRIPTOR' : _T_OFFESET_LEN,
+  '__module__' : 'levelData_pb2'
+  # @@protoc_insertion_point(class_scope:t_offeset_len)
+  })
+_sym_db.RegisterMessage(t_offeset_len)
+
+LevelData = _reflection.GeneratedProtocolMessageType('LevelData', (_message.Message,), {
+  'DESCRIPTOR' : _LEVELDATA,
+  '__module__' : 'levelData_pb2'
+  # @@protoc_insertion_point(class_scope:LevelData)
+  })
+_sym_db.RegisterMessage(LevelData)
+
+t_tile = _reflection.GeneratedProtocolMessageType('t_tile', (_message.Message,), {
+  'DESCRIPTOR' : _T_TILE,
+  '__module__' : 'levelData_pb2'
+  # @@protoc_insertion_point(class_scope:t_tile)
+  })
+_sym_db.RegisterMessage(t_tile)
+
+t_tile_data = _reflection.GeneratedProtocolMessageType('t_tile_data', (_message.Message,), {
+  'DESCRIPTOR' : _T_TILE_DATA,
+  '__module__' : 'levelData_pb2'
+  # @@protoc_insertion_point(class_scope:t_tile_data)
+  })
+_sym_db.RegisterMessage(t_tile_data)
+
+t_stack = _reflection.GeneratedProtocolMessageType('t_stack', (_message.Message,), {
+  'DESCRIPTOR' : _T_STACK,
+  '__module__' : 'levelData_pb2'
+  # @@protoc_insertion_point(class_scope:t_stack)
+  })
+_sym_db.RegisterMessage(t_stack)
+
+
+DESCRIPTOR._options = None
+_LEVELSINDEX_LEVELSINDEXENTRY._options = None
+# @@protoc_insertion_point(module_scope)

BIN
TileFamily/TileLevelScript/loadable/.DS_Store