diff --git a/Assets/BaoLiJia.meta b/Assets/BaoLiJia.meta new file mode 100644 index 0000000..6560b59 --- /dev/null +++ b/Assets/BaoLiJia.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 542bce6e7756745439cbcc326e95d36d +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/BaoLiJia/Scene.meta b/Assets/BaoLiJia/Scene.meta new file mode 100644 index 0000000..dd21b61 --- /dev/null +++ b/Assets/BaoLiJia/Scene.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: ced571f55d3952a439071ba30c584839 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/BaoLiJia/Scene/Materials.meta b/Assets/BaoLiJia/Scene/Materials.meta new file mode 100644 index 0000000..344f2b4 --- /dev/null +++ b/Assets/BaoLiJia/Scene/Materials.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c6fd56c4cf5c25546a13f05849f34f9f +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/BaoLiJia/Scene/Materials/shui.mat b/Assets/BaoLiJia/Scene/Materials/shui.mat new file mode 100644 index 0000000..0acae7b --- /dev/null +++ b/Assets/BaoLiJia/Scene/Materials/shui.mat @@ -0,0 +1,78 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: shui + m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0} + m_ShaderKeywords: _ALPHAPREMULTIPLY_ON _DETAIL_MULX2 _NORMALMAP + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 3000 + stringTagMap: + RenderType: Transparent + disabledShaderPasses: [] + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BumpMap: + m_Texture: {fileID: 2800000, guid: 1f3fa1d35b6cef64ca00a0b92c488a80, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailAlbedoMap: + m_Texture: {fileID: 0} + m_Scale: {x: 10, y: 5} + m_Offset: {x: 0, y: 0} + - _DetailMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailNormalMap: + m_Texture: {fileID: 2800000, guid: 1f3fa1d35b6cef64ca00a0b92c488a80, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 20, y: 20} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 0} + m_Scale: {x: 20, y: 20} + m_Offset: {x: 0, y: 0} + - _MetallicGlossMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _OcclusionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ParallaxMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _BumpScale: 1 + - _Cutoff: 0.5 + - _DetailNormalMapScale: 1 + - _DstBlend: 10 + - _GlossMapScale: 1 + - _Glossiness: 0.91 + - _GlossyReflections: 1 + - _Metallic: 0 + - _Mode: 3 + - _OcclusionStrength: 1 + - _Parallax: 0.02 + - _SmoothnessTextureChannel: 0 + - _SpecularHighlights: 1 + - _SrcBlend: 1 + - _UVSec: 0 + - _ZWrite: 0 + m_Colors: + - _Color: {r: 0.2865343, g: 0.44339618, b: 0.43843237, a: 0.35686275} + - _EmissionColor: {r: 0, g: 0, b: 0, a: 0} diff --git a/Assets/BaoLiJia/Scene/Materials/shui.mat.meta b/Assets/BaoLiJia/Scene/Materials/shui.mat.meta new file mode 100644 index 0000000..a4e0a81 --- /dev/null +++ b/Assets/BaoLiJia/Scene/Materials/shui.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: e6b1c013adbb50c4e9326050a2f42e99 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Common/River.meta b/Assets/Common/River.meta new file mode 100644 index 0000000..8c14607 --- /dev/null +++ b/Assets/Common/River.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: f3d16e563c55b574ba4c4f698e9077de +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Common/River/River_Normalmap.png b/Assets/Common/River/River_Normalmap.png new file mode 100644 index 0000000..3e84505 Binary files /dev/null and b/Assets/Common/River/River_Normalmap.png differ diff --git a/Assets/Common/River/River_Normalmap.png.meta b/Assets/Common/River/River_Normalmap.png.meta new file mode 100644 index 0000000..b29fab9 --- /dev/null +++ b/Assets/Common/River/River_Normalmap.png.meta @@ -0,0 +1,132 @@ +fileFormatVersion: 2 +guid: 1f3fa1d35b6cef64ca00a0b92c488a80 +TextureImporter: + fileIDToRecycleName: {} + externalObjects: {} + serializedVersion: 9 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 0 + 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 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: -1 + aniso: 2 + mipBias: -100 + wrapU: -1 + wrapV: -1 + wrapW: -1 + 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: 1 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 8192 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Standalone + maxTextureSize: 8192 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: iPhone + maxTextureSize: 8192 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Android + maxTextureSize: 8192 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: WebGL + maxTextureSize: 8192 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + vertices: [] + indices: + edges: [] + weights: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Freighter/Scene/Materials/River.mat b/Assets/Freighter/Scene/Materials/River.mat index 9d01333..caf08ba 100644 Binary files a/Assets/Freighter/Scene/Materials/River.mat and b/Assets/Freighter/Scene/Materials/River.mat differ diff --git a/Assets/Plugins/SmartX1App.dll.meta b/Assets/Plugins/SmartX1App.dll.meta index 3a084c6..d258105 100644 --- a/Assets/Plugins/SmartX1App.dll.meta +++ b/Assets/Plugins/SmartX1App.dll.meta @@ -1,27 +1,88 @@ fileFormatVersion: 2 guid: 0da92b84a3197f54681e93a2576be223 -timeCreated: 1551513530 -licenseType: Pro PluginImporter: + externalObjects: {} serializedVersion: 2 iconMap: {} executionOrder: {} + defineConstraints: [] isPreloaded: 0 isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 platformData: - data: - first: - Any: - second: - enabled: 1 - settings: {} - data: - first: - Editor: Editor - second: - enabled: 0 - settings: - DefaultValueInitialized: true + - first: + '': Any + second: + enabled: 0 + settings: + Exclude Editor: 1 + Exclude Linux: 0 + Exclude Linux64: 0 + Exclude LinuxUniversal: 0 + Exclude OSXUniversal: 0 + Exclude Win: 0 + Exclude Win64: 0 + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + CPU: AnyCPU + DefaultValueInitialized: true + OS: AnyOS + - first: + Facebook: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Facebook: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + - first: + Standalone: Linux + second: + enabled: 1 + settings: + CPU: x86 + - first: + Standalone: Linux64 + second: + enabled: 1 + settings: + CPU: x86_64 + - first: + Standalone: LinuxUniversal + second: + enabled: 1 + settings: {} + - first: + Standalone: OSXUniversal + second: + enabled: 1 + settings: + CPU: AnyCPU + - first: + Standalone: Win + second: + enabled: 1 + settings: + CPU: AnyCPU + - first: + Standalone: Win64 + second: + enabled: 1 + settings: + CPU: AnyCPU userData: assetBundleName: assetBundleVariant: diff --git a/Assets/Plugins/SmartX1AppX64.dll b/Assets/Plugins/SmartX1AppX64.dll new file mode 100644 index 0000000..a276833 Binary files /dev/null and b/Assets/Plugins/SmartX1AppX64.dll differ diff --git a/Assets/Plugins/SmartX1AppX64.dll.meta b/Assets/Plugins/SmartX1AppX64.dll.meta new file mode 100644 index 0000000..1bdc6e2 --- /dev/null +++ b/Assets/Plugins/SmartX1AppX64.dll.meta @@ -0,0 +1,27 @@ +fileFormatVersion: 2 +guid: 0a982d274fd319c429332954ac197479 +PluginImporter: + externalObjects: {} + serializedVersion: 2 + iconMap: {} + executionOrder: {} + defineConstraints: [] + isPreloaded: 0 + isOverridable: 0 + isExplicitlyReferenced: 0 + validateReferences: 1 + platformData: + - first: + Any: + second: + enabled: 1 + settings: {} + - first: + Editor: Editor + second: + enabled: 0 + settings: + DefaultValueInitialized: true + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scene/StartScene.unity b/Assets/Scene/StartScene.unity index 9f91588..d500fb8 100644 Binary files a/Assets/Scene/StartScene.unity and b/Assets/Scene/StartScene.unity differ diff --git a/Assets/Scripts/HelpScripts/CloneGameObjInfo.cs b/Assets/Scripts/HelpScripts/CloneGameObjInfo.cs index 6763744..3d08836 100644 --- a/Assets/Scripts/HelpScripts/CloneGameObjInfo.cs +++ b/Assets/Scripts/HelpScripts/CloneGameObjInfo.cs @@ -63,25 +63,27 @@ public class CloneGameObjInfo : BaseGameObjInfo } private static void UpdateEnabled(FloorData data, CloneGameObjInfo obj) { - if (obj.floorNum == 0) - { - if (!data.isOn) - { - obj.ShoworHidden = true; - } - else - { - if (data.floorNum > obj.floorNum) - { - obj.ShoworHidden = true; - } - else if (data.floorNum < obj.floorNum) - { - obj.ShoworHidden = false; - } - } - } - else if (data.buildNum == obj.buildNum) + if (string.IsNullOrEmpty(obj.buildNum))//室外物体不隐藏 + return; + //if (obj.floorNum == 0) + //{ + // //if (!data.isOn) + // //{ + // // obj.ShoworHidden = true; + // //} + // //else + // //{ + // // if (data.floorNum > obj.floorNum) + // // { + // obj.ShoworHidden = true; + // // } + // // else if (data.floorNum < obj.floorNum) + // // { + // // obj.ShoworHidden = false; + // // } + // //} + //} + if (data.buildNum == obj.buildNum) { if (!data.isOn) { diff --git a/Assets/Scripts/HelpScripts/CloneObjType.cs b/Assets/Scripts/HelpScripts/CloneObjType.cs index 91dfa0b..e762ad9 100644 --- a/Assets/Scripts/HelpScripts/CloneObjType.cs +++ b/Assets/Scripts/HelpScripts/CloneObjType.cs @@ -480,6 +480,7 @@ public enum CloneObjType /// PowerSupplyCar, #endregion + SpreadFireFrame, } /// /// 根据克隆类型获取中文名称。 diff --git a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs index 88be72e..ad4fba8 100644 --- a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs +++ b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs @@ -37,7 +37,7 @@ public class QuitApplicationManager : MonoSingleton { process.GetMode("assets", ref smart, ref unique, ref validity); if(smart) { - SmartController.Instance.Init(); + // SmartController.Instance.Init(); } else if(validity) { diff --git a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta index a034322..fe590d0 100644 --- a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta +++ b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta @@ -1,8 +1,7 @@ fileFormatVersion: 2 guid: db723300d2c5b00469e43ea91e7cd35f -timeCreated: 1551517212 -licenseType: Pro MonoImporter: + externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 diff --git a/Assets/Scripts/HelpScripts/TransformHelper.cs b/Assets/Scripts/HelpScripts/TransformHelper.cs index 1229cf3..9b9b0a0 100644 --- a/Assets/Scripts/HelpScripts/TransformHelper.cs +++ b/Assets/Scripts/HelpScripts/TransformHelper.cs @@ -1,3 +1,5 @@ +using Newtonsoft.Json; +using System.IO; using UnityEngine; /// @@ -19,7 +21,17 @@ public static class TransformHelper transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, rotationSpeed); } } - + public static string LoadJsonFromConfing(string pathname) + { + + string json = null; + string path = Path.Combine(Application.streamingAssetsPath, pathname); + if (File.Exists(path)) + { + json = File.ReadAllText(path); + } + return JsonConvert.DeserializeObject(json); + } /// /// 查找子物体（递归查找） /// diff --git a/Assets/Scripts/SmartX1/ApplicationClose.cs b/Assets/Scripts/SmartX1/ApplicationClose.cs new file mode 100644 index 0000000..e1fa344 --- /dev/null +++ b/Assets/Scripts/SmartX1/ApplicationClose.cs @@ -0,0 +1,73 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.Events; + +/// +/// 程序关闭提示处理 +/// +public class ApplicationClose : MonoBehaviour +{ + private bool isSure = false;//是否点击确定（退出）按钮 + public string SignOutApi = "/api/Account/SignOut"; + + public bool isSmartX1Exit = false;//是否是检测到没有加密狗而自动退出程序 + + private void Awake() + { + DontDestroyOnLoad(this); + } + + //private void OnApplicationQuit() + //{ + // if (!isSmartX1Exit) + // { + // if (!isSure) + // { + // Application.CancelQuit(); + + // MessageBox.Show("确定退出程序？", + // Sure, + // null + // ); + // } + // } + //} + + //private void Sure() + //{ + // if (!string.IsNullOrEmpty(WebRequestManager.Instance.userName)) + // { + // WebRequestManager.Instance.PostJson(WebRequestManager.Instance.httpUrl + SignOutApi, SignOuted, SignOutError); + // } + // else + // { + // isSure = true; + // Application.Quit(); + // } + //} + + private void SignOuted() + { + isSure = true; + Application.Quit(); + } + + private void SignOutError(int errorCode, string errorMsg) + { + //MessageBox.Show($"退出程序错误：{errorCode},{errorMsg}", 20); + } + + // Start is called before the first frame update + void Start() + { + + } + + // Update is called once per frame + void Update() + { + + } +} diff --git a/Assets/Scripts/SmartX1/ApplicationClose.cs.meta b/Assets/Scripts/SmartX1/ApplicationClose.cs.meta new file mode 100644 index 0000000..d6c0ec7 --- /dev/null +++ b/Assets/Scripts/SmartX1/ApplicationClose.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 037aa7f639e77b14e8c0fe047fcb62e5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/SmartX1/SmartApp.cs.meta b/Assets/Scripts/SmartX1/SmartApp.cs.meta index e77dd21..d40454b 100644 --- a/Assets/Scripts/SmartX1/SmartApp.cs.meta +++ b/Assets/Scripts/SmartX1/SmartApp.cs.meta @@ -1,8 +1,7 @@ fileFormatVersion: 2 -guid: ea8506719ccdade4e9996886ab543d10 -timeCreated: 1515718375 -licenseType: Pro +guid: 1f37c58fbc18d614fb830dd6caea7b71 MonoImporter: + externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 diff --git a/Assets/Scripts/SmartX1/SmartController.cs b/Assets/Scripts/SmartX1/SmartController.cs index f2e77a4..3c09fe9 100644 --- a/Assets/Scripts/SmartX1/SmartController.cs +++ b/Assets/Scripts/SmartX1/SmartController.cs @@ -1,57 +1,68 @@ -using AX.DevelopEngine; -using SmartX1Demo; +using UnityEngine; using System; -using System.Collections; +using System.Xml; using System.IO; +using System.Text; using System.Security.Cryptography; using System.Security.Cryptography.Xml; -using System.Text; -using System.Xml; -using UnityEngine; -using AX.MessageSystem; -using AX.Timer; +using System.Collections; +using SmartX1Demo; -public class SmartController : MonoSingleton { +public class SmartController : MonoBehaviour +{ int[] keyHandles = new int[8]; int[] keyNumber = new int[8]; private int Rtn = 0; SmartApp smart = new SmartApp(); - private Timer timer1_quit, timer2_checkExist; - string appid = ""; + private bool IsQuit = false; + private DateTime t1, t2, t11; + string appid = "AXKC"; - private uint uP1 = 0x987F6BCD, uP2 = 0xE193C5B2, uP3 = 0xD507CC28, uP4 = 0x4B125AF6; + // Use this for initialization + void Start () { + t2 = DateTime.Now; + t1 = DateTime.Now; + DontDestroyOnLoad(GameObject.Find("SmartX1")); + tipStyle = new GUIStyle(); + tipStyle.fontSize = 40; + tipStyle.normal.textColor = Color.red; - public void Init() - { - StartInit(); - } - // Use this for initialization - void StartInit () { - timer1_quit = new Timer(5.0f); - timer1_quit.AddTimeOutEvent(() => - { - //Debug.Log("程序退出！"); - QuitApplicationManager.Instance.SureQuit(); - }); + original_filepath = Application.streamingAssetsPath + @"/xml/SmartXProject.xml"; + encode_filepath = Application.streamingAssetsPath + @"/xml/enSmartXProject.xml"; + decode_filepath = Application.streamingAssetsPath + @"/xml/deSmartXProject.xml"; - string original_filepath = Application.dataPath + @"/xml/SmartXProject.xml"; - //string encode_filepath = Application.dataPath + @"/xml/enSmartXProject.xml"; - //string decode_filepath = Application.dataPath + @"/xml/deSmartXProject.xml"; + ControlXML(); - XmlProcess xmlProcess = new XmlProcess(original_filepath); - xmlProcess.SmartControlXML(ref appid); - if (string.IsNullOrEmpty(appid)) - { - QuitApplication(); - return; - } //检测加密狗是否存在 FindSmartX1(); + } + + public string GetAppID(string filepath) + { + if (File.Exists(filepath)) + { + XmlDocument xmlDoc = new XmlDocument(); + xmlDoc.Load(filepath); + XmlNode root = xmlDoc.SelectSingleNode("SmartX1"); + XmlNodeList nodeList = root.ChildNodes; + foreach (XmlElement elem in nodeList) + { + if (elem.Name == "BaseInfo") + { + foreach (XmlElement zq in elem.ChildNodes) + { + if (zq.Name == "AppID") + { + return zq.InnerText; + } + } + } - timer2_checkExist = new Timer(10.0f); - timer2_checkExist.AddTimeOutEvent(CheckExist); - timer2_checkExist.StartTimerRepeat(); + } + } + return ""; } + bool FindSmartX1() { try @@ -59,8 +70,10 @@ public class SmartController : MonoSingleton { Rtn = smart.SmartX1Find(appid, keyHandles, keyNumber); if (Rtn != 0) { - Debug.Log("SmartX1Find Error,ErrorCode =" + Rtn.ToString()); - QuitApplication(); + IsQuit = true; + t1 = DateTime.Now; + t2 = DateTime.Now; + t11 = DateTime.Now; return false; } Debug.Log("SmartX1Find Successfully"); @@ -70,62 +83,203 @@ public class SmartController : MonoSingleton { { Debug.Log(keyHandles[0]); Debug.Log("异常" + ex.Message); - QuitApplication(); + GameObject.Find("Application").GetComponent().isSmartX1Exit = true; + Application.Quit(); return false; } } - private void QuitApplication() + bool CheckExist() + { + try + { + Rtn = smart.SmartX1CheckExist(keyHandles[0]); + if (Rtn != 0) + { + //Debug.Log("SmartX1 not exist!" + Rtn.ToString()); + IsQuit = true; + t1 = DateTime.Now; + t2 = DateTime.Now; + t11 = DateTime.Now; + return false; + } + //Debug.Log("SmartX1Exist!"); + return true; + } + catch (Exception ex) + { + //Debug.Log(keyHandles[0]); + //Debug.Log("异常" + ex.Message); + GameObject.Find("Application").GetComponent().isSmartX1Exit = true; + Application.Quit(); + return false; + } + } + + private GUIStyle tipStyle; + private int timer = 5; + void OnGUI() + { + if (IsQuit) + { + t2 = DateTime.Now; + if(t2-t11>new TimeSpan(0,0,1)) + { + if(timer>0) + timer--; + t11 = t2; + } + GUI.Label(new Rect(Screen.width / 2 - 150, Screen.height / 2 - 75, 300, 150), "密钥验证失败，程序将在"+timer+"秒后退出！", tipStyle); + + if (t2 - t1 > new TimeSpan(0, 0, 5)) + { + //Debug.Log("程序退出！"); + GameObject.Find("Application").GetComponent().isSmartX1Exit = true; + Application.Quit(); + } + } + } + + // Update is called once per frame + void Update () { + if (IsQuit) + return; + t2 = DateTime.Now; + if (t2 - t1 > new TimeSpan(0, 0, 0, 10, 0)) + { + t1 = t2; + CheckExist(); + } + } + + //xml文件加密解密 + void ControlXML() { - timer1_quit.StartTimer(); + if (File.Exists(original_filepath))//证明这次是第一次运行该程序，获取当前配置文件 + { + appid = GetAppID(original_filepath); + //StartCoroutine(GenerateEncodeXML()); + GenerateEncodeXML1(); + } + else + { + if (File.Exists(encode_filepath)) + { + fileDcryption(encode_filepath); + if (File.Exists(decode_filepath)) + { + appid = GetAppID(decode_filepath); + File.Delete(decode_filepath); + } + } + } } - private void ReadStorage() + IEnumerator GenerateEncodeXML() { - int read_rtn = 0; - byte[] pbuffer = new byte[4096]; + yield return new WaitForSeconds(1.0f); + fileEncryption(original_filepath); + if (File.Exists(encode_filepath)) + { + File.Delete(original_filepath); + } + } - int open_rtn = smart.SmartX1Open(keyHandles[0], (int)uP1, (int)uP2, (int)uP3, (int)uP4); - if (open_rtn == 0)//打开成功 + void GenerateEncodeXML1() + { + fileEncryption(original_filepath); + if (File.Exists(encode_filepath)) { - read_rtn = smart.SmartX1ReadStorage(keyHandles[0], 0, 4096, pbuffer); - string data= Encoding.GetEncoding("gb2312").GetString(pbuffer); - Debug.Log(data); + File.Delete(original_filepath); } } - void CheckExist() + //加密xml文件 + private void Encrypt(XmlDocument doc, string ElementName, SymmetricAlgorithm key) { - try + XmlElement elementEncrypt = doc.GetElementsByTagName(ElementName)[0] as XmlElement; + EncryptedXml eXml = new EncryptedXml(); + byte[] encryptElement = eXml.EncryptData(elementEncrypt, key, false);// + EncryptedData edElement = new EncryptedData(); + edElement.Type = EncryptedXml.XmlEncElementUrl; + string encryptionMethod = null; + + if (key is TripleDES) { - Rtn = smart.SmartX1CheckExist(keyHandles[0]); - if (Rtn != 0) + encryptionMethod = EncryptedXml.XmlEncTripleDESUrl; + } + else if (key is DES) + { + encryptionMethod = EncryptedXml.XmlEncDESUrl; + } + + if (key is Rijndael) + { + switch (key.KeySize) { - Debug.Log("SmartX1 not exist!" + Rtn.ToString()); - QuitApplication(); - return; + case 128: + encryptionMethod = EncryptedXml.XmlEncAES128Url; + break; + case 192: + encryptionMethod = EncryptedXml.XmlEncAES192Url; + break; + case 256: + encryptionMethod = EncryptedXml.XmlEncAES256Url; + break; } - Debug.Log("SmartX1Exist!"); - return; } - catch (Exception ex) + edElement.EncryptionMethod = new EncryptionMethod(encryptionMethod); + edElement.CipherData.CipherValue = encryptElement; + EncryptedXml.ReplaceElement(elementEncrypt, edElement, false); + } + + //XML文件解密 + private void Decrypt(XmlDocument doc, SymmetricAlgorithm Alg) + { + XmlElement encryptedElement = doc.GetElementsByTagName("EncryptedData")[0] as XmlElement; + EncryptedData edElement = new EncryptedData(); + edElement.LoadXml(encryptedElement); + EncryptedXml exml = new EncryptedXml(); + byte[] rgbOutput = exml.DecryptData(edElement, Alg); + exml.ReplaceData(encryptedElement, rgbOutput); + } + + string original_filepath = ""; + string encode_filepath = ""; + string decode_filepath = ""; + + //举例，对某个XML文件加密 + private void fileEncryption(string filename) + { + RijndaelManaged key = new RijndaelManaged(); + //设置密钥：key为32位=数字或字母16个=汉子8个 + byte[] byteKey = Encoding.Unicode.GetBytes("1111111111111111"); + key.Key = byteKey; + XmlDocument xmldoc = new XmlDocument(); + xmldoc.PreserveWhitespace = true; + xmldoc.Load(original_filepath);//想要加密的xml文件 + Encrypt(xmldoc, "SmartX1", key);//需要加密的节点 + if (key != null) { - Debug.Log(keyHandles[0]); - Debug.Log("异常" + ex.Message); - QuitApplication(); - return; + key.Clear(); } + xmldoc.Save(encode_filepath);//生成加密后的xml文件 } - void OnGUI() + + //举例，对某个xml文件解密 + private void fileDcryption(string filename) { - if (timer1_quit.IsTimering) + RijndaelManaged key = new RijndaelManaged(); + byte[] byteKey = Encoding.Unicode.GetBytes("1111111111111111"); + key.Key = byteKey; + XmlDocument xmldoc = new XmlDocument(); + xmldoc.PreserveWhitespace = true; + xmldoc.Load(encode_filepath);//加载要解密的xml文件 + Decrypt(xmldoc, key); + if (key != null) { - QuitApplicationManager.Instance.SetGuiTip("加密狗验证失败，程序将在 " + timer1_quit.GetRemainingTime() + " 秒后退出！"); + key.Clear(); } + xmldoc.Save(decode_filepath);//生成解密后的文件 } - // Update is called once per frame - void Update () { - timer1_quit.UpdateTimer(); - timer2_checkExist.UpdateTimer(); - } } diff --git a/Assets/Scripts/SmartX1/SmartController.cs.meta b/Assets/Scripts/SmartX1/SmartController.cs.meta index e3a5595..ecd5a00 100644 --- a/Assets/Scripts/SmartX1/SmartController.cs.meta +++ b/Assets/Scripts/SmartX1/SmartController.cs.meta @@ -1,8 +1,7 @@ fileFormatVersion: 2 -guid: b7b3bd4e725af2649a00a7c9d90fa7ea -timeCreated: 1495250299 -licenseType: Pro +guid: f77080dba14a37a4abf47c331b296fb0 MonoImporter: + externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 diff --git a/Assets/Scripts/SmartX1/SmartX1.prefab b/Assets/Scripts/SmartX1/SmartX1.prefab new file mode 100644 index 0000000..13f614e --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartX1.prefab @@ -0,0 +1,45 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &8989827126564560699 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2279724216670829176} + - component: {fileID: 6226444345072152341} + m_Layer: 0 + m_Name: SmartX1 + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &2279724216670829176 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8989827126564560699} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!114 &6226444345072152341 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 8989827126564560699} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f77080dba14a37a4abf47c331b296fb0, type: 3} + m_Name: + m_EditorClassIdentifier: diff --git a/Assets/Scripts/SmartX1/SmartX1.prefab.meta b/Assets/Scripts/SmartX1/SmartX1.prefab.meta new file mode 100644 index 0000000..78f51cc --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartX1.prefab.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 5b9fb6e0da36afd4aa32e5d0d18f29f9 +PrefabImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/SmartX1/SmartX1Api.cs b/Assets/Scripts/SmartX1/SmartX1Api.cs index b15ab98..030beb9 100644 --- a/Assets/Scripts/SmartX1/SmartX1Api.cs +++ b/Assets/Scripts/SmartX1/SmartX1Api.cs @@ -114,78 +114,78 @@ namespace SmartX1Demo class SmartX1_X64 { // Find - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1Find(string appID, int[] keyHandles, int[] keyNumber); //open - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1Open(int keyHandle, int uPin1, int uPin2, int uPin3, int uPin4); //close - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1Close(int keyHandle); //checkExist - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1CheckExist(int keyHandle); //getUid - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1GetUid(int keyHandle, StringBuilder uid); //ReadStorage - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1ReadStorage(int keyHandle, int startAddr, int length, byte[] pBuffer); //WriteStorage - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1WriteStorage(int keyHandle, int startAddr, int length, byte[] pBuffer); //PageLogin - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1PageLogin(int keyHandle, int pageNo, byte[] password, int length); //PageLogout - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1PageLogout(int keyHandle, int pageNo); //ReadPage - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1ReadPage(int keyHandle, int pageNo, int startAddr, ref int length, byte[] pBuffer); //WritePage - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1WritePage(int keyHandle, int pageNo, int startAddr, int length, byte[] pBuffer); //ReadMem - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1ReadMem(int keyHandle, int start, int length, byte[] pBuffer); //WriteMem - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1WriteMem(int keyHandle, int start, int length, byte[] pBuffer); //encrypt - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1TriDesEncrypt(int keyHandle, int buffSize, byte[] pBuffer); //desDecrypt - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1TriDesDecrypt(int keyHandle, int buffSize, byte[] pBuffer); //led - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1Led(int keyHandle, int state); - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1PageGetProperty(int keyHandle, int pageNo, int propId, int[] propValue); - [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] public static extern int SmartX1GetSoftVersion(int keyHandle, int[] version); - public static string TridesEncrypt(string data, string key, Encoding encoding) + public static string TridesEncrypt(string data, string key, Encoding encoding) { TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider(); des.Key = Encoding.Default.GetBytes(key); @@ -200,7 +200,7 @@ namespace SmartX1Demo } - public static string TridesDecEncrypt(byte[] data, string key, Encoding encoding) + public static string TridesDecEncrypt(byte[] data, string key, Encoding encoding) { TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider(); des.Key = Encoding.Default.GetBytes(key); diff --git a/Assets/Scripts/SmartX1/SmartX1Api.cs.meta b/Assets/Scripts/SmartX1/SmartX1Api.cs.meta index 64cdfef..ecafac8 100644 --- a/Assets/Scripts/SmartX1/SmartX1Api.cs.meta +++ b/Assets/Scripts/SmartX1/SmartX1Api.cs.meta @@ -1,8 +1,7 @@ fileFormatVersion: 2 -guid: aa527fc755baf7d47ab4c14d9de2a6e8 -timeCreated: 1515718375 -licenseType: Pro +guid: 30969e5b5d02c2a418f4e239698f27a8 MonoImporter: + externalObjects: {} serializedVersion: 2 defaultReferences: [] executionOrder: 0 diff --git a/Assets/Sky/Materials/azure[Sky].mat b/Assets/Sky/Materials/azure[Sky].mat index 31d0eb3..f0f6019 100644 Binary files a/Assets/Sky/Materials/azure[Sky].mat and b/Assets/Sky/Materials/azure[Sky].mat differ diff --git a/Assets/StreamingAssets/xml/enSmartXProject.xml b/Assets/StreamingAssets/xml/enSmartXProject.xml new file mode 100644 index 0000000..916f042 --- /dev/null +++ b/Assets/StreamingAssets/xml/enSmartXProject.xml @@ -0,0 +1,2 @@ + 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 diff --git a/Assets/StreamingAssets/xml/enSmartXProject.xml.meta b/Assets/StreamingAssets/xml/enSmartXProject.xml.meta new file mode 100644 index 0000000..ddb6952 --- /dev/null +++ b/Assets/StreamingAssets/xml/enSmartXProject.xml.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: ebe415df66523c345abd2a1f8c1242d9 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/StreamingAssets/xml/enValidity.xml b/Assets/StreamingAssets/xml/enValidity.xml new file mode 100644 index 0000000..1fd5d96 --- /dev/null +++ b/Assets/StreamingAssets/xml/enValidity.xml @@ -0,0 +1,2 @@ + +DUFEM8pfzviy8H3Qf8hfuxCnO6FnaUoFi10eV7N6Ed6IlMzRrxzzpkpZWXBUD70+TWT62W4Kf7gGvDTlB5sBNDXZLmf4A+gwMqYhMpg9vWr/ksVYiWaP7JdEcIYXEDyQs5gUB18+cs212Kbz/EjbZbJYE5DD+bNg6IWz152YHyT4E1V8NBTXFAwflN10EiNkiY7PWuqpjft/9UR2qBiS0dT7hGA9ru/V1rQLkQ5LIq6nGQG/7Hmydie8mPW5NkSSa9DNVTpQIPbem/vQt1xkiA== \ No newline at end of file diff --git a/Assets/StreamingAssets/xml/enValidity.xml.meta b/Assets/StreamingAssets/xml/enValidity.xml.meta new file mode 100644 index 0000000..6aed170 --- /dev/null +++ b/Assets/StreamingAssets/xml/enValidity.xml.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: b3a2e5a3493e7e14099cb324d9075ae5 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: