├── .gitignore
├── test_map.sqlite
├── README.md
├── clrmap.py
├── inspectmap.py
├── recover.py
├── remap.py
├── tests.py
├── countowners.py
├── domap.py
├── mirrormap.py
├── mt_block_parser.py
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.bac
3 | *.bak
4 | __pycache__
5 | 


--------------------------------------------------------------------------------
/test_map.sqlite:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AndrejIT/map_unexplore/HEAD/test_map.sqlite


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | map_unexplore
 2 | =============
 3 | 
 4 | Scripts for Minetest game map v25 format.
 5 | 
 6 | mt_block_parser.py - Can do partial or full parsing of map block. Can reassemble("Compile") block back to binary data.
 7 | 
 8 | 
 9 | remap.py - Decrease minetest map size and saves it as backup(most likely even online).
10 | 
11 | domap.py - Creates simple image, to show where player have built something.
12 | 
13 | clrmap.py - Clears all objects from map and saves it as backup.
14 | 
15 | mt_block_parser.py - Can be used to read map block data from your code.
16 | 
17 | recover.py - Copy only healthy map blocks.
18 | 
19 | mirrormap.py - Creates mirrored version of map.
20 | 
21 | countowners.py - Get a list with players, who own protected chests and number of chests.
22 | 
23 | inspectmap.py - Get list of names for all nodes present on the map.
24 | 
25 | Now can pass paths to database files. Use like "./script.py <source.sqlite> <target.sqlite>" (or "<pythonpath>\python.exe script.py <source.sqlite> <target.sqlite>" on Windows)
26 | 


--------------------------------------------------------------------------------
/clrmap.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #Licence LGPL v2.1
 3 | 
 4 | #Copy all blocks, but remove from them all objects.
 5 | 
 6 | import sys #to get parameters
 7 | import sqlite3
 8 | import mt_block_parser
 9 | 
10 | import struct
11 | import zlib
12 | 
13 | source = r'<Put your path to world folder here>/map.sqlite.backup'
14 | target = r'<Put your path to world folder here>/map.sqlite.clear'
15 | arguments = sys.argv
16 | if(len(arguments) == 3 ):
17 |     source = str(arguments[1])
18 |     target = str(arguments[2])
19 | 
20 | sourceconn = sqlite3.connect(source)
21 | targetconn = sqlite3.connect(target)
22 | sourcecursor = sourceconn.cursor()
23 | targetcursor = targetconn.cursor()
24 | targetcursor.execute("CREATE TABLE IF NOT EXISTS `blocks` (`pos` INT NOT NULL PRIMARY KEY, `data` BLOB);")
25 | 
26 | for row in sourcecursor.execute("SELECT `pos`, `data` "+" FROM `blocks`;"):
27 |     block = mt_block_parser.MtBlockParser(row[1])
28 |     if block.static_object_count == 0:
29 |         targetcursor.execute("INSERT OR IGNORE INTO `blocks` VALUES (?, ?);", (row[0], row[1]))
30 |     else:
31 |         #combine block back to string, but leave objects out
32 |         block.objectsRead = struct.pack('>H', 0)
33 |         cleared_block = block.selfCompile()
34 |         targetcursor.execute("INSERT OR IGNORE INTO `blocks` VALUES (?, ?);", (row[0], sqlite3.Binary(cleared_block)))
35 |             
36 | targetconn.commit()
37 | 
38 | sourceconn.close()
39 | targetconn.close()
40 | 


--------------------------------------------------------------------------------
/inspectmap.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #Licence LGPL v2.1
 3 | 
 4 | #Find what nodes map contains
 5 | 
 6 | import sys #to get parameters
 7 | import sqlite3
 8 | import operator
 9 | import mt_block_parser
10 | 
11 | 
12 | source = r'<Put your path to world folder here>/map.sqlite.backup'
13 | target = r'<Put path to output text file>'
14 | arguments = sys.argv
15 | if(len(arguments) > 1 ):
16 |     source = str(arguments[1])
17 | if(len(arguments) > 2 ):
18 |     target = str(arguments[2])
19 | 
20 | sourceconn = sqlite3.connect(source)
21 | sourcecursor0 = sourceconn.cursor()
22 | sourcecursor = sourceconn.cursor()
23 | 
24 | nodelist = {}
25 | 
26 | for row in sourcecursor0.execute("SELECT `pos` FROM `blocks`"):
27 |     for datarow in sourcecursor.execute("SELECT `data` FROM `blocks` WHERE `pos` == ? LIMIT 1;", (row[0],)):
28 |         temp = mt_block_parser.MtBlockParser(datarow[0])
29 | 
30 |         temp.nameIdMappingsParse()
31 |         for key,value in temp.nameIdMappings.items():
32 |             if value.decode() not in nodelist:
33 |                 nodelist[value.decode()] = 0
34 | 
35 |         #Counting all nodes takes too long
36 |         # temp.nodeDataParse()
37 |         # for i in range(0, 4096):
38 |         #     tempName = temp.nameIdMappings[temp.arrayParam0[i]]
39 |         #     nodelist[tempName]+= 1
40 | 
41 | s_nodelist = sorted(nodelist)
42 | #s_nodelist = sorted(nodelist.items(), key=operator.itemgetter(1))
43 | 
44 | with open(target, "w") as text_file:
45 |     for n in s_nodelist:
46 |         text_file.write(str(n) + "\n")
47 |         #text_file.write(str(n[0]) + ' ' + str(n[1]) + "\n")
48 |         print(n)
49 | 
50 | sourceconn.close()
51 | 


--------------------------------------------------------------------------------
/recover.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #Licence LGPL v2.1
 3 | 
 4 | #Copy all blocks except corrupted ones
 5 | 
 6 | import sys #to get parameters
 7 | import sqlite3
 8 | import mt_block_parser
 9 | 
10 | import struct
11 | import zlib
12 | 
13 | def getIntegerAsBlock(i):
14 |     x = unsignedToSigned(i % 4096, 2048)
15 |     i = int((i - x) / 4096)
16 |     y = unsignedToSigned(i % 4096, 2048)
17 |     i = int((i - y) / 4096)
18 |     z = unsignedToSigned(i % 4096, 2048)
19 |     return x,y,z
20 | def unsignedToSigned(i, max_positive):
21 |     if i < max_positive:
22 |         return i
23 |     else:
24 |         return i - 2*max_positive
25 | 
26 | source = r'<Put your path to world folder here>/map.sqlite.backup'
27 | target = r'<Put your path to world folder here>/map.sqlite.clear'
28 | arguments = sys.argv
29 | if(len(arguments) == 3 ):
30 |     source = str(arguments[1])
31 |     target = str(arguments[2])
32 | 
33 | sourceconn = sqlite3.connect(source)
34 | targetconn = sqlite3.connect(target)
35 | sourcecursor = sourceconn.cursor()
36 | targetcursor = targetconn.cursor()
37 | targetcursor.execute("CREATE TABLE IF NOT EXISTS `blocks` (`pos` INT NOT NULL PRIMARY KEY, `data` BLOB);")
38 | 
39 | for row in sourcecursor.execute("SELECT `pos`, `data` "+" FROM `blocks`;"):
40 |     pos=getIntegerAsBlock(row[0])
41 |     try:
42 |         temp = mt_block_parser.MtBlockParser(row[1])
43 |         if temp:
44 |             targetcursor.execute("INSERT OR IGNORE INTO `blocks` VALUES (?, ?);", (row[0], row[1]))
45 |     except:
46 |         print("Block parse error:", pos[0], pos[1], pos[2])
47 |             
48 | targetconn.commit()
49 | 
50 | sourceconn.close()
51 | targetconn.close()
52 | 


--------------------------------------------------------------------------------
/remap.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | #Licence LGPL v2.1
 4 | #Creates copy of map db, leaving only specified(filtered) blocks.
 5 | #Can also be used for map backup, may-be even online backup.
 6 | 
 7 | import sys #to get parameters
 8 | import sqlite3
 9 | import mt_block_parser
10 | 
11 | import re
12 | 
13 | def getIntegerAsBlock(i):
14 |     x = unsignedToSigned(i % 4096, 2048)
15 |     i = int((i - x) / 4096)
16 |     y = unsignedToSigned(i % 4096, 2048)
17 |     i = int((i - y) / 4096)
18 |     z = unsignedToSigned(i % 4096, 2048)
19 |     return x,y,z
20 | def unsignedToSigned(i, max_positive):
21 |     if i < max_positive:
22 |         return i
23 |     else:
24 |         return i - 2*max_positive
25 | 
26 | source = r'<Put your path to world folder here>/map.sqlite.backup'
27 | target = r'<Put your path to world folder here>/map.sqlite.clear'
28 | arguments = sys.argv
29 | if(len(arguments) == 3 ):
30 |     source = str(arguments[1])
31 |     target = str(arguments[2])
32 | 
33 | #use compiled regular expression to filter blocks by block content. it is faster that checking "in array".
34 | useful_block_evidence = re.compile(
35 |     b"default:cobble|"+
36 |     b"protector:protect|default:chest_locked|doors:door_steel|"+
37 |     b"default:chest|default:torch|default:stonebrick|default:glass|default:obsidian_glass|"+
38 |     b"default:ladder|default:rail|default:fence_wood|"+
39 |     b"bones:bones"
40 |     )
41 | 
42 | sourceconn = sqlite3.connect(source)
43 | targetconn = sqlite3.connect(target)
44 | sourcecursor = sourceconn.cursor()
45 | targetcursor = targetconn.cursor()
46 | targetcursor.execute("CREATE TABLE IF NOT EXISTS `blocks` (`pos` INT NOT NULL PRIMARY KEY, `data` BLOB);")
47 | 
48 | for row in sourcecursor.execute("SELECT `pos`, `data` "+" FROM `blocks`;"):
49 |     pos=getIntegerAsBlock(row[0])
50 |     if 0 and pos[0]**2 + pos[2]**2 < (160/16)**2 and pos[1]>(-60/16):    #160 nodes radius and 60 nodes deep
51 |         targetcursor.execute("INSERT OR IGNORE INTO `blocks` VALUES (?, ?);", (row[0], row[1]))
52 |     else:
53 |         try:
54 |             temp = mt_block_parser.MtBlockParser(row[1])
55 |             if useful_block_evidence.search(temp.nameIdMappingsRead)!=None:
56 |                 targetcursor.execute("INSERT OR IGNORE INTO `blocks` VALUES (?, ?);", (row[0], row[1]))
57 |         except:
58 |             print("Block parse error:", pos[0], pos[1], pos[2])
59 |             
60 | targetconn.commit()
61 | 
62 | sourceconn.close()
63 | targetconn.close()
64 | 


--------------------------------------------------------------------------------
/tests.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #Licence LGPL v2.1
 3 | 
 4 | # Tests for coordinate conversion functions
 5 | 
 6 | def getIntegerAsBlock(i):
 7 |     x = unsignedToSigned(i % 4096, 2048)
 8 |     i = int((i - x) / 4096)
 9 |     y = unsignedToSigned(i % 4096, 2048)
10 |     i = int((i - y) / 4096)
11 |     z = unsignedToSigned(i % 4096, 2048)
12 |     return x,y,z
13 | 
14 | 
15 | def unsignedToSigned(i, max_positive):
16 |     if i < max_positive:
17 |         return i
18 |     else:
19 |         return i - 2*max_positive
20 | 
21 | 
22 | def int64(u):
23 | 	while u >= 2**63:
24 | 		u -= 2**64
25 | 	while u <= -2**63:
26 | 		u += 2**64
27 | 	return u
28 | 
29 | # Convert location to integer
30 | def getBlockAsInteger(p):
31 | 	return int64(p[2]*16777216 + p[1]*4096 + p[0])
32 | 
33 | 
34 | sample_p = (1, -1, 1)
35 | result_i = getBlockAsInteger(list(sample_p))
36 | result_p = getIntegerAsBlock(result_i)
37 | print(sample_p, result_i, result_p)
38 | assert result_p == sample_p, "Test 1 failed"
39 | 
40 | sample_p = (1, 1, 1)
41 | result_i = getBlockAsInteger(list(sample_p))
42 | result_p = getIntegerAsBlock(result_i)
43 | print(sample_p, result_i, result_p)
44 | assert result_p == sample_p, "Test 2 failed"
45 | 
46 | sample_p = (-1, -1, -1)
47 | result_i = getBlockAsInteger(list(sample_p))
48 | result_p = getIntegerAsBlock(result_i)
49 | print(sample_p, result_i, result_p)
50 | assert result_p == sample_p, "Test 3 failed"
51 | 
52 | sample_p = (-1, 0, 0)
53 | result_i = getBlockAsInteger(list(sample_p))
54 | result_p = getIntegerAsBlock(result_i)
55 | print(sample_p, result_i, result_p)
56 | assert result_p == sample_p, "Test 4 failed"
57 | 
58 | sample_p = (-1, 1, 1)
59 | result_i = getBlockAsInteger(list(sample_p))
60 | result_p = getIntegerAsBlock(result_i)
61 | print(sample_p, result_i, result_p)
62 | assert result_p == sample_p, "Test 5 failed"
63 | 
64 | sample_p = (0, -1, -1)
65 | result_i = getBlockAsInteger(list(sample_p))
66 | result_p = getIntegerAsBlock(result_i)
67 | print(sample_p, result_i, result_p)
68 | assert result_p == sample_p, "Test 6 failed"
69 | 
70 | sample_p = (0, 0, 0)
71 | result_i = getBlockAsInteger(list(sample_p))
72 | result_p = getIntegerAsBlock(result_i)
73 | print(sample_p, result_i, result_p)
74 | assert result_p == sample_p, "Test 7 failed"
75 | 
76 | sample_p = (-1, -1, 1)
77 | result_i = getBlockAsInteger(list(sample_p))
78 | result_p = getIntegerAsBlock(result_i)
79 | print(sample_p, result_i, result_p)
80 | assert result_p == sample_p, "Test 8 failed"
81 | 
82 | sample_p = (10, 10, 10)
83 | result_i = getBlockAsInteger(list(sample_p))
84 | result_p = getIntegerAsBlock(result_i)
85 | print(sample_p, result_i, result_p)
86 | assert result_p == sample_p, "Test 9 failed"
87 | 
88 | sample_p = (-10, -10, -10)
89 | result_i = getBlockAsInteger(list(sample_p))
90 | result_p = getIntegerAsBlock(result_i)
91 | print(sample_p, result_i, result_p)
92 | assert result_p == sample_p, "Test 10 failed"
93 | 


--------------------------------------------------------------------------------
/countowners.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | #Licence LGPL v2.1
 3 | 
 4 | #list owners of protection blocks and locked chests
 5 | 
 6 | import sys #to get parameters
 7 | import sqlite3
 8 | import operator
 9 | import mt_block_parser
10 | import re
11 | 
12 | 
13 | source = r'<Put your path to world folder here>/map.sqlite.backup'
14 | target = r'<Put path to output text file>'
15 | arguments = sys.argv
16 | if(len(arguments) > 1 ):
17 |     source = str(arguments[1])
18 | if(len(arguments) > 2 ):
19 |     target = str(arguments[2])
20 | 
21 | print(source)
22 | 
23 | sourceconn = sqlite3.connect(source)
24 | sourcecursor = sourceconn.cursor()
25 | 
26 | #ownprot = {}
27 | ownchest = {}
28 | ownsomething = {}
29 | 
30 | #owned_block_evidence = re.compile(b"protector:protect")
31 | #owned_block_evidence = re.compile(b"default:chest_locked")
32 | owned_block_evidence = re.compile(b"protector:protect|protector_mese:protect|default:chest_locked")
33 | 
34 | 
35 | 
36 | for datarow in sourcecursor.execute("SELECT `data` FROM `blocks`"):
37 |     temp = mt_block_parser.MtBlockParser(datarow[0])
38 |     if owned_block_evidence.search(temp.nameIdMappingsRead)!=None:
39 |         temp.nodeDataParse()
40 |         temp.nodeMetadataParse()
41 |         temp.nameIdMappingsParse()
42 |         for i in range(0, 4096):
43 |             tempName = temp.nameIdMappings[temp.arrayParam0[i]]
44 | #                if tempName == 'protector:protect':
45 | #                    if temp.arrayMetadataRead[i]['owner'] in ownprot:
46 | #                        ownprot[temp.arrayMetadataRead[i]['owner']]+= 1
47 | #                    else:
48 | #                        ownprot[temp.arrayMetadataRead[i]['owner']] = 1
49 | #                if tempName == 'default:chest_locked':
50 | #                    if temp.arrayMetadataRead[i]['owner'] in ownchest:
51 | #                        ownchest[temp.arrayMetadataRead[i]['owner']]+= 1
52 | #                    else:
53 | #                        ownchest[temp.arrayMetadataRead[i]['owner']] = 1
54 |             if tempName == b'protector:protect' or tempName == b'protector_mese:protect' or tempName == b'default:chest_locked':
55 |                 if temp.arrayMetadataRead[i][b'owner'] in ownsomething:
56 |                     ownsomething[temp.arrayMetadataRead[i][b'owner']]+= 1
57 |                 else:
58 |                     ownsomething[temp.arrayMetadataRead[i][b'owner']] = 1
59 |                     
60 | #s_ownprot = sorted(ownprot.items(), key=operator.itemgetter(1))
61 | #s_ownchest = sorted(ownchest.items(), key=operator.itemgetter(1))
62 | s_ownsomething = sorted(ownsomething.items(), key=operator.itemgetter(1))
63 | 
64 | with open(target, "w") as text_file:
65 |     for n in s_ownsomething:
66 |         text_file.write(str(n[0]) + "\n")
67 |         print(n)
68 | 
69 | #datafile = file('auth.txt')
70 | #for line in datafile:
71 | #    for i,n in enumerate(s_ownprot):
72 | #        pname = line.split(':')[0]
73 | #        if pname == n[0]:
74 | #            s_ownprot[i] = (n[0], line)
75 | #
76 | #with open("auth_re.txt", "w") as text_file:
77 | #    for n in s_ownprot:
78 | #        if isinstance(n[1], basestring):
79 | #            text_file.write(n[1])
80 | #        else:
81 | #            print n
82 | 
83 | sourceconn.close()
84 | 
85 | 


