os_global_calcs_dev.php

Go to the documentation of this file.

<?php
 
// Passwords for the database are stored outside of the webserver accessible directories to improve security.
// Ensure that passwor file has the correct permission to read, but not be written.
include '/usr/local/share/brigadoon/apache/os_passwords.php';

class OS_GLOBAL_CALCS
{
    // Database parameters that are obtained when the constructor is run
    
    public $Database;
    
    public $Host;
    
    public $Username;
    
    public $Password;
 
    
    public function __construct($Database, $Host, $Username, $Password)
    {
        global $pdo;
        
        // Data Source Name (DSN) string
        $dsn = "mysql:host=$Host;dbname=$Database;charset=utf8mb4";
 
        // Set PDO options for better error handling and security
        $options = [
                PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION, // Throw exceptions on errors
                PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,       // Set default fetch mode to associative array
                PDO::ATTR_EMULATE_PREPARES   => true,                  // Disable emulated prepares for better security
               ];
               
        try
        {
            // Create a new PDO connection instance
            $pdo = new PDO($dsn, $Username, $Password, $options);    
        }
        catch (PDOException $e)
        {
            // Catch the exception and display a user-friendly error message
            // In a production environment, you might log the specific error
            
            die("FAILURE=DATABASE:Connection failed " . $e->getMessage());
        }
    }
    
    public function GlobalToLocal($GlobalArray)
    {
        global $pdo;
        $sql_query = " select lor_name  as region_name, :global_x - lor_edge_left as local_x, :global_y - lor_edge_lower as local_y, :global_z as local_z from ls_os_region ";
        $sql_query .= " where :global_x >= lor_edge_left and :global_x <= lor_edge_right and :global_y >= lor_edge_lower  and :global_y <= lor_edge_upper ";
        
        try
        {
            $stmt = $pdo->prepare($sql_query);
            $stmt->execute($GlobalArray);
            $results = $stmt->fetchAll(PDO::FETCH_DEFAULT);
 
            //#########################################################################################
            //# Process Each Line                                                                     #
            //#########################################################################################
            
            if ($results)
            {
                return $results[0];
            }
            
            // If the Code gets here, then the global location is outside of the known world.
            else
            {
                $result['region_name'] = ""; // Flag no known Region
                $result['local_x'] = -1.0;   // Flag bad X reading
                $result['local_y'] = -1.0;   // Flag bad Y reading
                $result['local_z'] = -1.0;   // Flag bad Z reading
                return $result;
            }
        }
        catch (PDOException $e)
        {
            // Catch the exception and display a user-friendly error message
            // In a production environment, you might log the specific error
            
            die("FAILURE=DATABASE:Connection failed " . $e->getMessage());
        }
    }
     
    public function LocalToGlobal($LocalArray)
    {
        global $pdo;
        
        $sql_query = "select lor_edge_left + :local_x as global_x, lor_edge_lower + :local_y as global_y, :local_z as global_z  from ls_os_region where lor_name = :region_name";
        
        try
        {
            $stmt = $pdo->prepare($sql_query);
            $stmt->execute($LocalArray);
            $results = $stmt->fetchAll(PDO::FETCH_DEFAULT);
 
            //#########################################################################################
            //# Process Each Line                                                                     #
            //#########################################################################################
            
            if ($results)
            {
                return $results[0];
            }
        }
        catch (PDOException $e)
        {
            // Catch the exception and display a user-friendly error message
            // In a production environment, you might log the specific error
            
            die("FAILURE=DATABASE:Connection failed " . $e->getMessage());
        }
    }

    public function CourseFromTo($FromLocalArray, $ToLocalArray)
    {
        $FromGlobal = self::LocalToGlobal($FromLocalArray); $ToGlobal = self::LocalToGlobal($ToLocalArray);
        $delta_global['global_x'] = $ToGlobal['global_x'] - $FromGlobal['global_x'];
        $delta_global['global_y'] = $ToGlobal['global_y'] - $FromGlobal['global_y'];
        $delta_global['global_z'] = $ToGlobal['global_z'] - $FromGlobal['global_z'];
        $ground_distance = sqrt($delta_global['global_x'] ** 2.0 + $delta_global['global_y'] ** 2.0);
        $result['distance'] = sqrt($ground_distance ** 2.0 + $delta_global['global_z'] ** 2);
        $result['bearing']  = atan2($delta_global['global_x'], $delta_global['global_y']);
        $result['elevation'] = atan2($delta_global['global_z'], $ground_distance) ;
        return $result;
    }
    
    public function FromCourseTo($FromLocalArray, $CourseArray)
    {
        $FromGlobal = self::LocalToGlobal($FromLocalArray);
        $total_distance = $CourseArray['distance'];
        $elevation_angle = $CourseArray['elevation'];
        $bearing_angle = $CourseArray['bearing'];
        
        $ground_distance = $total_distance * cos($elevation_angle);
        $delta_z         = $total_distance * sin($elevation_angle);
        
        $delta_x = $ground_distance * sin($bearing_angle);
        $delta_y = $ground_distance * cos($bearing_angle);
        
        $GlobalArray['global_x'] = $FromGlobal['global_x'] + $delta_x;
        $GlobalArray['global_y'] = $FromGlobal['global_y'] + $delta_y;
        $GlobalArray['global_z'] = $FromGlobal['global_z'] + $delta_z;
        
        return self::GlobalToLocal($GlobalArray);
    }

     public function RegionBoundsGlobal($RegionName)
     {
        global $pdo;
        
        $sql_query  = "select :region_name as region_name, ";
        $sql_query .= "lor_edge_left as global_left,   lor_edge_lower as global_bottom, 0 as global_low, ";
        $sql_query .= "lor_edge_right as global_right, lor_edge_upper as global_top,    lor_size_z as global_high ";
        $sql_query .= "from ls_os_region where lor_name = :region_name";
        
        try
        {
            $stmt = $pdo->prepare($sql_query);
            $stmt->execute(['region_name' => $RegionName]);
            $results = $stmt->fetchAll(PDO::FETCH_DEFAULT);
 
            //#########################################################################################
            //# Process Each Line                                                                     #
            //#########################################################################################
            
            if ($results)
            {
                return $results[0];
            }
            else
            {
                $result['region_name'] = "";
                $result['global_left'] = -1;
                $result['global_bottom'] = -1;
                $result['global_right'] = -1;
                $result['global_top'] = -1;
                $result['global_low'] = -1;
                $result['global_high'] = -1;
                return $result;
            }   
        }
        catch (PDOException $e)
        {
            // Catch the exception and display a user-friendly error message
            // In a production environment, you might log the specific error
            
            die("FAILURE=DATABASE:Connection failed " . $e->getMessage());
        }
    }
    
     public function AddGlobal($FromGlobal, $DeltaGlobal)
     {
        $result['global_x'] = $ToGlobal['global_x'] + $DeltaGlobal['global_x'];
        $result['global_y'] = $ToGlobal['global_y'] + $DeltaGlobal['global_y'];
        $result['global_z'] = $ToGlobal['global_z'] + $DeltaGlobal['global_z'];
        return $result;
    }     
 
    
     public function DeltaGlobal($FromGlobal, $ToGlobal)
     {
        $result['global_x'] = $ToGlobal['global_x'] - $FromGlobal['global_x'];
        $result['global_y'] = $ToGlobal['global_y'] - $FromGlobal['global_y'];
        $result['global_z'] = $ToGlobal['global_z'] - $FromGlobal['global_z'];
        return $result;
    }     
    
     public function RegionToDeltaLocal($FromLocal, $ToLocal)
     {
        // Set the Local Position to the start of the Region
        $FromLocal['local_x'] = 0; $FromLocal['local_y'] = 0; $FromLocal['local_z'] = 0;
        $from_global = self::LocalToGlobal($FromLocal); $to_global = self::LocalToGlobal($ToLocal);
        $delta_global = self::DeltaGlobal($from_global, $to_global);
        $delta_global['region_name'] = $FromLocal['region_name'];
        return $delta_global;
     }
     
