function CreateRectangleShapeImage(file,size,cx,cy,ax,by,imagetype)
    
    local minx,miny,maxx,maxy = cx-ax,cy-by,cx+ax,cy+by
    local step = (size/2)
    local x,y = minx+step,miny+step

    local sum = 0
    
    --if ((ax*2)/step) * ((by*2)/step) < 4000 then --ограничение
        while x<maxx do
            y = miny+step
            while y<maxy do
                CreateSquareImage(file,size,x,y,imagetype) 
                SetImageColor(bj_lastCreatedImage, 0, 255, 0, 80)
                sum=sum+1
                y=y+step
            end
            x=x+step
        end
    --else
       -- print('ДОСТИГНУТ ЛИМИТ')
    --end
    
    print('sum: '..sum..' , t: '..((ax*2)/step)*((by*2)/step))
end

function CreateSquareShapeImage(file,size,cx,cy,a,imagetype)
    CreateRectangleShapeImage(file,size,cx,cy,a,a,imagetype)
end

function CreateCircleShapeImage(file,size,cx,cy,radius,imagetype)
    
    local minx,miny,maxx,maxy = cx-radius,cy-radius,cx+radius,cy+radius
    local step = (size/2)
    local x,y = minx-step,miny-step

    local sum = 0
    
    --if (radius^2)*math.pi < 4000 then
        while x<maxx+step do
            y = miny-step
            while y<maxy+step do
                if((cx-x)^2+(cy-y)^2)^0.5 < radius then
                    CreateSquareImage(file,size,x,y,imagetype) 
                    SetImageColor(bj_lastCreatedImage, 0, 255, 0, 80)

                    sum=sum+1
                end
                y=y+step
            end
            x=x+step
        
        end
    --else
    --    print('ДОСТИГНУТ ЛИМИТ')
    --end
    
    print('sum: '..sum..' , S: '..((radius/step)^2)*math.pi)
end

player = {}

for a=1, 12 do
	player[a] = {}
	player[a].shape = {}
end

function DestroyShapeImage(data,num)
   local sum = #data[num].images
   
   for a=1,sum do
        DestroyImage(data[num].images[a])
   end
    table.remove(data,num)
end

function ColorShapeImage(data,num,r,g,b,alpha)
   local sum = #data[num].images
   
   print(sum)
   
   for a=1,sum do
        SetImageColor(data[num].images[a], r, g, b, alpha)
   end
   
end

function CreateCircleShapeImage(data,file,size,cx,cy,radius,imagetype,line_width,color1,color2)
    
    param={}
    param.type_shape=1 --тип фигуры
    param.images={} --общие пиксели (удалить, сдвинуть, переместить, сдвинуть)
    param.images_color1={} --пиксели одного цвета
    param.images_color2={} --пиксели другого цвета
    
    local radius2
    if line_width then
        if line_width < size then
            line_width = size
        end
        radius2 = radius-(line_width/2)
    end
    
    
    local minx,miny,maxx,maxy = cx-radius,cy-radius,cx+radius,cy+radius
    local step = (size/2)
    local x,y = minx-step,miny-step

    local a1,r1,g1,b1,a2,r2,g2,b2
    if color1 then
        r1,g1,b1,a1 = hex2rgba(color1)
    end
    if color2 then
        r2,g2,b2,a2 = hex2rgba(color2)
    end

    local sum = 0
    local count = 0
    
    if color1 and type(color2)=='nil' then --внутренний круг
        count=((radius2/step)^2)*math.pi
    elseif (color2 and type(color1)=='nil') then --кольцо, контур круга
        count=(((radius/step)^2)*math.pi) - (((radius2/step)^2)*math.pi)
    else --полный круг
        count=((radius/step)^2)*math.pi
    end

    --if count < 4000 then
        while x<maxx+step do
            y = miny-step
            while y<maxy+step do
                if((cx-x)^2+(cy-y)^2)^0.5 < radius then
                    --AddSpecialEffect('land_1.mdx',x,y)
                    
                    
                    
                    if line_width then
                        if ((cx-x)^2+(cy-y)^2)^0.5 < radius2 then
                            if color1 then --внутренний круг
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                param.images_color1[sum+1]=bj_lastCreatedImage
                                SetImageColor(bj_lastCreatedImage, r1, g1, b1, a1)
                                sum=sum+1
                            end
                        else
                            
                            if color2 then --кольцо, контур круга
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype)
                                param.images_color2[sum+1]=bj_lastCreatedImage
                                SetImageColor(bj_lastCreatedImage, r2, g2, b2, a2)
                                sum=sum+1
                            elseif type(color1)=='nil' and type(color2)=='nil' then --если цвет кольца color2 не задан, то все равно создаем (сбивает счетчик)
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype)
                                sum=sum+1
                            end
                        end
                    else
                        param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                        sum=sum+1
                    end
                    
                    
                end
                y=y+step
            end
            x=x+step
        
        end
    --else
    --    print('ДОСТИГНУТ ЛИМИТ')
    --end
    if sum>0 then
        table.insert(data,param)
    else
        param.images=nil
        param.images_color1=nil 
        param.images_color2=nil 
        param=nil
    end
    print('sum: '..sum..' , S: '..count)
    
    return #data  --номер фигуры
end

function RoundEx(num)
  local inv = math.floor(math.abs(num) + 0.5)
    return num < 0 and inv * -1 or inv
end

function CoordGride(size,cord)

    --size всегда полож число
    if size>0 then
        return RoundEx(cord/size)*size
    else
        return 0
    end