--------------------------------------------------------------------------------
/domap.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #Licence LGPL v2.1
  3 | 
  4 | #https://github.com/minetest/minetest/blob/944ffe9e532a3b2be686ef28c33313148760b1c9/doc/mapformat.txt
  5 | #http://www.tutorialspoint.com/sqlite/sqlite_bitwise_operators.htm
  6 | #http://stackoverflow.com/questions/1294619/does-sqlite-support-any-kind-of-ifcondition-statement-in-a-select
  7 | 
  8 | import sys #to get parameters
  9 | import sqlite3
 10 | import mt_block_parser
 11 | 
 12 | import re
 13 | 
 14 | from PIL import Image, ImageDraw, ImageFont, ImageColor
 15 | 
 16 | #It is possible to get X, Y, Z directly by SQLite!
 17 | #for row in sourcecursor.execute(" SELECT "+
 18 | #                                " CASE WHEN `X` < 2048 THEN `X` ELSE `X` - 4096 END AS X, "+
 19 | #                                " CASE WHEN `Y` < 2048 THEN `Y` ELSE `Y` - 4096 END AS Y, "+
 20 | #                                " CASE WHEN `Z` < 2048 THEN `Z` ELSE `Z` - 4096 END AS Z "+
 21 | #                                " FROM ("+"SELECT "+
 22 | #                                    " (`pos`) & 4095 AS X, "+
 23 | #                                    " ((`pos`) & 16773120)>>12 AS Y, "+
 24 | #                                    " ((`pos`) & 68702699520)>>24 AS Z "+
 25 | #                                    " FROM `blocks`"+
 26 | #                                ")"):
 27 | 
 28 | source = r'<Put your path to world folder here>/map.sqlite'
 29 | target_image = r'<Put your path to world folder here>/map.png'
 30 | arguments = sys.argv
 31 | if(len(arguments) == 3 ):
 32 |     source = str(arguments[1])
 33 |     target_image = str(arguments[2])
 34 | 
 35 | #use compiled regular expression to filter blocks by block content. it is faster that checking "in array".
 36 | useful_block_evidence = re.compile(
 37 |     #b"default:cobble|"+"bones:bones|"+
 38 |     b"protector:protect|default:chest_locked|doors:door_steel|"+
 39 |     b"default:chest|default:torch|default:stonebrick|default:glass|default:obsidian_glass|"+
 40 |     b"default:ladder|default:rail|default:fence_wood"
 41 |     )
 42 | 
 43 | sourceconn = sqlite3.connect(source)
 44 | sourcecursorXZ = sourceconn.cursor()
 45 | sourcecursor = sourceconn.cursor()
 46 | 
 47 | #X and Z min and max to know image size
 48 | for rowMinMax in sourcecursorXZ.execute(" SELECT "+
 49 |                                 " MIN( CASE WHEN `X` < 2048 THEN `X` ELSE `X` - 4096 END ) AS minX, "+
 50 |                                 " MIN( CASE WHEN `Z` < 2048 THEN `Z` ELSE `Z` - 4096 END ) AS minZ, "+
 51 |                                 " MAX( CASE WHEN `X` < 2048 THEN `X` ELSE `X` - 4096 END ) AS maxX, "+
 52 |                                 " MAX( CASE WHEN `Z` < 2048 THEN `Z` ELSE `Z` - 4096 END ) AS maxZ "+
 53 |                                 " FROM ("+"SELECT "+
 54 |                                     " (`pos`) & 4095 AS X, "+
 55 |                                     " ((`pos`) & 68702699520)>>24 AS Z "+
 56 |                                     " FROM `blocks`"+
 57 |                                 ")"):
 58 |     minX = rowMinMax[0]
 59 |     minZ = rowMinMax[1]
 60 |     maxX = rowMinMax[2]
 61 |     maxZ = rowMinMax[3]
 62 |     width = maxZ - minZ
 63 |     height = maxX - minX
 64 | 
 65 | 
 66 | image = Image.new("RGB", (width, height), (0,0,0,0))
 67 | draw = ImageDraw.Draw(image)
 68 | impixel = image.load()
 69 | 
 70 | #assuming that map is moustly flat limit Y coordinate
 71 | for row in sourcecursor.execute(" SELECT "+
 72 |                                 " CASE WHEN `X` < 2048 THEN `X` ELSE `X` - 4096 END AS X, "+
 73 |                                 " CASE WHEN `Y` < 2048 THEN `Y` ELSE `Y` - 4096 END AS Y, "+
 74 |                                 " CASE WHEN `Z` < 2048 THEN `Z` ELSE `Z` - 4096 END AS Z, "+
 75 |                                 " `pos`, "+
 76 |                                 " `data` "+
 77 |                                 " FROM ("+"SELECT "+
 78 |                                     " `pos`, "+
 79 |                                     " (`pos`) & 4095 AS X, "+
 80 |                                     " ((`pos`) & 16773120)>>12 AS Y, "+
 81 |                                     " ((`pos`) & 68702699520)>>24 AS Z, "+
 82 |                                     " `data` "+
 83 |                                     " FROM `blocks`"+
 84 |                                 ")"+
 85 |                                 " WHERE Y>-5 AND Y<5; "):
 86 |     try:
 87 |         block = mt_block_parser.MtBlockParser(row[4])
 88 |     except:
 89 |         print("Block parse error:", row[0], row[1], row[2])
 90 |     else:
 91 |         if useful_block_evidence.search(block.nameIdMappingsRead)!=None:
 92 |             if row[0] - minX < 0 or width <= row[0] - minX or height - row[2] + minZ < 0 or height <= height - row[2] + minZ:
 93 |                 print("Do not fit to image:", row[0], row[1], row[2])
 94 |             else:
 95 |                 impixel[ row[0] - minX, height - row[2] + minZ ] = (255, 255, 200)
 96 | 
 97 | 
 98 | sourceconn.close()
 99 | 
100 | draw.ellipse((-minX - 5, height + minZ - 5, -minX + 5, height + minZ + 5), outline=(255, 0, 0)) #map center
101 | image.save(target_image)
102 | 