     public function DeltaLocalToLocal($DeltaLocal)
     {
        $region_boundaries = self::RegionBoundsGlobal($DeltaLocal['region_name']);
        $location_global['global_x'] = $DeltaLocal['global_x'] + $region_boundaries['global_left'];
        $location_global['global_y'] = $DeltaLocal['global_y'] + $region_boundaries['global_bottom'];
        $location_global['global_z'] = $DeltaLocal['global_z'] + $region_boundaries['global_low'];
        $local_array = self::GlobalToLocal($location_global);
        return $local_array;
     }
}
 
/***************************************************************************************************
 *              TEST PROGRAM ENTRY
 ***************************************************************************************************
 * These routines are both an example of how to use the class and method of testing each of the routines
 * in case a potential error is detected.
 ***************************************************************************************************/
 
    // Instantiate the Class with the database parameters. These parameters are provided by include file
    // near the start of this file.  
    $global_calcs = new OS_GLOBAL_CALCS($db, $host, $db_username, $db_password);
    
    // Examples of how data is formatted for inpuut to and output from the routines. This format makes the array
    // directly compatible as the parameter field in the SQL queries.
    $from_array = ['region_name'=>'BRIGADOON13', 'local_x' => 128, 'local_y' => 256, 'local_z' => 128];
    $to_array   = ['region_name'=>'BRIGADOON13', 'local_x' => 0, 'local_y' => 0,     'local_z' => 256];
    $course     = [];
    $global     = [];
    
    // Convert the Local Coordinates into Global Coordinates
    $global = $global_calcs->LocalToGlobal($from_array);
    echo "LocalToGlobal: Global X = ".$global['global_x'].", Global Y = ".$global['global_y'].", Global Z = ".$global['global_x']."\n\n";
 
    // Convert the Global Coordinates back to the Local Coordinates. They should be unchanged after the two conversion.
    $from_array = $global_calcs->GlobalToLocal($global);
    echo "GlobalToLocal: Region Name = ".$from_array['region_name'].", local_x = ".$from_array['local_x'].", local_y = ".$from_array['local_y'].", local_z = ".$from_array['local_z']."\n\n";
 
    // Take an Origin Local Location, convert to global, move the local and convert back into Local Coordinates 
    $course = $global_calcs->CourseFromTo($from_array, $to_array);
    echo "CourseFromTo: Distance = ".$course['distance'].", bearing = ".rad2deg($course['bearing']). ", elevation = ".rad2deg($course['elevation'])."\n\n";
 
    // Try to Move back to the Orgin using the previous Destination as the start and reverse the calculated course to get back the Origin in Local Coordinates
    $course['bearing'] += M_PI;
    $course['elevation'] *= -1; 
    $from_array = $global_calcs->FromCourseTo($to_array, $course);
    echo "FromCourseTo: Region Name = ".$from_array['region_name'].", local_x = ".$from_array['local_x'].", local_y = ".$from_array['local_y'].", local_z = ".$from_array['local_z']."\n\n";
 
    // Get the Region Information
    $result = $global_calcs->RegionBoundsGlobal("Brigadoon13");
    echo $result['region_name']." ".$result['global_left']." ".$result['global_bottom']." ".$result['global_right']." ".$result['global_top']." ".$result['global_low']." ".$result['global_high']."\n";
    
    // Find the Distance for Teleporter Use
    $FromLocal = ['region_name'=>'BRIGADOON01', 'local_x' => 128, 'local_y' => 256, 'local_z' => 128];
    $ToLocal   = ['region_name'=>'BRIGADOON05', 'local_x' => 0, 'local_y' => 0, 'local_z' => 128];
    $result = $global_calcs->RegionToDeltaLocal($FromLocal, $ToLocal);
    echo "RegionToDeltaLocal: Local X = ".$result['global_x'].", Local Y = ".$result['global_y'].", Global Z = ".$result['global_z']."\n\n";
    
    // Convert an extended local position into a normal global position
    
?>