using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI.Extensions;
using UnityEngine.UI;

public class DRAW : MonoBehaviour
{
    GameObject PNL;
    public Texture2D cursorPoint;
    Vector2 hotSpot = new Vector2(64, 64);
    float xpos;
    float ypos;
    Vector2 XY;
    
    // void Start(){
    //     _G.HEIGHT = 96;
    //     Get.o2("Canvas","DRAWPlan").SetActive(true);
    //     _G.PNL="DRAWPlan";
    //     //setMesure(DOIT.CSn(IV.text));
    //     //print("-------------------------START DRAW----------------");
    //    _G.NW=1;
    //    //print("-------------------------START DRAW 2----------------");
    //     PNL=Get.o2("DRAWPlan","Plan");
    //     PNL.SetActive(true); 
    //     //Get.o2("DRAWPlan","3D").SetActive(false);
    //     _G.Down=false;
    //     _G.Open=true;
    //     UILineRenderer pr=PNL.transform.GetComponent<UILineRenderer>();
    //     var pointlist = new List<Vector2>();
    //     pr.Points = pointlist.ToArray();
    //     DOIT.DELETEAllChild("Plan");
    //     _G.wP=new Vector2[24];
    //    // print("-------------------------START DRAW END----------------");
    //  }
    // void Update(){
    //     //print("Updat");
    //     XY=new Vector2(getXY("x"),getXY("y"));
    //     if (Input.GetMouseButtonDown(0)  && _G.Open==true && _G.Down==true){
    //         if (XY.x>-500f && XY.x<500f  &&  XY.y>-300 && XY.y<300 )
    //         {
    //             if(_G.NW==1) 
    //             {
    //                 _G.wP[_G.NW-1]=new Vector2(XY.x,XY.y);
    //             }
    //             if(_G.NW>=1)
    //             {
    //                 int sens=sense(_G.wP[_G.NW-2],XY); 
    //                 if(sens!=0){ _G.wP[_G.NW-1]=new Vector2(XY.x,XY.y);}
    //             }
    //         }
    //         else {restart();}            
    //      }
    //     if (Input.GetMouseButtonDown(1)  && _G.Open==true && _G.Down==true && _G.NW>=4) {
    //         print("RRRRRRRRRRRRRRRRRIIIIIIIIIIIGGGGGGGGGGGGGGGHHHHHHHHHHHHTR");
    //         _G.deleteLastWall = true;
    //         _G.closingWall=0;
    //         _G.Down=false; 
    //         _G.Open=true;
    //         _G.NW-=1;
    //         print("_G.NW====="+_G.NW);
            
    //         if(sense(_G.wP[_G.NW-1],XY)==7){_G.wP[_G.NW-1].x=_G.wP[1-1].x;}
    //         if(sense(_G.wP[_G.NW-1],XY)==8)
    //         {
    //             float disx=Mathf.Abs(_G.wP[_G.NW-1].x-_G.wP[1-1].x);
    //             _G.wP[_G.NW-1].y=_G.wP[1-1].y-disx;
    //         }
    //         DOIT.DELETEAllChild("Plan");         
    //         addlines(_G.NW);
    //         addMesures(_G.NW);
    //         RoomSize(); 
    //         Cursor.SetCursor(null, Vector2.zero, CursorMode.ForceSoftware);//Delete points
    //         //_G.NW-=1;
    //         _G.ROOMCLOSE=false;
    //      }
    //     if (Input.GetMouseButtonDown(0) && _G.Down==false && _G.Open==true){
    //         if (XY.x<-192 && XY.x>-292 && XY.y<245&& XY.y>145)
    //         {
    //             _G.Down=true;
    //             _G.wP[_G.NW-1]=new Vector2(XY.x,XY.y);
    //         }  
    //      }
    //     if (Input.GetMouseButtonUp(0) && _G.Open==true && _G.Down){
    //         if( _G.NW>3 && XY.x<-210 && XY.x>-310 && XY.y<236 && XY.y>136)
    //         {
    //             print("-----------------------------------DOWN FALSE------------------------------------");
    //             _G.Down=false; 
    //             _G.Open=false;
    //             _G.NW-=1;
    //             if(sense(_G.wP[_G.NW-1],XY)==7){_G.wP[_G.NW-1].x=_G.wP[1-1].x;}
    //             if(sense(_G.wP[_G.NW-1],XY)==8)
    //             {
    //                 float disx=Mathf.Abs(_G.wP[_G.NW-1].x-_G.wP[1-1].x);
    //                 _G.wP[_G.NW-1].y=_G.wP[1-1].y-disx;
    //             }
    //             DOIT.DELETEAllChild("Plan");         
    //             addlines(_G.NW);
    //             addMesures(_G.NW);
    //             RoomSize(); 
    //             Cursor.SetCursor(null, Vector2.zero, CursorMode.ForceSoftware);//Delete points
    //         }
    //         else {_G.NW+=1;}
    //      }        
    //  }