--------------------------------------------------------------------------------
/mirrormap.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | #Licence LGPL v2.1
  3 | 
  4 | #mirror map. just for fun and to prove concept of block reassembling.
  5 | 
  6 | import sys #to get parameters
  7 | import sqlite3
  8 | import time
  9 | import mt_block_parser
 10 | 
 11 | 
 12 | def rposAsInt(p):
 13 |     return int(p[2]*16*16 + p[1]*16 + p[0])
 14 | 
 15 | def intAsRpos(i):
 16 |     x = i % 16
 17 |     i = int((i - x) / 16)
 18 |     y = i % 16
 19 |     i = int((i - y) / 16)
 20 |     z = i % 16
 21 |     return x,y,z
 22 | 
 23 | def getIntegerAsBlock(i):
 24 |     x = unsignedToSigned(i % 4096, 2048)
 25 |     i = int((i - x) / 4096)
 26 |     y = unsignedToSigned(i % 4096, 2048)
 27 |     i = int((i - y) / 4096)
 28 |     z = unsignedToSigned(i % 4096, 2048)
 29 |     return x,y,z
 30 | def unsignedToSigned(i, max_positive):
 31 |     if i < max_positive:
 32 |         return i
 33 |     else:
 34 |         return i - 2*max_positive
 35 | 
 36 | # Convert location to integer
 37 | def getBlockAsInteger(p):
 38 | 	return int64(p[2]*16777216 + p[1]*4096 + p[0])
 39 | def int64(u):
 40 | 	while u >= 2**63:
 41 | 		u -= 2**64
 42 | 	while u <= -2**63:
 43 | 		u += 2**64
 44 | 	return u
 45 | 
 46 | source = r'<Put your path to world folder here>/map.sqlite.backup'
 47 | target = r'<Put your path to world folder here>/map.sqlite.clear'
 48 | arguments = sys.argv
 49 | if(len(arguments) == 3 ):
 50 |     source = str(arguments[1])
 51 |     target = str(arguments[2])
 52 | 
 53 | 
 54 | sourceconn = sqlite3.connect(source)
 55 | targetconn = sqlite3.connect(target)
 56 | sourcecursor0 = sourceconn.cursor()
 57 | sourcecursor = sourceconn.cursor()
 58 | targetcursor = targetconn.cursor()
 59 | 
 60 | targetcursor.execute("CREATE TABLE IF NOT EXISTS `blocks` (`pos` INT NOT NULL PRIMARY KEY, `data` BLOB);")
 61 | 
 62 | m = {} #mirrored order of keys
 63 | for i in range(0, 4096):
 64 |     p = intAsRpos(i)
 65 |     m[i] = rposAsInt([p[0], p[1], 15-p[2]])
 66 |     
 67 | facedir_nodelist = [b'default:chest', b'default:chest_locked', b'default:bookshelf', 
 68 | b'door_wood_a', b'door_wood_b', b'door_steel_a', b'door_steel_b',  #doors are more complicated, TODO
 69 | b'default:furnace', b'default:furnace_active',
 70 | b'beds:fancy_bed_top', b'beds:fancy_bed_bottom', b'beds:bed_top', b'beds:bed_bottom']
 71 | 
 72 | for row in sourcecursor0.execute("SELECT `pos` FROM `blocks`"):
 73 |     pos=getIntegerAsBlock(row[0])
 74 |     if pos[0]**2 + pos[2]**2 < (160/16)**2 and pos[1]>(-60/16) and pos[1]<(128/16):    #just small central map part for fast demonstration
 75 |         for datarow in sourcecursor.execute("SELECT `data` FROM `blocks` WHERE `pos` == ? LIMIT 1;", (row[0],)):
 76 |             tempA = mt_block_parser.MtBlockParser(datarow[0])
 77 |             tempA.nodeDataParse()
 78 |             tempA.nodeMetadataParse()
 79 |             tempA.nameIdMappingsParse()
 80 |             
 81 |             tempB = mt_block_parser.MtBlockParser(0) #blank block
 82 |             
 83 |             for i in range(0, 4096):
 84 |                 tempB.arrayParam0[i] = tempA.arrayParam0[m[i]]
 85 |                 tempB.arrayParam1[i] = tempA.arrayParam1[m[i]]
 86 |                 tempB.arrayParam2[i] = tempA.arrayParam2[m[i]]
 87 |                 if tempA.arrayParam0[i] not in tempB.nameIdMappings:
 88 |                     tempB.nameIdMappings[tempA.arrayParam0[i]] = tempA.nameIdMappings[tempA.arrayParam0[i]]
 89 |                 if m[i] in tempA.arrayMetadataRead:
 90 |                     tempB.arrayMetadataRead[i] = tempA.arrayMetadataRead[m[i]]
 91 |                     tempB.arrayMetadataReadPrivate[i] = tempA.arrayMetadataReadPrivate[m[i]]
 92 |                     tempB.arrayMetadataReadInventory[i] = tempA.arrayMetadataReadInventory[m[i]]
 93 |                 #rotate nodes wallmounted
 94 |                 if tempA.arrayParam2[m[i]] == 4:
 95 |                     tempB.arrayParam2[i] = 5
 96 |                 elif tempA.arrayParam2[m[i]] == 5:
 97 |                     tempB.arrayParam2[i] = 4
 98 |                 #rotate nodes facedir
 99 |                 elif tempA.arrayParam2[m[i]] == 0:
100 |                     if tempA.nameIdMappings[tempA.arrayParam0[m[i]]] in facedir_nodelist:
101 |                         tempB.arrayParam2[i] = 2
102 |                 elif tempA.arrayParam2[m[i]] == 2:
103 |                     if tempA.nameIdMappings[tempA.arrayParam0[m[i]]] in facedir_nodelist:
104 |                         tempB.arrayParam2[i] = 0
105 |             
106 |             tempB.nodeDataCompile()
107 |             tempB.nodeMetadataCompile()
108 |             tempB.nameIdMappingsCompile()
109 |             
110 |             cleared_block = sqlite3.Binary(tempB.selfCompile())
111 |             
112 |             posm = [pos[0], pos[1], -pos[2]]
113 |             targetcursor.execute("INSERT OR IGNORE INTO `blocks` VALUES (?, ?);", (getBlockAsInteger(posm), cleared_block))
114 |             if pos[0] == 0 and pos[2] == 0:
115 |                 targetconn.commit()
116 |                 print(row[0])    #at least something to see progress
117 | 
118 | targetconn.commit()
119 | sourceconn.close()
120 | targetconn.close()
121 | 
122 | 


--------------------------------------------------------------------------------
/mt_block_parser.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | 
  3 | #Licence LGPL v2.1
  4 | #Created for version 25. Updated to support version 28.
  5 | #https://github.com/minetest/minetest/blob/944ffe9e532a3b2be686ef28c33313148760b1c9/doc/mapformat.txt
  6 | #https://github.com/minetest/minetest/blob/master/doc/world_format.txt
  7 | 
  8 | import sys
  9 | import struct
 10 | import zlib
 11 | import re
 12 | 
 13 | class MtBlockParser:
 14 |     'Allows to read different data from Minetest map v.25 block'
 15 |     length = None
 16 | 
 17 |     version = 25
 18 |     flags = None
 19 |     content_width = 2
 20 |     params_width = 2
 21 | 
 22 |     nodeDataRead = bytearray()
 23 |     arrayParam0 = None
 24 |     arrayParam1 = None
 25 |     arrayParam2 = None
 26 | 
 27 |     nodeMetadataRead = bytearray()
 28 |     metadata_version = 2    # 2 since map version 28
 29 |     metadata_count = None
 30 |     arrayMetadataRead = None
 31 |     arrayMetadataReadPrivate = None
 32 |     arrayMetadataReadInventory = None
 33 | 
 34 |     static_object_version = 0
 35 |     static_object_count = None
 36 |     objectsRead = bytearray()
 37 |     #TODO
 38 | 
 39 |     timestamp = None
 40 | 
 41 |     name_id_mapping_version = 0
 42 |     num_name_id_mappings = None
 43 |     nameIdMappingsRead = bytearray()
 44 |     nameIdMappings = None
 45 | 
 46 |     length_of_timer = 10
 47 |     num_of_timers = None
 48 |     timersRead = bytearray()
 49 |     arrayTimerTimeout = None
 50 |     arrayTimerElapsed = None
 51 | 
 52 |     def __init__(self, blockBlob):
 53 |         self.nodeDataRead = bytearray()
 54 |         self.nodeMetadataRead = bytearray()
 55 |         self.objectsRead = bytearray()
 56 |         self.nameIdMappingsRead = bytearray()
 57 |     
 58 |         self.arrayParam0 = {}
 59 |         self.arrayParam1 = {}
 60 |         self.arrayParam2 = {}
 61 |         self.arrayMetadataRead = {}
 62 |         self.arrayMetadataReadPrivate = {}
 63 |         self.arrayMetadataReadInventory = {}
 64 |         self.nameIdMappings = {}
 65 |         self.arrayTimerTimeout = {}
 66 |         self.arrayTimerElapsed = {}
 67 | 
 68 |         if blockBlob:
 69 |             self.length = len(blockBlob)
 70 | 
 71 |             cursor = 0
 72 |             if self.version > struct.unpack('B', blockBlob[cursor:cursor + 1])[0]:
 73 |                 print("Old version not supported!")
 74 |             if 27 <= struct.unpack('B', blockBlob[cursor:cursor + 1])[0]:
 75 |                 #print("Warning for new version!")
 76 |                 cursor+= 1
 77 |                 self.flags = struct.unpack('B', blockBlob[cursor:cursor + 1])[0]
 78 |                 cursor+= 1
 79 |                 #Skipping two bytes from 27. version map format. Their purpose is for lightning recalculation
 80 |                 #I will just ignore them for now and save map back to the older format
 81 |                 cursor+= 1
 82 |                 cursor+= 1
 83 |             else:
 84 |                 cursor+= 1
 85 |                 self.flags = struct.unpack('B', blockBlob[cursor:cursor + 1])[0]
 86 |                 cursor+= 1
 87 |             if self.content_width != struct.unpack('B', blockBlob[cursor:cursor + 1])[0]:
 88 |                 print("Content width not supported!", struct.unpack('B', blockBlob[cursor:cursor + 1])[0])
 89 |             cursor+= 1
 90 |             if self.params_width != struct.unpack('B', blockBlob[cursor:cursor + 1])[0]:
 91 |                 print("Params width not supported!", struct.unpack('B', blockBlob[cursor:cursor + 1])[0])
 92 |             cursor+= 1
 93 |             decompressor = zlib.decompressobj()
 94 |             self.nodeDataRead = decompressor.decompress( blockBlob[cursor:] )
 95 |             cursor = self.length - len(decompressor.unused_data)
 96 |             decompressor = zlib.decompressobj()
 97 |             self.nodeMetadataRead = decompressor.decompress( blockBlob[cursor:] )
 98 |             cursor = self.length - len(decompressor.unused_data)
 99 |             if self.static_object_version != struct.unpack('B', blockBlob[cursor:cursor + 1])[0]:
100 |                 print("Object version not supported!")
101 |             cursor+=1
102 |             self.static_object_count = struct.unpack('>H', blockBlob[cursor:cursor + 2])[0]
103 |             self.objectsRead.extend(blockBlob[cursor:cursor + 2])
104 |             cursor+= 2
105 |             for i in range(0, self.static_object_count):
106 |                 self.objectsRead.extend(blockBlob[cursor:cursor + 13])
107 |                 cursor+= 13
108 |                 self.objectsRead.extend(blockBlob[cursor:cursor + 2])
109 |                 data_size = struct.unpack('>H', blockBlob[cursor:cursor + 2])[0]
110 |                 cursor+= 2
111 |                 self.objectsRead.extend(blockBlob[cursor:cursor + data_size])
112 |                 cursor+= data_size
113 |             self.timestamp = struct.unpack('>I', blockBlob[cursor:cursor + 4])[0]
114 |             cursor+= 4
115 |             if self.name_id_mapping_version != struct.unpack('B', blockBlob[cursor:cursor + 1])[0]:
116 |                 print("Name-ID mapping version not supported!")
117 |             cursor+= 1
118 |             self.num_name_id_mappings = struct.unpack('>H', blockBlob[cursor:cursor + 2])[0]
119 |             self.nameIdMappingsRead.extend(blockBlob[cursor:cursor + 2])
120 |             cursor+= 2
121 |             for i in range(0, self.num_name_id_mappings):
122 |                 self.nameIdMappingsRead.extend(blockBlob[cursor:cursor + 2])
123 |                 cursor+= 2
124 |                 self.nameIdMappingsRead.extend(blockBlob[cursor:cursor + 2])
125 |                 data_size = struct.unpack('>H', blockBlob[cursor:cursor + 2])[0]
126 |                 cursor+= 2
127 |                 self.nameIdMappingsRead.extend(blockBlob[cursor:cursor + data_size])
128 |                 cursor+= data_size
129 |             if self.length_of_timer != struct.unpack('B', blockBlob[cursor:cursor + 1])[0]:
130 |                 print("Length of timer not supported!")
131 |             cursor+= 1
132 |             self.num_of_timers = struct.unpack('>H', blockBlob[cursor:cursor + 2])[0]
133 |             self.timersRead.extend(blockBlob[cursor:cursor + 2])
134 |             cursor+= 2
135 |             for i in range(0, self.num_of_timers):
136 |                 self.timersRead.extend(blockBlob[cursor:cursor + 10])
137 |                 cursor+= 10
138 |             if self.length != cursor:
139 |                 print("Parsed length is wrong!")
140 |         #create blank block (parsed)
141 |         else:
142 |             self.flags = 0
143 |             for i in range(0, 4096):
144 |                 self.arrayParam0[i] = 1
145 |                 self.arrayParam1[i] = 1
146 |                 self.arrayParam2[i] = 1
147 |             self.metadata_count = 0
148 |             self.static_object_count = 0
149 |             self.objectsRead = struct.pack('>H', 0)
150 |             self.timestamp = 1458158584
151 |             num_name_id_mappings = 0
152 |             self.nameIdMappingsRead = struct.pack('>H', 0)
153 |             self.num_of_timers = 0
154 |             self.timersRead = struct.pack('>H', 0)
155 | 
156 | 
157 |     def selfCompile(self):
158 |         blockBlob = bytearray()
159 |         blockBlob.extend(struct.pack('B', self.version))
160 |         blockBlob.extend(struct.pack('B', self.flags))
161 |         blockBlob.extend(struct.pack('B', self.content_width))
162 |         blockBlob.extend(struct.pack('B', self.params_width))
163 |         if sys.version_info < (3, 0, 0):
164 |             blockBlob.extend(zlib.compress(buffer(self.nodeDataRead)))
165 |             blockBlob.extend(zlib.compress(buffer(self.nodeMetadataRead)))
166 |         else:
167 |             blockBlob.extend(zlib.compress(self.nodeDataRead))
168 |             blockBlob.extend(zlib.compress(self.nodeMetadataRead))
169 |         blockBlob.extend(struct.pack('B', self.static_object_version))
170 |         blockBlob.extend(self.objectsRead)
171 |         blockBlob.extend(struct.pack('>I', self.timestamp))
172 |         blockBlob.extend(struct.pack('B', self.name_id_mapping_version))
173 |         blockBlob.extend(self.nameIdMappingsRead)
174 |         blockBlob.extend(struct.pack('B', self.length_of_timer))
175 |         blockBlob.extend(self.timersRead)
176 |         return blockBlob
177 | 
178 |     def nodeDataParse(self):
179 |         if self.nodeDataRead == None or self.nodeDataRead == bytearray():
180 |             print("No node data!")
181 |             return
182 |         if len(self.nodeDataRead) != 4096 * 4:
183 |             print("Node data length is wrong!")
184 |         cursor = 0
185 |         for i in range(0, 4096):
186 |             self.arrayParam0[i] = struct.unpack('>H', self.nodeDataRead[cursor:cursor + 2])[0]
187 |             cursor+= 2
188 |         for i in range(0, 4096):
189 |             self.arrayParam1[i] = struct.unpack('B', self.nodeDataRead[cursor:cursor + 1])[0]
190 |             cursor+= 1
191 |         for i in range(0, 4096):
192 |             self.arrayParam2[i] = struct.unpack('B', self.nodeDataRead[cursor:cursor + 1])[0]
193 |             cursor+= 1
194 | 
195 |     def nodeDataCompile(self):
196 |         self.nodeDataRead = bytearray()
197 |         self.nodeDataRead.extend(struct.pack('>%sH' % 4096, *self.arrayParam0.values()))
198 |         self.nodeDataRead.extend(struct.pack('B' * 4096, *self.arrayParam1.values()))
199 |         self.nodeDataRead.extend(struct.pack('B' * 4096, *self.arrayParam2.values()))
200 | 
201 |     def nodeMetadataParse(self):
202 |         if self.nodeMetadataRead == None or self.nodeMetadataRead == bytearray():
203 |             print("No node metadata!")
204 |             return
205 |         length = len(self.nodeMetadataRead)
206 |         if length < 4:
207 |             self.metadata_count = 0
208 |             return
209 |         cursor = 0
210 |         block_metadata_version = struct.unpack('B', self.nodeMetadataRead[cursor:cursor + 1])[0]
211 |         if block_metadata_version > 2 or block_metadata_version < 1:
212 |             print("Unsuported metadata version! Trying anyway!")
213 |         cursor+= 1
214 |         self.metadata_count = struct.unpack('>H', self.nodeMetadataRead[cursor:cursor + 2])[0]
215 |         cursor+= 2
216 |         if block_metadata_version == 1:
217 |             for i in range(0, self.metadata_count):
218 |                 position = struct.unpack('>H', self.nodeMetadataRead[cursor:cursor + 2])[0]
219 |                 cursor+= 2
220 |                 num_vars = struct.unpack('>i', self.nodeMetadataRead[cursor:cursor + 4])[0]
221 |                 cursor+= 4
222 |                 self.arrayMetadataRead[position] = {}
223 |                 self.arrayMetadataReadPrivate[position] = {}
224 |                 for j in range(0, num_vars):
225 |                     key_len = struct.unpack('>H', self.nodeMetadataRead[cursor:cursor + 2])[0]
226 |                     if key_len == 0:
227 |                         cursor+= 1  # some bad guy added 1 empty bit without mentioning it in map specification???
228 |                         print("Extra empty bit in metadata! skipping!")
229 |                         key_len = struct.unpack('>H', self.nodeMetadataRead[cursor:cursor + 2])[0]
230 |                         cursor+= 2  # well, no point to make any better workaround until specification is corrected
231 |                     else:
232 |                         cursor+= 2
233 |                     key = self.nodeMetadataRead[cursor:cursor + key_len]
234 |                     cursor+= key_len
235 |                     val_len = struct.unpack('>i', self.nodeMetadataRead[cursor:cursor + 4])[0]
236 |                     cursor+= 4
237 |                     self.arrayMetadataRead[position][key] = self.nodeMetadataRead[cursor:cursor + val_len]
238 |                     cursor+= val_len
239 |                     # In old version all metadata was public
240 |                     self.arrayMetadataReadPrivate[position][key] = 0
241 |                 #just store inventory as text (bytearray!) for now
242 |                 inventory_len = 0
243 |                 inventory = self.nodeMetadataRead[cursor:].partition(b"EndInventory\n")
244 |                 inventory = inventory[0] + inventory[1]
245 |                 inventory_len = len(inventory)
246 |                 self.arrayMetadataReadInventory[position] = inventory
247 |                 cursor+= inventory_len
248 |         elif block_metadata_version >= 2:
249 |             for i in range(0, self.metadata_count):
250 |                 position = struct.unpack('>H', self.nodeMetadataRead[cursor:cursor + 2])[0]
251 |                 cursor+= 2
252 |                 num_vars = struct.unpack('>i', self.nodeMetadataRead[cursor:cursor + 4])[0]
253 |                 cursor+= 4
254 |                 self.arrayMetadataRead[position] = {}
255 |                 self.arrayMetadataReadPrivate[position] = {}
256 |                 for j in range(0, num_vars):
257 |                     key_len = struct.unpack('>H', self.nodeMetadataRead[cursor:cursor + 2])[0]
258 |                     cursor+= 2
259 |                     key = self.nodeMetadataRead[cursor:cursor + key_len]
260 |                     cursor+= key_len
261 |                     val_len = struct.unpack('>i', self.nodeMetadataRead[cursor:cursor + 4])[0]
262 |                     cursor+= 4
263 |                     self.arrayMetadataRead[position][key] = self.nodeMetadataRead[cursor:cursor + val_len]
264 |                     cursor+= val_len
265 |                     self.arrayMetadataReadPrivate[position][key] = struct.unpack('B', self.nodeMetadataRead[cursor:cursor + 1])[0]
266 |                     cursor+= 1
267 |                 #just store inventory as text (bytearray!) for now
268 |                 inventory_len = 0
269 |                 inventory = self.nodeMetadataRead[cursor:].partition(b"EndInventory\n")
270 |                 inventory = inventory[0] + inventory[1]
271 |                 inventory_len = len(inventory)
272 |                 self.arrayMetadataReadInventory[position] = inventory
273 |                 cursor+= inventory_len
274 |         if length != cursor:
275 |             print("Metadata length is wrong!")
276 | 
277 |     def nodeMetadataCompile(self):
278 |         self.nodeMetadataRead = bytearray()
279 |         self.nodeMetadataRead.extend(struct.pack('>B', self.metadata_version))
280 |         self.nodeMetadataRead.extend(struct.pack('>H', len(self.arrayMetadataRead)))
281 |         for position, Metadata in self.arrayMetadataRead.items():
282 |             #print("nokey??? "+type(position))
283 |             self.nodeMetadataRead.extend(struct.pack('>H', position))
284 |             self.nodeMetadataRead.extend(struct.pack('>i', len(Metadata)))
285 |             for key, val in Metadata.items():
286 |                 self.nodeMetadataRead.extend(struct.pack('>H', len(key)))
287 |                 self.nodeMetadataRead.extend(key)
288 |                 self.nodeMetadataRead.extend(struct.pack('>i', len(val)))
289 |                 self.nodeMetadataRead.extend(val)
290 |                 # So, save in new metadata format?
291 |                 self.nodeMetadataRead.append(self.arrayMetadataReadPrivate[position][key])
292 |                     
293 |             self.nodeMetadataRead.extend(self.arrayMetadataReadInventory[position])
294 | 
295 |     def objectsParse(self):
296 |         #TODO
297 |         return
298 | 
299 |     def nameIdMappingsParse(self):
300 |         length = len(self.nameIdMappingsRead)
301 |         cursor = 0
302 |         #length already was read
303 |         cursor = 2
304 |         for i in range(0, self.num_name_id_mappings):
305 |             mapping_id = struct.unpack('>H', self.nameIdMappingsRead[cursor:cursor + 2])[0]
306 |             cursor+= 2
307 |             size = struct.unpack('>H', self.nameIdMappingsRead[cursor:cursor + 2])[0]
308 |             cursor+= 2
309 |             self.nameIdMappings[mapping_id] = self.nameIdMappingsRead[cursor:cursor + size]
310 |             cursor+= size
311 |         if length != cursor:
312 |             print("Mapping data length is wrong!")
313 | 
314 |     def nameIdMappingsCompile(self):
315 |         self.num_name_id_mappings = len(self.nameIdMappings)
316 |         self.nameIdMappingsRead = bytearray()
317 |         self.nameIdMappingsRead.extend(struct.pack('>H', self.num_name_id_mappings))
318 |         for mapping_id, mapping in self.nameIdMappings.items():
319 |             self.nameIdMappingsRead.extend(struct.pack('>H', mapping_id))
320 |             self.nameIdMappingsRead.extend(struct.pack('>H', len(mapping)))
321 |             self.nameIdMappingsRead.extend(mapping)
322 | 
323 |     def timersParse(self):
324 |         length = len(self.timersRead)
325 |         cursor = 0
326 |         #num already was read
327 |         cursor = 2
328 |         for i in range(0, self.num_of_timers):
329 |             position = struct.unpack('>H', self.timersRead[cursor:cursor + 2])[0]
330 |             cursor+= 2
331 |             self.arrayTimerTimeout[position] = struct.unpack('>i', self.timersRead[cursor:cursor + 4])[0]
332 |             cursor+= 4
333 |             self.arrayTimerElapsed[position] = struct.unpack('>i', self.timersRead[cursor:cursor + 4])[0]
334 |             cursor+= 4
335 |         if length != cursor:
336 |             print("Timer data length wrong!")
337 | 
338 |     def timersCompile(self):
339 |         self.num_of_timers = len(self.arrayTimerTimeout)
340 |         self.timersRead = bytearray()
341 |         self.timersRead.extend(struct.pack('>H', self.num_of_timers))
342 |         for position, timeout in self.arrayTimerTimeout.items():
343 |             self.timersRead.extend(struct.pack('>H', position))
344 |             self.timersRead.extend(struct.pack('>i', timeout))
345 |             self.timersRead.extend(struct.pack('>i', self.arrayTimerElapsed[position]))
346 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 2.1, February 1999
  3 | 
  4 |  Copyright (C) 1991, 1999 Free Software Foundation, Inc.
  5 |  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 | (This is the first released version of the Lesser GPL.  It also counts
 10 |  as the successor of the GNU Library Public License, version 2, hence
 11 |  the version number 2.1.)
 12 | 
 13 |                             Preamble
 14 | 
 15 |   The licenses for most software are designed to take away your
 16 | freedom to share and change it.  By contrast, the GNU General Public
 17 | Licenses are intended to guarantee your freedom to share and change
 18 | free software--to make sure the software is free for all its users.
 19 | 
 20 |   This license, the Lesser General Public License, applies to some
 21 | specially designated software packages--typically libraries--of the
 22 | Free Software Foundation and other authors who decide to use it.  You
 23 | can use it too, but we suggest you first think carefully about whether
 24 | this license or the ordinary General Public License is the better
 25 | strategy to use in any particular case, based on the explanations below.
 26 | 
 27 |   When we speak of free software, we are referring to freedom of use,
 28 | not price.  Our General Public Licenses are designed to make sure that
 29 | you have the freedom to distribute copies of free software (and charge
 30 | for this service if you wish); that you receive source code or can get
 31 | it if you want it; that you can change the software and use pieces of
 32 | it in new free programs; and that you are informed that you can do
 33 | these things.
 34 | 
 35 |   To protect your rights, we need to make restrictions that forbid
 36 | distributors to deny you these rights or to ask you to surrender these
 37 | rights.  These restrictions translate to certain responsibilities for
 38 | you if you distribute copies of the library or if you modify it.
 39 | 
 40 |   For example, if you distribute copies of the library, whether gratis
 41 | or for a fee, you must give the recipients all the rights that we gave
 42 | you.  You must make sure that they, too, receive or can get the source
 43 | code.  If you link other code with the library, you must provide
 44 | complete object files to the recipients, so that they can relink them
 45 | with the library after making changes to the library and recompiling
 46 | it.  And you must show them these terms so they know their rights.
 47 | 
 48 |   We protect your rights with a two-step method: (1) we copyright the
 49 | library, and (2) we offer you this license, which gives you legal
 50 | permission to copy, distribute and/or modify the library.
 51 | 
 52 |   To protect each distributor, we want to make it very clear that
 53 | there is no warranty for the free library.  Also, if the library is
 54 | modified by someone else and passed on, the recipients should know
 55 | that what they have is not the original version, so that the original
 56 | author's reputation will not be affected by problems that might be
 57 | introduced by others.
 58 | 
 59 |   Finally, software patents pose a constant threat to the existence of
 60 | any free program.  We wish to make sure that a company cannot
 61 | effectively restrict the users of a free program by obtaining a
 62 | restrictive license from a patent holder.  Therefore, we insist that
 63 | any patent license obtained for a version of the library must be
 64 | consistent with the full freedom of use specified in this license.
 65 | 
 66 |   Most GNU software, including some libraries, is covered by the
 67 | ordinary GNU General Public License.  This license, the GNU Lesser
 68 | General Public License, applies to certain designated libraries, and
 69 | is quite different from the ordinary General Public License.  We use
 70 | this license for certain libraries in order to permit linking those
 71 | libraries into non-free programs.
 72 | 
 73 |   When a program is linked with a library, whether statically or using
 74 | a shared library, the combination of the two is legally speaking a
 75 | combined work, a derivative of the original library.  The ordinary
 76 | General Public License therefore permits such linking only if the
 77 | entire combination fits its criteria of freedom.  The Lesser General
 78 | Public License permits more lax criteria for linking other code with
 79 | the library.
 80 | 
 81 |   We call this license the "Lesser" General Public License because it
 82 | does Less to protect the user's freedom than the ordinary General
 83 | Public License.  It also provides other free software developers Less
 84 | of an advantage over competing non-free programs.  These disadvantages
 85 | are the reason we use the ordinary General Public License for many
 86 | libraries.  However, the Lesser license provides advantages in certain
 87 | special circumstances.
 88 | 
 89 |   For example, on rare occasions, there may be a special need to
 90 | encourage the widest possible use of a certain library, so that it becomes
 91 | a de-facto standard.  To achieve this, non-free programs must be
 92 | allowed to use the library.  A more frequent case is that a free
 93 | library does the same job as widely used non-free libraries.  In this
 94 | case, there is little to gain by limiting the free library to free
 95 | software only, so we use the Lesser General Public License.
 96 | 
 97 |   In other cases, permission to use a particular library in non-free
 98 | programs enables a greater number of people to use a large body of
 99 | free software.  For example, permission to use the GNU C Library in
