Esempio n. 1
0
def read_art(art_name):
    check_ext(art_name, '.ART')

    verbose = 0

    parts = read_madspack(art_name)

    save_madspack(art_name, parts)

    # parts[0] -- dimensions + palette
    # parts[1] -- image data

    # header
    h = Header()
    h.width = read_uint16(parts[0])
    h.height = read_uint16(parts[0])

    save_header(art_name, h)

    # palette
    pal = read_palette_rex(parts[0])

    export_palette(pal, art_name)

    # image -- read indexed image
    img = Image.new('P', (h.width, h.height))
    attach_palette(img, pal)
    pix = img.load()
    for j in range(h.height):
        for i in range(h.width):
            ind = read_uint8(parts[1])
            pix[i, j] = ind

    save_image(art_name, img)
Esempio n. 2
0
def read_pik(pik_name):
	check_ext(pik_name, '.PIK')
	
	parts = read_madspack(pik_name)
	assert len(parts) >= 3
	save_madspack(pik_name, parts)
	
	h = read_pik_header(parts[0])	
	pal = read_palette_col(parts[2])
	img = read_pik_image(parts[1], h, pal)
		
	save_image(pik_name, img)
Esempio n. 3
0
def read_cnv(cnv_name):
    check_ext(cnv_name, '.CNV')

    parts = read_madspack(cnv_name)
    assert len(parts) == 7
    save_madspack(cnv_name, parts)

    h = read_cnv_header(cnv_name)
    save_cnv_header(cnv_name, h)

    msgs = read_cnv_messages(cnv_name, h.msg_count)
    save_cnv_messages(cnv_name, msgs)
Esempio n. 4
0
def read_aa(aa_name):
	assert aa_name.endswith('.AA')
	
	parts = read_madspack(aa_name)
	assert len(parts) >= 1
	save_madspack(aa_name, parts)
	
	h = read_aa_header(aa_name)
	save_aa_header(aa_name, h)

	if len(parts) > 1:
		msgs = read_aa_messages(aa_name, h.msg_count)
		save_aa_messages(aa_name, msgs)
Esempio n. 5
0
def read_aa(aa_name):
    check_ext(aa_name, '.AA')

    parts = read_madspack(aa_name)
    assert len(parts) >= 1
    save_madspack(aa_name, parts)

    h = read_aa_header(aa_name)
    save_aa_header(aa_name, h)

    if len(parts) > 1:
        msgs = read_aa_messages(aa_name, h.msg_count)
        save_aa_messages(aa_name, msgs)
Esempio n. 6
0
def read_ss(f, ss_name):
	
	"""
	SS file is a MADSPACK file with 4 parts:

	* part 0
		header
			mode -- part3 encoding
				0 -- linemode
				1 -- FAB and linemode
			count -- number of sprites
			size -- size of part3
		
		
	* part 1
		is composed of tile_headers, there can be many tiles in one file 
		ntiles = len(part2) / 0x00000010

	* part 2
		palette
		
	* part 3	
		image data, may contain many tiles


	Tiles are compressed with linemode|command encoding. Colors are stored
	in indexed mode. Each pixel line begins with linemode. 

	Linemodes/commands:
	lm  cm            description
	------------------------------------------------------------------------
	255               fill rest of the line with bg color and read linemode

	252               stop

	254               pixel mode
	254 255           fill rest of the line with bg color and read linemode
	254 254 len col   produce len * [col] pixels, read command
	254 col           produce [col] pixel, read command

	253               multiple pixels mode
	253 255           fill rest of the line with bg color and read linemode
	253 len col       produce len * [col] pixels, read command

	"""
	verbose = 0
	
	
	parts = read_madspack(f)
	
	save_madspack(ss_name, parts)
		
	ss_header = read_ss_header(parts[0])
	
	# save header
	save_ss_header(ss_name, ss_header)
	
	if verbose:
		print("nsprites=", ss_header.nsprites)
	
		
	sprite_headers = []
	
	for i in range(ss_header.nsprites):
		sprite_header = read_sprite_header(parts[1])
		sprite_headers.append(sprite_header)
		
		# save header
		sprite_name = '{}.{:03}'.format(ss_name, i)
		save_sprite_header(sprite_name, sprite_header)
		
	
	
	pal = read_pallete(parts[2])
	
	sprites = []
	for i, sprite_header in enumerate(sprite_headers):
		sprite = read_sprite(sprite_header, parts[3], pal, mode = ss_header.mode)
		sprites.append(sprite)
		
		# save sprite
		sprite_name = '{}.{:03}'.format(ss_name, i)
		save_sprite(sprite_name, sprite)
	
	return sprites
