7.18

GQ_Communicate/Assembly-CSharp-Editor.csproj

@@ -57,6 +57,16 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Assets\TutorialInfo\Scripts\Editor\ReadmeEditor.cs" />
+    <Compile Include="Assets\Demigiant\DOTweenPro\Editor\DOTweenPreviewManager.cs" />
+    <Compile Include="Assets\Demigiant\DOTweenPro\Editor\DOTweenAnimationInspector.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Assets\Demigiant\DemiLib\Core\Editor\DemiEditor.dll" />
+    <None Include="Assets\Demigiant\DemiLib\Core\Editor\DemiEditor.xml" />
+    <None Include="Assets\Demigiant\DOTween\Editor\DOTweenEditor.dll" />
+    <None Include="Assets\Demigiant\DOTweenPro\Editor\DOTweenProEditor.XML" />
+    <None Include="Assets\Demigiant\DOTweenPro\Editor\DOTweenProEditor.dll" />
+    <None Include="Assets\Demigiant\DOTween\Editor\DOTweenEditor.XML" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="UnityEngine">
@@ -317,15 +327,27 @@
     <Reference Include="Unity.Plastic.Newtonsoft.Json">
       <HintPath>Library\PackageCache\com.unity.collab-proxy@1.15.16\Lib\Editor\PlasticSCM\Unity.Plastic.Newtonsoft.Json.dll</HintPath>
     </Reference>
+    <Reference Include="DemiLib">
+      <HintPath>Assets\Demigiant\DemiLib\Core\DemiLib.dll</HintPath>
+    </Reference>
     <Reference Include="Unity.Plastic.Antlr3.Runtime">
       <HintPath>Library\PackageCache\com.unity.collab-proxy@1.15.16\Lib\Editor\PlasticSCM\Unity.Plastic.Antlr3.Runtime.dll</HintPath>
     </Reference>
     <Reference Include="Unity.VisualScripting.YamlDotNet">
       <HintPath>Library\PackageCache\com.unity.visualscripting@1.7.6\Editor\VisualScripting.Core\Dependencies\YamlDotNet\Unity.VisualScripting.YamlDotNet.dll</HintPath>
     </Reference>
+    <Reference Include="DOTweenProEditor">
+      <HintPath>Assets\Demigiant\DOTweenPro\Editor\DOTweenProEditor.dll</HintPath>
+    </Reference>
+    <Reference Include="DOTweenEditor">
+      <HintPath>Assets\Demigiant\DOTween\Editor\DOTweenEditor.dll</HintPath>
+    </Reference>
     <Reference Include="Unity.Burst.Unsafe">
       <HintPath>Library\PackageCache\com.unity.burst@1.6.5\Unity.Burst.Unsafe.dll</HintPath>
     </Reference>
+    <Reference Include="DemiEditor">
+      <HintPath>Assets\Demigiant\DemiLib\Core\Editor\DemiEditor.dll</HintPath>
+    </Reference>
     <Reference Include="Unity.Burst.Cecil.Mdb">
       <HintPath>Library\PackageCache\com.unity.burst@1.6.5\Unity.Burst.CodeGen\Unity.Burst.Cecil.Mdb.dll</HintPath>
     </Reference>
@@ -344,12 +366,18 @@
     <Reference Include="Unity.Burst.Cecil.Rocks">
       <HintPath>Library\PackageCache\com.unity.burst@1.6.5\Unity.Burst.CodeGen\Unity.Burst.Cecil.Rocks.dll</HintPath>
     </Reference>
+    <Reference Include="DOTween">
+      <HintPath>Assets\Demigiant\DOTween\DOTween.dll</HintPath>
+    </Reference>
     <Reference Include="Unity.VisualScripting.Antlr3.Runtime">
       <HintPath>Library\PackageCache\com.unity.visualscripting@1.7.6\Runtime\VisualScripting.Flow\Dependencies\NCalc\Unity.VisualScripting.Antlr3.Runtime.dll</HintPath>
     </Reference>
     <Reference Include="Newtonsoft.Json">
       <HintPath>Library\PackageCache\com.unity.nuget.newtonsoft-json@3.0.2\Runtime\Newtonsoft.Json.dll</HintPath>
     </Reference>
+    <Reference Include="DOTweenPro">
+      <HintPath>Assets\Demigiant\DOTweenPro\DOTweenPro.dll</HintPath>
+    </Reference>
     <Reference Include="unityplastic">
       <HintPath>Library\PackageCache\com.unity.collab-proxy@1.15.16\Lib\Editor\PlasticSCM\unityplastic.dll</HintPath>
     </Reference>

GQ_Communicate/Assembly-CSharp.csproj

@@ -56,18 +56,46 @@
     <Analyzer Include="E:\VS\Common7\IDE\Extensions\Microsoft\Visual Studio Tools for Unity\Analyzers\Microsoft.Unity.Analyzers.dll" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Assets\script\SkyboxManager.cs" />
+    <Compile Include="Assets\Demigiant\DOTweenPro\DOTweenProShortcuts.cs" />
+    <Compile Include="Assets\Demigiant\DOTweenPro\DOTweenTextMeshPro.cs" />
+    <Compile Include="Assets\script\加密\EncryptionScript.cs" />
+    <Compile Include="Assets\script\透明\TransparentGlow.cs" />
+    <Compile Include="Assets\script\天空盒\SkyboxManager.cs" />
     <Compile Include="Assets\script\相机\ExtendedFlycam.cs" />
+    <Compile Include="Assets\Demigiant\DOTween\Modules\DOTweenModulePhysics2D.cs" />
+    <Compile Include="Assets\Demigiant\DOTweenPro\DOTweenAnimation.cs" />
+    <Compile Include="Assets\Demigiant\DOTweenPro\DOTweenTk2d.cs" />
+    <Compile Include="Assets\Demigiant\DOTween\Modules\DOTweenModuleUnityVersion.cs" />
+    <Compile Include="Assets\Demigiant\DOTween\Modules\DOTweenModuleUtils.cs" />
     <Compile Include="Assets\script\热力图\HeatMapPoints.cs" />
+    <Compile Include="Assets\script\透明\BaseWallControlTwo.cs" />
     <Compile Include="Assets\TutorialInfo\Scripts\Readme.cs" />
+    <Compile Include="Assets\script\点击\ClickEvent.cs" />
+    <Compile Include="Assets\script\透明\TransparentGlowManage.cs" />
+    <Compile Include="Assets\Demigiant\DOTween\Modules\DOTweenModulePhysics.cs" />
+    <Compile Include="Assets\Demigiant\DOTween\Modules\DOTweenModuleSprite.cs" />
     <Compile Include="Assets\Scripts\HeatMapComponent.cs" />
     <Compile Include="Assets\Scripts\HeatMapFactor.cs" />
-    <Compile Include="Assets\script\透明\BaseWallControlTwo.cs" />
+    <Compile Include="Assets\Demigiant\DOTween\Modules\DOTweenModuleUI.cs" />
+    <Compile Include="Assets\Demigiant\DOTween\Modules\DOTweenModuleAudio.cs" />
+    <Compile Include="Assets\script\加密\KeyGenerator.cs" />
+    <Compile Include="Assets\script\DrawLine.cs" />
+    <Compile Include="Assets\script\UI\PatternChoose.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Assets\Shaders\HeatMapShader.shader" />
+    <None Include="Assets\Resources\TransparentGlow.shader" />
+    <None Include="Assets\Demigiant\readme_DOTweenPro.txt" />
+    <None Include="Assets\Demigiant\DOTween\DOTween.XML" />
+    <None Include="Assets\Demigiant\DemiLib\Core\DemiLib.dll" />
+    <None Include="Assets\Demigiant\DOTween\DOTween.dll" />
     <None Include="Assets\Shaders\MetallBallHeatMapShader.shader" />
+    <None Include="Assets\Demigiant\DOTweenPro\DOTweenPro.dll" />
+    <None Include="Assets\Demigiant\DOTweenPro\readme.txt" />
+    <None Include="Assets\Demigiant\DemiLib\Core\DemiLib.xml" />
+    <None Include="Assets\Demigiant\DOTweenPro\DOTweenPro.XML" />
     <None Include="Assets\Shaders\HeatMapShaderPeak.shader" />
+    <None Include="Assets\Demigiant\DOTween\readme.txt" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="UnityEngine">
@@ -313,6 +341,9 @@
     <Reference Include="UnityEditor.UnityConnectModule">
       <HintPath>E:\Unity\2021.3.2f1c1\Editor\Data\Managed\UnityEngine\UnityEditor.UnityConnectModule.dll</HintPath>
     </Reference>
+    <Reference Include="DemiLib">
+      <HintPath>Assets\Demigiant\DemiLib\Core\DemiLib.dll</HintPath>
+    </Reference>
     <Reference Include="Unity.Burst.Unsafe">
       <HintPath>Library\PackageCache\com.unity.burst@1.6.5\Unity.Burst.Unsafe.dll</HintPath>
     </Reference>
@@ -328,12 +359,18 @@
     <Reference Include="Unity.Burst.Cecil.Rocks">
       <HintPath>Library\PackageCache\com.unity.burst@1.6.5\Unity.Burst.CodeGen\Unity.Burst.Cecil.Rocks.dll</HintPath>
     </Reference>
+    <Reference Include="DOTween">
+      <HintPath>Assets\Demigiant\DOTween\DOTween.dll</HintPath>
+    </Reference>
     <Reference Include="Unity.VisualScripting.Antlr3.Runtime">
       <HintPath>Library\PackageCache\com.unity.visualscripting@1.7.6\Runtime\VisualScripting.Flow\Dependencies\NCalc\Unity.VisualScripting.Antlr3.Runtime.dll</HintPath>
     </Reference>
     <Reference Include="Newtonsoft.Json">
       <HintPath>Library\PackageCache\com.unity.nuget.newtonsoft-json@3.0.2\Runtime\Newtonsoft.Json.dll</HintPath>
     </Reference>
+    <Reference Include="DOTweenPro">
+      <HintPath>Assets\Demigiant\DOTweenPro\DOTweenPro.dll</HintPath>
+    </Reference>
     <Reference Include="netstandard">
       <HintPath>E:\Unity\2021.3.2f1c1\Editor\Data\NetStandard\ref\2.1.0\netstandard.dll</HintPath>
     </Reference>

GQ_Communicate/Assets/Demigiant.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 898730fb72296dc4d8ca129bc23ae977
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d4e975fa3d8a03847b36769efdab0a5d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/DOTween.XML.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 34192c5e0d14aee43a0e86cc4823268a
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/DOTween.dll.mdb.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4f007001a22b3d24dae350342c4d19c8
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/DOTween.dll.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: a811bde74b26b53498b4f6d872b09b6d
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1565007c26338c54ab00d39262b50be0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/DOTweenEditor.XML

@@ -0,0 +1,98 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>DOTweenEditor</name>
+    </assembly>
+    <members>
+        <member name="M:DG.DOTweenEditor.DOTweenEditorPreview.Start(System.Action)">
+            <summary>
+            Starts the update loop of tween in the editor. Has no effect during playMode.
+            </summary>
+            <param name="onPreviewUpdated">Eventual callback to call after every update</param>
+        </member>
+        <member name="M:DG.DOTweenEditor.DOTweenEditorPreview.Stop(System.Boolean)">
+            <summary>
+            Stops the update loop and clears the onPreviewUpdated callback.
+            </summary>
+            <param name="resetTweenTargets">If TRUE also resets the tweened objects to their original state</param>
+        </member>
+        <member name="M:DG.DOTweenEditor.DOTweenEditorPreview.PrepareTweenForPreview(DG.Tweening.Tween,System.Boolean,System.Boolean,System.Boolean)">
+            <summary>
+            Readies the tween for editor preview by setting its UpdateType to Manual plus eventual extra settings.
+            </summary>
+            <param name="t">The tween to ready</param>
+            <param name="clearCallbacks">If TRUE (recommended) removes all callbacks (OnComplete/Rewind/etc)</param>
+            <param name="preventAutoKill">If TRUE prevents the tween from being auto-killed at completion</param>
+            <param name="andPlay">If TRUE starts playing the tween immediately</param>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.SetEditorTexture(UnityEngine.Texture2D,UnityEngine.FilterMode,System.Int32)">
+            <summary>
+            Checks that the given editor texture use the correct import settings,
+            and applies them if they're incorrect.
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.DOTweenSetupRequired">
+            <summary>
+            Returns TRUE if setup is required
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.AssetExists(System.String)">
+            <summary>
+            Returns TRUE if the file/directory at the given path exists.
+            </summary>
+            <param name="adbPath">Path, relative to Unity's project folder</param>
+            <returns></returns>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.ADBPathToFullPath(System.String)">
+            <summary>
+            Converts the given project-relative path to a full path,
+            with backward (\) slashes).
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.FullPathToADBPath(System.String)">
+            <summary>
+            Converts the given full path to a path usable with AssetDatabase methods
+            (relative to Unity's project folder, and with the correct Unity forward (/) slashes).
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.ConnectToSourceAsset``1(System.String,System.Boolean)">
+            <summary>
+            Connects to a <see cref="T:UnityEngine.ScriptableObject"/> asset.
+            If the asset already exists at the given path, loads it and returns it.
+            Otherwise, either returns NULL or automatically creates it before loading and returning it
+            (depending on the given parameters).
+            </summary>
+            <typeparam name="T">Asset type</typeparam>
+            <param name="adbFilePath">File path (relative to Unity's project folder)</param>
+            <param name="createIfMissing">If TRUE and the requested asset doesn't exist, forces its creation</param>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.GetAssemblyFilePath(System.Reflection.Assembly)">
+            <summary>
+            Full path for the given loaded assembly, assembly file included
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.AddGlobalDefine(System.String)">
+            <summary>
+            Adds the given global define if it's not already present
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.RemoveGlobalDefine(System.String)">
+            <summary>
+            Removes the given global define if it's present
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.EditorUtils.HasGlobalDefine(System.String,System.Nullable{UnityEditor.BuildTargetGroup})">
+            <summary>
+            Returns TRUE if the given global define is present in all the <see cref="T:UnityEditor.BuildTargetGroup"/>
+            or only in the given <see cref="T:UnityEditor.BuildTargetGroup"/>, depending on passed parameters.<para/>
+            </summary>
+            <param name="id"></param>
+            <param name="buildTargetGroup"><see cref="T:UnityEditor.BuildTargetGroup"/>to use. Leave NULL to check in all of them.</param>
+        </member>
+        <member name="T:DG.DOTweenEditor.DOTweenDefines">
+            <summary>
+            Not used as menu item anymore, but as a utiity function
+            </summary>
+        </member>
+    </members>
+</doc>

GQ_Communicate/Assets/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2e2c6224d345d9249acfa6e8ef40bb2d
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll.mdb.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8f46310a8b0a8f04a92993c37c713243
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: 45d5034162d6cf04dbe46da84fc7d074
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/Imgs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9ae1c63759a20fa478f14aadba8a5659
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta

@@ -0,0 +1,98 @@
+fileFormatVersion: 2
+guid: 8da095e39e9b4df488dfd436f81116d6
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 1
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 128
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 128
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/Imgs/Footer.png.meta

@@ -0,0 +1,98 @@
+fileFormatVersion: 2
+guid: 7051dba417b3d53409f2918f1ea4938d
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 1
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 256
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 256
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta

@@ -0,0 +1,98 @@
+fileFormatVersion: 2
+guid: 519694efe2bb2914788b151fbd8c01f4
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 1024
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 1024
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta

@@ -0,0 +1,98 @@
+fileFormatVersion: 2
+guid: 78a59ca99f8987941adb61f9e14a06a7
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 1
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 512
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 512
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9b0d022431e5a5240909230e7c725827
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs

@@ -0,0 +1,202 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true // MODULE_MARKER
+using System;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+#if UNITY_5 || UNITY_2017_1_OR_NEWER
+using UnityEngine.Audio; // Required for AudioMixer
+#endif
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModuleAudio
+    {
+        #region Shortcuts
+
+        #region Audio
+
+        /// <summary>Tweens an AudioSource's volume to the given value.
+        /// Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFade(this AudioSource target, float endValue, float duration)
+        {
+            if (endValue < 0) endValue = 0;
+            else if (endValue > 1) endValue = 1;
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.volume, x => target.volume = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an AudioSource's pitch to the given value.
+        /// Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOPitch(this AudioSource target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.pitch, x => target.pitch = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+#if UNITY_5 || UNITY_2017_1_OR_NEWER
+        #region AudioMixer (Unity 5 or Newer)
+
+        /// <summary>Tweens an AudioMixer's exposed float to the given value.
+        /// Also stores the AudioMixer as the tween's target so it can be used for filtered operations.
+        /// Note that you need to manually expose a float in an AudioMixerGroup in order to be able to tween it from an AudioMixer.</summary>
+        /// <param name="floatName">Name given to the exposed float to set</param>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOSetFloat(this AudioMixer target, string floatName, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(()=> {
+                    float currVal;
+                    target.GetFloat(floatName, out currVal);
+                    return currVal;
+                }, x=> target.SetFloat(floatName, x), endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #region Operation Shortcuts
+
+        /// <summary>
+        /// Completes all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens completed
+        /// (meaning the tweens that don't have infinite loops and were not already complete)
+        /// </summary>
+        /// <param name="withCallbacks">For Sequences only: if TRUE also internal Sequence callbacks will be fired,
+        /// otherwise they will be ignored</param>
+        public static int DOComplete(this AudioMixer target, bool withCallbacks = false)
+        {
+            return DOTween.Complete(target, withCallbacks);
+        }
+
+        /// <summary>
+        /// Kills all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens killed.
+        /// </summary>
+        /// <param name="complete">If TRUE completes the tween before killing it</param>
+        public static int DOKill(this AudioMixer target, bool complete = false)
+        {
+            return DOTween.Kill(target, complete);
+        }
+
+        /// <summary>
+        /// Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens flipped.
+        /// </summary>
+        public static int DOFlip(this AudioMixer target)
+        {
+            return DOTween.Flip(target);
+        }
+
+        /// <summary>
+        /// Sends to the given position all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens involved.
+        /// </summary>
+        /// <param name="to">Time position to reach
+        /// (if higher than the whole tween duration the tween will simply reach its end)</param>
+        /// <param name="andPlay">If TRUE will play the tween after reaching the given position, otherwise it will pause it</param>
+        public static int DOGoto(this AudioMixer target, float to, bool andPlay = false)
+        {
+            return DOTween.Goto(target, to, andPlay);
+        }
+
+        /// <summary>
+        /// Pauses all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens paused.
+        /// </summary>
+        public static int DOPause(this AudioMixer target)
+        {
+            return DOTween.Pause(target);
+        }
+
+        /// <summary>
+        /// Plays all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens played.
+        /// </summary>
+        public static int DOPlay(this AudioMixer target)
+        {
+            return DOTween.Play(target);
+        }
+
+        /// <summary>
+        /// Plays backwards all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens played.
+        /// </summary>
+        public static int DOPlayBackwards(this AudioMixer target)
+        {
+            return DOTween.PlayBackwards(target);
+        }
+
+        /// <summary>
+        /// Plays forward all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens played.
+        /// </summary>
+        public static int DOPlayForward(this AudioMixer target)
+        {
+            return DOTween.PlayForward(target);
+        }
+
+        /// <summary>
+        /// Restarts all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens restarted.
+        /// </summary>
+        public static int DORestart(this AudioMixer target)
+        {
+            return DOTween.Restart(target);
+        }
+
+        /// <summary>
+        /// Rewinds all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens rewinded.
+        /// </summary>
+        public static int DORewind(this AudioMixer target)
+        {
+            return DOTween.Rewind(target);
+        }
+
+        /// <summary>
+        /// Smoothly rewinds all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens rewinded.
+        /// </summary>
+        public static int DOSmoothRewind(this AudioMixer target)
+        {
+            return DOTween.SmoothRewind(target);
+        }
+
+        /// <summary>
+        /// Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference
+        /// (meaning tweens that were started from this target, or that had this target added as an Id)
+        /// and returns the total number of tweens involved.
+        /// </summary>
+        public static int DOTogglePause(this AudioMixer target)
+        {
+            return DOTween.TogglePause(target);
+        }
+
+        #endregion
+
+        #endregion
+#endif
+
+        #endregion
+    }
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b766d08851589514b97afb23c6f30a70
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs

@@ -0,0 +1,216 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true // MODULE_MARKER
+using System;
+using DG.Tweening.Core;
+using DG.Tweening.Core.Enums;
+using DG.Tweening.Plugins;
+using DG.Tweening.Plugins.Core.PathCore;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModulePhysics
+    {
+        #region Shortcuts
+
+        #region Rigidbody
+
+        /// <summary>Tweens a Rigidbody's position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMove(this Rigidbody target, Vector3 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's X position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveX(this Rigidbody target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's Y position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveY(this Rigidbody target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's Z position to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveZ(this Rigidbody target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's rotation to the given value.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="mode">Rotation mode</param>
+        public static TweenerCore<Quaternion, Vector3, QuaternionOptions> DORotate(this Rigidbody target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast)
+        {
+            TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
+            t.SetTarget(target);
+            t.plugOptions.rotateMode = mode;
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody's rotation so that it will look towards the given position.
+        /// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="towards">The position to look at</param><param name="duration">The duration of the tween</param>
+        /// <param name="axisConstraint">Eventual axis constraint for the rotation</param>
+        /// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
+        public static TweenerCore<Quaternion, Vector3, QuaternionOptions> DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null)
+        {
+            TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration)
+                .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
+            t.plugOptions.axisConstraint = axisConstraint;
+            t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up;
+            return t;
+        }
+
+        #region Special
+
+        /// <summary>Tweens a Rigidbody's position to the given value, while also applying a jump effect along the Y axis.
+        /// Returns a Sequence instead of a Tweener.
+        /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
+        /// <param name="numJumps">Total number of jumps</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Sequence DOJump(this Rigidbody target, Vector3 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
+        {
+            if (numJumps < 1) numJumps = 1;
+            float startPosY = 0;
+            float offsetY = -1;
+            bool offsetYSet = false;
+            Sequence s = DOTween.Sequence();
+            Tween yTween = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, jumpPower, 0), duration / (numJumps * 2))
+                .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
+                .SetLoops(numJumps * 2, LoopType.Yoyo)
+                .OnStart(() => startPosY = target.position.y);
+            s.Append(DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue.x, 0, 0), duration)
+                    .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                ).Join(DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue.z), duration)
+                    .SetOptions(AxisConstraint.Z, snapping).SetEase(Ease.Linear)
+                ).Join(yTween)
+                .SetTarget(target).SetEase(DOTween.defaultEaseType);
+            yTween.OnUpdate(() => {
+                if (!offsetYSet) {
+                    offsetYSet = true;
+                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                }
+                Vector3 pos = target.position;
+                pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
+                target.MovePosition(pos);
+            });
+            return s;
+        }
+
+        /// <summary>Tweens a Rigidbody's position through the given path waypoints, using the chosen path algorithm.
+        /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations.
+        /// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
+        /// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
+        /// If you plan to publish there you should use a regular transform.DOPath.</para></summary>
+        /// <param name="path">The waypoints to go through</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
+        /// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
+        /// <param name="resolution">The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive.
+        /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
+        /// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
+        public static TweenerCore<Vector3, Path, PathOptions> DOPath(
+            this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
+            PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
+        )
+        {
+            if (resolution < 1) resolution = 1;
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, new Path(pathType, path, resolution, gizmoColor), duration)
+                .SetTarget(target).SetUpdate(UpdateType.Fixed);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            return t;
+        }
+        /// <summary>Tweens a Rigidbody's localPosition through the given path waypoints, using the chosen path algorithm.
+        /// Also stores the Rigidbody as the tween's target so it can be used for filtered operations
+        /// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
+        /// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
+        /// If you plan to publish there you should use a regular transform.DOLocalPath.</para></summary>
+        /// <param name="path">The waypoint to go through</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="pathType">The type of path: Linear (straight path) or CatmullRom (curved CatmullRom path)</param>
+        /// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
+        /// <param name="resolution">The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive.
+        /// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
+        /// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
+        public static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
+            this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
+            PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
+        )
+        {
+            if (resolution < 1) resolution = 1;
+            Transform trans = target.transform;
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path, resolution, gizmoColor), duration)
+                .SetTarget(target).SetUpdate(UpdateType.Fixed);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            t.plugOptions.useLocalPosition = true;
+            return t;
+        }
+        // Used by path editor when creating the actual tween, so it can pass a pre-compiled path
+        internal static TweenerCore<Vector3, Path, PathOptions> DOPath(
+            this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D
+        )
+        {
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, path, duration)
+                .SetTarget(target);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            return t;
+        }
+        internal static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
+            this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D
+        )
+        {
+            Transform trans = target.transform;
+            TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), path, duration)
+                .SetTarget(target);
+
+            t.plugOptions.isRigidbody = true;
+            t.plugOptions.mode = pathMode;
+            t.plugOptions.useLocalPosition = true;
+            return t;
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+	}
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dae9aa560b4242648a3affa2bfabc365
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs

@@ -0,0 +1,107 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true && (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
+using System;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModulePhysics2D
+    {
+        #region Shortcuts
+
+        #region Rigidbody2D Shortcuts
+
+        /// <summary>Tweens a Rigidbody2D's position to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody2D's X position to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody2D's Y position to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Rigidbody2D's rotation to the given value.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DORotate(this Rigidbody2D target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #region Special
+
+        /// <summary>Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis.
+        /// Returns a Sequence instead of a Tweener.
+        /// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
+        /// <para>IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set the position</para></summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
+        /// <param name="numJumps">Total number of jumps</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Sequence DOJump(this Rigidbody2D target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
+        {
+            if (numJumps < 1) numJumps = 1;
+            float startPosY = 0;
+            float offsetY = -1;
+            bool offsetYSet = false;
+            Sequence s = DOTween.Sequence();
+            Tween yTween = DOTween.To(() => target.position, x => target.position = x, new Vector2(0, jumpPower), duration / (numJumps * 2))
+                .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
+                .SetLoops(numJumps * 2, LoopType.Yoyo)
+                .OnStart(() => startPosY = target.position.y);
+            s.Append(DOTween.To(() => target.position, x => target.position = x, new Vector2(endValue.x, 0), duration)
+                    .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                ).Join(yTween)
+                .SetTarget(target).SetEase(DOTween.defaultEaseType);
+            yTween.OnUpdate(() => {
+                if (!offsetYSet) {
+                    offsetYSet = true;
+                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                }
+                Vector3 pos = target.position;
+                pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
+                target.MovePosition(pos);
+            });
+            return s;
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+	}
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 230fe34542e175245ba74b4659dae700
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs

@@ -0,0 +1,92 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true && (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
+using System;
+using UnityEngine;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModuleSprite
+    {
+        #region Shortcuts
+
+        #region SpriteRenderer
+
+        /// <summary>Tweens a SpriteRenderer's color to the given value.
+        /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this SpriteRenderer target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Material's alpha color to the given value.
+        /// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this SpriteRenderer target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a SpriteRenderer's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this SpriteRenderer target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+
+        #endregion
+
+        #region Blendables
+
+        #region SpriteRenderer
+
+        /// <summary>Tweens a SpriteRenderer's color to the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the SpriteRenderer as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this SpriteRenderer target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                    Color diff = x - to;
+                    to = x;
+                    target.color += diff;
+                }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+	}
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 188918ab119d93148aa0de59ccf5286b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleUI.cs

@@ -0,0 +1,604 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+#if true && (UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using DG.Tweening.Core;
+using DG.Tweening.Core.Enums;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenModuleUI
+    {
+        #region Shortcuts
+
+        #region CanvasGroup
+
+        /// <summary>Tweens a CanvasGroup's alpha color to the given value.
+        /// Also stores the canvasGroup as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFade(this CanvasGroup target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.alpha, x => target.alpha = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Graphic
+
+        /// <summary>Tweens an Graphic's color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Graphic target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Graphic's alpha color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Graphic target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Image
+
+        /// <summary>Tweens an Image's color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Image target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Image's alpha color to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Image target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Image's fillAmount to the given value.
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFillAmount(this Image target, float endValue, float duration)
+        {
+            if (endValue > 1) endValue = 1;
+            else if (endValue < 0) endValue = 0;
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.fillAmount, x => target.fillAmount = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an Image's colors using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this Image target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+
+        #endregion
+
+        #region LayoutElement
+
+        /// <summary>Tweens an LayoutElement's flexibleWidth/Height to the given value.
+        /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOFlexibleSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.flexibleWidth, target.flexibleHeight), x => {
+                    target.flexibleWidth = x.x;
+                    target.flexibleHeight = x.y;
+                }, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an LayoutElement's minWidth/Height to the given value.
+        /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOMinSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.minWidth, target.minHeight), x => {
+                target.minWidth = x.x;
+                target.minHeight = x.y;
+            }, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens an LayoutElement's preferredWidth/Height to the given value.
+        /// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPreferredSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.preferredWidth, target.preferredHeight), x => {
+                target.preferredWidth = x.x;
+                target.preferredHeight = x.y;
+            }, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Outline
+
+        /// <summary>Tweens a Outline's effectColor to the given value.
+        /// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Outline target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.effectColor, x => target.effectColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Outline's effectColor alpha to the given value.
+        /// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Outline target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.effectColor, x => target.effectColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Outline's effectDistance to the given value.
+        /// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScale(this Outline target, Vector2 endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.effectDistance, x => target.effectDistance = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region RectTransform
+
+        /// <summary>Tweens a RectTransform's anchoredPosition to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPos(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition X to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPosX(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition Y to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPosY(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's anchoredPosition3D to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3D(this RectTransform target, Vector3 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition3D X to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DX(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition3D Y to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DY(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's anchoredPosition3D Z to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DZ(this RectTransform target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's anchorMax to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorMax(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchorMax, x => target.anchorMax = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's anchorMin to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorMin(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchorMin, x => target.anchorMin = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's pivot to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivot(this RectTransform target, Vector2 endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's pivot X to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivotX(this RectTransform target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X).SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a RectTransform's pivot Y to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivotY(this RectTransform target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a RectTransform's sizeDelta to the given value.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOSizeDelta(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.sizeDelta, x => target.sizeDelta = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Punches a RectTransform's anchoredPosition towards the given direction and then back to the starting one
+        /// as if it was connected to the starting position via an elastic.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="punch">The direction and strength of the punch (added to the RectTransform's current position)</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="vibrato">Indicates how much will the punch vibrate</param>
+        /// <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards.
+        /// 1 creates a full oscillation between the punch direction and the opposite direction,
+        /// while 0 oscillates only between the punch and the start position</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOPunchAnchorPos(this RectTransform target, Vector2 punch, float duration, int vibrato = 10, float elasticity = 1, bool snapping = false)
+        {
+            return DOTween.Punch(() => target.anchoredPosition, x => target.anchoredPosition = x, punch, duration, vibrato, elasticity)
+                .SetTarget(target).SetOptions(snapping);
+        }
+
+        /// <summary>Shakes a RectTransform's anchoredPosition with the given values.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="strength">The shake strength</param>
+        /// <param name="vibrato">Indicates how much will the shake vibrate</param>
+        /// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). 
+        /// Setting it to 0 will shake along a single direction.</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        /// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
+        public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, float strength = 100, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true)
+        {
+            return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, true, fadeOut)
+                .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping);
+        }
+        /// <summary>Shakes a RectTransform's anchoredPosition with the given values.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="strength">The shake strength on each axis</param>
+        /// <param name="vibrato">Indicates how much will the shake vibrate</param>
+        /// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware). 
+        /// Setting it to 0 will shake along a single direction.</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        /// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
+        public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, Vector2 strength, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true)
+        {
+            return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, fadeOut)
+                .SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping);
+        }
+
+        #region Special
+
+        /// <summary>Tweens a RectTransform's anchoredPosition to the given value, while also applying a jump effect along the Y axis.
+        /// Returns a Sequence instead of a Tweener.
+        /// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
+        /// <param name="numJumps">Total number of jumps</param>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Sequence DOJumpAnchorPos(this RectTransform target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
+        {
+            if (numJumps < 1) numJumps = 1;
+            float startPosY = 0;
+            float offsetY = -1;
+            bool offsetYSet = false;
+
+            // Separate Y Tween so we can elaborate elapsedPercentage on that insted of on the Sequence
+            // (in case users add a delay or other elements to the Sequence)
+            Sequence s = DOTween.Sequence();
+            Tween yTween = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, jumpPower), duration / (numJumps * 2))
+                .SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
+                .SetLoops(numJumps * 2, LoopType.Yoyo)
+                .OnStart(()=> startPosY = target.anchoredPosition.y);
+            s.Append(DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue.x, 0), duration)
+                    .SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
+                ).Join(yTween)
+                .SetTarget(target).SetEase(DOTween.defaultEaseType);
+            s.OnUpdate(() => {
+                if (!offsetYSet) {
+                    offsetYSet = true;
+                    offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
+                }
+                Vector2 pos = target.anchoredPosition;
+                pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
+                target.anchoredPosition = pos;
+            });
+            return s;
+        }
+
+        #endregion
+
+        #endregion
+
+        #region ScrollRect
+
+        /// <summary>Tweens a ScrollRect's horizontal/verticalNormalizedPosition to the given value.
+        /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DONormalizedPos(this ScrollRect target, Vector2 endValue, float duration, bool snapping = false)
+        {
+            return DOTween.To(() => new Vector2(target.horizontalNormalizedPosition, target.verticalNormalizedPosition),
+                x => {
+                    target.horizontalNormalizedPosition = x.x;
+                    target.verticalNormalizedPosition = x.y;
+                }, endValue, duration)
+                .SetOptions(snapping).SetTarget(target);
+        }
+        /// <summary>Tweens a ScrollRect's horizontalNormalizedPosition to the given value.
+        /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOHorizontalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false)
+        {
+            return DOTween.To(() => target.horizontalNormalizedPosition, x => target.horizontalNormalizedPosition = x, endValue, duration)
+                .SetOptions(snapping).SetTarget(target);
+        }
+        /// <summary>Tweens a ScrollRect's verticalNormalizedPosition to the given value.
+        /// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOVerticalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false)
+        {
+            return DOTween.To(() => target.verticalNormalizedPosition, x => target.verticalNormalizedPosition = x, endValue, duration)
+                .SetOptions(snapping).SetTarget(target);
+        }
+
+        #endregion
+
+        #region Slider
+
+        /// <summary>Tweens a Slider's value to the given value.
+        /// Also stores the Slider as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static TweenerCore<float, float, FloatOptions> DOValue(this Slider target, float endValue, float duration, bool snapping = false)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.value, x => target.value = x, endValue, duration);
+            t.SetOptions(snapping).SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Text
+
+        /// <summary>Tweens a Text's color to the given value.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this Text target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Text's alpha color to the given value.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this Text target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Text's text to the given value.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
+        /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
+        /// otherwise all tags will be considered as normal text</param>
+        /// <param name="scrambleMode">The type of scramble mode to use, if any</param>
+        /// <param name="scrambleChars">A string containing the characters to use for scrambling.
+        /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
+        /// Leave it to NULL (default) to use default ones</param>
+        public static TweenerCore<string, string, StringOptions> DOText(this Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
+        {
+            TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
+            t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Blendables
+
+        #region Graphic
+
+        /// <summary>Tweens a Graphic's color to the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the Graphic as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this Graphic target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                Color diff = x - to;
+                to = x;
+                target.color += diff;
+            }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #region Image
+
+        /// <summary>Tweens a Image's color to the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the Image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this Image target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                Color diff = x - to;
+                to = x;
+                target.color += diff;
+            }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #region Text
+
+        /// <summary>Tweens a Text's color BY the given value,
+        /// in a way that allows other DOBlendableColor tweens to work together on the same target,
+        /// instead than fight each other as multiple DOColor would do.
+        /// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
+        public static Tweener DOBlendableColor(this Text target, Color endValue, float duration)
+        {
+            endValue = endValue - target.color;
+            Color to = new Color(0, 0, 0, 0);
+            return DOTween.To(() => to, x => {
+                Color diff = x - to;
+                to = x;
+                target.color += diff;
+            }, endValue, duration)
+                .Blendable().SetTarget(target);
+        }
+
+        #endregion
+
+        #endregion
+
+        #endregion
+
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+        // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+        public static class Utils
+        {
+            /// <summary>
+            /// Converts the anchoredPosition of the first RectTransform to the second RectTransform,
+            /// taking into consideration offset, anchors and pivot, and returns the new anchoredPosition
+            /// </summary>
+            public static Vector2 SwitchToRectTransform(RectTransform from, RectTransform to)
+            {
+                Vector2 localPoint;
+                Vector2 fromPivotDerivedOffset = new Vector2(from.rect.width * 0.5f + from.rect.xMin, from.rect.height * 0.5f + from.rect.yMin);
+                Vector2 screenP = RectTransformUtility.WorldToScreenPoint(null, from.position);
+                screenP += fromPivotDerivedOffset;
+                RectTransformUtility.ScreenPointToLocalPointInRectangle(to, screenP, null, out localPoint);
+                Vector2 pivotDerivedOffset = new Vector2(to.rect.width * 0.5f + to.rect.xMin, to.rect.height * 0.5f + to.rect.yMin);
+                return to.anchoredPosition + localPoint - pivotDerivedOffset;
+            }
+        }
+	}
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a060394c03331a64392db53a10e7f2d1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs

@@ -0,0 +1,299 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+using System;
+using UnityEngine;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Shortcuts/functions that are not strictly related to specific Modules
+    /// but are available only on some Unity versions
+    /// </summary>
+	public static class DOTweenModuleUnityVersion
+    {
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER
+        #region Unity 4.3 or Newer
+
+        #region Material
+
+        /// <summary>Tweens a Material's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this Material target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+        /// <summary>Tweens a Material's named color property using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param>
+        /// <param name="property">The name of the material property to tween (like _Tint or _SpecColor)</param>
+        /// <param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this Material target, Gradient gradient, string property, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.SetColor(property, c.color);
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, property, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+
+        #endregion
+
+        #endregion
+#endif
+
+#if UNITY_5_3_OR_NEWER || UNITY_2017_1_OR_NEWER
+        #region Unity 5.3 or Newer
+
+        #region CustomYieldInstructions
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or complete.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForCompletion(true);</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForCompletion(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForCompletion(t);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or rewinded.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForRewind();</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForRewind(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForRewind(t);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForKill();</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForKill(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForKill(t);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or has gone through the given amount of loops.
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForElapsedLoops(2);</code>
+        /// </summary>
+        /// <param name="elapsedLoops">Elapsed loops to wait for</param>
+        public static CustomYieldInstruction WaitForElapsedLoops(this Tween t, int elapsedLoops, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForElapsedLoops(t, elapsedLoops);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or has reached the given position (loops included, delays excluded).
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForPosition(2.5f);</code>
+        /// </summary>
+        /// <param name="position">Position (loops included, delays excluded) to wait for</param>
+        public static CustomYieldInstruction WaitForPosition(this Tween t, float position, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForPosition(t, position);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or started
+        /// (meaning when the tween is set in a playing state the first time, after any eventual delay).
+        /// It can be used inside a coroutine as a yield.
+        /// <para>Example usage:</para><code>yield return myTween.WaitForStart();</code>
+        /// </summary>
+        public static CustomYieldInstruction WaitForStart(this Tween t, bool returnCustomYieldInstruction)
+        {
+            if (!t.active) {
+                if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
+                return null;
+            }
+            return new DOTweenCYInstruction.WaitForStart(t);
+        }
+
+        #endregion
+
+        #endregion
+#endif
+
+#if UNITY_2018_1_OR_NEWER
+        #region Unity 2018.1 or Newer
+
+        #region Material
+
+        /// <summary>Tweens a Material's named texture offset property with the given ID to the given value.
+        /// Also stores the material as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+        /// <param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOOffset(this Material target, Vector2 endValue, int propertyID, float duration)
+        {
+            if (!target.HasProperty(propertyID)) {
+                if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID);
+                return null;
+            }
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.GetTextureOffset(propertyID), x => target.SetTextureOffset(propertyID, x), endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a Material's named texture scale property with the given ID to the given value.
+        /// Also stores the material as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param>
+        /// <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
+        /// <param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOTiling(this Material target, Vector2 endValue, int propertyID, float duration)
+        {
+            if (!target.HasProperty(propertyID)) {
+                if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID);
+                return null;
+            }
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.GetTextureScale(propertyID), x => target.SetTextureScale(propertyID, x), endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #endregion
+#endif
+    }
+
+    // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+    // ███ CLASSES █████████████████████████████████████████████████████████████████████████████████████████████████████████
+    // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+#if UNITY_5_3_OR_NEWER || UNITY_2017_1_OR_NEWER
+    public static class DOTweenCYInstruction
+    {
+        public class WaitForCompletion : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && !t.IsComplete();
+            }}
+            readonly Tween t;
+            public WaitForCompletion(Tween tween)
+            {
+                t = tween;
+            }
+        }
+
+        public class WaitForRewind : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && (!t.playedOnce || t.position * (t.CompletedLoops() + 1) > 0);
+            }}
+            readonly Tween t;
+            public WaitForRewind(Tween tween)
+            {
+                t = tween;
+            }
+        }
+
+        public class WaitForKill : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active;
+            }}
+            readonly Tween t;
+            public WaitForKill(Tween tween)
+            {
+                t = tween;
+            }
+        }
+
+        public class WaitForElapsedLoops : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && t.CompletedLoops() < elapsedLoops;
+            }}
+            readonly Tween t;
+            readonly int elapsedLoops;
+            public WaitForElapsedLoops(Tween tween, int elapsedLoops)
+            {
+                t = tween;
+                this.elapsedLoops = elapsedLoops;
+            }
+        }
+
+        public class WaitForPosition : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && t.position * (t.CompletedLoops() + 1) < position;
+            }}
+            readonly Tween t;
+            readonly float position;
+            public WaitForPosition(Tween tween, float position)
+            {
+                t = tween;
+                this.position = position;
+            }
+        }
+
+        public class WaitForStart : CustomYieldInstruction
+        {
+            public override bool keepWaiting { get {
+                return t.active && !t.playedOnce;
+            }}
+            readonly Tween t;
+            public WaitForStart(Tween tween)
+            {
+                t = tween;
+            }
+        }
+    }
+#endif
+}

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 63c02322328255542995bd02b47b0457
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs

@@ -0,0 +1,155 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+using System;
+using System.Reflection;
+using UnityEngine;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Core.PathCore;
+using DG.Tweening.Plugins.Options;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Utility functions that deal with available Modules.
+    /// Modules defines:
+    /// - DOTAUDIO
+    /// - DOTPHYSICS
+    /// - DOTPHYSICS2D
+    /// - DOTSPRITE
+    /// - DOTUI
+    /// Extra defines set and used for implementation of external assets:
+    /// - DOTWEEN_TMP ► TextMesh Pro
+    /// - DOTWEEN_TK2D ► 2D Toolkit
+    /// </summary>
+	public static class DOTweenModuleUtils
+    {
+        static bool _initialized;
+
+        #region Reflection
+
+        /// <summary>
+        /// Called via Reflection by DOTweenComponent on Awake
+        /// </summary>
+#if UNITY_2018_1_OR_NEWER
+        [UnityEngine.Scripting.Preserve]
+#endif
+        public static void Init()
+        {
+            if (_initialized) return;
+
+            _initialized = true;
+            DOTweenExternalCommand.SetOrientationOnPath += Physics.SetOrientationOnPath;
+
+#if UNITY_EDITOR
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1
+            UnityEditor.EditorApplication.playmodeStateChanged += PlaymodeStateChanged;
+#else
+            UnityEditor.EditorApplication.playModeStateChanged += PlaymodeStateChanged;
+#endif
+#endif
+        }
+
+#if UNITY_2018_1_OR_NEWER
+#pragma warning disable
+        [UnityEngine.Scripting.Preserve]
+        // Just used to preserve methods when building, never called
+        static void Preserver()
+        {
+            Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+            MethodInfo mi = typeof(MonoBehaviour).GetMethod("Stub");
+        }
+#pragma warning restore
+#endif
+
+        #endregion
+
+#if UNITY_EDITOR
+        // Fires OnApplicationPause in DOTweenComponent even when Editor is paused (otherwise it's only fired at runtime)
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1
+        static void PlaymodeStateChanged()
+        #else
+        static void PlaymodeStateChanged(UnityEditor.PlayModeStateChange state)
+#endif
+        {
+            if (DOTween.instance == null) return;
+            DOTween.instance.OnApplicationPause(UnityEditor.EditorApplication.isPaused);
+        }
+#endif
+
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+        // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+        public static class Physics
+        {
+            // Called via DOTweenExternalCommand callback
+            public static void SetOrientationOnPath(PathOptions options, Tween t, Quaternion newRot, Transform trans)
+            {
+#if true // PHYSICS_MARKER
+                if (options.isRigidbody) ((Rigidbody)t.target).rotation = newRot;
+                else trans.rotation = newRot;
+#else
+                trans.rotation = newRot;
+#endif
+            }
+
+            // Returns FALSE if the DOTween's Physics2D Module is disabled, or if there's no Rigidbody2D attached
+            public static bool HasRigidbody2D(Component target)
+            {
+#if true // PHYSICS2D_MARKER
+                return target.GetComponent<Rigidbody2D>() != null;
+#else
+                return false;
+#endif
+            }
+
+            #region Called via Reflection
+
+
+            // Called via Reflection by DOTweenPathInspector
+            // Returns FALSE if the DOTween's Physics Module is disabled, or if there's no rigidbody attached
+#if UNITY_2018_1_OR_NEWER
+            [UnityEngine.Scripting.Preserve]
+#endif
+            public static bool HasRigidbody(Component target)
+            {
+#if true // PHYSICS_MARKER
+                return target.GetComponent<Rigidbody>() != null;
+#else
+                return false;
+#endif
+            }
+
+            // Called via Reflection by DOTweenPath
+#if UNITY_2018_1_OR_NEWER
+            [UnityEngine.Scripting.Preserve]
+#endif
+            public static TweenerCore<Vector3, Path, PathOptions> CreateDOTweenPathTween(
+                MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode
+            ){
+                TweenerCore<Vector3, Path, PathOptions> t;
+#if true // PHYSICS_MARKER
+                Rigidbody rBody = tweenRigidbody ? target.GetComponent<Rigidbody>() : null;
+                if (tweenRigidbody && rBody != null) {
+                    t = isLocal
+                        ? rBody.DOLocalPath(path, duration, pathMode)
+                        : rBody.DOPath(path, duration, pathMode);
+                } else {
+                    t = isLocal
+                        ? target.transform.DOLocalPath(path, duration, pathMode)
+                        : target.transform.DOPath(path, duration, pathMode);
+                }
+#else
+                t = isLocal
+                    ? target.transform.DOLocalPath(path, duration, pathMode)
+                    : target.transform.DOPath(path, duration, pathMode);
+#endif
+                return t;
+            }
+
+            #endregion
+        }
+    }
+}

GQ_Communicate/Assets/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7bcaf917d9cf5b84090421a5a2abe42e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTween/readme.txt

@@ -0,0 +1,29 @@
+DOTween and DOTween Pro are copyright (c) 2014-2018 Daniele Giardini - Demigiant
+
+// IMPORTANT!!! /////////////////////////////////////////////
+// Upgrading DOTween from versions older than 1.2.000 ///////
+// (or DOTween Pro older than 1.0.000) //////////////////////
+-------------------------------------------------------------
+If you're upgrading your project from a version of DOTween older than 1.2.000 (or DOTween Pro older than 1.0.000) please follow these instructions carefully.
+1) Import the new version in the same folder as the previous one, overwriting old files. A lot of errors will appear but don't worry
+2) Close and reopen Unity (and your project). This is fundamental: skipping this step will cause a bloodbath
+3) Open DOTween's Utility Panel (Tools > Demigiant > DOTween Utility Panel) if it doesn't open automatically, then press "Setup DOTween...": this will run the upgrade setup
+4) From the Add/Remove Modules panel that opens, activate/deactivate Modules for Unity systems and for external assets (Pro version only)
+
+// GET STARTED //////////////////////////////////////////////
+
+- After importing a new DOTween update, select DOTween's Utility Panel from the "Tools/Demigiant" menu (if it doesn't open automatically) and press the "Setup DOTween..." button to activate/deactivate Modules. You can also access a Preferences Tab from there to choose default settings for DOTween.
+- In your code, add "using DG.Tweening" to each class where you want to use DOTween.
+- You're ready to tween. Check out the links below for full documentation and license info.
+
+
+// LINKS ///////////////////////////////////////////////////////
+
+DOTween website (documentation, examples, etc): http://dotween.demigiant.com
+DOTween license: http://dotween.demigiant.com/license.php
+DOTween repository (Google Code): https://code.google.com/p/dotween/
+Demigiant website (documentation, examples, etc): http://www.demigiant.com
+
+// NOTES //////////////////////////////////////////////////////
+
+- DOTween's Utility Panel can be found under "Tools > Demigiant > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences

GQ_Communicate/Assets/Demigiant/DOTween/readme.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: fccfc62abf2eb0a4db614853430894fd
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 223ebd9c80507d8428f0dc9736723ef8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenAnimation_Advanced.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a5f7a56d339da84449899ecf95fbe33d
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenAnimation_AdvancedSettings.lighting

@@ -0,0 +1,64 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!850595691 &4890085278179872738
+LightingSettings:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: DOTweenAnimation_AdvancedSettings
+  serializedVersion: 4
+  m_GIWorkflowMode: 1
+  m_EnableBakedLightmaps: 1
+  m_EnableRealtimeLightmaps: 0
+  m_RealtimeEnvironmentLighting: 1
+  m_BounceScale: 1
+  m_AlbedoBoost: 1
+  m_IndirectOutputScale: 1
+  m_UsingShadowmask: 0
+  m_BakeBackend: 0
+  m_LightmapMaxSize: 1024
+  m_BakeResolution: 50
+  m_Padding: 2
+  m_LightmapCompression: 0
+  m_AO: 1
+  m_AOMaxDistance: 1
+  m_CompAOExponent: 1
+  m_CompAOExponentDirect: 0
+  m_ExtractAO: 0
+  m_MixedBakeMode: 1
+  m_LightmapsBakeMode: 1
+  m_FilterMode: 1
+  m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
+  m_ExportTrainingData: 0
+  m_TrainingDataDestination: TrainingData
+  m_RealtimeResolution: 1
+  m_ForceWhiteAlbedo: 0
+  m_ForceUpdates: 0
+  m_FinalGather: 0
+  m_FinalGatherRayCount: 256
+  m_FinalGatherFiltering: 1
+  m_PVRCulling: 1
+  m_PVRSampling: 1
+  m_PVRDirectSampleCount: 32
+  m_PVRSampleCount: 512
+  m_PVREnvironmentSampleCount: 512
+  m_PVREnvironmentReferencePointCount: 2048
+  m_LightProbeSampleCountMultiplier: 4
+  m_PVRBounces: 2
+  m_PVRMinBounces: 2
+  m_PVREnvironmentMIS: 0
+  m_PVRFilteringMode: 0
+  m_PVRDenoiserTypeDirect: 0
+  m_PVRDenoiserTypeIndirect: 0
+  m_PVRDenoiserTypeAO: 0
+  m_PVRFilterTypeDirect: 0
+  m_PVRFilterTypeIndirect: 0
+  m_PVRFilterTypeAO: 0
+  m_PVRFilteringGaussRadiusDirect: 1
+  m_PVRFilteringGaussRadiusIndirect: 5
+  m_PVRFilteringGaussRadiusAO: 2
+  m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+  m_PVRFilteringAtrousPositionSigmaIndirect: 2
+  m_PVRFilteringAtrousPositionSigmaAO: 1
+  m_PVRTiledBaking: 0

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenAnimation_AdvancedSettings.lighting.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 531c0f957fbf8d848a26e8daf0642553
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 4890085278179872738
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenAnimation_Basics.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6a2ad353325ffe64983c28d69a8738f5
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenAnimation_BasicsSettings.lighting

@@ -0,0 +1,64 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!850595691 &4890085278179872738
+LightingSettings:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: DOTweenAnimation_BasicsSettings
+  serializedVersion: 4
+  m_GIWorkflowMode: 1
+  m_EnableBakedLightmaps: 1
+  m_EnableRealtimeLightmaps: 0
+  m_RealtimeEnvironmentLighting: 1
+  m_BounceScale: 1
+  m_AlbedoBoost: 1
+  m_IndirectOutputScale: 1
+  m_UsingShadowmask: 0
+  m_BakeBackend: 0
+  m_LightmapMaxSize: 1024
+  m_BakeResolution: 50
+  m_Padding: 2
+  m_LightmapCompression: 0
+  m_AO: 1
+  m_AOMaxDistance: 1
+  m_CompAOExponent: 1
+  m_CompAOExponentDirect: 0
+  m_ExtractAO: 0
+  m_MixedBakeMode: 1
+  m_LightmapsBakeMode: 1
+  m_FilterMode: 1
+  m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
+  m_ExportTrainingData: 0
+  m_TrainingDataDestination: TrainingData
+  m_RealtimeResolution: 1
+  m_ForceWhiteAlbedo: 0
+  m_ForceUpdates: 0
+  m_FinalGather: 0
+  m_FinalGatherRayCount: 256
+  m_FinalGatherFiltering: 1
+  m_PVRCulling: 1
+  m_PVRSampling: 1
+  m_PVRDirectSampleCount: 32
+  m_PVRSampleCount: 512
+  m_PVREnvironmentSampleCount: 512
+  m_PVREnvironmentReferencePointCount: 2048
+  m_LightProbeSampleCountMultiplier: 4
+  m_PVRBounces: 2
+  m_PVRMinBounces: 2
+  m_PVREnvironmentMIS: 0
+  m_PVRFilteringMode: 0
+  m_PVRDenoiserTypeDirect: 0
+  m_PVRDenoiserTypeIndirect: 0
+  m_PVRDenoiserTypeAO: 0
+  m_PVRFilterTypeDirect: 0
+  m_PVRFilterTypeIndirect: 0
+  m_PVRFilterTypeAO: 0
+  m_PVRFilteringGaussRadiusDirect: 1
+  m_PVRFilteringGaussRadiusIndirect: 5
+  m_PVRFilteringGaussRadiusAO: 2
+  m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+  m_PVRFilteringAtrousPositionSigmaIndirect: 2
+  m_PVRFilteringAtrousPositionSigmaAO: 1
+  m_PVRTiledBaking: 0

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenAnimation_BasicsSettings.lighting.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f29687c4487c4d2418f56b5864f3f40f
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 4890085278179872738
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenPath.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a351b59ca54a0bc4083c35844da13a61
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenPathSettings.lighting

@@ -0,0 +1,64 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!850595691 &4890085278179872738
+LightingSettings:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: DOTweenPathSettings
+  serializedVersion: 4
+  m_GIWorkflowMode: 1
+  m_EnableBakedLightmaps: 1
+  m_EnableRealtimeLightmaps: 0
+  m_RealtimeEnvironmentLighting: 1
+  m_BounceScale: 1
+  m_AlbedoBoost: 1
+  m_IndirectOutputScale: 1
+  m_UsingShadowmask: 0
+  m_BakeBackend: 0
+  m_LightmapMaxSize: 1024
+  m_BakeResolution: 50
+  m_Padding: 2
+  m_LightmapCompression: 0
+  m_AO: 1
+  m_AOMaxDistance: 1
+  m_CompAOExponent: 1
+  m_CompAOExponentDirect: 0
+  m_ExtractAO: 0
+  m_MixedBakeMode: 1
+  m_LightmapsBakeMode: 1
+  m_FilterMode: 1
+  m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
+  m_ExportTrainingData: 0
+  m_TrainingDataDestination: TrainingData
+  m_RealtimeResolution: 1
+  m_ForceWhiteAlbedo: 0
+  m_ForceUpdates: 0
+  m_FinalGather: 0
+  m_FinalGatherRayCount: 256
+  m_FinalGatherFiltering: 1
+  m_PVRCulling: 1
+  m_PVRSampling: 1
+  m_PVRDirectSampleCount: 32
+  m_PVRSampleCount: 512
+  m_PVREnvironmentSampleCount: 512
+  m_PVREnvironmentReferencePointCount: 2048
+  m_LightProbeSampleCountMultiplier: 4
+  m_PVRBounces: 2
+  m_PVRMinBounces: 2
+  m_PVREnvironmentMIS: 0
+  m_PVRFilteringMode: 0
+  m_PVRDenoiserTypeDirect: 0
+  m_PVRDenoiserTypeIndirect: 0
+  m_PVRDenoiserTypeAO: 0
+  m_PVRFilterTypeDirect: 0
+  m_PVRFilterTypeIndirect: 0
+  m_PVRFilterTypeAO: 0
+  m_PVRFilteringGaussRadiusDirect: 1
+  m_PVRFilteringGaussRadiusIndirect: 5
+  m_PVRFilteringGaussRadiusAO: 2
+  m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+  m_PVRFilteringAtrousPositionSigmaIndirect: 2
+  m_PVRFilteringAtrousPositionSigmaAO: 1
+  m_PVRTiledBaking: 0

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/DOTweenPathSettings.lighting.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8d575ccae28c77943b6ce492cb1e4dba
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 4890085278179872738
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/Examples Assets.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 180fb14fbafc641489aaf232087b9d10
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro Examples/Examples Assets/dotweenpro_logo.png.meta

@@ -0,0 +1,98 @@
+fileFormatVersion: 2
+guid: 44a054df1702e39458b7072b08d0f212
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMasterTextureLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 512
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 16
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 1
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 512
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: dae5de7f766cd0740a260be6e60218da
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenAnimation.cs

@@ -0,0 +1,716 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2015/03/12 15:55
+
+using System;
+using System.Collections.Generic;
+using DG.Tweening.Core;
+using UnityEngine;
+#if true // UI_MARKER
+using UnityEngine.UI;
+#endif
+#if false // TEXTMESHPRO_MARKER
+using TMPro;
+#endif
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Attach this to a GameObject to create a tween
+    /// </summary>
+    [AddComponentMenu("DOTween/DOTween Animation")]
+    public class DOTweenAnimation : ABSAnimationComponent
+    {
+        public enum AnimationType
+        {
+            None,
+            Move, LocalMove,
+            Rotate, LocalRotate,
+            Scale,
+            Color, Fade,
+            Text,
+            PunchPosition, PunchRotation, PunchScale,
+            ShakePosition, ShakeRotation, ShakeScale,
+            CameraAspect, CameraBackgroundColor, CameraFieldOfView, CameraOrthoSize, CameraPixelRect, CameraRect,
+            UIWidthHeight
+        }
+
+        public enum TargetType
+        {
+            Unset,
+
+            Camera,
+            CanvasGroup,
+            Image,
+            Light,
+            RectTransform,
+            Renderer, SpriteRenderer,
+            Rigidbody, Rigidbody2D,
+            Text,
+            Transform,
+
+            tk2dBaseSprite,
+            tk2dTextMesh,
+
+            TextMeshPro,
+            TextMeshProUGUI
+        }
+
+        #region EVENTS - EDITOR-ONLY
+
+        /// <summary>Used internally by the editor</summary>
+        public static event Action<DOTweenAnimation> OnReset;
+        static void Dispatch_OnReset(DOTweenAnimation anim) { if (OnReset != null) OnReset(anim); }
+
+        #endregion
+
+        public bool targetIsSelf = true; // If FALSE allows to set the target manually
+        public GameObject targetGO = null; // Used in case targetIsSelf is FALSE
+        // If TRUE always uses the GO containing this DOTweenAnimation (and not the one containing the target) as DOTween's SetTarget target
+        public bool tweenTargetIsTargetGO = true;
+
+        public float delay;
+        public float duration = 1;
+        public Ease easeType = Ease.OutQuad;
+        public AnimationCurve easeCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1));
+        public LoopType loopType = LoopType.Restart;
+        public int loops = 1;
+        public string id = "";
+        public bool isRelative;
+        public bool isFrom;
+        public bool isIndependentUpdate = false;
+        public bool autoKill = true;
+
+        public bool isActive = true;
+        public bool isValid;
+        public Component target;
+        public AnimationType animationType;
+        public TargetType targetType;
+        public TargetType forcedTargetType; // Used when choosing between multiple targets
+        public bool autoPlay = true;
+        public bool useTargetAsV3;
+
+        public float endValueFloat;
+        public Vector3 endValueV3;
+        public Vector2 endValueV2;
+        public Color endValueColor = new Color(1, 1, 1, 1);
+        public string endValueString = "";
+        public Rect endValueRect = new Rect(0, 0, 0, 0);
+        public Transform endValueTransform;
+
+        public bool optionalBool0;
+        public float optionalFloat0;
+        public int optionalInt0;
+        public RotateMode optionalRotationMode = RotateMode.Fast;
+        public ScrambleMode optionalScrambleMode = ScrambleMode.None;
+        public string optionalString;
+
+        bool _tweenCreated; // TRUE after the tweens have been created
+        int _playCount = -1; // Used when calling DOPlayNext
+
+        #region Unity Methods
+
+        void Awake()
+        {
+            if (!isActive || !isValid) return;
+
+            if (animationType != AnimationType.Move || !useTargetAsV3) {
+                // Don't create tweens if we're using a RectTransform as a Move target,
+                // because that will work only inside Start
+                CreateTween();
+                _tweenCreated = true;
+            }
+        }
+
+        void Start()
+        {
+            if (_tweenCreated || !isActive || !isValid) return;
+
+            CreateTween();
+            _tweenCreated = true;
+        }
+
+        void Reset()
+        {
+            Dispatch_OnReset(this);
+        }
+
+        void OnDestroy()
+        {
+            if (tween != null && tween.IsActive()) tween.Kill();
+            tween = null;
+        }
+
+        // Used also by DOTweenAnimationInspector when applying runtime changes and restarting
+        public void CreateTween()
+        {
+//            if (target == null) {
+//                Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target is NULL, because the animation was created with a DOTween Pro version older than 0.9.255. To fix this, exit Play mode then simply select this object, and it will update automatically", this.gameObject.name), this.gameObject);
+//                return;
+//            }
+
+            GameObject tweenGO = GetTweenGO();
+            if (target == null || tweenGO == null) {
+                if (targetIsSelf && target == null) {
+                    // Old error caused during upgrade from DOTween Pro 0.9.255
+                    Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target is NULL, because the animation was created with a DOTween Pro version older than 0.9.255. To fix this, exit Play mode then simply select this object, and it will update automatically", this.gameObject.name), this.gameObject);
+                } else {
+                    // Missing non-self target
+                    Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target/GameObject is unset: the tween will not be created.", this.gameObject.name), this.gameObject);
+                }
+                return;
+            }
+
+            if (forcedTargetType != TargetType.Unset) targetType = forcedTargetType;
+            if (targetType == TargetType.Unset) {
+                // Legacy DOTweenAnimation (made with a version older than 0.9.450) without stored targetType > assign it now
+                targetType = TypeToDOTargetType(target.GetType());
+            }
+
+            switch (animationType) {
+            case AnimationType.None:
+                break;
+            case AnimationType.Move:
+                if (useTargetAsV3) {
+                    isRelative = false;
+                    if (endValueTransform == null) {
+                        Debug.LogWarning(string.Format("{0} :: This tween's TO target is NULL, a Vector3 of (0,0,0) will be used instead", this.gameObject.name), this.gameObject);
+                        endValueV3 = Vector3.zero;
+                    } else {
+#if true // UI_MARKER
+                        if (targetType == TargetType.RectTransform) {
+                            RectTransform endValueT = endValueTransform as RectTransform;
+                            if (endValueT == null) {
+                                Debug.LogWarning(string.Format("{0} :: This tween's TO target should be a RectTransform, a Vector3 of (0,0,0) will be used instead", this.gameObject.name), this.gameObject);
+                                endValueV3 = Vector3.zero;
+                            } else {
+                                RectTransform rTarget = target as RectTransform;
+                                if (rTarget == null) {
+                                    Debug.LogWarning(string.Format("{0} :: This tween's target and TO target are not of the same type. Please reassign the values", this.gameObject.name), this.gameObject);
+                                } else {
+                                    // Problem: doesn't work inside Awake (ararargh!)
+                                    endValueV3 = DOTweenModuleUI.Utils.SwitchToRectTransform(endValueT, rTarget);
+                                }
+                            }
+                        } else
+#endif
+                            endValueV3 = endValueTransform.position;
+                    }
+                }
+                switch (targetType) {
+                case TargetType.Transform:
+                    tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
+                    break;
+                case TargetType.RectTransform:
+#if true // UI_MARKER
+                    tween = ((RectTransform)target).DOAnchorPos3D(endValueV3, duration, optionalBool0);
+#else
+                    tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
+#endif
+                    break;
+                case TargetType.Rigidbody:
+#if true // PHYSICS_MARKER
+                    tween = ((Rigidbody)target).DOMove(endValueV3, duration, optionalBool0);
+#else
+                    tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
+#endif
+                    break;
+                case TargetType.Rigidbody2D:
+#if true // PHYSICS2D_MARKER
+                    tween = ((Rigidbody2D)target).DOMove(endValueV3, duration, optionalBool0);
+#else
+                    tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
+#endif
+                    break;
+                }
+                break;
+            case AnimationType.LocalMove:
+                tween = tweenGO.transform.DOLocalMove(endValueV3, duration, optionalBool0);
+                break;
+            case AnimationType.Rotate:
+                switch (targetType) {
+                case TargetType.Transform:
+                    tween = ((Transform)target).DORotate(endValueV3, duration, optionalRotationMode);
+                    break;
+                case TargetType.Rigidbody:
+#if true // PHYSICS_MARKER
+                    tween = ((Rigidbody)target).DORotate(endValueV3, duration, optionalRotationMode);
+#else
+                    tween = ((Transform)target).DORotate(endValueV3, duration, optionalRotationMode);
+#endif
+                    break;
+                case TargetType.Rigidbody2D:
+#if true // PHYSICS2D_MARKER
+                    tween = ((Rigidbody2D)target).DORotate(endValueFloat, duration);
+#else
+                    tween = ((Transform)target).DORotate(endValueV3, duration, optionalRotationMode);
+#endif
+                    break;
+                }
+                break;
+            case AnimationType.LocalRotate:
+                tween = tweenGO.transform.DOLocalRotate(endValueV3, duration, optionalRotationMode);
+                break;
+            case AnimationType.Scale:
+                switch (targetType) {
+#if false // TK2D_MARKER
+                case TargetType.tk2dTextMesh:
+                    tween = ((tk2dTextMesh)target).DOScale(optionalBool0 ? new Vector3(endValueFloat, endValueFloat, endValueFloat) : endValueV3, duration);
+                    break;
+                case TargetType.tk2dBaseSprite:
+                    tween = ((tk2dBaseSprite)target).DOScale(optionalBool0 ? new Vector3(endValueFloat, endValueFloat, endValueFloat) : endValueV3, duration);
+                    break;
+#endif
+                default:
+                    tween = tweenGO.transform.DOScale(optionalBool0 ? new Vector3(endValueFloat, endValueFloat, endValueFloat) : endValueV3, duration);
+                    break;
+                }
+                break;
+#if true // UI_MARKER
+            case AnimationType.UIWidthHeight:
+                tween = ((RectTransform)target).DOSizeDelta(optionalBool0 ? new Vector2(endValueFloat, endValueFloat) : endValueV2, duration);
+                break;
+#endif
+            case AnimationType.Color:
+                isRelative = false;
+                switch (targetType) {
+                case TargetType.Renderer:
+                    tween = ((Renderer)target).material.DOColor(endValueColor, duration);
+                    break;
+                case TargetType.Light:
+                    tween = ((Light)target).DOColor(endValueColor, duration);
+                    break;
+#if true // SPRITE_MARKER
+                case TargetType.SpriteRenderer:
+                    tween = ((SpriteRenderer)target).DOColor(endValueColor, duration);
+                    break;
+#endif
+#if true // UI_MARKER
+                case TargetType.Image:
+                    tween = ((Graphic)target).DOColor(endValueColor, duration);
+                    break;
+                case TargetType.Text:
+                    tween = ((Text)target).DOColor(endValueColor, duration);
+                    break;
+#endif
+#if false // TK2D_MARKER
+                case TargetType.tk2dTextMesh:
+                    tween = ((tk2dTextMesh)target).DOColor(endValueColor, duration);
+                    break;
+                case TargetType.tk2dBaseSprite:
+                    tween = ((tk2dBaseSprite)target).DOColor(endValueColor, duration);
+                    break;
+#endif
+#if false // TEXTMESHPRO_MARKER
+                case TargetType.TextMeshProUGUI:
+                    tween = ((TextMeshProUGUI)target).DOColor(endValueColor, duration);
+                    break;
+                case TargetType.TextMeshPro:
+                    tween = ((TextMeshPro)target).DOColor(endValueColor, duration);
+                    break;
+#endif
+                }
+                break;
+            case AnimationType.Fade:
+                isRelative = false;
+                switch (targetType) {
+                case TargetType.Renderer:
+                    tween = ((Renderer)target).material.DOFade(endValueFloat, duration);
+                    break;
+                case TargetType.Light:
+                    tween = ((Light)target).DOIntensity(endValueFloat, duration);
+                    break;
+#if true // SPRITE_MARKER
+                case TargetType.SpriteRenderer:
+                    tween = ((SpriteRenderer)target).DOFade(endValueFloat, duration);
+                    break;
+#endif
+#if true // UI_MARKER
+                case TargetType.Image:
+                    tween = ((Graphic)target).DOFade(endValueFloat, duration);
+                    break;
+                case TargetType.Text:
+                    tween = ((Text)target).DOFade(endValueFloat, duration);
+                    break;
+                case TargetType.CanvasGroup:
+                    tween = ((CanvasGroup)target).DOFade(endValueFloat, duration);
+                    break;
+#endif
+#if false // TK2D_MARKER
+                case TargetType.tk2dTextMesh:
+                    tween = ((tk2dTextMesh)target).DOFade(endValueFloat, duration);
+                    break;
+                case TargetType.tk2dBaseSprite:
+                    tween = ((tk2dBaseSprite)target).DOFade(endValueFloat, duration);
+                    break;
+#endif
+#if false // TEXTMESHPRO_MARKER
+                case TargetType.TextMeshProUGUI:
+                    tween = ((TextMeshProUGUI)target).DOFade(endValueFloat, duration);
+                    break;
+                case TargetType.TextMeshPro:
+                    tween = ((TextMeshPro)target).DOFade(endValueFloat, duration);
+                    break;
+#endif
+                }
+                break;
+            case AnimationType.Text:
+#if true // UI_MARKER
+                switch (targetType) {
+                case TargetType.Text:
+                    tween = ((Text)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
+                    break;
+                }
+#endif
+#if false // TK2D_MARKER
+                switch (targetType) {
+                case TargetType.tk2dTextMesh:
+                    tween = ((tk2dTextMesh)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
+                    break;
+                }
+#endif
+#if false // TEXTMESHPRO_MARKER
+                switch (targetType) {
+                case TargetType.TextMeshProUGUI:
+                    tween = ((TextMeshProUGUI)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
+                    break;
+                case TargetType.TextMeshPro:
+                    tween = ((TextMeshPro)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
+                    break;
+                }
+#endif
+                break;
+            case AnimationType.PunchPosition:
+                switch (targetType) {
+                case TargetType.Transform:
+                    tween = ((Transform)target).DOPunchPosition(endValueV3, duration, optionalInt0, optionalFloat0, optionalBool0);
+                    break;
+#if true // UI_MARKER
+                case TargetType.RectTransform:
+                    tween = ((RectTransform)target).DOPunchAnchorPos(endValueV3, duration, optionalInt0, optionalFloat0, optionalBool0);
+                    break;
+#endif
+                }
+                break;
+            case AnimationType.PunchScale:
+                tween = tweenGO.transform.DOPunchScale(endValueV3, duration, optionalInt0, optionalFloat0);
+                break;
+            case AnimationType.PunchRotation:
+                tween = tweenGO.transform.DOPunchRotation(endValueV3, duration, optionalInt0, optionalFloat0);
+                break;
+            case AnimationType.ShakePosition:
+                switch (targetType) {
+                case TargetType.Transform:
+                    tween = ((Transform)target).DOShakePosition(duration, endValueV3, optionalInt0, optionalFloat0, optionalBool0);
+                    break;
+#if true // UI_MARKER
+                case TargetType.RectTransform:
+                    tween = ((RectTransform)target).DOShakeAnchorPos(duration, endValueV3, optionalInt0, optionalFloat0, optionalBool0);
+                    break;
+#endif
+                }
+                break;
+            case AnimationType.ShakeScale:
+                tween = tweenGO.transform.DOShakeScale(duration, endValueV3, optionalInt0, optionalFloat0);
+                break;
+            case AnimationType.ShakeRotation:
+                tween = tweenGO.transform.DOShakeRotation(duration, endValueV3, optionalInt0, optionalFloat0);
+                break;
+            case AnimationType.CameraAspect:
+                tween = ((Camera)target).DOAspect(endValueFloat, duration);
+                break;
+            case AnimationType.CameraBackgroundColor:
+                tween = ((Camera)target).DOColor(endValueColor, duration);
+                break;
+            case AnimationType.CameraFieldOfView:
+                tween = ((Camera)target).DOFieldOfView(endValueFloat, duration);
+                break;
+            case AnimationType.CameraOrthoSize:
+                tween = ((Camera)target).DOOrthoSize(endValueFloat, duration);
+                break;
+            case AnimationType.CameraPixelRect:
+                tween = ((Camera)target).DOPixelRect(endValueRect, duration);
+                break;
+            case AnimationType.CameraRect:
+                tween = ((Camera)target).DORect(endValueRect, duration);
+                break;
+            }
+
+            if (tween == null) return;
+
+            if (isFrom) {
+                ((Tweener)tween).From(isRelative);
+            } else {
+                tween.SetRelative(isRelative);
+            }
+            GameObject setTarget = targetIsSelf || !tweenTargetIsTargetGO ? this.gameObject : targetGO;
+            tween.SetTarget(setTarget).SetDelay(delay).SetLoops(loops, loopType).SetAutoKill(autoKill)
+                .OnKill(()=> tween = null);
+            if (isSpeedBased) tween.SetSpeedBased();
+            if (easeType == Ease.INTERNAL_Custom) tween.SetEase(easeCurve);
+            else tween.SetEase(easeType);
+            if (!string.IsNullOrEmpty(id)) tween.SetId(id);
+            tween.SetUpdate(isIndependentUpdate);
+
+            if (hasOnStart) {
+                if (onStart != null) tween.OnStart(onStart.Invoke);
+            } else onStart = null;
+            if (hasOnPlay) {
+                if (onPlay != null) tween.OnPlay(onPlay.Invoke);
+            } else onPlay = null;
+            if (hasOnUpdate) {
+                if (onUpdate != null) tween.OnUpdate(onUpdate.Invoke);
+            } else onUpdate = null;
+            if (hasOnStepComplete) {
+                if (onStepComplete != null) tween.OnStepComplete(onStepComplete.Invoke);
+            } else onStepComplete = null;
+            if (hasOnComplete) {
+                if (onComplete != null) tween.OnComplete(onComplete.Invoke);
+            } else onComplete = null;
+            if (hasOnRewind) {
+                if (onRewind != null) tween.OnRewind(onRewind.Invoke);
+            } else onRewind = null;
+
+            if (autoPlay) tween.Play();
+            else tween.Pause();
+
+            if (hasOnTweenCreated && onTweenCreated != null) onTweenCreated.Invoke();
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        // These methods are here so they can be called directly via Unity's UGUI event system
+
+        public override void DOPlay()
+        {
+            DOTween.Play(this.gameObject);
+        }
+
+        public override void DOPlayBackwards()
+        {
+            DOTween.PlayBackwards(this.gameObject);
+        }
+
+        public override void DOPlayForward()
+        {
+            DOTween.PlayForward(this.gameObject);
+        }
+
+        public override void DOPause()
+        {
+            DOTween.Pause(this.gameObject);
+        }
+
+        public override void DOTogglePause()
+        {
+            DOTween.TogglePause(this.gameObject);
+        }
+
+        public override void DORewind()
+        {
+        	_playCount = -1;
+            // Rewind using Components order (in case there are multiple animations on the same property)
+            DOTweenAnimation[] anims = this.gameObject.GetComponents<DOTweenAnimation>();
+            for (int i = anims.Length - 1; i > -1; --i) {
+                Tween t = anims[i].tween;
+                if (t != null && t.IsInitialized()) anims[i].tween.Rewind();
+            }
+            // DOTween.Rewind(this.gameObject);
+        }
+
+        /// <summary>
+        /// Restarts the tween
+        /// </summary>
+        public override void DORestart()
+        { DORestart(false); }
+        /// <summary>
+        /// Restarts the tween
+        /// </summary>
+        /// <param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position.
+        /// Set it to TRUE when spawning the same DOTweenAnimation in different positions (like when using a pooling system)</param>
+        public override void DORestart(bool fromHere)
+        {
+        	_playCount = -1;
+            if (tween == null) {
+                if (Debugger.logPriority > 1) Debugger.LogNullTween(tween); return;
+            }
+            if (fromHere && isRelative) ReEvaluateRelativeTween();
+            DOTween.Restart(this.gameObject);
+        }
+
+        public override void DOComplete()
+        {
+            DOTween.Complete(this.gameObject);
+        }
+
+        public override void DOKill()
+        {
+            DOTween.Kill(this.gameObject);
+            tween = null;
+        }
+
+        #region Specifics
+
+        public void DOPlayById(string id)
+        {
+            DOTween.Play(this.gameObject, id);
+        }
+        public void DOPlayAllById(string id)
+        {
+            DOTween.Play(id);
+        }
+
+        public void DOPauseAllById(string id)
+        {
+            DOTween.Pause(id);
+        }
+
+        public void DOPlayBackwardsById(string id)
+        {
+            DOTween.PlayBackwards(this.gameObject, id);
+        }
+        public void DOPlayBackwardsAllById(string id)
+        {
+            DOTween.PlayBackwards(id);
+        }
+
+        public void DOPlayForwardById(string id)
+        {
+            DOTween.PlayForward(this.gameObject, id);
+        }
+        public void DOPlayForwardAllById(string id)
+        {
+            DOTween.PlayForward(id);
+        }
+
+        public void DOPlayNext()
+        {
+            DOTweenAnimation[] anims = this.GetComponents<DOTweenAnimation>();
+            while (_playCount < anims.Length - 1) {
+                _playCount++;
+                DOTweenAnimation anim = anims[_playCount];
+                if (anim != null && anim.tween != null && !anim.tween.IsPlaying() && !anim.tween.IsComplete()) {
+                    anim.tween.Play();
+                    break;
+                }
+            }
+        }
+
+        public void DORewindAndPlayNext()
+        {
+            _playCount = -1;
+            DOTween.Rewind(this.gameObject);
+            DOPlayNext();
+        }
+
+        public void DORewindAllById(string id)
+        {
+            _playCount = -1;
+            DOTween.Rewind(id);
+        }
+
+        public void DORestartById(string id)
+        {
+            _playCount = -1;
+            DOTween.Restart(this.gameObject, id);
+        }
+        public void DORestartAllById(string id)
+        {
+            _playCount = -1;
+            DOTween.Restart(id);
+        }
+
+        /// <summary>
+        /// Returns the tweens created by this DOTweenAnimation, in the same order as they appear in the Inspector (top to bottom)
+        /// </summary>
+        public List<Tween> GetTweens()
+        {
+//            return DOTween.TweensByTarget(this.gameObject);
+
+            List<Tween> result = new List<Tween>();
+            DOTweenAnimation[] anims = this.GetComponents<DOTweenAnimation>();
+            foreach (DOTweenAnimation anim in anims) result.Add(anim.tween);
+            return result;
+        }
+
+        #endregion
+
+        #region Internal (also used by Inspector)
+
+        public static TargetType TypeToDOTargetType(Type t)
+        {
+            string str = t.ToString();
+            int dotIndex = str.LastIndexOf(".");
+            if (dotIndex != -1) str = str.Substring(dotIndex + 1);
+            if (str.IndexOf("Renderer") != -1 && (str != "SpriteRenderer")) str = "Renderer";
+//#if true // PHYSICS_MARKER
+//            if (str == "Rigidbody") str = "Transform";
+//#endif
+//#if true // PHYSICS2D_MARKER
+//            if (str == "Rigidbody2D") str = "Transform";
+//#endif
+#if true // UI_MARKER
+//            if (str == "RectTransform") str = "Transform";
+            if (str == "RawImage") str = "Image"; // RawImages are managed like Images for DOTweenAnimation (color and fade use Graphic target anyway)
+#endif
+            return (TargetType)Enum.Parse(typeof(TargetType), str);
+        }
+
+        // Editor preview system
+        /// <summary>
+        /// Previews the tween in the editor. Only for DOTween internal usage: don't use otherwise.
+        /// </summary>
+        public Tween CreateEditorPreview()
+        {
+            if (Application.isPlaying) return null;
+
+            CreateTween();
+            return tween;
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Private
+
+        // Returns the gameObject whose target component should be animated
+        GameObject GetTweenGO()
+        {
+            return targetIsSelf ? this.gameObject : targetGO;
+        }
+
+        // Re-evaluate relative position of path
+        void ReEvaluateRelativeTween()
+        {
+            GameObject tweenGO = GetTweenGO();
+            if (tweenGO == null) {
+                Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target/GameObject is unset: the tween will not be created.", this.gameObject.name), this.gameObject);
+                return;
+            }
+            if (animationType == AnimationType.Move) {
+                ((Tweener)tween).ChangeEndValue(tweenGO.transform.position + endValueV3, true);
+            } else if (animationType == AnimationType.LocalMove) {
+                ((Tweener)tween).ChangeEndValue(tweenGO.transform.localPosition + endValueV3, true);
+            }
+        }
+
+        #endregion
+    }
+
+    public static class DOTweenAnimationExtensions
+    {
+//        // Doesn't work on Win 8.1
+//        public static bool IsSameOrSubclassOf(this Type t, Type tBase)
+//        {
+//            return t.IsSubclassOf(tBase) || t == tBase;
+//        }
+
+        public static bool IsSameOrSubclassOf<T>(this Component t)
+        {
+            return t is T;
+        }
+    }
+}

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenAnimation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4d0390bd8b8ffd640b34fe25065ff1df
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenPro.XML

@@ -0,0 +1,62 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>DOTweenPro</name>
+    </assembly>
+    <members>
+        <member name="M:DG.Tweening.Core.ABSAnimationComponent.DORestart">
+            <summary>
+            Restarts the tween
+            </summary>
+        </member>
+        <member name="M:DG.Tweening.Core.ABSAnimationComponent.DORestart(System.Boolean)">
+            <summary>
+            Restarts the tween
+            </summary>
+            <param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position.
+            Set it to TRUE when spawning the same DOTweenPath in different positions (like when using a pooling system)</param>
+        </member>
+        <member name="T:DG.Tweening.DOTweenPath">
+            <summary>
+            Attach this to a GameObject to create and assign a path to it
+            </summary>
+        </member>
+        <member name="E:DG.Tweening.DOTweenPath.OnReset">
+            <summary>Used internally by the editor</summary>
+        </member>
+        <member name="M:DG.Tweening.DOTweenPath.DORestart">
+            <summary>
+            Restarts the tween
+            </summary>
+        </member>
+        <member name="M:DG.Tweening.DOTweenPath.DORestart(System.Boolean)">
+            <summary>
+            Restarts the tween
+            </summary>
+            <param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position.
+            Set it to TRUE when spawning the same DOTweenPath in different positions (like when using a pooling system)</param>
+        </member>
+        <member name="M:DG.Tweening.DOTweenPath.GetDrawPoints">
+            <summary>
+            Returns a list of points that are used to draw the path inside the editor.
+            </summary>
+        </member>
+        <member name="T:DG.Tweening.Plugins.SpiralPlugin">
+            <summary>
+            Tweens a Vector3 along a spiral.
+            EndValue represents the direction of the spiral
+            </summary>
+        </member>
+        <member name="T:DG.Tweening.SpiralMode">
+            <summary>
+            Spiral tween mode
+            </summary>
+        </member>
+        <member name="F:DG.Tweening.SpiralMode.Expand">
+            <summary>The spiral motion will expand outwards for the whole the tween</summary>
+        </member>
+        <member name="F:DG.Tweening.SpiralMode.ExpandThenContract">
+            <summary>The spiral motion will expand outwards for half the tween and then will spiral back to the starting position</summary>
+        </member>
+    </members>
+</doc>

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenPro.XML.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: db7d7ef84c388bc4fbc3835d31a15306
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenPro.dll.mdb.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d719ed2e2c87eae4e8dd520e2df659c1
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenPro.dll.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: aa0b1eebb5db27a419fa4564bbe5c9c5
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenProShortcuts.cs

@@ -0,0 +1,90 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2018/07/13
+
+using System;
+using DG.Tweening.Core;
+using DG.Tweening.Plugins;
+using UnityEngine;
+
+#pragma warning disable 1591
+namespace DG.Tweening
+{
+	public static class DOTweenProShortcuts
+    {
+        static DOTweenProShortcuts()
+        {
+            // Create stub instances of custom plugins, in order to allow IL2CPP to understand they must be included in the build
+#pragma warning disable 219
+            SpiralPlugin stub = new SpiralPlugin();
+#pragma warning restore 219
+        }
+
+        #region Shortcuts
+
+        #region Transform
+
+        /// <summary>Tweens a Transform's localPosition in a spiral shape.
+        /// Also stores the transform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="axis">The axis around which the spiral will rotate</param>
+        /// <param name="mode">The type of spiral movement</param>
+        /// <param name="speed">Speed of the rotations</param>
+        /// <param name="frequency">Frequency of the rotation. Lower values lead to wider spirals</param>
+        /// <param name="depth">Indicates how much the tween should move along the spiral's axis</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOSpiral(
+            this Transform target, float duration, Vector3? axis = null, SpiralMode mode = SpiralMode.Expand,
+            float speed = 1, float frequency = 10, float depth = 0, bool snapping = false
+        ) {
+            if (Mathf.Approximately(speed, 0)) speed = 1;
+            if (axis == null || axis == Vector3.zero) axis = Vector3.forward;
+
+            TweenerCore<Vector3, Vector3, SpiralOptions> t = DOTween.To(SpiralPlugin.Get(), () => target.localPosition, x => target.localPosition = x, (Vector3)axis, duration)
+                .SetTarget(target);
+
+            t.plugOptions.mode = mode;
+            t.plugOptions.speed = speed;
+            t.plugOptions.frequency = frequency;
+            t.plugOptions.depth = depth;
+            t.plugOptions.snapping = snapping;
+            return t;
+        }
+
+        #endregion
+
+#if true // PHYSICS_MARKER
+        #region Rigidbody
+
+        /// <summary>Tweens a Rigidbody's position in a spiral shape.
+        /// Also stores the transform as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="duration">The duration of the tween</param>
+        /// <param name="axis">The axis around which the spiral will rotate</param>
+        /// <param name="mode">The type of spiral movement</param>
+        /// <param name="speed">Speed of the rotations</param>
+        /// <param name="frequency">Frequency of the rotation. Lower values lead to wider spirals</param>
+        /// <param name="depth">Indicates how much the tween should move along the spiral's axis</param>
+        /// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
+        public static Tweener DOSpiral(
+            this Rigidbody target, float duration, Vector3? axis = null, SpiralMode mode = SpiralMode.Expand,
+            float speed = 1, float frequency = 10, float depth = 0, bool snapping = false
+        ) {
+            if (Mathf.Approximately(speed, 0)) speed = 1;
+            if (axis == null || axis == Vector3.zero) axis = Vector3.forward;
+
+            TweenerCore<Vector3, Vector3, SpiralOptions> t = DOTween.To(SpiralPlugin.Get(), () => target.position, target.MovePosition, (Vector3)axis, duration)
+                .SetTarget(target);
+
+            t.plugOptions.mode = mode;
+            t.plugOptions.speed = speed;
+            t.plugOptions.frequency = frequency;
+            t.plugOptions.depth = depth;
+            t.plugOptions.snapping = snapping;
+            return t;
+        }
+
+        #endregion
+#endif
+
+        #endregion
+	}
+}

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenProShortcuts.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1c3190a1a1c53f449926f6d5542b4ce5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs

@@ -0,0 +1,141 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2015/03/27 19:02
+// 
+// License Copyright (c) Daniele Giardini.
+// This work is subject to the terms at http://dotween.demigiant.com/license.php
+
+#if false // MODULE_MARKER
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+using TMPro;
+
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Methods that extend TMP_Text objects and allow to directly create and control tweens from their instances.
+    /// </summary>
+    public static class ShortcutExtensionsTMPText
+    {
+        #region Colors
+
+        /// <summary>Tweens a TextMeshPro's color to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this TMP_Text target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's faceColor to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFaceColor(this TMP_Text target, Color32 endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.faceColor, x => target.faceColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's outlineColor to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOOutlineColor(this TMP_Text target, Color32 endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.outlineColor, x => target.outlineColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's glow color to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="useSharedMaterial">If TRUE will use the fontSharedMaterial instead than the fontMaterial</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOGlowColor(this TMP_Text target, Color endValue, float duration, bool useSharedMaterial = false)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = useSharedMaterial
+                ? target.fontSharedMaterial.DOColor(endValue, "_GlowColor", duration)
+                : target.fontMaterial.DOColor(endValue, "_GlowColor", duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's alpha color to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this TMP_Text target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro faceColor's alpha to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFaceFade(this TMP_Text target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.faceColor, x => target.faceColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Other
+
+        /// <summary>Tweens a TextMeshPro's scale to the given value (using correct uniform scale as TMP requires).
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this TMP_Text target, float endValue, float duration)
+        {
+            Transform trans = target.transform;
+            Vector3 endValueV3 = new Vector3(endValue, endValue, endValue);
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => trans.localScale, x => trans.localScale = x, endValueV3, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's fontSize to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFontSize(this TMP_Text target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.fontSize, x => target.fontSize = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's maxVisibleCharacters to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<int, int, NoOptions> DOMaxVisibleCharacters(this TMP_Text target, int endValue, float duration)
+        {
+            TweenerCore<int, int, NoOptions> t = DOTween.To(() => target.maxVisibleCharacters, x => target.maxVisibleCharacters = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's text to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
+        /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
+        /// otherwise all tags will be considered as normal text</param>
+        /// <param name="scrambleMode">The type of scramble mode to use, if any</param>
+        /// <param name="scrambleChars">A string containing the characters to use for scrambling.
+        /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
+        /// Leave it to NULL (default) to use default ones</param>
+        public static TweenerCore<string, string, StringOptions> DOText(this TMP_Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
+        {
+            TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
+            t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+    }
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon

@@ -0,0 +1,141 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2015/03/27 19:02
+// 
+// License Copyright (c) Daniele Giardini.
+// This work is subject to the terms at http://dotween.demigiant.com/license.php
+
+#if false // MODULE_MARKER
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+using TMPro;
+
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Methods that extend TMP_Text objects and allow to directly create and control tweens from their instances.
+    /// </summary>
+    public static class ShortcutExtensionsTMPText
+    {
+        #region Colors
+
+        /// <summary>Tweens a TextMeshPro's color to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this TMP_Text target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's faceColor to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFaceColor(this TMP_Text target, Color32 endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.faceColor, x => target.faceColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's outlineColor to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOOutlineColor(this TMP_Text target, Color32 endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.outlineColor, x => target.outlineColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's glow color to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        /// <param name="useSharedMaterial">If TRUE will use the fontSharedMaterial instead than the fontMaterial</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOGlowColor(this TMP_Text target, Color endValue, float duration, bool useSharedMaterial = false)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = useSharedMaterial
+                ? target.fontSharedMaterial.DOColor(endValue, "_GlowColor", duration)
+                : target.fontMaterial.DOColor(endValue, "_GlowColor", duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's alpha color to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this TMP_Text target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro faceColor's alpha to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFaceFade(this TMP_Text target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.faceColor, x => target.faceColor = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region Other
+
+        /// <summary>Tweens a TextMeshPro's scale to the given value (using correct uniform scale as TMP requires).
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this TMP_Text target, float endValue, float duration)
+        {
+            Transform trans = target.transform;
+            Vector3 endValueV3 = new Vector3(endValue, endValue, endValue);
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => trans.localScale, x => trans.localScale = x, endValueV3, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's fontSize to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<float, float, FloatOptions> DOFontSize(this TMP_Text target, float endValue, float duration)
+        {
+            TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.fontSize, x => target.fontSize = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's maxVisibleCharacters to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<int, int, NoOptions> DOMaxVisibleCharacters(this TMP_Text target, int endValue, float duration)
+        {
+            TweenerCore<int, int, NoOptions> t = DOTween.To(() => target.maxVisibleCharacters, x => target.maxVisibleCharacters = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a TextMeshPro's text to the given value.
+        /// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
+        /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
+        /// otherwise all tags will be considered as normal text</param>
+        /// <param name="scrambleMode">The type of scramble mode to use, if any</param>
+        /// <param name="scrambleChars">A string containing the characters to use for scrambling.
+        /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
+        /// Leave it to NULL (default) to use default ones</param>
+        public static TweenerCore<string, string, StringOptions> DOText(this TMP_Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
+        {
+            TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
+            t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+    }
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.addon.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2a5935d4c3cbf544e8dec8f08ac0d540
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8fb0d65aa5b048649a3a785b82b8f8db
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTk2d.cs

@@ -0,0 +1,245 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2014/10/27 15:59
+// 
+// License Copyright (c) Daniele Giardini.
+// This work is subject to the terms at http://dotween.demigiant.com/license.php
+
+#if false // MODULE_MARKER
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Methods that extend 2D Toolkit objects and allow to directly create and control tweens from their instances.
+    /// </summary>
+    public static class ShortcutExtensionsTk2d
+    {
+        #region Sprite
+
+        /// <summary>Tweens a 2D Toolkit Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this tk2dBaseSprite target, Vector3 endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleX(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleY(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleZ(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z)
+                .SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit Sprite's color to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this tk2dBaseSprite target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit Sprite's alpha color to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit Sprite's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this tk2dBaseSprite target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+
+        #endregion
+
+        #region tk2dSlicedSprite
+
+        /// <summary>Tweens a 2D Toolkit SlicedSprite's dimensions to the given value.
+        /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensions(this tk2dSlicedSprite target, Vector2 endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a SlicedSprite's dimensions to the given value.
+        /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensionsX(this tk2dSlicedSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a SlicedSprite's dimensions to the given value.
+        /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensionsY(this tk2dSlicedSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region TextMesh
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this tk2dTextMesh target, Vector3 endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleX(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleY(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleZ(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z)
+                .SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's color to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this tk2dTextMesh target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's alpha color to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this tk2dTextMesh target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+
+        /// <summary>Tweens a tk2dTextMesh's text to the given value.
+        /// Also stores the tk2dTextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
+        /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
+        /// otherwise all tags will be considered as normal text</param>
+        /// <param name="scrambleMode">The type of scramble mode to use, if any</param>
+        /// <param name="scrambleChars">A string containing the characters to use for scrambling.
+        /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
+        /// Leave it to NULL (default) to use default ones</param>
+        public static TweenerCore<string, string, StringOptions> DOText(this tk2dTextMesh target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
+        {
+            TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
+            t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+    }
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon

@@ -0,0 +1,245 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2014/10/27 15:59
+// 
+// License Copyright (c) Daniele Giardini.
+// This work is subject to the terms at http://dotween.demigiant.com/license.php
+
+#if false // MODULE_MARKER
+using DG.Tweening.Core;
+using DG.Tweening.Plugins.Options;
+using UnityEngine;
+
+namespace DG.Tweening
+{
+    /// <summary>
+    /// Methods that extend 2D Toolkit objects and allow to directly create and control tweens from their instances.
+    /// </summary>
+    public static class ShortcutExtensionsTk2d
+    {
+        #region Sprite
+
+        /// <summary>Tweens a 2D Toolkit Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this tk2dBaseSprite target, Vector3 endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleX(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleY(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a Sprite's dimensions to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleZ(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z)
+                .SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit Sprite's color to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this tk2dBaseSprite target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit Sprite's alpha color to the given value.
+        /// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this tk2dBaseSprite target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit Sprite's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this tk2dBaseSprite target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+
+        #endregion
+
+        #region tk2dSlicedSprite
+
+        /// <summary>Tweens a 2D Toolkit SlicedSprite's dimensions to the given value.
+        /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensions(this tk2dSlicedSprite target, Vector2 endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a SlicedSprite's dimensions to the given value.
+        /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensionsX(this tk2dSlicedSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(endValue, 0), duration);
+            t.SetOptions(AxisConstraint.X)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a SlicedSprite's dimensions to the given value.
+        /// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensionsY(this tk2dSlicedSprite target, float endValue, float duration)
+        {
+            TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(0, endValue), duration);
+            t.SetOptions(AxisConstraint.Y)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+
+        #region TextMesh
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this tk2dTextMesh target, Vector3 endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleX(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(endValue, 0, 0), duration);
+            t.SetOptions(AxisConstraint.X)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleY(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, endValue, 0), duration);
+            t.SetOptions(AxisConstraint.Y)
+                .SetTarget(target);
+            return t;
+        }
+        /// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleZ(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, 0, endValue), duration);
+            t.SetOptions(AxisConstraint.Z)
+                .SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's color to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOColor(this tk2dTextMesh target, Color endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's alpha color to the given value.
+        /// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
+        public static TweenerCore<Color, Color, ColorOptions> DOFade(this tk2dTextMesh target, float endValue, float duration)
+        {
+            TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
+            t.SetTarget(target);
+            return t;
+        }
+
+        /// <summary>Tweens a 2D Toolkit TextMesh's color using the given gradient
+        /// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
+        /// Also stores the image as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
+        public static Sequence DOGradientColor(this tk2dTextMesh target, Gradient gradient, float duration)
+        {
+            Sequence s = DOTween.Sequence();
+            GradientColorKey[] colors = gradient.colorKeys;
+            int len = colors.Length;
+            for (int i = 0; i < len; ++i) {
+                GradientColorKey c = colors[i];
+                if (i == 0 && c.time <= 0) {
+                    target.color = c.color;
+                    continue;
+                }
+                float colorDuration = i == len - 1
+                    ? duration - s.Duration(false) // Verifies that total duration is correct
+                    : duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
+                s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
+            }
+            return s;
+        }
+
+        /// <summary>Tweens a tk2dTextMesh's text to the given value.
+        /// Also stores the tk2dTextMesh as the tween's target so it can be used for filtered operations</summary>
+        /// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
+        /// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
+        /// otherwise all tags will be considered as normal text</param>
+        /// <param name="scrambleMode">The type of scramble mode to use, if any</param>
+        /// <param name="scrambleChars">A string containing the characters to use for scrambling.
+        /// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
+        /// Leave it to NULL (default) to use default ones</param>
+        public static TweenerCore<string, string, StringOptions> DOText(this tk2dTextMesh target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
+        {
+            TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
+            t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
+                .SetTarget(target);
+            return t;
+        }
+
+        #endregion
+    }
+}
+#endif

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTk2d.cs.addon.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6ec99626716d95c4ba56a6d6f9dec583
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/DOTweenTk2d.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b590cd7c24ffa5d4faa5b6fa993cccad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 260670f40f7e2dd439b34c632286ed44
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs

@@ -0,0 +1,745 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2015/03/12 16:03
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using DG.DemiEditor;
+using DG.DOTweenEditor.Core;
+using DG.DOTweenEditor.UI;
+using DG.Tweening;
+using DG.Tweening.Core;
+using UnityEditor;
+using UnityEngine;
+using DOTweenSettings = DG.Tweening.Core.DOTweenSettings;
+#if true // UI_MARKER
+using UnityEngine.UI;
+#endif
+#if false // TEXTMESHPRO_MARKER
+    using TMPro;
+#endif
+
+namespace DG.DOTweenEditor
+{
+    [CustomEditor(typeof(DOTweenAnimation))]
+    public class DOTweenAnimationInspector : ABSAnimationInspector
+    {
+        enum FadeTargetType
+        {
+            CanvasGroup,
+            Image
+        }
+
+        enum ChooseTargetMode
+        {
+            None,
+            BetweenCanvasGroupAndImage
+        }
+
+        static readonly Dictionary<DOTweenAnimation.AnimationType, Type[]> _AnimationTypeToComponent = new Dictionary<DOTweenAnimation.AnimationType, Type[]>() {
+            { DOTweenAnimation.AnimationType.Move, new[] {
+#if true // PHYSICS_MARKER
+                typeof(Rigidbody),
+#endif
+#if true // PHYSICS2D_MARKER
+                typeof(Rigidbody2D),
+#endif
+#if true // UI_MARKER
+                typeof(RectTransform),
+#endif
+                typeof(Transform)
+            }},
+            { DOTweenAnimation.AnimationType.Rotate, new[] {
+#if true // PHYSICS_MARKER
+                typeof(Rigidbody),
+#endif
+#if true // PHYSICS2D_MARKER
+                typeof(Rigidbody2D),
+#endif
+                typeof(Transform)
+            }},
+            { DOTweenAnimation.AnimationType.LocalMove, new[] { typeof(Transform) } },
+            { DOTweenAnimation.AnimationType.LocalRotate, new[] { typeof(Transform) } },
+            { DOTweenAnimation.AnimationType.Scale, new[] { typeof(Transform) } },
+            { DOTweenAnimation.AnimationType.Color, new[] {
+                typeof(Light),
+#if true // SPRITE_MARKER
+                typeof(SpriteRenderer),
+#endif
+#if true // UI_MARKER
+                typeof(Image), typeof(Text), typeof(RawImage),
+#endif
+                typeof(Renderer),
+            }},
+            { DOTweenAnimation.AnimationType.Fade, new[] {
+                typeof(Light),
+#if true // SPRITE_MARKER
+                typeof(SpriteRenderer),
+#endif
+#if true // UI_MARKER
+                typeof(Image), typeof(Text), typeof(CanvasGroup), typeof(RawImage),
+#endif
+                typeof(Renderer),
+            }},
+#if true // UI_MARKER
+            { DOTweenAnimation.AnimationType.Text, new[] { typeof(Text) } },
+#endif
+            { DOTweenAnimation.AnimationType.PunchPosition, new[] {
+#if true // UI_MARKER
+                typeof(RectTransform),
+#endif
+                typeof(Transform)
+            }},
+            { DOTweenAnimation.AnimationType.PunchRotation, new[] { typeof(Transform) } },
+            { DOTweenAnimation.AnimationType.PunchScale, new[] { typeof(Transform) } },
+            { DOTweenAnimation.AnimationType.ShakePosition, new[] {
+#if true // UI_MARKER
+                typeof(RectTransform),
+#endif
+                typeof(Transform)
+            }},
+            { DOTweenAnimation.AnimationType.ShakeRotation, new[] { typeof(Transform) } },
+            { DOTweenAnimation.AnimationType.ShakeScale, new[] { typeof(Transform) } },
+            { DOTweenAnimation.AnimationType.CameraAspect, new[] { typeof(Camera) } },
+            { DOTweenAnimation.AnimationType.CameraBackgroundColor, new[] { typeof(Camera) } },
+            { DOTweenAnimation.AnimationType.CameraFieldOfView, new[] { typeof(Camera) } },
+            { DOTweenAnimation.AnimationType.CameraOrthoSize, new[] { typeof(Camera) } },
+            { DOTweenAnimation.AnimationType.CameraPixelRect, new[] { typeof(Camera) } },
+            { DOTweenAnimation.AnimationType.CameraRect, new[] { typeof(Camera) } },
+#if true // UI_MARKER
+            { DOTweenAnimation.AnimationType.UIWidthHeight, new[] { typeof(RectTransform) } },
+#endif
+        };
+
+#if false // TK2D_MARKER
+        static readonly Dictionary<DOTweenAnimation.AnimationType, Type[]> _Tk2dAnimationTypeToComponent = new Dictionary<DOTweenAnimation.AnimationType, Type[]>() {
+            { DOTweenAnimation.AnimationType.Scale, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } },
+            { DOTweenAnimation.AnimationType.Color, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } },
+            { DOTweenAnimation.AnimationType.Fade, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } },
+            { DOTweenAnimation.AnimationType.Text, new[] { typeof(tk2dTextMesh) } }
+        };
+#endif
+#if false // TEXTMESHPRO_MARKER
+        static readonly Dictionary<DOTweenAnimation.AnimationType, Type[]> _TMPAnimationTypeToComponent = new Dictionary<DOTweenAnimation.AnimationType, Type[]>() {
+            { DOTweenAnimation.AnimationType.Color, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } },
+            { DOTweenAnimation.AnimationType.Fade, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } },
+            { DOTweenAnimation.AnimationType.Text, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } }
+        };
+#endif
+
+        static readonly string[] _AnimationType = new[] {
+            "None",
+            "Move", "LocalMove",
+            "Rotate", "LocalRotate",
+            "Scale",
+            "Color", "Fade",
+#if true // UI_MARKER
+            "Text",
+#endif
+#if false // TK2D_MARKER
+            "Text",
+#endif
+#if false // TEXTMESHPRO_MARKER
+            "Text",
+#endif
+#if true // UI_MARKER
+            "UIWidthHeight",
+#endif
+            "Punch/Position", "Punch/Rotation", "Punch/Scale",
+            "Shake/Position", "Shake/Rotation", "Shake/Scale",
+            "Camera/Aspect", "Camera/BackgroundColor", "Camera/FieldOfView", "Camera/OrthoSize", "Camera/PixelRect", "Camera/Rect"
+        };
+        static string[] _animationTypeNoSlashes; // _AnimationType list without slashes in values
+        static string[] _datString; // String representation of DOTweenAnimation enum (here for caching reasons)
+
+        DOTweenAnimation _src;
+        DOTweenSettings _settings;
+        bool _runtimeEditMode; // If TRUE allows to change and save stuff at runtime
+        bool _refreshRequired; // If TRUE refreshes components data
+        int _totComponentsOnSrc; // Used to determine if a Component is added or removed from the source
+        bool _isLightSrc; // Used to determine if we're tweening a Light, to set the max Fade value to more than 1
+#pragma warning disable 414
+        ChooseTargetMode _chooseTargetMode = ChooseTargetMode.None;
+#pragma warning restore 414
+
+        static readonly GUIContent _GuiC_selfTarget_true = new GUIContent(
+            "SELF", "Will animate components on this gameObject"
+        );
+        static readonly GUIContent _GuiC_selfTarget_false = new GUIContent(
+            "OTHER", "Will animate components on the given gameObject instead than on this one"
+        );
+        static readonly GUIContent _GuiC_tweenTargetIsTargetGO_true = new GUIContent(
+            "Use As Tween Target", "Will set the tween target (via SetTarget, used to control a tween directly from a target) to the \"OTHER\" gameObject"
+        );
+        static readonly GUIContent _GuiC_tweenTargetIsTargetGO_false = new GUIContent(
+            "Use As Tween Target", "Will set the tween target (via SetTarget, used to control a tween directly from a target) to the gameObject containing this animation, not the \"OTHER\" one"
+        );
+
+        #region MonoBehaviour Methods
+
+        void OnEnable()
+        {
+            _src = target as DOTweenAnimation;
+            _settings = DOTweenUtilityWindow.GetDOTweenSettings();
+
+            onStartProperty = base.serializedObject.FindProperty("onStart");
+            onPlayProperty = base.serializedObject.FindProperty("onPlay");
+            onUpdateProperty = base.serializedObject.FindProperty("onUpdate");
+            onStepCompleteProperty = base.serializedObject.FindProperty("onStepComplete");
+            onCompleteProperty = base.serializedObject.FindProperty("onComplete");
+            onRewindProperty = base.serializedObject.FindProperty("onRewind");
+            onTweenCreatedProperty = base.serializedObject.FindProperty("onTweenCreated");
+
+            // Convert _AnimationType to _animationTypeNoSlashes
+            int len = _AnimationType.Length;
+            _animationTypeNoSlashes = new string[len];
+            for (int i = 0; i < len; ++i) {
+                string a = _AnimationType[i];
+                a = a.Replace("/", "");
+                _animationTypeNoSlashes[i] = a;
+            }
+        }
+
+        void OnDisable()
+        {
+            DOTweenPreviewManager.StopAllPreviews();
+        }
+
+        override public void OnInspectorGUI()
+        {
+        	base.OnInspectorGUI();
+
+            GUILayout.Space(3);
+            EditorGUIUtils.SetGUIStyles();
+
+            bool playMode = Application.isPlaying;
+            _runtimeEditMode = _runtimeEditMode && playMode;
+
+            GUILayout.BeginHorizontal();
+            EditorGUIUtils.InspectorLogo();
+            GUILayout.Label(_src.animationType.ToString() + (string.IsNullOrEmpty(_src.id) ? "" : " [" + _src.id + "]"), EditorGUIUtils.sideLogoIconBoldLabelStyle);
+            // Up-down buttons
+            GUILayout.FlexibleSpace();
+            if (GUILayout.Button("▲", DeGUI.styles.button.toolIco)) UnityEditorInternal.ComponentUtility.MoveComponentUp(_src);
+            if (GUILayout.Button("▼", DeGUI.styles.button.toolIco)) UnityEditorInternal.ComponentUtility.MoveComponentDown(_src);
+            GUILayout.EndHorizontal();
+
+            if (playMode) {
+                if (_runtimeEditMode) {
+                    
+                } else {
+                    GUILayout.Space(8);
+                    GUILayout.Label("Animation Editor disabled while in play mode", EditorGUIUtils.wordWrapLabelStyle);
+                    if (!_src.isActive) {
+                        GUILayout.Label("This animation has been toggled as inactive and won't be generated", EditorGUIUtils.wordWrapLabelStyle);
+                        GUI.enabled = false;
+                    }
+                    if (GUILayout.Button(new GUIContent("Activate Edit Mode", "Switches to Runtime Edit Mode, where you can change animations values and restart them"))) {
+                        _runtimeEditMode = true;
+                    }
+                    GUILayout.Label("NOTE: when using DOPlayNext, the sequence is determined by the DOTweenAnimation Components order in the target GameObject's Inspector", EditorGUIUtils.wordWrapLabelStyle);
+                    GUILayout.Space(10);
+                    if (!_runtimeEditMode) return;
+                }
+            }
+
+            Undo.RecordObject(_src, "DOTween Animation");
+            Undo.RecordObject(_settings, "DOTween Animation");
+
+//            _src.isValid = Validate(); // Moved down
+
+            EditorGUIUtility.labelWidth = 110;
+
+            if (playMode) {
+                GUILayout.Space(4);
+                DeGUILayout.Toolbar("Edit Mode Commands");
+                DeGUILayout.BeginVBox(DeGUI.styles.box.stickyTop);
+                    GUILayout.BeginHorizontal();
+                    if (GUILayout.Button("TogglePause")) _src.tween.TogglePause();
+                    if (GUILayout.Button("Rewind")) _src.tween.Rewind();
+                    if (GUILayout.Button("Restart")) _src.tween.Restart();
+                    GUILayout.EndHorizontal();
+                    if (GUILayout.Button("Commit changes and restart")) {
+                        _src.tween.Rewind();
+                        _src.tween.Kill();
+                        if (_src.isValid) {
+                            _src.CreateTween();
+                            _src.tween.Play();
+                        }
+                    }
+                    GUILayout.Label("To apply your changes when exiting Play mode, use the Component's upper right menu and choose \"Copy Component\", then \"Paste Component Values\" after exiting Play mode", DeGUI.styles.label.wordwrap);
+                DeGUILayout.EndVBox();
+            } else {
+                GUILayout.BeginHorizontal();
+                bool hasManager = _src.GetComponent<DOTweenVisualManager>() != null;
+                EditorGUI.BeginChangeCheck();
+                _settings.showPreviewPanel = hasManager
+                    ? DeGUILayout.ToggleButton(_settings.showPreviewPanel, "Preview Controls", styles.custom.inlineToggle)
+                    : DeGUILayout.ToggleButton(_settings.showPreviewPanel, "Preview Controls", styles.custom.inlineToggle, GUILayout.Width(120));
+                if (EditorGUI.EndChangeCheck()) {
+                    EditorUtility.SetDirty(_settings);
+                    DOTweenPreviewManager.StopAllPreviews();
+                }
+                if (!hasManager) {
+                    if (GUILayout.Button(new GUIContent("Add Manager", "Adds a manager component which allows you to choose additional options for this gameObject"))) {
+                        _src.gameObject.AddComponent<DOTweenVisualManager>();
+                    }
+                }
+                GUILayout.EndHorizontal();
+            }
+
+            // Preview in editor
+            bool isPreviewing = _settings.showPreviewPanel ? DOTweenPreviewManager.PreviewGUI(_src) : false;
+
+            EditorGUI.BeginDisabledGroup(isPreviewing);
+            // Choose target
+            GUILayout.BeginHorizontal();
+                _src.isActive = EditorGUILayout.Toggle(new GUIContent("", "If unchecked, this animation will not be created"), _src.isActive, GUILayout.Width(14));
+                EditorGUI.BeginChangeCheck();
+                    EditorGUI.BeginChangeCheck();
+                        _src.targetIsSelf = DeGUILayout.ToggleButton(
+                            _src.targetIsSelf, _src.targetIsSelf ? _GuiC_selfTarget_true : _GuiC_selfTarget_false,
+                            new Color(1f, 0.78f, 0f), DeGUI.colors.bg.toggleOn, new Color(0.33f, 0.14f, 0.02f), DeGUI.colors.content.toggleOn,
+                            null, GUILayout.Width(47)
+                        );
+                    bool innerChanged = EditorGUI.EndChangeCheck();
+                    if (innerChanged) {
+                        _src.targetGO = null;
+                        GUI.changed = true;
+                    }
+                    if (_src.targetIsSelf) GUILayout.Label(_GuiC_selfTarget_true.tooltip);
+                    else {
+                        using (new DeGUI.ColorScope(null, null, _src.targetGO == null ? Color.red : Color.white)) {
+                            _src.targetGO = (GameObject)EditorGUILayout.ObjectField(_src.targetGO, typeof(GameObject), true);
+                        }
+                        _src.tweenTargetIsTargetGO = DeGUILayout.ToggleButton(
+                            _src.tweenTargetIsTargetGO, _src.tweenTargetIsTargetGO ? _GuiC_tweenTargetIsTargetGO_true : _GuiC_tweenTargetIsTargetGO_false,
+                            GUILayout.Width(131)
+                        );
+                    }
+                bool check = EditorGUI.EndChangeCheck();
+                if (check) _refreshRequired = true;
+            GUILayout.EndHorizontal();
+
+            GameObject targetGO = _src.targetIsSelf ? _src.gameObject : _src.targetGO;
+
+            if (targetGO == null) {
+                // Uses external target gameObject but it's not set
+                if (_src.targetGO != null || _src.target != null) {
+                    _src.targetGO = null;
+                    _src.target = null;
+                    GUI.changed = true;
+                }
+            } else {
+                GUILayout.BeginHorizontal();
+                DOTweenAnimation.AnimationType prevAnimType = _src.animationType;
+//                _src.animationType = (DOTweenAnimation.AnimationType)EditorGUILayout.EnumPopup(_src.animationType, EditorGUIUtils.popupButton);
+                GUI.enabled = GUI.enabled && _src.isActive;
+                _src.animationType = AnimationToDOTweenAnimationType(_AnimationType[EditorGUILayout.Popup(DOTweenAnimationTypeToPopupId(_src.animationType), _AnimationType)]);
+                _src.autoPlay = DeGUILayout.ToggleButton(_src.autoPlay, new GUIContent("AutoPlay", "If selected, the tween will play automatically"));
+                _src.autoKill = DeGUILayout.ToggleButton(_src.autoKill, new GUIContent("AutoKill", "If selected, the tween will be killed when it completes, and won't be reusable"));
+                GUILayout.EndHorizontal();
+                if (prevAnimType != _src.animationType) {
+                    // Set default optional values based on animation type
+                    _src.endValueTransform = null;
+                    _src.useTargetAsV3 = false;
+                    switch (_src.animationType) {
+                    case DOTweenAnimation.AnimationType.Move:
+                    case DOTweenAnimation.AnimationType.LocalMove:
+                    case DOTweenAnimation.AnimationType.Rotate:
+                    case DOTweenAnimation.AnimationType.LocalRotate:
+                    case DOTweenAnimation.AnimationType.Scale:
+                        _src.endValueV3 = Vector3.zero;
+                        _src.endValueFloat = 0;
+                        _src.optionalBool0 = _src.animationType == DOTweenAnimation.AnimationType.Scale;
+                        break;
+                    case DOTweenAnimation.AnimationType.UIWidthHeight:
+                        _src.endValueV3 = Vector3.zero;
+                        _src.endValueFloat = 0;
+                        _src.optionalBool0 = _src.animationType == DOTweenAnimation.AnimationType.UIWidthHeight;
+                        break;
+                    case DOTweenAnimation.AnimationType.Color:
+                    case DOTweenAnimation.AnimationType.Fade:
+                        _isLightSrc = targetGO.GetComponent<Light>() != null;
+                        _src.endValueFloat = 0;
+                        break;
+                    case DOTweenAnimation.AnimationType.Text:
+                        _src.optionalBool0 = true;
+                        break;
+                    case DOTweenAnimation.AnimationType.PunchPosition:
+                    case DOTweenAnimation.AnimationType.PunchRotation:
+                    case DOTweenAnimation.AnimationType.PunchScale:
+                        _src.endValueV3 = _src.animationType == DOTweenAnimation.AnimationType.PunchRotation ? new Vector3(0, 180, 0) : Vector3.one;
+                        _src.optionalFloat0 = 1;
+                        _src.optionalInt0 = 10;
+                        _src.optionalBool0 = false;
+                        break;
+                    case DOTweenAnimation.AnimationType.ShakePosition:
+                    case DOTweenAnimation.AnimationType.ShakeRotation:
+                    case DOTweenAnimation.AnimationType.ShakeScale:
+                        _src.endValueV3 = _src.animationType == DOTweenAnimation.AnimationType.ShakeRotation ? new Vector3(90, 90, 90) : Vector3.one;
+                        _src.optionalInt0 = 10;
+                        _src.optionalFloat0 = 90;
+                        _src.optionalBool0 = false;
+                        break;
+                    case DOTweenAnimation.AnimationType.CameraAspect:
+                    case DOTweenAnimation.AnimationType.CameraFieldOfView:
+                    case DOTweenAnimation.AnimationType.CameraOrthoSize:
+                        _src.endValueFloat = 0;
+                        break;
+                    case DOTweenAnimation.AnimationType.CameraPixelRect:
+                    case DOTweenAnimation.AnimationType.CameraRect:
+                        _src.endValueRect = new Rect(0, 0, 0, 0);
+                        break;
+                    }
+                }
+                if (_src.animationType == DOTweenAnimation.AnimationType.None) {
+                    _src.isValid = false;
+                    if (GUI.changed) EditorUtility.SetDirty(_src);
+                    return;
+                }
+
+                if (_refreshRequired || prevAnimType != _src.animationType || ComponentsChanged()) {
+                    _refreshRequired = false;
+                    _src.isValid = Validate(targetGO);
+                    // See if we need to choose between multiple targets
+#if true // UI_MARKER
+                    if (_src.animationType == DOTweenAnimation.AnimationType.Fade && targetGO.GetComponent<CanvasGroup>() != null && targetGO.GetComponent<Image>() != null) {
+                        _chooseTargetMode = ChooseTargetMode.BetweenCanvasGroupAndImage;
+                        // Reassign target and forcedTargetType if lost
+                        if (_src.forcedTargetType == DOTweenAnimation.TargetType.Unset) _src.forcedTargetType = _src.targetType;
+                        switch (_src.forcedTargetType) {
+                        case DOTweenAnimation.TargetType.CanvasGroup:
+                            _src.target = targetGO.GetComponent<CanvasGroup>();
+                            break;
+                        case DOTweenAnimation.TargetType.Image:
+                            _src.target = targetGO.GetComponent<Image>();
+                            break;
+                        }
+                    } else {
+#endif
+                        _chooseTargetMode = ChooseTargetMode.None;
+                        _src.forcedTargetType = DOTweenAnimation.TargetType.Unset;
+#if true // UI_MARKER
+                    }
+#endif
+                }
+
+                if (!_src.isValid) {
+                    GUI.color = Color.red;
+                    GUILayout.BeginVertical(GUI.skin.box);
+                    GUILayout.Label("No valid Component was found for the selected animation", EditorGUIUtils.wordWrapLabelStyle);
+                    GUILayout.EndVertical();
+                    GUI.color = Color.white;
+                    if (GUI.changed) EditorUtility.SetDirty(_src);
+                    return;
+                }
+
+#if true // UI_MARKER
+                // Special cases in which multiple target types could be used (set after validation)
+                if (_chooseTargetMode == ChooseTargetMode.BetweenCanvasGroupAndImage && _src.forcedTargetType != DOTweenAnimation.TargetType.Unset) {
+                    FadeTargetType fadeTargetType = (FadeTargetType)Enum.Parse(typeof(FadeTargetType), _src.forcedTargetType.ToString());
+                    DOTweenAnimation.TargetType prevTargetType = _src.forcedTargetType;
+                    _src.forcedTargetType = (DOTweenAnimation.TargetType)Enum.Parse(typeof(DOTweenAnimation.TargetType), EditorGUILayout.EnumPopup(_src.animationType + " Target", fadeTargetType).ToString());
+                    if (_src.forcedTargetType != prevTargetType) {
+                        // Target type change > assign correct target
+                        switch (_src.forcedTargetType) {
+                        case DOTweenAnimation.TargetType.CanvasGroup:
+                            _src.target = targetGO.GetComponent<CanvasGroup>();
+                            break;
+                        case DOTweenAnimation.TargetType.Image:
+                            _src.target = targetGO.GetComponent<Image>();
+                            break;
+                        }
+                    }
+                }
+#endif
+
+                GUILayout.BeginHorizontal();
+                _src.duration = EditorGUILayout.FloatField("Duration", _src.duration);
+                if (_src.duration < 0) _src.duration = 0;
+                _src.isSpeedBased = DeGUILayout.ToggleButton(_src.isSpeedBased, new GUIContent("SpeedBased", "If selected, the duration will count as units/degree x second"), DeGUI.styles.button.tool, GUILayout.Width(75));
+                GUILayout.EndHorizontal();
+                _src.delay = EditorGUILayout.FloatField("Delay", _src.delay);
+                if (_src.delay < 0) _src.delay = 0;
+                _src.isIndependentUpdate = EditorGUILayout.Toggle("Ignore TimeScale", _src.isIndependentUpdate);
+                _src.easeType = EditorGUIUtils.FilteredEasePopup(_src.easeType);
+                if (_src.easeType == Ease.INTERNAL_Custom) {
+                    _src.easeCurve = EditorGUILayout.CurveField("   Ease Curve", _src.easeCurve);
+                }
+                _src.loops = EditorGUILayout.IntField(new GUIContent("Loops", "Set to -1 for infinite loops"), _src.loops);
+                if (_src.loops < -1) _src.loops = -1;
+                if (_src.loops > 1 || _src.loops == -1)
+                    _src.loopType = (LoopType)EditorGUILayout.EnumPopup("   Loop Type", _src.loopType);
+                _src.id = EditorGUILayout.TextField("ID", _src.id);
+
+                bool canBeRelative = true;
+                // End value and eventual specific options
+                switch (_src.animationType) {
+                case DOTweenAnimation.AnimationType.Move:
+                case DOTweenAnimation.AnimationType.LocalMove:
+                    GUIEndValueV3(targetGO, _src.animationType == DOTweenAnimation.AnimationType.Move);
+                    _src.optionalBool0 = EditorGUILayout.Toggle("    Snapping", _src.optionalBool0);
+                    canBeRelative = !_src.useTargetAsV3;
+                    break;
+                case DOTweenAnimation.AnimationType.Rotate:
+                case DOTweenAnimation.AnimationType.LocalRotate:
+                    bool isRigidbody2D = DOTweenModuleUtils.Physics.HasRigidbody2D(_src);
+                    if (isRigidbody2D) GUIEndValueFloat();
+                    else {
+                        GUIEndValueV3(targetGO);
+                        _src.optionalRotationMode = (RotateMode)EditorGUILayout.EnumPopup("    Rotation Mode", _src.optionalRotationMode);
+                    }
+                    break;
+                case DOTweenAnimation.AnimationType.Scale:
+                    if (_src.optionalBool0) GUIEndValueFloat();
+                    else GUIEndValueV3(targetGO);
+                    _src.optionalBool0 = EditorGUILayout.Toggle("Uniform Scale", _src.optionalBool0);
+                    break;
+                case DOTweenAnimation.AnimationType.UIWidthHeight:
+                    if (_src.optionalBool0) GUIEndValueFloat();
+                    else GUIEndValueV2();
+                    _src.optionalBool0 = EditorGUILayout.Toggle("Uniform Scale", _src.optionalBool0);
+                    break;
+                case DOTweenAnimation.AnimationType.Color:
+                    GUIEndValueColor();
+                    canBeRelative = false;
+                    break;
+                case DOTweenAnimation.AnimationType.Fade:
+                    GUIEndValueFloat();
+                    if (_src.endValueFloat < 0) _src.endValueFloat = 0;
+                    if (!_isLightSrc && _src.endValueFloat > 1) _src.endValueFloat = 1;
+                    canBeRelative = false;
+                    break;
+                case DOTweenAnimation.AnimationType.Text:
+                    GUIEndValueString();
+                    _src.optionalBool0 = EditorGUILayout.Toggle("Rich Text Enabled", _src.optionalBool0);
+                    _src.optionalScrambleMode = (ScrambleMode)EditorGUILayout.EnumPopup("Scramble Mode", _src.optionalScrambleMode);
+                    _src.optionalString = EditorGUILayout.TextField(new GUIContent("Custom Scramble", "Custom characters to use in case of ScrambleMode.Custom"), _src.optionalString);
+                    break;
+                case DOTweenAnimation.AnimationType.PunchPosition:
+                case DOTweenAnimation.AnimationType.PunchRotation:
+                case DOTweenAnimation.AnimationType.PunchScale:
+                    GUIEndValueV3(targetGO);
+                    canBeRelative = false;
+                    _src.optionalInt0 = EditorGUILayout.IntSlider(new GUIContent("    Vibrato", "How much will the punch vibrate"), _src.optionalInt0, 1, 50);
+                    _src.optionalFloat0 = EditorGUILayout.Slider(new GUIContent("    Elasticity", "How much the vector will go beyond the starting position when bouncing backwards"), _src.optionalFloat0, 0, 1);
+                    if (_src.animationType == DOTweenAnimation.AnimationType.PunchPosition) _src.optionalBool0 = EditorGUILayout.Toggle("    Snapping", _src.optionalBool0);
+                    break;
+                case DOTweenAnimation.AnimationType.ShakePosition:
+                case DOTweenAnimation.AnimationType.ShakeRotation:
+                case DOTweenAnimation.AnimationType.ShakeScale:
+                    GUIEndValueV3(targetGO);
+                    canBeRelative = false;
+                    _src.optionalInt0 = EditorGUILayout.IntSlider(new GUIContent("    Vibrato", "How much will the shake vibrate"), _src.optionalInt0, 1, 50);
+                    _src.optionalFloat0 = EditorGUILayout.Slider(new GUIContent("    Randomness", "The shake randomness"), _src.optionalFloat0, 0, 90);
+                    if (_src.animationType == DOTweenAnimation.AnimationType.ShakePosition) _src.optionalBool0 = EditorGUILayout.Toggle("    Snapping", _src.optionalBool0);
+                    break;
+                case DOTweenAnimation.AnimationType.CameraAspect:
+                case DOTweenAnimation.AnimationType.CameraFieldOfView:
+                case DOTweenAnimation.AnimationType.CameraOrthoSize:
+                    GUIEndValueFloat();
+                    canBeRelative = false;
+                    break;
+                case DOTweenAnimation.AnimationType.CameraBackgroundColor:
+                    GUIEndValueColor();
+                    canBeRelative = false;
+                    break;
+                case DOTweenAnimation.AnimationType.CameraPixelRect:
+                case DOTweenAnimation.AnimationType.CameraRect:
+                    GUIEndValueRect();
+                    canBeRelative = false;
+                    break;
+                }
+
+                // Final settings
+                if (canBeRelative) _src.isRelative = EditorGUILayout.Toggle("    Relative", _src.isRelative);
+
+                // Events
+                AnimationInspectorGUI.AnimationEvents(this, _src);
+            }
+            EditorGUI.EndDisabledGroup();
+
+            if (GUI.changed) EditorUtility.SetDirty(_src);
+        }
+
+        #endregion
+
+        #region Methods
+
+        // Returns TRUE if the Component layout on the src gameObject changed (a Component was added or removed)
+        bool ComponentsChanged()
+        {
+            int prevTotComponentsOnSrc = _totComponentsOnSrc;
+            _totComponentsOnSrc = _src.gameObject.GetComponents<Component>().Length;
+            return prevTotComponentsOnSrc != _totComponentsOnSrc;
+        }
+
+        // Checks if a Component that can be animated with the given animationType is attached to the src
+        bool Validate(GameObject targetGO)
+        {
+            if (_src.animationType == DOTweenAnimation.AnimationType.None) return false;
+
+            Component srcTarget;
+            // First check for external plugins
+#if false // TK2D_MARKER
+            if (_Tk2dAnimationTypeToComponent.ContainsKey(_src.animationType)) {
+                foreach (Type t in _Tk2dAnimationTypeToComponent[_src.animationType]) {
+                    srcTarget = targetGO.GetComponent(t);
+                    if (srcTarget != null) {
+                        _src.target = srcTarget;
+                        _src.targetType = DOTweenAnimation.TypeToDOTargetType(t);
+                        return true;
+                    }
+                }
+            }
+#endif
+#if false // TEXTMESHPRO_MARKER
+            if (_TMPAnimationTypeToComponent.ContainsKey(_src.animationType)) {
+                foreach (Type t in _TMPAnimationTypeToComponent[_src.animationType]) {
+                    srcTarget = targetGO.GetComponent(t);
+                    if (srcTarget != null) {
+                        _src.target = srcTarget;
+                        _src.targetType = DOTweenAnimation.TypeToDOTargetType(t);
+                        return true;
+                    }
+                }
+            }
+#endif
+            // Then check for regular stuff
+            if (_AnimationTypeToComponent.ContainsKey(_src.animationType)) {
+                foreach (Type t in _AnimationTypeToComponent[_src.animationType]) {
+                    srcTarget = targetGO.GetComponent(t);
+                    if (srcTarget != null) {
+                        _src.target = srcTarget;
+                        _src.targetType = DOTweenAnimation.TypeToDOTargetType(t);
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
+        DOTweenAnimation.AnimationType AnimationToDOTweenAnimationType(string animation)
+        {
+            if (_datString == null) _datString = Enum.GetNames(typeof(DOTweenAnimation.AnimationType));
+            animation = animation.Replace("/", "");
+            return (DOTweenAnimation.AnimationType)(Array.IndexOf(_datString, animation));
+        }
+        int DOTweenAnimationTypeToPopupId(DOTweenAnimation.AnimationType animation)
+        {
+            return Array.IndexOf(_animationTypeNoSlashes, animation.ToString());
+        }
+
+        #endregion
+
+        #region GUI Draw Methods
+
+        void GUIEndValueFloat()
+        {
+            GUILayout.BeginHorizontal();
+            GUIToFromButton();
+            _src.endValueFloat = EditorGUILayout.FloatField(_src.endValueFloat);
+            GUILayout.EndHorizontal();
+        }
+
+        void GUIEndValueColor()
+        {
+            GUILayout.BeginHorizontal();
+            GUIToFromButton();
+            _src.endValueColor = EditorGUILayout.ColorField(_src.endValueColor);
+            GUILayout.EndHorizontal();
+        }
+
+        void GUIEndValueV3(GameObject targetGO, bool optionalTransform = false)
+        {
+            GUILayout.BeginHorizontal();
+            GUIToFromButton();
+            if (_src.useTargetAsV3) {
+                Transform prevT = _src.endValueTransform;
+                _src.endValueTransform = EditorGUILayout.ObjectField(_src.endValueTransform, typeof(Transform), true) as Transform;
+                if (_src.endValueTransform != prevT && _src.endValueTransform != null) {
+#if true // UI_MARKER
+                    // Check that it's a Transform for a Transform or a RectTransform for a RectTransform
+                    if (targetGO.GetComponent<RectTransform>() != null) {
+                        if (_src.endValueTransform.GetComponent<RectTransform>() == null) {
+                            EditorUtility.DisplayDialog("DOTween Pro", "For Unity UI elements, the target must also be a UI element", "Ok");
+                            _src.endValueTransform = null;
+                        }
+                    } else if (_src.endValueTransform.GetComponent<RectTransform>() != null) {
+                        EditorUtility.DisplayDialog("DOTween Pro", "You can't use a UI target for a non UI object", "Ok");
+                        _src.endValueTransform = null;
+                    }
+#endif
+                }
+            } else {
+                _src.endValueV3 = EditorGUILayout.Vector3Field("", _src.endValueV3, GUILayout.Height(16));
+            }
+            if (optionalTransform) {
+                if (GUILayout.Button(_src.useTargetAsV3 ? "target" : "value", EditorGUIUtils.sideBtStyle, GUILayout.Width(44))) _src.useTargetAsV3 = !_src.useTargetAsV3;
+            }
+            GUILayout.EndHorizontal();
+#if true // UI_MARKER
+            if (_src.useTargetAsV3 && _src.endValueTransform != null && _src.target is RectTransform) {
+                EditorGUILayout.HelpBox("NOTE: when using a UI target, the tween will be created during Start instead of Awake", MessageType.Info);
+            }
+#endif
+        }
+
+        void GUIEndValueV2()
+        {
+            GUILayout.BeginHorizontal();
+            GUIToFromButton();
+            _src.endValueV2 = EditorGUILayout.Vector2Field("", _src.endValueV2, GUILayout.Height(16));
+            GUILayout.EndHorizontal();
+        }
+
+        void GUIEndValueString()
+        {
+            GUILayout.BeginHorizontal();
+            GUIToFromButton();
+            _src.endValueString = EditorGUILayout.TextArea(_src.endValueString, EditorGUIUtils.wordWrapTextArea);
+            GUILayout.EndHorizontal();
+        }
+
+        void GUIEndValueRect()
+        {
+            GUILayout.BeginHorizontal();
+            GUIToFromButton();
+            _src.endValueRect = EditorGUILayout.RectField(_src.endValueRect);
+            GUILayout.EndHorizontal();
+        }
+
+        void GUIToFromButton()
+        {
+            if (GUILayout.Button(_src.isFrom ? "FROM" : "TO", EditorGUIUtils.sideBtStyle, GUILayout.Width(90))) _src.isFrom = !_src.isFrom;
+            GUILayout.Space(16);
+        }
+
+        #endregion
+    }
+
+    // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+    // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
+    // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+    [InitializeOnLoad]
+    static class Initializer
+    {
+        static Initializer()
+        {
+            DOTweenAnimation.OnReset += OnReset;
+        }
+
+        static void OnReset(DOTweenAnimation src)
+        {
+            DOTweenSettings settings = DOTweenUtilityWindow.GetDOTweenSettings();
+            if (settings == null) return;
+
+            Undo.RecordObject(src, "DOTweenAnimation");
+            src.autoPlay = settings.defaultAutoPlay == AutoPlay.All || settings.defaultAutoPlay == AutoPlay.AutoPlayTweeners;
+            src.autoKill = settings.defaultAutoKill;
+            EditorUtility.SetDirty(src);
+        }
+    }
+}

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e0203fd81362bab4d842d87ad09ee76e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenPreviewManager.cs

@@ -0,0 +1,263 @@
+// Author: Daniele Giardini - http://www.demigiant.com
+// Created: 2015/03/12 16:03
+
+using System;
+using System.Collections.Generic;
+using DG.DemiEditor;
+using DG.DemiLib;
+using DG.Tweening;
+using DG.Tweening.Core;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace DG.DOTweenEditor
+{
+    public static class DOTweenPreviewManager
+    {
+        static bool _previewOnlyIfSetToAutoPlay = true;
+        static readonly Dictionary<DOTweenAnimation,TweenInfo> _AnimationToTween = new Dictionary<DOTweenAnimation,TweenInfo>();
+        static readonly List<DOTweenAnimation> _TmpKeys = new List<DOTweenAnimation>();
+
+        #region Public Methods & GUI
+
+        /// <summary>
+        /// Returns TRUE if its actually previewing animations
+        /// </summary>
+        public static bool PreviewGUI(DOTweenAnimation src)
+        {
+            if (EditorApplication.isPlaying) return false;
+
+            Styles.Init();
+
+            bool isPreviewing = _AnimationToTween.Count > 0;
+            bool isPreviewingThis = isPreviewing && _AnimationToTween.ContainsKey(src);
+
+            // Preview in editor
+            GUI.backgroundColor = isPreviewing
+                ? new DeSkinColor(new Color(0.49f, 0.8f, 0.86f), new Color(0.15f, 0.26f, 0.35f))
+                : new DeSkinColor(Color.white, new Color(0.13f, 0.13f, 0.13f));
+            GUILayout.BeginVertical(Styles.previewBox);
+            DeGUI.ResetGUIColors();
+            GUILayout.BeginHorizontal();
+            GUILayout.Label("Preview Mode - Experimental", Styles.previewLabel);
+            _previewOnlyIfSetToAutoPlay = DeGUILayout.ToggleButton(
+                _previewOnlyIfSetToAutoPlay,
+                new GUIContent("AutoPlay only", "If toggled only previews animations that have AutoPlay turned ON"),
+                Styles.btOption
+            );
+            GUILayout.EndHorizontal();
+            GUILayout.Space(1);
+            // Preview - Play
+            GUILayout.BeginHorizontal();
+            EditorGUI.BeginDisabledGroup(
+                isPreviewingThis || src.animationType == DOTweenAnimation.AnimationType.None
+                || !src.isActive || _previewOnlyIfSetToAutoPlay && !src.autoPlay
+            );
+            if (GUILayout.Button("► Play", Styles.btPreview)) {
+                if (!isPreviewing) StartupGlobalPreview();
+                AddAnimationToGlobalPreview(src);
+            }
+            EditorGUI.EndDisabledGroup();
+            EditorGUI.BeginDisabledGroup(isPreviewing);
+            if (GUILayout.Button("► Play All <i>on GameObject</i>", Styles.btPreview)) {
+                if (!isPreviewing) StartupGlobalPreview();
+                DOTweenAnimation[] anims = src.gameObject.GetComponents<DOTweenAnimation>();
+                foreach (DOTweenAnimation anim in anims) AddAnimationToGlobalPreview(anim);
+            }
+            if (GUILayout.Button("► Play All <i>in Scene</i>", Styles.btPreview)) {
+                if (!isPreviewing) StartupGlobalPreview();
+                DOTweenAnimation[] anims = Object.FindObjectsOfType<DOTweenAnimation>();
+                foreach (DOTweenAnimation anim in anims) AddAnimationToGlobalPreview(anim);
+            }
+            EditorGUI.EndDisabledGroup();
+            GUILayout.EndHorizontal();
+            // Preview - Stop
+            GUILayout.BeginHorizontal();
+            EditorGUI.BeginDisabledGroup(!isPreviewingThis);
+            if (GUILayout.Button("■ Stop", Styles.btPreview)) {
+                if (_AnimationToTween.ContainsKey(src)) StopPreview(_AnimationToTween[src].tween);
+            }
+            EditorGUI.EndDisabledGroup();
+            EditorGUI.BeginDisabledGroup(!isPreviewing);
+            if (GUILayout.Button("■ Stop All <i>on GameObject</i>", Styles.btPreview)) {
+                StopPreview(src.gameObject);
+            }
+            if (GUILayout.Button("■ Stop All <i>in Scene</i>", Styles.btPreview)) {
+                StopAllPreviews();
+            }
+            EditorGUI.EndDisabledGroup();
+            GUILayout.EndHorizontal();
+            if (isPreviewing) {
+                int playingTweens = 0;
+                int completedTweens = 0;
+                int pausedTweens = 0;
+                foreach (KeyValuePair<DOTweenAnimation, TweenInfo> kvp in _AnimationToTween) {
+                    Tween t = kvp.Value.tween;
+                    if (t.IsPlaying()) playingTweens++;
+                    else if (t.IsComplete()) completedTweens++;
+                    else pausedTweens++;
+                }
+                GUILayout.Label("Playing Tweens: " + playingTweens, Styles.previewStatusLabel);
+                GUILayout.Label("Completed Tweens: " + completedTweens, Styles.previewStatusLabel);
+//                GUILayout.Label("Paused Tweens: " + playingTweens);
+            }
+            GUILayout.EndVertical();
+
+            return isPreviewing;
+        }
+
+#if !(UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5)
+        public static void StopAllPreviews(PlayModeStateChange state)
+        {
+            StopAllPreviews();
+        }
+#endif
+
+        public static void StopAllPreviews()
+        {
+            _TmpKeys.Clear();
+            foreach (KeyValuePair<DOTweenAnimation,TweenInfo> kvp in _AnimationToTween) {
+                _TmpKeys.Add(kvp.Key);
+            }
+            StopPreview(_TmpKeys);
+            _TmpKeys.Clear();
+            _AnimationToTween.Clear();
+
+            DOTweenEditorPreview.Stop();
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5
+            UnityEditor.EditorApplication.playmodeStateChanged -= StopAllPreviews;
+#else
+            UnityEditor.EditorApplication.playModeStateChanged -= StopAllPreviews;
+#endif
+//            EditorApplication.playmodeStateChanged -= StopAllPreviews;
+
+            InternalEditorUtility.RepaintAllViews();
+        }
+
+#endregion
+
+#region Methods
+
+        static void StartupGlobalPreview()
+        {
+            DOTweenEditorPreview.Start();
+#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5
+            UnityEditor.EditorApplication.playmodeStateChanged += StopAllPreviews;
+#else
+            UnityEditor.EditorApplication.playModeStateChanged += StopAllPreviews;
+#endif
+//            EditorApplication.playmodeStateChanged += StopAllPreviews;
+        }
+
+        static void AddAnimationToGlobalPreview(DOTweenAnimation src)
+        {
+            if (!src.isActive) return; // Ignore sources whose tweens have been set to inactive
+            if (_previewOnlyIfSetToAutoPlay && !src.autoPlay) return;
+
+            Tween t = src.CreateEditorPreview();
+            _AnimationToTween.Add(src, new TweenInfo(src, t, src.isFrom));
+            // Tween setup
+            DOTweenEditorPreview.PrepareTweenForPreview(t);
+        }
+
+        static void StopPreview(GameObject go)
+        {
+            _TmpKeys.Clear();
+            foreach (KeyValuePair<DOTweenAnimation,TweenInfo> kvp in _AnimationToTween) {
+                if (kvp.Key.gameObject != go) continue;
+                _TmpKeys.Add(kvp.Key);
+            }
+            StopPreview(_TmpKeys);
+            _TmpKeys.Clear();
+
+            if (_AnimationToTween.Count == 0) StopAllPreviews();
+            else InternalEditorUtility.RepaintAllViews();
+        }
+
+        static void StopPreview(Tween t)
+        {
+            TweenInfo tInfo = null;
+            foreach (KeyValuePair<DOTweenAnimation,TweenInfo> kvp in _AnimationToTween) {
+                if (kvp.Value.tween != t) continue;
+                tInfo = kvp.Value;
+                _AnimationToTween.Remove(kvp.Key);
+                break;
+            }
+            if (tInfo == null) {
+                Debug.LogWarning("DOTween Preview ► Couldn't find tween to stop");
+                return;
+            }
+            if (tInfo.isFrom) {
+                int totLoops = tInfo.tween.Loops();
+                if (totLoops < 0 || totLoops > 1) {
+                    tInfo.tween.Goto(tInfo.tween.Duration(false));
+                } else tInfo.tween.Complete();
+            } else tInfo.tween.Rewind();
+            tInfo.tween.Kill();
+            EditorUtility.SetDirty(tInfo.animation); // Refresh views
+
+            if (_AnimationToTween.Count == 0) StopAllPreviews();
+            else InternalEditorUtility.RepaintAllViews();
+        }
+
+        // Stops while iterating inversely, which deals better with tweens that overwrite each other
+        static void StopPreview(List<DOTweenAnimation> keys)
+        {
+            for (int i = keys.Count - 1; i > -1; --i) {
+                DOTweenAnimation anim = keys[i];
+                TweenInfo tInfo = _AnimationToTween[anim];
+                if (tInfo.isFrom) {
+                    int totLoops = tInfo.tween.Loops();
+                    if (totLoops < 0 || totLoops > 1) {
+                        tInfo.tween.Goto(tInfo.tween.Duration(false));
+                    } else tInfo.tween.Complete();
+                } else tInfo.tween.Rewind();
+                tInfo.tween.Kill();
+                EditorUtility.SetDirty(anim); // Refresh views
+                _AnimationToTween.Remove(anim);
+            }
+        }
+
+#endregion
+
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+        // ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
+        // █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
+
+        class TweenInfo
+        {
+            public DOTweenAnimation animation;
+            public Tween tween;
+            public bool isFrom;
+            public TweenInfo(DOTweenAnimation animation, Tween tween, bool isFrom)
+            {
+                this.animation = animation;
+                this.tween = tween;
+                this.isFrom = isFrom;
+            }
+        }
+
+        static class Styles
+        {
+            static bool _initialized;
+
+            public static GUIStyle previewBox, previewLabel, btOption, btPreview, previewStatusLabel;
+
+            public static void Init()
+            {
+                if (_initialized) return;
+
+                _initialized = true;
+
+                previewBox = new GUIStyle(GUI.skin.box).Clone().Padding(1, 1, 0, 3)
+                    .Background(DeStylePalette.squareBorderCurved_darkBorders).Border(7, 7, 7, 7);
+                previewLabel = new GUIStyle(GUI.skin.label).Clone(10, FontStyle.Bold).Padding(1, 0, 3, 0).Margin(3, 6, 0, 0).StretchWidth(false);
+                btOption = DeGUI.styles.button.bBlankBorderCompact.MarginBottom(2).MarginRight(4);
+                btPreview = EditorStyles.miniButton.Clone(Format.RichText);
+                previewStatusLabel = EditorStyles.miniLabel.Clone().Padding(4, 0, 0, 0).Margin(0);
+            }
+        }
+    }
+}

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenPreviewManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22292a5f27a9a644ba9e6ad1bf863531
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>DOTweenProEditor</name>
+    </assembly>
+    <members>
+        <member name="T:DG.DOTweenEditor.Core.ColorPalette.Custom">
+            <summary>
+            Custom colors
+            </summary>
+        </member>
+        <member name="M:DG.DOTweenEditor.Core.StylePalette.Custom.Init">
+            <summary>
+            Needs to be overridden in order to initialize new styles added from inherited classes
+            </summary>
+        </member>
+    </members>
+</doc>

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 753a4f4ed73b17143923101226957756
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: ee3a420017f129443896310d9fab256b
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: a6402d4311c862b4eb1325590d6466af
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

GQ_Communicate/Assets/Demigiant/DOTweenPro/readme.txt

@@ -0,0 +1,35 @@
+DOTween and DOTween Pro are copyright (c) 2014-2018 Daniele Giardini - Demigiant
+
+// IMPORTANT!!! /////////////////////////////////////////////
+// Upgrading DOTween from versions older than 1.2.000 ///////
+// (or DOTween Pro older than 1.0.000) //////////////////////
+-------------------------------------------------------------
+If you're upgrading your project from a version of DOTween older than 1.2.000 (or DOTween Pro older than 1.0.000) please follow these instructions carefully.
+1) Import the new version in the same folder as the previous one, overwriting old files. A lot of errors will appear but don't worry
+2) Close and reopen Unity (and your project). This is fundamental: skipping this step will cause a bloodbath
+3) Open DOTween's Utility Panel (Tools > Demigiant > DOTween Utility Panel) if it doesn't open automatically, then press "Setup DOTween...": this will run the upgrade setup
+4) From the Add/Remove Modules panel that opens, activate/deactivate Modules for Unity systems and for external assets (like TextMesh Pro)
+
+// GET STARTED //////////////////////////////////////////////
+
+- After importing a new DOTween update, select DOTween's Utility Panel from the "Tools/Demigiant" menu (if it doesn't open automatically) and press the "Setup DOTween..." button to activate/deactivate Modules. You can also access a Preferences Tab from there to choose default settings for DOTween.
+
+// VISUAL SCRIPTING (PRO ONLY)
+- To animate a gameObject, select it and choose "Add Component > DOTween > DOTween Animation"
+- To animate a gameObject along a path, select it and choose "Add Component > DOTween > DOTween Path"
+
+// SCRIPTING
+- In your code, add "using DG.Tweening" to each class where you want to use DOTween.
+- You're ready to tween. Check out the links below for full documentation and license info.
+
+
+// LINKS ///////////////////////////////////////////////////////
+
+DOTween website (documentation, examples, etc): http://dotween.demigiant.com
+DOTween license: http://dotween.demigiant.com/license.php
+DOTween repository (Google Code): https://code.google.com/p/dotween/
+Demigiant website (documentation, examples, etc): http://www.demigiant.com
+
+// NOTES //////////////////////////////////////////////////////
+
+- DOTween's Utility Panel can be found under "Tools > Demigiant > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences