import cv2

import json

import numpy as np

import matplotlib.pyplot as plt

meta={'cats':[],'blocks':[]}

mask_l=[]

def parse_item(path_prop,path_mask):

    fp_prop=open(path_prop,'r')

    json_prop=json.load(fp_prop)

    size,origin=[[json_prop[_] for _ in __] 

                 for __ in [['Height','Width'],['OriginY','OriginX']]]

    dsize=[_//64 for _ in size]

    dorigin=[_//64 for _ in origin]

    mask=cv2.imread(path_mask,cv2.IMREAD_GRAYSCALE)

    if mask is None:

        mask=np.ones(dsize)*255

    else:

        mask=cv2.resize(mask,list(reversed(dsize)),interpolation = cv2.INTER_AREA)

    item={['size','origin'][i]:{['x','y'][j]:d[j] for j in range(2)} for i,d in enumerate([dsize,dorigin])}

    item['verts']=[]

    for i in range(mask.shape[0]):

        for j in range(mask.shape[1]):

            mask_l.append(mask[i][j])

            if mask[i][j] > 10:

                item['verts'].append({'x':i,'y':j})

    print(item)

    return item

def task():

    cat_names=['c'+str(_) for _ in range(1,31)]

    block_names=['b'+str(_) for _ in range(1,21)]+['board_tile_overpaint']

    dir='./meta/'

    for name in cat_names:

        meta['cats'].append(parse_item(dir+name+'_prop.json',dir+name+'_0.png'))

    for name in block_names:

        meta['blocks'].append(parse_item(dir+name+'_prop.json',dir+name+'_0.png'))

    json.dump(meta,open('meta.json','w'))

def test():

    parse_item('./meta/b7_prop.json','./meta/b7_0.png')

if __name__=='__main__':

    task()

    # plt.hist(mask_l,bins=256)

    # plt.show()

import json

import numpy

rot={

    0:[[1,0],[0,1]],

    90:[[0,-1],[1,0]],

    180:[[-1,0],[0,-1]],

    270:[[0,1],[-1,0]]

}

rot={k:numpy.matrix(v) for k,v in rot.items()}

def test_rot():

    x,y=-2,0

    x,y=[int(_) for _ in rot[90]*[[x],[y]]]

    print(x,y)

meta=json.load(open('meta.json','r'))

max_cat_count=0

def parse_level(src_path, dst_path):

    level = json.load(open(src_path, 'r'))

    size=int(level['grid_size'])

    res_map=[['.' for _ in range(size)] for __ in range(size)]

    res_cats=[]

    bx=768-(size-7)*32

    by=320-(size-7)*32

    def add_block(i,j,block_id,angle):

        block=meta['blocks'][block_id]

        ox,oy=[block['origin'][_] for _ in ['x','y']]

        for p in block['verts']:

            p=[p[_] for _ in ['x','y']]

            p=[p[0]-ox,p[1]-oy]

            p=rot[angle]*[[p[0]],[p[1]]]

            p=p.reshape(1,2).tolist()[0]

            p=[p[0]+ox,p[1]+oy]

            print(block_id,i,j,p)

            res_map[i+p[0]-ox][j+p[1]-oy]='#'

    def add_cat(cat_id):

        res_cats.append(cat_id)

    for cat in level['cats']:

        x,y,id,ang=[int(cat[_]) for _ in ['x','y','id','angle']]

        i=int(y-by)//64

        j=int(x-bx)//64

        if(id>=30):

            add_block(i,j,int(id-30),ang)

        else:

            add_cat(id)

    def print_bitmap(bm,sx,sy,of=None):

        for i in range(sx):

            for j in range(sy):

                print(bm[i][j],end='',file=of)

            print(file=of)

    of=open(dst_path,'w')

    print(size,len(res_cats),file=of)

    global max_cat_count

    max_cat_count=max(max_cat_count,len(res_cats))

    print_bitmap(res_map,size,size,of)

    for index,i in enumerate(res_cats):

        cat=meta['cats'][i]

        sx,sy=[cat['size'][_] for _ in ['x','y']]

        mp=[['0' for __ in range(sy)] for _ in range(sx)]

        for p in cat['verts']:

            x,y=[int(p[_]) for _ in ['x','y']]

            mp[x][y]=1

        print(sx,sy,file=of)

        print_bitmap(mp,sx,sy,of)

if __name__ == '__main__':

    for i in range(1,81):

        parse_level('./levels/level'+str(i), './data/cats'+str(i)+'.in')

    # parse_level('./levels/level43','./cats.in')

    print('max_cat_count=',max_cat_count)