100 | non-free programs enables many more people to use the whole GNU
101 | operating system, as well as its variant, the GNU/Linux operating
102 | system.
103 | 
104 |   Although the Lesser General Public License is Less protective of the
105 | users' freedom, it does ensure that the user of a program that is
106 | linked with the Library has the freedom and the wherewithal to run
107 | that program using a modified version of the Library.
108 | 
109 |   The precise terms and conditions for copying, distribution and
110 | modification follow.  Pay close attention to the difference between a
111 | "work based on the library" and a "work that uses the library".  The
112 | former contains code derived from the library, whereas the latter must
113 | be combined with the library in order to run.
114 | 
115 |                   GNU LESSER GENERAL PUBLIC LICENSE
116 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
117 | 
118 |   0. This License Agreement applies to any software library or other
119 | program which contains a notice placed by the copyright holder or
120 | other authorized party saying it may be distributed under the terms of
121 | this Lesser General Public License (also called "this License").
122 | Each licensee is addressed as "you".
123 | 
124 |   A "library" means a collection of software functions and/or data
125 | prepared so as to be conveniently linked with application programs
126 | (which use some of those functions and data) to form executables.
127 | 
128 |   The "Library", below, refers to any such software library or work
129 | which has been distributed under these terms.  A "work based on the
130 | Library" means either the Library or any derivative work under
131 | copyright law: that is to say, a work containing the Library or a
132 | portion of it, either verbatim or with modifications and/or translated
133 | straightforwardly into another language.  (Hereinafter, translation is
134 | included without limitation in the term "modification".)
135 | 
136 |   "Source code" for a work means the preferred form of the work for
137 | making modifications to it.  For a library, complete source code means
138 | all the source code for all modules it contains, plus any associated
139 | interface definition files, plus the scripts used to control compilation
140 | and installation of the library.
141 | 
142 |   Activities other than copying, distribution and modification are not
143 | covered by this License; they are outside its scope.  The act of
144 | running a program using the Library is not restricted, and output from
145 | such a program is covered only if its contents constitute a work based
146 | on the Library (independent of the use of the Library in a tool for
147 | writing it).  Whether that is true depends on what the Library does
148 | and what the program that uses the Library does.
149 | 
150 |   1. You may copy and distribute verbatim copies of the Library's
151 | complete source code as you receive it, in any medium, provided that
152 | you conspicuously and appropriately publish on each copy an
153 | appropriate copyright notice and disclaimer of warranty; keep intact
154 | all the notices that refer to this License and to the absence of any
155 | warranty; and distribute a copy of this License along with the
156 | Library.
157 | 
158 |   You may charge a fee for the physical act of transferring a copy,
159 | and you may at your option offer warranty protection in exchange for a
160 | fee.
161 | 
162 |   2. You may modify your copy or copies of the Library or any portion
163 | of it, thus forming a work based on the Library, and copy and
164 | distribute such modifications or work under the terms of Section 1
165 | above, provided that you also meet all of these conditions:
166 | 
167 |     a) The modified work must itself be a software library.
168 | 
169 |     b) You must cause the files modified to carry prominent notices
170 |     stating that you changed the files and the date of any change.
171 | 
172 |     c) You must cause the whole of the work to be licensed at no
173 |     charge to all third parties under the terms of this License.
174 | 
175 |     d) If a facility in the modified Library refers to a function or a
176 |     table of data to be supplied by an application program that uses
177 |     the facility, other than as an argument passed when the facility
178 |     is invoked, then you must make a good faith effort to ensure that,
179 |     in the event an application does not supply such function or
180 |     table, the facility still operates, and performs whatever part of
181 |     its purpose remains meaningful.
182 | 
183 |     (For example, a function in a library to compute square roots has
184 |     a purpose that is entirely well-defined independent of the
185 |     application.  Therefore, Subsection 2d requires that any
186 |     application-supplied function or table used by this function must
187 |     be optional: if the application does not supply it, the square
188 |     root function must still compute square roots.)
189 | 
190 | These requirements apply to the modified work as a whole.  If
191 | identifiable sections of that work are not derived from the Library,
192 | and can be reasonably considered independent and separate works in
193 | themselves, then this License, and its terms, do not apply to those
194 | sections when you distribute them as separate works.  But when you
195 | distribute the same sections as part of a whole which is a work based
196 | on the Library, the distribution of the whole must be on the terms of
197 | this License, whose permissions for other licensees extend to the
198 | entire whole, and thus to each and every part regardless of who wrote
199 | it.
200 | 
201 | Thus, it is not the intent of this section to claim rights or contest
202 | your rights to work written entirely by you; rather, the intent is to
203 | exercise the right to control the distribution of derivative or
204 | collective works based on the Library.
205 | 
206 | In addition, mere aggregation of another work not based on the Library
207 | with the Library (or with a work based on the Library) on a volume of
208 | a storage or distribution medium does not bring the other work under
209 | the scope of this License.
210 | 
211 |   3. You may opt to apply the terms of the ordinary GNU General Public
212 | License instead of this License to a given copy of the Library.  To do
213 | this, you must alter all the notices that refer to this License, so
214 | that they refer to the ordinary GNU General Public License, version 2,
215 | instead of to this License.  (If a newer version than version 2 of the
216 | ordinary GNU General Public License has appeared, then you can specify
217 | that version instead if you wish.)  Do not make any other change in
218 | these notices.
219 | 
220 |   Once this change is made in a given copy, it is irreversible for
221 | that copy, so the ordinary GNU General Public License applies to all
222 | subsequent copies and derivative works made from that copy.
223 | 
224 |   This option is useful when you wish to copy part of the code of
225 | the Library into a program that is not a library.
226 | 
227 |   4. You may copy and distribute the Library (or a portion or
228 | derivative of it, under Section 2) in object code or executable form
229 | under the terms of Sections 1 and 2 above provided that you accompany
230 | it with the complete corresponding machine-readable source code, which
231 | must be distributed under the terms of Sections 1 and 2 above on a
232 | medium customarily used for software interchange.
233 | 
234 |   If distribution of object code is made by offering access to copy
235 | from a designated place, then offering equivalent access to copy the
236 | source code from the same place satisfies the requirement to
237 | distribute the source code, even though third parties are not
238 | compelled to copy the source along with the object code.
239 | 
240 |   5. A program that contains no derivative of any portion of the
241 | Library, but is designed to work with the Library by being compiled or
242 | linked with it, is called a "work that uses the Library".  Such a
243 | work, in isolation, is not a derivative work of the Library, and
244 | therefore falls outside the scope of this License.
245 | 
246 |   However, linking a "work that uses the Library" with the Library
247 | creates an executable that is a derivative of the Library (because it
248 | contains portions of the Library), rather than a "work that uses the
249 | library".  The executable is therefore covered by this License.
250 | Section 6 states terms for distribution of such executables.
251 | 
252 |   When a "work that uses the Library" uses material from a header file
253 | that is part of the Library, the object code for the work may be a
254 | derivative work of the Library even though the source code is not.
255 | Whether this is true is especially significant if the work can be
256 | linked without the Library, or if the work is itself a library.  The
257 | threshold for this to be true is not precisely defined by law.
258 | 
259 |   If such an object file uses only numerical parameters, data
260 | structure layouts and accessors, and small macros and small inline
261 | functions (ten lines or less in length), then the use of the object
262 | file is unrestricted, regardless of whether it is legally a derivative
263 | work.  (Executables containing this object code plus portions of the
264 | Library will still fall under Section 6.)
265 | 
266 |   Otherwise, if the work is a derivative of the Library, you may
267 | distribute the object code for the work under the terms of Section 6.
268 | Any executables containing that work also fall under Section 6,
269 | whether or not they are linked directly with the Library itself.
270 | 
271 |   6. As an exception to the Sections above, you may also combine or
272 | link a "work that uses the Library" with the Library to produce a
273 | work containing portions of the Library, and distribute that work
274 | under terms of your choice, provided that the terms permit
275 | modification of the work for the customer's own use and reverse
276 | engineering for debugging such modifications.
277 | 
278 |   You must give prominent notice with each copy of the work that the
279 | Library is used in it and that the Library and its use are covered by
280 | this License.  You must supply a copy of this License.  If the work
281 | during execution displays copyright notices, you must include the
282 | copyright notice for the Library among them, as well as a reference
283 | directing the user to the copy of this License.  Also, you must do one
284 | of these things:
285 | 
286 |     a) Accompany the work with the complete corresponding
287 |     machine-readable source code for the Library including whatever
288 |     changes were used in the work (which must be distributed under
289 |     Sections 1 and 2 above); and, if the work is an executable linked
290 |     with the Library, with the complete machine-readable "work that
291 |     uses the Library", as object code and/or source code, so that the
292 |     user can modify the Library and then relink to produce a modified
293 |     executable containing the modified Library.  (It is understood
294 |     that the user who changes the contents of definitions files in the
295 |     Library will not necessarily be able to recompile the application
296 |     to use the modified definitions.)
297 | 
298 |     b) Use a suitable shared library mechanism for linking with the
299 |     Library.  A suitable mechanism is one that (1) uses at run time a
300 |     copy of the library already present on the user's computer system,
301 |     rather than copying library functions into the executable, and (2)
302 |     will operate properly with a modified version of the library, if
303 |     the user installs one, as long as the modified version is
304 |     interface-compatible with the version that the work was made with.
305 | 
306 |     c) Accompany the work with a written offer, valid for at
307 |     least three years, to give the same user the materials
308 |     specified in Subsection 6a, above, for a charge no more
309 |     than the cost of performing this distribution.
310 | 
311 |     d) If distribution of the work is made by offering access to copy
312 |     from a designated place, offer equivalent access to copy the above
313 |     specified materials from the same place.
314 | 
315 |     e) Verify that the user has already received a copy of these
316 |     materials or that you have already sent this user a copy.
317 | 
318 |   For an executable, the required form of the "work that uses the
319 | Library" must include any data and utility programs needed for
320 | reproducing the executable from it.  However, as a special exception,
321 | the materials to be distributed need not include anything that is
322 | normally distributed (in either source or binary form) with the major
323 | components (compiler, kernel, and so on) of the operating system on
324 | which the executable runs, unless that component itself accompanies
325 | the executable.
326 | 
327 |   It may happen that this requirement contradicts the license
328 | restrictions of other proprietary libraries that do not normally
329 | accompany the operating system.  Such a contradiction means you cannot
330 | use both them and the Library together in an executable that you
331 | distribute.
332 | 
333 |   7. You may place library facilities that are a work based on the
334 | Library side-by-side in a single library together with other library
335 | facilities not covered by this License, and distribute such a combined
336 | library, provided that the separate distribution of the work based on
337 | the Library and of the other library facilities is otherwise
338 | permitted, and provided that you do these two things:
339 | 
340 |     a) Accompany the combined library with a copy of the same work
341 |     based on the Library, uncombined with any other library
342 |     facilities.  This must be distributed under the terms of the
343 |     Sections above.
344 | 
345 |     b) Give prominent notice with the combined library of the fact
346 |     that part of it is a work based on the Library, and explaining
347 |     where to find the accompanying uncombined form of the same work.
348 | 
349 |   8. You may not copy, modify, sublicense, link with, or distribute
350 | the Library except as expressly provided under this License.  Any
351 | attempt otherwise to copy, modify, sublicense, link with, or
352 | distribute the Library is void, and will automatically terminate your
353 | rights under this License.  However, parties who have received copies,
354 | or rights, from you under this License will not have their licenses
355 | terminated so long as such parties remain in full compliance.
356 | 
357 |   9. You are not required to accept this License, since you have not
358 | signed it.  However, nothing else grants you permission to modify or
359 | distribute the Library or its derivative works.  These actions are
360 | prohibited by law if you do not accept this License.  Therefore, by
361 | modifying or distributing the Library (or any work based on the
362 | Library), you indicate your acceptance of this License to do so, and
363 | all its terms and conditions for copying, distributing or modifying
364 | the Library or works based on it.
365 | 
366 |   10. Each time you redistribute the Library (or any work based on the
367 | Library), the recipient automatically receives a license from the
368 | original licensor to copy, distribute, link with or modify the Library
369 | subject to these terms and conditions.  You may not impose any further
370 | restrictions on the recipients' exercise of the rights granted herein.
371 | You are not responsible for enforcing compliance by third parties with
372 | this License.
373 | 
374 |   11. If, as a consequence of a court judgment or allegation of patent
375 | infringement or for any other reason (not limited to patent issues),
376 | conditions are imposed on you (whether by court order, agreement or
377 | otherwise) that contradict the conditions of this License, they do not
378 | excuse you from the conditions of this License.  If you cannot
379 | distribute so as to satisfy simultaneously your obligations under this
380 | License and any other pertinent obligations, then as a consequence you
381 | may not distribute the Library at all.  For example, if a patent
382 | license would not permit royalty-free redistribution of the Library by
383 | all those who receive copies directly or indirectly through you, then
384 | the only way you could satisfy both it and this License would be to
385 | refrain entirely from distribution of the Library.
386 | 
387 | If any portion of this section is held invalid or unenforceable under any
388 | particular circumstance, the balance of the section is intended to apply,
389 | and the section as a whole is intended to apply in other circumstances.
390 | 
391 | It is not the purpose of this section to induce you to infringe any
392 | patents or other property right claims or to contest validity of any
393 | such claims; this section has the sole purpose of protecting the
394 | integrity of the free software distribution system which is
395 | implemented by public license practices.  Many people have made
396 | generous contributions to the wide range of software distributed
397 | through that system in reliance on consistent application of that
398 | system; it is up to the author/donor to decide if he or she is willing
399 | to distribute software through any other system and a licensee cannot
400 | impose that choice.
401 | 
402 | This section is intended to make thoroughly clear what is believed to
403 | be a consequence of the rest of this License.
404 | 
405 |   12. If the distribution and/or use of the Library is restricted in
406 | certain countries either by patents or by copyrighted interfaces, the
407 | original copyright holder who places the Library under this License may add
408 | an explicit geographical distribution limitation excluding those countries,
409 | so that distribution is permitted only in or among countries not thus
410 | excluded.  In such case, this License incorporates the limitation as if
411 | written in the body of this License.
412 | 
413 |   13. The Free Software Foundation may publish revised and/or new
414 | versions of the Lesser General Public License from time to time.
415 | Such new versions will be similar in spirit to the present version,
416 | but may differ in detail to address new problems or concerns.
417 | 
418 | Each version is given a distinguishing version number.  If the Library
419 | specifies a version number of this License which applies to it and
420 | "any later version", you have the option of following the terms and
421 | conditions either of that version or of any later version published by
422 | the Free Software Foundation.  If the Library does not specify a
423 | license version number, you may choose any version ever published by
424 | the Free Software Foundation.
425 | 
426 |   14. If you wish to incorporate parts of the Library into other free
427 | programs whose distribution conditions are incompatible with these,
428 | write to the author to ask for permission.  For software which is
429 | copyrighted by the Free Software Foundation, write to the Free
430 | Software Foundation; we sometimes make exceptions for this.  Our
431 | decision will be guided by the two goals of preserving the free status
432 | of all derivatives of our free software and of promoting the sharing
433 | and reuse of software generally.
434 | 
435 |                             NO WARRANTY
436 | 
437 |   15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
438 | WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
439 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
440 | OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
441 | KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
442 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
443 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
444 | LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
445 | THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
446 | 
447 |   16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
448 | WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
449 | AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
450 | FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
451 | CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
452 | LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
453 | RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
454 | FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
455 | SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
456 | DAMAGES.
457 | 
458 |                      END OF TERMS AND CONDITIONS
459 | 
460 |            How to Apply These Terms to Your New Libraries
461 | 
462 |   If you develop a new library, and you want it to be of the greatest
463 | possible use to the public, we recommend making it free software that
464 | everyone can redistribute and change.  You can do so by permitting
465 | redistribution under these terms (or, alternatively, under the terms of the
466 | ordinary General Public License).
467 | 
468 |   To apply these terms, attach the following notices to the library.  It is
469 | safest to attach them to the start of each source file to most effectively
470 | convey the exclusion of warranty; and each file should have at least the
471 | "copyright" line and a pointer to where the full notice is found.
472 | 
473 |     {description}
474 |     Copyright (C) {year} {fullname}
475 | 
476 |     This library is free software; you can redistribute it and/or
477 |     modify it under the terms of the GNU Lesser General Public
478 |     License as published by the Free Software Foundation; either
479 |     version 2.1 of the License, or (at your option) any later version.
480 | 
481 |     This library is distributed in the hope that it will be useful,
482 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
483 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
484 |     Lesser General Public License for more details.
485 | 
486 |     You should have received a copy of the GNU Lesser General Public
487 |     License along with this library; if not, write to the Free Software
488 |     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
489 |     USA
490 | 
491 | Also add information on how to contact you by electronic and paper mail.
492 | 
493 | You should also get your employer (if you work as a programmer) or your
494 | school, if any, to sign a "copyright disclaimer" for the library, if
495 | necessary.  Here is a sample; alter the names:
496 | 
497 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the
498 |   library `Frob' (a library for tweaking knobs) written by James Random
499 |   Hacker.
500 | 
501 |   {signature of Ty Coon}, 1 April 1990
502 |   Ty Coon, President of Vice
503 | 
504 | That's all there is to it!
505 | 
506 | 


--------------------------------------------------------------------------------