/*
// BEGIN__HARVEST_EXCEPTION_ZSTRING

Fotofuze...
filter
6F17BFA7-EFC9-11EA-B960-7B96ED7EA713
 in (PSHOP_ImageMode, RGBMode, CMYKMode, HSLMode, HSBMode, LabMode, RGB48Mode)  && (PSHOP_IsTargetVisible  &&  ! PSHOP_IsTargetSection)
filter

// END__HARVEST_EXCEPTION_ZSTRING
*/


#target photoshop

app.bringToFront();
 
/////////////////////////
// SETUP
/////////////////////////

var inputURL = "";
var requesthtml = "";
var redirectURL = "";
var fotofuzeDomain = "fotofuze.com";
var username = "";
var password = "";
var cookieFile= new File("~/Desktop/FotofuzeCookie.txt"); 
var cookieContents = {};
var now = new Date();
var monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
var dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
var timeOutRequests = 0;
    

if(app.documents.length == 0) { 
    alert("No Document Actively Open");
    }


/////////////////////////
// FUNCTIONS
/////////////////////////



////////////////////////////////////////////////
// GENERATE A RANDOM NAME FOR TEMPORARY FILES 
////////////////////////////////////////////////
function generateRandomName(){
    var docName = app.activeDocument.name.replace(/\.[^\.]+$/, '');
    var randomNumber = Math.floor((Math.random() * 100) + 1);
    var randomlyGeneratedName = docName + randomNumber;
    return randomlyGeneratedName;
};



///////////////////////////////////////////////
// CONSTRUCT CURRENT DATE INTO HEADER FORMAT 
///////////////////////////////////////////////
function constructCurrentDate(monthInteger_and_fullYearFlag){
    if(monthInteger_and_fullYearFlag == undefined || !monthInteger_and_fullYearFlag || monthInteger_and_fullYearFlag == false){
        var currentDate = dayNames[now.getDay()] + ", " + now.getDate() + "-" + monthNames[now.getMonth()] + "-" + String(now.getFullYear()).substr(2,2) + " " +                         now.getHours()+":"+now.getMinutes()+":"+now.getSeconds() + " GMT";    
    }
    else{
        var currentDate = dayNames[now.getDay()] + ", " + now.getDate() + "-" + now.getMonth() + "-" + now.getFullYear() + " " +                                                      now.getHours()+":"+now.getMinutes()+":"+now.getSeconds() + " GMT";    
    }
    
    return currentDate;
};



///////////////////////////////////////////////
// READ COOKIE FILE INTO COOKIE CONTENTS 
///////////////////////////////////////////////
function readCookieFile(){
    
    var cookieCache = "";
    cookieFile.open('r');
    cookieCache = cookieFile.read();
    cookieFile.close();

    parseCookie(cookieCache, cookieContents);        
}



///////////////////////////
// PARSE RECIEVED COOKIE 
///////////////////////////
function parseCookie(binary, cookieTarget){
    
    var headerEnd = binary.indexOf("\n\n");
    headerEnd = headerEnd == -1? binary.length: headerEnd; 
    
    var header = binary.substr(0,headerEnd);
    
    //if(header.indexOf(fotofuzeDomain) > -1){ //make sure header comes from Fotofuze
        
        var headerElements = header.split("\n");
        
        for (var i = 0; i < headerElements.length; i++){
            var token = headerElements[i];

            if (token.indexOf("Set-Cookie: ") == 0){
                var cookieToAdd = parseHeaderObject(token, "Set-Cookie: ");
                var cookieValuePosition = cookieToAdd.indexOf("=");
                var cookieKey = cookieToAdd.substr(0, cookieValuePosition);
                var cookieValue = cookieToAdd.substr(cookieValuePosition);
                cookieTarget[cookieKey] = cookieValue;
            }  
        }
    //}
};



////////////////////////////////////////////////
// ITERATE THROUGH COOKIES TO CHECK EXPIRATION
////////////////////////////////////////////////
function iterateThroughCookiesForExpirations(){
    
    var expiredFlag = 0;
    
    for (var cookie in cookieContents) {
        if( cookieContents.hasOwnProperty(cookie) ){
            expiredFlag += checkCookieExpiration(cookie);
        } 
    }
    
    if (expiredFlag > 0){
        writeCookieFile();
    }
}