    // void LateUpdate()
    //     {
    //         if(_G.Down && _G.NW>1 && _G.Open )
    //         {
    //             //XY=new Vector2(getXY("x"),getXY("y"));
    //             float dis=Vector2.Distance(XY,_G.wP[_G.NW-2]);
    //             Cursor.SetCursor(cursorPoint, hotSpot, CursorMode.ForceSoftware);      
    //             int sens=sense(_G.wP[_G.NW-2],XY);
    //             //print("sens==="+sens);
    //             switch(sens){
    //                     case 1:_G.wP[_G.NW-1]=new Vector2(getXY("x"),_G.wP[_G.NW-2].y);break;
    //                     case 2:_G.wP[_G.NW-1]=new Vector2(_G.wP[_G.NW-2].x+dis*0.707f ,_G.wP[_G.NW-2].y-dis*0.707f );break;
    //                     case 3:_G.wP[_G.NW-1]=new Vector2(_G.wP[_G.NW-2].x,getXY("y"));    ;break;
    //                     case 4: _G.wP[_G.NW-1]=new Vector2(_G.wP[_G.NW-2].x-dis*0.707f ,_G.wP[_G.NW-2].y-dis*0.707f );break;
    //                     case 5: _G.wP[_G.NW-1]=new Vector2(getXY("x"),_G.wP[_G.NW-2].y);break;
    //                     case 6:_G.wP[_G.NW-1]=new Vector2(_G.wP[_G.NW-2].x-dis*0.707f ,_G.wP[_G.NW-2].y+dis*0.707f );break;
    //                     case 7:_G.wP[_G.NW-1]=new Vector2(_G.wP[_G.NW-2].x,getXY("y"));break;
    //                     case 8: _G.wP[_G.NW-1]=new Vector2(_G.wP[_G.NW-2].x+dis*0.707f ,_G.wP[_G.NW-2].y+dis*0.707f );break;
    //             }
    //             if(sens!=0){
    //                 addlines(_G.NW);
    //                 addMesures(_G.NW);
    //                 _G.endPoint = _G.wP[_G.NW-1];
    //             }   
    //             Get.o3("DRAWPlan","StartHere","T_Start").GetComponent<Text>().text=TRANS.This("T_FinishHere");
    //         }
    //         else{
    //             Cursor.SetCursor(null, Vector2.zero, CursorMode.ForceSoftware);
    //         }    
    //     }
    // public void restart(){
    //     _G.NW=1;
    //     print("RESATRT");
    //     _G.closingWall=1;
    //     _G.Down=false;
    //     _G.Open=true;
    //     GameObject p=Get.o2("DRAWPlan","Plan");
    //     p.SetActive(true);
    //     UILineRenderer pr=p.transform.GetComponent<UILineRenderer>();
    //     var pointlist = new List<Vector2>();
    //     pr.Points = pointlist.ToArray();
    //     DOIT.DELETEAllChild("Plan");
    //     _G.ROOMCLOSE=true;
    //     _G.wP=new Vector2[24];
    //     GameObject.Find("T_StarttHere").transform.GetComponent<CanvasGroup>().alpha=1;
    //     GameObject.Find("T_FinishHere").transform.GetComponent<CanvasGroup>().alpha=0;
    //     Measure.okShow("DRAWPlan", "FINISH", false);
    //  }
    // //--------------------------------------------------------------------------------------------------------
    // //--------------------------------------------------------------------------------------------------------
    // // public static void RedrawRoom(string Ms,float Value){
    // //     print("--------pass redraw----------");
    // //     //print("_G.NW===== "+_G.NW);       
    // //     int Mi=int.Parse(Ms.Substring(1,3))-100;

