src/irrlichttypes.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

/*
Minetest-c55
Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#ifndef IRRLICHTTYPES_HEADER
#define IRRLICHTTYPES_HEADER

#include <irrTypes.h>
#include <vector2d.h>
#include <vector3d.h>
#include <irrMap.h>
#include <irrList.h>
#include <irrArray.h>
#include <aabbox3d.h>
#include <SColor.h>
using namespace irr;
typedef core::vector3df v3f;
typedef core::vector3d<s16> v3s16;
typedef core::vector3d<s32> v3s32;

typedef core::vector2d<f32> v2f;
typedef core::vector2d<s16> v2s16;
typedef core::vector2d<s32> v2s32;
typedef core::vector2d<u32> v2u32;
typedef core::vector2d<f32> v2f32;

typedef core::aabbox3d<f32> aabb3f;

#ifdef _MSC_VER
	// Windows
	typedef unsigned long long u64;
#else
	// Posix
	#include <stdint.h>
	typedef uint64_t u64;
	//typedef unsigned long long u64;
#endif

#endif
#!/usr/bin/python2

# This is an example script that generates some valid map data.

import struct
import random
import os
import sys
import zlib
import array
from pnoise import pnoise

# Old directory format:
# world/sectors/XXXXZZZZ/YYYY
# XXXX,YYYY,ZZZZ = coordinates in hexadecimal
# fffe = -2
# ffff = -1
# 0000 =  0
# 0001 =  1
# 
# New directory format:
# world/sectors2/XXX/ZZZ/YYYY
# XXX,YYYY,ZZZ = coordinates in hexadecimal
# fffe = -2
# ffff = -1
# 0000 =  0
# 0001 =  1
# ffe = -2
# fff = -1
# 000 =  0
# 001 =  1
#
# For more proper file format documentation, refer to mapformat.txt
# For node type documentation, refer to mapnode.h
# NodeMetadata documentation is not complete, refer to nodemeta.cpp
#

# Seed for generating terrain
SEED = 0

# 0=old, 1=new
SECTOR_DIR_FORMAT = 1

mapdir = "../world"

def to4h(i):
	s = "";
	s += '{0:1x}'.format((i>>12) & 0x000f)
	s += '{0:1x}'.format((i>>8) & 0x000f)
	s += '{0:1x}'.format((i>>4) & 0x000f)
	s += '{0:1x}'.format((i>>0) & 0x000f)
	return s

def to3h(i):
	s = "";
	s += '{0:1x}'.format((i>>8) & 0x000f)
	s += '{0:1x}'.format((i>>4) & 0x000f)
	s += '{0:1x}'.format((i>>0) & 0x000f)
	return s

def get_sector_dir(px, pz):
	global SECTOR_DIR_FORMAT
	if SECTOR_DIR_FORMAT == 0:
		return "/sectors/"+to4h(px)+to4h(pz)
	elif SECTOR_DIR_FORMAT == 1:
		return "/sectors2/"+to3h(px)+"/"+to3h(pz)
	else:
		assert(0)

def getrand_air_stone():
	i = random.randrange(0,2)
	if i==0:
		return 0
	return 254

# 3-dimensional vector (position)
class v3:
	def __init__(self, x=0, y=0, z=0):
		self.X = x
		self.Y = y
		self.Z = z

class NodeMeta:
	def __init__(self, type_id, data):
		self.type_id = type_id
		self.data = data

class StaticObject:
	def __init__(self):
		self.type_id = 0
		self.data = ""

def ser_u16(i):
	return chr((i>>8)&0xff) + chr((i>>0)&0xff)
def ser_u32(i):
	return (chr((i>>24)&0xff) + chr((i>>16)&0xff)
			+ chr((i>>8)&0xff) + chr((i>>0)&0xff))

# A 16x16x16 chunk of map
class MapBlock:
	def __init__(self):
		self.content = array.array('B')
		self.param1 = array.array('B')
		self.param2 = array.array('B')
		for i in range(16*16*16):
			# Initialize to air
			self.content.append(254)
			# Full light on sunlight, none when no sunlight
			self.param1.append(15)
			# No additional parameters
			self.param2.append(0)
		
		# key = v3 pos
		# value = NodeMeta
		self.nodemeta = {}
	
		# key = v3 pos
		# value = StaticObject
		self.static_objects = {}
	
	def set_content(self, v3, b):
		self.content[v3.Z*16*16+v3.Y*16+v3.X] = b
	def set_param1(self, v3, b):
		self.param1[v3.Z*16*16+v3.Y*16+v3.X] = b
	def set_param2(self, v3, b):
		self.param2[v3.Z*16*16+v3.Y*16+v3.X] = b
	
	# Get data for serialization. Returns a string.
	def serialize_data(self):
		s = ""
		for i in range(16*16*16):
			s += chr(self.content[i])
		for i in range(16*16*16):
			s += chr(self.param1[i])
		for i in range(16*16*16):
			s += chr(self.param2[i])
		return s

	def serialize_nodemeta(self):
		s = ""
		s += ser_u16(1)
		s += ser_u16(len(self.nodemeta))
		for pos, meta in self.nodemeta.items():
			pos_i = pos.Z*16*16 + pos.Y*16 + pos.X
			s += ser_u16(pos_i)
			s += ser_u16(meta.type_id)
			s += ser_u16(len(meta.data))
			s += meta.data
		return s

	def serialize_staticobj(self):
		s = ""
		s += chr(0)
		s += ser_u16(len(self.static_objects))
		for pos, obj in self.static_objects.items():
			pos_i = pos.Z*16*16 + pos.Y*16 + pos.X
			s += ser_s32(pos.X*1000)
			s += ser_s32(pos.Y*1000)
			s += ser_s32(pos.Z*1000)
			s += ser_u16(obj.type_id)
			s += ser_u16(len(obj.data))
			s += obj.data
		return s

def writeblock(mapdir, px,py,pz, block):

	sectordir = mapdir + get_sector_dir(px, pz);
	
	try:
		os.makedirs(sectordir)
	except OSError:
		pass
	
	path = sectordir+"/"+to4h(py)

	print("writing block file "+path)

	f = open(sectordir+"/"+to4h(py), "wb")

	if f == None:
		return

	# version
	version = 17
	f.write(struct.pack('B', version))

	# flags
	# 0x01=is_undg, 0x02=dn_diff, 0x04=lighting_expired
	flags = 0 + 0x02 + 0x04
	f.write(struct.pack('B', flags))
	
	# data
	c_obj = zlib.compressobj()
	c_obj.compress(block.serialize_data())
	f.write(struct.pack('BB', 0x78, 0x9c)) # zlib magic number
	f.write(c_obj.flush())

	# node metadata
	c_obj = zlib.compressobj()
	c_obj.compress(block.serialize_nodemeta())
	f.write(struct.pack('BB', 0x78, 0x9c)) # zlib magic number
	f.write(c_obj.flush())

	# mapblockobject count
	f.write(ser_u16(0))

	# static objects
	f.write(block.serialize_staticobj())

	# timestamp
	f.write(ser_u32(0xffffffff))

	f.close()

for z0 in range(-1,3):
	for x0 in range(-1,3):
		for y0 in range(-1,3):
			print("generating block "+str(x0)+","+str(y0)+","+str(z0))
			#v3 blockp = v3(x0,y0,z0)
			
			# Create a MapBlock
			block = MapBlock()
			
			# Generate stuff in it
			for z in range(0,16):
				for x in range(0,16):
					h = 20.0*pnoise((x0*16+x)/100.,(z0*16+z)/100.,SEED+0)
					h += 5.0*pnoise((x0*16+x)/25.,(z0*16+z)/25.,SEED+0)
					if pnoise((x0*16+x)/25.,(z0*16+z)/25.,SEED+92412) > 0.05:
						h += 10
					#print("r="+str(r))
					# This enables comparison by ==
					h = int(h)
					for y in range(0,16):
						p = v3(x,y,z)
						b = 254
						y1 = y0*16+y
						if y1 <= h-3:
							b = 0 #stone
						elif y1 <= h and y1 <= 0:
							b = 8 #mud