Esempio n. 7
0
def read_ff(ff_name):
	"""
	FF file: 1 part MADSPACK
	header
		max_height: 1 byte
		max_width: 1 byte
		glyphs widths: 128 bytes
		glyphs offsets: 2 x 128 byte
	glyphs
		...
	"""
	check_ext(ff_name, '.FF')

	parts = read_madspack(ff_name)
	save_madspack(ff_name, parts)
	f = parts[0]

	# Header
	h = Record()
	h.max_height = read_uint8(f)
	h.max_width = read_uint8(f)

	# glyphs width in pixels
	# glyph height is max_height
	# null has width 0
	h.char_widths = [0] + [read_uint8(f) for _ in range(127)]

	read_uint8(f)  # alignment to 128



	# space occupied by glyph is
	# math.ceil((glyph_width * max_height) / 4.0)   # or is is rounded per line ?

	# offsets inside section
	h.char_offsets = [2 + 128 + 256] + [read_uint16(f) for _ in range(127)]

	read_uint16(f)  # alignment

	assert f.tell() == 2 + 128 + 256


	save_ff_header(ff_name, h)

	# Glyphs

	f.seek(h.char_offsets[1])
	for ch in range(1,128):

		width = h.char_widths[ch]
		height = h.max_height
		offset = h.char_offsets[ch]

		assert f.tell() == offset

		if width == 0:
			continue

		img = Image.new("P", (width,height))
		attach_palette(img, pal)

		y = 0
		while y < height:
			x = 0
			while 1:
				byte = read_uint8(f)

				col = (byte & 0b11000000) >> 6
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break

				col = (byte & 0b00110000) >> 4
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break

				col = (byte & 0b00001100) >> 2
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break

				col = (byte & 0b00000011) >> 0
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break

			y += 1

		oname = "{}.{:03}.png".format(ff_name, ch)
		img.save(oname)
		output(oname)
Esempio n. 8
0
def read_ff(ff_name):
	pal = [(0,0,0,0),(0,255,0,255),(0,127,0,255),(0,63,0,255)]
	
	parts = read_madspack(ff_name)
	save_madspack(ff_name, parts)
	
	f = parts[0]
	f.seek(0)
	
	h = Record()
	
	h.max_height = read_uint8(f)
	h.max_width = read_uint8(f)

	# glyphs width in pixels
	# glyph height is max_height
	# null has width 0
	h.char_widths = [0] + read_bytes(f, 127)
	
	
	
	read_uint8(f)  # alignment to 128
	
	# space occupied by glyph is 
	# math.ceil((glyph_width * max_height) / 4.0)   # or is is rounded per line ?
	
	
	# offsets inside section
	h.char_offsets = [2 + 128 + 256] + [read_uint16(f) for _ in range(127)]	
	
	read_uint16(f)  # alignment
	
	assert f.tell() == 2 + 128 + 256
	
	save_ff_header(ff_name, h)	

	# load glyphs	
	for ch in range(1,128):
		
		width = h.char_widths[ch]
		height = h.max_height
		
		if width == 0:
			continue
		
		img = Image.new("RGBA", (width,height))
		
		y = 0
		while y < height:
			x = 0
			while 1:				
				byte = read_uint8(f)
				
				col = pal[(byte & 0b11000000) >> 6]
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break
				
				col = pal[(byte & 0b00110000) >> 4]
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break
				
				col = pal[(byte & 0b00001100) >> 2]
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break
				
				col = pal[(byte & 0b00000011) >> 0]
				img.putpixel((x,y), col)
				x += 1
				if x == width:
					break
					
				
			y += 1

		oname = "{}.{:03}.png".format(ff_name, ch)
		img.save(oname)
		output(oname)
Esempio n. 9
0
def call(fmt,cmd,path):
	
	odd = os.getcwd()
	
	ndd,arg1 = os.path.split(path)
	
	
	common.g_curr_dir = ndd
	
	if ndd:
		os.chdir(ndd)
		
	try:
		
		if cmd not in ['pack','unpack']:
			print('invalid command; use "pack" or "unpack"')
			sys.exit(1)
		
		
		if fmt == 'dat':
			
			if cmd == 'unpack':
				read_messagesdat(open(arg1, 'rb'), arg1)
			elif cmd == 'pack':
				write_messagesdat(open(arg1, 'wb'), arg1)
			
		elif fmt == 'hag':
		
			if cmd == 'unpack':
				read_madsconcat(open(arg1, 'rb'), arg1)
			elif cmd == 'pack':
				write_madsconcat(arg1)
		
		
		elif fmt == 'ss':
			if cmd == 'unpack':
				read_ss(open(arg1, 'rb'), arg1)
			elif cmd == 'pack':
				write_ss(arg1)
			else:
				print(usage)
				sys.exit(1)
				
		elif fmt == 'fab':
			if cmd == 'unpack':
				read_fab_unrestricted(arg1)			
			elif cmd == 'pack':
				print("fab compression? what for?")
				# write_fab_unrestricted(arg1)		
			else:
				print(usage)
				sys.exit(1)
			
		elif fmt == 'madspack':
			if cmd == 'unpack':			
				save_madspack(arg1, read_madspack(open(arg1, 'rb')))
				
			elif cmd == 'pack':
				write_madspack(arg1, load_madspack(arg1))
							
			else:
				print(usage)
				sys.exit(1)
		
		elif fmt == 'aa':
			if cmd == 'unpack':			
				read_aa(arg1)
				
			elif cmd == 'pack':
				write_aa(arg1)
							
			else:
				print(usage)
				sys.exit(1)
			
		
		elif fmt == 'ff':
			if cmd == 'unpack':			
				read_ff(arg1)
				
			elif cmd == 'pack':
				write_ff(arg1)
							
			else:
				print(usage)
				sys.exit(1)
			
		else:
			raise External('invalid format specification')
			
	finally:
		os.chdir(odd)
		common.g_curr_dir = ''