end

--принадлежность точки эллипсу
--благодарность Prometheus в помощи
function IsPointInEllipse(x, y, cx, cy, a, b, angle)
  x = x - cx
  y = y - cy
  if angle then
    -- (xcosz + ysinz)^2 / a^2 + (ycosz - xsinz)^2 / b^2 = 1
    local sinz = math.sin(angle)
    local cosz = math.cos(angle)
    return (x * cosz + y * sinz)^2 / a^2 + (y * cosz - x * sinz)^2 / b^2 <= 1
  else
    return x^2 / a^2 + y^2 / b^2 <= 1
  end
end

--создаем эллипс. Если угол angle не нужен, то его можно не указывать
function CreateEllipseShapeImage(file,size,cx,cy,rx,ry,imagetype,angle)
    
    local minx,miny,maxx,maxy = cx-rx,cy-ry,cx+rx,cy+ry
    local step = (size/2)
    local x,y = minx-step,miny-step

    local sum = 0
    
    --if (math.pi*rx*ry/step^2) < 4000 then
        while x<maxx+step do
            y = miny-step
            while y<maxy+step do
                if IsPointInEllipse(x,y,cx,cy,rx,ry,angle) then
                    --AddSpecialEffect('land_1.mdx',x,y)
                    
                    CreateSquareImage(file,size,x,y,imagetype) 
                    SetImageColor(bj_lastCreatedImage, 0, 255, 0, 80)

                    sum=sum+1
                end
                y=y+step
            end
            x=x+step
        
        end
    --else
    --    print('ДОСТИГНУТ ЛИМИТ')
    --end
    
    print('sum: '..sum..' , S: '..(math.pi*rx*ry/step^2))
end

--округление в большую/меньшую сторону
--в большую: 0.5 => 1.0 or 0.3 => 0.0
--в меньшую: -0.5 => -1. or -0.3 => 0.0
function RoundEx(num)
  local inv = math.floor(math.abs(num) + 0.5)
    return num < 0 and inv * -1 or inv
end

function CoordGride(size,cord)

    --size всегда полож число
    if size>0 then
        return RoundEx(cord/size)*size
    else
        return 0
    end
end

function CreateEllipseShapeImage(data,file,size,cx,cy,rx,ry,imagetype,angle,line_width,color1,color2)

    param={}
    param.type_shape=1 --тип фигуры
    param.images={} --общие пиксели (удалить, сдвинуть, переместить, сдвинуть)
    param.images_color1={} --пиксели одного цвета
    param.images_color2={} --пиксели другого цвета
    
    local S = (math.pi*rx*ry) --площадь эллипса
    
    local a,b 
    if line_width then
        if size>line_width then
            line_width = size
        end
        a,b = rx-line_width,ry-line_width --полуоси внутреннего эллипса
    
        if color2 and type(color1)=='nil' then
            S=(math.pi*a*b) --площадь внутреннего эллипса
        elseif type(color2)=='nil' then
            S=S-(math.pi*a*b) --площадь внешнего контура
        end
    end
    
    local a1,r1,g1,b1,a2,r2,g2,b2
    if color1 then
        r1,g1,b1,a1 = hex2rgba(color1)
    end
    if color2 then
        r2,g2,b2,a2 = hex2rgba(color2)
    end
    
    local step = (size/2)
    local minx,miny,maxx,maxy = cx-rx,cy-ry,cx+rx,cy+ry
    
    if angle then
        local dg = CoordGride(step,(rx^2+ry^2)^0.5) --диагональ
        minx,miny,maxx,maxy = cx-dg,cy-dg,cx+dg,cy+dg
    end
    local x,y = minx-step,miny-step
    local sum = 0
    

    
    --if (S/step^2) < 4000 then
        while x<maxx+step do
            y = miny-step
            while y<maxy+step do
                if line_width then
                    if IsPointInEllipse(x,y,cx,cy,rx,ry,angle) then
                    
                        if (not IsPointInEllipse(x,y,cx,cy,a,b,angle)) then
                                
                            if color1 then --внешний контур
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                param.images_color1[sum+1]=bj_lastCreatedImage
                                SetImageColor(bj_lastCreatedImage, r1, g1, b1, a1)
                                sum=sum+1
                            elseif type(color1)=='nil' and type(color2)=='nil' then 
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                sum=sum+1
                            end
                        else
                            if color2 then --внутренний эллипс
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                param.images_color2[sum+1]=bj_lastCreatedImage
                                SetImageColor(bj_lastCreatedImage, r2, g2, b2, a2)
                                sum=sum+1
                            end
                        end
                    end
                        
                else
                    if IsPointInEllipse(x,y,cx,cy,rx,ry,angle) then
                        --AddSpecialEffect('land_1.mdx',x,y)
                        
                        param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                        sum=sum+1
                    end
                end
                y=y+step
            end
            x=x+step
        
        end
    --else
    --    print('ДОСТИГНУТ ЛИМИТ')
    --end
    if sum>0 then
        table.insert(data,param)
    else
        param.images=nil
        param.images_color1=nil 
        param.images_color2=nil 
        param=nil
    end
    
    print('sum: '..sum..' , S: '..(S/step^2))
    return #data --номер фигуры
end

function IsPointInSector(x,y,cx,cy,orientation,width,radius,deg)
    local lenght= ((x-cx)^2 + (y-cy)^2)^0.5
    
    local cosa
    local sina
    
    if deg then --ввод только deg
        orientation= math.rad(orientation)
        cosa = math.cos(orientation)
        sina = math.sin(orientation)
    else
        cosa = math.cos(orientation)
        sina = math.sin(orientation)
    end
    
    local angle= math.acos(cosa*(x-cx) / lenght+ sina*(y-cy) / lenght)
    angle = math.deg(angle)
    
    return ( angle <= width / 2 ) and ( lenght >= radius )

    --по идее lenght <= radius - внутри сектора, а нам нужно чтобы снаружи сектора не выходило. поэтому меняем на (lenght >= radius)
end

	print('начало')
	param={}
    
    param.vertexs = {}
    param.vertexs.x = {}
    param.vertexs.y = {}
    
    param.vertexs.x[1]=450; param.vertexs.y[1]=450
    param.vertexs.x[2]=450; param.vertexs.y[2]=180
    param.vertexs.x[3]=150; param.vertexs.y[3]=180
    param.vertexs.x[4]=150; param.vertexs.y[4]=450
    param.vertexs.x[5]=200; param.vertexs.y[5]=450
    param.vertexs.x[6]=200; param.vertexs.y[6]=250
    param.vertexs.x[7]=400; param.vertexs.y[7]=250
    param.vertexs.x[8]=400; param.vertexs.y[8]=450

function area(x1,y1,x2,y2,x3,y3)
	return (x2-x1) * (y3-y1) - (y2-y1) * (x3-x1);
end
 
function intersect_1 (a,b,c,d)
	if (a > b)then a,b=b,a end
	if (c > d)then c,d=d,c end
	return math.max(a,c) <= math.min(b,d);
end
 
function intersect(x1,y1,x2,y2,x3,y3,x4,y4)
	return intersect_1 (x1, x2, x3, x4)
		and intersect_1 (y1, y2, y3, y4)
		and area(x1,y1,x2,y2,x3,y3) * area(x1,y1,x2,y2,x4,y4) <= 0
		and area(x3,y3,x4,y4,x1,y1) * area(x3,y3,x4,y4,x2,y2) <= 0;
end

--mod работает хорошо в других ЯП, где нумерация идет с 0. в луа нумерация идет с 1
function index(x,max)
    if x> max then x=x%max
        if x== 0 then return 1 end
    elseif x<=0 then x=x%max
        if x== 0 then return max end
    end
    return x
end 
--кол-во пересечении отрезка со сторонами полигона
function CrossSegmentPolygon(x1,y1,x2,y2,p)
    local count,a,b = 0,1,1

    repeat
        a=b
        b=index(a+1,#p.x)
        print(' k'..a..'-'..b..' итерация')

        if intersect(x1,y1,x2,y2,p.x[a],p.y[a],p.x[b],p.y[b]) then
            print(' пересечение')
            count = count+1
        end
    until(a==#p.x)
    print(' конец k: '..a..'-итерация')
    return count
end

polygon={x={420,700,700,420},y={220,220,100,100}}
print('кол-во пересечении: '..CrossSegmentPolygon(450,20,450,300,polygon))

    poly = {x={},y={}}
    poly.x[1]=450; poly.y[1]=450
    poly.x[2]=450; poly.y[2]=180
    poly.x[3]=150; poly.y[3]=180
    poly.x[4]=150; poly.y[4]=450
    poly.x[5]=200; poly.y[5]=450
    poly.x[6]=200; poly.y[6]=250
    poly.x[7]=400; poly.y[7]=250
    poly.x[8]=400; poly.y[8]=450

--уголком нижнем праовом углу
--polygon={x={420,700,700,420},y={220,220,100,100}}
--уголком верхнем левом углу
--polygon={x={100,170,170,100},y={700,700,400,400}}
--прикасаются ребром
polygon={x={450,600,600,450},y={450,450,180,180}}
--прикасаются ребром
--polygon={x={450,600,600,450},y={450,450,200,200}}
--взаимодействие ребром
--polygon={x={150,450,150,450},y={180,180,1,1}}


--mod работает хорошо в других ЯП, где нумерация идет с 0. в луа нумерация идет с 1
function index(x,max)
    if x> max then x=x%max
        if x== 0 then return 1 end
    elseif x<=0 then x=x%max
        if x== 0 then return max end
    end
    return x
end 

--определение точки пересечении
function getPointOfIntersection(x1,y1,x2,y2,x3,y3,x4,y4)
	local d,da,db,ta,tb,dx,dy
	
	d = (x1 - x2) * (y4 - y3) - (y1 - y2) * (x4 - x3);
	da = (x1 - x3) * (y4 - y3) - (y1 - y3) * (x4 - x3);
	db = (x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3);
 
	if d==0 then
		return false
	end
 
	ta = da / d;
	tb = db / d;
 
	if (ta >= 0 and ta <= 1 and tb >= 0 and tb <= 1) then
		dx = x1 + ta * (x2 - x1);
		dy = y1 + ta * (y2 - y1);
 
		return dx,dy
	end
 
	return false
end

--кол-во пересечении сторон между многоугольниками
function CountCrossTwoPolygons(p1,p2)
	local b,j,x,y,bool
	local p={x={},y={}}
	for a=1, #p1.x do
		b=index(a+1,#p1.x)
        --print(a..'-'..b..' интерация')
		for i=1,#p2.x do
			j=index(i+1,#p2.x)
			--print(i..'-'..j..' интерация')

			x,y=getPointOfIntersection(p1.x[a],p1.y[a],p1.x[b],p1.y[b],p2.x[i],p2.y[i],p2.x[j],p2.y[j])
			
			if x and y then
			    
			    bool = false
			    for e=1, #p.x do
			        if x==p.x[e] and y==p.y[e] then
			            bool = true
			            break
			        end
			    end
			    if not bool then
			        p.x[#p.x+1]=x
			        p.y[#p.y+1]=y
			    end
		    end
		end
    end

    return #p.x
end

print('кол-во пересечении: '..CountCrossTwoPolygons(poly,polygon))

--создание равнобедренного треугольника
--тут еще можно угол поворота прикрутить для вершин относительно центра
function CreateIsoscelesTriangleShapeImage(file,size,cx,cy,radius,imagetype)

    local minx,miny,maxx,maxy = cx-radius,cy-radius,cx+radius,cy+radius
    local step = (size/2)
    local x,y = minx+step,miny+step

    local Ax,Ay=cx,maxy
    local Bx,By=minx,miny
    local Cx,Cy=maxx,miny
    
    local sum = 0
    
    --if TriS(Ax,Ay,Bx,By,Cx,Cy)/(step^2) <4000 then
        while x<maxx+step do
            y = miny+step
            while y<maxy+step do
                if IsPIn_Vector(x,y,Ax,Ay,Bx,By,Cx,Cy) then
                    CreateSquareImage(file,size,x,y,imagetype) 
                    SetImageColor(bj_lastCreatedImage, 0, 255, 0, 80)

                    sum=sum+1
                end
                y=y+step
            end
            x=x+step
        
        end
    --else
    --    print('ДОСТИГНУТ ЛИМИТ')
    --end
    
    print('sum: '..sum..' , S: '..TriS(Ax,Ay,Bx,By,Cx,Cy)/(step^2))

end

player = {}

for a=1, 12 do
	player[a] = {}
	player[a].shape = {}
end

function DestroyShapeImage(data,num)
   local sum = #data[num].images
   
   for a=1,sum do
        DestroyImage(data[num].images[a])
   end
    table.remove(data,num)
end

function ColorShapeImage(data,num,r,g,b,alpha)
   local sum = #data[num].images
   
   print(sum)
   
   for a=1,sum do
        SetImageColor(data[num].images[a], r, g, b, alpha)
   end
   
end

--Принадлежность точки (x;y) произвольному четырёхугольнику (x1;y1);(x2;y2);(x3;y3);(x4;y4). Облегчённая версия, см. примечание.
function IsCoordsIn4GonSimple(x,y,x1,y1,x2,y2,x3,y3,x4,y4)
    return IsCoordsInTriangle(x, y, x1, y1, x2, y2, x3, y3) or IsCoordsInTriangle(x, y, x1, y1, x4, y4, x3, y3)
end

--Принадлежность точки (x;y) произвольному четырёхугольнику (x1;y1);(x2;y2);(x3;y3);(x4;y4). Полная версия, см. примечание.
function IsCoordsIn4Gon(x,y,x1,y1,x2,y2,x3,y3,x4,y4)
    return IsCoordsInTriangle(x, y, x1, y1, x2, y2, x3, y3) or IsCoordsInTriangle(x, y, x1, y1, x4, y4, x3, y3) or IsCoordsInTriangle(x, y, x1, y1, x2, y2, x4, y4)
end


--Угол между 2 векторами, угол между направлениями этих векторов (наименьший угол).
--По определению, угол между двумя векторами находится в промежутке [0°; 180°].
--Косинус угла между ними равен
--@param real dx1,dy1,dx2,dy2
---@return real
function AngleBetweenTwoVectors(dx1,dy1,dx2,dy2) --в радианах (для превращения в градусы заверните в Acos)
    return math.acos((dx1*dx2+dy1*dy2)/((dx1^2+dy1^2)^0.5  * (dx2^2+dy2^2)^0.5))
end
--угол между двумя векторами
function AngleVectors(x1,y1,x2,y2)
    return math.acos((x1*x2+y1*y2)/((x1^2+y1^2)^0.5  * (x2^2+y2^2)^0.5))
end

--Угол между двумя отрезками
function BlzAngleBetweenSegments(Ax1,Ay1,Ax2,Ay2,Bx1,By1,Bx2,By2)
    local dx1,dx2,dy1,dy2=Ax2-Ax1,Bx2-Bx1,Ay2-Ay1,By2-By1
    return AngleBetweenTwoVectors(dx1,dy1,dx2,dy2)
end
--угол между диагоналями четырехугольника/сторонами треугольника и пр
--cx,cy - точка пересечения диагоналей A и B
--Ax,Ay,Bx,By - одна из крайних точек диагоналей
function BlzAngleBetweenDiagonals(cx,cy,Ax,Ay,Bx,By)
    local dx1,dx2,dy1,dy2=Ax-cx,Bx-cx,Ay-cy,By-cy
    return AngleBetweenTwoVectors(dx1,dy1,dx2,dy2)
end

--расстояние между 2 точками
--@param real x1,y1,x2,y2
---@return real
function VectorLength(x1,y1,x2,y2)
    return ((x2-x1)^2 + (y2-y1)^2)^0.5
end

--Площадь четырехугольника по диагоналям и углу между ними
function AreaQuadrilateral_v1(x1,y1,x2,y2,x3,y3,x4,y4)
    
    local x,y=InterLineLine(x1,y1,x3,y3,x2,y2,x4,y4)
    if x then
        local d1 = VectorLength(x1,y1,x3,y3) --длина диагоналя
        local d2 = VectorLength(x2,y2,x4,y4)
        local angle = BlzAngleBetweenDiagonals(x,y,x1,y1,x2,y2)
        return (d1*d1*math.sin(angle))/2
    end
    return 0
end
--Площадь четырехугольника через стороны и углы между этими сторонами
function AreaQuadrilateral_v2(x1,y1,x2,y2,x3,y3,x4,y4)
    
    local a = VectorLength(x1,y1,x2,y2)
    local b = VectorLength(x2,y2,x3,y3)
    local c = VectorLength(x3,y3,x4,y4)
    local d = VectorLength(x4,y4,x1,y1)
    
    local p = (a+b+c+d)/2 --полупериметр четырехугольника
    
    local alpha = BlzAngleBetweenDiagonals(x2,y2,x1,y1,x3,y3)
    local beta = BlzAngleBetweenDiagonals(x4,y4,x3,y3,x1,y1)
    
    return ((p-a)*(p-b)*(p-c)*(p-d)-a*b*c*d*math.cos((alpha+beta)/2))^0.5
end


function function CreateRectangleShapeImage(data,file,size,cx,cy,half_widht,half_height,imagetype,angle,line_width,color1,color2)
        
    param={}
    param.type_shape=1 --тип фигуры
    param.images={} --общие пиксели (удалить, сдвинуть, переместить, сдвинуть)
    param.images_color1={} --пиксели одного цвета
    param.images_color2={} --пиксели другого цвета
    
    
    local step = (size/2)
    local minx,miny,maxx,maxy = cx-half_widht,cy-half_height,cx+half_widht,cy+half_height
    local ax1,ay1,ax2,ay2,ax3,ay3,ax4,ay4
    local bx1,by1,bx2,by2,bx3,by3,bx4,by4
    local S = (half_widht*2-step)*(half_height*2-step)/step^2
    
    if line_width then
        if line_width < step then
            line_width = step
        end
    end
    
    local a1,r1,g1,b1,a2,r2,g2,b2
    if color1 then
        r1,g1,b1,a1 = hex2rgba(color1)
    end
    if color2 then
        r2,g2,b2,a2 = hex2rgba(color2)
    end
        
    if angle then
        local w,h = (half_widht),(half_height)
        local dg = CoordGride(step,(w^2+h^2)^0.5) --диагональ
        
        --векторы
        local dx1,dy1 = minx-cx,miny-cy
        local dx2,dy2 = minx-cx,maxy-cy
        local dx3,dy3 = maxx-cx,maxy-cy
        local dx4,dy4 = maxx-cx,miny-cy
        
        --нужно повернуть вершины
        local cosa = math.cos(angle)
        local sina = math.sin(angle)
        
        --повороты
        ax1,ay1 = cx+(dx1*cosa - dy1*sina),cy+(dx1*sina + dy1*cosa)
        ax2,ay2 = cx+(dx2*cosa - dy2*sina),cy+(dx2*sina + dy2*cosa)
        ax3,ay3 = cx+(dx3*cosa - dy3*sina),cy+(dx3*sina + dy3*cosa)
        ax4,ay4 = cx+(dx4*cosa - dy4*sina),cy+(dx4*sina + dy4*cosa)
        
        S = (AreaQuadrilateral_v1(ax1,ay1,ax2,ay2,ax3,ay3,ax4,ay4)-step)/step^2
        
        if line_width then
            --векторы
            dx1,dy1 = (minx+line_width)-cx,(miny+line_width)-cy
            dx2,dy2 = (minx+line_width)-cx,(maxy-line_width)-cy
            dx3,dy3 = (maxx-line_width)-cx,(maxy-line_width)-cy
            dx4,dy4 = (maxx-line_width)-cx,(miny+line_width)-cy
            
            bx1,by1 = cx+(dx1*cosa - dy1*sina),cy+(dx1*sina + dy1*cosa)
            bx2,by2 = cx+(dx2*cosa - dy2*sina),cy+(dx2*sina + dy2*cosa)
            bx3,by3 = cx+(dx3*cosa - dy3*sina),cy+(dx3*sina + dy3*cosa)
            bx4,by4 = cx+(dx4*cosa - dy4*sina),cy+(dx4*sina + dy4*cosa)
            
            if type(color2)=='nil' then
                S = S-((AreaQuadrilateral_v1(bx1,by1,bx2,by2,bx3,by3,bx4,by4)-step)/step^2)
            elseif type(color1)=='nil' and color2 then
                S = ((AreaQuadrilateral_v1(bx1,by1,bx2,by2,bx3,by3,bx4,by4)-step)/step^2)
            end
        end
        
        --print('SSSS',S)
        --AddLightningEx("HWPB", true, ax1, ay1, 0, ax2, ay2, 0)
        --AddLightningEx("CLPB", true, ax2, ay2, 0, ax3, ay3, 0)
        --AddLightningEx("CLPB", true, ax3, ay3, 0, ax4, ay4, 0)
        --AddLightningEx("CLPB", true, ax4, ay4, 0, ax1, ay1, 0)
        
        --помечаем область поиска
        minx,miny,maxx,maxy = cx-dg,cy-dg,cx+dg,cy+dg
        
        --print(minx,miny,maxx,maxy)
    
    end
    
    local x,y = minx+step,miny+step

    local function Rectangle_Outline(x,y,minx,miny,maxx,maxy,line_width)
        if line_width then
            
            local maxX = maxx-line_width
            local maxY = maxy-line_width
            local minX = minx+line_width
            local minY = miny+line_width
            
            return((x >= maxX and x<= maxx)or(x <= minX and x>= minx))or((y >= maxY and y<= maxy)or(y <= minY and y>= miny))
        end
    
    end
    --площадь контура прямоугольника
    local function AreaRectangle(widht,height,step,line_width)
         
        if line_width then
            
            local w = (widht-step)-(line_width*2)
            local h = (height-step)-(line_width*2)

            S=((widht-step)*(height-step))-(w*h)
        else
            S=(widht-step)*(height-step)
        end
        return S
    
    end

    

    local sum = 0
    
    if angle then
        --if S < 4000 then --ограничение
            if line_width then
                while x<maxx do
                    y = miny+step
                    while y<maxy do
                        if IsCoordsIn4GonSimple(x,y,ax1,ay1,ax2,ay2,ax3,ay3,ax4,ay4)then
                        
                            if (not IsCoordsIn4GonSimple(x,y,bx1,by1,bx2,by2,bx3,by3,bx4,by4)) then --IsCoordsIn4GonSimple или IsCoordsIn4Gon
                                
                                if color1 then --внешний контур
                                    param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                    param.images_color1[sum+1]=bj_lastCreatedImage
                                    SetImageColor(bj_lastCreatedImage, r1, g1, b1, a1)
                                    sum=sum+1
                                elseif type(color1)=='nil' and type(color2)=='nil' then 
                                    param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                    sum=sum+1
                                end
                            else
                                if color2 then --внутренний квадрат
                                    param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                    param.images_color2[sum+1]=bj_lastCreatedImage
                                    SetImageColor(bj_lastCreatedImage, r2, g2, b2, a2)
                                    sum=sum+1
                                end
                            end
                        end
                        y=y+step
                    end
                    x=x+step
                
                end
            else
                while x<maxx do
                    y = miny+step
                    while y<maxy do
                        if IsCoordsIn4GonSimple(x,y,ax1,ay1,ax2,ay2,ax3,ay3,ax4,ay4) then --IsCoordsIn4GonSimple или IsCoordsIn4Gon
                            --AddSpecialEffect('land_1.mdx',x,y)
                      
                            param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype)
                            sum=sum+1
                        end
                        y=y+step
                    end
                    x=x+step
                
                end
            end
            
            
        --else
           -- print('ДОСТИГНУТ ЛИМИТ')
        --end
    else
        S = AreaRectangle(half_widht*2,half_height*2,step,line_width)/step^2
        --if S < 4000 then --ограничение
            while x<maxx do
                y = miny+step
                while y<maxy do
                    if line_width then
                        if Rectangle_Outline(x,y,minx,miny,maxx,maxy,line_width) then
                            --AddSpecialEffect('land_1.mdx',x,y)
                              
                            if color1 then --внешний контур
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                param.images_color1[sum+1]=bj_lastCreatedImage
                                SetImageColor(bj_lastCreatedImage, r1, g1, b1, a1)
                                sum=sum+1
                            elseif type(color1)=='nil' and type(color2)=='nil' then 
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                sum=sum+1
                            end 
                        else
                            if color2 then --внутренний квадрат
                                param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                                param.images_color2[sum+1]=bj_lastCreatedImage
                                SetImageColor(bj_lastCreatedImage, r2, g2, b2, a2)
                                sum=sum+1
                            end
                        end
                    else
                        --AddSpecialEffect('land_1.mdx',x,y)
                            
                        param.images[sum+1]=CreateSquareImage(file,size,x,y,imagetype) 
                        sum=sum+1
                    end
                    y=y+step
                end
                x=x+step
            
            end
        --else
           -- print('ДОСТИГНУТ ЛИМИТ')
        --end
    end
    
    if sum>0 then
        table.insert(data,param)
    else
        param.images=nil
        param.images_color1=nil 
        param.images_color2=nil 
        param=nil
    end
    
    print('count: '..sum..' , S: '..S)--AreaRectangle(half_widht*2,half_height*2,step,line_width)/step^2)

    return #data  --номер фигуры
end

function CreateSquareShapeImage(data,file,size,cx,cy,a,imagetype,angle,line_width,color1,color2)
    return CreateRectangleShapeImage(data,file,size,cx,cy,a,a,imagetype,angle,line_width,color1,color2)
end

function CreateSquareShapeImage(data,file,size,cx,cy,a,imagetype,angle,line_width,color1,color2)
    return CreateRectangleShapeImage(data,file,size,cx,cy,a,a,imagetype,angle,line_width,color1,color2)
end

function plotLine(file,size,imagetype,x0,y0,x1,y1)
   local dx =  math.abs(x1-x0)
   local dy = -math.abs(y1-y0) 
   local err,sx,sy, e2 = dx+dy
   
   if x0<x1 then
    sx=1
    else
    sx=-1
    end 
    if y0<y1 then
    sy=1
    else
    sy=-1
    end

    local sum = 0
   while(true) do
        CreateSquareImage(file,size,x0,y0,imagetype) 
        SetImageColor(bj_lastCreatedImage, 0, 255, 0, 80)
        sum = sum+1
      if (x0==x1 and y0==y1) then
        break
      end
      e2 = 2*err
        if (e2 >= dy) then
            err = err+dy
            x0 = x0+sx
        end
        if (e2 <= dx) then
            err = err+dx
            y0 = y0+sy
        end
   end
   print('sum:',sum)
end

function putpixel(file,size,imagetype,x,y,a)
    CreateSquareImage(file,size,x,y,imagetype)
    if a then
        a = math.abs(a)//1
        if a> 255 then
            a = 255
        elseif a<0 then
            a = 0
        end
        SetImageColor(bj_lastCreatedImage, 0, 255, 0, 255-a)
    else
        SetImageColor(bj_lastCreatedImage, 0, 255, 0, 80)
    end
    return bj_lastCreatedImage
end

function plotLine(file,size,imagetype,x0,y0,x1,y1)
    local step = size/2
    x0 = CoordGride(size,x0)
    y0 = CoordGride(size,y0)
    x1 = CoordGride(size,x1)
    y1 = CoordGride(size,y1)
   
    local dx =  math.abs(x1-x0)
    local dy = -math.abs(y1-y0) 
    local err,sx,sy, e2 = dx+dy
   
    if x0<x1 then
        sx=step
    else
        sx=-step
    end 
    if y0<y1 then
        sy=step
    else
        sy=-step
    end

    local sum = 0
	while(true) do
        putpixel(file,size,imagetype,x0,y0)
        sum = sum+1
      if (x0==x1 and y0==y1) then
        break
      end
      e2 = 2*err
        if (e2 >= dy) then
            err = err+dy
            x0 = x0+sx
        end
        if (e2 <= dx) then
            err = err+dx
            y0 = y0+sy
        end
   end
   print('sum:',sum)
end

function drawLine(file,size,imagetype,x1,y1,x2,y2)
   local step = size/2
   x1 = CoordGride(size,x1)
   y1 = CoordGride(size,y1)
   x2 = CoordGride(size,x2)
   y2 = CoordGride(size,y2)
   local dx,dy = (x2 - x1)/step,(y2 - y1)/step
   
   CreateUnit(Player(0),FourCC('hfoo'),x1,y1,0)
   CreateUnit(Player(0),FourCC('hfoo'),x2,y2,0)
   
    local sign_x,sign_y = step,step
    local pdx,pdy,es,el,x,y,error, t
    if(dx > 0) then 
        sign_x = step
    elseif(dx == 0) then 
        sign_x = 0
    else 
        sign_x = -step
    end
    
    if(dy > 0) then 
        sign_y = step
    elseif(dy == 0) then 
        sign_y = 0
    else 
        sign_y = -step
    end  
        
    if dx < 0 then dx = -dx end
    if dy < 0 then dy = -dy end
        
    if dx > dy then
        pdx, pdy = sign_x, 0
        es, el = dy, dx
    else
        pdx, pdy = 0, sign_y
        es, el = dx, dy
    end
        
    x, y = x1, y1
    error, t = el/2, 0        
        
    putpixel(file,size,imagetype,x,y)
    
    
    while t < el do
        error = error - es
        if error < 0 then
            error = error + el
            x = x + sign_x
            y = y + sign_y
        else
            x = x + pdx
            y = y + pdy
        end
        t = t + 1
        putpixel(file,size,imagetype,x,y)
    end
end

drawLine("war3mapImported\\block 32x32.TGA",128,2,0,0,512,512)

function plotCircle(file,size,imagetype,xm, ym, r)
    xm = CoordGride(size,xm)
    ym = CoordGride(size,ym)
    r = CoordGride(size,r)
   local step = size/2
   local x,y,err = xm-r, ym+0, 2-2*r
   local sum = 0
   while (x < 0) do
        --   I. Quadrant
        putpixel(file,size,imagetype,xm-x,ym+y)
        --  II. Quadrant
        putpixel(file,size,imagetype,xm-y,ym-x)
        -- III. Quadrant
        putpixel(file,size,imagetype,xm+x,ym-y)
        --  IV. Quadrant
        putpixel(file,size,imagetype,xm+y,ym+x)
		
		sum = sum + 4
      r = err
        if (r <= y) then
            y = y +step
            err = err +y*2+step 
        end       
        if (r > x or err > y) then 
            x = x +step
            err = err +x*2+step 
        end 
   end
   print('sum:',sum)
end

plotCircle("war3mapImported\\block 32x32.TGA",128,2,0, 0, 512)

--Алгоритм Брезенхема для рисования эллипса
--https://studassistent.ru/charp/rastrovaya-razvertka-okruzhnosti-i-ellipsa-c
function ellipse(file,size,imagetype,x,y,a,b)
    x = CoordGride(size,x)
    y = CoordGride(size,y)
    local step = size/2

    local col, i, row, bnew
    local a_square, b_square, two_a_square, two_b_square, four_a_square, four_b_square, d
         
    b_square = b * b;
    a_square = a * a;
    row = b;
    col = 0;
    two_a_square = a_square << 1;
    four_a_square = a_square << 2;
    four_b_square = b_square << 2;
    two_b_square = b_square << 1;
                    
    d = two_a_square * ((row - 1) * (row)) + a_square + two_b_square * (1 - a_square);
    while (a_square * (row) > b_square * (col))do
        putpixel(file,size,imagetype, col + x, row + y)
        putpixel(file,size,imagetype, col + x, y - row)
        putpixel(file,size,imagetype, x - col, row + y)
        putpixel(file,size,imagetype, x - col, y - row)
        if (d >= 0)then
            row=row-step
            d = d- (four_a_square * (row))
        end
        d = d+(two_b_square * (3 + (col << 1)))
        col=col+step
    end
    d = two_b_square * (col + 1) * col + two_a_square * (row * (row - 2) + 1) + (1 - two_a_square) * b_square;

    while ((row) + 1 > 0)do
        putpixel(file,size,imagetype, col + x, row + y)
        putpixel(file,size,imagetype, col + x, y - row)
        putpixel(file,size,imagetype, x - col, row + y)
        putpixel(file,size,imagetype, x - col, y - row)
        if (d <= 0)then
            col=col+step
            d = d+(four_b_square * col)
        end
        row=row-step
        d = d+(two_a_square * (3 - (row << 1)))
    end
     
end

--https://www.geeksforgeeks.org/midpoint-ellipse-drawing-algorithm/
function midptellipse(file,size,imagetype,xc,yc,rx,ry)
    xc = CoordGride(size,xc)
    yc = CoordGride(size,yc)
    rx = CoordGride(size,rx)
    ry = CoordGride(size,ry)
    local step = size/2

    local dx, dy, d1, d2, x, y
    
    
    if rx>ry then
        x,y = 0,ry
     
        -- Initial decision parameter of region 1
        d1 = (ry^2) - (rx^2 * ry) + (0.25 * rx^2)
        dx = 2 * ry^2 * x;
        dy = 2 * rx^2 * y;
     
        -- For region 1
        while (dx < dy) do
            -- Print points based on 4-way symmetry
            if x+xc == -x+xc then --чтоб дважды не выделяла точку
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,-x+xc,-y+yc)
            else
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,-x+xc,y+yc)
                putpixel(file,size,imagetype,x+xc,-y+yc)
                putpixel(file,size,imagetype,-x+xc,-y+yc)
            end
            
            -- Checking and updating value of
            -- decision parameter based on algorithm
            if (d1 < 0) then
                x=x+step
                dx = dx + (2*step * ry * ry);
                d1 = d1 + dx + (ry * ry);
            else
                x=x+step
                y=y-step
                dx = dx + (2*step * ry * ry);
                dy = dy - (2*step * rx * rx);
                d1 = d1 + dx - dy + (ry * ry);
            end
        end
     
        -- Decision parameter of region 2
        d2 = ((ry * ry) * ((x + 0.5) * (x + 0.5))) +((rx * rx) * ((y - 1) * (y - 1))) -(rx * rx * ry * ry);
     
        -- Plotting points of region 2
        while (y >= 0)do
     
            -- Print points based on 4-way symmetry
            if y+yc == -y+yc then --чтоб дважды не выделяла точку
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,-x+xc,y+yc)
            else
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,-x+xc,y+yc)
                putpixel(file,size,imagetype,x+xc,-y+yc)
                putpixel(file,size,imagetype,-x+xc,-y+yc)
            end
            -- Checking and updating parameter
            -- value based on algorithm
            if (d2 > 0)then
                y=y-step
                dy = dy - (2*step * rx * rx);
                d2 = d2 + (rx * rx) - dy;
            else
                y=y-step
                x=x+step
                dx = dx + (2*step * ry * ry);
                dy = dy - (2*step * rx * rx);
                d2 = d2 + dx - dy + (rx * rx);
            end
        end
    elseif rx<ry then
        x,y = rx,0
     
        -- Initial decision parameter of region 1
        d1 = (rx * rx) - (ry * ry * rx) + (0.25 * ry * ry)
        
        dy = 2 * rx * rx * y;
        dx = 2 * ry * ry * x;
     
        -- For region 1
        while (dy < dx) do
            -- Print points based on 4-way symmetry
            if y+yc == -y+yc then --чтоб дважды не выделяла точку
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,-x+xc,-y+yc)
            else
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,-x+xc,y+yc)
                putpixel(file,size,imagetype,x+xc,-y+yc)
                putpixel(file,size,imagetype,-x+xc,-y+yc)
            end
            
            -- Checking and updating value of
            -- decision parameter based on algorithm
            if (d1 < 0) then
                y=y+step
                dy = dy + (2*step * rx * rx);
                d1 = d1 + dy + (rx * rx);
            else
                y=y+step
                x=x-step
                dy = dy + (2*step * rx * rx);
                dx = dx - (2*step * ry * ry);
                d1 = d1 + dy - dx + (rx * rx);
            end
        end
     
        -- Decision parameter of region 2
        d2 = ((rx * rx) * ((y + 0.5) * (y + 0.5))) +((ry * ry) * ((x - 1) * (x - 1))) -(ry * ry * rx * rx);
     
        -- Plotting points of region 2
        while (x >= 0)do
     
            -- Print points based on 4-way symmetry
            if x+xc == -x+xc then --чтоб дважды не выделяла точку
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,x+xc,-y+yc)
            else
                putpixel(file,size,imagetype,x+xc,y+yc)
                putpixel(file,size,imagetype,-x+xc,y+yc)
                putpixel(file,size,imagetype,x+xc,-y+yc)
                putpixel(file,size,imagetype,-x+xc,-y+yc)
            end
            -- Checking and updating parameter
            -- value based on algorithm
            if (d2 > 0)then
                x=x-step
                dx = dx - (2*step * ry * ry);
                d2 = d2 + (ry * ry) - dx;
            else
                x=x-step
                y=y+step
                dy = dy + (2*step * rx * rx);
                dx = dx - (2*step * ry * ry);
                d2 = d2 + dy - dx + (ry * ry);
            end
        end
    elseif rx==ry then
        plotCircle(file,size,imagetype,xc,yc,rx or ry)
    end
end

    --ellipse("war3mapImported\\block 32x32.TGA",128,2,0,0,512,256)
    midptellipse("war3mapImported\\block 32x32.TGA",128,2,0,0,512,256)