MD7_HEADER
	char	ident[4];		// "MDL7"
	long	version;		// '0', 'sub'- version number;
	long	bones_num;
	long	groups_num;
	long	mdl7data_size;	// this file size (head included), except entlump and medlump. 
	long	entlump_size;	// entity info size (not yet used, always 0)
	long	medlump_size;	// size of data for MED in bytes

	unsigned short md7_bone_stc_size;
	unsigned short md7_skin_stc_size;
	unsigned short md7_colorvalue_stc_size;
	unsigned short md7_material_stc_size;
	unsigned short md7_skinpoint_stc_size;
	unsigned short md7_triangle_stc_size;
	unsigned short md7_mainvertex_stc_size;
	unsigned short md7_framevertex_stc_size;
	unsigned short md7_bonetrans_stc_size;
	unsigned short md7_frame_stc_size;

struct MD7_BONE
{
	unsigned short parent_index;
	BYTE _unused_[2]; // 
	float x,y,z;
//ws, 12.05.2003: bone name mitspeichern...
	char name[MAX_BONENAMESIZE];
};

struct MD7_GROUP
{
	unsigned char	typ;		// = '1' -> triangle based Mesh

//ws, 26.04.2006 max weights per vertex
//	BYTE	_unused_[3];
	BYTE	deformers;
	BYTE	max_weights;
	BYTE	_unused_;

	long	groupdata_size; // size of data for this group in bytes ( MD7_GROUP stc. included).
	char	name[MAX_GROUPNAMESIZE];
	long	numskins;
	long	num_stpts;	// number of 2D skin vertices
	long	numtris;
	long	numverts;
	long	numframes;
};


struct MD7_DEFORMER
{
	BYTE	deformer_version;		// 0
	BYTE	deformer_typ;			// 0 - bones
	BYTE	_unused_[2];
	long	group_index;
	long	elements;
	long	deformerdata_size;
};

struct MD7_DEFORMERELEMENT
{
	long	element_index;		// bei deformer_typ==0 (==bones) element_index == bone index
	char	element_name[MAX_BONENAMESIZE];
	long	weights;
};

struct MD7_DEFORMERWEIGHT
{
	long	index;				// bei deformer_typ==0 (==bones) index == vertex index
	float	weight;
};

file.write(struct.pack("<4sllllllHHHHHHHHHH",
                                   b,
                                   0,
                                   len(self.bones),
                                   len(self.groups),
                                   self.getsize(),  # 0 = subversion
                                   0,  # entlumpsize,
                                   0,  # medlumpsize
                                   36,
                                   28,
                                   16,
                                   68,
                                   8,
                                   16,
                                   26,
                                   26,
                                   68,
                                   24))
        for bone in self.bones:
            bone.write(file)
        for group in self.groups:
            group.write(file)

//bone
            file.write(struct.pack("<HHfff20s",
                                   self.parentindex, 0,
                                   self.x, self.y, self.z, b))

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

//group
            file.write(struct.pack("<BBBBl16slllll",
                                   1, # type 1 = triangle mesh
                                   0, # deformers ??
                                   0, # max_weights ??
                                   0, #
                                   self.getsize(),
                                   b,
                                   len(self.skins),
                                   len(self.uvs),
                                   len(self.triangles),
                                   len(self.vertices),
                                   len(self.frames)))

if extension == "mdl":
            file.write(struct.pack("<BBBlll",
                                   deformer_version,  # 0
                                   deformer_typ,  # 0 - bones
                                   0, # _unused_[2] evtl ändern zu  " 0,0, und ein B hinzufügen"
                                   group_index,
                                   len(deformer_elements),
                                   deformerdata_size # <-- ?? XDD  shit xD
                                   ))

            for element in deformer_elements: 
                b = bytearray()
                b.extend(map(ord, element[1]))

                file.write(struct.pack("<l16sl",
                                       element[0], # element[0] == bone index nummer evtl  ändern auf " element[0] -1 " !!!
                                       b, # element[1] == bone name || b == element[1]
                                       len(element[2]) # länge von weights
                                       ))
                for weight in element[2]:
                    file.write(struct.pack("<Hf",
                                           weight[0], # weight[0] == vertex index
                                           weight[1]  # weight[1] == weight
                                           ))