diff --git a/Assets/Editor/SceneToolFloor.cs b/Assets/Editor/SceneToolFloor.cs new file mode 100644 index 0000000..38eb7ca --- /dev/null +++ b/Assets/Editor/SceneToolFloor.cs @@ -0,0 +1,213 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using UnityEngine.AI; +using System.IO; +using System.Text; +using System; + +public class SceneToolFloor +{ + //[MenuItem("SceneTool/SetFloorMessage")]//添加FloorMessage脚本绑定楼层信息 + //public static void SetFloorMessage() + //{ + // Transform neiParent = GameObject.Find("shinei").transform.GetChild(0); + // for (int i = 0; i < neiParent.childCount; i++) + // { + // //Debug.Log(neiParent.GetChild(i).name); + // if (!neiParent.GetChild(i).GetComponent()) + // { + // neiParent.GetChild(i).gameObject.AddComponent(); + // } + // FloorMessage msg = neiParent.GetChild(i).GetComponent(); + // msg.targetTrans = GetTarget(neiParent.GetChild(i)); + // msg.buildNum = neiParent.name; + // if (!neiParent.GetChild(i).name.ToLower().Contains("m")) + // { + // string floornum = neiParent.GetChild(i).name.Substring + // (neiParent.GetChild(i).name.ToLower().IndexOf("nei") + 3/*, neiParent.GetChild(i).name.Length - 4*/); + + // msg.floorNum = int.Parse(floornum); + // msg.interlayerNum = 0; + // } + // else + // { + // msg.floorNum = int.Parse(neiParent.GetChild(i).name.Substring + // (neiParent.GetChild(i).name.ToLower().IndexOf("nei") + 3, neiParent.GetChild(i).name.ToLower().IndexOf("m") + // - neiParent.GetChild(i).name.ToLower().IndexOf("nei") - 4)); + // msg.interlayerNum = int.Parse(neiParent.GetChild(i).name.Substring + // (neiParent.GetChild(i).name.ToLower().IndexOf("m") + 1, neiParent.GetChild(i).name.Length - + // neiParent.GetChild(i).name.ToLower().IndexOf("m") - 1)); + // } + // } + // Transform waiParent = GameObject.Find("shiwai").transform.GetChild(0); + // for (int i = 0; i < waiParent.childCount; i++) + // { + // //Debug.Log(waiParent.GetChild(i).name); + // if (!waiParent.GetChild(i).GetComponent()) + // { + // waiParent.GetChild(i).gameObject.AddComponent(); + // } + // FloorMessage msg = waiParent.GetChild(i).GetComponent(); + // msg.buildNum = waiParent.name; + // if (!waiParent.GetChild(i).name.ToLower().Contains("m")) + // { + // string floornum = waiParent.GetChild(i).name.Substring + // (waiParent.GetChild(i).name.ToLower().IndexOf("wai") + 3/*, waiParent.GetChild(i).name.Length - 4*/); + // msg.floorNum = int.Parse(floornum); + // msg.interlayerNum = 0; + // } + // else + // { + // msg.floorNum = int.Parse(waiParent.GetChild(i).name.Substring + // (waiParent.GetChild(i).name.ToLower().IndexOf("wai") + 4, waiParent.GetChild(i).name.ToLower().IndexOf("m") + // - waiParent.GetChild(i).name.ToLower().IndexOf("wai") - 4)); + // msg.interlayerNum = int.Parse(waiParent.GetChild(i).name.Substring + // (waiParent.GetChild(i).name.ToLower().IndexOf("m") + 1, waiParent.GetChild(i).name.Length - + // waiParent.GetChild(i).name.ToLower().IndexOf("m") - 1)); + // } + // } + //} + //static Transform GetTarget(Transform parent) + //{ + // for (int i = 0; i < parent.childCount; i++) + // { + // if (parent.GetChild(i).name.ToLower().Contains("_floor") + // || parent.GetChild(i).name.ToLower().Contains("-floor") + // ) + // { + // return parent.GetChild(i); + // } + // } + + // return parent; + //} + //[MenuItem("SceneTool/SetNavLayershinei")]//添加寻路层（选中shinei对象设置，注：扶梯情况特殊没有包含） + //public static void SetNavLayer() + //{ + // Transform[] obj = Selection.GetTransforms(SelectionMode.Deep); + // for (int i = 0; i < obj.Length; i++) + // { + // if (obj[i].name.ToLower().Contains("_floor") ||//地面 + // obj[i].name.ToLower().Contains("_floor")) + // { + // Debug.Log(obj[i].name); + // // obj[i].gameObject.layer = LayerMask.NameToLayer("SoldierRoad"); + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // // } + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // // } + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // obj[i].gameObject.GetComponent().gameObjType=CloneObjType.staticGameObject; + // // } + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // // } + // // CloneableEnums enumParent = obj[i].gameObject.GetComponent(); + // // GameObject CarRoad = GameObject.Find("FloorNei"); + // // var CloneableEnums = CarRoad.GetComponent(); + // // enumParent.CloneableTypes = CloneableEnums.CloneableTypes; + // // if (obj[i].parent.GetComponent()) + // // { + // // FloorMessage fmg = obj[i].parent.GetComponent(); + // // obj[i].gameObject.GetComponent().gameObjType = CloneObjType.StaticGameObject; + // // obj[i].gameObject.GetComponent().buildNum = fmg.buildNum; + // // obj[i].gameObject.GetComponent().floorNum = fmg.floorNum; + // // obj[i].gameObject.GetComponent().interlayerNum = fmg.interlayerNum; + // // } + // // if (obj[i].parent.parent.GetComponent()) + // // { + // // FloorMessage fmg = obj[i].parent.parent.GetComponent(); + // // obj[i].gameObject.GetComponent().gameObjType = CloneObjType.StaticGameObject; + // // obj[i].gameObject.GetComponent().buildNum = fmg.buildNum; + // // obj[i].gameObject.GetComponent().floorNum = fmg.floorNum; + // // obj[i].gameObject.GetComponent().interlayerNum = fmg.interlayerNum; + // // } + // //} + // //if (obj[i].name.ToLower().Contains("_wall") ||//墙面 + // // obj[i].name.ToLower().Contains("_wall")) + // //{ + // // obj[i].gameObject.layer = LayerMask.NameToLayer("SoldierRoad"); + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // // } + // // NavMeshModifier mod = obj[i].gameObject.GetComponent(); + // // mod.overrideArea = true; + // // mod.area = 1; + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // // } + // //} + // //if (obj[i].name.ToLower().Contains("lt"))//楼梯 + // //{ + // // obj[i].gameObject.layer = LayerMask.NameToLayer("SoldierRoad"); + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // // } + // // if (!obj[i].gameObject.GetComponent()) + // // { + // // obj[i].gameObject.AddComponent(); + // // } + // } + // } + //} + //[MenuItem("SceneTool/GetNavLayerCarRoad")] + //public static void GetNavLayerCarRoad() + //{ + // Transform[] obj = Selection.GetTransforms(SelectionMode.Deep); + // { + // for (int i = 0; i < obj.Length; i++) + // { + // if (obj[i].gameObject.layer == LayerMask.NameToLayer("CarRoad")) + // { + // // if (!obj[i].gameObject.GetComponent()) + // { + // Debug.Log(obj[i].name); + // } + // } + // } + // } + //} + //[MenuItem("SceneTool/ReadCloneTypes")] + //static void ReadCloneTypes() + //{ + // string path = Application.dataPath + "/Floors.txt"; + // string str = File.ReadAllText(path, Encoding.UTF8); + // string[] EnumStrList = str.Split(','); + // //List EnmuList = new List(); + // //foreach (var item in EnumStrList) + // //{ + // // if (!string.IsNullOrEmpty(item)) + // // { + // // CloneObjType type = (CloneObjType)Enum.Parse(typeof(CloneObjType), item); + // // EnmuList.Add(type); + // // } + // //} + // //GameObject CarRoad = GameObject.Find("FloorNei"); + // //if (!CarRoad.GetComponent()) + // //{ + // // CarRoad.AddComponent(); + // //} + // //var CloneableEnums = CarRoad.GetComponent(); + // //CloneableEnums.CloneableTypes = EnmuList; + //} + //[MenuItem("SceneTool/AddColider")] + //static void AddColider() + //{ + // Transform[] obj = Selection.GetTransforms(SelectionMode.Unfiltered); + // { + // Debug.Log(obj[0].name); + // } + //} +} \ No newline at end of file diff --git a/Assets/Editor/SceneToolFloor.cs.meta b/Assets/Editor/SceneToolFloor.cs.meta new file mode 100644 index 0000000..74d4e15 --- /dev/null +++ b/Assets/Editor/SceneToolFloor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 64783b6d3a93095469a2c37618e659f0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + 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..eee8d76 --- /dev/null +++ b/Assets/Plugins/SmartX1AppX64.dll.meta @@ -0,0 +1,27 @@ +fileFormatVersion: 2 +guid: 5ca7162f4ce085947800aa96363b3551 +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/Plugins/System.Security.dll b/Assets/Plugins/System.Security.dll new file mode 100644 index 0000000..2901130 Binary files /dev/null and b/Assets/Plugins/System.Security.dll differ diff --git a/Assets/Plugins/System.Security.dll.meta b/Assets/Plugins/System.Security.dll.meta new file mode 100644 index 0000000..df5973f --- /dev/null +++ b/Assets/Plugins/System.Security.dll.meta @@ -0,0 +1,33 @@ +fileFormatVersion: 2 +guid: 42d3b95abd582bc42afe2646828af763 +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 + - first: + Windows Store Apps: WindowsStoreApps + second: + enabled: 0 + settings: + CPU: AnyCPU + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/x86_64.meta b/Assets/Plugins/x86_64.meta new file mode 100644 index 0000000..54cde71 --- /dev/null +++ b/Assets/Plugins/x86_64.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 0965f84e7f9c4bb4a9ed42f8334139ed +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Plugins/x86_64/SmartX1App.dll b/Assets/Plugins/x86_64/SmartX1App.dll new file mode 100644 index 0000000..a276833 Binary files /dev/null and b/Assets/Plugins/x86_64/SmartX1App.dll differ diff --git a/Assets/Plugins/x86_64/SmartX1App.dll.meta b/Assets/Plugins/x86_64/SmartX1App.dll.meta new file mode 100644 index 0000000..385ab7d --- /dev/null +++ b/Assets/Plugins/x86_64/SmartX1App.dll.meta @@ -0,0 +1,136 @@ +fileFormatVersion: 2 +guid: b4224153725ef6e468efeab33ad7e553 +timeCreated: 1515718354 +licenseType: Pro +PluginImporter: + serializedVersion: 2 + iconMap: {} + executionOrder: {} + isPreloaded: 0 + isOverridable: 0 + platformData: + data: + first: + '': Any + second: + enabled: 0 + settings: + Exclude Android: 0 + Exclude Editor: 1 + Exclude Linux: 1 + Exclude Linux64: 1 + Exclude LinuxUniversal: 1 + Exclude OSXIntel: 1 + Exclude OSXIntel64: 1 + Exclude OSXUniversal: 1 + Exclude WebGL: 0 + Exclude Win: 1 + Exclude Win64: 1 + data: + first: + '': Editor + second: + enabled: 0 + settings: + CPU: AnyCPU + OS: Windows + data: + first: + Android: Android + second: + enabled: 1 + settings: + CPU: ARMv7 + data: + first: + Any: + second: + enabled: 1 + settings: {} + data: + first: + Editor: Editor + second: + enabled: 0 + settings: + CPU: x86_64 + DefaultValueInitialized: true + data: + first: + Facebook: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + data: + first: + Facebook: Win64 + second: + enabled: 1 + settings: + CPU: AnyCPU + data: + first: + Standalone: Linux + second: + enabled: 0 + settings: + CPU: None + data: + first: + Standalone: Linux64 + second: + enabled: 0 + settings: + CPU: x86_64 + data: + first: + Standalone: LinuxUniversal + second: + enabled: 0 + settings: + CPU: None + data: + first: + Standalone: OSXIntel + second: + enabled: 0 + settings: + CPU: None + data: + first: + Standalone: OSXIntel64 + second: + enabled: 0 + settings: + CPU: AnyCPU + data: + first: + Standalone: OSXUniversal + second: + enabled: 0 + settings: + CPU: None + data: + first: + Standalone: Win + second: + enabled: 0 + settings: + CPU: AnyCPU + data: + first: + Standalone: Win64 + second: + enabled: 0 + settings: + CPU: AnyCPU + data: + first: + WebGL: WebGL + second: + enabled: 1 + settings: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Prefabs/Common/DisasterLibrary/DissaterSetting.prefab b/Assets/Prefabs/Common/DisasterLibrary/DissaterSetting.prefab index ed45a01..f5ab283 100644 --- a/Assets/Prefabs/Common/DisasterLibrary/DissaterSetting.prefab +++ b/Assets/Prefabs/Common/DisasterLibrary/DissaterSetting.prefab @@ -1498,7 +1498,7 @@ GameObject: m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 - m_IsActive: 1 + m_IsActive: 0 --- !u!224 &224479387984022046 RectTransform: m_ObjectHideFlags: 0 @@ -2557,8 +2557,8 @@ RectTransform: m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 1, y: 1} - m_AnchoredPosition: {x: 0, y: 0} - m_SizeDelta: {x: 0, y: 320} + m_AnchoredPosition: {x: 0.00006380459, y: 0.00003049684} + m_SizeDelta: {x: 0, y: 240} m_Pivot: {x: 0, y: 1} --- !u!114 &114792364379617722 MonoBehaviour: @@ -7425,7 +7425,7 @@ RectTransform: m_LocalEulerAnglesHint: {x: 180, y: 0, z: 180} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 265, y: -200} + m_AnchoredPosition: {x: 53, y: -200} m_SizeDelta: {x: 106, y: 80} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &114077331183161620 @@ -8106,7 +8106,7 @@ GameObject: m_Icon: {fileID: 0} m_NavMeshLayer: 0 m_StaticEditorFlags: 0 - m_IsActive: 1 + m_IsActive: 0 --- !u!224 &224453689643152912 RectTransform: m_ObjectHideFlags: 0 @@ -11604,7 +11604,7 @@ RectTransform: m_LocalEulerAnglesHint: {x: 180, y: 0, z: 180} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 159, y: -200} + m_AnchoredPosition: {x: 265, y: -120} m_SizeDelta: {x: 106, y: 80} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &114828467249771398 @@ -15825,7 +15825,7 @@ RectTransform: m_LocalEulerAnglesHint: {x: 180, y: 0, z: 180} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 53, y: -200} + m_AnchoredPosition: {x: 159, y: -120} m_SizeDelta: {x: 106, y: 80} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &114666889020222772 @@ -18188,7 +18188,7 @@ RectTransform: m_Father: {fileID: 224146768237282860} m_RootOrder: 0 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} - m_AnchorMin: {x: 0, y: 0.9999999} + m_AnchorMin: {x: 0, y: 0.99999946} m_AnchorMax: {x: 1, y: 0.9999999} m_AnchoredPosition: {x: 0, y: 0} m_SizeDelta: {x: 20, y: 20} @@ -19439,7 +19439,7 @@ RectTransform: m_LocalEulerAnglesHint: {x: 180, y: 0, z: 180} m_AnchorMin: {x: 0, y: 1} m_AnchorMax: {x: 0, y: 1} - m_AnchoredPosition: {x: 53, y: -280} + m_AnchoredPosition: {x: 159, y: -200} m_SizeDelta: {x: 106, y: 80} m_Pivot: {x: 0.5, y: 0.5} --- !u!114 &114620266658905952 @@ -25426,6 +25426,31 @@ PrefabInstance: propertyPath: m_Pivot.y value: 0.5 objectReference: {fileID: 0} + - target: {fileID: 8509549370938670763, guid: f35e203b6f844c3458c5337e1bbc09c7, + type: 3} + propertyPath: m_AnchorMax.x + value: 0.5 + objectReference: {fileID: 0} + - target: {fileID: 8509549370938670763, guid: f35e203b6f844c3458c5337e1bbc09c7, + type: 3} + propertyPath: m_AnchorMax.y + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 8508462630750896635, guid: f35e203b6f844c3458c5337e1bbc09c7, + type: 3} + propertyPath: m_AnchorMin.x + value: 0.5 + objectReference: {fileID: 0} + - target: {fileID: 8508462630750896635, guid: f35e203b6f844c3458c5337e1bbc09c7, + type: 3} + propertyPath: m_AnchorMax.x + value: 0.5 + objectReference: {fileID: 0} + - target: {fileID: 8508462630750896635, guid: f35e203b6f844c3458c5337e1bbc09c7, + type: 3} + propertyPath: m_AnchorMax.y + value: 1 + objectReference: {fileID: 0} m_RemovedComponents: [] m_SourcePrefab: {fileID: 100100000, guid: f35e203b6f844c3458c5337e1bbc09c7, type: 3} --- !u!224 &224104126818797746 stripped diff --git a/Assets/Scenes/DummyScene.unity b/Assets/Scenes/DummyScene.unity index 308af62..02a44bb 100644 --- a/Assets/Scenes/DummyScene.unity +++ b/Assets/Scenes/DummyScene.unity @@ -13,7 +13,7 @@ OcclusionCullingSettings: --- !u!104 &2 RenderSettings: m_ObjectHideFlags: 0 - serializedVersion: 8 + serializedVersion: 9 m_Fog: 0 m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1} m_FogMode: 3 @@ -39,26 +39,25 @@ RenderSettings: m_CustomReflection: {fileID: 0} m_Sun: {fileID: 0} m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1} + m_UseRadianceAmbientProbe: 0 --- !u!157 &3 LightmapSettings: m_ObjectHideFlags: 0 - serializedVersion: 9 + serializedVersion: 11 m_GIWorkflowMode: 1 m_GISettings: serializedVersion: 2 m_BounceScale: 1 m_IndirectOutputScale: 1 m_AlbedoBoost: 1 - m_TemporalCoherenceThreshold: 1 m_EnvironmentLightingMode: 0 m_EnableBakedLightmaps: 1 m_EnableRealtimeLightmaps: 1 m_LightmapEditorSettings: - serializedVersion: 8 + serializedVersion: 10 m_Resolution: 2 m_BakeResolution: 40 - m_TextureWidth: 1024 - m_TextureHeight: 1024 + m_AtlasSize: 1024 m_AO: 0 m_AOMaxDistance: 1 m_CompAOExponent: 1 @@ -71,23 +70,26 @@ LightmapSettings: m_FinalGatherFiltering: 1 m_FinalGatherRayCount: 256 m_ReflectionCompression: 2 - m_MixedBakeMode: 3 + m_MixedBakeMode: 2 m_BakeBackend: 0 m_PVRSampling: 1 m_PVRDirectSampleCount: 32 m_PVRSampleCount: 500 m_PVRBounces: 2 - m_PVRFiltering: 0 + m_PVRFilterTypeDirect: 0 + m_PVRFilterTypeIndirect: 0 + m_PVRFilterTypeAO: 0 m_PVRFilteringMode: 1 m_PVRCulling: 1 m_PVRFilteringGaussRadiusDirect: 1 m_PVRFilteringGaussRadiusIndirect: 5 m_PVRFilteringGaussRadiusAO: 2 - m_PVRFilteringAtrousColorSigma: 1 - m_PVRFilteringAtrousNormalSigma: 1 - m_PVRFilteringAtrousPositionSigma: 1 + m_PVRFilteringAtrousPositionSigmaDirect: 0.5 + m_PVRFilteringAtrousPositionSigmaIndirect: 2 + m_PVRFilteringAtrousPositionSigmaAO: 1 + m_ShowResolutionOverlay: 1 m_LightingDataAsset: {fileID: 0} - m_ShadowMaskMode: 2 + m_UseShadowmask: 1 --- !u!196 &4 NavMeshSettings: serializedVersion: 2 @@ -107,13 +109,16 @@ NavMeshSettings: manualTileSize: 0 tileSize: 256 accuratePlacement: 0 + debug: + m_Flags: 0 m_NavMeshData: {fileID: 0} --- !u!1 &340961646 GameObject: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} - serializedVersion: 5 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 m_Component: - component: {fileID: 340961648} - component: {fileID: 340961647} @@ -127,8 +132,9 @@ GameObject: --- !u!114 &340961647 MonoBehaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 340961646} m_Enabled: 1 m_EditorHideFlags: 0 @@ -138,8 +144,9 @@ MonoBehaviour: --- !u!4 &340961648 Transform: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 340961646} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 0, z: 0} @@ -148,12 +155,56 @@ Transform: m_Father: {fileID: 0} m_RootOrder: 4 m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1 &546100755 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 546100757} + - component: {fileID: 546100756} + m_Layer: 0 + m_Name: SmartX1 + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &546100756 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 546100755} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: ae7ba88dc2eb0ac428673f57e7adae5e, type: 3} + m_Name: + m_EditorClassIdentifier: +--- !u!4 &546100757 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 546100755} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: -94.06678, y: 0.23535156, z: 32.006668} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 0} + m_RootOrder: 5 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} --- !u!1 &1100379995 GameObject: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} - serializedVersion: 5 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 m_Component: - component: {fileID: 1100379997} - component: {fileID: 1100379996} @@ -167,8 +218,9 @@ GameObject: --- !u!108 &1100379996 Light: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1100379995} m_Enabled: 1 serializedVersion: 8 @@ -194,6 +246,7 @@ Light: serializedVersion: 2 m_Bits: 4294967295 m_Lightmapping: 4 + m_LightShadowCasterMode: 0 m_AreaSize: {x: 1, y: 1} m_BounceIntensity: 1 m_ColorTemperature: 6570 @@ -203,8 +256,9 @@ Light: --- !u!4 &1100379997 Transform: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1100379995} m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261} m_LocalPosition: {x: 0, y: 3, z: 0} @@ -216,9 +270,10 @@ Transform: --- !u!1 &1480189306 GameObject: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} - serializedVersion: 5 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 m_Component: - component: {fileID: 1480189307} - component: {fileID: 1480189308} @@ -234,8 +289,9 @@ GameObject: --- !u!4 &1480189307 Transform: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1480189306} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 564.5, y: 379.28125, z: 0} @@ -247,8 +303,9 @@ Transform: --- !u!114 &1480189308 MonoBehaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1480189306} m_Enabled: 1 m_EditorHideFlags: 0 @@ -258,8 +315,9 @@ MonoBehaviour: --- !u!114 &1480189309 MonoBehaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1480189306} m_Enabled: 1 m_EditorHideFlags: 0 @@ -269,8 +327,9 @@ MonoBehaviour: --- !u!114 &1480189310 MonoBehaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1480189306} m_Enabled: 1 m_EditorHideFlags: 0 @@ -280,9 +339,10 @@ MonoBehaviour: --- !u!1 &1699723576 GameObject: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} - serializedVersion: 5 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 m_Component: - component: {fileID: 1699723578} - component: {fileID: 1699723577} @@ -296,8 +356,9 @@ GameObject: --- !u!114 &1699723577 MonoBehaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1699723576} m_Enabled: 1 m_EditorHideFlags: 0 @@ -307,8 +368,9 @@ MonoBehaviour: --- !u!4 &1699723578 Transform: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1699723576} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 564.5, y: 379.28125, z: 0} @@ -320,9 +382,10 @@ Transform: --- !u!1 &1970330119 GameObject: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} - serializedVersion: 5 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 m_Component: - component: {fileID: 1970330124} - component: {fileID: 1970330123} @@ -340,34 +403,43 @@ GameObject: --- !u!81 &1970330120 AudioListener: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1970330119} m_Enabled: 1 --- !u!124 &1970330121 Behaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1970330119} m_Enabled: 1 --- !u!92 &1970330122 Behaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1970330119} m_Enabled: 1 --- !u!20 &1970330123 Camera: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1970330119} m_Enabled: 1 serializedVersion: 2 m_ClearFlags: 1 m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0} + m_projectionMatrixMode: 1 + m_SensorSize: {x: 36, y: 24} + m_LensShift: {x: 0, y: 0} + m_GateFitMode: 2 + m_FocalLength: 50 m_NormalizedViewPortRect: serializedVersion: 2 x: 0 @@ -389,16 +461,17 @@ Camera: m_TargetEye: 3 m_HDR: 1 m_AllowMSAA: 1 + m_AllowDynamicResolution: 0 m_ForceIntoRT: 0 m_OcclusionCulling: 1 m_StereoConvergence: 10 m_StereoSeparation: 0.022 - m_StereoMirrorMode: 0 --- !u!4 &1970330124 Transform: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1970330119} m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} m_LocalPosition: {x: 0, y: 1, z: -10} @@ -410,8 +483,9 @@ Transform: --- !u!114 &1970330125 MonoBehaviour: m_ObjectHideFlags: 0 - m_PrefabParentObject: {fileID: 0} - m_PrefabInternal: {fileID: 0} + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} m_GameObject: {fileID: 1970330119} m_Enabled: 1 m_EditorHideFlags: 0 diff --git a/Assets/Scripts/SmartX1.meta b/Assets/Scripts/SmartX1.meta new file mode 100644 index 0000000..89ab5d7 --- /dev/null +++ b/Assets/Scripts/SmartX1.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: eae1f933c7e75804cb6fe9ead9b3405b +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/SmartX1/SmartApp.cs b/Assets/Scripts/SmartX1/SmartApp.cs new file mode 100644 index 0000000..afe1b29 --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartApp.cs @@ -0,0 +1,275 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SmartX1Demo +{ + public class SmartApp + { + bool _is64ibt = false; + public SmartApp() + { + if (IntPtr.Size == 4) + _is64ibt = true; + } + public int SmartX1Find(string appID, int[] keyHandles, int[] keyNumber) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1Find(appID, keyHandles, keyNumber); + } + else + { + return SmartX1_X64.SmartX1Find(appID, keyHandles, keyNumber); + } + } + + //open + + public int SmartX1Open(int keyHandle, int uPin1, int uPin2, int uPin3, int uPin4) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1Open(keyHandle, uPin1, uPin2, uPin3, uPin4); + } + else + { + return SmartX1_X64.SmartX1Open(keyHandle, uPin1, uPin2, uPin3, uPin4); + } + } + //close + + + public int SmartX1Close(int keyHandle) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1Close(keyHandle); + } + else + { + return SmartX1_X64.SmartX1Close(keyHandle); + } + } + //checkExist + + + public int SmartX1CheckExist(int keyHandle) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1CheckExist(keyHandle); + } + else + { + return SmartX1_X64.SmartX1CheckExist(keyHandle); + } + } + //getUid + + public int SmartX1GetUid(int keyHandle, StringBuilder uid) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1GetUid(keyHandle, uid); + } + else + { + return SmartX1_X64.SmartX1GetUid(keyHandle, uid); + } + } + //ReadStorage + + public int SmartX1ReadStorage(int keyHandle, int startAddr, int length, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1ReadStorage(keyHandle, startAddr, length, pBuffer); + } + else + { + return SmartX1_X64.SmartX1ReadStorage(keyHandle, startAddr, length, pBuffer); + } + } + //WriteStorage + + public int SmartX1WriteStorage(int keyHandle, int startAddr, int length, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1WriteStorage(keyHandle, startAddr, length, pBuffer); + } + else + { + return SmartX1_X64.SmartX1WriteStorage(keyHandle, startAddr, length, pBuffer); + } + } + //PageLogin + + public int SmartX1PageLogin(int keyHandle, int pageNo, byte[] password, int length) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1PageLogin(keyHandle, pageNo, password, length); + } + else + { + return SmartX1_X64.SmartX1PageLogin(keyHandle, pageNo, password, length); + } + } + //PageLogout + + public int SmartX1PageLogout(int keyHandle, int pageNo) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1PageLogout(keyHandle, pageNo); + } + else + { + return SmartX1_X64.SmartX1PageLogout(keyHandle, pageNo); + } + } + //ReadPage + + public int SmartX1ReadPage(int keyHandle, int pageNo, int startAddr, ref int length, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1ReadPage(keyHandle, pageNo, startAddr, ref length, pBuffer); + } + else + { + return SmartX1_X64.SmartX1ReadPage(keyHandle, pageNo, startAddr, ref length, pBuffer); + } + } + //WritePage + + public int SmartX1WritePage(int keyHandle, int pageNo, int startAddr, int length, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1WritePage(keyHandle, pageNo, startAddr, length, pBuffer); + } + else + { + return SmartX1_X64.SmartX1WritePage(keyHandle, pageNo, startAddr, length, pBuffer); + } + } + //ReadMem + + public int SmartX1ReadMem(int keyHandle, int start, int length, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1ReadMem(keyHandle, start, length, pBuffer); + } + else + { + return SmartX1_X64.SmartX1ReadMem(keyHandle, start, length, pBuffer); + } + } + //WriteMem + + public int SmartX1WriteMem(int keyHandle, int start, int length, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1WriteMem( keyHandle, start, length, pBuffer); + } + else + { + return SmartX1_X64.SmartX1WriteMem(keyHandle, start, length, pBuffer); + } + } + //encrypt + + public int SmartX1TriDesEncrypt(int keyHandle, int buffSize, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1TriDesEncrypt(keyHandle, buffSize, pBuffer); + } + else + { + return SmartX1_X64.SmartX1TriDesEncrypt(keyHandle, buffSize, pBuffer); + } + } + //desDecrypt + + public int SmartX1TriDesDecrypt(int keyHandle, int buffSize, byte[] pBuffer) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1TriDesDecrypt(keyHandle, buffSize, pBuffer); + } + else + { + return SmartX1_X64.SmartX1TriDesDecrypt(keyHandle, buffSize, pBuffer); + } + } + //led + + public int SmartX1Led(int keyHandle, int state) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1Led(keyHandle, state); + } + else + { + return SmartX1_X64.SmartX1Led(keyHandle, state); + } + } + + public int SmartX1PageGetProperty(int keyHandle, int pageNo, int propId, int[] propValue) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1PageGetProperty(keyHandle, pageNo, propId, propValue); + } + else + { + return SmartX1_X64.SmartX1PageGetProperty(keyHandle, pageNo, propId, propValue); + } + } + public int SmartX1GetSoftVersion(int keyHandle, int[] version) + { + if (_is64ibt) + { + return SmartX1_X86.SmartX1GetSoftVersion(keyHandle, version); + } + else + { + return SmartX1_X64.SmartX1GetSoftVersion(keyHandle, version); + } + } + + public string TridesEncrypt(string data, string key, Encoding encoding) + { + + if (_is64ibt) + { + return SmartX1_X86.TridesEncrypt(data, key, encoding); + } + else + { + return SmartX1_X64.TridesEncrypt(data, key, encoding); + } + } + + public string TridesDecEncrypt(byte[] data, string key, Encoding encoding) + { + if (_is64ibt) + { + return SmartX1_X86.TridesDecEncrypt(data, key, encoding); + } + else + { + return SmartX1_X64.TridesDecEncrypt(data, key, encoding); + } + } + + } +} diff --git a/Assets/Scripts/SmartX1/SmartApp.cs.meta b/Assets/Scripts/SmartX1/SmartApp.cs.meta new file mode 100644 index 0000000..676d4ff --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartApp.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0dd22a80b53a7c942a93255e8d8ecc3a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/SmartX1/SmartController.cs b/Assets/Scripts/SmartX1/SmartController.cs new file mode 100644 index 0000000..33c9d9e --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartController.cs @@ -0,0 +1,280 @@ +using UnityEngine; +using System; +using System.Xml; +using System.IO; +using System.Text; + +using System.Security.Cryptography; +using System.Security.Cryptography.Xml; +using System.Collections; + +using SmartX1Demo; + +public class SmartController : MonoBehaviour +{ + int[] keyHandles = new int[8]; + int[] keyNumber = new int[8]; + private int Rtn = 0; + SmartApp smart = new SmartApp(); + private bool IsQuit = false; + + private DateTime t1, t2, t11; + void Start() + { + t2 = DateTime.Now; + t1 = DateTime.Now; + DontDestroyOnLoad(GameObject.Find("SmartX1")); + + tipStyle = new GUIStyle(); + tipStyle.fontSize = 40; + tipStyle.normal.textColor = Color.red; + + original_filepath = Application.streamingAssetsPath + @"/xml/SmartXProject.xml"; + encode_filepath = Application.streamingAssetsPath + @"/xml/enSmartXProject.xml"; + decode_filepath = Application.streamingAssetsPath + @"/xml/deSmartXProject.xml"; + original_filepath2 = Application.streamingAssetsPath + @"/xml/SmartXProject2.xml"; + encode_filepath2 = Application.streamingAssetsPath + @"/xml/enSmartXProject2.xml"; + decode_filepath2 = Application.streamingAssetsPath + @"/xml/deSmartXProject2.xml"; + + appid = ControlXML(original_filepath, encode_filepath, decode_filepath); + appid2 = ControlXML(original_filepath2, encode_filepath2, decode_filepath2); + //appid = GetAppID(original_filepath); + + //检测加密狗是否存在 + FindSmartX1(); + } + string appid = "AXKC"; + string appid2 = "YuAnguanli"; + public string GetAppID(string filepath) + { + //filepath = Application.dataPath + @"/xml/SmartXProject.xml"; + 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; + } + } + } + + } + } + return ""; + } + void FindSmartX1() + { + try + { + Rtn = smart.SmartX1Find(appid, keyHandles, keyNumber); + if (Rtn == 0) + { + return; + } + + Rtn = smart.SmartX1Find(appid2, keyHandles, keyNumber); + if (Rtn == 0) + { + return; + } + IsQuit = true; + t1 = DateTime.Now; + t2 = DateTime.Now; + t11 = DateTime.Now; + + } + catch (Exception ex) + { + Debug.Log("异常" + ex.Message); + Application.Quit(); + } + } + void CheckExist() + { + try + { + Rtn = smart.SmartX1CheckExist(keyHandles[0]); + if (Rtn != 0) + { + IsQuit = true; + } + + if (IsQuit) + { + t1 = DateTime.Now; + t2 = DateTime.Now; + t11 = DateTime.Now; + } + } + catch (Exception ex) + { + Debug.Log("异常" + ex.Message); + Application.Quit(); + } + } + 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("程序退出！"); + 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文件加密解密 + + string ControlXML(string originalFile, string encodeFile, string decodeFile) + { + var id = ""; + if (File.Exists(originalFile))//证明这次是第一次运行该程序，获取当前配置文件 + { + id = GetAppID(originalFile); + fileEncryption(originalFile, encodeFile); + if (File.Exists(encodeFile)) + { + File.Delete(originalFile); + } + } + else + { + if (File.Exists(encodeFile)) + { + fileDcryption(encodeFile, decodeFile); + if (File.Exists(decodeFile)) + { + id = GetAppID(decodeFile); + File.Delete(decodeFile); + } + } + } + //Debug.Log("--------->" + id); + return id; + } + + //加密xml文件 + private void Encrypt(XmlDocument doc, string ElementName, SymmetricAlgorithm key) + { + 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) + { + encryptionMethod = EncryptedXml.XmlEncTripleDESUrl; + } + else if (key is DES) + { + encryptionMethod = EncryptedXml.XmlEncDESUrl; + } + + if (key is Rijndael) + { + switch (key.KeySize) + { + case 128: + encryptionMethod = EncryptedXml.XmlEncAES128Url; + break; + case 192: + encryptionMethod = EncryptedXml.XmlEncAES192Url; + break; + case 256: + encryptionMethod = EncryptedXml.XmlEncAES256Url; + break; + } + } + 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 = ""; + + string original_filepath2 = ""; + string encode_filepath2 = ""; + string decode_filepath2 = ""; + //举例，对某个XML文件加密 + private void fileEncryption(string originalFile, string encodeFile) + { + 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(originalFile);//想要加密的xml文件 + Encrypt(xmldoc, "SmartX1", key);//需要加密的节点 + if (key != null) + { + key.Clear(); + } + xmldoc.Save(encodeFile);//生成加密后的xml文件 + } + //举例，对某个xml文件解密 + private void fileDcryption(string encodeFile, string decodeFile) + { + RijndaelManaged key = new RijndaelManaged(); + byte[] byteKey = Encoding.Unicode.GetBytes("1111111111111111"); + key.Key = byteKey; + XmlDocument xmldoc = new XmlDocument(); + xmldoc.PreserveWhitespace = true; + xmldoc.Load(encodeFile);//加载要解密的xml文件 + Decrypt(xmldoc, key); + if (key != null) + { + key.Clear(); + } + xmldoc.Save(decodeFile);//生成解密后的文件 + } +} diff --git a/Assets/Scripts/SmartX1/SmartController.cs.meta b/Assets/Scripts/SmartX1/SmartController.cs.meta new file mode 100644 index 0000000..3edf859 --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartController.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ae7ba88dc2eb0ac428673f57e7adae5e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/SmartX1/SmartX1Api.cs b/Assets/Scripts/SmartX1/SmartX1Api.cs new file mode 100644 index 0000000..030beb9 --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartX1Api.cs @@ -0,0 +1,214 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Runtime.InteropServices; +using System.Security.Cryptography; + +namespace SmartX1Demo +{ + public class SmartX1_X86 + { + + //注意不要添加.dll后缀 + // Find + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1Find(string appID, int[] keyHandles, int[] keyNumber); + + //open + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1Open(int keyHandle, int uPin1, int uPin2, int uPin3, int uPin4); + //close + + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1Close(int keyHandle); + + //checkExist + + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1CheckExist(int keyHandle); + + //getUid + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1GetUid(int keyHandle, StringBuilder uid); + + //ReadStorage + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1ReadStorage(int keyHandle, int startAddr, int length, byte[] pBuffer); + + //WriteStorage + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1WriteStorage(int keyHandle, int startAddr, int length, byte[] pBuffer); + + //PageLogin + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1PageLogin(int keyHandle, int pageNo, byte[] password, int length); + + //PageLogout + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1PageLogout(int keyHandle, int pageNo); + + //ReadPage + [DllImport("SmartX1App", 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", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1WritePage(int keyHandle, int pageNo, int startAddr, int length, byte[] pBuffer); + + //ReadMem + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1ReadMem(int keyHandle, int start, int length, byte[] pBuffer); + + //WriteMem + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1WriteMem(int keyHandle, int start, int length, byte[] pBuffer); + + //encrypt + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1TriDesEncrypt(int keyHandle, int buffSize, byte[] pBuffer); + + //desDecrypt + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1TriDesDecrypt(int keyHandle, int buffSize, byte[] pBuffer); + + //led + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1Led(int keyHandle, int state); + + + [DllImport("SmartX1App", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1PageGetProperty(int keyHandle, int pageNo, int propId, int[] propValue); + + [DllImport("SmartX1App", 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) + { + TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider(); + des.Key = Encoding.Default.GetBytes(key); + des.Mode = CipherMode.ECB; + + des.Padding = PaddingMode.PKCS7; + + ICryptoTransform DesEncrypt = des.CreateEncryptor(); + byte[] dataBytes = encoding.GetBytes(data); + byte[] outPut = DesEncrypt.TransformFinalBlock(dataBytes, 0, dataBytes.Length); + return Convert.ToBase64String(outPut); + + } + + public static string TridesDecEncrypt(byte[] data, string key, Encoding encoding) + { + TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider(); + des.Key = Encoding.Default.GetBytes(key); + des.Padding = PaddingMode.PKCS7; + des.Mode = CipherMode.ECB; + ICryptoTransform DesDecEncrypt = des.CreateDecryptor(); + byte[] outValue = DesDecEncrypt.TransformFinalBlock(data, 0, data.Length); + return encoding.GetString(outValue); + } + } + + + class SmartX1_X64 + { + // Find + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1Find(string appID, int[] keyHandles, int[] keyNumber); + + //open + [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("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1Close(int keyHandle); + + //checkExist + + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1CheckExist(int keyHandle); + + //getUid + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1GetUid(int keyHandle, StringBuilder uid); + + //ReadStorage + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1ReadStorage(int keyHandle, int startAddr, int length, byte[] pBuffer); + + //WriteStorage + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1WriteStorage(int keyHandle, int startAddr, int length, byte[] pBuffer); + + //PageLogin + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1PageLogin(int keyHandle, int pageNo, byte[] password, int length); + + //PageLogout + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1PageLogout(int keyHandle, int pageNo); + + //ReadPage + [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("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1WritePage(int keyHandle, int pageNo, int startAddr, int length, byte[] pBuffer); + + //ReadMem + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1ReadMem(int keyHandle, int start, int length, byte[] pBuffer); + + //WriteMem + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1WriteMem(int keyHandle, int start, int length, byte[] pBuffer); + + //encrypt + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1TriDesEncrypt(int keyHandle, int buffSize, byte[] pBuffer); + + //desDecrypt + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1TriDesDecrypt(int keyHandle, int buffSize, byte[] pBuffer); + + //led + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1Led(int keyHandle, int state); + + + [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)] + public static extern int SmartX1PageGetProperty(int keyHandle, int pageNo, int propId, int[] propValue); + + [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) + { + TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider(); + des.Key = Encoding.Default.GetBytes(key); + des.Mode = CipherMode.ECB; + + des.Padding = PaddingMode.PKCS7; + + ICryptoTransform DesEncrypt = des.CreateEncryptor(); + byte[] dataBytes = encoding.GetBytes(data); + byte[] outPut = DesEncrypt.TransformFinalBlock(dataBytes, 0, dataBytes.Length); + return Convert.ToBase64String(outPut); + + } + + public static string TridesDecEncrypt(byte[] data, string key, Encoding encoding) + { + TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider(); + des.Key = Encoding.Default.GetBytes(key); + des.Padding = PaddingMode.PKCS7; + des.Mode = CipherMode.ECB; + ICryptoTransform DesDecEncrypt = des.CreateDecryptor(); + byte[] outValue = DesDecEncrypt.TransformFinalBlock(data, 0, data.Length); + return encoding.GetString(outValue); + } + } +} diff --git a/Assets/Scripts/SmartX1/SmartX1Api.cs.meta b/Assets/Scripts/SmartX1/SmartX1Api.cs.meta new file mode 100644 index 0000000..c2b6662 --- /dev/null +++ b/Assets/Scripts/SmartX1/SmartX1Api.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 29d71005b2314cb49b256b33cfcd8fbd +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/StreamingAssets/xml.meta b/Assets/StreamingAssets/xml.meta new file mode 100644 index 0000000..b58daf0 --- /dev/null +++ b/Assets/StreamingAssets/xml.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 871c53a1373720349bb4841eeb3c6fc4 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/StreamingAssets/xml/enSmartXProject.xml b/Assets/StreamingAssets/xml/enSmartXProject.xml new file mode 100644 index 0000000..08a6c80 --- /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..44d6aef --- /dev/null +++ b/Assets/StreamingAssets/xml/enSmartXProject.xml.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: e7af0c1bd47c22b47b39ec0c647de44f +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: