diff --git a/Icons/RJActionList.svg b/Icons/RJActionList.svg index aed7b72..4d7dfb6 100644 --- a/Icons/RJActionList.svg +++ b/Icons/RJActionList.svg @@ -23,9 +23,9 @@ inkscape:pagecheckerboard="0" inkscape:deskcolor="#505050" showgrid="false" - inkscape:zoom="10.363534" - inkscape:cx="-6.368484" - inkscape:cy="-0.048246091" + inkscape:zoom="20.727068" + inkscape:cx="4.1491638" + inkscape:cy="6.8750679" inkscape:window-width="1920" inkscape:window-height="1017" inkscape:window-x="-8" diff --git a/Icons/RJActionSequence.svg b/Icons/RJActionSequence.svg new file mode 100644 index 0000000..56ceb67 --- /dev/null +++ b/Icons/RJActionSequence.svg @@ -0,0 +1,157 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/Icons/RJActionSequence.svg.import b/Icons/RJActionSequence.svg.import new file mode 100644 index 0000000..e0b6a9f --- /dev/null +++ b/Icons/RJActionSequence.svg.import @@ -0,0 +1,37 @@ +[remap] + +importer="texture" +type="CompressedTexture2D" +uid="uid://c6lekbldg584j" +path="res://.godot/imported/RJActionSequence.svg-861cbfffa33440d8d759203c534bd591.ctex" +metadata={ +"vram_texture": false +} + +[deps] + +source_file="res://Scripts/Rokojori/Rokojori-Action-Library/Icons/RJActionSequence.svg" +dest_files=["res://.godot/imported/RJActionSequence.svg-861cbfffa33440d8d759203c534bd591.ctex"] + +[params] + +compress/mode=0 +compress/high_quality=false +compress/lossy_quality=0.7 +compress/hdr_compression=1 +compress/normal_map=0 +compress/channel_pack=0 +mipmaps/generate=false +mipmaps/limit=-1 +roughness/mode=0 +roughness/src_normal="" +process/fix_alpha_border=true +process/premult_alpha=false +process/normal_map_invert_y=false +process/hdr_as_srgb=false +process/hdr_clamp_exposure=false +process/size_limit=0 +detect_3d/compress_to=1 +svg/scale=1.0 +editor/scale_with_editor_scale=false +editor/convert_colors_with_editor_theme=false diff --git a/Runtime/Actions/ActionList.cs b/Runtime/Actions/ActionList.cs index 41c86c0..2679cf7 100644 --- a/Runtime/Actions/ActionList.cs +++ b/Runtime/Actions/ActionList.cs @@ -4,12 +4,31 @@ using Godot; namespace Rokojori { + /** + + + Executes multiple actions (RJAction) at once. + + + + The ActionList, which is an RJAction itself, executes all actions stored in the member 'actions' and also child nodes + that extend RJAction, when 'triggerDirectChildren' is checked. + + + + + */ + [GlobalClass, Icon("res://Scripts/Rokojori/Rokojori-Action-Library/Icons/RJActionList.svg") ] public partial class ActionList : RJAction - { + { + + /** Actions to execute*/ [Export] public RJAction[] actions; - [Export] + + /** Whether to execute RJAction child nodes*/ + [Export] public bool triggerDirectChildren = true; public override void _OnTrigger() @@ -27,6 +46,9 @@ namespace Rokojori return; } + Nodes.ForEachDirectChild( this, a => Actions.Trigger( a ) ); + + /* var childCount = GetChildCount(); for ( int i = 0; i < childCount; i++ ) @@ -41,6 +63,7 @@ namespace Rokojori Actions.Trigger( action ); } + */ } } } \ No newline at end of file diff --git a/Runtime/Actions/ActionSequence.cs b/Runtime/Actions/ActionSequence.cs new file mode 100644 index 0000000..79779bb --- /dev/null +++ b/Runtime/Actions/ActionSequence.cs @@ -0,0 +1,237 @@ + +using System.Diagnostics; +using System.Collections; +using System.Collections.Generic; +using System; +using Godot; + + +namespace Rokojori +{ + public class ActionSequenceRunner + { + public ActionSequence sequence; + public List actions; + public List sequencables; + public int sequencablesIndex = 0; + bool cancelled = false; + bool cancelledSequence = false; + + int _runID = -1; + + RJSequenceAction _runningAction; + int _runningActionID = -1; + + public void Cancel() + { + if ( cancelled || _runningAction == null ) + { + return; + } + + cancelled = true; + _runningAction.CancelAction( _runningActionID ); + } + + void CancelRun() + { + if ( cancelledSequence ) + { + return; + } + + if ( ! cancelled ) + { + cancelled = true; + } + + cancelledSequence = true; + sequence.DispatchCancelled( _runID ); + sequence.ClearRun( this ); + } + + + public void ProcessNext() + { + RJLog.Log( "@" + sequence.Name, "Index:", sequencablesIndex ); + + if ( sequencablesIndex == 0 ) + { + _runID = sequence.DispatchStart(); + + if ( sequencables.Count == 0 ) + { + actions.ForEach( a => Actions.Trigger( a ) ); + sequence.DispatchEnd( _runID ); + sequence.ClearRun( this ); + return; + } + } + + if ( sequencablesIndex >= sequencables.Count ) + { + TriggerAllAfter( sequencables[ sequencables.Count -1 ] ); + sequence.DispatchEnd( _runID ); + sequence.ClearRun( this ); + return; + } + + if ( cancelled ) + { + CancelRun(); + return; + } + + + var sequenceAction = sequencables[ sequencablesIndex ]; + StartAction( sequenceAction ); + } + + Dictionary callbacks = + new Dictionary(); + + void StartAction( RJSequenceAction action ) + { + var capturedAction = action; + + RJSequenceAction.OnSequenceDoneEventHandler callback = + ( long id, bool success ) => + { + + //RJLog.Log( "On Done", id, success ); + + if ( id != _runningActionID ) + { + // RJLog.Error( "Invalid ID", id, "!=", _runningActionID ); + return; + } + + _runningActionID = -1; + + if ( success ) + { + sequencablesIndex ++; + ProcessNext(); + } + else + { + sequence.DispatchCancelled( _runID ); + sequence.ClearRun( this ); + } + + var callbackReference = callbacks[ capturedAction ]; + capturedAction.OnSequenceDone -= callbackReference; + + callbacks.Remove( capturedAction ); + }; + + RunNext( action, callback ); + + /* + _runningAction = action; + callbacks[ _runningAction ] = callback; + _runningAction.OnSequenceDone += callback; + TriggerAllBefore( _runningAction ); + Actions.Trigger( _runningAction ); + _runningActionID = _runningAction.GetLastSequenceActionID(); + */ + } + + void RunNext( RJSequenceAction action, RJSequenceAction.OnSequenceDoneEventHandler callback ) + { + _runningAction = action; + callbacks[ _runningAction ] = callback; + _runningAction.OnSequenceDone += callback; + + + TriggerAllBefore( _runningAction ); + Actions.Trigger( _runningAction ); + _runningActionID = _runningAction.GetLastSequenceActionID(); + } + + void TriggerAllBefore( RJSequenceAction action ) + { + var actionIndex = actions.IndexOf( action ); + + for ( int i = actionIndex - 1; i >= 0; i -- ) + { + if ( typeof( RJSequenceAction ).IsAssignableFrom( actions[ i ].GetType() ) ) + { + return; + } + + RJLog.Log( "Triggering Action", actions[ i ].Name ); + + Actions.Trigger( actions[ i ] ); + } + + } + + void TriggerAllAfter( RJSequenceAction action ) + { + var actionIndex = actions.IndexOf( action ); + + for ( int i = actionIndex + 1; i < actions.Count; i ++ ) + { + if ( typeof( RJSequenceAction ).IsAssignableFrom( actions[ i ].GetType() ) ) + { + return; + } + + RJLog.Log( "Triggering Action", actions[ i ].Name ); + Actions.Trigger( actions[ i ] ); + } + + } + + + } + + [GlobalClass, Icon("res://Scripts/Rokojori/Rokojori-Action-Library/Icons/RJActionSequence.svg") ] + public partial class ActionSequence:RJSequenceAction + { + /** Actions to execute*/ + [Export] + public RJAction[] actions; + + [Export] + public bool triggerDirectChildren = true; + + List running = new List(); + + public override void _OnTrigger() + { + var run = new ActionSequenceRunner(); + run.sequence = this; + run.actions = new List( actions ); + + if ( triggerDirectChildren ) + { + Nodes.ForEachDirectChild( this, a => run.actions.Add( a ) ); + } + + run.sequencables = Lists.FilterType( run.actions ); + + + + + // RJLog.Log( "Running", HierarchyName.Of( this ), run.sequencables.Count ); + running.Add( run ); + run.ProcessNext(); + } + + public override void CancelAction( int id ) + { + running.ForEach( r => r.Cancel() ); + } + + public void ClearRun( ActionSequenceRunner run ) + { + running.Remove( run ); + } + + } + + + +} \ No newline at end of file diff --git a/Runtime/Actions/Actions.cs b/Runtime/Actions/Actions.cs index 9b5e8a7..1c77045 100644 --- a/Runtime/Actions/Actions.cs +++ b/Runtime/Actions/Actions.cs @@ -11,7 +11,7 @@ namespace Rokojori if ( action == null ) { return; - } + } action.Trigger(); } diff --git a/Runtime/Actions/Delay.cs b/Runtime/Actions/Delay.cs new file mode 100644 index 0000000..ec9f163 --- /dev/null +++ b/Runtime/Actions/Delay.cs @@ -0,0 +1,57 @@ + +using Godot; + + +namespace Rokojori +{ + [GlobalClass] + public partial class Delay : RJSequenceAction + { + [Export] + public float duration; + + [Export] + public string message; + + float elapsed = 0; + bool running = false; + bool finished = false; + + int runID = 0; + + public override void _Ready() + { + /// OnSequenceDone += ( id, success ) => { RJLog.Log( "OnSequenceDone", Name ); } ; + } + + public override void _OnTrigger() + { + //RJLog.Log( "Starting", Name ); + runID = DispatchStart(); + + elapsed = 0; + running = true; + finished = false; + + } + + public override void _Process( double delta ) + { + if ( ! running ) + { + return; + } + + elapsed += (float) delta; + + if ( elapsed > duration ) + { + running = false; + finished = true; + + RJLog.Log( Name, " >> '" + message + "'" ); + DispatchEnd( runID ); + } + } + } +} \ No newline at end of file diff --git a/Runtime/Actions/GDDelay.gd b/Runtime/Actions/GDDelay.gd new file mode 100644 index 0000000..8d64dcf --- /dev/null +++ b/Runtime/Actions/GDDelay.gd @@ -0,0 +1,34 @@ +class_name GDDelay +extends RJSequenceAction + +@export var duration = 1 +@export var message = "huhu" + +var running = false +var elapsed = 0; +var id = 0; +var cachedIDs = [] + +func _onTrigger(): + if running: + cachedIDs + + + running = true + elapsed = 0 + id = dispatchStart() + +func _process( delta ): + if ! running: + return + elapsed += delta + + if elapsed > duration: + running = false + elapsed = 0 + print( name + " >> " + message ) + dispatchEnd( id ) + + + + diff --git a/Runtime/Actions/LoadScene.cs b/Runtime/Actions/LoadScene.cs new file mode 100644 index 0000000..3a88ffc --- /dev/null +++ b/Runtime/Actions/LoadScene.cs @@ -0,0 +1,80 @@ + +using Godot; +using System.Collections.Generic; + +namespace Rokojori +{ + [GlobalClass] + public partial class LoadScene : RJSequenceAction + { + [Export] + public string scenePath; + + [Export] + public Node target; + + [Export] + public RJAction onLoaded; + + bool _loading = false; + int _id = -1; + List _cached = new List(); + + public override void _OnTrigger() + { + if ( _loading ) + { + _cached.Add( DispatchStart() ); + return; + } + + _loading = true; + _id = DispatchStart(); + var errorCode = ResourceLoader.LoadThreadedRequest( scenePath ); + + if ( Error.Ok != errorCode ) + { + _cached.Add( _id ); + _id = -1; + _loading = false; + } + } + + public override void _Process ( double delta ) + { + if ( ! _loading ) + { + return; + } + + var status = ResourceLoader.LoadThreadedGetStatus( scenePath ); + + if ( ResourceLoader.ThreadLoadStatus.Loaded != status ) + { + return; + } + + _loading = false; + + var packedScene = (PackedScene) ResourceLoader.LoadThreadedGet( scenePath ); + var node = packedScene.Instantiate(); + target.AddChild( node ); + Actions.Trigger( onLoaded ); + DispatchEnd( _id ); + _id = -1; + + _cached.ForEach( + ( c )=> + { + target.AddChild( packedScene.Instantiate() ); + Actions.Trigger( onLoaded ); + DispatchEnd( c ); + } + ); + + _cached.Clear(); + + + } + } +} \ No newline at end of file diff --git a/Runtime/Actions/OnReady.cs b/Runtime/Actions/OnReady.cs index f9cfd3d..6a30730 100644 --- a/Runtime/Actions/OnReady.cs +++ b/Runtime/Actions/OnReady.cs @@ -12,7 +12,7 @@ namespace Rokojori public override void _Ready() { - RJLog.Log( "OnReady" ); + // RJLog.Log( "OnReady" ); Actions.Trigger( action ); } } diff --git a/Runtime/Colors/HSLColor.cs b/Runtime/Colors/HSLColor.cs new file mode 100644 index 0000000..6145329 --- /dev/null +++ b/Runtime/Colors/HSLColor.cs @@ -0,0 +1,204 @@ +using Godot; + +namespace Rokojori +{ + + public struct HSLColor + { + public static readonly HSLColor white = new HSLColor( new Color( 1, 1, 1, 1 ) ); + public static readonly HSLColor red = new HSLColor( new Color( 1, 0, 0, 1 ) ); + public static readonly HSLColor green = new HSLColor( new Color( 0, 1, 0, 1 ) ); + public static readonly HSLColor blue = new HSLColor( new Color( 0, 0, 1, 1 ) ); + public static readonly HSLColor black = new HSLColor( new Color( 0, 0, 0, 1 ) ); + + // hue in degrees 0 - 360 + public float h; + // saturation 0 - 1 + public float s; + // luminance 0 - 1 + public float l; + // alpha 0 - 1 + public float a; + + + public HSLColor( float h, float s, float l, float a ) + { + this.h = h; + this.s = s; + this.l = l; + this.a = a; + } + + public HSLColor( float h, float s, float l ) + { + this.h = h; + this.s = s; + this.l = l; + this.a = 1f; + } + + public float lumaBT601 + { + get + { + var rgb = ToRGBA(); + + var R = rgb.R; + var G = rgb.G; + var B = rgb.B; + + return 0.2989f * R + 0.5870f * G + 0.1140f * B; + } + } + + public float lumaBT709 + { + get + { + var rgb = ToRGBA(); + + var R = rgb.R; + var G = rgb.G; + var B = rgb.B; + + return 0.2126f * R + 0.7152f * G + 0.0722f * B; + } + } + + public float normalizedHue + { + get { return h / 360f;} + } + + public HSLColor( Color c ) + { + HSLColor temp = FromRGBA( c ); + h = temp.h; + s = temp.s; + l = temp.l; + a = temp.a; + } + + public static HSLColor FromRGBA( Color c ) + { + float h, s, l, a; + a = c.A; + + float cmin = Mathf.Min( Mathf.Min( c.R, c.G ), c.B ); + float cmax = Mathf.Max( Mathf.Max( c.R, c.G ), c.B ); + + l = ( cmin + cmax ) / 2f; + + if ( cmin == cmax ) + { + s = 0; + h = 0; + } + else + { + float delta = cmax - cmin; + + s = ( l <= .5f ) ? ( delta / ( cmax + cmin ) ) : ( delta / ( 2f - ( cmax + cmin ) ) ); + + h = 0; + + if ( c.R == cmax ) + { + h = ( c.G - c.B ) / delta; + } + else if ( c.G == cmax ) + { + h = 2f + ( c.B - c.R ) / delta; + } + else if ( c.B == cmax ) + { + h = 4f + ( c.R - c.G ) / delta; + } + + h = MathX.Repeat( h * 60f, 360f ); + } + + return new HSLColor( h, s, l, a ); + } + + public static HSLColor Lerp( HSLColor x, HSLColor y, float t ) + { + float h = Mathf.LerpAngle( x.h, y.h, t ); + float s = Mathf.Lerp( x.s, y.s, t ); + float l = Mathf.Lerp( x.l, y.l, t ); + float a = Mathf.Lerp( x.a, y.a, t ); + + return new HSLColor( h, s, l, a ); + } + + public static Color Lerp( Color x, Color y, float t ) + { + var hx = new HSLColor( x ); + var hy = new HSLColor( y ); + + var h = Lerp( hx, hy, t ); + + return h.ToRGBA(); + } + + + public Color ToRGBA( ) + { + float r, g, b, a; + a = this.a; + + float m1, m2; + + m2 = ( l <= .5f ) ? ( l * ( 1f + s ) ) : ( l + s - l * s ); + m1 = 2f * l - m2; + + if ( s == 0f ) + { + r = g = b = l; + } + else + { + r = Value( m1, m2, h + 120f ); + g = Value( m1, m2, h ); + b = Value( m1, m2, h - 120f ); + } + + return new Color( r, g, b, a ); + } + + static float Value( float n1, float n2, float hue ) + { + + hue = MathX.Repeat( hue, 360f ); + + if ( hue < 60f ) + { + return n1 + ( n2 - n1 ) * hue / 60f; + } + else if ( hue < 180f ) + { + return n2; + } + else if ( hue < 240f ) + { + return n1 + ( n2 - n1 ) * ( 240f - hue ) / 60f; + } + else + { + return n1; + } + } + + public static implicit operator HSLColor( Color src ) + { + return FromRGBA( src ); + } + + public static implicit operator Color( HSLColor src ) + { + return src.ToRGBA( ); + } + + } + +} \ No newline at end of file diff --git a/Runtime/Files/FilePath.cs b/Runtime/Files/FilePath.cs new file mode 100644 index 0000000..85cf534 --- /dev/null +++ b/Runtime/Files/FilePath.cs @@ -0,0 +1,169 @@ + +using System.Collections; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Text.RegularExpressions; + +namespace Rokojori +{ + public enum FilePathType + { + ABSOLUTE, + RELATIVE + } + + public class FilePath + { + public FilePathType type; + public FilePath parent; + public string path; + + public string _fileName; + public string _fileExtension; + string _fullPath = null; + + /**Only fileName without fileExtension */ + public string fileName + { + get + { + if ( _fileName == null) + { + _fileName = Path.GetFileNameWithoutExtension( path ); + } + + return _fileName; + } + } + + /**Combines fileName + fileExtension */ + public string fullFileName => fileName + fileExtension; + + /***/ + public string fileExtension + { + get + { + if ( _fileExtension == null) + { + _fileExtension = Path.GetExtension( path ); + } + + return _fileExtension; + } + } + + public string fullPath + { + get + { + if ( _fullPath == null ) + { + if ( this.parent != null ) + { + _fullPath = this.parent.fullPath + "/" + path; + } + else + { + _fullPath = path; + } + + } + + return _fullPath; + } + } + + public static FilePath Create( string path, FilePathType type = FilePathType.RELATIVE, FilePath parent = null ) + { + var rp = new FilePath(); + + rp.type = type; + rp.parent = parent; + rp.path = path; + + return rp; + } + + public static FilePath Absolute( string path ) + { + return FilePath.Create( path, FilePathType.ABSOLUTE ); + } + + public FilePath MakeRelative( string path ) + { + return FilePath.Create( path, FilePathType.RELATIVE, this ); + } + + public FilePath MakeAbsolutePathRelative( string absolutePath ) + { + absolutePath = FilePath.Normalize( absolutePath ); + var ownAbsolutePath = FilePath.Normalize( fullPath ); + + if ( ! absolutePath.StartsWith( ownAbsolutePath ) ) + { + return null; + } + + var relativePath = absolutePath.Substring( ownAbsolutePath.Length ); + + return MakeRelative( relativePath ); + } + + public FilePath CreateRelativeFromAbsolutePathWithParent( string absolutePath, FilePath absoluteParent ) + { + var rp = new FilePath(); + + rp.type = FilePathType.RELATIVE; + rp.parent = absoluteParent; + rp.path = Path.GetFileName( absolutePath ); + rp._fullPath = absolutePath; + + return rp; + + } + + public static string Normalize( string path, bool removeFirst = true, bool removeLast = true ) + { + path = Regex.Replace( path, @"\\", "/" ); + path = Regex.Replace( path, @"/+", "/" ); + + if ( removeFirst ) + { + path = Regex.Replace( path, @"^/", "" ); + } + + if ( removeLast ) + { + path = Regex.Replace( path, @"/$", "" ); + } + + + + return path; + } + + public static string Join( params string[] paths ) + { + var sb = new StringBuilder(); + + for ( int i = 0; i < paths.Length; i++ ) + { + var path = paths[ i ]; + + path = Normalize( path ); + + if ( i != 0 ) + { + sb.Append( "/" ); + } + + sb.Append( path ); + } + + return sb.ToString(); + } + + } +} \ No newline at end of file diff --git a/Runtime/Files/FilesSync.cs b/Runtime/Files/FilesSync.cs new file mode 100644 index 0000000..56565e9 --- /dev/null +++ b/Runtime/Files/FilesSync.cs @@ -0,0 +1,138 @@ + +using System.Collections; +using System.Collections.Generic; + +using System.IO; + +namespace Rokojori +{ + public class FilesSync + { + public static bool DirectoryExists( string path ) + { + return Directory.Exists( path ); + } + + public static void CreateDirectory( string path ) + { + Directory.CreateDirectory( path ); + } + + public static void EnsureDirectoryExists( string path ) + { + if ( DirectoryExists( path ) ) + { + return; + } + + CreateDirectory( path ); + } + + public static List GetDirectories( string path, System.Func evaluator = null ) + { + var list = new List(); + + var files = Directory.GetDirectories( path, "*", SearchOption.TopDirectoryOnly ); + + var absolutePath = FilePath.Absolute( path ); + + for ( int i = 0; i < files.Length; i++ ) + { + var fileName = Path.GetFileName( files[ i ] ); + + var relativePath = absolutePath.MakeRelative( fileName ); + + if ( evaluator == null || evaluator( relativePath ) ) + { + list.Add( relativePath ); + } + } + + return list; + } + + public static List GetFiles( string path, System.Func evaluator = null, bool recursive = false ) + { + var list = new List(); + + var files = Directory.GetFiles( path, "*", recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly ); + + + var absoluteFilePath = FilePath.Absolute( path ); + + for ( int i = 0; i < files.Length; i++ ) + { + var relativePath = absoluteFilePath.MakeAbsolutePathRelative( files[ i ] ); + + if ( evaluator == null || evaluator( relativePath ) ) + { + list.Add( relativePath ); + } + } + + return list; + } + + public static bool SaveUTF8( string path, string data ) + { + try + { + using ( StreamWriter streamWriter = File.CreateText( path ) ) + { + streamWriter.Write( data ); + } + } + catch ( System.Exception e ) + { + RJLog.Log( "Could not save text: ", path, "exception", e ); + return false; + } + + return true; + + } + + public static bool SaveJSON( string path, object obj ) + { + return SaveUTF8( path, JSON.StringifyObject( obj ) ); + } + + public static string LoadUTF8( string path ) + { + try + { + using ( StreamReader streamReader = File.OpenText( path ) ) + { + return streamReader.ReadToEnd(); + } + } + catch ( System.Exception e ) + { + RJLog.Log( "Could not load text: ", path, "exception", e ); + } + + return null; + } + + public static bool SaveBytes( string fileName, byte[] byteArray ) + { + try + { + using ( var fs = new FileStream( fileName, FileMode.Create, FileAccess.Write ) ) + { + fs.Write( byteArray, 0, byteArray.Length ); + return true; + } + } + catch ( System.Exception e ) + { + RJLog.Log( "Exception caught in process: {0}", e ); + return false; + } + + } + } + + + +} \ No newline at end of file diff --git a/Runtime/Godot/Nodes.cs b/Runtime/Godot/Nodes.cs index d83d63f..2a894d8 100644 --- a/Runtime/Godot/Nodes.cs +++ b/Runtime/Godot/Nodes.cs @@ -37,13 +37,35 @@ namespace Rokojori if ( node is T ) { - return (T)node; + return (T) node; } } return null; } + public static void ForEachDirectChild( Node parent, System.Action action ) where T:Node + { + if ( parent == null || action == null ) + { + return; + } + + var numChildren = parent.GetChildCount(); + + for ( int i = 0; i < numChildren; i++ ) + { + var node = parent.GetChild( i ); + + if ( ! ( node is T ) ) + { + continue; + } + + action( node as T ); + } + } + static NodesWalker nodesWalker = new NodesWalker(); public static T GetAnyChild( Node parent ) where T:Node @@ -63,6 +85,8 @@ namespace Rokojori SetState.SetStateOfNode( NodeStateType.Disabled, n, affectProcess, affectPhysicsProcess, affectInput ); } + */ + public static void Iterate( Node[] nodes, System.Action callback ) { for ( int i = 0; i < nodes.Length; i++ ) @@ -71,7 +95,7 @@ namespace Rokojori } } - */ + } } diff --git a/Runtime/Logging/RJLog.cs b/Runtime/Logging/RJLog.cs index b33d304..6d446e4 100644 --- a/Runtime/Logging/RJLog.cs +++ b/Runtime/Logging/RJLog.cs @@ -12,12 +12,64 @@ namespace Rokojori static void Stringify( object obj, StringBuilder output ) { + if ( obj == null ) + { + output.Append( "" ); + return; + } + output.Append( obj.ToString() ); } static void LogMessage( string message ) { - GD.Print( message ); + var trace = GetTrace(); + GD.PrintRich("[b]" + message + "[/b]"); + GD.PrintRich( trace ); + } + + static void LogErrorMessage( string message ) + { + var trace = GetTrace(); + GD.PrintErr( message ); + GD.PrintRich( trace ); + } + + static string GetTrace() + { + var stackTrace = new System.Diagnostics.StackTrace( true ); + var frameIndex = 3; + + var frame = stackTrace.GetFrame( frameIndex ); + + var className = frame.GetFileName(); + + if ( className != null ) + { + var slashIndex = -1; + for ( int i = className.Length - 1; i >= 0 && slashIndex == -1; i-- ) + { + if ( className[ i ] == '\\' || className[ i ] == '/' ) + { + slashIndex = i; + } + } + + if ( slashIndex != -1 ) + { + var end = className.EndsWith( ".cs" ) ? className.Length - 3 : className.Length; + className = className.Substring( slashIndex + 1, end - ( slashIndex + 1 ) ); + } + } + + if ( className == null ) + { + className =""; + } + + + var trace = className + "." + frame.GetMethod().Name + "() ln."+ frame.GetFileLineNumber(); + return "[color=gray] " + trace + "[/color]" ; } public static void Log( params object[] objects) @@ -36,6 +88,23 @@ namespace Rokojori LogMessage( sb.ToString() ); } + + public static void Error( params object[] objects) + { + var sb = new StringBuilder(); + + for ( int i = 0; i < objects.Length; i++ ) + { + if ( i != 0 ) + { + sb.Append( " " ); + } + + Stringify( objects[ i ], sb ); + } + + LogErrorMessage( sb.ToString() ); + } } } diff --git a/Runtime/Math/MathX.cs b/Runtime/Math/MathX.cs new file mode 100644 index 0000000..e811c15 --- /dev/null +++ b/Runtime/Math/MathX.cs @@ -0,0 +1,228 @@ +using System.Collections; +using System.Collections.Generic; +using Godot; +using System.Text; +using System; + +namespace Rokojori +{ + public class MathX + { + + public static float Clamp01( float value ) + { + return Mathf.Clamp( value, 0, 1 ); + } + + public static float Normalize( float value, float min, float max ) + { + return ( value - min ) / ( max - min ); + } + + public static float NormalizeClamped( float value, float min, float max ) + { + return MathX.Clamp01( Normalize( value, min, max ) ); + } + + public static float Map( float value, float inputMin, float inputMax, + float outputMin, float outputMax ) + { + var normalized = Normalize( value, inputMin, inputMax ); + return normalized * ( outputMax - outputMin ) + outputMin; + } + + public static float MapPositive( float value, float inputMax, float outputMax ) + { + return Map( value, 0, inputMax, 0, outputMax ); + } + + public static float MapClamped( float value, float inputMin, float inputMax, + float outputMin, float outputMax ) + { + var normalized = NormalizeClamped( value, inputMin, inputMax ); + return normalized * ( outputMax - outputMin ) + outputMin; + } + + public static float Map01( float value, float outputMin, float outputMax ) + { + return value * ( outputMax - outputMin ) + outputMin; + } + + public static float MapPolar( float value, float min, float max ) + { + return Map01( value * 0.5f + 0.5f, min, max ); + } + + public static float MapPolarTo01( float value) + { + return value * 0.5f + 0.5f; + } + + public static float Repeat( float value, float length ) + { + while ( value > length ) + { + value -=length; + } + + while ( value < 0 ) + { + value += length; + } + + return value; + } + + public static float Triangle( float value ) + { + value = MathX.Repeat( value, 1 ) * 2; + + if ( value > 1 ) + { + value = 2 - value; + } + + return value; + } + + public static float EaseSine( float value ) + { + return Mathf.Sin( Mathf.Pi * ( value * 0.5f + 1.5f ) ) + 1; + } + + public static int Sign( int value ) + { + return value == 0 ? 0 : value < 0 ? -1 : 1; + } + + + public static T LerpList( List data, float t, Func lerpElementsFunction, + int dataFillSize = -1 ) + { + dataFillSize = dataFillSize == -1 ? data.Count : dataFillSize; + var floatIndex = t * dataFillSize; + + if ( floatIndex <= 0 ) + { + return data[ 0 ]; + } + + if ( floatIndex >= ( dataFillSize - 1 ) ) + { + return data[ dataFillSize - 1 ]; + } + + var flooredIndex = Mathf.FloorToInt( floatIndex ); + var ceiledIndex = flooredIndex + 1; + + var flooredValue = data[ flooredIndex ]; + var ceiledValue = data[ ceiledIndex ]; + + var interpolationAmount = floatIndex - flooredIndex; + + return lerpElementsFunction( flooredValue, ceiledValue, interpolationAmount ); + + } + + public static float PolarTriangle( float value ) + { + return Triangle( value ) * 2f - 1f; + } + + public static float Step( float phase, float phaseStart, float phaseEnd ) + { + if ( phase < phaseStart ) + { + return 0; + } + + if ( phase >= phaseEnd ) + { + return 1; + } + + return ( phase - phaseStart ) / ( phaseStart - phaseEnd ); + } + + + public static int Repeat( int value, int range ) + { + while ( value < 0 ) + { + value += range; + } + + while ( value >= range ) + { + value -= range; + } + + return value; + } + + public static float PolarRepeat( float value, float range ) + { + while ( value < -range ) + { + value += range * 2; + } + + while ( value >= range ) + { + value -= range * 2; + } + + return value; + } + + + public static float Exponent( float base_, float power ) + { + return Mathf.Log( power ) / Mathf.Log( base_ ); + } + + public static float Base( float exponent, float power ) + { + return Mathf.Pow( power, 1f / exponent ); + } + + public static float SmoothingCoefficient( float ms, float reachingTarget = 0.1f, float frameDurationMS = 16.66666666f ) + { + return 1f - Base( ms / frameDurationMS, reachingTarget ); + } + + public static float SmoothValue( float oldValue, float newValue, float ms, float reachingTarget = 0.1f, float frameDurationMS = 16.66666666f ) + { + return oldValue + SmoothingCoefficient( ms, reachingTarget, frameDurationMS ) * ( newValue - oldValue ); + } + + public static float SmoothDegrees( float oldValue, float newValue, float ms, float reachingTarget = 0.1f, float frameDurationMS = 16.66666666f ) + { + oldValue = Mathf.Wrap( oldValue, 0, 360 ); + newValue = Mathf.Wrap( newValue, 0, 360 ); + + var difference = newValue - oldValue; + + if ( Mathf.Abs( difference ) > 180 ) + { + if ( newValue > oldValue ) + { + oldValue += 360; + } + else + { + newValue += 360; + } + } + + return oldValue + SmoothingCoefficient( ms, reachingTarget, frameDurationMS ) * ( newValue - oldValue ); + } + + public static Vector3 SmoothVector3( Vector3 oldValue, Vector3 newValue, float ms, float reachingTarget = 0.1f, float frameDurationMS = 16.66666666f ) + { + return oldValue + SmoothingCoefficient( ms, reachingTarget, frameDurationMS ) * ( newValue - oldValue ); + } + + + } +} \ No newline at end of file diff --git a/Runtime/Random/GodotRandom.cs b/Runtime/Random/GodotRandom.cs new file mode 100644 index 0000000..e69de29 diff --git a/Runtime/Random/LCG.cs b/Runtime/Random/LCG.cs new file mode 100644 index 0000000..495eccb --- /dev/null +++ b/Runtime/Random/LCG.cs @@ -0,0 +1,85 @@ +using System.Collections; +using System.Collections.Generic; +using System; +using Godot; + +namespace Rokojori +{ + [System.Serializable] + public class LCGSeedState + { + public int modulus; + public int multiplier; + public int increment; + public int state; + } + + public class LCG:SeedableRandomEngine + { + private LCGSeedState _seedState = new LCGSeedState(); + private float _normalizer; + + public LCG() + { + this.setParameters( (int)Mathf.Pow(2,32), 1664525, 1013904223 ); + } + + public static LCG Randomized() + { + var ms = Time.GetUnixTimeFromSystem() % 1; + var seed = (int) ( ms * 10000 ); + var lcg = new LCG(); + RJLog.Log( "Seed", seed, Time.GetUnixTimeFromSystem() ); + lcg.SetSeed( seed ); + lcg.Next(); + return lcg; + + } + + void setParameters( int modulus, int multiplier, int increment ) + { + _seedState.modulus = modulus; + _seedState.multiplier = multiplier; + _seedState.increment = increment; + _seedState.state = 0; + this._normalizer = 1f/(_seedState.modulus); + } + + public override object GetSeedState() + { + var seedState = new LCGSeedState(); + + seedState.modulus = _seedState.modulus; + seedState.multiplier = _seedState.multiplier; + seedState.increment = _seedState.increment; + seedState.state = _seedState.state; + + + return seedState; + } + + public override void SetSeedState( object seedStateObject ) + { + var seedState = (LCGSeedState) seedStateObject; + + _seedState.modulus = seedState.modulus; + _seedState.multiplier = seedState.multiplier; + _seedState.increment = seedState.increment; + _seedState.state = seedState.state; + this._normalizer = 1 / ( _seedState.modulus ); + } + + public override float Next() + { + _seedState.state = ( _seedState.state * _seedState.multiplier + _seedState.increment) % _seedState.modulus; + var value = _seedState.state * this._normalizer; + return Mathf.Abs( value ); + } + + public override void SetSeed( int seed ) + { + _seedState.state = seed % _seedState.modulus; + } + + } +} \ No newline at end of file diff --git a/Runtime/Random/RandomEngine.cs b/Runtime/Random/RandomEngine.cs new file mode 100644 index 0000000..91af38f --- /dev/null +++ b/Runtime/Random/RandomEngine.cs @@ -0,0 +1,219 @@ +using System.Collections; +using System.Collections.Generic; +using Godot; +using System; + + + +namespace Rokojori +{ + public abstract class RandomEngine + { + public abstract float Next(); + + public float Value( float scalar ) + { + return Next() * scalar; + } + + public float Range( float a, float b) + { + return this.Next()*( b - a ) + a; + } + + public float Polar() + { + return this.Next() * 2f - 1f; + } + + public float Polar( float value ) + { + return Polar() * value; + } + + public bool Bool() + { + return this.Next() > 0.5f; + } + + + public bool Chance( float value ) + { + return value / 100f >= Next(); + } + + public bool FlipCoin() + { + return Chance( 50f ); + } + + public float PercentageVariation( float variation ) + { + var value = ( 100f - variation ) / 100f; + return Range( value, 1f / value ); + } + + public bool WithChanceOf( float value ) + { + return ( this.Next() * 100 ) <= value ; + } + + public Vector3 Between( Vector3 a, Vector3 b ) + { + return a.Lerp( b, this.Next() ); + } + + public Color RandomHue( float saturation = 1f, float luminance = 0.5f) + { + var hue = Range( 0, 360 ); + var color = new HSLColor( hue, saturation, luminance ); + + return color; + } + + public Vector2 InRectangle( Vector2 min, Vector2 max ) + { + var x = Mathf.Lerp( min.X, max.X, Next() ); + var y = Mathf.Lerp( min.Y, max.Y, Next() ); + + return new Vector2( x, y ); + } + + public Vector3 InCube() + { + return new Vector3( Polar(), Polar(), Polar() ); + } + + public Vector3 InsideCube( float size ) + { + return InCube() * ( size * 0.5f ); + } + + public Vector3 InsideSphere() + { + var inCube = InCube(); + + if ( inCube.LengthSquared() > 1 ) + { + inCube = inCube.Normalized() * Next(); + } + + return inCube; + } + + public Vector3 OnSphere( float size ) + { + return OnSphere() * size; + } + + public Vector3 OnSphere() + { + var dir = InsideSphere(); + + while ( dir.LengthSquared() == 0 ) + { + dir = InsideSphere(); + } + + return dir; + } + + + public Vector3 InSphere( float size ) + { + return InsideSphere() * ( size * 0.5f ); + } + + public int IntegerInclusive( int min, int max ) + { + return (int) ( Mathf.Floor( this.Next() * ( max - min + 1 ) ) + min ) ; + } + + public int IntegerInclusive( int max ) + { + return IntegerInclusive( 0, max ); + } + + + public int IntegerExclusive( int min, int max ) + { + var nextValue = this.Next(); + var randomValue = nextValue * ( max - min ) + min; + + var value = (int) ( Mathf.Floor( randomValue ) ); + return Mathf.Min( max - 1, value ); + } + + public int IntegerExclusive( int max ) + { + return IntegerExclusive( 0, max ); + } + + + public char From( string source ) + { + var index = IntegerExclusive( source.Length ); + return source[ index ]; + } + + public T From( T[] array ) + { + if ( array.Length == 0 ) + { + return default ( T ); + } + var index = IntegerExclusive( array.Length ); + return array[ index ]; + } + + public T From( HashSet set ) + { + var selectedIndex = IntegerExclusive( set.Count ); + + var currentIndex = 0; + + foreach ( var e in set ) + { + if ( selectedIndex == currentIndex ) + { + return e; + } + + currentIndex++; + } + + return default( T ); + } + + public T FromValues( T first, params T[] values ) + { + if ( values.Length == 0 ) + { + return first; + } + + var index = IntegerExclusive( values.Length + 1 ); + + return index == 0 ? first : values[ index - 1 ]; + } + + public T From( List list ) + { + if ( list.Count == 0 ) + { + return default ( T ); + } + + var index = this.IntegerExclusive( 0, list.Count ); + + return list[ index ]; + } + } + + public abstract class SeedableRandomEngine:RandomEngine + { + public abstract void SetSeed( int number ); + public abstract object GetSeedState(); + public abstract void SetSeedState( object seedState ); + } +} diff --git a/Runtime/Text/JSON/JSON.cs b/Runtime/Text/JSON/JSON.cs new file mode 100644 index 0000000..5612e1a --- /dev/null +++ b/Runtime/Text/JSON/JSON.cs @@ -0,0 +1,35 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + +namespace Rokojori +{ + + public class JSON + { + public static string Stringify( JSONData jsonData ) + { + return jsonData.Stringify(); + } + + public static JSONData Parse( string jsonString ) + { + return new JSONParser().Parse( jsonString ); + } + + public static string StringifyObject( object value ) + { + var serializer = new JSONSerializer( new JSONSerializationSettings() ); + return serializer.Serialize( value ); + } + + public static T ParseObject( string jsonString ) where T:new() + { + var deserializer = new JSONDeserializer( new JSONSerializationSettings() ); + return deserializer.Deserialize( jsonString ); + } + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/JSONArray.cs b/Runtime/Text/JSON/JSONArray.cs new file mode 100644 index 0000000..bd5f494 --- /dev/null +++ b/Runtime/Text/JSON/JSONArray.cs @@ -0,0 +1,102 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + + +namespace Rokojori +{ + public class JSONArray:JSONData + { + List _values = new List(); + + public override JSONDataType dataType + { + get { return JSONDataType.ARRAY; } + } + + public List values { get { return _values; }} + + public int size { get { return _values.Count; } } + + public JSONData Get( int index ) + { + return _values[ index ]; + } + + + + public void Delete( int index ) + { + _values.RemoveAt( index ); + } + + public void Push( JSONData value ) {_values.Add( value );} + + public void Push( string value ) { Push( new JSONValue( value ) ); } + public void Push( double value ) { Push( new JSONValue( value ) ); } + public void Push( bool value ) { Push( new JSONValue( value ) ); } + + public void Set( int index, JSONData data ) + { + while ( index >= _values.Count ) + { + Push( new JSONValue( null ) ); + } + _values[ index ] = data; + } + + public void Set( int index, string value ) { Set( index, new JSONValue( value ) ); } + public void Set( int index, bool value ) { Set( index, new JSONValue( value ) ); } + public void Set( int index, double value ) { Set( index, new JSONValue( value ) ); } + + public JSONData this[ int index ] + { + get { return Get( index ); } + set { Set( index, value ); } + } + + public JSONData Pop() + { + return Lists.Pop( _values ); + } + + public override string Stringify( StringifyOptions options ) + { + var builder = new StringBuilder(); + + if ( values.Count == 0) + { + options.increaseIndent(); + builder.Append( "[]" ); + options.decreaseIndent(); + return builder.ToString(); + } + + options.increaseIndent(); + builder.Append( "[\n" ); + if ( values.Count > 0 ) + { + builder.Append( options.indent ); + builder.Append( values[ 0 ].Stringify( options ) ); + } + + for ( var i = 1; i < values.Count; i++ ) + { + builder.Append( ",\n" ); + builder.Append( options.indent ); + builder.Append( values[ i ].Stringify( options ) ); + } + + options.decreaseIndent(); + builder.Append( "\n" ); + builder.Append( options.indent ); + builder.Append( "]" ); + return builder.ToString(); + } + + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/JSONData.cs b/Runtime/Text/JSON/JSONData.cs new file mode 100644 index 0000000..0ed9448 --- /dev/null +++ b/Runtime/Text/JSON/JSONData.cs @@ -0,0 +1,232 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + + +namespace Rokojori +{ + public enum JSONDataType + { + BOOLEAN, + NUMBER, + STRING, + OBJECT, + ARRAY, + NULL + } + + public class StringifyOptions + { + public bool pretty = true; + public string indentString = " "; + + int _indentLevel = -1; + string _indent = ""; + + public void increaseIndent(){ _indentLevel++; UpdateIndent(); } + public void decreaseIndent(){ _indentLevel--; UpdateIndent(); } + + public string indent{ get { return _indent; }} + + void UpdateIndent() + { + _indent = ""; + + for ( var i = 0; i < _indentLevel; i++ ) + { + _indent += indentString; + } + } + } + + public abstract class JSONData + { + public abstract JSONDataType dataType { get; } + public abstract string Stringify( StringifyOptions options ); + + public string Stringify() + { + return Stringify( new StringifyOptions() ); + } + + public bool isArray + { + get { return dataType == JSONDataType.ARRAY; } + } + + public bool isObject + { + get { return dataType == JSONDataType.OBJECT; } + } + + public bool isNull + { + get { return dataType == JSONDataType.NULL; } + } + + public bool isNotNull + { + get { return dataType != JSONDataType.NULL; } + } + + public bool isNumber + { + get { return dataType == JSONDataType.NUMBER; } + } + + public bool isBoolean + { + get { return dataType == JSONDataType.BOOLEAN; } + } + + public bool isString + { + get { return dataType == JSONDataType.STRING; } + } + + public JSONArray AsArray() + { + if ( isArray ) + { + return (JSONArray)this; + } + + return null; + } + + public JSONObject AsObject() + { + if ( isObject ) + { + return (JSONObject)this; + } + + return null; + } + + + public static int GetInt( JSONData data, int alternative = 0 ) + { + if ( data == null || ! data.isNumber ) + { + return alternative; + } + + return data.intValue; + } + + public static float GetFloat( JSONData data, float alternative = 0 ) + { + if ( data == null || ! data.isNumber ) + { + return alternative; + } + + return data.floatValue; + } + + public static double GetNumber( JSONData data, double alternative = 0 ) + { + if ( data == null || ! data.isNumber ) + { + return alternative; + } + + return data.numberValue; + } + + public static bool GetBool( JSONData data, bool alternative = false ) + { + if ( data == null || ! data.isBoolean ) + { + return alternative; + } + + return data.booleanValue; + } + + public static string GetString( JSONData data, string alternative = "" ) + { + if ( data == null || ! data.isString ) + { + return alternative; + } + + return data.stringValue; + } + + public double numberValue + { + get + { + var value = (JSONValue) this; + return value.GetNumberValue(); + } + } + + public float floatValue + { + get + { + var value = (JSONValue) this; + return value.GetFloatValue(); + } + } + + + public int intValue + { + get + { + var value = (JSONValue) this; + return value.GetIntValue(); + } + } + + public bool booleanValue + { + get + { + var value = (JSONValue) this; + return value.GetBooleanValue(); + } + } + + public string stringValue + { + get + { + var value = (JSONValue) this; + return value.GetStringValue(); + } + } + + + public object enumValue( System.Type enumType ) + { + var value = intValue; + try + { + var enumValue = System.Enum.ToObject( enumType , intValue ); + return enumValue; + } + catch ( System.Exception e ) + { + RJLog.Log( + "Exception:", e, "\n", + "Couldn't parse enum value", value , + "JSON Data Type", dataType, + "Stringified Value:", JSON.Stringify( this ) + ); + } + + return null; + } + + + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/JSONLexer.cs b/Runtime/Text/JSON/JSONLexer.cs new file mode 100644 index 0000000..d49149d --- /dev/null +++ b/Runtime/Text/JSON/JSONLexer.cs @@ -0,0 +1,340 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + + +namespace Rokojori +{ + + public enum JSONLexerEventType + { + DONE_SUCCESS, + DONE_ERROR, + + OBJECT_START, + OBJECT_END, + ARRAY_START, + ARRAY_END, + IDENTIFIER, + STRING, + NUMBER, + TRUE, + FALSE, + NULL, + ARRAY_SEPERATOR, + IDENTIFIER_SEPERATOR, + + + ERROR_UNEXPECTED_SYMBOL, + ERROR_UNCLOSED_STRING, + ERROR_UNCLOSED_OBJECT, + ERROR_UNCLOSED_ARRAY, + ERROR_EXPECTED_FALSE, + ERROR_EXPECTED_TRUE, + ERROR_EXPECTED_NULL, + ERROR_INFINITY_PREVENTION + } + + public class JSONLexer + { + public static bool IsErrorType( JSONLexerEventType type ) + { + switch( type ) + { + case JSONLexerEventType.ERROR_UNEXPECTED_SYMBOL: + case JSONLexerEventType.ERROR_UNCLOSED_STRING: + case JSONLexerEventType.ERROR_UNCLOSED_OBJECT: + case JSONLexerEventType.ERROR_UNCLOSED_ARRAY: + case JSONLexerEventType.ERROR_EXPECTED_FALSE: + case JSONLexerEventType.ERROR_EXPECTED_TRUE: + case JSONLexerEventType.ERROR_EXPECTED_NULL: + case JSONLexerEventType.ERROR_INFINITY_PREVENTION: + case JSONLexerEventType.DONE_ERROR: + { + return true; + } + } + + return false; + } + + public delegate void OnParse( JSONLexerEventType type, int offset, int length ); + + string source; + OnParse onParseCallback; + + + + public void Lex( string source, OnParse onParseCallback = null ) + { + this.source = source; + this.onParseCallback = onParseCallback; + + Call( LexJSON(), 0 ); + + } + + void Call( JSONLexerEventType type, int offset, int length = -1 ) + { + if ( onParseCallback != null ) + { + onParseCallback( type, offset, length ); + } + } + + + + JSONLexerEventType LexJSON() + { + var offset = SkipWhiteSpace( 0 ); + + while ( offset < source.Length ) + { + var offsetStart = offset; + + var character = source[ offset ]; + + if ( character == '{' ) + { + Call( JSONLexerEventType.OBJECT_START, offset , 1 ); + } + else if ( character == '}' ) + { + Call( JSONLexerEventType.OBJECT_END, offset , 1 ); + } + else if ( character == '[' ) + { + Call( JSONLexerEventType.ARRAY_START, offset , 1 ); + } + else if ( character == ']' ) + { + Call( JSONLexerEventType.ARRAY_END, offset , 1 ); + } + else if ( character == ',' ) + { + Call( JSONLexerEventType.ARRAY_SEPERATOR, offset , 1 ); + } + else if ( character == ':' ) + { + Call( JSONLexerEventType.IDENTIFIER_SEPERATOR, offset , 1 ); + } + else if ( character == '\"' ) + { + offset = LexString( offset ); + } + else if ( character == 't' ) + { + offset = LexTrue( offset ); + } + else if ( character == 'f' ) + { + offset = LexFalse( offset ); + } + else if ( character == 'n' ) + { + offset = LexNull( offset ); + } + else if ( System.Char.IsDigit( character ) || character == '-' ) + { + offset = LexNumber( offset ); + } + + if ( offset == -1 ) + { + return JSONLexerEventType.DONE_ERROR; + } + + offset ++; + offset = SkipWhiteSpace( offset ); + + if ( offsetStart >= offset ) + { + Call( JSONLexerEventType.ERROR_INFINITY_PREVENTION, offsetStart ); + return JSONLexerEventType.DONE_ERROR; + } + } + + return JSONLexerEventType.DONE_SUCCESS; + } + + int SkipWhiteSpace( int offset ) + { + + while ( offset < source.Length && System.Char.IsWhiteSpace( source[ offset ] ) ) + { + offset ++; + } + + return offset; + } + + bool IsIdentifier( int offset ) + { + offset = SkipWhiteSpace( offset ); + return offset < source.Length && source[ offset ] == ':'; + } + + int LexString( int offset ) + { + var offsetStart = offset; + offset++; + + var maxTries = 10000; var currentTries = 0; + // currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + + while ( offset < source.Length ) + { + currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + + var character = source[ offset ]; + + if ( character == '\"' ) + { + var previousCharacter = source[ offset - 1 ]; + + if ( previousCharacter != '\\' ) + { + var length = ( offset - offsetStart ) + 1; + var isIdentifier = IsIdentifier( offset + 1 ); + var type = isIdentifier ? JSONLexerEventType.IDENTIFIER : + JSONLexerEventType.STRING; + Call( type, offsetStart, length ); + return ( offsetStart + length ) - 1; + } + } + + offset ++; + + } + + Call( JSONLexerEventType.ERROR_UNCLOSED_STRING, offsetStart ); + return -1; + } + + int LexTrue( int offset ) + { + if ( MatchNextThree( offset, 'r', 'u', 'e' ) ) + { + Call( JSONLexerEventType.TRUE, offset, 4 ); + return offset + 3; + } + + Call( JSONLexerEventType.ERROR_EXPECTED_TRUE, offset ); + return -1; + } + + int LexFalse( int offset ) + { + if ( MatchNextFour( offset, 'a', 'l', 's', 'e' ) ) + { + Call( JSONLexerEventType.FALSE, offset, 5 ); + return offset + 4; + } + Call( JSONLexerEventType.ERROR_EXPECTED_FALSE, offset ); + return -1; + } + + int LexNull( int offset ) + { + if ( MatchNextThree( offset, 'u', 'l', 'l' ) ) + { + Call( JSONLexerEventType.NULL, offset, 4 ); + return offset + 3; + } + + Call( JSONLexerEventType.ERROR_EXPECTED_NULL, offset ); + + return -1; + } + + int LexNumber( int offset ) + { + var hasDot = false; + var hasE = false; + var hasMinus = false; + var parsing = true; + + var offsetStart = offset; + + var maxTries = 100; var currentTries = 0; + // currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + + while ( parsing && offset < source.Length ) + { + currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + var character = source[ offset ]; + + parsing = false; + + if ( System.Char.IsDigit( character ) ) + { + parsing = true; + } + else if ( character == '-' && ! hasMinus ) + { + hasMinus = true; + parsing = true; + } + else if ( character == '.' && ! hasDot ) + { + hasDot = true; + parsing = true; + } + else if ( ( character == 'e' || character == 'E' ) && ! hasE ) + { + var hasNext = offset + 2 < source.Length; + + if ( hasNext ) + { + var nextCharacter = source[ offset + 1 ]; + hasE = nextCharacter == '+' || nextCharacter == '-'; + parsing = hasE; + } + + if ( parsing ) + { + offset ++; + } + + } + + if ( parsing ) + { + offset ++; + } + + } + + var length = ( offset - offsetStart ); + Call( JSONLexerEventType.NUMBER, offsetStart, length ); + + return ( offsetStart + length ) - 1; + } + + bool MatchNextThree( int offset, char next, char second, char third ) + { + if ( offset + 3 >= source.Length ) { return false; } + if ( source[ offset + 1 ] != next ) { return false; } + if ( source[ offset + 2 ] != second ){ return false; } + if ( source[ offset + 3 ] != third ) { return false; } + + return true; + } + + bool MatchNextFour( int offset, char next, char second, char third, char fourth ) + { + if ( offset + 4 >= source.Length ) { return false; } + if ( source[ offset + 1 ] != next ) { return false; } + if ( source[ offset + 2 ] != second ){ return false; } + if ( source[ offset + 3 ] != third ) { return false; } + if ( source[ offset + 4 ] != fourth ){ return false; } + + return true; + } + + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/JSONObject.cs b/Runtime/Text/JSON/JSONObject.cs new file mode 100644 index 0000000..6b9b6ba --- /dev/null +++ b/Runtime/Text/JSON/JSONObject.cs @@ -0,0 +1,146 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + + + + + +namespace Rokojori +{ + public class JSONObject:JSONData + { + List _keys = new List(); + List _values = new List(); + + public override JSONDataType dataType + { + get { return JSONDataType.OBJECT; } + } + + public List keys { get { return _keys; }} + public List values { get { return _values; }} + + public int size { get { return _keys.Count; } } + + public JSONData Get( string key ) + { + var index = _keys.IndexOf( key ); + return index == -1 ? null : _values[ index ]; + } + + public string GetString( string key ){ return Get( key ).stringValue; } + public double GetNumber( string key ){ return Get( key ).numberValue; } + public int GetInt( string key ){ return Get( key ).intValue; } + public float GetFloat( string key ){ return Get( key ).floatValue; } + public bool GetBoolean( string key ){ return Get( key ).booleanValue; } + + public T GetEnum( string key ) + { + var value = System.Enum.Parse( typeof( T ), GetString( key ) ); + return (T) value; + } + + public double GetNumberOr( string key, double defaultFallback ) + { + var index = _keys.IndexOf( key ); + + if ( index != -1 ) + { + var value = _values[ index ]; + return value.isNumber ? value.numberValue : defaultFallback; + } + + return defaultFallback; + } + + public bool Contains( string key ) + { + return _keys.Contains( key ); + } + + public void Delete( string key ) + { + var index = _keys.IndexOf( key ); + + if ( index != -1 ) + { + _keys.RemoveAt( index ); + _values.RemoveAt( index ); + } + } + + public void Set( string key, JSONData value ) + { + var index = _keys.IndexOf( key ); + + if ( index == -1 ) + { + _keys.Add( key ); + _values.Add( value ); + } + else + { + _values[ index ] = value; + } + + } + + public void Set( string key, double value ){ Set( key, new JSONValue( value ) ); } + public void Set( string key, string value ){ Set( key, new JSONValue( value ) ); } + public void Set( string key, bool value ){ Set( key, new JSONValue( value ) ); } + public void SetEnum( string key, object value) + { + var stringValue = System.Enum.GetName( typeof( T ), value ); + Set( key, stringValue ); + } + + public override string Stringify( StringifyOptions options ) + { + options.increaseIndent(); + var builder = new StringBuilder(); + + if ( values.Count == 0 ) + { + builder.Append( "{}" ); + options.decreaseIndent(); + return builder.ToString(); + } + + + builder.Append( "{\n" ); + + if ( values.Count > 0 ) + { + builder.Append( options.indent ); + JSONStringConverter.Write( builder, keys[ 0 ] ); + builder.Append( ": " ); + builder.Append( values[ 0 ].Stringify( options ) ); + } + + for ( var i = 1; i < values.Count; i++ ) + { + builder.Append( ",\n" ); + builder.Append( options.indent ); + JSONStringConverter.Write( builder, keys[ i ] ); + builder.Append( ": " ); + builder.Append( values[ i ].Stringify( options ) ); + } + + options.decreaseIndent(); + builder.Append( "\n" ); + builder.Append( options.indent ); + builder.Append( "}" ); + + + + return builder.ToString(); + } + + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/JSONParser.cs b/Runtime/Text/JSON/JSONParser.cs new file mode 100644 index 0000000..befcf98 --- /dev/null +++ b/Runtime/Text/JSON/JSONParser.cs @@ -0,0 +1,227 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + +using Godot; + +namespace Rokojori +{ + using LexerType = JSONLexerEventType; + + public class JSONParser + { + List stack = new List(); + + JSONArray currentArray = null; + JSONObject currentObject = null; + JSONData current = null; + bool currentIsArray = false; + JSONData root = null; + + string identifier = null; + string source = null; + bool hasError = false; + JSONObject errorReport = null; + + void Reset() + { + stack = new List(); + + currentArray = null; + currentObject = null; + current = null; + currentIsArray = false; + root = null; + + identifier = null; + source = null; + } + + void ProcessJSONData( JSONData jsonData ) + { + if ( current == null ) + { + root = jsonData; + } + else if ( currentIsArray ) + { + currentArray.Push( jsonData ); + } + else + { + currentObject.Set( identifier, jsonData ); + } + } + + public static bool SHOW_DEBUG_INFO = false; + + void OnParse( LexerType type, int offset, int length ) + { + if ( hasError ) { return; } + + if ( SHOW_DEBUG_INFO ) + { + RJLog.Log(type, offset, length ); + + if ( offset < source.Length && length > 0 && ( offset + length ) < source.Length ) + { + RJLog.Log("'" + source.Substring( offset, length ) + "'" ); + } + + } + + switch ( type ) + { + case LexerType.NUMBER: + { + var stringValue = source.Substring( offset, length ); + //double numberValue = 0; + double numberValue = RegexUtility.ParseDouble( stringValue ); + //System.Double.TryParse( stringValue, out numberValue ); + ProcessJSONData( new JSONValue( numberValue ) ); + } + break; + + case LexerType.STRING: + { + var stringValue = new StringBuilder(); + JSONStringConverter.Read( stringValue, source, offset, length ); + ProcessJSONData( new JSONValue( stringValue.ToString() ) ); + } + break; + + case LexerType.IDENTIFIER: + { + var stringValue = new StringBuilder(); + JSONStringConverter.Read( stringValue, source, offset, length ); + identifier = stringValue.ToString(); + } + break; + + case LexerType.NULL: + case LexerType.TRUE: + case LexerType.FALSE: + { + JSONData jsonData = new JSONValue(); + + if ( LexerType.NULL != type ) + { jsonData = new JSONValue( LexerType.TRUE == type ); } + + ProcessJSONData( jsonData ); + } + break; + + case LexerType.ARRAY_START: + case LexerType.OBJECT_START: + { + var isArrayStart = LexerType.ARRAY_START == type; + + JSONData jsonData = null; + if ( isArrayStart ){ jsonData = new JSONArray(); } + else { jsonData = new JSONObject(); } + + ProcessJSONData( jsonData ); + + current = jsonData; + + if ( isArrayStart ) + { + currentArray = (JSONArray) jsonData; + currentObject = null; + } + else + { + currentObject = (JSONObject) jsonData; + currentArray = null; + } + + stack.Add( current ); + currentIsArray = isArrayStart; + } + break; + + case LexerType.ARRAY_END: + case LexerType.OBJECT_END: + { + Lists.Pop( stack ); + current = Lists.Last( stack ); + + if ( current is JSONArray ) + { + currentArray = (JSONArray) current; + currentObject = null; + currentIsArray = true; + } + else if ( current is JSONObject ) + { + currentArray = null; + currentObject = (JSONObject) current; + currentIsArray = false; + } + + } + break; + + case LexerType.ARRAY_SEPERATOR: + case LexerType.IDENTIFIER_SEPERATOR: + { + + } + break; + + case LexerType.DONE_SUCCESS: + { + + } + break; + + + // ERRORS: + default: + { + hasError = true; + CreateErrorReport( type, offset, length ); + } + break; + } + } + + void CreateErrorReport( LexerType type, int offset, int length ) + { + var linesMapper = new TextLinesMapper(); + linesMapper.Map( source ); + errorReport = new JSONObject(); + + var end = offset + Mathf.Max( length, 0 ); + var linesInfo = linesMapper.GetTextEditorInfo( offset, end ); + var snippet = linesMapper.GetTextEditorSnippet( source, offset, end ); + + errorReport.Set( "errorType", type + "" ); + errorReport.Set( "linesInfo", linesInfo ); + errorReport.Set( "snippet", snippet ); + + } + + public JSONData Parse( string source ) + { + Reset(); + + this.source = source; + + var lexer = new JSONLexer(); + lexer.Lex( source, this.OnParse ); + + if ( hasError ) + { + RJLog.Log( errorReport.Stringify() ); + return null; + } + + return root; + + } + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/JSONStringConverter.cs b/Runtime/Text/JSON/JSONStringConverter.cs new file mode 100644 index 0000000..5b89822 --- /dev/null +++ b/Runtime/Text/JSON/JSONStringConverter.cs @@ -0,0 +1,215 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; +using System.Threading.Tasks; + + + +namespace Rokojori +{ + public class JSONStringConverter + { + static bool ContainsBackslash( string dataFromFile, int start, int length ) + { + var end = start + length; + for ( var i = start; i < end; i++ ) + { + if ( dataFromFile[ i ] == '\\' ) { return true; } + } + + return false; + } + + public static string Read( string dataFromFile ) + { + var output = new StringBuilder(); + Read( output, dataFromFile, 0, dataFromFile.Length ); + return output.ToString(); + } + + public static void Read( StringBuilder output, string dataFromFile, int start, int length ) + { + ReadWithoutQuotes( output, dataFromFile, start + 1, length - 2 ); + } + + public static void Read( StringBuilder output, string dataFromFile ) + { + Read( output, dataFromFile, 0, dataFromFile.Length ); + } + + public static void ReadWithoutQuotes( StringBuilder output, string dataFromFile, int start, int length ) + { + if ( ! JSONStringConverter.ContainsBackslash( dataFromFile, start, length ) ) + { + output.Append( dataFromFile.Substring( start, length ) ); + return; + } + + + var end = start + length; + + for ( var i = start ; i < end; i++ ) + { + var rawCharacter = dataFromFile[ i ]; + + if ( rawCharacter == '\\' ) + { + if ( i == end - 1 ) { return; } + + var nextRawCharacter = dataFromFile[ i + 1 ]; + + if ( nextRawCharacter == 'u' ) + { + var hexStringStart = i + 2; + var hexString = dataFromFile.Substring( hexStringStart, 4 ); + var unicodeValue = ReadUnicodeFromHexString( hexString ); + + output.Append( unicodeValue ); + + i += 5; + } + else + { + var escapedCharacter = ReadSingleEscaped( nextRawCharacter ); + output.Append( escapedCharacter ); + + i ++; + } + + + } + else + { + output.Append( rawCharacter ); + } + } + + } + + static char ReadSingleEscaped( char character ) + { + switch ( character ) + { + case 'b': return '\b'; + case 'f': return '\f'; + case 'n': return '\n'; + case 'r': return '\r'; + case 't': return '\t'; + + default: return character; + } + } + + static char ReadUnicodeFromHexString( string hexString ) + { + return (char) int.Parse( hexString, System.Globalization.NumberStyles.HexNumber ); + } + + static readonly char[] ESCAPE_CHARACTERS = new char[] + { + '\"', '\\', '/', '\b', '\f', '\n', '\r', '\t' + }; + + static readonly string[] ESCAPING_SEQUENCES = new string[] + { + "\\\"", "\\\\", "\\/", "\\b", "\\f", "\\n", "\\r", "\\t" + }; + + public static string Write( string dataFromMemory ) + { + var output = new StringBuilder(); + Write( output, dataFromMemory, 0, dataFromMemory.Length ); + return output.ToString(); + } + + public static void Write( StringBuilder output, string dataFromMemory, int start, int length ) + { + output.Append( "\"" ); + WriteWithoutQuotes( output, dataFromMemory, start, length ); + output.Append( "\"" ); + } + + public static void Write( StringBuilder output, string dataFromMemory ) + { + Write( output, dataFromMemory, 0, dataFromMemory.Length ); + } + + + public static void WriteWithoutQuotes( StringBuilder output, string dataFromMemory, int start, int length ) + { + var end = start + length; + var index = IndexOfEscapeCharacter( dataFromMemory, start, end ); + + if ( index == -1 ) + { + output.Append( dataFromMemory.Substring( start, length ) ); + return; + } + + + for ( var i = 0; i < end; i++ ) + { + var intValue = ( int ) dataFromMemory[ i ]; + + if ( intValue > 127 ) + { + var escapedUnicodeValue = "\\u" + intValue.ToString( "x4" ); + output.Append( escapedUnicodeValue ); + + continue; + } + + var escapeIndex = GetEscapeIndex( dataFromMemory[ i ] ); + + if ( escapeIndex != -1 ) + { + output.Append( ESCAPING_SEQUENCES[ escapeIndex ] ); + } + else + { + output.Append( dataFromMemory[ i ] ); + } + } + + } + + static int IndexOfEscapeCharacter( string dataFromMemory, int start, int end ) + { + for ( var i = start; i < end; i++ ) + { + var intValue = ( int ) dataFromMemory[ i ]; + + if ( intValue > 127 ) + { + return i; + } + + var escapeIndex = GetEscapeIndex( dataFromMemory[ i ] ); + + if ( escapeIndex != -1 ) + { + return i; + } + } + + return -1; + } + + static int GetEscapeIndex( char c ) + { + for ( int i = 0; i < ESCAPE_CHARACTERS.Length; i++ ) + { + if ( ESCAPE_CHARACTERS[ i ] == c ) + { + return i; + } + } + + return -1; + + } + + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/JSONValue.cs b/Runtime/Text/JSON/JSONValue.cs new file mode 100644 index 0000000..0e56afc --- /dev/null +++ b/Runtime/Text/JSON/JSONValue.cs @@ -0,0 +1,82 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + +namespace Rokojori +{ + public class JSONValue:JSONData + { + JSONDataType _dataType; + double _numberValue = 0; + bool _booleanValue = false; + string _stringValue = ""; + + public override JSONDataType dataType + { + get { return _dataType; } + } + + public JSONValue(){ SetNull(); } + public JSONValue( string value ){ Set( value ); } + public JSONValue( double value ){ Set( value ); } + public JSONValue( bool value ){ Set( value ); } + + + private void Set( double number ) + { + _numberValue = number; + _dataType = JSONDataType.NUMBER; + } + + private void Set( string value ) + { + _stringValue = value; + _dataType = value == null ? JSONDataType.NULL : JSONDataType.STRING; + } + + private void Set( bool flag ) + { + _booleanValue = flag; + _dataType = JSONDataType.BOOLEAN; + } + + private void SetNull() + { + _dataType = JSONDataType.NULL; + } + + public double GetNumberValue(){ return _numberValue; } + public float GetFloatValue() { return (float) _numberValue; } + public int GetIntValue(){ return (int) System.Math.Round( _numberValue ); } + public bool GetBooleanValue(){ return _booleanValue; } + public string GetStringValue(){ return _stringValue; } + public T GetEnumFromString( T enumValue ) where T : System.Enum + { + //System.Enum.TryParse( _stringValue, out T enumValue); + return enumValue; + } + + public override string Stringify( StringifyOptions options ) + { + if ( JSONDataType.STRING == _dataType ) + { + var output = new StringBuilder(); + JSONStringConverter.Write( output, _stringValue, 0, _stringValue.Length ); + return output.ToString(); + } + else if ( JSONDataType.NUMBER == _dataType ) + { + return RegexUtility.WriteDouble( _numberValue ); + } + else if ( JSONDataType.BOOLEAN == _dataType ) + { + return _booleanValue ? "true" : "false"; + } + + return "null"; + } + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/BigIntegerSerializer.cs b/Runtime/Text/JSON/Serializers/BigIntegerSerializer.cs new file mode 100644 index 0000000..d90b42f --- /dev/null +++ b/Runtime/Text/JSON/Serializers/BigIntegerSerializer.cs @@ -0,0 +1,40 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text; +using System.Globalization; +using System; +using System.Numerics; + + + + + +namespace Rokojori +{ + public class BigIntegerSerializer: CustomSerializer + { + public override List HandlingTypes() + { + return new List(){ typeof( BigInteger ) }; + } + + + public override JSONData Serialize( object value ) + { + var bigInteger = (BigInteger) value; + return new JSONValue( bigInteger.ToString( "R" ) ); + } + + public override void Deserialize( JSONData data, Reference referenceRelation ) + { + if ( referenceRelation.target == null ) + { + return; + } + + var bigInteger = BigInteger.Parse( data.stringValue ); + + referenceRelation.AssignValue( bigInteger ); + } + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/ColorSerializer.cs b/Runtime/Text/JSON/Serializers/ColorSerializer.cs new file mode 100644 index 0000000..edb8b81 --- /dev/null +++ b/Runtime/Text/JSON/Serializers/ColorSerializer.cs @@ -0,0 +1,54 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; +using System.Globalization; +using System; + +using Godot; + + + + + +namespace Rokojori +{ + public class ColorSerializer: CustomSerializer + { + public override List HandlingTypes() + { + return new List(){ typeof( Color ) }; + } + + + public override JSONData Serialize( object value ) + { + var color = (Color) value; + var jsonArray = new JSONArray(); + jsonArray.Push( color.R ); + jsonArray.Push( color.G ); + jsonArray.Push( color.B ); + jsonArray.Push( color.A ); + + return jsonArray; + } + + public override void Deserialize( JSONData data, Reference referenceRelation ) + { + if ( referenceRelation.target == null ) + { + return; + } + var array = data.AsArray(); + + var color = new Color( + array.Get( 0 ).floatValue, + array.Get( 1 ).floatValue, + array.Get( 2 ).floatValue, + array.Get( 3 ).floatValue + ); + + referenceRelation.AssignValue( color ); + } + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/CustomSerializer.cs b/Runtime/Text/JSON/Serializers/CustomSerializer.cs new file mode 100644 index 0000000..f34f1c9 --- /dev/null +++ b/Runtime/Text/JSON/Serializers/CustomSerializer.cs @@ -0,0 +1,18 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + +using System; + +namespace Rokojori +{ + public abstract class CustomSerializer + { + public abstract List HandlingTypes(); + public abstract JSONData Serialize( object value ); + public abstract void Deserialize( JSONData data, Reference reference ); + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/DateTimeSerializer.cs b/Runtime/Text/JSON/Serializers/DateTimeSerializer.cs new file mode 100644 index 0000000..2dceff5 --- /dev/null +++ b/Runtime/Text/JSON/Serializers/DateTimeSerializer.cs @@ -0,0 +1,42 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; +using System.Globalization; +using System; + + + + + +namespace Rokojori +{ + public class DateTimeSerializer: CustomSerializer + { + public override List HandlingTypes() + { + return new List(){ typeof( DateTime ) }; + } + + + public override JSONData Serialize( object value ) + { + var dateTime = (DateTime) value; + return new JSONValue( dateTime.ToString( "o" ) ); + } + + public override void Deserialize( JSONData data, Reference referenceRelation ) + { + if ( referenceRelation.target == null ) + { + return; + } + + var dateTime = System.DateTime.Parse( data.stringValue, + CultureInfo.InvariantCulture, + DateTimeStyles.RoundtripKind ); + + referenceRelation.AssignValue( dateTime ); + } + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/JSONAlwaysProcessable.cs b/Runtime/Text/JSON/Serializers/JSONAlwaysProcessable.cs new file mode 100644 index 0000000..f18a663 --- /dev/null +++ b/Runtime/Text/JSON/Serializers/JSONAlwaysProcessable.cs @@ -0,0 +1,18 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + +using System; + +using System.Numerics; + +namespace Rokojori +{ + public class JSONAlwaysProcessable: System.Attribute + { + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/JSONDeserializer.cs b/Runtime/Text/JSON/Serializers/JSONDeserializer.cs new file mode 100644 index 0000000..e65ef9f --- /dev/null +++ b/Runtime/Text/JSON/Serializers/JSONDeserializer.cs @@ -0,0 +1,397 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + +using System; + + +namespace Rokojori +{ + public class JSONDeserializer + { + JSONSerializationSettings settings = new JSONSerializationSettings(); + Dictionary customSerializers = null; + + + public JSONDeserializer ( JSONSerializationSettings settings ) + { + this.settings = settings == null ? new JSONSerializationSettings() : settings; + } + + public T Deserialize( string data ) where T:new() + { + return Deserialize( JSON.Parse( data ).AsObject() ); + } + + public T Deserialize( JSONObject jsonObject ) where T:new() + { + Initialize(); + + var output = new T(); + var keys = jsonObject.keys; + + for ( int i = 0; i < keys.Count; i++) + { + var key = keys[ i ]; + DeserializeMemberField( jsonObject.Get( key ), output, key ); + } + + return output; + } + + public void Deserialize( string data, T output ) + { + Deserialize( JSON.Parse( data ).AsObject(), output ); + } + + public void Deserialize( JSONObject jsonObject, T output ) + { + Initialize(); + + var keys = jsonObject.keys; + + for ( int i = 0; i < keys.Count; i++) + { + var key = keys[ i ]; + DeserializeMemberField( jsonObject.Get( key ), output, key ); + } + } + + void DeserializeMemberField( JSONData data, object parent, string name ) + { + if ( data.isNull ) + { + SetMemberValue( parent, name, null ); + return; + } + + var type = parent.GetType(); + var field = type.GetField( name ); + + if ( field == null ) + { + RJLog.Log( "Field not present: " + name ); + return; + } + + var reference = new Reference( parent, name ); + var fieldType = field.FieldType; + + AssignValue( data, reference, fieldType ); + + } + + void DeserializeListField( JSONData data, IList parent, int index ) + { + if ( data.isNull ) + { + SetListValue( parent, index, null ); + return; + } + + var type = parent.GetType(); + var reference = new Reference( parent, index ); + var listType = type.GetGenericArguments()[ 0 ]; + + AssignValue( data, reference, listType ); + } + + void DeserializeDictionaryField( JSONData data, IDictionary parent, string key, int index ) + { + var type = parent.GetType(); + var isIndexed = type.GetGenericArguments()[ 0 ] == typeof( int ); + + if ( data.isNull ) + { + if ( isIndexed ) + { + SetDictionaryValue( parent, index, null ); + } + else + { + SetDictionaryValue( parent, key, null ); + } + return; + } + + + var reference = isIndexed ? new Reference( parent, index ) : new Reference( parent, key ); + var valueType = type.GetGenericArguments()[ 1 ]; + + AssignValue( data, reference, valueType ); + } + + void AssignValue( JSONData data, Reference reference, Type type ) + { + var customSerializer = GetCustomDeserializer( type ); + + if ( customSerializer != null ) + { + customSerializer.Deserialize( data, reference ); + return; + } + + if ( typeof( int ) == type ) + { + SetNumber( data, reference, INT ); + } + else if ( typeof( float ) == type ) + { + SetNumber( data, reference, FLOAT ); + } + else if ( typeof( double ) == type ) + { + SetNumber( data, reference, DOUBLE ); + } + else if ( typeof( bool ) == type ) + { + if ( ! data.isBoolean ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + reference.AssignValue( data.booleanValue ); + } + else if ( type.IsEnum ) + { + reference.AssignValue( data.enumValue( type ) ); + } + else if ( typeof( string ) == type ) + { + if ( ! data.isString ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + reference.AssignValue( data.stringValue ); + } + else if ( ReflectionHelper.IsList( type ) ) + { + if ( ! data.isArray ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + + reference.AssignValue( CreateList( data, type ) ); + } + else if ( IsSerializableDictionary( type ) ) + { + if ( ! data.isObject ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + + reference.AssignValue( CreateDictionary( data, type ) ); + } + else + { + if ( ! data.isObject ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + + reference.AssignValue( CreateObject( data, type ) ); + } + } + + IList CreateList( JSONData data, Type fieldType ) + { + var array = data.AsArray(); + var list = (IList) Activator.CreateInstance( fieldType ); + + for ( int i = 0 ; i < array.size; i++ ) + { + var jsonValue = array.Get( i ); + DeserializeListField( jsonValue, list, i ); + } + + return list; + } + + IDictionary CreateDictionary( JSONData data, Type fieldType ) + { + var map = data.AsObject(); + var dict = (IDictionary) Activator.CreateInstance( fieldType ); + var keys = map.keys; + + var isIndexed = dict.GetType().GetGenericArguments()[ 0 ] == typeof( int ); + + if ( isIndexed ) + { + for ( int i = 0 ; i < keys.Count; i++ ) + { + var jsonValue = map.Get( keys[ i ] ); + var index = RegexUtility.ParseInt( keys[ i ] ); + DeserializeDictionaryField( jsonValue, dict, "", index ); + } + } + else + { + for ( int i = 0 ; i < keys.Count; i++ ) + { + var jsonValue = map.Get( keys[ i ] ); + DeserializeDictionaryField( jsonValue, dict, keys[ i ], 0 ); + } + } + + return dict; + } + + object CreateObject( JSONData data, Type type ) + { + var output = Activator.CreateInstance( type ); + var jsonObject = data.AsObject(); + var keys = jsonObject.keys; + + for ( int i = 0; i < keys.Count; i++) + { + var key = keys[ i ]; + DeserializeMemberField( jsonObject.Get( key ), output, key ); + } + + return output; + } + + void SetMemberValue( object instance, string name, object value ) + { + ReflectionHelper.SetMemberValue( instance, name, value ); + } + + void SetListValue( IList list, int index, object value ) + { + list[ index ] = value; + } + + void SetDictionaryValue( IDictionary dictionary, string index, object value ) + { + dictionary[ index ] = value; + } + + void SetDictionaryValue( IDictionary dictionary, int index, object value ) + { + dictionary[ index ] = value; + } + + + + const int INT = 0; + const int FLOAT = 1; + const int DOUBLE = 2; + + void SetNumber( JSONData data, Reference reference, int numberType ) + { + if ( ! settings.saveNumbersWithType ) + { + if ( ! data.isNumber ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + + switch ( numberType ) + { + case INT:{ reference.AssignValue( data.intValue ); return; } + case FLOAT:{ reference.AssignValue( data.floatValue ); return; } + case DOUBLE:{ reference.AssignValue( data.numberValue ); return; } + } + + RJLog.Log( "Unknown number type: " + reference.GetInfo() + ">>" + data ); + return; + + + } + + if ( ! data.isObject ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + + var objectValue = data.AsObject(); + + if ( ! objectValue.Contains( JSONSerializationSettings.NUMBER_VALUE ) ) + { + RJLog.Log( "Type not matching: " + reference.GetInfo() + ">>" + data ); + return; + } + + switch ( numberType ) + { + case INT: + { + var value = objectValue.Get( JSONSerializationSettings.NUMBER_VALUE ).intValue; + reference.AssignValue( value ); + } + break; + + case FLOAT: + { + var value = objectValue.Get( JSONSerializationSettings.NUMBER_VALUE ).floatValue; + reference.AssignValue( value ); + } + break; + + case DOUBLE: + { + var value = objectValue.Get( JSONSerializationSettings.NUMBER_VALUE ).numberValue; + reference.AssignValue( value ); + } + break; + + } + + } + + void Initialize() + { + if ( customSerializers != null ){ return ;} + + customSerializers = new Dictionary(); + + settings.customSerializers.ForEach( s => AddSerializer( s ) ); + + JSONSerializationSettings.defaultSerializers.ForEach( s => AddSerializer( s ) ); + } + + void AddSerializer( CustomSerializer serializer ) + { + var types = serializer.HandlingTypes(); + types.ForEach( type => AddSerializerForType( type, serializer ) ); + + } + + void AddSerializerForType( Type type, CustomSerializer serializer ) + { + if ( customSerializers.ContainsKey( type ) ) + { + return; + } + + customSerializers[ type ] = serializer; + } + + + CustomSerializer GetCustomDeserializer( Type type ) + { + + if ( customSerializers.ContainsKey( type ) ) + { + return customSerializers[ type ]; + } + + return null; + } + + static bool IsSerializableDictionary( Type type ) + { + return JSONSerializationSettings.IsSerializableDictionary( type ); + } + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/JSONSerializer.cs b/Runtime/Text/JSON/Serializers/JSONSerializer.cs new file mode 100644 index 0000000..9d8362b --- /dev/null +++ b/Runtime/Text/JSON/Serializers/JSONSerializer.cs @@ -0,0 +1,429 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + +using System; +using System.Linq; + +using System.Numerics; + +namespace Rokojori +{ + public class JSONSerializer + { + JSONSerializationSettings settings = new JSONSerializationSettings(); + HashSet processedObjects = new HashSet(); + HashSet alwaysReprocessTypes = new HashSet() + { + typeof( DateTime ), typeof( BigInteger ) + }; + + public JSONSerializer ( JSONSerializationSettings settings = null ) + { + this.settings = settings == null ? new JSONSerializationSettings() : settings; + } + + Dictionary customSerializers = null; + + public string Serialize( object value ) + { + + Initialize(); + + if ( value == null ) + { + return JSON.Stringify( new JSONValue() ); + } + else if ( value is int ) + { + return JSON.Stringify( CreateNumber( (int) value ) ); + } + else if ( value is double ) + { + return JSON.Stringify( CreateNumber( (double) value ) ); + } + else if ( value is float ) + { + return JSON.Stringify( CreateNumber( (float) value ) ); + } + else if ( value is string ) + { + return JSON.Stringify( new JSONValue( (string) value ) ); + } + else if ( value is bool ) + { + return JSON.Stringify( new JSONValue( (bool) value ) ); + } + else if ( ReflectionHelper.IsList( value ) ) + { + return JSON.Stringify( CreateArray( value as IList ) ); + } + else if ( IsSerializableDictionary( value ) ) + { + return JSON.Stringify( CreateMapLikeObject( value as IDictionary ) ); + } + else + { + var serializer = GetCustomSerializer( value ); + + if ( serializer != null ) + { + return JSON.Stringify( serializer.Serialize( value ) ); + } + else + { + return JSON.Stringify( CreateObject( value ) ); + } + + } + } + + void Initialize() + { + processedObjects.Clear(); + + if ( customSerializers != null ){ return ;} + + customSerializers = new Dictionary(); + + settings.customSerializers.ForEach( s => AddSerializer( s ) ); + + JSONSerializationSettings.defaultSerializers.ForEach( s => AddSerializer( s ) ); + } + + void AddSerializer( CustomSerializer serializer ) + { + var types = serializer.HandlingTypes(); + types.ForEach( type => AddSerializerForType( type, serializer ) ); + + } + + void AddSerializerForType( Type type, CustomSerializer serializer ) + { + if ( customSerializers.ContainsKey( type ) ) + { + return; + } + + customSerializers[ type ] = serializer; + } + + + CustomSerializer GetCustomSerializer( object value ) + { + if ( value == null ){ return null; } + + var type = value.GetType(); + + if ( customSerializers.ContainsKey( type ) ) + { + return customSerializers[ type ]; + } + + return null; + } + + static bool IsSerializableDictionary( object value ) + { + return JSONSerializationSettings.IsSerializableDictionary( value ); + } + + + + JSONData CreateNumber( int value ) + { + if ( settings.saveNumbersWithType ) + { + var jsonObject = new JSONObject(); + jsonObject.Set( JSONSerializationSettings.NUMBER_TYPE, JSONSerializationSettings.INT_NUMBER_TYPE ); + jsonObject.Set( JSONSerializationSettings.NUMBER_VALUE, value ); + + return jsonObject; + } + + return new JSONValue( value ); + } + + JSONData CreateNumber( float value ) + { + if ( settings.saveNumbersWithType ) + { + var jsonObject = new JSONObject(); + jsonObject.Set( JSONSerializationSettings.NUMBER_TYPE, JSONSerializationSettings.FLOAT_NUMBER_TYPE ); + jsonObject.Set( JSONSerializationSettings.NUMBER_VALUE, value ); + + return jsonObject; + } + + return new JSONValue( value ); + } + + JSONData CreateNumber( double value ) + { + if ( settings.saveNumbersWithType ) + { + var jsonObject = new JSONObject(); + jsonObject.Set( JSONSerializationSettings.NUMBER_TYPE, JSONSerializationSettings.DOUBLE_NUMBER_TYPE ); + jsonObject.Set( JSONSerializationSettings.NUMBER_VALUE, value ); + + return jsonObject; + } + + return new JSONValue( value ); + } + + bool IsProcessableObject( object value ) + { + if (System.Attribute.IsDefined( value.GetType(), typeof(JSONAlwaysProcessable) ) ) + { + return true; + } + + if ( alwaysReprocessTypes.Contains( value.GetType() ) ) + { + return true; + } + + if ( processedObjects.Contains( value ) ) + { + RJLog.Error( "Cycle detected: " + value ); + var interfaces = typeof( object ).GetInterfaces(); + + for ( int i = 0; i < interfaces.Length; i++ ) + { + RJLog.Error( "Interfaces[" + i + "]" + interfaces[ i ].Name ); + } + + + + if ( settings.throwErrorOnCycles ) + { + throw new System.Exception( "Cycle detected: " + value ); + } + + return false; + } + + processedObjects.Add( value ); + + return true; + } + + JSONData CreateArray( IList value ) + { + if ( ! IsProcessableObject( value ) ) + { + return new JSONValue(); + } + + var jsonArray = new JSONArray(); + + //RJLog.Log(value ); + + for ( int i = 0; i < value.Count; i++ ) + { + AssignArrayMember( jsonArray, i, value[ i ] ); + } + + return jsonArray; + } + + JSONData CreateMapLikeObject( IDictionary value ) + { + if ( ! IsProcessableObject( value ) ) + { + return new JSONValue(); + } + + var jsonObject = new JSONObject(); + + foreach ( var key in value.Keys ) + { + AssignObjectMember( jsonObject, key + "", value[ key ] ); + } + + return jsonObject; + } + + JSONData CreateObject( object obj ) + { + if ( ! IsProcessableObject( obj ) ) + { + return new JSONValue(); + } + + var type = obj.GetType(); + var fields = type.GetFields(); + var jsonObject = new JSONObject(); + + foreach ( var f in fields ) + { + if ( f.IsStatic ) + { + continue; + } + + var name = f.Name; + var value = f.GetValue( obj ); + + if ( value == null ) + { + jsonObject.Set( name, new JSONValue() ); + } + else if ( value is int ) + { + jsonObject.Set( name, CreateNumber( (int) value ) ); + } + else if ( value is double ) + { + jsonObject.Set( name, CreateNumber( (double) value ) ); + } + else if ( value is float ) + { + jsonObject.Set( name, CreateNumber( (float) value ) ); + } + else if ( value is string ) + { + jsonObject.Set( name, (string) value ); + } + else if ( value is bool ) + { + jsonObject.Set( name, (bool) value ); + } + else if ( value is Enum ) + { + jsonObject.Set( name, (int) value ); + } + else if ( ReflectionHelper.IsList( value ) ) + { + jsonObject.Set( name, CreateArray( value as IList ) ); + } + else if ( IsSerializableDictionary( value ) ) + { + jsonObject.Set( name, CreateMapLikeObject( value as IDictionary ) ); + } + else + { + var exporter = GetCustomSerializer( value ); + + if ( exporter != null ) + { + jsonObject.Set( name, exporter.Serialize( value ) ); + } + else + { + jsonObject.Set( name, CreateObject( value ) ); + } + + } + } + + return jsonObject; + } + + void AssignArrayMember( JSONArray jsonArray, int index, object value ) + { + if ( value == null ) + { + jsonArray.Set( index, new JSONValue() ); + } + else if ( value is int ) + { + jsonArray.Set( index, CreateNumber( (int) value ) ); + } + else if ( value is double ) + { + jsonArray.Set( index, CreateNumber( (double) value ) ); + } + else if ( value is float ) + { + jsonArray.Set( index, CreateNumber( (float) value ) ); + } + else if ( value is string ) + { + jsonArray.Set( index, (string) value ); + } + else if ( value is bool ) + { + jsonArray.Set( index, (bool) value ); + } + else if ( ReflectionHelper.IsList( value ) ) + { + jsonArray.Set( index, CreateArray( value as IList) ); + } + else if ( IsSerializableDictionary( value ) ) + { + jsonArray.Set( index, CreateMapLikeObject( value as IDictionary ) ); + } + else + { + var exporter = GetCustomSerializer( value ); + + if ( exporter != null ) + { + jsonArray.Set( index, exporter.Serialize( value ) ); + } + else + { + jsonArray.Set( index, CreateObject( value ) ); + } + + } + } + + void AssignObjectMember( JSONObject jsonObject, string name, object value ) + { + if ( value == null ) + { + jsonObject.Set( name, new JSONValue() ); + } + else if ( value is int ) + { + jsonObject.Set( name, CreateNumber( (int) value ) ); + } + else if ( value is double ) + { + jsonObject.Set( name, CreateNumber( (double) value ) ); + } + else if ( value is float ) + { + jsonObject.Set( name, CreateNumber( (float) value ) ); + } + else if ( value is string ) + { + jsonObject.Set( name, (string) value ); + } + else if ( value is bool ) + { + jsonObject.Set( name, (bool) value ); + } + else if ( ReflectionHelper.IsList( value ) ) + { + jsonObject.Set( name, CreateArray( value as IList ) ); + } + else if ( IsSerializableDictionary( value ) ) + { + jsonObject.Set( name, CreateMapLikeObject( value as IDictionary ) ); + } + else + { + var exporter = GetCustomSerializer( value ); + + if ( exporter != null ) + { + jsonObject.Set( name, exporter.Serialize( value ) ); + } + else + { + jsonObject.Set( name, CreateObject( value ) ); + } + } + + } + + + } +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/JSONSerializiationSettings.cs b/Runtime/Text/JSON/Serializers/JSONSerializiationSettings.cs new file mode 100644 index 0000000..3eaa500 --- /dev/null +++ b/Runtime/Text/JSON/Serializers/JSONSerializiationSettings.cs @@ -0,0 +1,66 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; + + + +using System; + + +namespace Rokojori +{ + public class JSONSerializationSettings + { + public static readonly string NUMBER_TYPE = "number-type"; + public static readonly string NUMBER_VALUE = "number-value"; + public static readonly string INT_NUMBER_TYPE = "int"; + public static readonly string FLOAT_NUMBER_TYPE = "float"; + public static readonly string DOUBLE_NUMBER_TYPE = "double"; + + static List serializableDictionaryKeyTypes = new List() + { + typeof( string ), typeof( int ) + }; + + public static readonly List defaultSerializers = new List() + { + new DateTimeSerializer(), + new BigIntegerSerializer() + }; + + + public static bool IsSerializableDictionary( Type type ) + { + if ( ! ReflectionHelper.IsDictionary( type ) ) + { + return false; + } + + var keyType = type.GetGenericArguments()[ 0 ]; + + return serializableDictionaryKeyTypes.IndexOf( keyType ) != -1; + } + + + public static bool IsSerializableDictionary( object value ) + { + if ( ! ReflectionHelper.IsDictionary( value ) ) + { + return false; + } + + var keyType = value.GetType().GetGenericArguments()[ 0 ]; + + return serializableDictionaryKeyTypes.IndexOf( keyType ) != -1; + } + + + public List customSerializers = new List(); + public bool saveNumbersWithType = false; + public bool throwErrorOnCycles = false; + + + } + +} \ No newline at end of file diff --git a/Runtime/Text/JSON/Serializers/Reference.cs b/Runtime/Text/JSON/Serializers/Reference.cs new file mode 100644 index 0000000..7c884b4 --- /dev/null +++ b/Runtime/Text/JSON/Serializers/Reference.cs @@ -0,0 +1,168 @@ +using System.Collections; +using System.Collections.Generic; + +using System.Text; +using System.Globalization; +using System; +using Godot; + + +namespace Rokojori +{ + public enum ReferenceType + { + MEMBER_REFERENCE, + ARRAY_LIST_REFERENCE, + MAP_DICTIONARY_REFERENCE + } + + public class Reference + { + public ReferenceType type; + public object target; + public int index; + public string name; + + public string GetInfo() + { + var accessorInfo = ""; + + if ( ReferenceType.ARRAY_LIST_REFERENCE == type ) + { + if ( target is JSONArray ) + { + accessorInfo += "JSONArray[ " + index + " ]"; + } + else if ( target is IList ) + { + accessorInfo += "List[ " + index + " ]"; + } + else + { + accessorInfo += "List/Array[ " + index + " ]"; + } + + } + else if ( ReferenceType.MEMBER_REFERENCE == type ) + { + accessorInfo += "Member[ " + name + " ]"; + } + else if ( ReferenceType.MAP_DICTIONARY_REFERENCE == type ) + { + if ( JSONSerializationSettings.IsSerializableDictionary( target ) ) + { + var keyType = target.GetType().GetGenericArguments()[ 0 ]; + + if ( typeof( int ) == keyType ) + { + accessorInfo += "Dictionary[ " + index + " ]"; + } + else if ( typeof( string ) == keyType ) + { + accessorInfo += "Dictionary[ " + name + " ]"; + } + } + else if ( target is JSONObject ) + { + accessorInfo += "JSONObject[ " + name + " ]"; + } + else + { + accessorInfo += "Map/Dictionary[ " + index + " ]"; + } + + } + + return accessorInfo + "@" + target; + } + + public void AssignValue( object value ) + { + if ( ReferenceType.ARRAY_LIST_REFERENCE == type ) + { + if ( target is IList ) + { + var list = ( (IList) target ); + var missing = Mathf.Max( 0, index - ( list.Count - 1 ) ); + + for ( int i = 0; i < missing; i++ ) + { + list.Add( null ); + } + + list[ index ] = value; + } + else if ( target is JSONArray ) + { + ( (JSONArray) target ).Set( index, (JSONData) value ); + } + } + else if ( ReferenceType.MEMBER_REFERENCE == type ) + { + if ( target is JSONObject ) + { + ( (JSONObject) target ).Set( name, (JSONData) value ); + } + else + { + ReflectionHelper.SetMemberValue( target, name, value ); + } + + } + else if ( ReferenceType.MAP_DICTIONARY_REFERENCE == type ) + { + if ( target is JSONObject ) + { + ( (JSONObject) target ).Set( name, (JSONData) value ); + } + else if ( JSONSerializationSettings.IsSerializableDictionary( target ) ) + { + if ( typeof( string ) == target.GetType().GetGenericArguments()[ 0 ] ) + { + ( (IDictionary) target )[ name ] = value; + } + else + { + ( (IDictionary) target )[ index ] = value; + } + + } + } + } + + public Reference( object target, int index ) + { + this.target = target; + this.index = index; + + if ( target is JSONObject || JSONSerializationSettings.IsSerializableDictionary( target ) ) + { + type = ReferenceType.MAP_DICTIONARY_REFERENCE; + } + else + { + type = ReferenceType.ARRAY_LIST_REFERENCE; + } + } + + public Reference( object target, string name ) + { + this.target = target; + this.name = name; + + if ( target is JSONObject || JSONSerializationSettings.IsSerializableDictionary( target ) ) + { + type = ReferenceType.MAP_DICTIONARY_REFERENCE; + } + else + { + type = ReferenceType.MEMBER_REFERENCE; + } + + } + + + + + } +} \ No newline at end of file diff --git a/Runtime/Text/Lexing/Lexer.cs b/Runtime/Text/Lexing/Lexer.cs new file mode 100644 index 0000000..93906e7 --- /dev/null +++ b/Runtime/Text/Lexing/Lexer.cs @@ -0,0 +1,126 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text.RegularExpressions; + +namespace Rokojori +{ + public class Lexer + { + Dictionary> _modes = new Dictionary>(); + bool _hasError =false; + + public bool hasError => _hasError; + + void AddMatcher( LexerMatcher matcher ) + { + var list = _modes.ContainsKey( matcher.mode ) ? _modes[ matcher.mode ] : null; + + if ( list == null ) + { + list = new List(); + _modes[ matcher.mode ] = list; + } + + list.Add( matcher ); + } + + public void AddAllMatchers( params LexerMatcher[] matchers ) + { + for ( int i = 0; i < matchers.Length; i++ ) + { + AddMatcher( matchers[ i ] ); + } + } + + public void AddMatcher( string type, Regex regex, string mode = "", string nextMode = null ) + { + AddMatcher( new LexerMatcher( type, regex, mode, nextMode ) ); + } + + public void AddMatcher( string type, string regex, string mode = "", string nextMode = null ) + { + AddMatcher( type, new Regex( regex ), mode, nextMode ); + } + + public void Lex( string source, System.Action callback, int offset = 0, string mode = "" ) + { + var ERROR_FLAG = -1; + var DONE_FLAG = -2; + + var lexerEvent = new LexerEvent( "", 0, -2 ); + + while ( offset < source.Length ) + { + if ( ! _modes.ContainsKey( mode ) ) + { + var errorMessage = "@Lexer-Error. Mode not found: '" + mode + "'"; + RJLog.Log( errorMessage, "@", offset ); + lexerEvent.set( errorMessage, offset, ERROR_FLAG ); + _hasError = true; + callback( lexerEvent ); + + return; + } + + var matchers = _modes[ mode ]; + var foundSomething = false; + + for ( var i = 0; i < matchers.Count; i++ ) + { + var matcher = matchers[ i ]; + var matchLength = matcher.MatchLength( source, offset ); + + if ( matchLength > 0 ) + { + lexerEvent.set( matcher.type, offset, matchLength ); + //Logs.Log(matcher.type, ">>", "'"+source.Substring( offset, matchLength )+"'", "@", offset, matchLength ); + callback( lexerEvent ); + + foundSomething = true; + + i = matchers.Count; + + if ( matcher.nextMode != null ) + { + mode = matcher.nextMode; + } + + offset += matchLength; + + } + } + + if ( ! foundSomething ) + { + var errorMessage = "@Lexer-Error. No match: '" + mode + "'"; + RJLog.Log(errorMessage, "@", offset ); + lexerEvent.set( errorMessage, offset, ERROR_FLAG ); + _hasError = true; + callback( lexerEvent ); + + return; + } + + } + + lexerEvent.set( mode, offset, DONE_FLAG ); + callback( lexerEvent ); + } + + public List LexToList( string source, int offset = 0, string mode = "" ) + { + var list = new List(); + + Lex( + source, + ( LexerEvent token )=> + { + list.Add( token.Copy() ); + }, + offset, mode + ); + + return list; + } + } +} \ No newline at end of file diff --git a/Runtime/Text/Lexing/LexerEvent.cs b/Runtime/Text/Lexing/LexerEvent.cs new file mode 100644 index 0000000..86696c1 --- /dev/null +++ b/Runtime/Text/Lexing/LexerEvent.cs @@ -0,0 +1,69 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text.RegularExpressions; + + + +namespace Rokojori +{ + public class LexerEvent + { + string _type; + int _offset; + int _length; + string _match; + + public string match => _match; + + public LexerEvent( string type, int offset, int length ) + { + set( type, offset, length ); + } + + public string type { get { return _type; } } + public int offset { get { return _offset; } } + public int length { get { return _length; } } + + public bool isError + { + get { return this.length == -1; } + } + + public bool isDone + { + get { return this.length == -2; } + } + + public void set( string type, int offset, int length ) + { + this._type = type; + this._offset = offset; + this._length = length; + } + + public LexerEvent Copy() + { + return new LexerEvent( _type, _offset, _length ); + } + + public int end + { + get { return this._offset + _length; } + } + public override string ToString() + { + return "Token{ '" + type + "' (" + offset + "-" + end + ") }"; + } + + public void GrabMatch( string source ) + { + if ( _length < 0 ) + { + return; + } + + _match = source.Substring( offset, length ); + } + + } +} \ No newline at end of file diff --git a/Runtime/Text/Lexing/LexerLibrary/CSharpLexer.cs b/Runtime/Text/Lexing/LexerLibrary/CSharpLexer.cs new file mode 100644 index 0000000..6aad395 --- /dev/null +++ b/Runtime/Text/Lexing/LexerLibrary/CSharpLexer.cs @@ -0,0 +1,47 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text.RegularExpressions; + +namespace Rokojori +{ + public class CSharpLexer:Lexer + { + public static List Lex( string source ) + { + var lexer = new CSharpLexer(); + var events = lexer.LexToList( source ); + + if ( lexer.hasError ) + { + return null; + } + + events.ForEach( ev => { ev.GrabMatch( source ); } ); + return events; + } + + public CSharpLexer() + { + AddAllMatchers( + LexerMatcherLibrary.SINGLE_LINE_COMMENT_MATCHER, + LexerMatcherLibrary.MULTI_LINE_COMMENT_MATCHER, + LexerMatcherLibrary.DOUBLE_QUOTED_STRING_MATCHER, + LexerMatcherLibrary.SINGLE_QUOTED_STRING_MATCHER, + LexerMatcherLibrary.C_INSTRUCTION_MATCHER, + LexerMatcherLibrary.NUMBER_MATCHER, + LexerMatcherLibrary.NULL_MATCHER, + LexerMatcherLibrary.BOOL_MATCHER, + LexerMatcherLibrary.BREAK_MATCHER, + LexerMatcherLibrary.WHITESPACE_MATCHER, + LexerMatcherLibrary.LOGIC_MATCHER, + LexerMatcherLibrary.BRACKET_MATCHER, + LexerMatcherLibrary.ACCESS_MODIFIER_MATCHER, + LexerMatcherLibrary.CLASS_MATCHER, + LexerMatcherLibrary.OPERATOR_MATCHER, + LexerMatcherLibrary.CFUNCTION_MATCHER, + LexerMatcherLibrary.CWORD_MATCHER, + LexerMatcherLibrary.ANY_SYMBOL_MATCHER + ); + } + } +} \ No newline at end of file diff --git a/Runtime/Text/Lexing/LexerMatcher.cs b/Runtime/Text/Lexing/LexerMatcher.cs new file mode 100644 index 0000000..48c5269 --- /dev/null +++ b/Runtime/Text/Lexing/LexerMatcher.cs @@ -0,0 +1,70 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text.RegularExpressions; + +namespace Rokojori +{ + public class LexerMatcher + { + string _mode; + public string mode => _mode; + + string _type; + public string type => _type; + + string _nextMode; + public string nextMode => _nextMode; + + Regex _matcher; + Regex matcher + { + get { return this._matcher; } + } + + public bool Matches( LexerEvent le ) + { + return type == le.type; + } + + public LexerMatcher( string type, Regex matcher, string mode = "", string nextMode = "" ) + { + _type = type; + _mode = mode; + _nextMode = nextMode; + _matcher = RegexUtility.MakeSticky( matcher ); + } + + public LexerMatcher( string type, string matcher, string mode = "", string nextMode = "" ) + { + _type = type; + _mode = mode; + _nextMode = nextMode; + _matcher = RegexUtility.MakeSticky( new Regex( matcher ) ); + } + + public LexerMatcher CloneWithMode( string mode, string nextMode ) + { + return new LexerMatcher( _type, _matcher, mode, nextMode ); + } + + public int MatchLength( string source, int offset ) + { + var match = matcher.Match( source, offset ); + + if ( match.Success && match.Index != offset ) + { + var message = "Illegal match index! Not a sticky matcher: " + matcher + "."; + message += "Offset: " + offset + " Matched Index: " + match.Index ; + throw new System.Exception( message ); + } + + if ( match.Success ) + { + return match.Groups[ 0 ].Length; + } + + return -1; + } + + } +} \ No newline at end of file diff --git a/Runtime/Text/Lexing/LexerMatcherLibrary.cs b/Runtime/Text/Lexing/LexerMatcherLibrary.cs new file mode 100644 index 0000000..665ede8 --- /dev/null +++ b/Runtime/Text/Lexing/LexerMatcherLibrary.cs @@ -0,0 +1,100 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text.RegularExpressions; + +namespace Rokojori +{ + public class LexerMatcherLibrary + { + public static readonly LexerMatcher CWORD_MATCHER = + new LexerMatcher( "CWORD", @"[a-zA-Z_]\w*" ); + + public static readonly LexerMatcher CFUNCTION_MATCHER = + new LexerMatcher( "CFUNCTION", @"[a-zA-Z_]\w*(?=\s*\()" ); + + // public static readonly LexerMatcher LexerMatcherCLASSNAME_MATCHER = + // new LexerMatcher( "CLASSNAME", @"(?<=(?:(?:class|interface|struct)\s+))[a-zA-Z_]\w*" ); + + public static readonly LexerMatcher JSWORD_MATCHER = + new LexerMatcher( "JSWORD", @"[a-zA-Z_\$]\w*" ); + + public static readonly LexerMatcher PHPWORD_MATCHER = + new LexerMatcher( "PHPWORD", @"\$?[a-zA-Z_]\w*" ); + + + public static readonly LexerMatcher CSS_CLASS_SELECTOR_MATCHER = + new LexerMatcher( "CSS_CLASS_SELECTOR", @"\.[a-zA-Z_](\w|\-)*" ); + + public static readonly LexerMatcher CSS_ID_SELECTOR_MATCHER = + new LexerMatcher( "CSS_ID_SELECTOR", @"\#[a-zA-Z_](\w|\-)*" ); + + public static readonly LexerMatcher CSS_WORD_MATCHER = + new LexerMatcher( "CSS_WORD", @"[a-zA-Z_](\w|\-)*" ); + + + public static readonly LexerMatcher HTML_CUSTOM_ELEMENT_MATCHER = + new LexerMatcher( "HTML_CUSTOM_ELEMENT", @"[a-zA-Z]\w*\-(\w|\-)+" ); + + public static readonly LexerMatcher DOUBLE_QUOTED_STRING_MATCHER = + new LexerMatcher( "DOUBLE_QUOTED_STRING", "\"(?:[^\"\\\\]|\\\\.)*\"" ); + + public static readonly LexerMatcher SINGLE_QUOTED_STRING_MATCHER = + new LexerMatcher( "SINGLE_QUOTED_STRING", @"'(?:[^'\\]|\\.)*'" ); + + public static readonly LexerMatcher NUMBER_MATCHER = + new LexerMatcher( "NUMBER", @"(?=\.\d|\d)(?:\d+)?(?:\.?\d*)(?:[eE][+-]?\d+)?" ); + + public static readonly LexerMatcher WHITESPACE_MATCHER = + new LexerMatcher( "WHITESPACE", @"\s+" ); + + public static readonly LexerMatcher BREAK_MATCHER = + new LexerMatcher( "BREAK", @"(\r\n|\r|\n)" ); + + + public static readonly LexerMatcher NULL_MATCHER = + new LexerMatcher( "NULL", "null" ); + + public static readonly LexerMatcher BOOL_MATCHER = + new LexerMatcher( "BOOL", "true|false" ); + + public static readonly LexerMatcher LOGIC_MATCHER = + new LexerMatcher( "LOGIC", "if|else|switch|do|while|for|break|continue|return" ); + + public static readonly LexerMatcher OPERATOR_MATCHER = + new LexerMatcher( "OPERATOR", "(?:\\=\\=)|(?:\\+\\+)|(?:\\-\\-)|\\+|\\-|\\*|\\/|\\^|\\||\\~|\\&|\\%|\\<|\\>|\\=|\\!|\\.|\\:|\\,|\\;" ); + + public static readonly LexerMatcher BRACKET_MATCHER = + new LexerMatcher( "BRACKET", @"\(|\)|\[|\]|\{|\}" ); + + public static readonly LexerMatcher BLOCKSTART_MATCHER = + new LexerMatcher( "BLOCKSTART", @"\{" ); + + public static readonly LexerMatcher BLOCKEND_MATCHER = + new LexerMatcher( "BLOCKEND", @"\}" ); + + public static readonly LexerMatcher CLASS_MATCHER = + new LexerMatcher( "CLASS", @"\bclass\b" ); + + public static readonly LexerMatcher ACCESS_MODIFIER_MATCHER = + new LexerMatcher( "ACCESS_MODIFIER", @"\b(?:public|protected|private)\b" ); + + + public static readonly LexerMatcher SINGLE_LINE_COMMENT_MATCHER = + new LexerMatcher( "SINGLE_LINE_COMMENT", @"//.*" ); + + public static readonly LexerMatcher C_INSTRUCTION_MATCHER = + new LexerMatcher( "C_INSTRUCTION", @"\#.*" ); + + public static readonly LexerMatcher MULTI_LINE_COMMENT_MATCHER = + new LexerMatcher( "MULTI_LINE_COMMENT", @"\/\*(.|(\r\n|\r|\n))*?\*\/" ); + + public static readonly LexerMatcher ANY_SYMBOL_MATCHER = + new LexerMatcher( "ANY_SYMBOL", @"." ); + + public static readonly LexerMatcher HASH_TAG = + new LexerMatcher( "HASH_TAG", @"\#(\w|-|\d)+" ); + + public static readonly LexerMatcher URL = + new LexerMatcher( "URL", @"https?\:\/\/(\w|\.|\-|\?|\=|\+|\/)+" ); + } +} \ No newline at end of file diff --git a/Runtime/Text/RegexBuilder.cs b/Runtime/Text/RegexBuilder.cs new file mode 100644 index 0000000..e919d9f --- /dev/null +++ b/Runtime/Text/RegexBuilder.cs @@ -0,0 +1,117 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text.RegularExpressions; +using System.Text; + +using System.Globalization; +using Godot; + +namespace Rokojori +{ + public class RegexBuilder + { + List _parts = new List(); + List _flags = new List(); + + public static RegexBuilder Create() + { + var rb = new RegexBuilder(); + return rb; + } + + public RegexBuilder this[ string key ] + { + get { _parts.Add( RegexUtility.EscapeForRegex( key ) ); return this; } + } + + public RegexBuilder _ + { + get + { + _parts.Add( @"\s*" ); + return this; + } + } + + public RegexBuilder __ + { + get + { + _parts.Add( @"\s+" ); + return this; + } + } + + public RegexBuilder Word + { + get + { + _parts.Add( @"(\w+)" ); + return this; + } + } + + public RegexBuilder groupStart + { + get + { + _parts.Add( "(" ); + return this; + } + } + + public RegexBuilder groupEnd + { + get + { + _parts.Add( ")" ); + return this; + } + } + + public RegexBuilder word + { + get + { + _parts.Add( @"\w+" ); + return this; + } + + } + + + public RegexBuilder flags( string flags ) + { + for ( int i = 0 ; i < flags.Length; i++ ) + { + _flags.Add( flags[ i ] + "" ); + } + + return this; + } + + public Regex ToRegex() + { + var options = RegexOptions.None; + var pattern = Lists.Join( _parts, "" ); + + if ( _flags.IndexOf( "i" ) != -1 ) + { + options = options | RegexOptions.IgnoreCase; + } + + if ( _flags.IndexOf( "m" ) != -1 ) + { + options = options | RegexOptions.Multiline; + } + + if ( _flags.IndexOf( "y" ) != -1 ) + { + pattern = RegexUtility.MakeSourceSticky( pattern ); + } + + return new Regex( pattern, options ); + } + + } +} \ No newline at end of file diff --git a/Runtime/Text/RegexUtility.cs b/Runtime/Text/RegexUtility.cs new file mode 100644 index 0000000..3fcc3cc --- /dev/null +++ b/Runtime/Text/RegexUtility.cs @@ -0,0 +1,520 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text.RegularExpressions; +using System.Text; + +using System.Globalization; +using Godot; + +namespace Rokojori +{ + public class RegexUtility + { + public static Regex MakeSticky( Regex regex ) + { + var source = MakeSourceSticky( regex + "" ); + + return new Regex( source, regex.Options ); + } + + public static string MakeSourceSticky( string source ) + { + if ( ! source.StartsWith( "\\G" ) ) + { + source = "\\G(?:" + source + ")"; + } + + return source; + } + + public static string WriteDouble( double value ) + { + try + { + var specifier = "G"; + + return value.ToString( specifier, CultureInfo.InvariantCulture ); + } + catch( System.Exception e ) + { + RJLog.Log(e ); + } + + return "0"; + } + + public static double ParseDouble( string source, double alternative = 0 ) + { + try + { + double newValue = System.Double.Parse( source, CultureInfo.InvariantCulture ); + return newValue; + } + catch ( System.Exception e ) + { + if ( e != null ) + { + + } + return alternative; + } + } + + public static float ParseFloat( string source, float alternative = 0 ) + { + return ( float ) ParseDouble( source, alternative ); + } + + /*public static int ParseInt( string source, int alternative = 0 ) + { + return Mathf.RoundToInt( ( float ) ParseDouble( source, alternative ) ); + }*/ + + public static int ParseInt( string source, int alternative = 0 ) + { + var multiply = 1; + var value = 0; + + for ( int i = source.Length - 1; i >= 0 ; i-- ) + { + var symbol = source[ i ]; + + if ( i == 0 ) + { + if ( symbol == '-' ) + { return -value; } + + if ( symbol == '+' ) + { return value; } + } + + var digitValue = ParseDigit( symbol ); + + if ( digitValue == -1 ) + { + return alternative; + } + + value += digitValue * multiply; + + multiply *= 10; + } + + return value; + } + + public static int ParseDigit( char c ) + { + switch ( c ) + { + case '0': return 0; + case '1': return 1; + case '2': return 2; + case '3': return 3; + case '4': return 4; + case '5': return 5; + case '6': return 6; + case '7': return 7; + case '8': return 8; + case '9': return 9; + } + + return -1; + } + + public static bool Matching( string source, string regex ) + { + return new Regex( regex ).Match( source ).Success; + } + + public static string Substring( string source, string regex ) + { + return new Regex( regex ).Match( source ).Value; + } + + public static string EscapeForRegex( string source ) + { + var sb = new StringBuilder(); + + var escapes = "+*?^$\\.[]{}()|/"; + + for ( int i = 0; i < source.Length; i++ ) + { + var character = source[ i ]; + + if ( escapes.IndexOf( character ) != -1 ) + { + sb.Append( "\\" ); + } + + sb.Append( character ); + } + + return sb.ToString(); + } + + public static string LeadingZeros( int value, int minDigits = 2) + { + var stringValue = value + ""; + + while ( stringValue.Length < minDigits ) + { + stringValue = "0" + stringValue; + } + + return stringValue; + } + + public static string NumberWithThousandsSeperator( int value, string seperator = "." ) + { + var isNegative = value < 0; + + if ( isNegative ){ value = - value; } + + var stringValue = value + ""; + + var builder = new StringBuilder(); + + for ( int i = 0; i < stringValue.Length; i++ ) + { + var index = ( stringValue.Length - 1 ) - i ; + + if ( i % 4 == 3 ) + { + builder.Append( seperator ); + } + + builder.Append( stringValue[ index ] ); + } + + var seperatorValue = builder.ToString(); + + return Reverse( seperatorValue ); + } + + public static string Reverse( string source ) + { + char[] characters = source.ToCharArray(); + System.Array.Reverse( characters ); + return new string( characters ); + } + + public static Regex EscapedOrRegex( string first, params string[] other ) + { + var value = EscapeForRegex( first ); + + for ( var i = 0; i < other.Length; i++ ) + { + value += "|" + EscapeForRegex( other[ i ] ); + + /* + + if ( i == 0 ) + { + value = "(" + value; + } + value += ")|(" + EscapeForRegex( other[ i ] ); + + if ( i == ( other.Length - 1 ) ) + { + value += ")"; + } + + */ + } + + //Logs.Log("EscapedOrRegex:", "'" + value + "'"); + return new Regex( value ); + + } + + public static Color ParseColor( string source, Color alternative ) + { + if ( Matching( source, @"#\d+" ) ) + { + return ParseHexColor( source, alternative ); + } + else if ( Matching( source, @"^rgb" ) ) + { + return ParseRGBColor( source, alternative ); + } + else if ( Matching( source, @"^hsl" ) ) + { + return ParseHSLColor( source, alternative ); + } + + return alternative; + } + + + public static double ParsePercentage( string source ) + { + source = Remove( source, @"\s*%" ); + return ParseDouble( source.Trim(), 0 ) / 100.0; + } + + public static int ParseHexCharacter( char hexCharacter ) + { + if ( '0' <= hexCharacter && hexCharacter <= '9' ) + { + return (int) (hexCharacter - '0' ); + } + + if ( 'a' <= hexCharacter && hexCharacter <= 'f' ) + { + return (int) (hexCharacter - 'a') + 10; + } + + if ( 'A' <= hexCharacter && hexCharacter <= 'F' ) + { + return (int) (hexCharacter - 'A') + 10; + } + + return 0; + } + + public static int ParseHex( string source ) + { + var value = 0; + var shift = 0; + + for ( var i = source.Length - 1; i < source.Length; i++ ) + { + var hexValue = ParseHexCharacter( source[ i ] ) << shift; + shift += 4; + } + + return value; + + } + + public static Color ParseHexColor( string source, Color alternative ) + { + source = RegexUtility.Remove( source, @"^#" ); + + var numbers = new List(); + + for ( var i = 0; i < 3; i++ ) + { + var value = source.Substring( i * 2, 2 ); + var numberValue = ParseHex( value ) / 255f; + numbers.Add( numberValue ); + } + + if ( numbers.Count == 3 ) + { + numbers.Add( 1f ); + } + + return new Color( numbers[ 0 ], numbers[ 1 ], numbers[ 2 ] , numbers[ 3 ] ); + + } + + public static Color ParseRGBColor( string source, Color alternative ) + { + source = RegexUtility.Remove( source, @"^rgba?\(" ); + source = RegexUtility.Remove( source, @"\)$" ); + + var splits = Split( source, @"\," ); + var numbers = Lists.Map( splits, + ( string value, int index ) => + { + if ( value.Contains( "%" ) ) + { + return (float) ParsePercentage( value ); + } + + return ParseFloat( value ); + } + ); + + if ( numbers.Count == 3 ) + { + numbers.Add( 1f ); + } + + return new Color( numbers[ 0 ], numbers[ 1 ], numbers[ 2 ] , numbers[ 3 ] ); + + } + + public static HSLColor ParseHSLColor( string source, HSLColor alternative ) + { + source = RegexUtility.Remove( source, @"^hsl\(" ); + source = RegexUtility.Remove( source, @"\)$" ); + + var splits = Split( source, @"\," ); + var numbers =Lists.Map( splits, + ( string value, int index ) => + { + if ( value.Contains( "%" ) ) + { + return (float) ParsePercentage( value ); + } + + return ParseFloat( value ); + } + ); + + if ( numbers.Count < 3 ) + { + RJLog.Log("Not enough numbers parsed: ", source, ">>", numbers.Count, Lists.Join( numbers, "," ) ); + } + + + if ( numbers.Count == 3 ) + { + numbers.Add( 1f ); + } + + return new HSLColor( numbers[ 0 ], numbers[ 1 ], numbers[ 2 ] , numbers[ 3 ] ); + } + + public static List Split( string source, Regex regex ) + { + var strings = regex.Split( source ); + var list = new List(); + + list.AddRange( strings ); + + return list; + } + + public static List Split( string source, string regex ) + { + return Split( source, new Regex( regex ) ); + } + + public static string Remove( string source, string regex ) + { + return Replace( source, regex, "" ); + } + + public static string Replace( string source, Regex regex, string replacement ) + { + return regex.Replace( source, replacement ); + } + + public static string Remove( string source, Regex regex ) + { + return Replace( source, regex, "" ); + } + + public static string Replace( string source, string regex, string replacement ) + { + return new Regex( regex ).Replace( source, replacement ); + } + + public static string ReplaceMultiple( string source, Dictionary replacements ) + { + var replaced = source; + + foreach ( var vk in replacements ) + { + replaced = replaced.Replace( vk.Key, vk.Value ); + } + + return replaced; + } + + public static string ParentPathOrLastFragment( string path ) + { + var splits = SplitPaths( path ); + + return splits[ splits.Count - 1 ]; + } + + public static List SplitPaths( string path ) + { + var splittedPaths = new List(); + var normalizedPath = NormalizePath( path ); + var splits = Split( normalizedPath, new Regex( @"\/" ) ); + return splits; + } + + public static string JoinPaths( List paths, int startIndex = 0, int length = -1 ) + { + var normalizedPaths = new List(); + // normalizedPaths.AddRange( paths ); + + var endIndex = startIndex + length; + var end = ( length < 0 || ( length + startIndex ) >= paths.Count ) ? paths.Count : endIndex; + + for ( var i = startIndex; i < end; i++ ) + { + normalizedPaths.Add( _NormalizePath( paths[ i ] ) ); + } + + return Lists.Join( normalizedPaths, "/" ); + } + + public static string Join( string pathA, string pathB, params string[] paths ) + { + var normalizedPaths = new List(); + normalizedPaths.Add( pathA ); + normalizedPaths.Add( pathB ); + normalizedPaths.AddRange( paths ); + + for ( var i = 0; i < normalizedPaths.Count; i++ ) + { + normalizedPaths[ i ] = _NormalizePath( normalizedPaths[ i ] ); + } + + return Lists.Join( normalizedPaths, "/" ); + } + + private static string _EnsureForwardSlashes( string path ) + { + if ( path.IndexOf( "\\" ) == -1 ) + { + return path; + } + + var correctedPath = ""; + + for ( int i = 0; i < path.Length; i++ ) + { + if ( path[ i ] == '\\' ) + { + correctedPath += "/"; + } + else + { + correctedPath += path[ i ]; + } + } + + return correctedPath; + } + + public static string NormalizePath( string path ) + { + return _NormalizePath( path ); + } + + public static string WindowsPath( string path ) + { + path = _NormalizePath( path ); + + var slashes = @"\/"; + + path = Regex.Replace( path, slashes, "\\" ); + + return path; + } + + private static string _NormalizePath( string path ) + { + path = _EnsureForwardSlashes( path ); + + var startSlashes = @"^\/+"; + var endSlashes = @"\/+$"; + var multiples = @"\/\/+"; + + path = Regex.Replace( path, startSlashes, "" ); + path = Regex.Replace( path, endSlashes, "" ); + path = Regex.Replace( path, multiples, "/" ); + + return path; + } + } +} \ No newline at end of file diff --git a/Runtime/Text/TextAnchor.cs b/Runtime/Text/TextAnchor.cs new file mode 100644 index 0000000..46f8f25 --- /dev/null +++ b/Runtime/Text/TextAnchor.cs @@ -0,0 +1,32 @@ +using System.Collections; +using System.Collections.Generic; + + +namespace Rokojori +{ + public class TextAnchor + { + public readonly int lineIndex; + public readonly int characterIndex; + + public TextAnchor( int lineIndex, int characterIndex ) + { + this.lineIndex = lineIndex; + this.characterIndex = characterIndex; + } + + public TextAnchor Copy() + { + return new TextAnchor( lineIndex, characterIndex ); + } + + public string info + { + get + { + return lineIndex + " (" + characterIndex + ")"; + } + } + + } +} \ No newline at end of file diff --git a/Runtime/Text/TextLine.cs b/Runtime/Text/TextLine.cs new file mode 100644 index 0000000..29df0c9 --- /dev/null +++ b/Runtime/Text/TextLine.cs @@ -0,0 +1,75 @@ +using System.Collections; +using System.Collections.Generic; +using Godot; + +namespace Rokojori +{ + public class TextLine + { + public readonly int characterIndex; + public readonly int length; + public readonly int lineIndex; + public readonly int lineBreakLength; + + public TextLine( int lineIndex, int characterIndex, int length, int lineBreakLength ) + { + this.characterIndex = characterIndex; + this.length = length; + this.lineIndex = lineIndex; + this.lineBreakLength = lineBreakLength; + } + + public int contentLength { get { return length - lineBreakLength; } } + public int contentOffset { get { return characterIndex + lineBreakLength; } } + public int textEditorLineIndex { get { return lineIndex + 1 ; } } + + public string GetContent( string source ) + { + return source.Substring( contentOffset, contentLength ); + } + + + public string info + { + get + { + var info = new List(); + + info.AddRange( new List{ + "line index: " + lineIndex, + "character index: " + characterIndex, + "content length: " + contentLength, + "length: " + length, + "line break length: " + lineBreakLength + } + ); + + return "{ " + Lists.Join( info, ", " ) + " }"; + + } + } + + + + public TextAnchor GetRawAnchor( int characterIndex ) + { + return new TextAnchor( lineIndex, characterIndex - this.characterIndex ); + } + + public TextAnchor GetTextEditorAnchor( int characterIndex ) + { + var lineOffset = this.characterIndex + lineBreakLength; + var offset = Mathf.Max( 0, characterIndex - lineOffset ); + return new TextAnchor( lineIndex + 1, offset + 1 ); + } + + public int lineStart { get { return characterIndex; } } + public int lineEnd { get { return ( characterIndex + length ); } } + + public bool Contains( int characterIndex ) + { + return lineStart <= characterIndex && characterIndex <= lineEnd; + } + + } +} \ No newline at end of file diff --git a/Runtime/Text/TextLinesMapper.cs b/Runtime/Text/TextLinesMapper.cs new file mode 100644 index 0000000..823972b --- /dev/null +++ b/Runtime/Text/TextLinesMapper.cs @@ -0,0 +1,233 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text; + +namespace Rokojori +{ + public class TextLinesMapper + { + List _lines; + int _cachedLineIndex; + + void Reset() + { + _lines = new List(); + _cachedLineIndex = 0; + } + + public void Map( string source ) + { + Reset(); + + var currentCharacterIndex = 0; + currentCharacterIndex = NextLineBreak( source, currentCharacterIndex ); + + var lastCharacterIndex = 0; + var lastLineBreakLength = 0; + + var currentLineIndex = 0; + var maxTries = 10000; var currentTries = 0; + // currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + while ( currentCharacterIndex != -1 ) + { + + currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + var currentBreakLength = LineBreakLength( source, currentCharacterIndex ); + + + var lineLength = currentCharacterIndex - lastCharacterIndex; + var lineInfo = new TextLine( currentLineIndex, lastCharacterIndex, lineLength, lastLineBreakLength ); + _lines.Add( lineInfo ); + + lastLineBreakLength = currentBreakLength; + lastCharacterIndex = currentCharacterIndex; + currentLineIndex ++; + + + currentCharacterIndex = NextLineBreak( source, currentCharacterIndex + currentBreakLength ); + } + + var endLineLength = source.Length - lastCharacterIndex; + var endLineInfo = new TextLine( currentLineIndex, lastCharacterIndex, endLineLength, lastLineBreakLength ); + _lines.Add( endLineInfo ); + + } + + public int numCharacters { get { return _lines[ _lines.Count -1 ].lineEnd + 1; } } + + public int numLines { get { return _lines.Count; } } + public string lineInfos + { + get + { + var output = new List(); + foreach ( var line in _lines ) + { + output.Add( line.info ); + } + + return Lists.Join( output, ",\n" ); + } + } + public TextLine GetLine( int characterIndex ) + { + var lineIndex = GetLineIndex( characterIndex ); + return lineIndex == -1 ? null : _lines[ lineIndex ]; + } + + public TextAnchor GetAnchor( int characterIndex, bool forTextEditor ) + { + var line = GetLine( characterIndex ); + if ( line == null ) { return null; } + + return forTextEditor ? line.GetTextEditorAnchor( characterIndex ) : line.GetRawAnchor( characterIndex ); + } + + public TextSelection GetSelection( int startCharacterIndex, int endCharacterIndex, bool forTextEditor = false ) + { + var startAnchor = GetAnchor( startCharacterIndex, forTextEditor ); + var endAnchor = GetAnchor( endCharacterIndex, forTextEditor ); + + if ( startAnchor == null || endAnchor == null ) { return null; } + + return new TextSelection( startAnchor, endAnchor ); + } + + public TextSelection GetTextEditorSelection( int startCharacterIndex, int endCharacterIndex ) + { + return GetSelection( startCharacterIndex, endCharacterIndex, true ); + } + + public string GetTextEditorInfo( int startCharacterIndex, int endCharacterIndex ) + { + var selection = GetTextEditorSelection( startCharacterIndex, endCharacterIndex ); + + if ( selection != null ) { return selection.info; } + + return "@chars(" + startCharacterIndex + "," + endCharacterIndex + ")"; + } + + public string GetTextEditorSnippet( string source, int startCharacterIndex, int endCharacterIndex ) + { + var startLine = GetLineIndex( startCharacterIndex ); + var endLine = GetLineIndex( endCharacterIndex ); + + if ( endLine < startLine ) + { + var b = endLine; endLine = startLine; startLine = b; + } + + var snippet = new StringBuilder(); + var lengthMaxLineNumberIndex = ( _lines[ endLine ].textEditorLineIndex + "" ).Length; + + for ( var i = startLine; i < endLine; i++ ) + { + var line = _lines[ i ]; + var lineNumber = _lines[ i ].textEditorLineIndex + ""; + + while ( lineNumber.Length < lengthMaxLineNumberIndex ) + { + lineNumber = "0" + lineNumber; + } + + var content = line.GetContent( source ); + snippet.Append( lineNumber + ": " ); + snippet.Append( content ); + snippet.Append( "\n" ); + } + + return snippet.ToString(); + + } + + public string GetTextEditorInfo( int characterIndex ) + { + var anchor = GetAnchor( characterIndex, true ); + + if ( anchor != null ) { return anchor.info; } + + return "@chars(" + characterIndex + ")"; + } + + + + TextLine _cachedLine { get { return _lines[ _cachedLineIndex ]; } } + + public int GetLineIndex( int characterIndex ) + { + if ( _cachedLine.Contains( characterIndex ) ) + { + return _cachedLineIndex; + } + + if ( _lines.Count == 0 || characterIndex < 0 || characterIndex > numCharacters ) + { return -1; } + + var lineContainsCharacterIndex = false; + var lineIndexInRange = true; + + var characterIndexIsHigher = _cachedLine.characterIndex < characterIndex; + var searchForward = 1; + var searchBackward = -1 ; + var searchStep = characterIndexIsHigher ? searchForward : searchBackward; + + var maxTries = 1000; var currentTries = 0; + // currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + + do + { + currentTries ++; if ( currentTries == maxTries ) { throw new System.Exception(); } + var nextLineIndex = _cachedLineIndex + searchStep; + lineIndexInRange = 0 <= nextLineIndex && nextLineIndex < _lines.Count; + + if ( lineIndexInRange ) + { + _cachedLineIndex = nextLineIndex; + lineContainsCharacterIndex = _cachedLine.Contains( characterIndex ); + } + else + { + lineContainsCharacterIndex = false; + } + + } + while ( ! lineContainsCharacterIndex && lineIndexInRange ); + + if ( lineContainsCharacterIndex ) + { + return _cachedLineIndex; + } + + return -1; + + } + + int NextLineBreak( string source, int offset ) + { + for ( int i = offset; i < source.Length; i++ ) + { + if ( source[ i ] == '\n' || source[ i ] == '\r' ) + { + return i; + } + } + + return -1; + } + + int LineBreakLength( string source, int offset ) + { + if ( source[ offset ] == '\r' && ( ( offset + 1 ) < source.Length ) ) + { + return source[ offset + 1 ] == '\n' ? 2 : 1; + } + + return 1; + } + + + + } + + +} \ No newline at end of file diff --git a/Runtime/Text/TextSelection.cs b/Runtime/Text/TextSelection.cs new file mode 100644 index 0000000..816f7d8 --- /dev/null +++ b/Runtime/Text/TextSelection.cs @@ -0,0 +1,48 @@ +using System.Collections; +using System.Collections.Generic; + +namespace Rokojori +{ + public class TextSelection + { + TextAnchor _start; + TextAnchor _end; + + public TextSelection( TextAnchor start, TextAnchor end ) + { + _start = start.Copy(); + _end = end.Copy(); + } + + public TextAnchor start { get { return _start; } } + public TextAnchor end { get { return _end; } } + public TextSelection Copy() { return new TextSelection( start, end ); } + + public bool isOneLine { get { return _start.lineIndex == _end.lineIndex; } } + public bool isAnchor { get { return isOneLine && _start.characterIndex == _end.characterIndex; } } + + public string info + { + get + { + if ( isAnchor ) + { + // Output: 12 (1) + return start.info; + } + + if ( isOneLine ) + { + // Output: 12 (1-6) + return start.lineIndex + " (" + start.characterIndex + "-" + end.characterIndex + ")"; + } + + // Output: 12-15 (3,12) + return start.lineIndex + "-" + end.lineIndex + + "(" + start.characterIndex + "," + end.characterIndex + ")"; + } + } + + } + +} \ No newline at end of file diff --git a/Runtime/Tools/Lists.cs b/Runtime/Tools/Lists.cs new file mode 100644 index 0000000..bb1117c --- /dev/null +++ b/Runtime/Tools/Lists.cs @@ -0,0 +1,250 @@ +using System.Collections; +using System.Collections.Generic; +using System.Text; +using System; + +namespace Rokojori +{ + public class Lists + { + public static List ToList( T[] array ) + { + var list = new List(); + list.AddRange( array ); + return list; + } + + public static bool Has( List list, T item ) + { + return list.IndexOf( item ) != - 1; + } + + public static T Pop( List list ) + { + if ( list.Count == 0 ){ return default(T); } + + var element = list[ list.Count - 1 ]; + list.RemoveAt( list.Count - 1 ); + return element; + } + + public static T Last( List list ) + { + return list.Count == 0 ? default(T) : list[ list.Count - 1 ]; + } + + + public static int CountItems( List list, Predicate test ) + { + var result = 0; + + for ( int i = 0; i < list.Count; i++ ) + { + if ( test( list[ i ] ) ) + { + result++; + } + } + + return result; + } + + public static int CountItems( T[] list, Predicate test ) + { + var result = 0; + + for ( int i = 0; i < list.Length; i++ ) + { + if ( test( list[ i ] ) ) + { + result++; + } + } + + return result; + } + + public static bool AreEntriesEqual( List a, List b ) + { + if ( a.Count != b.Count ) + { + return false; + } + + for ( int i = 0; i < a.Count; i++ ) + { + var isEqual = EqualityComparer.Default.Equals( a[ i ], b[ i ]); + + if ( ! isEqual ) + { + return false; + } + } + + return true; + } + + + + public static string Join( List array, string seperator = ", " ) + { + var sb = new StringBuilder(); + + for ( var i = 0; i < array.Count; i++ ) + { + if ( i != 0 ) + { + sb.Append( seperator ); + } + + sb.Append( array[ i ] ); + } + + return sb.ToString(); + } + + public static List From( T[] array ) + { + var copy = new List(); + copy.AddRange( array ); + return copy; + } + + public static List From( List list ) + { + var copy = new List(); + copy.AddRange( list ); + return copy; + } + + public static void Filter( List inputList, List list, Func filter ) + { + for ( int i = 0; i < inputList.Count; i++ ) + { + if ( filter( inputList[ i ], i ) ) + { + list.Add( inputList[ i ] ); + } + } + } + + public static void Filter( List inputList, List list, Func filter ) + { + for ( int i = 0; i < inputList.Count; i++ ) + { + if ( filter( inputList[ i ] ) ) + { + list.Add( inputList[ i ] ); + } + } + } + + public static List Filter( List inputList, Func filter ) + { + var list = new List(); + + for ( int i = 0; i < inputList.Count; i++ ) + { + if ( filter( inputList[ i ] ) ) + { + list.Add( inputList[ i ] ); + } + } + + return list; + } + + public static List FilterType( List inputList ) where R:T + { + var list = new List(); + + inputList.ForEach + ( + e => + { + if ( e == null || ! typeof( R ).IsAssignableFrom( e.GetType() ) ) + { + return; + } + + list.Add( (R) e ); + } + ); + + return list; + } + + public static T Find( List list, Func callback ) + { + for ( int i = 0; i < list.Count; i++ ) + { + if ( callback( list[ i ] ) ) + { + return list[ i ]; + } + } + + return default( T ); + } + + public static List Map( List inputList, Func mapper, List list = null ) + { + if ( list == null ) + { + list = new List(); + } + + for ( int i = 0; i < inputList.Count; i++ ) + { + list.Add( mapper( inputList[ i ], i ) ); + } + + return list; + } + + public static List Map( T[] inputList, Func mapper, List list = null ) + { + if ( list == null ) + { + list = new List(); + } + + for ( int i = 0; i < inputList.Length; i++ ) + { + list.Add( mapper( inputList[ i ], i ) ); + } + + return list; + } + + public static List Map( List inputList, Func mapper, List list = null ) + { + if ( list == null ) + { + list = new List(); + } + + for ( int i = 0; i < inputList.Count; i++ ) + { + list.Add( mapper( inputList[ i ] ) ); + } + + return list; + } + + public static List Map( T[] inputList, Func mapper, List list = null ) + { + if ( list == null ) + { + list = new List(); + } + + for ( int i = 0; i < inputList.Length; i++ ) + { + list.Add( mapper( inputList[ i ] ) ); + } + + return list; + } + } +} \ No newline at end of file diff --git a/Runtime/Tools/ReflectionHelper.cs b/Runtime/Tools/ReflectionHelper.cs new file mode 100644 index 0000000..d31b15d --- /dev/null +++ b/Runtime/Tools/ReflectionHelper.cs @@ -0,0 +1,241 @@ +using System.Collections; +using System.Collections.Generic; +using System; +using System.Reflection; +using System.Text.RegularExpressions; + +namespace Rokojori +{ + public class ReflectionHelper + { + public static Type GetTypeByNameFromAssembly( string name, Assembly assembly ) + { + var type = assembly.GetType( name ); + + if ( type != null ) + { + return type; + } + + var types = assembly.GetTypes(); + + var genericEndingRegex = @"`\d+$"; + + for ( int i = 0; i < types.Length; i++ ) + { + var typeName = types[ i ].Name; + var isGeneric = Regex.IsMatch( typeName, genericEndingRegex ); + + if ( ! isGeneric ) + { + continue; + } + + var typeNameWithoutGeneric = Regex.Replace( typeName, genericEndingRegex, "" ); + + if ( typeNameWithoutGeneric == name ) + { + return types[ i ]; + } + } + + return null; + + } + + public static Type GetTypeByName( string name) + { + var assemblies = new List(); + assemblies.AddRange( AppDomain.CurrentDomain.GetAssemblies() ); + assemblies.Reverse(); + + var assembly = assemblies.Find( a => a.GetType( name ) != null ); + + return assembly == null ? null : assembly.GetType( name ); + } + + public static bool IsList( Type type ) + { + if ( ! ( type.IsGenericType ) ) + { + return false; + } + + return type.GetGenericTypeDefinition().IsAssignableFrom( typeof( List<> ) ); + } + + public static bool IsList( object objectValue ) + { + if ( objectValue == null ) + { + return false; + } + + if ( ! ( objectValue is IList ) ) + { + return false; + } + + return IsList( objectValue.GetType() ); + } + + public static bool IsDictionary( Type type ) + { + if ( ! ( type.IsGenericType ) ) + { + return false; + } + + return type.GetGenericTypeDefinition().IsAssignableFrom( typeof( Dictionary<,> ) ); + } + + public static bool IsDictionary( object objectValue ) + { + if ( objectValue == null ) + { + return false; + } + + if ( ! ( objectValue is IDictionary ) ) + { + return false; + } + + return IsDictionary( objectValue.GetType() ); + } + + public static string GetMemberName( object obj, object member ) + { + if ( obj == null || member == null ) + { + return null; + } + + var type = obj.GetType(); + var fields = type.GetFields(); + + for ( int i = 0; i < fields.Length; i++ ) + { + var value = fields[ i ].GetValue( obj ); + + if ( value == member ) + { + return fields[ i ].Name; + } + } + + return null; + + } + + public static List GetFieldsOfType( object instance ) where T:class + { + var type = instance.GetType(); + var fields = type.GetFields(); + var list = new List(); + + for ( int i = 0; i < fields.Length; i++ ) + { + var value = fields[ i ].GetValue( instance ); + var tValue = value as T; + + if ( tValue != null ) + { + list.Add( tValue ); + } + } + + return list; + } + + public static void GetFields( System.Action action ) + { + GetFields( typeof( C ), action ); + } + + public static void GetFields( System.Type c, System.Action action ) + { + var fields = c.GetFields(); + + foreach( var f in fields ) + { + if ( f.FieldType == typeof( T ) ) + { + action( f ); + } + } + } + + public static System.Reflection.FieldInfo GetFieldInfo( object instance, string memberName ) + { + var type = instance.GetType(); + var fields = type.GetFields(); + var index = -1; + + for ( int i = 0; i < fields.Length; i++ ) + { + if ( fields[ i ].Name == memberName ) + { + index = i; + } + + } + + return index == -1 ? null : fields[ index ]; + } + + public static bool HasMember( object instance, string memberName ) + { + return GetFieldInfo( instance, memberName ) != null; + } + + public static object GetMemberValue( object instance, string memberName ) + { + try + { + var field = ReflectionHelper.GetFieldInfo( instance, memberName ); + + if ( field == null ) + { + RJLog.Log(instance, "GetValue: member not found with name ", "'" + memberName + "'" ); + + return null; + } + + return field.GetValue( instance ); + + } + catch( System.Exception e ) + { + RJLog.Log(e ); + } + + return null; + } + + public static void SetMemberValue( object instance, string memberName, object value ) + { + try + { + var field = ReflectionHelper.GetFieldInfo( instance, memberName ); + + if ( field == null ) + { + RJLog.Log(instance, "SetValue: member not found with name ", "'" + memberName + "'" ); + + return; + } + + field.SetValue( instance, value ); + + } + catch( System.Exception e ) + { + RJLog.Log(e ); + } + + } + + + } +} \ No newline at end of file