    // //     int i=1;
    // //     for(i=1; i<_G.NW; i++){ _G.wD[i-1]=sense(_G.wP[i-1],_G.wP[i]);}
    // //     _G.wD[_G.NW-1]=sense(_G.wP[_G.NW-1],_G.wP[1-1]);

    // //     _G.WallsWidth[Mi-1]=Value;
    // //     _G.wP[1-1].x=-242;
    // //     _G.wP[1-1].y=195;

    // //     //print(" _G.wD[_G.NW-1]====="+_G.wD[_G.NW-1]);

    // //     float dis=_G.WallsWidth[1-1]*2;
    // //     for(i=1; i<_G.NW+1; i++){
    // //         dis=_G.WallsWidth[i-1]*2;
    // //         if(_G.wD[i-1]==1){_G.wP[i]=new Vector2(_G.wP[i-1].x+dis,_G.wP[i-1].y);}
    // //         if(_G.wD[i-1]==2){_G.wP[i]=new Vector2(_G.wP[i-1].x+dis*0.707f,_G.wP[i-1].y-dis*0.707f);}
    // //         if(_G.wD[i-1]==3){_G.wP[i]=new Vector2(_G.wP[i-1].x,_G.wP[i-1].y-dis);}
    // //         if(_G.wD[i-1]==4){_G.wP[i]=new Vector2(_G.wP[i-1].x-dis*0.707f,-_G.wP[i-1].y-dis*0.707f);}
    // //         if(_G.wD[i-1]==5){_G.wP[i]=new Vector2(_G.wP[i-1].x-dis,_G.wP[i-1].y);}
    // //         if(_G.wD[i-1]==6){_G.wP[i]=new Vector2(_G.wP[i-1].x-dis*0.707f,_G.wP[i-1].y+dis*0.707f);}
    // //         if(_G.wD[i-1]==7){_G.wP[i]=new Vector2(_G.wP[i-1].x,_G.wP[i-1].y+dis);}
    // //         if(_G.wD[i-1]==8){_G.wP[i]=new Vector2(_G.wP[i-1].x+dis*0.707f,_G.wP[i-1].y+dis*0.707f);}
    // //     }
        
    // //     if(_G.wD[_G.NW-1]==1){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x-dis,_G.wP[1-1].y);}
    // //     if(_G.wD[_G.NW-1]==2){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x-dis*0.707f,_G.wP[1-1].y+dis*0.707f);}
    // //     if(_G.wD[_G.NW-1]==3){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x,_G.wP[1-1].y+dis);}
    // //     if(_G.wD[_G.NW-1]==4){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x+dis*0.707f,_G.wP[1-1].y+dis*0.707f);}
    // //     if(_G.wD[_G.NW-1]==5){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x+dis,_G.wP[1-1].y);}
    // //     if(_G.wD[_G.NW-1]==6){
    // //             float disx=Mathf.Abs(_G.wP[_G.NW-1].x-_G.wP[1-1].x);
    // //             _G.wP[_G.NW-1].y=_G.wP[1-1].y-disx;
    // //         }
    // //     if(_G.wD[_G.NW-1]==7){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x,_G.wP[_G.NW-1].y);}           
    // //     if(_G.wD[_G.NW-1]==8){
    // //             float disx=Mathf.Abs(_G.wP[_G.NW-1].x-_G.wP[1-1].x);
    // //             _G.wP[_G.NW-1].y=_G.wP[1-1].y-disx;
    // //         }
    

    // //     GameObject p=Get.o2("DRAWPlan","Plan");
    // //     p.SetActive(true);
    // //     UILineRenderer pr=p.transform.GetComponent<UILineRenderer>();
    // //     var pointlist = new List<Vector2>();
        