///////////////////////////////////////////////
// COMPARE COOKIE EXPIRATION TO CURRENT DATE 
///////////////////////////////////////////////
function checkCookieExpiration(Cookie){

    var cookieExpiration = parseHeaderObject(cookieContents[Cookie], "expires=");
    cookieExpiration = cookieExpiration.substr(5,11);
    cookieExpiration = cookieExpiration.replace(/[`~!@#$%^&*()_|+\-=?;:'",.<>\{\}\[\]\\\/]/gi, ' ');
    
    var cookieDate = new Date(cookieExpiration).getTime();
    var currentDate = new Date().getTime();

    if(currentDate > cookieDate){
        delete cookieContents[Cookie];
        return 1;
    } else {return 0;}

};



///////////////////////////////
// WRITE COOKIE INFO TO FILE 
///////////////////////////////
function writeCookieFile(){
    
    var finalCookies = "";

    for (var cookie in cookieContents) {
        if( cookieContents.hasOwnProperty(cookie) ){       
            finalCookies += "Set-Cookie: " + cookie + cookieContents[cookie] + "\n";  
        } 
    }
    
    cookieFile.open('w');
    cookieFile.encoding = "UTF-8";
    cookieFile.lineFeed = "Unix";
    cookieFile.writeln(finalCookies);
    cookieFile.close();
};



/////////////////////////////////////
// CONSTRUCT A COOKIE FOR POSTS 
/////////////////////////////////////
function constructCookie(){
    
    var cookieString = "";
    
    for (var cookie in cookieContents) {
        if( cookieContents.hasOwnProperty(cookie) ){
            cookieString += "Set-Cookie: " + cookie + cookieContents[cookie] + "\n";
        }
    }
    
    return cookieString;
};



/////////////////////////////////
// PARSE SPECIFIED HEADER DATA 
/////////////////////////////////
function parseHeaderObject(headerObject, Tag, dataEndTag){
    
    var Position = headerObject.indexOf(Tag) + Tag.length; 
    var Length;
    
    if (!dataEndTag || dataEndTag == undefined){
        Length = headerObject.length - Position;
    }else{Length = headerObject.indexOf(dataEndTag, Position) - Position;}

    var Data = headerObject.substr(Position, Length); 

    if(Data.charCodeAt(Data.length-1) == 13)
    {
        Data = Data.substr(0,Data.length - 1);   
    }
    
    return Data;
}



/////////////////////////////////////
// CONSTRUCT A HEADER FOR REQUESTS 
/////////////////////////////////////
function constructHeader(method, targetPath, attachedCookie, postLength){
    
    var OriginAndContent=   "\nUser-Agent: Photoshop" + 
                            "\nContent-Type: application/x-www-form-urlencoded" + 
                            "\nContent-Length: " + postLength +
                            "\nAccept: text/plain, text/html */*";
                            
    var theDate = "\nDate: " + constructCurrentDate();
    
    return  method + " " + 
            targetPath + " HTTP/1.0" +
            "\nHost: " + fotofuzeDomain +
            OriginAndContent + 
            attachedCookie + 
            theDate +
            "\n\n";
};



////////////
// LOG-IN 
////////////
function logIn(){
    username = prompt("Please Enter your Fotofuze Username: ","Zephir62@Gmail.com");  
    var usernameEncoded = encodeURIComponent(username);
    password = prompt("Please Enter your Fotofuze Password for " + username + ": ","ZEPHZEPH");
    var passwordEncoded = encodeURIComponent(password);
    var loginURL = "/auth/login?" + "user=" + usernameEncoded + "&pass=" + passwordEncoded;
    
    Get(fotofuzeDomain, loginURL);
};



////////////////////////////
// POST REQUEST TO SERVER 
////////////////////////////
function Post(domain, targetPath, attachedCookie, postBody){
    
    var port = ":80";
    var socket = new Socket;
    //socket.timeout = 3;
    
    if(postBody == undefined || !postBody){
        postBody = "";
    }
    
    if(attachedCookie == undefined || !attachedCookie){
        attachedCookie = "";
    } 
    
    var Header = constructHeader("POST", targetPath, attachedCookie, postBody.length);
    
    var post = Header + postBody;
    
    alert("Post: " + post);
    
    if (socket.open(domain + port, "binary")){
        socket.write(post); // get the file
        var binary = socket.read(99999999);

        socket.close(); 
        
        if(domain == fotofuzeDomain){
            parseCookie(binary, cookieContents);
            writeCookieFile();
        }
    }
};



///////////////////////////
// GET REQUEST TO SERVER 
///////////////////////////
function Get(domain, targetPath, attachedCookie){
    
    var port = ":80";
    var socket = new Socket;
    //socket.timeout = 3;
    
    var postBody = "";
    
    if(attachedCookie == undefined || !attachedCookie){
        attachedCookie = "";
    }
    
    var Header = constructHeader("GET", targetPath, attachedCookie, postBody.length);
    
    var get = Header;
    
    alert("Get: " + get);
    
    if (socket.open(domain + port, "binary")){
        socket.write(get); // get the file
        var binary = socket.read(99999999);

        socket.close(); 
        
        if(domain == fotofuzeDomain){
            parseCookie(binary, cookieContents);
            writeCookieFile();
        }
        
        //return binary;
    }
};



/////////////////////////////////////////
// SAVE CURRENT DOCUMENT TO A PNG FILE 
/////////////////////////////////////////
function saveDocument(){
    var outputFolder = Folder.selectDialog("Select a folder for the output files");
    var randomName = generateRandomName();
    var outputFile = new File(outputFolder + "/" + randomName + ".png"); //"~/Desktop/"
    var currentLayer = activeDocument.activeLayer;
    
    var pngSaveOptions = new PNGSaveOptions();
    pngSaveOptions.interlaced = false;
    pngSaveOptions.compression = 9;
    pngSaveOptions.transparency = false;
    pngSaveOptions.PNG8 = false;
    pngSaveOptions.includeProfile = false;
    
    activeDocument.saveAs(outputFile, pngSaveOptions, true);
    
    //outputFile.remove();
    return outputFile; // SHOULD WE RETURN THE OUTPUT FILE?
};



/////////////////////////////////////////
// ASK FOTOFUZE IF IT HAS FINISHED YET 
/////////////////////////////////////////
function checkProgress(){
    $.sleep(5000);
    var success = Get(fotofuzeDomain, "targetPath", constructCookie());
    timeOutRequests += 1;
    if(success){
        //DO STUFF
    } else {checkProgress();}
};



///////////////////////////
// GET IMAGE FROM SERVER 
///////////////////////////
function getImage(url){
    
    var html = "";
    var request = "";
    var binary = "";
    var socket = new Socket;
    var http = "http://";
    var domain = "" // the domain for the file we want
    var sImg = ""; // the rest of the url for the file we want
    var port = ":80"; // the port for the file we want

    
    
    // Check for Redirects
    function checkRedirect(binary){
       if (binary.indexOf("Location: ") > 1){
            redirectURL = parseHeaderObject(binary, "Location: ");
            return true;
        } else { return false; } 
    };
    
    

    // Remove header lines from HTTP response
    function removeHeaders(binary){
        var bContinue = true ; // flag for finding end of header
        var line = "";
        var httpheader = "";
        var nFirst = 0;
        var count = 0;
        while (bContinue) {
            line = getLine(binary) ; // each header line
            httpheader = httpheader + line;
            bContinue = line.length >= 2 ; // blank header == end of header
            nFirst = line.length + 1 ;
            binary = binary.substr(nFirst) ;
        }
        if (httpheader.indexOf("Bad Request") != -1 || httpheader.indexOf("Not Found") != -1) {
            alert ("RequestHTML: " + requesthtml + " Request: " + request + " HTTPHeader: " + httpheader);
            var binary = "";
        }
        return binary;
    };



    // Get a response line from the HTML
    function getLine(html){
        var line = "" ;
        for (var i = 0; html.charCodeAt(i) != 10; i++){ // finding line end
            line += html[i] ;
        }
        return line ;
    };    

    
    
    // Place image into Photoshop Layer
    function placeImage(fileRef){
        //create a new smart object  layer using a file
        try { 
            var desc = new ActionDescriptor();
            desc.putPath( charIDToTypeID( "null" ), new File( fileRef ) );
            desc.putEnumerated( charIDToTypeID( "FTcs" ), charIDToTypeID( "QCSt" ), charIDToTypeID( "Qcsa" ) );
            desc.putBoolean( charIDToTypeID( "Lnkd" ), true );
            executeAction( charIDToTypeID( "Plc " ), desc, DialogModes.NO );
            
            activeDocument.activeLayer.merge(); //merge new layer with the one below it
            
        } catch (e) { alert("Placeing file: '" + fileRef + "' failed" + e); }
    };    


 
/////////////////////////
// MAIN
/////////////////////////

    if (url != null && url != ""){

        if ( (url.indexOf(http) != -1)  || (url.indexOf(http.toUpperCase()) != -1)  ) {

            domainPathLength = url.length - http.length; 
            domainPath = url.substr(http.length, domainPathLength);
            pathOffset = domainPath.indexOf("/"); 
            domain = domainPath.substr(0, pathOffset);
            sImgPath = domainPath.substr(pathOffset, domainPath.length - pathOffset );
            
            
            if ( domain != "" && sImgPath != "" && sImgPath != "/" ) {  //&& Name.indexOf(".") != -1
                
                
                var theDate = "\nDate: " + constructCurrentDate();
                requesthtml ="\n\nDmain:" + domain + " Port" + port + " binary\n";
                request =   "GET " + 
                            sImgPath +" HTTP/1.0" +
                            "\nHost: " + domain + 
                            "\nAccept: image/gif, image/x-xbitmap, image/png, image/jpeg, */*" + 
                            theDate + 
                            "\nUser-Agent: Photoshop" + 
                            "\nContent-Type: application/x-www-form-urlencoded" + 
                            "\n\n";

                if (socket.open(domain + port, "binary")){

                    socket.write(request); // get the file
                    var binary = socket.read(99999999);

                    socket.close();
                    
                    if(domain == fotofuzeDomain){
                        parseCookie(binary, cookieContents); // DO WE NEED TO RE-WRITE COOKIE?
                        writeCookieFile();
                    }
                    
                    if (checkRedirect(binary) == true){
                        return;
                    }
                    
                    
                    var randomName = generateRandomName();
                    var fileExtension = sImgPath;
                    while (fileExtension.indexOf(".") != -1 ) {	// Strip Path
                        fileExtension = fileExtension.substr(fileExtension.indexOf(".") + 1 ,);		
                    }
                    
                    var f = File("~/" + randomName + "." + fileExtension); // Image file name
                    f.encoding = "binary"; // set binary mode
                    f.open("w");

                    binary = removeHeaders(binary);
                    f.write(binary);
                    f.close();

                    if (binary.length != 0) {
                        placeImage( f );
                    } 

                    f.remove(); // Remove temporary downloaded files

                    } else { alert("Connection to Domain:" + domain + " Port" + port + " Failed   " + url);}


            } else { alert("Invalid Image URL: " + url ); }


        } else { alert("Invalid URL: " + url ); }


    } else { if ( url == "" ) alert("No URL Entered"); }
    
};

// This script will create a new Isometric Grid of various dimensions on it's own art layer.
// 
// Author: Matt Olick 
// Version: 1.0.1
// Date: April 2020
// Homepage: http://www.mattOlick.com/
//
// This script is released under the GPLv3 Software License. You are free to use it for free or commercial purposes.
// If you make any modifications or improvements to this script, please do share them back with us.

/*
// BEGIN__HARVEST_EXCEPTION_ZSTRING

Isometric Grid Generator
filter
6F17BFA7-EFC9-11EA-B960-7B96ED7EA770
 in (PSHOP_ImageMode, RGBMode, CMYKMode, HSLMode, HSBMode, LabMode, RGB48Mode)  && (PSHOP_IsTargetVisible  &&  ! PSHOP_IsTargetSection)
filter

// END__HARVEST_EXCEPTION_ZSTRING
*/


#target photoshop

app.bringToFront();
 
/////////////////////////
// SETUP
/////////////////////////
const ScriptTitle = "Isometric Grid Generator";

const UserOptionsKey = "isoGridGen_UserOptions";

const UserOptionsWidthKey = "gridWidthSize";
const UserOptionsHeightKey = "gridHeightSize";
const UserOptionsResizeKey = "matchGridResize";

function Ruler_savePrefs()
{
    prevRulerUnits = app.preferences.rulerUnits;
}
function Ruler_setPixels()
{
    app.preferences.rulerUnits = Units.PIXELS;
}
function Ruler_setPoints()
{
    app.preferences.rulerUnits = Units.POINTS;
}
function Ruler_returnPrefs()
{
    app.preferences.rulerUnits = prevRulerUnits;
}  


/////////////////////////
// MAIN
/////////////////////////

if(app.documents.length == 0) { 
    alert("No Document Actively Open");
    }

else{
    main();
}

function main()
{   
    Ruler_savePrefs();
    
     // Get the user's input options
    var userOptions = getUserOptions();
    
    if ( userOptions == false ) { 
        return;
    }
    
    var srcDoc = app.activeDocument;
    
    // Make sure to match ppi to 72, to match Points Ruler
    if(srcDoc.resolution != 72) { srcDoc.resizeImage(undefined, undefined, 72, ResampleMethod.NONE); }
    
    var targetLayer = srcDoc.artLayers.add();
    
    Ruler_setPixels();
    gridWidth = userOptions[UserOptionsWidthKey];
    gridHeight = userOptions[UserOptionsHeightKey];
    Canvas_setSize(srcDoc);
    
    Ruler_setPoints();
    //gridWidth = userOptions[UserOptionsWidthKey]*(72/srcDoc.resolution);
    //gridHeight = userOptions[UserOptionsHeightKey]*(72/srcDoc.resolution);
    createGrid(srcDoc, targetLayer);
    
    if(userOptions[UserOptionsResizeKey] == true)
    {
        Ruler_setPixels();
        Canvas_returnSize(srcDoc);
    }
    
    Ruler_returnPrefs();
}


function Canvas_setSize(srcDoc)
{
    prevWidth = srcDoc.width;
    prevHeight = srcDoc.height;
    
    var newWidth = prevWidth;
    var newHeight = prevHeight;
    
    var remainderWidth = parseInt( srcDoc.width % gridWidth );
    var remainderHeight = parseInt( srcDoc.height % gridHeight );
    
    if(remainderWidth > 0)
    { newWidth += gridWidth - remainderWidth; }
    
    if(remainderHeight > 0)
    { newHeight += gridHeight - remainderHeight; }

    srcDoc.resizeCanvas( UnitValue(newWidth,"px"), UnitValue(newHeight,"px") );
}

function Canvas_returnSize(srcDoc)
{
    srcDoc.resizeCanvas( UnitValue(prevWidth,"px"), UnitValue(prevHeight,"px") );
}



/////////////////////////
// USER OPTIONS
/////////////////////////

function putActionDescValue(desc, method, key, value)
{
    if ( key == undefined || value == undefined ) {
        return;
    }

    desc[method](app.stringIDToTypeID(key), value);
}

function getActionDescValue(desc, method, key, defaultValue)
{
    if ( desc.hasKey(app.stringIDToTypeID(key)) ) {
        return desc[method](app.stringIDToTypeID(key)); 
    } 

    return defaultValue;
}



function storeLastUserOptions(userOptions)
{
    var desc = new ActionDescriptor();
    
    putActionDescValue(desc, "putInteger", UserOptionsWidthKey, userOptions[UserOptionsWidthKey]);
    putActionDescValue(desc, "putInteger", UserOptionsHeightKey, userOptions[UserOptionsHeightKey]);
    putActionDescValue(desc, "putBoolean", UserOptionsResizeKey, userOptions[UserOptionsResizeKey]);

    app.putCustomOptions( UserOptionsKey, desc, true );
}


function retrieveLastUserOptions()
{
    try { 
        var desc = app.getCustomOptions(UserOptionsKey);
    } catch( e ) { return { }; }
    
    var result = { };
    
    result[UserOptionsWidthKey] = getActionDescValue(desc, "getInteger", UserOptionsWidthKey, 0);  
    result[UserOptionsHeightKey] = getActionDescValue(desc, "getInteger", UserOptionsHeightKey, 0); 
    result[UserOptionsResizeKey] = getActionDescValue(desc, "getBoolean", UserOptionsResizeKey, false); 
    
    return result;
}

function indexOf(array, obj)
{
    for( var i = 0; i < array.length; ++i ) 
    {
        if ( array[i] == obj ) {
            return i;
        }
    }

    return -1;
}


function getUserOptions()
{
    var lastUserOptions = retrieveLastUserOptions();
    
    var sizeItems = [8, 16, 32, 64, 128, 256, 512];
    var sizeItemsStrings = ["8", "16", "32", "64", "128", "256", "512"];
    
    var dlg = new Window('dialog', ScriptTitle);
    
    dlg.widthSizeGrp = dlg.add('group', undefined, );
    dlg.widthSizeGrp.orientation = "row";
    dlg.widthSizeGrp.alignment = 'left';
    dlg.widthSizeGrp.dropDownWidthSize = dlg.widthSizeGrp.add('DropDownList', undefined, sizeItemsStrings);
    dlg.widthSizeGrp.dropDownWidthSize.text = "Width Size: ";
    dlg.widthSizeGrp.dropDownWidthSize.selection = 0;
    
    dlg.heightSizeGrp = dlg.add('group', undefined, );
    dlg.heightSizeGrp.orientation = "row";
    dlg.heightSizeGrp.alignment = 'left';
    dlg.heightSizeGrp.dropDownHeightSize = dlg.heightSizeGrp.add('DropDownList', undefined, sizeItemsStrings);
    dlg.heightSizeGrp.dropDownHeightSize.text = "Height Size: ";
    dlg.heightSizeGrp.dropDownHeightSize.selection = 0;
    
    dlg.resizeGrp = dlg.add('group');
    dlg.resizeGrp.orientation = 'row';
    dlg.resizeGrp.alignment = 'left';
    dlg.resizeGrp.resizeCheck = dlg.resizeGrp.add('CheckBox', undefined, "Return Canvas to Non-Grid Size?");
    
    dlg.buttonGrp = dlg.add('group');
    dlg.buttonGrp.okButton = dlg.buttonGrp.add('button', undefined, 'OK');
    dlg.buttonGrp.cancelButton = dlg.buttonGrp.add('button', undefined, 'Cancel');
        
    
    // Before presenting, update from user options (if applicable)
    if ( lastUserOptions[UserOptionsWidthKey] > 0 ) 
    { 
        dlg.widthSizeGrp.dropDownWidthSize.selection = indexOf(sizeItems, lastUserOptions[UserOptionsWidthKey]); 
    }
    
    if ( lastUserOptions[UserOptionsHeightKey] > 0 ) 
    { 
        dlg.heightSizeGrp.dropDownHeightSize.selection = indexOf(sizeItems, lastUserOptions[UserOptionsHeightKey]); 
    }
    if ( lastUserOptions[UserOptionsResizeKey] !== undefined ) 
    { 
        dlg.resizeGrp.resizeCheck.value = lastUserOptions[UserOptionsResizeKey]; 
    }
        
        
    dlg.center();
    var dlgResult = dlg.show(); // 1 = ok, 2 = cancel
    
    
    // Note: .selection as a string is the value in the drop down, as an int it's the item's index!
    var userOptions = { };
    userOptions[UserOptionsWidthKey] = parseInt(sizeItems[parseInt(dlg.widthSizeGrp.dropDownWidthSize.selection)]);
    userOptions[UserOptionsHeightKey] = parseInt(sizeItems[parseInt(dlg.heightSizeGrp.dropDownHeightSize.selection)]);
    userOptions[UserOptionsResizeKey] = dlg.resizeGrp.resizeCheck.value;
    
    storeLastUserOptions(userOptions);
    
    if ( dlgResult == 2 ) {
        return false;
    }    

    return userOptions;
}






/////////////////////////
// LOGIC
/////////////////////////


function createGrid(srcDoc, targetLayer)
{
    //Photoshop counts from Top-Left corner

    var totalX_iterations = (srcDoc.width - gridWidth) / gridWidth;
    var totalY_iterations = (srcDoc.height - gridHeight) / gridHeight;
    
    var gridBegin_x = gridWidth/2;
    var gridBegin_y = gridHeight/2;
    
    
    //left -- bottom to top -- downslope
    for(var y = totalY_iterations; y>= 0;y--)
    {
        var startX = parseInt(0);
        var startY = parseInt(gridBegin_y + gridHeight*y);

        var endX = parseInt(gridBegin_x + gridWidth*(totalY_iterations-y));
        var endY = parseInt(srcDoc.height);

        drawLine(   startX, 
                    startY, 
                    endX, 
                    endY, srcDoc);
    }
    
    //top -- left to right -- downslope
    for(var x = 0; x<= totalX_iterations;x++)
    {
        var startX = parseInt(gridBegin_x + gridWidth*x);
        var startY = parseInt(0);

        var endX = parseInt(gridBegin_x + (totalY_iterations+1 + x)*gridWidth);
        var endY = parseInt(srcDoc.height);

        drawLine(   startX, 
                    startY, 
                    endX, 
                    endY, srcDoc);
    }
    
    
    //left -- top to bottom -- upslope
    for(var y = 0; y<= totalY_iterations;y++)
    {
        var startX = parseInt(0);
        var startY = parseInt(gridBegin_y + gridHeight*y);

        var endX = parseInt(gridBegin_x + gridWidth*y);
        var endY = parseInt(0);

        drawLine(   startX, 
                    startY, 
                    endX, 
                    endY, srcDoc);
    }
    
    //bottom -- left to right -- upslope
    for(var x = 0; x<= totalX_iterations;x++)
    {
        var startX = parseInt(gridBegin_x + gridWidth*x);
        var startY = parseInt(srcDoc.height);

        var endX = parseInt(gridBegin_x + (totalY_iterations+1 + x)*gridWidth);
        var endY = parseInt(0);

        drawLine(   startX, 
                    startY, 
                    endX, 
                    endY, srcDoc);
    }
}


function drawLine(startX, startY, endX, endY, srcDoc)
{
    //alert("sX " + startX + "sY " + startY + "eX " + endX + "eY " + endY );

    var startPoint = new PathPointInfo();
    startPoint.kind = PointKind.CORNERPOINT;
    startPoint.anchor = [startX, startY];
    startPoint.leftDirection = startPoint.anchor;
    startPoint.rightDirection = startPoint.anchor;
    
    var endPoint = new PathPointInfo();
    endPoint.kind = PointKind.CORNERPOINT;
    endPoint.anchor = [endX, endY];
    endPoint.leftDirection = endPoint.anchor;
    endPoint.rightDirection = endPoint.anchor;
    
    var lineSubPath = new SubPathInfo();
    lineSubPath.operation = ShapeOperation.SHAPEXOR;
    lineSubPath.closed = false;
    lineSubPath.entireSubPath = [startPoint, endPoint];
    
    var gridLine = srcDoc.pathItems.add("GridLine", [lineSubPath]);
    
    srcDoc.pathItems[0].subPathItems[0].pathPoints[0].anchor = [0, 0];
    //alert(lineSubPath.entireSubPath[0].anchor);
    //alert(gridLine.subPathItems[0].pathPoints[0].anchor);
    
    gridLine.strokePath(ToolType.PENCIL);
    
    gridLine.remove();
}

// This script will export a texture atlas as a new document given either a set of documents or a layered document.
// 
// Author: Matt Olick 
// Version: 1.0.2
// Date: June 2018
// Homepage: http://www.mattOlick.com/
//
// This script is released under the GPLv3 Software License. You are free to use it for free or commercial purposes.
// If you make any modifications or improvements to this script, please do share them back with us.

/*
// BEGIN__HARVEST_EXCEPTION_ZSTRING

Texture Atlas Generator
filter
6F17BFA7-EFC9-11EA-B960-7B96ED7EA769
 in (PSHOP_ImageMode, RGBMode, CMYKMode, HSLMode, HSBMode, LabMode, RGB48Mode)  && (PSHOP_IsTargetVisible  &&  ! PSHOP_IsTargetSection)
filter

// END__HARVEST_EXCEPTION_ZSTRING
*/


#target photoshop

app.bringToFront();
 
/////////////////////////
// SETUP
/////////////////////////
const ScriptTitle = "Texture Atlas Generator";

const UserOptionsKey = "texAtlasGen_UserOptions";
const UserOptionsDocNameKey = "documentName";
const UserOptionsSourceKey = "Current Document Layers";

const UserOptionsLayerSetKey = "layerSetIndex";

const UserOptionsResizeKey = "mipMapping";

const UserOptionsSourceAllDocs = 0;
const UserOptionsSourceDocument = 1;
const UserOptionsSourceLayerSet = 2;
const UserOptionsSourceFrameAnim = 3;

function Ruler_setPixels()
{
    prevRulerUnits = app.preferences.rulerUnits;
    app.preferences.rulerUnits = Units.PIXELS;
}
function Ruler_returnPrefs()
{
    app.preferences.rulerUnits = prevRulerUnits;
}  


/////////////////////////
// MAIN
/////////////////////////

if(app.documents.length == 0) { 
    alert("No Document Actively Open");
    }

else{
    main();
}

function main()
{
    Ruler_setPixels();
    
    var srcDoc = app.activeDocument;
    
    // Fix for broken resolution images
    if(srcDoc.resolution != 72) { srcDoc.resizeImage(undefined, undefined, 72, ResampleMethod.NONE); }
    
     // Get the user's input options
    var userOptions = getUserOptions();
    
    if ( userOptions == false ) { 
        return;
    }
    
    var destDoc = createDestDoc(userOptions, srcDoc);
    
    returnAllCanvasSizes(destDoc);
    
    //Remove white base layer created with new documents
    app.activeDocument = destDoc;
    destDoc.layers[destDoc.layers.length-1].remove();
    
    layoutLayersAsSprites(destDoc, userOptions);
    
    Ruler_returnPrefs();
}



/////////////////////////
// USER OPTIONS
/////////////////////////

function putActionDescValue(desc, method, key, value)
{
    if ( key == undefined || value == undefined ) {
        return;
    }

    desc[method](app.stringIDToTypeID(key), value);
}

function getActionDescValue(desc, method, key, defaultValue)
{
    if ( desc.hasKey(app.stringIDToTypeID(key)) ) {
        return desc[method](app.stringIDToTypeID(key)); 
    } 

    return defaultValue;
}



function storeLastUserOptions(userOptions)
{
    var desc = new ActionDescriptor();
    
    putActionDescValue(desc, "putString", UserOptionsDocNameKey, userOptions[UserOptionsDocNameKey]);
    putActionDescValue(desc, "putInteger", UserOptionsSourceKey, userOptions[UserOptionsSourceKey]);
    putActionDescValue(desc, "putInteger", UserOptionsLayerSetKey, userOptions[UserOptionsLayerSetKey]);
    putActionDescValue(desc, "putBoolean", UserOptionsResizeKey, userOptions[UserOptionsResizeKey]);
    
    app.putCustomOptions( UserOptionsKey, desc, true );
}


function retrieveLastUserOptions()
{
    try { 
        var desc = app.getCustomOptions(UserOptionsKey);
    } catch( e ) { return { }; }
    
    var result = { };
    
    result[UserOptionsDocNameKey] = getActionDescValue(desc, "getString", UserOptionsDocNameKey, "");
    result[UserOptionsSourceKey] = getActionDescValue(desc, "getInteger", UserOptionsSourceKey, 0);        
    result[UserOptionsLayerSetKey] = getActionDescValue(desc, "getInteger", UserOptionsLayerSetKey, 0);   
    result[UserOptionsResizeKey] = getActionDescValue(desc, "getBoolean", UserOptionsResizeKey, false); 
    
    return result;
}


function getUserOptions()
{
    var lastUserOptions = retrieveLastUserOptions();
    
    var sourceItems = ["All Open Documents", "Current Document Layers", "Specific Layer Group", "Frame Animation"];
    var layerSetItems = [];
    var documentItems = [];

    for( i = 0; i < app.activeDocument.layerSets.length; i++ ) {
        var layerSet = app.activeDocument.layerSets[i];
        layerSetItems[layerSetItems.length] = layerSet.name;
    }
    
    for( i = 0; i < app.documents.length; i++ ) {
        var documentSet = app.documents[i];
        documentItems[documentItems.length] = documentSet.name;
    }

    if ( layerSetItems.length == 0 ) { layerSetItems[0] = "No Layer Groups Available"; }
    if ( documentItems.length == 0 ) { documentItems[0] = "No Documents Available"; }
    
    var dlg = new Window('dialog', ScriptTitle);
    
    dlg.sourceGrp = dlg.add('group', undefined);
    dlg.sourceGrp.orientation = "column";
    dlg.sourceGrp.alignment = "left";    
    dlg.sourceGrp.dropDownSource = dlg.sourceGrp.add('DropDownList', undefined, sourceItems);
    dlg.sourceGrp.dropDownSource.text = "Source: ";
    dlg.sourceGrp.dropDownSource.selection = 0;
    dlg.sourceGrp.dropDownSource.onChange = function() { 
        userOptionsDlg_updateControls(dlg);
    };
   
    dlg.sourceGrp.dropDownLayerSet = dlg.sourceGrp.add('DropDownList', undefined, layerSetItems);
    dlg.sourceGrp.dropDownLayerSet.text = "Layer Group: ";
    dlg.sourceGrp.dropDownLayerSet.selection = 0;
    
    
    dlg.resizeGrp = dlg.add('group');
    dlg.resizeGrp.orientation = 'row';
    dlg.resizeGrp.alignment = 'left';
    dlg.resizeGrp.resizeCheck = dlg.resizeGrp.add('CheckBox', undefined, "Use Powers of 2 for MipMapping?");
    
    
    dlg.buttonGrp = dlg.add('group');
    dlg.buttonGrp.okButton = dlg.buttonGrp.add('button', undefined, 'OK');
    dlg.buttonGrp.cancelButton = dlg.buttonGrp.add('button', undefined, 'Cancel');
        
    
    // Before presenting, update from user options (if applicable)
    if ( lastUserOptions[UserOptionsSourceKey] > 0 ) { dlg.sourceGrp.dropDownSource.selection = lastUserOptions[UserOptionsSourceKey]; }
    
    if ( (lastUserOptions[UserOptionsDocNameKey] == app.activeDocument.name) && (lastUserOptions[UserOptionsLayerSetKey] < app.activeDocument.layerSets.length) ) {
        dlg.sourceGrp.dropDownLayerSet.selection = lastUserOptions[UserOptionsLayerSetKey];
    }
    
    if ( lastUserOptions[UserOptionsResizeKey] !== undefined ) 
    { 
        dlg.resizeGrp.resizeCheck.value = lastUserOptions[UserOptionsResizeKey]; 
    }
        
    userOptionsDlg_updateControls(dlg); 
    dlg.center();
    var dlgResult = dlg.show(); // 1 = ok, 2 = cancel
    
    
    // Note: .selection as a string is the value in the drop down, as an int it's the item's index!
    var userOptions = { };
    userOptions[UserOptionsDocNameKey] = app.activeDocument.name;
    userOptions[UserOptionsSourceKey] = parseInt(dlg.sourceGrp.dropDownSource.selection);
    userOptions[UserOptionsLayerSetKey] = parseInt(dlg.sourceGrp.dropDownLayerSet.selection);
    userOptions[UserOptionsResizeKey] = dlg.resizeGrp.resizeCheck.value;
    
    storeLastUserOptions(userOptions);
    
    if ( dlgResult == 2 ) {
        return false;
    }    

    return userOptions;
}

function userOptionsDlg_updateControls(dlg)
{
    if ( dlg.sourceGrp.dropDownSource.selection == UserOptionsSourceLayerSet ) {
        dlg.sourceGrp.dropDownLayerSet.visible = true;
        dlg.sourceGrp.dropDownLayerSet.text = "Layer Group: ";
    } else {
        dlg.sourceGrp.dropDownLayerSet.visible = false;
        dlg.sourceGrp.dropDownLayerSet.text = "";
    }
}






/////////////////////////
// LOGIC
/////////////////////////


function createDestDoc(userOptions, srcDoc)
{
    if ( userOptions === false ) {
        return false;
    }    

    var sourceType = userOptions[UserOptionsSourceKey];
    var layerSetIndex = userOptions[UserOptionsLayerSetKey];
    var destDoc = false;
    
    destDoc = app.documents.add(srcDoc.width, srcDoc.height, srcDoc.resolution, srcDoc.name + " Sheet");

    if ( sourceType == UserOptionsSourceAllDocs ) 
    {
        var biggestCanvasSize = findBiggestCanvas();
        matchAllCanvasSizes(biggestCanvasSize);
        copy_perDocument(destDoc);
    }
    else if ( sourceType == UserOptionsSourceDocument ) 
    {        
        copy_perLayer(srcDoc, destDoc, srcDoc.layers);
    }
    else if ( sourceType == UserOptionsSourceLayerSet ) 
    {
        if ( layerSetIndex >= srcDoc.layerSets.length ) {
            alert ("The 'Specific Layer Set' option was selected, but there is no selected layer set in the open document.");
        }
    
        if ( srcDoc.layerSets[layerSetIndex].layers.length == 0 ) {
            alert ("The selected layer set contains no layers.");
        }
      
        copy_perLayer(srcDoc, destDoc, srcDoc.layerSets[layerSetIndex].layers);        
    }
    else if (sourceType == UserOptionsSourceFrameAnim)
    {    
        copy_perFrame(srcDoc, destDoc);
    }

    return destDoc;
}


function findBiggestCanvas()
{
    var biggestCanvas = {width: 0, height: 0};
    
    // Find and return the biggest canvas size of all open documents
    for( var i = 0; i < app.documents.length; i++ ) 
    {
        // Fix for broken resolution images
        app.activeDocument = app.documents[i];
        app.documents[i].resizeImage(undefined, undefined, 72, ResampleMethod.NONE);
    
        // Compare canvas sizes to find the biggest size
        if(app.documents[i].width > biggestCanvas.width)
        {
            biggestCanvas.width = app.documents[i].width;
        }
        if(app.documents[i].height > biggestCanvas.height)
        {
            biggestCanvas.height = app.documents[i].height;
        }
    }
    
    return biggestCanvas;
}

function matchAllCanvasSizes(biggestCanvasSize)
{
    prevSize = new Array();
    
    for( var i = 0; i < app.documents.length; i++ ) 
    {
        app.activeDocument = app.documents[i];
        
        prevSize[i] = {width: app.documents[i].width, height: app.documents[i].height};
        
        app.documents[i].resizeCanvas(biggestCanvasSize.width, biggestCanvasSize.height);
    }
}

function returnAllCanvasSizes(destDoc)
{
    for( var i = 0; i < app.documents.length; i++ ) 
    {
        if(app.documents[i] != destDoc)
        {
            app.activeDocument = app.documents[i];

            app.documents[i].resizeCanvas(prevSize[i].width, prevSize[i].height);
        }
    }
}
    
function copy_perDocument(destDoc)
{
    // Copy Merged Documents Layers across to new image Texture Atlas
    for( var i = 0; i < app.documents.length; i++ ) 
    {
        if(app.documents[i] != destDoc)
        {
            app.activeDocument = app.documents[i];
            
            processLayers(destDoc);
        }
    }
}
    
 
function copy_perLayer(srcDoc, destDoc, layers)
{
    app.activeDocument = srcDoc;    
    
    if ( srcDoc == undefined || destDoc == undefined || layers == undefined ) {
        alert ("source, destination, or layers were undefined.");
    }
    
    var wasVisible = [];
    var wasParentVisible = undefined;

    // Pre process
    for( var i = 0; i < layers.length; i++ ) {
        wasVisible[i] = layers[i].visible;
    }

    if ( layers[0].parent.visible !== undefined ) {
        wasParentVisible = layers[0].parent.visible;
        layers[0].parent.visible = true;
    }
    
    // Do the work
    for( var i = layers.length-1; i > -1; i-- ) 
    {
        app.activeDocument = srcDoc;
        
        // Don't process background layer as it causes issues (probably don't want it as a sprite anyway)
        if ( layers[i].isBackgroundLayer == true ) { 
            continue;
        }

        // Turn off all layers (but don't mess with the background layer)
        for( var j = 0; j < layers.length; j++ ) {
            if ( layers[j].isBackgroundLayer == false ) {
                layers[j].visible = false;
            }
        }

        // Turn on active layer
        layers[i].visible = true;
        
        // Move to Texture Atlas
        processLayers(destDoc);
    }

    // Undo Pre-Process
    app.activeDocument = srcDoc;    

    for( var i = 0; i < layers.length; i++ ) {
        layers[i].visible = wasVisible[i];    
    }

    if ( layers[0].parent.visible !== undefined ) {
        layers[0].parent.visible = wasParentVisible;
    }
}


function copy_perFrame(srcDoc, destDoc)
{
    app.activeDocument = srcDoc; 

    var frameCount = getFrameCount();
        
    if ( frameCount == 0 ) { 
        alert ("No animation frames were found in this file.");
    }
    else {
        // Copy Merged Frames across to new image
        for( var i = 1; i <= frameCount; i++ ) 
        {
            app.activeDocument = srcDoc;
            goToFrame(i);
            processLayers(destDoc);      
        }
    }  
}



function processLayers(destDoc) 
{
    selectAllLayers();
    duplicateSelectedLayers();

    if( (app.activeDocument.layers.length > 2 || app.activeDocument.layerSets.length > 1) )
    {
        mergeSelectedLayers();
    }

    var layer = app.activeDocument.activeLayer.duplicate(destDoc, ElementPlacement.PLACEATEND);
    deleteSelectedLayers();

    app.activeDocument = destDoc;
    layer.name = "Frame " + i;     
}




function layoutLayersAsSprites(destDoc, userOptions)
{
    // Figure out atlas size
    var frameWidth = parseInt(destDoc.width);
    var frameHeight = parseInt(destDoc.height);
    var frameCount = destDoc.layers.length;
    
    if(userOptions[UserOptionsResizeKey] == true)
    {
        var atlasSize = atlasResizeForMipMapping(frameWidth, frameHeight, frameCount);
    }
    else
    {
        var atlasSize = atlasResize(frameWidth, frameHeight, frameCount);
    }
    
    destDoc.resizeCanvas(atlasSize.width, atlasSize.height, AnchorPosition.TOPLEFT);
    
    // Layout Layers
    var x = 0;
    var y = 0;
    
    for( var i = 0; i < frameCount; i++ ) 
    {         
        try { 
            destDoc.layers[i].translate(x, y);
        } catch ( e ) { }
        
        x += frameWidth;
        
        if ( (x+frameWidth) > atlasSize.width ) 
        {
            x = 0;
            y += frameHeight;
        }
    }

    //flatten image
    selectAllLayers ();
    mergeSelectedLayers ();
}


function atlasResizeForMipMapping(frameWidth, frameHeight, frameCount)
{
    var atlasWidth = 2;
    var atlasHeight = 2;
    var didFit = false;
       
    //determine the resolution of the texture atlas for bin-packing
    while( didFit == false ) 
    {   
        var gridWidth = Math.floor(atlasWidth / frameWidth);
        if(gridWidth == 0) {atlasWidth *= 2; continue;}
        
        var requiredGridHeight = Math.ceil(frameCount / gridWidth);
        var requiredPixelHeight = requiredGridHeight * frameHeight;
        
        if ( requiredPixelHeight > atlasHeight ) 
        {
            if ( (atlasWidth <= atlasHeight) ) { atlasWidth *= 2; }
            else { atlasHeight *= 2; }
            
            didFit = false;
        } 
        else 
        {
            didFit = true;
        }
    }

    var result = {width: atlasWidth, height: atlasHeight};
    
    return result;
}



function atlasResize(frameWidth, frameHeight, frameCount)
{
    var atlasWidth = frameWidth;
    var atlasHeight = frameHeight;
    var didFit = false;
    
    //determine the resolution of the texture atlas for bin-packing
    while( didFit == false ) 
    {   
        var gridWidth = Math.floor(atlasWidth / frameWidth);
        if(gridWidth == 0) {atlasWidth += frameWidth; continue;}
        
        var requiredGridHeight = Math.ceil(frameCount / gridWidth);
        var requiredPixelHeight = requiredGridHeight * frameHeight;
        
        if ( requiredPixelHeight > atlasHeight ) 
        {
            if ( (atlasWidth <= atlasHeight) ) { atlasWidth += frameWidth; }
            else { atlasHeight += frameHeight; }
            
            didFit = false;
        } 
        else 
        {
            didFit = true;
        }
    }

    var result = {width: atlasWidth, height: atlasHeight};
    
    return result;
}


/////////////////////////
// LAYER FUNCTIONS
/////////////////////////    
    
// Select all layers in the active document
function selectAllLayers()
{
    var idselectAllLayers = stringIDToTypeID( "selectAllLayers" );
    var desc4 = new ActionDescriptor();
    var idnull = charIDToTypeID( "null" );
    var ref1 = new ActionReference();
    var idLyr = charIDToTypeID( "Lyr " );
    var idOrdn = charIDToTypeID( "Ordn" );
    var idTrgt = charIDToTypeID( "Trgt" );
    ref1.putEnumerated( idLyr, idOrdn, idTrgt );
    desc4.putReference( idnull, ref1 );
    executeAction( idselectAllLayers, desc4, DialogModes.NO );
}


// Duplicate all layers that are currently selected
function duplicateSelectedLayers()
{
    var idDplc = charIDToTypeID( "Dplc" );
    var desc5 = new ActionDescriptor();
    var idnull = charIDToTypeID( "null" );
    var ref2 = new ActionReference();
    var idLyr = charIDToTypeID( "Lyr " );
    var idOrdn = charIDToTypeID( "Ordn" );
    var idTrgt = charIDToTypeID( "Trgt" );
    ref2.putEnumerated( idLyr, idOrdn, idTrgt );
    desc5.putReference( idnull, ref2 );
    var idVrsn = charIDToTypeID( "Vrsn" );
    desc5.putInteger( idVrsn, 2 );
    executeAction( idDplc, desc5, DialogModes.NO );
}


// Merge all currently selected layers
function mergeSelectedLayers()
{
    var idMrgtwo = charIDToTypeID( "Mrg2" );
    
    try {
        executeAction( idMrgtwo, undefined, DialogModes.NO );
    } catch( e ) { }
}


// Delete all selected layers
function deleteSelectedLayers()
{
    // Delete selected layers
    var idDlt = charIDToTypeID( "Dlt " );
    var desc8 = new ActionDescriptor();
    var idnull = charIDToTypeID( "null" );
    var ref6 = new ActionReference();
    var idLyr = charIDToTypeID( "Lyr " );
    var idOrdn = charIDToTypeID( "Ordn" );
    var idTrgt = charIDToTypeID( "Trgt" );
    ref6.putEnumerated( idLyr, idOrdn, idTrgt );
    desc8.putReference( idnull, ref6 );
    
    try{
        executeAction( idDlt, desc8, DialogModes.NO );
    } catch(e) { }
}



/////////////////////////
// FRAME FUNCTIONS
/////////////////////////   

// Count the number of frames in the current frame animation.
function getFrameCount()
{
    for( var f = 1; f < 999; f++ ) 
    {
        if ( goToFrame(f) == false ) {
            return f - 1;
        }
    }

    return 0;
}


// Jump to the given frame in the frame animation in the active document
function goToFrame(frameIndex)
{
    try { 
        var desc = new ActionDescriptor();  
        var ref1 = new ActionReference();  
        ref1.putIndex( stringIDToTypeID( "animationFrameClass" ), frameIndex);  
        desc.putReference( charIDToTypeID( "null" ), ref1 );  
        executeAction( charIDToTypeID( "slct" ), desc, DialogModes.NO );  
        
        return true;
        
     } catch(e) {

     }
     
     return false;
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;

[NetworkSettings(sendInterval = 0.07f)]

public class Sync_Position : NetworkBehaviour {

	[SyncVar]
    public Vector3 serverPosition;
    
    private Coroutine UpdatePositionServer_Coroutine;
    public bool snapPosition;
    private Coroutine SnapPosition_Coroutine;
    
    public float threshold_Radius;
    
    public Rigidbody syncObject;
    
    
    void Awake()
    {
        syncObject = gameObject.GetComponent();
        
        //RADIUS WORKS BY PREVENTING SERVER FROM UPDATING CLIENT'S LATEST STATE, UNLESS THERE IS A LARGE DISPARITY.
        threshold_Radius = 0.05f;     
    }
    
    void Start () {
        serverPosition = transform.position;
        
        if(!isServer) {return;}
        
        UpdatePositionServer_Coroutine = StartCoroutine( UpdatePosition_Server(0.07f) ); 
        SnapPosition_Coroutine = StartCoroutine(SnapPosition(3f));
        
	}
    
    
    
    //SERVER RESPONSIBILITES::
    IEnumerator UpdatePosition_Server(float delay)
    {
        if(isServer)
        {
            WaitForSeconds Wait = new WaitForSeconds(delay);
            while(true)
            {
                yield return Wait;
                
                if (syncObject.velocity.magnitude > 0.01)
                {

                    //RECONCILE WITH CLIENT IF LARGE DISPARITY BETWEEN CLIENT-SIDE PREDICTION AND SERVER POSITIONS
                    if (Vector3.Distance(transform.position, serverPosition) > threshold_Radius) 
                    {
                        serverPosition = transform.position;
                    }
                }
            }
        }
    }
    
    //SNAP THE PLAYER TO THE SERVER POSITION EVERY ONCE IN A WHILE, JUST INCASE THEY HAVE DE-SYNCED FROM THE RADIUS OF TRUST
    IEnumerator SnapPosition(float delay)
    {
        WaitForSeconds Wait = new WaitForSeconds(delay);
        while(true)
        {
            yield return Wait;
            Rpc_SnapPosition(transform.position);
        }
    }
    
    [ClientRpc]
    public void Rpc_SnapPosition(Vector3 snappedPosition)
    {
        if(serverPosition != snappedPosition)
        {
            serverPosition = snappedPosition;
            if(snapPosition)
            {
                transform.position = snappedPosition;
                snapPosition = false;
            }
            else if (Vector3.Distance(transform.position, serverPosition) > threshold_Radius)
            {
                transform.position = snappedPosition;
            }
        }
    }
    
    
    
    
    //CLIENT RESPONSIBILITES::
    void FixedUpdate()
    {
    //INTERPOLATION
        if(!isServer)
        {
            if(Vector3.Distance(transform.position, serverPosition) > threshold_Radius)
            {
                if(snapPosition)
                {
                    if(Vector3.Distance(transform.position, serverPosition) < threshold_Radius*3f)
                    { transform.position = serverPosition; snapPosition = false;}
                }
                
                transform.position = Vector3.Lerp(transform.position, serverPosition, GameState.Instance.fixedTime_Framerate);
            }  
        }
    }
}



using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;

[NetworkSettings(sendInterval = 0.07f)]

public class Sync_Rotation : NetworkBehaviour {

	[SyncVar]
    public Quaternion serverRotation;
    
    private Coroutine UpdateRotation_Coroutine;
    private Coroutine SnapRotation_Coroutine;
    
    private float threshold_Angle;
    
    public bool snapRotation;
    
    void OnCollisionEnter()
    {
        snapRotation = true;
    }
    
    void Start () 
    {
        threshold_Angle = 90f;
        
        if(!isServer) {return;}
        UpdateRotation_Coroutine = StartCoroutine( UpdateRotation_Server(0.07f) ); 
        SnapRotation_Coroutine = StartCoroutine(SnapRotation(3f));
	}
    
    
    
    //SERVER RESPONSIBILITES::
    IEnumerator UpdateRotation_Server (float delay)
    {
        if(isServer)
        {
            WaitForSeconds Wait = new WaitForSeconds(delay);
            while(true)
            {
                yield return Wait;
                 
                 if (Vector3.Angle(transform.rotation * transform.forward, serverRotation * transform.forward) > threshold_Angle) 
                 {
                     serverRotation = transform.rotation;
                 }
                 
            }
        }
    }
    
    IEnumerator SnapRotation(float delay)
    {
        WaitForSeconds Wait = new WaitForSeconds(delay);
        while(true)
        {
            yield return Wait;
            Rpc_SnapRotation(transform.rotation);
        }
    }
    
    [ClientRpc]
    void Rpc_SnapRotation(Quaternion snappedRotation)
    {
        if(serverRotation != snappedRotation)
        {
            transform.rotation = snappedRotation;
            serverRotation = snappedRotation;
        }  
    }
    
    
    
    
    //CLIENT RESPONSIBILITES::
    void FixedUpdate()
    {
        if(!isServer)
        {
            //INTERPOLATION
            if (Vector3.Angle(transform.rotation * transform.forward, serverRotation * transform.forward) > threshold_Angle) {
                if(snapRotation)
                {
                    transform.rotation = serverRotation;
                    snapRotation = false;
                }
                
                transform.rotation = Quaternion.Slerp(transform.rotation, serverRotation, GameState.Instance.fixedTime_Framerate);
            }
        }
    }
    
}