    // //     for(i=1; i<_G.NW+1; i++){ pointlist.Add(_G.wP[i-1]); }

    // //     if(_G.closingWall==1){_G.endPoint=_G.wP[1-1]; } 
    // //     else  {
    // //         _G.endPoint=new Vector3(_G.wP[_G.NW-1].x+50,_G.wP[_G.NW-1].y,1);
    // //         }
    // //     pointlist.Add(_G.endPoint);   
    // //     pr.Points = pointlist.ToArray();

    // //     for(i=1; i<_G.NW; i++)
    // //     {
    // //         setM("M"+(100+i).ToString(),_G.wP[i-1],_G.wP[i]);
    // //         _G.WallsPointCenter[i-1]=(_G.wP[i-1] + _G.wP[i])/2;
    // //         _G.WallsWidth[i-1] = Vector2.Distance(_G.wP[i-1],_G.wP[i])/2;
    // //     }
         
    // //     _G.WallsWidth[_G.NW-1] = Vector2.Distance(_G.wP[_G.NW-1],_G.wP[1-1])/2;
    // //     _G.WallsPointCenter[_G.NW-1]=(_G.wP[_G.NW-1]+_G.wP[1-1])/2;
        

    // //     for(i=1; i<_G.NW+_G.closingWall; i++){
    // //         Create3D.setMesureNew(Mathf.Abs(_G.WallsWidth[i-1]), "m"+(100+i).ToString());
    // //         }
    // //     RoomSize();
    // //     }
    // public static void RedrawRoomFromScene(){

    //     int i=1;
    //     for(i=1; i<_G.NW; i++){ _G.wD[i-1]=sense(_G.wP[i-1],_G.wP[i]);}
    //     _G.wD[_G.NW-1]=sense(_G.wP[_G.NW-1],_G.wP[1-1]);

    //     _G.wP[1-1].x=-242;
    //     _G.wP[1-1].y=195;

    //     float dis=_G.WallsWidth[1-1]*2;
    //     for(i=1; i<_G.NW+_G.closingWall; i++){
    //         dis=_G.WallsWidth[i-1]*2;
    //         if(_G.wD[i-1]==1){_G.wP[i]=new Vector2(_G.wP[i-1].x+dis,_G.wP[i-1].y);}
    //         if(_G.wD[i-1]==2){_G.wP[i]=new Vector2(_G.wP[i-1].x+dis*0.707f,_G.wP[i-1].y-dis*0.707f);}
    //         if(_G.wD[i-1]==3){_G.wP[i]=new Vector2(_G.wP[i-1].x,_G.wP[i-1].y-dis);}
    //         if(_G.wD[i-1]==4){_G.wP[i]=new Vector2(_G.wP[i-1].x-dis*0.707f,-_G.wP[i-1].y-dis*0.707f);}
    //         if(_G.wD[i-1]==5){_G.wP[i]=new Vector2(_G.wP[i-1].x-dis,_G.wP[i-1].y);}
    //         if(_G.wD[i-1]==6){_G.wP[i]=new Vector2(_G.wP[i-1].x-dis*0.707f,_G.wP[i-1].y+dis*0.707f);}
    //         if(_G.wD[i-1]==7){_G.wP[i]=new Vector2(_G.wP[i-1].x,_G.wP[i-1].y+dis);}
    //         if(_G.wD[i-1]==8){_G.wP[i]=new Vector2(_G.wP[i-1].x+dis*0.707f,_G.wP[i-1].y+dis*0.707f);}
    //     }
    //     if(_G.wD[_G.NW-1]==1){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x-dis,_G.wP[1-1].y);}
    //     if(_G.wD[_G.NW-1]==2){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x-dis*0.707f,_G.wP[1-1].y+dis*0.707f);}
    //     if(_G.wD[_G.NW-1]==3){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x,_G.wP[1-1].y+dis);}
    //     if(_G.wD[_G.NW-1]==4){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x+dis*0.707f,_G.wP[1-1].y+dis*0.707f);}
    //     if(_G.wD[_G.NW-1]==5){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x+dis,_G.wP[1-1].y);}

    //     if(_G.wD[_G.NW-1]==6){
    //             float disx=Mathf.Abs(_G.wP[_G.NW-1].x-_G.wP[1-1].x);
    //             _G.wP[_G.NW-1].y=_G.wP[1-1].y-disx;
    //         }
    //     if(_G.wD[_G.NW-1]==7){_G.wP[_G.NW-1]=new Vector2(_G.wP[1-1].x,_G.wP[_G.NW-1].y);}    
        
    //     if(_G.wD[_G.NW-1]==8){
    //             float disx=Mathf.Abs(_G.wP[_G.NW-1].x-_G.wP[1-1].x);
    //             _G.wP[_G.NW-1].y=_G.wP[1-1].y-disx;
    //         }

    //     GameObject p=Get.o2("DRAWPlan","Plan");
    //     p.SetActive(true);
    //     UILineRenderer pr=p.transform.GetComponent<UILineRenderer>();
    //     var pointlist = new List<Vector2>();
        
    //     for(i=1; i<_G.NW+1; i++){ pointlist.Add(_G.wP[i-1]); }
    //     pointlist.Add(_G.wP[1-1]);     
    //     pr.Points = pointlist.ToArray();

    //     for(i=1; i<_G.NW; i++)
    //     {
    //         setM("M"+(100+i).ToString(),_G.wP[i-1],_G.wP[i]);
    //         _G.WallsPointCenter[i-1]=(_G.wP[i-1] + _G.wP[i])/2;
    //         _G.WallsWidth[i-1] = Vector2.Distance(_G.wP[i-1],_G.wP[i])/2;
    //     }
    //     if(_G.closingWall==1){
    //         setM("M"+(100+_G.NW).ToString(),_G.wP[_G.NW-1],_G.wP[1-1]*1);
    //         _G.WallsWidth[_G.NW-1] = Vector2.Distance(_G.wP[_G.NW-1],_G.wP[1-1])/2;
    //         _G.WallsPointCenter[_G.NW-1]=(_G.wP[_G.NW-1]+_G.wP[1-1])/2;
    //         }

    //     for(i=1; i<_G.NW+_G.closingWall; i++){
    //         Create3D.setMesureNew(Mathf.Abs(_G.WallsWidth[i-1]), "m"+(100+i).ToString());
    //         }
    //     RoomSize();
    //     }

    // //--------------------------------------------------------------------------------------------------------
    // //--------------------------------------------------------------------------------------------------------
    // public static int sense(Vector2 P1,Vector2 P2){
    //     int s=0;
    //     Vector2 dir=(P2-P1).normalized;
    //     if(dir.x>=0.8f && dir.y<=0.3f && dir.y>=-0.3f){s=1;} 
    //     if(dir.x<=0.8f && dir.x>=0.3f && dir.y>=-0.8f && dir.y<=-0.3f){s=2;} 
    //     if(dir.x<=0.3f && dir.x>=-0.3f && dir.y<=-0.8f ){s=3;} 
    //     if(dir.x<=-0.3f && dir.x>=-0.8f && dir.y>=-0.8f && dir.y<=-0.3f ){s=4;} 
    //     if(dir.x<=-0.8f && dir.y<=0.3f && dir.y>=-0.3f ){s=5;} 
    //     if(dir.x<=-0.3f && dir.x>=-0.8f && dir.y<=0.8f && dir.y>=0.3f ){s=6;} 
    //     if(dir.x<=0.3f && dir.x>=-0.3f && dir.y>=0.8f){s=7;} 
    //     if(dir.x<=0.8f && dir.x>=0.3f && dir.y<=0.8f && dir.y>=0.3f ){s=8;} 
    //     return s;
    //   }
    //     float getXY(string xy){
    //     XY=new Vector2(0,0);   
    //     XY = new Vector2(Input.mousePosition.x, Input.mousePosition.y);          
    //     Vector2 localCursor;
    //     var rect1 = Get.o2("DRAWPlan","Planboard").GetComponent<RectTransform>();
    //     var pos1 = XY;
    //     RectTransformUtility.ScreenPointToLocalPointInRectangle(rect1, pos1,null, out localCursor);        
    //     xpos = (float)(localCursor.x);
    //     ypos = (float)(localCursor.y);       
    //     if (xpos < 0) xpos = xpos + (int)rect1.rect.width / 2;
    //     else xpos += (float)rect1.rect.width / 2;       
    //     if (ypos > 0) ypos = ypos + (int)rect1.rect.height / 2;
    //     else ypos += (float)rect1.rect.height / 2;
    //     xpos-=1000/2;
    //     ypos-=300;     
    //     xpos=Mathf.RoundToInt(xpos);
    //     ypos=Mathf.RoundToInt(ypos); 
        
    //     //Debug.Log("Correct Cursor Pos: " + xpos + " " + ypos);
    //     float r=xpos;
    //     if(xy=="y")r=ypos;
    //     return r; 
    //  }
    // void addlines(int Q){
        
    //     GameObject p=Get.o2("DRAWPlan","Plan");
    //     p.SetActive(true);
    //     UILineRenderer pr=p.transform.GetComponent<UILineRenderer>();
    //     var pointlist = new List<Vector2>();
    //     var pointAngle = new List<float>();
    //     int i=1;
    //     for(i=1; i<Q+1; i++){ pointlist.Add(_G.wP[i-1]);  }
    //     if(_G.Open==false){pointlist.Add(_G.wP[1-1]);}  
    //     pr.Points = pointlist.ToArray();
    //     //Calculate the angle between the each two line's points
    //     if (pointlist.Count > 1) { 
    //     for (int j=1;j< pointlist.Count;j++)
    //     { 
            
    //         float AngleRad = Mathf.Atan2(pointlist[j - 1].y - pointlist[j].y, pointlist[j - 1].x - pointlist[j].x);
    //         float AngleDeg = (180 / Mathf.PI) * AngleRad;
    //         pointAngle.Add (AngleDeg);
    //         pr.PointAngle = pointAngle.ToArray();
    //     }
    //     }
    //     for (i=1; i<Q; i++)
    //     {
    //         setM("M"+(100+i).ToString(),_G.wP[i-1],_G.wP[i]);
    //         _G.WallsPointCenter[i-1]=(_G.wP[i-1] + _G.wP[i])/2;
    //         _G.wa[i-1] = getA(  (_G.wP[i]-_G.wP[i-1]).normalized  );
    //         _G.WallsWidth[i-1] = Vector2.Distance(_G.wP[i-1],_G.wP[i])/2;
    //     }
    //     if(_G.Open==false)
    //     {
    //         setM("M"+(100+Q).ToString(),_G.wP[Q-1],_G.wP[1-1]*1);
    //         _G.WallsPointCenter[Q-1]=(_G.wP[Q-1]+_G.wP[1-1])/2;
    //         _G.wa[Q-1]=getA( (_G.wP[1-1]-_G.wP[Q-1]).normalized  );
    //         _G.WallsWidth[Q-1] = Vector2.Distance(_G.wP[Q-1],_G.wP[1-1])/2;
    //     }
    //     if (_G.Open == true)
    //     {
    //         pointlist.Remove(_G.wP[pointlist.Count - 1]);
    //     }
    //  }
    // static void setM(string M,Vector2 p1,Vector2 p2){
    //     if(GameObject.Find(M)) {GameObject.DestroyImmediate(GameObject.Find(M).gameObject);}
    //     GameObject Mesure=(GameObject)Instantiate(Get.o2("HIDER","Mesure"));
    //     Mesure.name=M;
    //     Mesure.SetActive(true);
    //     Mesure.transform.Find("m").name=M.Replace("M","m");
    //     Mesure.transform.SetParent(Get.o2("DRAWPlan","Plan").transform);
    //     Mesure.transform.localPosition=(p1+p2)/2;
    //     int i= int.Parse(M.Substring(1, M.Length-1));
    //     Mesure.transform.Find("no").gameObject.GetComponent<Text>().text=(i-100).ToString();
    //  }
    // void addMesures(int Q)
    //  {
    //     if(_G.Open==false)Q+=1;
    //     for(int i=1; i<Q; i++){
    //         Create3D.setMesureNew(Mathf.Abs(_G.WallsWidth[i-1]), "m"+(100+i).ToString());
    //         }
    //  }
    // float getA(Vector2 d){
    //     float A=0;
    //     d.x= Mathf.Round(d.x * 10f) / 10f;
    //     d.y= Mathf.Round(d.y * 10f) / 10f;
    //     if(d.x==1 && d.y==0.0f)A=0;
    //     if(d.x==0.7f && d.y==-0.7f)A=45;
    //     if(d.x==0.0f && d.y==-1.0f)A=90;
    //     if(d.x==-0.7f && d.y==-0.7f)A=135;
    //     if(d.x==-1.0f && d.y==0.0f)A=180;
    //     if(d.x==-0.7f && d.y==0.7f)A=225;
    //     if(d.x==0.0f && d.y==1.0f)A=270;
    //     if(d.x==0.7f && d.y==0.7f)A=315;
    //     return A;
    //     }    
    // public static void RoomSize(){
    //     //DOIT.get2("DRAWPlan","3D").SetActive(true);
    //     _G.WIDE=0;
    //     float Xmax=_G.wP[1-1].x;
    //     float Xmin=_G.wP[1-1].x;
    //     float Ymax=_G.wP[1-1].y;
    //     float Ymin=_G.wP[1-1].y;
    //     int i;

    //     for(i=1; i<_G.NW+1; i++){
    //             if(_G.wP[i-1].x<Xmin)Xmin=_G.wP[i-1].x;
    //             if(_G.wP[i-1].x>Xmax)Xmax=_G.wP[i-1].x;
    //             if(_G.wP[i-1].y<Ymin)Ymin=_G.wP[i-1].y;
    //             if(_G.wP[i-1].y>Ymax)Ymax=_G.wP[i-1].y;
    //         }
   
    //     Vector2 RC=new Vector2(Xmin, Ymax);
    //     Vector2 offset=new Vector2(RC.x+Xmax/2-Xmin/2, RC.y-Ymax/2+Ymin/2);

    //     for(i=1; i<_G.NW+1; i++){
    //         _G.wP[i-1]=_G.wP[i-1]-offset;
    //         _G.wP[i-1].x=_G.wP[i-1].x/2;
    //         _G.wP[i-1].y=_G.wP[i-1].y/2;
    //      }
    //     for(i=1; i<_G.NW+1; i++){
    //         //print("i===="+i);
    //         _G.WallsPointCenter[i-1]=(_G.wP[i-1] + _G.wP[i])/2;
    //         _G.WallsWidth[i-1] = Vector2.Distance(_G.wP[i-1],_G.wP[i]);
    //         }
    //     Xmax=0;
    //     Xmin=0;
    //     Ymax=0;
    //     Ymin=0;
    //     for(i=1; i<_G.NW+1; i++){
    //             if(_G.wP[i-1].x<Xmin)Xmin=_G.wP[i-1].x;
    //             if(_G.wP[i-1].x>Xmax)Xmax=_G.wP[i-1].x;
    //             if(_G.wP[i-1].y<Ymin)Ymin=_G.wP[i-1].y;
    //             if(_G.wP[i-1].y>Ymax)Ymax=_G.wP[i-1].y;
    //         }

    //     _G.WallsPointCenter[_G.NW-1]=(_G.wP[_G.NW-1] + _G.wP[1-1])/2;
    //     _G.WallsWidth[_G.NW-1] = Vector2.Distance(_G.wP[_G.NW-1],_G.wP[1-1]);

    //     for(i=1; i<_G.NW; i++){
    //             _G.wD[i-1]=sense(_G.wP[i-1],_G.wP[i]);
    //         }
    //     _G.wD[_G.NW-1]=sense(_G.wP[_G.NW-1],_G.wP[1-1]);

    //     _G.WIDE=Xmax-Xmin;
    //     _G.DEPTH=Ymax-Ymin;
        
    //     Measure.okShow("DRAWPlan", "FINISH", true);
    //  }
}