From c02e0a69a94369a3937d4ade07ef6a8f56faaec2 Mon Sep 17 00:00:00 2001 From: LeeJu Date: Fri, 22 May 2026 16:31:31 +0800 Subject: [PATCH] add drumming --- drumming/README.md | 21 + drumming/drummer/.gitignore | 11 + drumming/drummer/AppScope/app.json5 | 10 + .../resources/base/element/string.json | 8 + .../resources/base/media/app_icon.png | Bin 0 -> 2041 bytes drumming/drummer/build-profile.json5 | 49 ++ drumming/drummer/entry/.gitignore | 6 + drumming/drummer/entry/build-profile.json5 | 31 + drumming/drummer/entry/hvigorfile.ts | 6 + drumming/drummer/entry/obfuscation-rules.txt | 18 + drumming/drummer/entry/oh-package.json5 | 10 + .../src/main/ets/common/CommonConstant.ets | 38 ++ .../ets/common/customDialog/SetNodeCount.ets | 56 ++ .../common/customDialog/SetNodeNameDialog.ets | 33 + .../main/ets/common/dataStruct/class/Data.ets | 16 + .../main/ets/common/dataStruct/class/Edge.ets | 21 + .../main/ets/common/dataStruct/class/Node.ets | 16 + .../ets/common/dataStruct/class/PathData.ets | 28 + .../ets/common/dataStruct/class/RouteData.ets | 16 + .../ets/common/dataStruct/class/StepData.ets | 8 + .../common/dataStruct/interface/CityInfo.ets | 6 + .../ets/common/dataStruct/interface/Graph.ets | 6 + .../dataStruct/interface/SolutionData.ets | 6 + .../entry/src/main/ets/component/Header.ets | 194 ++++++ .../src/main/ets/component/ImageShow.ets | 96 +++ .../src/main/ets/component/OperateBar.ets | 460 ++++++++++++++ .../main/ets/entryability/EntryAbility.ets | 60 ++ .../entry/src/main/ets/pages/Index.ets | 126 ++++ .../entry/src/main/ets/utils/Logger.ets | 22 + .../src/main/ets/utils/algorithm/TSP.ets | 48 ++ .../main/ets/utils/algorithm/customPath.ets | 574 ++++++++++++++++++ .../ets/utils/functions/createCityInfo.ets | 110 ++++ .../ets/utils/functions/deepCopyGraph.ets | 17 + .../ets/utils/functions/degreesToRadians.ets | 3 + .../src/main/ets/utils/functions/drawEdge.ets | 33 + .../src/main/ets/utils/functions/drawNode.ets | 40 ++ .../main/ets/utils/functions/getRealData.ets | 147 +++++ .../main/ets/utils/functions/showToast.ets | 8 + drumming/drummer/entry/src/main/module.json5 | 49 ++ .../main/resources/base/element/color.json | 8 + .../main/resources/base/element/string.json | 16 + .../src/main/resources/base/media/icon.png | Bin 0 -> 2041 bytes .../main/resources/base/media/startIcon.png | Bin 0 -> 4351 bytes .../resources/base/profile/main_pages.json | 5 + .../main/resources/en_US/element/string.json | 16 + .../main/resources/zh_CN/element/string.json | 16 + .../src/ohosTest/ets/test/Ability.test.ets | 35 ++ .../entry/src/ohosTest/ets/test/List.test.ets | 5 + .../ohosTest/ets/testability/TestAbility.ets | 50 ++ .../ohosTest/ets/testability/pages/Index.ets | 17 + .../ets/testrunner/OpenHarmonyTestRunner.ets | 47 ++ .../drummer/entry/src/ohosTest/module.json5 | 37 ++ .../resources/base/element/color.json | 8 + .../resources/base/element/string.json | 16 + .../ohosTest/resources/base/media/icon.png | Bin 0 -> 6790 bytes .../resources/base/profile/test_pages.json | 5 + drumming/drummer/entry/src/test/List.test.ets | 5 + .../drummer/entry/src/test/LocalUnit.test.ets | 33 + drumming/drummer/hvigor/hvigor-config.json5 | 18 + drumming/drummer/hvigor/hvigor-wrapper.js | 1 + drumming/drummer/hvigorfile.ts | 6 + drumming/drummer/hvigorw | 48 ++ drumming/drummer/hvigorw.bat | 64 ++ drumming/drummer/oh-package-lock.json5 | 13 + drumming/drummer/oh-package.json5 | 12 + drumming/figs/evolution.png | Bin 0 -> 154563 bytes drumming/figs/overall.png | Bin 0 -> 144801 bytes drumming/figs/relation.png | Bin 0 -> 62145 bytes 68 files changed, 2888 insertions(+) create mode 100644 drumming/README.md create mode 100644 drumming/drummer/.gitignore create mode 100644 drumming/drummer/AppScope/app.json5 create mode 100644 drumming/drummer/AppScope/resources/base/element/string.json create mode 100644 drumming/drummer/AppScope/resources/base/media/app_icon.png create mode 100644 drumming/drummer/build-profile.json5 create mode 100644 drumming/drummer/entry/.gitignore create mode 100644 drumming/drummer/entry/build-profile.json5 create mode 100644 drumming/drummer/entry/hvigorfile.ts create mode 100644 drumming/drummer/entry/obfuscation-rules.txt create mode 100644 drumming/drummer/entry/oh-package.json5 create mode 100644 drumming/drummer/entry/src/main/ets/common/CommonConstant.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeCount.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeNameDialog.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/class/Data.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/class/Edge.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/class/Node.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/class/PathData.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/class/RouteData.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/class/StepData.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/interface/CityInfo.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/interface/Graph.ets create mode 100644 drumming/drummer/entry/src/main/ets/common/dataStruct/interface/SolutionData.ets create mode 100644 drumming/drummer/entry/src/main/ets/component/Header.ets create mode 100644 drumming/drummer/entry/src/main/ets/component/ImageShow.ets create mode 100644 drumming/drummer/entry/src/main/ets/component/OperateBar.ets create mode 100644 drumming/drummer/entry/src/main/ets/entryability/EntryAbility.ets create mode 100644 drumming/drummer/entry/src/main/ets/pages/Index.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/Logger.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/algorithm/TSP.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/algorithm/customPath.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/functions/createCityInfo.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/functions/deepCopyGraph.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/functions/degreesToRadians.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/functions/drawEdge.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/functions/drawNode.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/functions/getRealData.ets create mode 100644 drumming/drummer/entry/src/main/ets/utils/functions/showToast.ets create mode 100644 drumming/drummer/entry/src/main/module.json5 create mode 100644 drumming/drummer/entry/src/main/resources/base/element/color.json create mode 100644 drumming/drummer/entry/src/main/resources/base/element/string.json create mode 100644 drumming/drummer/entry/src/main/resources/base/media/icon.png create mode 100644 drumming/drummer/entry/src/main/resources/base/media/startIcon.png create mode 100644 drumming/drummer/entry/src/main/resources/base/profile/main_pages.json create mode 100644 drumming/drummer/entry/src/main/resources/en_US/element/string.json create mode 100644 drumming/drummer/entry/src/main/resources/zh_CN/element/string.json create mode 100644 drumming/drummer/entry/src/ohosTest/ets/test/Ability.test.ets create mode 100644 drumming/drummer/entry/src/ohosTest/ets/test/List.test.ets create mode 100644 drumming/drummer/entry/src/ohosTest/ets/testability/TestAbility.ets create mode 100644 drumming/drummer/entry/src/ohosTest/ets/testability/pages/Index.ets create mode 100644 drumming/drummer/entry/src/ohosTest/ets/testrunner/OpenHarmonyTestRunner.ets create mode 100644 drumming/drummer/entry/src/ohosTest/module.json5 create mode 100644 drumming/drummer/entry/src/ohosTest/resources/base/element/color.json create mode 100644 drumming/drummer/entry/src/ohosTest/resources/base/element/string.json create mode 100644 drumming/drummer/entry/src/ohosTest/resources/base/media/icon.png create mode 100644 drumming/drummer/entry/src/ohosTest/resources/base/profile/test_pages.json create mode 100644 drumming/drummer/entry/src/test/List.test.ets create mode 100644 drumming/drummer/entry/src/test/LocalUnit.test.ets create mode 100644 drumming/drummer/hvigor/hvigor-config.json5 create mode 100644 drumming/drummer/hvigor/hvigor-wrapper.js create mode 100644 drumming/drummer/hvigorfile.ts create mode 100644 drumming/drummer/hvigorw create mode 100644 drumming/drummer/hvigorw.bat create mode 100644 drumming/drummer/oh-package-lock.json5 create mode 100644 drumming/drummer/oh-package.json5 create mode 100644 drumming/figs/evolution.png create mode 100644 drumming/figs/overall.png create mode 100644 drumming/figs/relation.png diff --git a/drumming/README.md b/drumming/README.md new file mode 100644 index 0000000..065a003 --- /dev/null +++ b/drumming/README.md @@ -0,0 +1,21 @@ +# pointgaming +### 1、项目说明 +总体思路：数独程序项目开发的总体思路如图1.1示意，拟实现头部区域，主体区域，右边的内容展示和操作区域等。 + 图1.1 项目开发的总体思路图 + + + +### 2、开发环境说明 +（1）系统版本：OpenHarmony 4.0 Release +（2）SDK版本：API 10 +（3）Model类型：Stage +（4）DevEco Studio版本：Deveco Studio 4.0 release +（5）硬件环境：Unionpi Whale、RK3566开发板 +（6）预览器参数：(1)DeviceType:default;(2)Resolution:560-1280;(3)DPI:240;其余参数自定。 +### 3、项目主要函数调用关系图与项目输出界面演进图 + 图3.1 项目主要函数调用关系图 + + + + 图3.2 项目输出界面演进图 + \ No newline at end of file diff --git a/drumming/drummer/.gitignore b/drumming/drummer/.gitignore new file mode 100644 index 0000000..fbabf77 --- /dev/null +++ b/drumming/drummer/.gitignore @@ -0,0 +1,11 @@ +/node_modules +/oh_modules +/local.properties +/.idea +**/build +/.hvigor +.cxx +/.clangd +/.clang-format +/.clang-tidy +**/.test \ No newline at end of file diff --git a/drumming/drummer/AppScope/app.json5 b/drumming/drummer/AppScope/app.json5 new file mode 100644 index 0000000..3c45fe7 --- /dev/null +++ b/drumming/drummer/AppScope/app.json5 @@ -0,0 +1,10 @@ +{ + "app": { + "bundleName": "com.test.myapplication", + "vendor": "example", + "versionCode": 1000000, + "versionName": "1.0.0", + "icon": "$media:app_icon", + "label": "$string:app_name" + } +} diff --git a/drumming/drummer/AppScope/resources/base/element/string.json b/drumming/drummer/AppScope/resources/base/element/string.json new file mode 100644 index 0000000..7c49b04 --- /dev/null +++ b/drumming/drummer/AppScope/resources/base/element/string.json @@ -0,0 +1,8 @@ +{ + "string": [ + { + "name": "app_name", + "value": "drawpart3" + } + ] +} diff --git a/drumming/drummer/AppScope/resources/base/media/app_icon.png b/drumming/drummer/AppScope/resources/base/media/app_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..cd45accb1dfd2fd0da16c732c72faa6e46b26521 GIT binary patch literal 2041 zcmaJ?c~nzZ9u6@;0AXaYAVN(;Kr(@>EJ+}skOWf=BA~*l4us@ELY9{%0m5QX6pnb} z(jZF|S&pLAS}3BZAfeQSvJ_h>F2Q1PYqi?o5`;m_yjZdG$1v}l_wK#F^L^iMz2}uD z#K$>1dON~kFlWvhW+Jp=tuN9J`ZlM-rl4h+ij|^D0y9;4JOuz-EdVnB6i3R-0ulk9 zApi4zAQA>!N9@-o026$1@L`d124`3G5<@_m`0f)Ug_Ie~;HT2q<_a=HH> zDwTdfD^-cW-|_xWVP$f@93UhDN-#&khZ>jZXLTi~$0`7x3REP6pk%&^2|`c>DutjN zMJD4Zs6Z}{FOpd;*mo2zm(GzXRXiCV;4m3zNCYnu3Fy=i5;2An&Lp!#LP;bRD~1&s z%VH6UY+}r6YDgG+p34OJIZ{BTn&%4s=CT&#TBkuOhdeU@g(w#guoa*b^)73=XyI65 z7Swys6)YS}?1EeZ6b!-I+yCnIya^g0>-NLsLWd8t56GZ_S3r|ZGbR+mV2ErEb9J)X zIF!njY-D-7{qtF2(?nlQ$0}!pzt=}hc*m%%)0Jb#N_K4@IC-`Pi5DahPZN7N9rH;ol;Gc*>-Go@gXKTM{eP)iJj6CYTIi}B#zLKZYD@_;m zrXmXXsFq@~ou-z!9bHoM8*(hwl>X(zm)TDcdkF4lZm$1jP*HbnD`o1$g}_R#+bu2D zr%7Y8KdsaC-V*aem5#@*M%r^GPgu%P2e-BnBClhP2yoGFe40>);=}>{NONtkXQ01p z)OX^t2Ojhddot9eg0WTIVSTNBa}7V-^_pO595w|Hx9q?k4dMp@$G7PK*TD=y;ck6J zdGRB!_RAI2nR3%tO1IkdWp*bw*?<=pM_LZb30?!oK)s;En( z!#nnd9=cXJ<}+e{XLdx(q3&ikJISe?eSHHohk+pz+$6Cv{ytvc{QXmMn2XQ9U8rvt zrJdAn(0gpSD@N=yTrI_2^P#*zQg7MTp1)k(lv(*(KtUR6@M|2WB>2wRwC-h=wk6XF zPtSes*_JwI+^d>xW489MJw5R6=t5?{R zc|E8i?RL@p9)A3ZJAQOg`}+F;<_vnWA!KxR#g%jZ@y_1Qu#Uw)kFPw_xmZ?a^e*1{ zM|ImtqA|(CaDQ@Fyvcof`MN66&VI6m6gAyAXx`%cDx6BI{Bj#}V*Rn1(b~;Am)D2u zX7(027IO?Z2VYK^1vXXpoZ@AtH~N?0rYWwtyA15`6vEf6fk&;o-L;7zFt`5nk*iOy z`<918zB+k;EytI$FAXug)jk*e@e};4e9g__w4A5ev!!)H$yC@{?vsRqJ##X1R%xPG z&_R3oDi$MtTkVqfPj)HEUDx_7wd!y{8#1%$U*Dd0sK@=#6+!XlsE-s^1f5E`R9Wo71^b~mbVdU;Fw0LG~mUQg;xsX4QYRo3B@rH_=ry>DE8ef!c2ta8UcI#26# zF|`*4wtMHe@%#eGZw`#Yj|QWuB`eRD)b~)r9mM95p_JVG%-IdcbIX5qG#GpGD+IrS zEqxb1Rg&Dadk5#7t4j68I1f!@A$efp1?I%&d*56)yl!tkz!14<$0Od_&6cGw$WW0r zjSlQA7l*6;vgfhv!cR|RmAD$+w6j`rVf=-?-D@q>kOseUVSb*~jbAS^*1h?ZL)n(9 zDa}`4etXO6`}9;{k5E^N{rcfnV_(LPwsDg``wtyS*V<19c3!PGJ3Kqy9ksvkwbJ%Z z*N(fT0{e*Wji-Ck5!3YE0j|PZ@&z`v=kitWL$bqSt!e4bH!+(|Q)CZ30^nVPfkx{s zX{6of`p=BiPb@u@IyL!tRk>?qgBqCmo-Zlt!636g?z`s~zdfwuB7DXZHvV`Usp+%Z zo*&;Biu@MHE&2j+?j^o`Cr12u<>vOe=a&8a2hlcmFjJiDR>XnD4c4DAhZWCkiAgW{ E51q9-lK=n! literal 0 HcmV?d00001 diff --git a/drumming/drummer/build-profile.json5 b/drumming/drummer/build-profile.json5 new file mode 100644 index 0000000..f1e6a10 --- /dev/null +++ b/drumming/drummer/build-profile.json5 @@ -0,0 +1,49 @@ +{ + "app": { + "signingConfigs": [ + { + "name": "default", + "material": { + "certpath": "C:\\Users\\cyf20\\.ohos\\config\\openharmony\\auto_ohos_default_drawpart3_com.test.myapplication.cer", + "storePassword": "0000001B112EEEE42E9C65C70B8BE139E9746FD3A593BEC334955CFDC40C11FEB89314E23E845E58F31D6E", + "keyAlias": "debugKey", + "keyPassword": "0000001BACB92E1829CB96E1D19A1D0FD4AF75EC50D07DAACF62C3FB0B8D5EF8E82E944DC0FD8F397E8901", + "profile": "C:\\Users\\cyf20\\.ohos\\config\\openharmony\\auto_ohos_default_drawpart3_com.test.myapplication.p7b", + "signAlg": "SHA256withECDSA", + "storeFile": "C:\\Users\\cyf20\\.ohos\\config\\openharmony\\auto_ohos_default_drawpart3_com.test.myapplication.p12" + } + } + ], + "products": [ + { + "name": "default", + "signingConfig": "default", + "compileSdkVersion": 10, + "compatibleSdkVersion": 10, + "runtimeOS": "OpenHarmony", + } + ], + "buildModeSet": [ + { + "name": "debug", + }, + { + "name": "release" + } + ] + }, + "modules": [ + { + "name": "entry", + "srcPath": "./entry", + "targets": [ + { + "name": "default", + "applyToProducts": [ + "default" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/.gitignore b/drumming/drummer/entry/.gitignore new file mode 100644 index 0000000..e2713a2 --- /dev/null +++ b/drumming/drummer/entry/.gitignore @@ -0,0 +1,6 @@ +/node_modules +/oh_modules +/.preview +/build +/.cxx +/.test \ No newline at end of file diff --git a/drumming/drummer/entry/build-profile.json5 b/drumming/drummer/entry/build-profile.json5 new file mode 100644 index 0000000..197e83c --- /dev/null +++ b/drumming/drummer/entry/build-profile.json5 @@ -0,0 +1,31 @@ +{ + "apiType": "stageMode", + "buildOption": { + "arkOptions": { + // "apPath": "./modules.ap" /* Profile used for profile-guided optimization (PGO), a compiler optimization technique to improve app runtime performance. */ + } + }, + "buildOptionSet": [ + { + "name": "release", + "arkOptions": { + "obfuscation": { + "ruleOptions": { + "enable": true, + "files": [ + "./obfuscation-rules.txt" + ] + } + } + } + }, + ], + "targets": [ + { + "name": "default" + }, + { + "name": "ohosTest", + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/hvigorfile.ts b/drumming/drummer/entry/hvigorfile.ts new file mode 100644 index 0000000..c6edcd9 --- /dev/null +++ b/drumming/drummer/entry/hvigorfile.ts @@ -0,0 +1,6 @@ +import { hapTasks } from '@ohos/hvigor-ohos-plugin'; + +export default { + system: hapTasks, /* Built-in plugin of Hvigor. It cannot be modified. */ + plugins:[] /* Custom plugin to extend the functionality of Hvigor. */ +} diff --git a/drumming/drummer/entry/obfuscation-rules.txt b/drumming/drummer/entry/obfuscation-rules.txt new file mode 100644 index 0000000..985b2ae --- /dev/null +++ b/drumming/drummer/entry/obfuscation-rules.txt @@ -0,0 +1,18 @@ +# Define project specific obfuscation rules here. +# You can include the obfuscation configuration files in the current module's build-profile.json5. +# +# For more details, see +# https://gitee.com/openharmony/arkcompiler_ets_frontend/blob/master/arkguard/README.md + +# Obfuscation options: +# -disable-obfuscation: disable all obfuscations +# -enable-property-obfuscation: obfuscate the property names +# -enable-toplevel-obfuscation: obfuscate the names in the global scope +# -compact: remove unnecessary blank spaces and all line feeds +# -remove-log: remove all console.* statements +# -print-namecache: print the name cache that contains the mapping from the old names to new names +# -apply-namecache: reuse the given cache file + +# Keep options: +# -keep-property-name: specifies property names that you want to keep +# -keep-global-name: specifies names that you want to keep in the global scope \ No newline at end of file diff --git a/drumming/drummer/entry/oh-package.json5 b/drumming/drummer/entry/oh-package.json5 new file mode 100644 index 0000000..225946c --- /dev/null +++ b/drumming/drummer/entry/oh-package.json5 @@ -0,0 +1,10 @@ +{ + "license": "", + "devDependencies": {}, + "author": "", + "name": "entry", + "description": "Please describe the basic information.", + "main": "", + "version": "1.0.0", + "dependencies": {} +} diff --git a/drumming/drummer/entry/src/main/ets/common/CommonConstant.ets b/drumming/drummer/entry/src/main/ets/common/CommonConstant.ets new file mode 100644 index 0000000..bf8cfa3 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/CommonConstant.ets @@ -0,0 +1,38 @@ +/** + * 字体大小(大) + */ +export const BIG_SIZE_FONT = 20 +/** + * 字体大小(小) + */ +export const SMALL_SIZE_FONT = 15 + +//以da yu200屏幕为标准 imageShow组件的左上角和右下角的坐标 +//经过测试在whale RK3588上影响不大 +export const TOP_LEFT_X = 0 +export const TOP_LEFT_Y = 38 +export const BOTTOM_RIGHT_X = 681 +export const BOTTOM_RIGHT_Y = 373 + +//定义绘制节点的大小（vp） +export const DRAW_NODE_SIZE = 40 + +let setting:RenderingContextSettings = new RenderingContextSettings(true) +//绘制未选择/一般情况 +export const NORMAL_CONTEXT: CanvasRenderingContext2D = new CanvasRenderingContext2D(setting) +//绘制选中 +export const SELECTED_CONTEXT: CanvasRenderingContext2D = new CanvasRenderingContext2D(setting) + +export const X_CENTER = (BOTTOM_RIGHT_X - TOP_LEFT_X) / 2 - TOP_LEFT_X +export const Y_CENTER = (BOTTOM_RIGHT_Y - TOP_LEFT_Y) / 2 - TOP_LEFT_Y + +//TODO KEY 用户需要自行更改 +export const KEY = "14a9551d9cdbf6e2ce12768de807a5fe" + +/** + * 程序会默认使用这些预定的城市作为参数调用API以获取数据 然后将其写入文件 + */ +//模拟的城市 +export const CITY = ["广州市","深圳市","珠海市","汕头市","佛山市","韶关市","湛江市","肇庆市","江门市","茂名市","惠州市","梅州市","汕尾市"] +//,"汕头市","佛山市","韶关市","湛江市","肇庆市","江门市","茂名市","惠州市","梅州市","汕尾市" + diff --git a/drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeCount.ets b/drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeCount.ets new file mode 100644 index 0000000..973f954 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeCount.ets @@ -0,0 +1,56 @@ +import { cp } from '../../utils/algorithm/customPath' +import { showToast } from '../../utils/functions/showToast' +import Node from '../dataStruct/class/Node' + +@CustomDialog +export struct setNodeCount{ + controller:CustomDialogController + @State count:number = 0 + @Link Nodes:Array + @Consume refresh:boolean + @Consume isStartToPath:boolean + @Consume nodePathId:Array + build(){ + Column({space:5}){ + Row(){ + Text('设置个数:') + TextInput() + .layoutWeight(1) + .onChange((value)=>{ + this.count = Number(value) + }) + }.width('100%') + Row(){ + Button('确定') + .type(ButtonType.Normal) + .onClick(()=>{ + this.isStartToPath = false + this.nodePathId = [] + if(this.count <= 1 || this.count >= 14){ + showToast("节点数只能位于2至13之间") + return + } + this.Nodes = cp.createNodeData(this.count) + this.refresh = !this.refresh + this.controller.close() + }) + Button('取消') + .type(ButtonType.Normal) + .onClick(()=>{ + this.controller.close() + }) + }.width('100%').justifyContent(FlexAlign.SpaceAround) + }.width('100%').padding(5) + } +} + + + + + + + + + + + diff --git a/drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeNameDialog.ets b/drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeNameDialog.ets new file mode 100644 index 0000000..02e8c87 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/customDialog/SetNodeNameDialog.ets @@ -0,0 +1,33 @@ +import Node from '../dataStruct/class/Node' + +@CustomDialog +export struct setNodeNameDialog{ + controller:CustomDialogController + @ObjectLink node:Node + @State inputName:string = "" + build(){ + Column({space:5}){ + Row(){ + Text('设置名称:') + TextInput() + .layoutWeight(1) + .onChange((value)=>{ + this.inputName = value + }) + }.width('100%') + Row(){ + Button('确定') + .type(ButtonType.Normal) + .onClick(()=>{ + this.node.label = this.inputName + this.controller.close() + }) + Button('取消') + .type(ButtonType.Normal) + .onClick(()=>{ + this.controller.close() + }) + }.width('100%').justifyContent(FlexAlign.SpaceAround) + }.width('100%').padding(5) + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Data.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Data.ets new file mode 100644 index 0000000..1e62267 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Data.ets @@ -0,0 +1,16 @@ +import { RouteData } from './RouteData' + +export class Data{ + status:string + info:string + count:string + route:RouteData + + constructor(status: string, info: string, count: string, route: RouteData) { + this.status = status + this.info = info + this.count = count + this.route = route + } + +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Edge.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Edge.ets new file mode 100644 index 0000000..b78cc8a --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Edge.ets @@ -0,0 +1,21 @@ +export default class Edge { + id: number; // “连接对象编号”：连接线唯一标识，通常是自然数编号 + node1: number; // “节点对象1编号” + node2: number; // “节点对象2编号”：连接线两端节点的编号 + visible: boolean; // “连接是否显示”：表示该连接是否存在 + marked: boolean; // ”连接是否标记“：该连接是否被标记 + label: string; // ”连接标签“：该连接的名字 + distance: number ; // ”连接的距离/成本“ + time: number; // ”连接的时间“ + + constructor(id: number, node1: number, node2: number, visible: boolean, marked: boolean, label: string, distance: number, time: number) { + this.id = id; + this.node1 = node1; + this.node2 = node2; + this.visible = visible; + this.marked = marked; + this.label = label; + this.distance = distance; + this.time = time; + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Node.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Node.ets new file mode 100644 index 0000000..8aa7075 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/Node.ets @@ -0,0 +1,16 @@ +@Observed +export default class Node { + id: number; // “节点编号”：唯一标识一个节点，通常是自然数编号 + label: string; // “节点标签”：节点名称（如城市名） + marked: boolean; // “节点是否标记”：节点是否被标记 + coordinates: [number, number]; // “节点坐标”：节点坐标组 + mustVisit: boolean; // “是否为必经节点”：表示在遍历时是否必经该节点，默认为必经节点 + + constructor(id: number, label: string, marked: boolean, coordinates: [number, number], mustVisit: boolean = true) { + this.id = id; + this.label = label; + this.marked = marked; + this.coordinates = coordinates; + this.mustVisit = mustVisit; + } +} diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/class/PathData.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/PathData.ets new file mode 100644 index 0000000..3aa76f2 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/PathData.ets @@ -0,0 +1,28 @@ +import { StepData } from './StepData' + +export class PathData{ + path:string + distance:string + duration:string + strategy:string + tolls:string + restriction:string + traffic_lights:string + toll_distance:string + steps:Array + + constructor(path: string, distance: string, duration: string, strategy: string, tolls: string, restriction: string, + traffic_lights: string, toll_distance: string, steps: Array) { + this.path = path + this.distance = distance + this.duration = duration + this.strategy = strategy + this.tolls = tolls + this.restriction = restriction + this.traffic_lights = traffic_lights + this.toll_distance = toll_distance + this.steps = steps + } + + +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/class/RouteData.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/RouteData.ets new file mode 100644 index 0000000..80b3524 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/RouteData.ets @@ -0,0 +1,16 @@ +import { PathData } from './PathData' + +export class RouteData{ + origin:string + destination:string + taxi_cost:string + paths:Array + + constructor(origin: string, destination: string, taxi_cost: string, paths: Array) { + this.origin = origin + this.destination = destination + this.taxi_cost = taxi_cost + this.paths = paths + } + +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/class/StepData.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/StepData.ets new file mode 100644 index 0000000..084abff --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/class/StepData.ets @@ -0,0 +1,8 @@ +export class StepData{ + step:string + + constructor(step: string) { + this.step = step + } + +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/CityInfo.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/CityInfo.ets new file mode 100644 index 0000000..8fd1694 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/CityInfo.ets @@ -0,0 +1,6 @@ +interface urbanTransitionCost { + distance: number, + time: number +} + +export type CityInfo = Record>; \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/Graph.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/Graph.ets new file mode 100644 index 0000000..cc16c5d --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/Graph.ets @@ -0,0 +1,6 @@ +export interface nodeInfo { + to: number, + weight: number +} + +export type Graph = Record; \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/SolutionData.ets b/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/SolutionData.ets new file mode 100644 index 0000000..31400eb --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/common/dataStruct/interface/SolutionData.ets @@ -0,0 +1,6 @@ +export interface solutionData{ + count?:number + time:string + path:string + otherPath:Array +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/component/Header.ets b/drumming/drummer/entry/src/main/ets/component/Header.ets new file mode 100644 index 0000000..3762381 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/component/Header.ets @@ -0,0 +1,194 @@ +import { SMALL_SIZE_FONT } from '../common/CommonConstant' +import { setNodeCount } from '../common/customDialog/SetNodeCount' +import Node from '../common/dataStruct/class/Node' +import { solutionData } from '../common/dataStruct/interface/SolutionData' +import { cp } from '../utils/algorithm/customPath' +import { tsp } from '../utils/algorithm/TSP' +import { showToast } from '../utils/functions/showToast' + +@Component +export struct header { + @Link resTime:number + @Link resDistance:number + + @Prop headerContent:Array + @Link curHeaderContentIndex:number + + @Consume Nodes:Array + @Consume refresh: boolean; + @Consume curNodesIndex:number + @Consume isStartToPath:boolean + @Consume solutionData:solutionData + + controller:CustomDialogController = new CustomDialogController({ + builder:setNodeCount({Nodes:$Nodes}) + }) + + @Builder operatorMenu(){ + Menu(){ + MenuItem({content:"随机生成一个TSP问题"}) + .onClick(()=>{ + tsp.createRandomTspProblem(); + this.Nodes = cp.nodes; + this.curHeaderContentIndex = 0 + this.isStartToPath = false + }) + MenuItem({content:"重新更改节点位置"}) + .onClick(()=>{ + cp.regenerate(); + this.refresh = !this.refresh; + this.curHeaderContentIndex = 0 + this.isStartToPath = false + }) + MenuItem({content:"自动求解最优路径-遍历"}) + .onClick(()=>{ + + if (this.Nodes.length <= 10) { + let startNodeId = this.Nodes[this.curNodesIndex].id; + // let result: [number[][], number, number, number] = cp.solveTspInTraversal(startNodeId); + let result: [number[][], number, number, number] = cp.solveTsp(startNodeId, cp.traversalSearchToPath); + let NodeIdsPaths: number[][] = result[0].slice(); + if (!NodeIdsPaths.length) return; + let displayPath: number[] = NodeIdsPaths[0]; // 要展示的最短路径 + let enumPaths: number[][] = NodeIdsPaths.slice(1); // 其余的最短路径 + cp.setDisplayPath(displayPath); + this.refresh = !this.refresh; + let distanceCost: number = result[1]; // 距离成本 + let runtime: number = result[2]; + let runtimeTag: string = ""; // 运行时间的字符串表示，已有单位 + if (runtime == 0) { + runtimeTag = "<0.001s"; + } else { + runtimeTag = runtime.toFixed(3) + "s"; + } + let traversalNum: number = result[3]; // 遍历次数 + cp.createGraph(this.Nodes, false); + let timeCost: number = cp.calculatePathCost(cp.graph, displayPath); // 时间成本 + this.curHeaderContentIndex = 3 + + this.resTime = Number((timeCost / 60).toFixed(0)) + this.resDistance = Number((distanceCost * 1e-3).toFixed(3)) + this.solutionData.count = traversalNum + this.solutionData.time = runtimeTag + this.solutionData.path = "" + this.solutionData.otherPath = [""] + for (let index = 0; index < displayPath.length; index++) { + this.solutionData.path += (this.Nodes[displayPath[index]].label) + if (index != displayPath.length - 1) { + this.solutionData.path += "->"; + } + } + for (let index = 0; index < enumPaths.length; index++) { + for (let i = 0; i < enumPaths[index].length; i++) { + this.solutionData.otherPath[index] += (this.Nodes[enumPaths[index][i]].label) + if (i != enumPaths[index].length - 1) { + this.solutionData.otherPath[index] += "->"; + } + } + } + + } else { + showToast("超过11个节点的遍历法求tsp问题会导致程序崩溃，不建议使用"); + } + }) + MenuItem({content:"自动求解优化路径-贪心"}) + .onClick(()=>{ + + let startNodeId = this.Nodes[this.curNodesIndex].id; + let result: [number[][], number, number, number] = cp.solveTsp(startNodeId, cp.greedySearchToPath); + if (!result[0].length) return; + let displayPath: number[] = result[0][0].slice(); // 要展示的最短路径 + cp.setDisplayPath(displayPath); + this.refresh = !this.refresh; + let distanceCost: number = result[1]; // 距离成本 + let runtime: number = result[2]; + let runtimeTag: string = ""; // 运行时间的字符串表示，已有单位 + if (runtime == 0) { + runtimeTag = "<0.001s"; + } else { + runtimeTag = runtime.toFixed(3) + "s"; + } + cp.createGraph(this.Nodes, false); + let timeCost: number = cp.calculatePathCost(cp.graph, displayPath); // 时间成本 + this.curHeaderContentIndex = 4 + + this.resTime = Number((timeCost / 60).toFixed(0)) + this.resDistance = Number((distanceCost * 1e-3).toFixed(3)) + this.solutionData.time = runtimeTag + this.solutionData.path = "" + for (let index = 0; index < displayPath.length; index++) { + this.solutionData.path += (this.Nodes[displayPath[index]].label) + if (index != displayPath.length - 1) { + this.solutionData.path += "->"; + } + } + }) + MenuItem({content:"检查是否存在路径"}) + .onClick(()=>{ + + let id1:number|undefined = AppStorage.get("startNodeId") + let id2:number|undefined = AppStorage.get("endNodeId") + if(id1 == undefined || id2 == undefined){ + showToast("未选择两个节点，请前往路径操作中去选择两个节点") + return + } + let node1Id: number = id1; + let node2Id: number = id2; + if (cp.graphCheckConnectivity(this.Nodes[node1Id], this.Nodes[node2Id])[0]) { + showToast(`节点${node1Id} (${this.Nodes[node1Id].label})和节点${node2Id} (${this.Nodes[node2Id].label})之间存在路径`); + } else { + showToast(`节点${node1Id} (${this.Nodes[node1Id].label})和节点${node2Id} (${this.Nodes[node2Id].label})之间不存在路径`); + } + }) + }.radius(0) + } + + build() { + Row({space:5}){ + + ForEach(this.headerContent,(item:string,index:number)=>{ + if(index <= 2){ + Text(item) + .fontSize(SMALL_SIZE_FONT) + .fontColor(this.curHeaderContentIndex == index?Color.Red:Color.Black) + .onClick(()=>{ + this.curHeaderContentIndex = index + if(this.curHeaderContentIndex != 2){ + this.isStartToPath = false + } + }) + } + }) + + Blank() + + Row({space:5}){ + Text("节点数目 " + (this.Nodes.length)) + .fontSize(SMALL_SIZE_FONT) + Button('修改') + .width(60).height(25) + .type(ButtonType.Normal) + .onClick(()=>{ + this.controller.open() + }) + } + + Text("时间 " + this.resTime + " 分钟") + .fontSize(SMALL_SIZE_FONT) + + Text("距离(成本) " + this.resDistance+ " 千米") + .fontSize(SMALL_SIZE_FONT) + + Blank() + + Text("TSP问题生成与自动求解") + .onClick(()=>{ + this.isStartToPath = false + }) + .fontSize(SMALL_SIZE_FONT) + .bindMenu(this.operatorMenu) + + }.width('100%').height('100%').padding(5).backgroundColor('#F8F8F8') + + } +} diff --git a/drumming/drummer/entry/src/main/ets/component/ImageShow.ets b/drumming/drummer/entry/src/main/ets/component/ImageShow.ets new file mode 100644 index 0000000..700ec11 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/component/ImageShow.ets @@ -0,0 +1,96 @@ +import { DRAW_NODE_SIZE, NORMAL_CONTEXT, SELECTED_CONTEXT } from '../common/CommonConstant' +import Edge from '../common/dataStruct/class/Edge' +import Node from '../common/dataStruct/class/Node' +import { drawEdgeList } from '../utils/functions/drawEdge' +import { drawNode, drawNodeList } from '../utils/functions/drawNode' +import { showToast } from '../utils/functions/showToast' +import { Logger } from '../utils/Logger' + +@Component +export struct imageShow { + @Consume Nodes:Array + @Consume curNodesIndex:number + @Consume Edges:Array + @Consume refresh:boolean + @Consume isStartToPath:boolean + @Consume nodePathId:Array + @Link curEdgesIndex:number + @Prop loop:string = "100%" + build() { + Stack() { + Canvas(SELECTED_CONTEXT).width('100%').height(this.loop) + .onReady(()=>{ + SELECTED_CONTEXT.beginPath() + SELECTED_CONTEXT.strokeStyle = 'yellow' + SELECTED_CONTEXT.font = '20vp' + drawNode(this.Nodes[this.curNodesIndex],SELECTED_CONTEXT) + }) + Canvas(NORMAL_CONTEXT).width('100%').height(this.loop) + .onReady(()=>{ + NORMAL_CONTEXT.beginPath() + NORMAL_CONTEXT.strokeStyle = 'green' + NORMAL_CONTEXT.fillStyle = 'green' + //绘制线 + drawEdgeList(this.Edges,false) + // drawEdgeList(this.Edges,true) + NORMAL_CONTEXT.font = '15vp' + //绘制点 + drawNodeList(this.Nodes.slice(0,this.curNodesIndex),NORMAL_CONTEXT) + if(this.curNodesIndex == this.Nodes.length - 1){ + return + } + drawNodeList(this.Nodes.slice(this.curNodesIndex + 1,this.Nodes.length),NORMAL_CONTEXT) + }) + .onClick((event:ClickEvent)=>{ + for (let index = 0; index < this.Nodes.length; index++) { + //是否点到节点上 + if(event.x >= this.Nodes[index].coordinates[0] && event.x <= this.Nodes[index].coordinates[0] + DRAW_NODE_SIZE && + event.y >= this.Nodes[index].coordinates[1] && event.y <= this.Nodes[index].coordinates[1] + DRAW_NODE_SIZE){ + //进入到标记模式 + if (this.isStartToPath) { + let i = index + if(this.Nodes[i].marked){ + showToast("不允许选择相同的节点") + }else{ + this.curNodesIndex = index + this.Nodes[this.curNodesIndex].marked = true + this.nodePathId.push(index) + } + }else{ + this.curNodesIndex = index + this.refresh = !this.refresh + } + return + } + } + + for (let index = 0; index < this.Edges.length; index++) { + if(!this.Edges[index].visible){ + continue + } + let x1 = this.Nodes[this.Edges[index].node1].coordinates[0] + DRAW_NODE_SIZE / 2 + let y1 = this.Nodes[this.Edges[index].node1].coordinates[1] + DRAW_NODE_SIZE / 2 + let x2 = this.Nodes[this.Edges[index].node2].coordinates[0] + DRAW_NODE_SIZE / 2 + let y2 = this.Nodes[this.Edges[index].node2].coordinates[1] + DRAW_NODE_SIZE / 2 + + let A = y2 - y1 + let B = x1 - x2 + let C = x2*y1 - x1*y2 + let t1 = A * event.x + B * event.y + C + if(t1 < 0){ + t1 = -t1 + } + let t2 = Math.sqrt((A * A + B * B)) + let d = t1 / t2 + Logger.i("index" + index + "label" + this.Nodes[this.Edges[this.curEdgesIndex].node1].label + this.Nodes[this.Edges[this.curEdgesIndex].node2].label ) + if(d < 3){ + this.curEdgesIndex = index + Logger.i("cur - index" + index) + return + } + } + }) + } + .width('100%').height('100%') + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/component/OperateBar.ets b/drumming/drummer/entry/src/main/ets/component/OperateBar.ets new file mode 100644 index 0000000..9c3d025 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/component/OperateBar.ets @@ -0,0 +1,460 @@ +import { BIG_SIZE_FONT , SMALL_SIZE_FONT } from '../common/CommonConstant' +import { setNodeNameDialog } from '../common/customDialog/SetNodeNameDialog' +import Edge from '../common/dataStruct/class/Edge' +import Node from '../common/dataStruct/class/Node' +import { solutionData } from '../common/dataStruct/interface/SolutionData' +import { cp } from '../utils/algorithm/customPath' +import { showToast } from '../utils/functions/showToast' +import { Logger } from '../utils/Logger' + +@Component +export struct operateBar { + @Prop headerContent:Array + @Link curHeaderContentIndex:number + + @Consume Nodes:Array + @Consume curNodesIndex:number + + build() { + Column(){ + Text(this.headerContent[this.curHeaderContentIndex]) + .fontSize(BIG_SIZE_FONT) + if(this.curHeaderContentIndex == 0){ + nodeOP({selectNode:this.Nodes[this.curNodesIndex]}) + .width('100%').layoutWeight(1) + } + if(this.curHeaderContentIndex == 1){ + linkOP() + .width('100%').layoutWeight(1) + } + if(this.curHeaderContentIndex == 2){ + pathOP() + .width('100%').layoutWeight(1) + } + if(this.curHeaderContentIndex == 3){ + solution_traverse() + } + if(this.curHeaderContentIndex == 4){ + solution_greedy() + } + }.width('100%').height('100%').backgroundColor(Color.Pink) + } +} + +@Component +struct nodeOP { + @Consume Nodes:Array + @Consume curNodesIndex:number + @Consume refresh:boolean + @ObjectLink selectNode:Node + controller:CustomDialogController = new CustomDialogController({ + builder:setNodeNameDialog({node:this.Nodes[this.curNodesIndex]}) + }) + build() { + Column({space:5}){ + Text('当前共有' + this.Nodes.length + "个节点") + .fontSize(SMALL_SIZE_FONT) + Row({space:5}){ + Text('当前节点ID:') + .fontSize(SMALL_SIZE_FONT) + Text(this.selectNode.id.toString()) + .fontSize(SMALL_SIZE_FONT) + }.width('100%') + Row({space:5}){ + Text('当前节点标签:') + .fontSize(SMALL_SIZE_FONT) + Text(this.selectNode.label) + .fontSize(SMALL_SIZE_FONT) + }.width('100%') + Button('设置标签') + .type(ButtonType.Normal) + .fontSize(SMALL_SIZE_FONT) + .onClick(()=>{ + this.controller.open() + }) + Button('删除当前节点') + .type(ButtonType.Normal) + .fontSize(SMALL_SIZE_FONT) + .onClick(()=>{ + if (this.Nodes.length <= 2){ + showToast("节点数不可少于2") + return + } + this.Nodes = cp.deleteNodeData(this.curNodesIndex) + }) + Button('设置为非经过点') + .type(ButtonType.Normal) + .fontSize(SMALL_SIZE_FONT) + .onClick(()=>{ + let c = 0 + for (let index = 0; index < this.Nodes.length; index++) { + if(!this.Nodes[index].mustVisit){ + c++; + } + if(c == 2){ + showToast("最多只能选择两个非经过点") + return + } + } + this.Nodes[this.curNodesIndex].mustVisit = false + this.refresh = !this.refresh + }) + Button('设置为经过点') + .type(ButtonType.Normal) + .fontSize(SMALL_SIZE_FONT) + .onClick(()=>{ + this.Nodes[this.curNodesIndex].mustVisit = true + this.refresh = !this.refresh + }) + Button('增加一个节点') + .type(ButtonType.Normal) + .fontSize(SMALL_SIZE_FONT) + .onClick(()=>{ + if (this.Nodes.length >= 13) { + showToast("节点数只能位于2至13之间") + return + } + this.Nodes = cp.addNodeData() + }) + }.width('100%').height('100%') + } +} + +@Component +struct linkOP { + @Consume Nodes:Array + @Consume curNodesIndex:number + @Consume Edges:Array + @Consume curEdgesIndex:number + + @State isOnClick:boolean = false + @State startNode:Node|undefined = undefined + @State endNode:Node|undefined = undefined + + @Consume refresh:boolean + + build() { + Scroll() { + Column({ space: 5 }) { + Button('建立为完全图') + .type(ButtonType.Normal) + .fontSize(SMALL_SIZE_FONT) + .onClick(() => { + for (let index = 0; index < this.Edges.length; index++) { + this.Edges[index].visible = true + } + this.refresh = !this.refresh + }) + Button('删除所有连接') + .type(ButtonType.Normal) + .fontSize(SMALL_SIZE_FONT) + .onClick(() => { + for (let index = 0; index < this.Edges.length; index++) { + this.Edges[index].visible = false + } + this.refresh = !this.refresh + }) + Column({ space: 5 }) { + Text('当前选中的连接:') + .fontSize(SMALL_SIZE_FONT) + Text(`从 节点${this.Edges[this.curEdgesIndex].node1}:` + this.Nodes[this.Edges[this.curEdgesIndex].node1].label) + .fontSize(SMALL_SIZE_FONT) + Text(`到 节点${this.Edges[this.curEdgesIndex].node2}:` + this.Nodes[this.Edges[this.curEdgesIndex].node2].label) + .fontSize(SMALL_SIZE_FONT) + Text(`距离${(this.Edges[this.curEdgesIndex].distance * 1e-3).toFixed(3)}千米`) + .fontSize(SMALL_SIZE_FONT) + Text(`时间${(this.Edges[this.curEdgesIndex].time / 60).toFixed(0)}分钟`) + .fontSize(SMALL_SIZE_FONT) + }.width('100%') + + Button(this.isOnClick ? "取消" : '选择两个节点进行连接') + .type(ButtonType.Normal) + .onClick(() => { + this.startNode = this.Nodes[this.curNodesIndex] + this.isOnClick = !this.isOnClick + }) + Row({ space: 5 }) { + Text('当前节点:') + .fontSize(SMALL_SIZE_FONT) + Text(this.isOnClick ? this.startNode!.label : this.Nodes[this.curNodesIndex].label) + .fontSize(SMALL_SIZE_FONT) + }.width('100%') + + if (this.isOnClick) { + Row({ space: 5 }) { + Text('要连接节点:') + .fontSize(SMALL_SIZE_FONT) + Text(this.Nodes[this.curNodesIndex].label) + .fontSize(SMALL_SIZE_FONT) + }.width('100%') + + Button('确定') + .type(ButtonType.Normal) + .onClick(() => { + let startNodeId = this.startNode!.id + let endNodeId = this.Nodes[this.curNodesIndex].id + Logger.i(startNodeId + " " + endNodeId) + this.startNode = this.Nodes[this.curNodesIndex] + if (startNodeId == endNodeId) { + showToast("不允许连接同一个节点") + return + } + this.isOnClick = false + cp.connectTwoNodes(startNodeId, endNodeId); + this.refresh = !this.refresh; + }) + } + } + }.width('100%').height('100%').padding({bottom:5}) + } +} + +@Component +struct pathOP { + @Consume Nodes:Array + @Consume curNodesIndex:number + @Consume Edges:Array + @Consume refresh:boolean + @Consume nodePathId:Array + @Consume nodePath:string + @Consume isStartToPath:boolean + @Consume solutionData:solutionData + @State isSelectNode:boolean = false + @State selectIndex:number = 0 + @State index:number = -1 + @State startNode:Node|undefined = undefined + @State endNode:Node|undefined = undefined + @State displayShortPath: boolean = false + + + + build() { + Scroll(){ + Column({space:5}){ + Button(this.isStartToPath?"结束标记":'标记路径') + .type(ButtonType.Normal) + .onClick(()=>{ + if(this.isSelectNode){ + return + } + if(!this.isStartToPath){ + this.nodePathId = [] + } else { + if (!cp.checkPathLegitimate(this.nodePathId)) { + this.nodePathId.length = 0; + cp.clearPath(); + } + } + this.isStartToPath = !this.isStartToPath + + //先置空 + for (let index = 0; index < this.Edges.length; index++) { + this.Edges[index].marked = false + } + for (let index = 0; index < this.Nodes.length; index++) { + this.Nodes[index].marked = false + } + this.refresh = !this.refresh + cp.setDisplayPath(this.nodePathId); + }) + Text('用户指定路径:' + this.nodePath) + .fontSize(SMALL_SIZE_FONT) + .width("100%") + if(this.isStartToPath){ + Row(){ + Button('清除') + .type(ButtonType.Normal) + .onClick(()=>{ + this.nodePathId = [] + cp.clearPath(); + for (let index = 0; index < this.Nodes.length; index++) { + this.Nodes[index].marked = false + } + }) + Button('撤销') + .type(ButtonType.Normal) + .onClick(()=>{ + cp.undoPath(); + if(this.nodePathId.length == 0){ + return + } + this.Nodes[this.nodePathId[this.nodePathId.length-1]].marked = false + this.nodePathId.pop() + return + + }) + }.width('100%').justifyContent(FlexAlign.SpaceEvenly) + Button('检查路径是否合法') + .type(ButtonType.Normal) + .onClick(()=>{ + cp.checkPathLegitimate(this.nodePathId); + }) + } + Button('判断是否为最短路径') + .type(ButtonType.Normal) + .onClick(()=>{ + if(this.isStartToPath){ + return + } + if(this.isSelectNode){ + return + } + if(!this.nodePath.length){ + return + } + if(this.Nodes.length <= 10){ + if (cp.checkUserBest(cp.path, this.nodePathId[0])) { + showToast("当前路径是最短路径"); + } else { + showToast("当前路径不是最短路径"); + } + }else{ + showToast("超过11个节点的遍历法求tsp问题会导致程序崩溃，不建议使用"); + } + + }) + Button('判断是否为贪心路径') + .type(ButtonType.Normal) + .onClick(()=>{ + if(this.isStartToPath){ + return + } + if(this.isSelectNode){ + return + } + if(!this.nodePath.length){ + return + } + if (cp.checkIsGreedy(cp.path, this.nodePathId[0])) { + showToast("当前路径是贪心路径"); + } else { + setTimeout(() => { + showToast("当前路径不是贪心路径"); + }, 2000); + } + }) + Row(){ + Button(this.isSelectNode?"取消":'选择两个节点') + .type(ButtonType.Normal) + .onClick(()=>{ + if(this.isStartToPath){ + return + } + this.isSelectNode = !this.isSelectNode + this.selectIndex = this.curNodesIndex + this.startNode = this.Nodes[this.curNodesIndex] + this.endNode = this.Nodes[this.curNodesIndex] + this.index = -1 + this.displayShortPath = false; + this.solutionData.path = ""; + this.solutionData.count = 0; + this.Nodes.forEach(node => { + node.mustVisit = true; + }) + this.refresh = !this.refresh; + }) + if(this.isSelectNode){ + Button("确定") + .type(ButtonType.Normal) + .onClick(()=>{ + if(this.curNodesIndex == this.startNode!.id){ + showToast("不能选择相同的节点") + return + } + if (!cp.graphCheckConnectivity(this.Nodes[this.curNodesIndex], this.Nodes[this.startNode!.id])[0]) { + showToast("节点间不可达，请重新选择节点"); + return; + } + if(this.index != -1){ + return + } + this.endNode = this.Nodes[this.curNodesIndex] + this.index = this.curNodesIndex + AppStorage.setOrCreate("startNodeId",this.startNode!.id) + AppStorage.setOrCreate("endNodeId",this.endNode!.id) + }) + } + } + Text(`当前节点1ID:${this.isSelectNode?this.selectIndex + `(${this.Nodes[this.selectIndex].label})`:this.curNodesIndex + `(${this.Nodes[this.curNodesIndex].label})`}`) + .fontSize(SMALL_SIZE_FONT) + if(this.isSelectNode){ + Text(`当前节点2ID:${this.index != -1?this.index + `(${this.Nodes[this.index].label})`:this.curNodesIndex + `(${this.Nodes[this.curNodesIndex].label})`}`) + .fontSize(SMALL_SIZE_FONT) + Button('求解最短路径') + .type(ButtonType.Normal) + .onClick(()=>{ + this.displayShortPath = false; + this.solutionData.path = ""; + this.solutionData.count = 0; + if(this.endNode != undefined){ + if(this.endNode!.id != this.startNode!.id){ + let shortPathInfo: [number[], number] = cp.shortestPathAlgorithm(this.startNode!.id, this.endNode!.id); + let shortPath: number[] = shortPathInfo[0]; + this.solutionData.count = Number((shortPathInfo[1] * 1e-3).toFixed(3)); + for (let index = 0; index < shortPath.length; index++) { + this.solutionData.path += (this.Nodes[shortPath[index]].label) + if (index != shortPath.length - 1) { + this.solutionData.path += "->"; + } + } + if (this.solutionData.path != "") { + this.displayShortPath = true; + } else { + showToast("没有找到路径"); + } + return; + } + } + showToast("请选择第二个节点,或点击确定") + }) + if (this.displayShortPath) { + Text('最短路径长度:' + this.solutionData.count + "km") + .fontSize(SMALL_SIZE_FONT) + .width("100%") + Text('最短路径为:' + this.solutionData.path) + .fontSize(SMALL_SIZE_FONT) + .width("100%") + } + } + } + }.width('100%').height('100%').padding({bottom:5}) + } +} + +@Component +struct solution_traverse { + @Consume solutionData:solutionData + build() { + Column({space:5}){ + Text('遍历次数' + this.solutionData.count!) + .fontSize(SMALL_SIZE_FONT) + Text('求解花费时间' + this.solutionData.time) + .fontSize(SMALL_SIZE_FONT) + Text('最短路径:' + this.solutionData.path) + .fontSize(SMALL_SIZE_FONT) + .width("100%") + ForEach(this.solutionData.otherPath,(item:string,index:number)=>{ + Row(){ + Text('其他最短路径' + (index + 1) + ": " + item) + .fontSize(SMALL_SIZE_FONT) + }.width('100%') + }) + }.width('100%').height('100%') + } +} + +@Component +struct solution_greedy{ + + @Consume solutionData:solutionData + build() { + Column({space:5}){ + Text('求解花费时间' + this.solutionData.time) + .fontSize(SMALL_SIZE_FONT) + Text('最短路径:' + this.solutionData.path) + .fontSize(SMALL_SIZE_FONT) + .width('100%') + }.width('100%').height('100%') + } +} + diff --git a/drumming/drummer/entry/src/main/ets/entryability/EntryAbility.ets b/drumming/drummer/entry/src/main/ets/entryability/EntryAbility.ets new file mode 100644 index 0000000..6e45be4 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/entryability/EntryAbility.ets @@ -0,0 +1,60 @@ +import AbilityConstant from '@ohos.app.ability.AbilityConstant'; +import hilog from '@ohos.hilog'; +import UIAbility from '@ohos.app.ability.UIAbility'; +import Want from '@ohos.app.ability.Want'; +import window from '@ohos.window'; +import dataPreferences from '@ohos.data.preferences'; + +export default class EntryAbility extends UIAbility { + + async onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): Promise { + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate'); + let dp = await dataPreferences.getPreferences(this.context,"web") + let loop = await dp.has("isLoad") + if(loop){ + //读取文件操作 + AppStorage.setOrCreate('isOpFile',true) + }else{ + dp.put("isLoad",true,()=>{ + dp.flush() + }) + //调用api操作 + AppStorage.setOrCreate('isOpFile',false) + } + + + } + + + onDestroy(): void { + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy'); + } + + onWindowStageCreate(windowStage: window.WindowStage): void { + // Main window is created, set main page for this ability + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate'); + + windowStage.loadContent('pages/Index', (err, data) => { + if (err.code) { + hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); + return; + } + hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', JSON.stringify(data) ?? ''); + }); + } + + onWindowStageDestroy(): void { + // Main window is destroyed, release UI related resources + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy'); + } + + onForeground(): void { + // Ability has brought to foreground + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground'); + } + + onBackground(): void { + // Ability has back to background + hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground'); + } +} diff --git a/drumming/drummer/entry/src/main/ets/pages/Index.ets b/drumming/drummer/entry/src/main/ets/pages/Index.ets new file mode 100644 index 0000000..35f292e --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/pages/Index.ets @@ -0,0 +1,126 @@ +import { CityInfo } from '../common/dataStruct/interface/CityInfo'; +import { X_CENTER, Y_CENTER } from '../common/CommonConstant'; +import Edge from '../common/dataStruct/class/Edge'; +import Node from '../common/dataStruct/class/Node'; +import { solutionData } from '../common/dataStruct/interface/SolutionData'; +import { header } from '../component/Header'; +import { imageShow } from '../component/ImageShow'; +import { operateBar } from '../component/OperateBar'; +import { cp } from '../utils/algorithm/customPath'; +import { getRealData } from '../utils/functions/getRealData'; +import { Logger } from '../utils/Logger'; +import { createCityInfo } from '../utils/functions/createCityInfo'; + +export let cityInfo: CityInfo = {}; + +@Entry +@Component +struct Index { + @State headerContent:Array = ["节点操作","连接操作","路径操作","最短路径-遍历","最短路径-贪心"] + @State @Watch('refreshOption')curHeaderContentIndex:number = 0 + refreshOption(){ + for (let index = 0; index < this.Nodes.length; index++) { + this.Nodes[index].marked = false + } + this.nodePathId = [] + } + + @Provide @Watch('refreshNodes')Nodes:Array = [new Node(0, "noMean", false, [X_CENTER,Y_CENTER])]; + @Provide curNodesIndex:number = 0 + + @Provide Edges:Array = [] + @Provide curEdgesIndex:number = 0 + + @State resTime:number = 0 + @State resDistance:number = 0 + + @Provide solutionData:solutionData = { + count:-1, + time:" ", + path:" ", + otherPath:[""] + } + + //画板刷新 + @Provide @Watch('refreshBoard')refresh:boolean = false + @State loop:string = "100%" + + @Provide isStartToPath:boolean = false + @Provide nodePath:string = "" + @Provide @Watch('refreshNodePath')nodePathId:Array = [] + refreshNodePath(){ + this.nodePath = '' + for (let index = 0; index < this.nodePathId.length; index++) { + this.nodePath += (this.Nodes[this.nodePathId[index]].label + `(${this.nodePathId[index]})`); + if (index != this.nodePathId.length - 1) { + this.nodePath += "->"; + } + } + if(this.nodePathId.length == 0){ + this.curNodesIndex = 0 + }else{ + this.curNodesIndex = this.nodePathId[this.nodePathId.length-1] + } + this.refresh = !this.refresh + Logger.i(JSON.stringify(this.nodePathId)) + } + refreshNodes(){ + this.curNodesIndex = 0 + //重新给id排序 + for (let index = 0; index < this.Nodes.length; index++) { + this.Nodes[index].id = index + } + + this.Edges = cp.createEdgeData(this.Nodes) + + //涉及到节点数组的变化先更新节点数组再更新连接数组再更新画板 + this.refresh = !this.refresh + } + + refreshBoard(){ + this.loop = this.loop == "100%"?"101%":"100%" + } + + @State isShow:boolean = true + build() { + Stack(){ + Column(){ + + header({headerContent:this.headerContent,curHeaderContentIndex:$curHeaderContentIndex,resTime:$resTime,resDistance:$resDistance}) + .width('100%') + .layoutWeight(1) + + Divider() + .width('100%') + .strokeWidth(1) + .color(Color.Orange) + + Row(){ + + imageShow({loop:this.loop,curEdgesIndex:$curEdgesIndex}) + .width('80%') + .height('100%') + + operateBar({headerContent:this.headerContent,curHeaderContentIndex:$curHeaderContentIndex}) + .width('20%') + .height('100%') + + }.width('100%').height('90%') + }.width('100%').height('100%').opacity(this.isShow?0.425:1) + if(this.isShow) { + Column() { + Text('正在初始化数据...') + .fontSize(40) + .onAppear(async () => { + await createCityInfo().then((info) => { + cityInfo = info; + }) + this.Nodes = cp.createNodeData(3); + this.Edges = cp.createEdgeData(this.Nodes); + this.isShow = false; + }) + }.width('100%').height('100%').justifyContent(FlexAlign.Center) + } + } + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/Logger.ets b/drumming/drummer/entry/src/main/ets/utils/Logger.ets new file mode 100644 index 0000000..2339ef5 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/Logger.ets @@ -0,0 +1,22 @@ +import hilog from '@ohos.hilog'; + +const DOMAIN = 0 +const APP_TAG = 'TSPTestApp' + +export class Logger { + public static d(message: string) { + hilog.debug(DOMAIN, APP_TAG, message) + } + + public static i(message: string) { + hilog.info(DOMAIN, APP_TAG, message) + } + + public static e(message: string) { + hilog.error(DOMAIN, APP_TAG, message) + } + + public static w(message: string) { + hilog.warn(DOMAIN, APP_TAG, message) + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/algorithm/TSP.ets b/drumming/drummer/entry/src/main/ets/utils/algorithm/TSP.ets new file mode 100644 index 0000000..1faebee --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/algorithm/TSP.ets @@ -0,0 +1,48 @@ +import { cp } from "./customPath"; +import Node from '../../common/dataStruct/class/Node'; +import Edge from '../../common/dataStruct/class/Edge'; + +export class TSP { + path: Edge[]; // 从连接构造的路径 + nodes: Node[]; // 节点对象列表 + edges: Edge[]; // 连接列表 + + constructor() { + this.path = []; + this.nodes = []; + this.edges = []; + } + + /** + * 创建节点数组和全连接数组 + * @param nodeNum 节点数量 + */ + createNodesAndEdges(nodeNum: number) { + this.path = []; + this.nodes = cp.createNodeData(nodeNum); + this.edges = cp.createEdgeData(this.nodes); + } + + /** + * 创建随机 tsp 问题 + */ + createRandomTspProblem() { + // 随机4到7个节点 + const nodeNum: number = Math.floor(Math.random() * (7 - 4 + 1)) + 4; + this.createNodesAndEdges(nodeNum); + } + + /** + * 创建随机路径 + * @param nodeNum 节点数量 + */ + createRandomPath(nodeNum: number) { + this.createNodesAndEdges(nodeNum); + let connOrder: number[] = Array.from({length: nodeNum}, (_: number, i: number) => i); + connOrder.sort(() => Math.random() - 0.5); + this.path = cp.setDisplayPath(connOrder)[0]; + } + +} + +export let tsp: TSP = new TSP(); \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/algorithm/customPath.ets b/drumming/drummer/entry/src/main/ets/utils/algorithm/customPath.ets new file mode 100644 index 0000000..09ab82a --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/algorithm/customPath.ets @@ -0,0 +1,574 @@ +import { showToast } from "../functions/showToast" +import Node from '../../common/dataStruct/class/Node' +import Edge from '../../common/dataStruct/class/Edge' +import { BOTTOM_RIGHT_X, BOTTOM_RIGHT_Y, DRAW_NODE_SIZE, TOP_LEFT_X, TOP_LEFT_Y, CITY } from '../../common/CommonConstant'; +import { cityInfo } from '../../pages/Index'; +import { Graph, nodeInfo } from '../../common/dataStruct/interface/Graph'; +import { deepCopyGraph } from '../functions/deepCopyGraph'; +import { degreesToRadians } from '../functions/degreesToRadians'; + +let cityName: string[] = CITY.slice(); +let usedCity: string[] = []; +let surplusCity: string[] = []; + +export class CustomPath { + path: Edge[]; // 从连接构造的路径 + pathDistanceCount: number; // 路径距离成本 + pathTimeCount: number; // 路径时间成本 + elapsedTime: number; // 运行时间 + graph: Graph; // 邻接图 + nodes: Node[]; // 节点对象列表 + edges: Edge[]; // 连接列表 + circles: number[][]; // 形成环路径 + numberOfPasses: number; // 遍历次数 + + constructor(path: Edge[], pathDistanceCount: number, pathTimeCount: number, elapsedTime: number, graph: Graph, nodes: Node[], edges: Edge[]) { + this.path = path; + this.pathDistanceCount = pathDistanceCount; + this.pathTimeCount = pathTimeCount; + this.elapsedTime = elapsedTime; + this.graph = graph; + this.nodes = nodes; + this.edges = edges; + this.circles = []; + this.numberOfPasses = 0; + } + + createNodeData(data: number): Node[] { + let num: number = data; + let ang = 360 / num; + let R = 140; + this.nodes = []; + cityName.sort(() => Math.random() - 0.5); + for (let i = 0; i < num; i++) { + let origin: [number, number] = [(BOTTOM_RIGHT_X - TOP_LEFT_X - DRAW_NODE_SIZE) / 2, (BOTTOM_RIGHT_Y - TOP_LEFT_Y - DRAW_NODE_SIZE) / 2]; + let rad = degreesToRadians(i * ang); + const x = origin[0] + Math.cos(rad) * R | 0; + const y = origin[1] + Math.sin(rad) * R | 0; + this.nodes.push(new Node(i, cityName[i], false, [x, y], true)); + } + usedCity = cityName.slice(0, num); + surplusCity = cityName.slice(num); + return this.nodes; + } + + addNodeData(): Node[] { + let num: number = this.nodes.length + 1; + let ang = 360 / num; + let R = 140; + let origin: [number, number] = [(BOTTOM_RIGHT_X - TOP_LEFT_X - DRAW_NODE_SIZE) / 2, (BOTTOM_RIGHT_Y - TOP_LEFT_Y - DRAW_NODE_SIZE) / 2]; + surplusCity.sort(() => Math.random() - 0.5); + this.nodes = this.nodes.map(node => { + let rad = degreesToRadians(node.id * ang); + const x = origin[0] + Math.cos(rad) * R | 0; + const y = origin[1] + Math.sin(rad) * R | 0; + node.coordinates = [x, y]; + return node; + }); + let rad = degreesToRadians((num - 1) * ang); + const x = origin[0] + Math.cos(rad) * R | 0; + const y = origin[1] + Math.sin(rad) * R | 0; + this.nodes.push(new Node(this.nodes.length, surplusCity[0] , false, [x, y], true)); + usedCity = usedCity.concat(surplusCity[0]); + surplusCity = surplusCity.slice(1); + this.createEdgeData(this.nodes); + return this.nodes; + } + + deleteNodeData(currentNodeId: number): Node[] { + // surplusCity = usedCity.slice(-1).concat(surplusCity); + // usedCity = usedCity.slice(0, -1); + // this.nodes.pop(); + usedCity = usedCity.filter((city) => city != this.nodes[currentNodeId].label); + surplusCity = [this.nodes[currentNodeId].label].concat(surplusCity); + this.nodes = this.nodes.filter(node => node.id != currentNodeId); + this.nodes = this.nodes.map((node, index) => { + node.id = index; + return node; + }); + this.createEdgeData(this.nodes); + return this.nodes; + } + + regenerate() { + this.nodes = this.nodes.map(node => { + let x = Math.random()*(BOTTOM_RIGHT_X - TOP_LEFT_X - DRAW_NODE_SIZE); + let y = Math.random()*(BOTTOM_RIGHT_Y - TOP_LEFT_Y - DRAW_NODE_SIZE); + node.coordinates = [x, y]; + return node; + }) + } + + createEdgeData(nodes: Node[]): Edge[] { + this.edges = []; + for (let i = 0; i < nodes.length; i++) { + for (let j = i + 1; j < nodes.length; j++) { + const connectionId = this.edges.length + 1; + const node1Id = nodes[i].id; + const node2Id = nodes[j].id; + const visible = true; + const marked = false; + const label = `Connection-${connectionId}`; + // const distance = Math.floor(Math.random() * (1000 - 10 + 1)) + 10; // 生成10到1000的随机整数 --你需要设置实际的距离值 + // const time = Math.floor(Math.random() * (720 - 60 + 1)) + 60; // 生成60到720的随机整数 --你需要设置实际的时间值 + const distance = cityInfo[nodes[i].label][nodes[j].label].distance; + const time = cityInfo[nodes[i].label][nodes[j].label].time; + // console.log(`${nodes[i].label}->${nodes[j].label}: 距离为${distance}，时间为${time}`); + this.edges.push(new Edge(connectionId, node1Id, node2Id, visible, marked, label, distance, time)); + } + } + return this.edges; + } + + connectTwoNodes(node1Id: number, node2Id: number) { + let nodeId: [number, number] = [node1Id, node2Id]; + for (const edge of this.edges) { + if (nodeId.includes(edge.node1) && nodeId.includes(edge.node2)) { + if (!edge.visible) edge.visible = true; + else showToast("当前两节点已连接"); + } + } + } + + setDisplayPath(nodeIds: number[]): [Edge[], number, number] { + this.path = []; // 置空操作 + this.pathDistanceCount = 0; + this.pathTimeCount = 0; + if (nodeIds.length) { + for (let i = 0; i < nodeIds.length; i++) { + let id1: number = 0; + let id2: number = 0; + if (i < nodeIds.length - 1) { + id1 = nodeIds[i]; + id2 = nodeIds[i + 1]; + } else { + if (nodeIds[0] == nodeIds[-1]) { + break; + } else { + id1 = nodeIds[i]; + id2 = nodeIds[0]; + } + } + let nodeId: [number, number] = [id1, id2]; // 用于寻找两节点的连接对象 + for (const edge of this.edges) { + if (nodeId.includes(edge.node1) && nodeId.includes(edge.node2)) { + edge.marked = true; + this.path.push(edge); + this.pathDistanceCount += edge.distance; + this.pathTimeCount += edge.time; + } + } + } + } + return [this.path, this.pathDistanceCount, this.pathTimeCount]; + } + + clearPath() { + this.path = []; + this.pathDistanceCount = 0; + this.pathTimeCount = 0; + this.edges.forEach(edge => { + edge.marked = false; // 全部连接清除标记 + }) + } + + undoPath() { + if (this.path.length) { + this.path[-1].marked = false; // 路径末尾连接清除标记 + this.path.pop(); + } + } + + checkPathLegitimate(paths: number[]): boolean { + for (let i = 0; i < paths.length; i++) { + let node1Id: number = 0; + let node2Id: number = 0; + if (i < paths.length - 1) { + node1Id = paths[i]; + node2Id = paths[i + 1]; + } else { + node1Id = paths[i]; + node2Id = paths[0]; + } + if (node1Id == node2Id) { + return false; + } + let node1: Node = this.nodes[node1Id]; + let node2: Node = this.nodes[node2Id]; + if (!this.graphCheckConnectivity(node1, node2)[0]) { + showToast(`在节点${node1.label}与节点${node2.label}之间没有连接, 路径不合法, 请重新选择路径`); + return false; + } + } + let nonessentialNode: Node[] = this.nodes.filter(node => node.mustVisit == false); + let nonessentialNum: number = nonessentialNode.length; + let tempPaths: number[] = paths.filter(nodeId => { // 路径中所有必经节点构成数组 + for (let i = 0; i < nonessentialNum; i++) { + if (nodeId == nonessentialNode[i].id) { + return false; + } + } + return true; + }); + if (tempPaths.length != this.nodes.length - nonessentialNum) { + showToast(`所选路径未经所有必经节点城市, 路径不合法, 请重新选择路径`); + return false; + } + showToast("所选路径合法"); + return true; + } + + createGraph(nodes: Node[], isDistance: boolean = true): Graph { + this.graph = {}; + nodes.forEach(node => { + if (node.mustVisit == true) { + this.graph[node.id] = []; + } + }) + nodes.forEach(node => { + if (node.mustVisit == true) { + this.edges.forEach(edge => { + if (edge.visible) { + let nodeIds: [number, number] = [edge.node1, edge.node2]; + if (nodeIds.includes(node.id) && nodes[nodeIds[0]].mustVisit == true && nodes[nodeIds[1]].mustVisit == true) { + let nodeId: number = nodeIds.find(id => id !== node.id) as number; + let weight: number = isDistance ? edge.distance : edge.time; + this.graph[node.id].push({ to: nodeId, weight: weight }); + } + } + }) + } + }) + return this.graph; + } + + dfs(nodeId: number, visited: Set, path: number[], startNeighbors: Set) { + try { + visited.add(nodeId); + path.push(nodeId); + if (path.length == Object.keys(this.graph).length && startNeighbors.has(path[path.length - 1])) { + this.circles.push(path.slice()); + return; + } + for (const adjacentNodeInfo of this.graph[nodeId]) { + const neighbor: number = adjacentNodeInfo.to; + if (!visited.has(neighbor)) { + this.dfs(neighbor, visited, path, startNeighbors); + visited.delete(neighbor); + path.pop(); + } + } + } catch { + console.log(this.circles.length.toString()); + this.circles.length = 0; + return; + } + } + + findCompleteCycles(graph: Graph, startNodeId: number = 0): number[][] { + this.circles = []; + let visited: Set = new Set(); + let startNeighborsArr: number[] = graph[startNodeId].map(nodeInfo => nodeInfo.to); + let startNeighbors: Set = new Set(startNeighborsArr); + this.dfs(startNodeId, visited, [], startNeighbors); + return this.circles; + } + + calculatePathCost(graph: Graph, path: number[]) { + let costValue = 0; + for (let i = 0; i < path.length - 1; i++) { + let currentNodeId: number = path[i]; + let nextNodeId: number = path[i + 1]; + if (!(graph[currentNodeId] && graph[currentNodeId].length === 0)) { + for (const adjacentNodeInfo of graph[currentNodeId]) { + if (adjacentNodeInfo.to == nextNodeId) { + costValue += adjacentNodeInfo.weight; + break; + } + } + } else break; + } + return costValue; + } + + traversalSearchToPath(cp: CustomPath, graph: Graph, startNodeId: number = 0, _mustVisitNode?: number[]): [number[][], number, number, number] { + let startTime: number = Date.now(); + let allPaths: number[][] = cp.findCompleteCycles(graph, startNodeId); + let numOfPasses = allPaths.length; + if (allPaths.length == 0) { + try { + throw new Error("当前图无法获取完整路径,请检查节点连接是否完整"); + } catch { + showToast("当前图无法获取完整路径,请检查节点连接是否完整"); + return [[], 0, 0, 0]; + } + } + let minPathList: number[][] = []; + let minValue: number = Number.POSITIVE_INFINITY; + for (const permutation of allPaths) { + let currentPath = permutation.concat([startNodeId]); + let currentCostValue = cp.calculatePathCost(graph, currentPath); + if (currentCostValue < minValue) { + minValue = currentCostValue; + minPathList = []; + minPathList.push(currentPath.slice()); + } else if (currentCostValue == minValue) { + minPathList.push(currentPath.slice()); + } + } + let endTime: number = Date.now(); + cp.elapsedTime = (endTime - startTime) * 1e-3; // 转换为秒 + return [minPathList, minValue, cp.elapsedTime, numOfPasses]; + } + + greedySearchToPath(cp: CustomPath, graph: Graph, startNodeId: number = 0, _mustVisitNode?: number[]): [number[][], number, number, number] { + let startTime: number = Date.now(); + let startNeighborsArr: number[] = graph[startNodeId].map(nodeInfo => nodeInfo.to); + let startNeighbors: Set = new Set(startNeighborsArr); + let remainingNodes: Set = new Set(Object.keys(graph).map(i => Number(i))); + remainingNodes.delete(startNodeId); + let currentNodeId = startNodeId; + let path: number[] = [startNodeId]; + while (remainingNodes.size > 0) { + if (graph[currentNodeId].length === 0) break; + let nextNodeId: number = Number.NaN; + let minValue: number = Number.POSITIVE_INFINITY; + for (const adjacentNodeInfo of graph[currentNodeId]) { + if (adjacentNodeInfo.weight < minValue && !path.includes(adjacentNodeInfo.to)) { + minValue = adjacentNodeInfo.weight; + nextNodeId = adjacentNodeInfo.to; + } + } + if (Number.isNaN(nextNodeId)) { + try { + throw new Error(`当前id为${currentNodeId}的节点无直接路径到id为${Array.from(remainingNodes)[0]}的节点，贪心算法求解失败`); + } catch { + showToast(`当前id为${currentNodeId}的节点无直接路径到id为${Array.from(remainingNodes)[0]}的节点，贪心算法求解失败`); + return [[], 0, 0, 1]; + } + } + path.push(nextNodeId); + remainingNodes.delete(nextNodeId); + currentNodeId = nextNodeId; + } + if (startNeighbors.has(path[path.length - 1])) { + path.push(startNodeId); + } else { + try { + throw new Error(`当前id为${path[path.length - 1]}的节点无直接路径到id为${startNodeId}的节点，贪心算法求解失败`); + } catch { + showToast(`当前id为${path[path.length - 1]}的节点无直接路径到id为${startNodeId}的节点，贪心算法求解失败`); + return [[], 0, 0, 1]; + } + } + let endTime: number = Date.now(); + cp.elapsedTime = (endTime - startTime) * 1e-3; // 转换为秒 + return [[path], cp.calculatePathCost(graph, path), cp.elapsedTime, 1]; + } + + solveTsp(startNodeId: number = 0, func: (cp: CustomPath, graph: Graph, startNodeId: number) => [number[][], number, number, number]): [number[][], number, number, number] { + let startTime: number = Date.now(); + let shortestDistance: number[] = []; + let pathList: number[][][] = []; + let remainGraph: Graph[] = []; + let nonessentialNode: Node[] = this.nodes.filter(node => node.mustVisit == false); + let nonessentialNum: number = nonessentialNode.length; + this.numberOfPasses = 0; + + for (let i = 0; i < nonessentialNum; i++) { + if (startNodeId == nonessentialNode[i].id) { + try { + throw new Error("起始节点不能为非必经节点"); + } catch { + showToast("起始节点不能为非必经节点"); + return [[], 0, 0, 0]; + } + } + } + + let graph: Graph = this.createGraph(this.nodes); + let res: [number[][], number, number, number] = func(this, graph, startNodeId); + if (!res[0].length) return [[], 0, 0, 0]; + pathList.push(res[0].slice()); + shortestDistance.push(res[1]); + this.numberOfPasses += res[3]; + remainGraph.push(deepCopyGraph(graph)); + for (let i = 0; i < nonessentialNum; i++) { + this.nodes[nonessentialNode[i].id].mustVisit = true; + for (let j = i + 1; j < nonessentialNum; j++) { + this.nodes[nonessentialNode[j].id].mustVisit = true; + graph = this.createGraph(this.nodes); + res = func(this, graph, startNodeId); + if (!res[0].length) return [[], 0, 0, 0]; + pathList.push(res[0].slice()); + shortestDistance.push(res[1]); + this.numberOfPasses += res[3]; + remainGraph.push(deepCopyGraph(graph)); + this.nodes[nonessentialNode[j].id].mustVisit = false; + } + graph = this.createGraph(this.nodes); + res = func(this, graph, startNodeId); + if (!res[0].length) return [[], 0, 0, 0]; + pathList.push(res[0].slice()); + shortestDistance.push(res[1]); + this.numberOfPasses += res[3]; + remainGraph.push(deepCopyGraph(graph)); + this.nodes[nonessentialNode[i].id].mustVisit = false; + } + let index: number = shortestDistance.reduce((minIndex, currentValue, currentIndex, array) => { + return currentValue < array[minIndex] ? currentIndex : minIndex; + }, 0); + this.graph = deepCopyGraph(remainGraph[index]); + let endTime: number = Date.now(); + this.elapsedTime = (endTime - startTime) * 1e-3; // 转换为秒 + return [pathList[index], shortestDistance[index], this.elapsedTime, this.numberOfPasses]; + } + + graphCheckConnectivity(node1: Node, node2: Node): [boolean, number, number] { + if (this.nodes && this.edges && this.nodes.length != 0 && this.edges.length != 0) { + let find: number[] = []; + for (const node of this.nodes) { + find.push(node.id); + } + for (const edge of this.edges) { + if (edge.visible) { + let x: number = edge.node1; + let y: number = edge.node2; + while (x != find[x]) x = find[x]; + while (y != find[y]) y = find[y]; + if (x < y) find[y] = x; + else find[x] = y; + } + } + let x: number = node1.id; + let y: number = node2.id; + while (x != find[x]) x = find[x]; + while (y != find[y]) y = find[y]; + if (find[x] == find[y]) return [true, x, y]; + else return [false, x, y]; + } else { + try { + throw new Error("当前图无节点或无边"); + } catch { + showToast("当前图无节点或无边"); + return [false, -1, -1]; + } + } + } + + specificPathCost(path: Edge[], isDistance: boolean = true): number { + let minValue: number = 0; + if (!isDistance) { + for (const pathEle of path) { + minValue += pathEle.time; + } + return minValue; + } else { + for (const pathEle of path) { + minValue += pathEle.distance; + } + return minValue; + } + } + + checkUserBest(path: Edge[], startNodeId: number = 0, isDistance: boolean = true): boolean { + let revalue: [number[][], number, number, number] = this.solveTsp(startNodeId, this.traversalSearchToPath); + let minPath: number[] = revalue[0][0]; + if (path.length + 1 != minPath.length) return false; + let minValue: number = revalue[1]; + let userMinValue = this.specificPathCost(path, isDistance); + if (minValue == userMinValue) return true; + else return false; + } + + NodeIdsPathToEdgesPath(path: number[]): Edge[] { + let paths: Edge[] = []; + let len: number = path.length; + for (let i = 0; i < len - 1; i++) { + for (const edge of this.edges) { + if ((edge.node1 == path[i] && edge.node2 == path[i + 1]) || (edge.node1 == path[i + 1] && edge.node2 == path[i])) { + paths.push(edge); + break; + } + } + } + return paths; + } + + EdgesPathToNodeIdsPath(path: Edge[], startNodeId: number = 0): number[] { + let paths: number[] = [startNodeId]; + let nextNodeId: number = paths[0]; + for (const pathEle of path) { + let nodeIds: number[] = [pathEle.node1, pathEle.node2]; + if (nodeIds.includes(nextNodeId)) { + nextNodeId = nodeIds.find(id => id != nextNodeId) as number; + paths.push(nextNodeId); + } + } + return paths; + } + + checkIsGreedy(path: Edge[], startNodeId: number = 0) { + let revalue: [number[][], number, number, number] = this.solveTsp(startNodeId, this.greedySearchToPath); + let greedyPath: number[] = revalue[0][0]; + if (path.length + 1 != greedyPath.length) return false; + let userPath: number[] = this.EdgesPathToNodeIdsPath(path, startNodeId); + let len: number = userPath.length; + for (let i = 0; i < len; i++) { + if (userPath[i] != greedyPath[i]) { + try { + throw new Error(`正确的贪心节点顺序为${greedyPath.slice(0, -1)}\n你的第${i + 1}个节点${this.nodes[userPath[i]].label}不符合贪心规则。`); + } catch { + showToast(`正确的贪心节点顺序为${greedyPath.slice(0, -1)}\n你的第${i + 1}个节点${this.nodes[userPath[i]].label}不符合贪心规则。`); + return false; + } + }; + } + return true; + } + + shortestPathAlgorithm(startNodeId: number, endNodeId: number, isDistance: boolean = true): [number[], number] { + this.graph = this.createGraph(this.nodes, isDistance); + let distances: Record = {}; // 记录从起始节点到每个节点的最短距离 + let previous: Record = {}; // 记录最短路径中每个节点的前驱节点 + let visited: Set = new Set(); // 存储已经处理过的节点 + let priorityQueue: Array = []; // 优先队列，用于处理待访问的节点，按照距离排序 + + for (const nodeId of Object.keys(this.graph)) { + distances[nodeId] = Number.POSITIVE_INFINITY; + previous[nodeId] = -1; + } + + distances[startNodeId] = 0; + priorityQueue.push({ to: startNodeId, weight: 0 }); + while (priorityQueue.length > 0) { + priorityQueue.sort((a, b) => a.weight - b.weight); // 维护优先队列，保证每次队列中距离最小的节点在最前面 + let currentNodeId = priorityQueue.shift()!.to; + + if (currentNodeId === endNodeId) break; + if (visited.has(currentNodeId)) continue; + visited.add(currentNodeId); + + for (const neighbor of this.graph[currentNodeId]) { + const neighborNodeId: number = neighbor.to; + const weight: number = neighbor.weight; + let newDist: number = distances[currentNodeId] + weight; + + if (newDist < distances[neighborNodeId]) { + distances[neighborNodeId] = newDist; + previous[neighborNodeId] = currentNodeId; + priorityQueue.push({ to: neighborNodeId, weight: newDist }); + } + } + } + let path: number[] = []; + let currentNodeId: number = endNodeId; + while (currentNodeId != -1) { + path.unshift(currentNodeId); + currentNodeId = previous[currentNodeId]; + } + return [path, distances[endNodeId]]; + } +} + +export let cp: CustomPath = new CustomPath([], 0, 0, 0, {}, [], []); \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/functions/createCityInfo.ets b/drumming/drummer/entry/src/main/ets/utils/functions/createCityInfo.ets new file mode 100644 index 0000000..5b519b7 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/functions/createCityInfo.ets @@ -0,0 +1,110 @@ +import { CITY } from '../../common/CommonConstant'; +import { CityInfo } from '../../common/dataStruct/interface/CityInfo'; +import { Logger } from '../Logger'; +import { getRealData } from './getRealData'; + +export async function createCityInfo(): Promise { + //TODO 可注释掉第87、88行 再将第6行至85行注释打开 即可在指定的预览器参数下模拟程序 + // let res: [string, string, number, number][] = [ + // ["广州市", "深圳市", 123012, 10838], + // ["广州市", "珠海市", 118916, 9380], + // ["广州市", "汕头市", 408198, 20355], + // ["广州市", "佛山市", 24721, 4042], + // ["广州市", "韶关市", 214580, 10298], + // ["广州市", "湛江市", 412296, 17672], + // ["广州市", "肇庆市", 95526, 6740], + // ["广州市", "江门市", 79764, 6810], + // ["广州市", "茂名市", 330124, 16845], + // ["广州市", "惠州市", 132169, 10257], + // ["广州市", "梅州市", 375039, 23471], + // ["广州市", "汕尾市", 250695, 22951], + // ["深圳市", "珠海市", 96524, 6856], + // ["深圳市", "汕头市", 327090, 16705], + // ["深圳市", "佛山市", 131396, 7894], + // ["深圳市", "韶关市", 314989, 14934], + // ["深圳市", "湛江市", 458270, 17171], + // ["深圳市", "肇庆市", 207397, 12600], + // ["深圳市", "江门市", 117755, 7185], + // ["深圳市", "茂名市", 379777, 14772], + // ["深圳市", "惠州市", 85900, 8126], + // ["深圳市", "梅州市", 333237, 19392], + // ["深圳市", "汕尾市", 160776, 10851], + // ["珠海市", "汕头市", 414804, 20789], + // ["珠海市", "佛山市", 115634, 8714], + // ["珠海市", "韶关市", 330794, 18384], + // ["珠海市", "湛江市", 399887, 17975], + // ["珠海市", "肇庆市", 170341, 10310], + // ["珠海市", "江门市", 74683, 6582], + // ["珠海市", "茂名市", 321394, 15731], + // ["珠海市", "惠州市", 166006, 16927], + // ["珠海市", "梅州市", 418175, 22730], + // ["珠海市", "汕尾市", 248490, 14697], + // ["汕头市", "佛山市", 428134, 21849], + // ["汕头市", "韶关市", 439125, 28337], + // ["汕头市", "湛江市", 777628, 31482], + // ["汕头市", "肇庆市", 503503, 19173], + // ["汕头市", "江门市", 437113, 21891], + // ["汕头市", "茂名市", 699135, 28654], + // ["汕头市", "惠州市", 281852, 13534], + // ["汕头市", "梅州市", 150580, 10931], + // ["汕头市", "汕尾市", 178082, 9358], + // ["佛山市", "韶关市", 236498, 14079], + // ["佛山市", "湛江市", 387931, 16579], + // ["佛山市", "肇庆市", 83082, 6325], + // ["佛山市", "江门市", 57582, 5669], + // ["佛山市", "茂名市", 306652, 14224], + // ["佛山市", "惠州市", 152376, 11891], + // ["佛山市", "梅州市", 395246, 25040], + // ["佛山市", "汕尾市", 270551, 21935], + // ["韶关市", "湛江市", 597469, 29973], + // ["韶关市", "肇庆市", 266051, 13269], + // ["韶关市", "江门市", 297901, 15143], + // ["韶关市", "茂名市", 512263, 25970], + // ["韶关市", "惠州市", 241728, 12976], + // ["韶关市", "梅州市", 351402, 17854], + // ["韶关市", "汕尾市", 353072, 17957], + // ["湛江市", "肇庆市", 337242, 17455], + // ["湛江市", "江门市", 352004, 13773], + // ["湛江市", "茂名市", 88410, 5807], + // ["湛江市", "惠州市", 525222, 21359], + // ["湛江市", "梅州市", 772108, 35020], + // ["湛江市", "汕尾市", 611969, 26177], + // ["肇庆市", "江门市", 96870, 6183], + // ["肇庆市", "茂名市", 250335, 13916], + // ["肇庆市", "惠州市", 227448, 15215], + // ["肇庆市", "梅州市", 470318, 28141], + // ["肇庆市", "汕尾市", 347288, 23119], + // ["江门市", "茂名市", 273884, 11126], + // ["江门市", "惠州市", 175884, 14701], + // ["江门市", "梅州市", 425305, 22731], + // ["江门市", "汕尾市", 271930, 18071], + // ["茂名市", "惠州市", 446878, 18932], + // ["茂名市", "梅州市", 693764, 33390], + // ["茂名市", "汕尾市", 533625, 25063], + // ["惠州市", "梅州市", 253720, 11521], + // ["惠州市", "汕尾市", 121252, 8521], + // ["梅州市", "汕尾市", 216441, 11933] + // ] + + let res: [string, string, number, number][] = await getRealData(); + Logger.i(JSON.stringify(res)); + + let cityName: string[] = CITY.slice(); + let cityInfo: CityInfo = {}; + cityName.forEach((city) => { + cityInfo[city] = {}; + }) + res.forEach((urbanTransitionInfo) => { + cityInfo[urbanTransitionInfo[0]][urbanTransitionInfo[1]] = { distance: urbanTransitionInfo[2], time: urbanTransitionInfo[3] }; + if (!cityInfo[urbanTransitionInfo[1]][urbanTransitionInfo[0]]) cityInfo[urbanTransitionInfo[1]][urbanTransitionInfo[0]] = { distance: urbanTransitionInfo[2], time: urbanTransitionInfo[3] }; + }) + + // console.log(Object.keys(cityInfo).toString()) + // for (const i of Object.keys(cityInfo)) { + // console.log(Object.keys(cityInfo[i]).toString()) + // for (const j of Object.keys(cityInfo[i])) { + // console.log(`${i}->${j}: 距离为${cityInfo[i][j].distance}，时间为${cityInfo[i][j].time}`); + // } + // } + return cityInfo; +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/functions/deepCopyGraph.ets b/drumming/drummer/entry/src/main/ets/utils/functions/deepCopyGraph.ets new file mode 100644 index 0000000..a6b1549 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/functions/deepCopyGraph.ets @@ -0,0 +1,17 @@ +import { Graph, nodeInfo } from '../../common/dataStruct/interface/Graph'; + +export function deepCopyGraph(graph: Graph): Graph { + const newGraph: Graph = {}; + + for (const nodeId of Object.keys(graph)) { + // 深拷贝每个 nodeInfo 数组 + newGraph[nodeId] = graph[nodeId].map((node: nodeInfo) => { + let nodeMessage: nodeInfo ={ + to: node.to, + weight: node.weight + }; + return nodeMessage; + }); + } + return newGraph; +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/functions/degreesToRadians.ets b/drumming/drummer/entry/src/main/ets/utils/functions/degreesToRadians.ets new file mode 100644 index 0000000..c8c0a94 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/functions/degreesToRadians.ets @@ -0,0 +1,3 @@ +export function degreesToRadians(degrees: number): number { + return degrees * Math.PI / 180; +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/functions/drawEdge.ets b/drumming/drummer/entry/src/main/ets/utils/functions/drawEdge.ets new file mode 100644 index 0000000..ccd20d2 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/functions/drawEdge.ets @@ -0,0 +1,33 @@ +import { DRAW_NODE_SIZE, NORMAL_CONTEXT, SELECTED_CONTEXT } from '../../common/CommonConstant' +import Edge from '../../common/dataStruct/class/Edge' +import { cp } from '../algorithm/customPath' +import { Logger } from '../Logger' + +export let drawEdge = (edge:Edge,isSelectedPath:boolean)=>{ + let context = isSelectedPath?SELECTED_CONTEXT:NORMAL_CONTEXT + + if(isSelectedPath){ + if(edge.marked){ + context.moveTo(cp.nodes[edge.node1].coordinates[0] + DRAW_NODE_SIZE/2,cp.nodes[edge.node1].coordinates[1] + DRAW_NODE_SIZE/2) + context.lineTo(cp.nodes[edge.node2].coordinates[0] + DRAW_NODE_SIZE/2,cp.nodes[edge.node2].coordinates[1] + DRAW_NODE_SIZE/2) + context.stroke() + } + }else{ + if(edge.visible){ + context.moveTo(cp.nodes[edge.node1].coordinates[0] + DRAW_NODE_SIZE/2,cp.nodes[edge.node1].coordinates[1] + DRAW_NODE_SIZE/2) + context.lineTo(cp.nodes[edge.node2].coordinates[0] + DRAW_NODE_SIZE/2,cp.nodes[edge.node2].coordinates[1] + DRAW_NODE_SIZE/2) + context.stroke() + } + } + + context.stroke() +} +export let drawEdgeList = (edgeList:Array,isSelectedPath:boolean)=>{ + if(edgeList.length == 0){ + return + } + for(let index = 0;index < edgeList.length;index++){ + drawEdge(edgeList[index],isSelectedPath) + } +} + diff --git a/drumming/drummer/entry/src/main/ets/utils/functions/drawNode.ets b/drumming/drummer/entry/src/main/ets/utils/functions/drawNode.ets new file mode 100644 index 0000000..f185e2b --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/functions/drawNode.ets @@ -0,0 +1,40 @@ +import Node from '../../common/dataStruct/class/Node' +import { BOTTOM_RIGHT_X, BOTTOM_RIGHT_Y, DRAW_NODE_SIZE, TOP_LEFT_X, TOP_LEFT_Y, + X_CENTER, + Y_CENTER +} from '../../common/CommonConstant' + +export let drawNode = (node:Node,context:CanvasRenderingContext2D)=>{ + + + if(!node.mustVisit){ + context.fillRect(node.coordinates[0],node.coordinates[1],DRAW_NODE_SIZE,DRAW_NODE_SIZE) + }else{ + context.strokeRect(node.coordinates[0],node.coordinates[1],DRAW_NODE_SIZE,DRAW_NODE_SIZE) + } + let bias = getTextBiasValue(node) + context.fillText(node.label,node.coordinates[0] + DRAW_NODE_SIZE/2 + bias[0],node.coordinates[1] + DRAW_NODE_SIZE/2 + bias[1]) + + context.stroke() +} + +export let drawNodeList = (nodeList:Array,context:CanvasRenderingContext2D)=>{ + if(nodeList.length == 0){ + return + } + for (let index = 0; index < nodeList.length; index++) { + drawNode(nodeList[index],context) + } +} + + +let getTextBiasValue = (node:Node)=>{ + let bias:[number,number] = [0,0] + if(node.coordinates[0] < X_CENTER){ + bias[0] = -40 + } + if(node.coordinates[1] > Y_CENTER){ + bias[1] = 25 + } + return bias +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/ets/utils/functions/getRealData.ets b/drumming/drummer/entry/src/main/ets/utils/functions/getRealData.ets new file mode 100644 index 0000000..8c13983 --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/functions/getRealData.ets @@ -0,0 +1,147 @@ +import { CITY, KEY } from '../../common/CommonConstant' +import http from '@ohos.net.http' +import { Logger } from '../Logger' +import fs from '@ohos.file.fs'; +import picker from '@ohos.file.picker'; +import { BusinessError } from '@ohos.base'; +import process from '@ohos.process'; + +import { showToast } from './showToast'; +import { Data } from '../../common/dataStruct/class/Data'; + +export let getRealData = async ()=>{ + let res:Array<[string,string,number,number]> = [] + let loop:boolean = AppStorage.get("isOpFile") as boolean + if(loop){ + res = await getRealDataFromFile() + }else{ + let str = "" + for(let i = 0;i < CITY.length;i++){ + for(let j = i + 1;j < CITY.length;j++){ + let tmp = await getRealDataFromMap(CITY[i],CITY[j]) + res.push(tmp) + str += `${tmp[0]} ${tmp[1]} ${tmp[2]} ${tmp[3]}` + str += '\n' + + } + } + await writeDocument(str) + } + return res; +} + + +/** + * 从地图获取真实数据 + */ +let getRealDataFromMap = async (cityName1:string,cityName2:string)=>{ + + let res:[string,string,number,number] = ["","",0,0] + //获取经纬度 + let getLocation1_url = `https://restapi.amap.com/v3/geocode/geo?address=${cityName1}&key=${KEY}` + let getLocation2_url = `https://restapi.amap.com/v3/geocode/geo?address=${cityName2}&key=${KEY}` + let loc1 = await getLoc(getLocation1_url) + let loc2 = await getLoc(getLocation2_url) + //获取最短路径 + let getPath_url = `https://restapi.amap.com/v3/direction/driving?origin=${loc1}&destination=${loc2}&strategy=2&key=${KEY}` + let path = await getPath(getPath_url) + + res[0] = cityName1 + res[1] = cityName2 + res[2] = path[0] + res[3] = path[1] + Logger.i(JSON.stringify(res)) + return res +} + +/** + * 从文件获取真实数据 + */ +let getRealDataFromFile = async ()=>{ + let dataList:Array<[string,string,number,number]> = [] + //读取文件 + let res = await readDocument(dataList) + if(!res){ + setTimeout(()=>{ + showToast("数据初始化异常,将自动关闭程序") + setTimeout(()=>{ + let pro = new process.ProcessManager(); + pro.exit(0); + },2000) + },2000) + } + return dataList +} + +let getLoc = async (url:string)=>{ + try { + let h = http.createHttp() + let res = await h.request(url) + + //JSON + let json = res.result as string + let i = json.indexOf("location") + let loc = json.slice(i + 11,i+31) + return loc; + } catch (e) { + Logger.e(JSON.stringify(e)) + return "" + } +} + +let getPath = async (url:string)=>{ + let h = http.createHttp() + let res = await h.request(url) + //JSON + let json = res.result as string + let obj:Data = JSON.parse(json) + let loc:[number,number] = [Number(obj.route.paths[0].distance),Number(obj.route.paths[0].duration)] + return loc; +} + +let writeDocument = async (str:string)=>{ + let documentPicker = new picker.DocumentViewPicker(); + let uris:Array = [] + let DocumentSaveOptions = new picker.DocumentSaveOptions(); + DocumentSaveOptions.newFileNames = ['cityData.txt'] + uris = await documentPicker.save(DocumentSaveOptions) + let uri = uris[0] + let file = fs.openSync(uri, fs.OpenMode.WRITE_ONLY); + fs.writeSync(file.fd,"THIS IS A TAG\n") + let writeStr = str + fs.writeSync(file.fd, writeStr); + fs.closeSync(file); +} + +let readDocument = async (dataList:Array<[string,string,number,number]>)=>{ + let documentPicker = new picker.DocumentViewPicker() + let DocumentSelectOptions = new picker.DocumentSelectOptions(); + let DocumentSelectResult: Array = await documentPicker.select(DocumentSelectOptions) + if(DocumentSelectResult.length == 0){ + showToast("您未选择任何文件！将无法获取到数据") + return false + } + let uri = DocumentSelectResult[0] + let file = fs.openSync(uri,fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE) + //已经获取到选择的文件 进行读取操作 + let arrayBuffer = new ArrayBuffer(8) + let size = 0 + let dSize = 0 + let str = fs.readTextSync(file.path) + //解析路径 + fs.closeSync(file) + + //解析文件样本点 + let arr = str.split('\n') + if(arr[0] != "THIS IS A TAG"){ + showToast("读取文件失败,请确认文件是否选择正确或是否损坏") + return false + } + for (let index = 1; index < arr.length - 1; index++) { + let res = arr[index].split(' ') + + let item:[string,string,number,number] = [res[0],res[1],Number(res[2]),Number(res[3])] + dataList.push(item) + } + return true +} diff --git a/drumming/drummer/entry/src/main/ets/utils/functions/showToast.ets b/drumming/drummer/entry/src/main/ets/utils/functions/showToast.ets new file mode 100644 index 0000000..e41cc5b --- /dev/null +++ b/drumming/drummer/entry/src/main/ets/utils/functions/showToast.ets @@ -0,0 +1,8 @@ +import promptAction from '@ohos.promptAction' + +export let showToast = (message:string,duration:number = 2000)=>{ + promptAction.showToast({ + message:message, + duration:duration + }) +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/module.json5 b/drumming/drummer/entry/src/main/module.json5 new file mode 100644 index 0000000..a4ce4f2 --- /dev/null +++ b/drumming/drummer/entry/src/main/module.json5 @@ -0,0 +1,49 @@ +{ + "module": { + "name": "entry", + "type": "entry", + "description": "$string:module_desc", + "mainElement": "EntryAbility", + "requestPermissions": [ + { + "name": "ohos.permission.INTERNET" + }, + { + "name": "ohos.permission.FILE_ACCESS_MANAGER" + }, + { + "name": "ohos.permission.GET_BUNDLE_INFO_PRIVILEGED" + } + ], + "deviceTypes": [ + "default", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false, + "pages": "$profile:main_pages", + "abilities": [ + { + "name": "EntryAbility", + "srcEntry": "./ets/entryability/EntryAbility.ets", + "description": "$string:EntryAbility_desc", + "icon": "$media:icon", + "label": "$string:EntryAbility_label", + "startWindowIcon": "$media:startIcon", + "startWindowBackground": "$color:start_window_background", + "exported": true, + "orientation": "landscape", + "skills": [ + { + "entities": [ + "entity.system.home" + ], + "actions": [ + "action.system.home" + ] + } + ] + } + ] + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/resources/base/element/color.json b/drumming/drummer/entry/src/main/resources/base/element/color.json new file mode 100644 index 0000000..3c71296 --- /dev/null +++ b/drumming/drummer/entry/src/main/resources/base/element/color.json @@ -0,0 +1,8 @@ +{ + "color": [ + { + "name": "start_window_background", + "value": "#FFFFFF" + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/resources/base/element/string.json b/drumming/drummer/entry/src/main/resources/base/element/string.json new file mode 100644 index 0000000..f945955 --- /dev/null +++ b/drumming/drummer/entry/src/main/resources/base/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "module description" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/resources/base/media/icon.png b/drumming/drummer/entry/src/main/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..cd45accb1dfd2fd0da16c732c72faa6e46b26521 GIT binary patch literal 2041 zcmaJ?c~nzZ9u6@;0AXaYAVN(;Kr(@>EJ+}skOWf=BA~*l4us@ELY9{%0m5QX6pnb} z(jZF|S&pLAS}3BZAfeQSvJ_h>F2Q1PYqi?o5`;m_yjZdG$1v}l_wK#F^L^iMz2}uD z#K$>1dON~kFlWvhW+Jp=tuN9J`ZlM-rl4h+ij|^D0y9;4JOuz-EdVnB6i3R-0ulk9 zApi4zAQA>!N9@-o026$1@L`d124`3G5<@_m`0f)Ug_Ie~;HT2q<_a=HH> zDwTdfD^-cW-|_xWVP$f@93UhDN-#&khZ>jZXLTi~$0`7x3REP6pk%&^2|`c>DutjN zMJD4Zs6Z}{FOpd;*mo2zm(GzXRXiCV;4m3zNCYnu3Fy=i5;2An&Lp!#LP;bRD~1&s z%VH6UY+}r6YDgG+p34OJIZ{BTn&%4s=CT&#TBkuOhdeU@g(w#guoa*b^)73=XyI65 z7Swys6)YS}?1EeZ6b!-I+yCnIya^g0>-NLsLWd8t56GZ_S3r|ZGbR+mV2ErEb9J)X zIF!njY-D-7{qtF2(?nlQ$0}!pzt=}hc*m%%)0Jb#N_K4@IC-`Pi5DahPZN7N9rH;ol;Gc*>-Go@gXKTM{eP)iJj6CYTIi}B#zLKZYD@_;m zrXmXXsFq@~ou-z!9bHoM8*(hwl>X(zm)TDcdkF4lZm$1jP*HbnD`o1$g}_R#+bu2D zr%7Y8KdsaC-V*aem5#@*M%r^GPgu%P2e-BnBClhP2yoGFe40>);=}>{NONtkXQ01p z)OX^t2Ojhddot9eg0WTIVSTNBa}7V-^_pO595w|Hx9q?k4dMp@$G7PK*TD=y;ck6J zdGRB!_RAI2nR3%tO1IkdWp*bw*?<=pM_LZb30?!oK)s;En( z!#nnd9=cXJ<}+e{XLdx(q3&ikJISe?eSHHohk+pz+$6Cv{ytvc{QXmMn2XQ9U8rvt zrJdAn(0gpSD@N=yTrI_2^P#*zQg7MTp1)k(lv(*(KtUR6@M|2WB>2wRwC-h=wk6XF zPtSes*_JwI+^d>xW489MJw5R6=t5?{R zc|E8i?RL@p9)A3ZJAQOg`}+F;<_vnWA!KxR#g%jZ@y_1Qu#Uw)kFPw_xmZ?a^e*1{ zM|ImtqA|(CaDQ@Fyvcof`MN66&VI6m6gAyAXx`%cDx6BI{Bj#}V*Rn1(b~;Am)D2u zX7(027IO?Z2VYK^1vXXpoZ@AtH~N?0rYWwtyA15`6vEf6fk&;o-L;7zFt`5nk*iOy z`<918zB+k;EytI$FAXug)jk*e@e};4e9g__w4A5ev!!)H$yC@{?vsRqJ##X1R%xPG z&_R3oDi$MtTkVqfPj)HEUDx_7wd!y{8#1%$U*Dd0sK@=#6+!XlsE-s^1f5E`R9Wo71^b~mbVdU;Fw0LG~mUQg;xsX4QYRo3B@rH_=ry>DE8ef!c2ta8UcI#26# zF|`*4wtMHe@%#eGZw`#Yj|QWuB`eRD)b~)r9mM95p_JVG%-IdcbIX5qG#GpGD+IrS zEqxb1Rg&Dadk5#7t4j68I1f!@A$efp1?I%&d*56)yl!tkz!14<$0Od_&6cGw$WW0r zjSlQA7l*6;vgfhv!cR|RmAD$+w6j`rVf=-?-D@q>kOseUVSb*~jbAS^*1h?ZL)n(9 zDa}`4etXO6`}9;{k5E^N{rcfnV_(LPwsDg``wtyS*V<19c3!PGJ3Kqy9ksvkwbJ%Z z*N(fT0{e*Wji-Ck5!3YE0j|PZ@&z`v=kitWL$bqSt!e4bH!+(|Q)CZ30^nVPfkx{s zX{6of`p=BiPb@u@IyL!tRk>?qgBqCmo-Zlt!636g?z`s~zdfwuB7DXZHvV`Usp+%Z zo*&;Biu@MHE&2j+?j^o`Cr12u<>vOe=a&8a2hlcmFjJiDR>XnD4c4DAhZWCkiAgW{ E51q9-lK=n! literal 0 HcmV?d00001 diff --git a/drumming/drummer/entry/src/main/resources/base/media/startIcon.png b/drumming/drummer/entry/src/main/resources/base/media/startIcon.png new file mode 100644 index 0000000000000000000000000000000000000000..366f76459ffd4494ec40d0ddd5c59385b9c5da11 GIT binary patch literal 4351 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 literal 0 HcmV?d00001 diff --git a/drumming/drummer/entry/src/main/resources/base/profile/main_pages.json b/drumming/drummer/entry/src/main/resources/base/profile/main_pages.json new file mode 100644 index 0000000..55c3f00 --- /dev/null +++ b/drumming/drummer/entry/src/main/resources/base/profile/main_pages.json @@ -0,0 +1,5 @@ +{ + "src": [ + "pages/Index" + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/resources/en_US/element/string.json b/drumming/drummer/entry/src/main/resources/en_US/element/string.json new file mode 100644 index 0000000..f945955 --- /dev/null +++ b/drumming/drummer/entry/src/main/resources/en_US/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "module description" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/main/resources/zh_CN/element/string.json b/drumming/drummer/entry/src/main/resources/zh_CN/element/string.json new file mode 100644 index 0000000..597ecf9 --- /dev/null +++ b/drumming/drummer/entry/src/main/resources/zh_CN/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_desc", + "value": "模块描述" + }, + { + "name": "EntryAbility_desc", + "value": "description" + }, + { + "name": "EntryAbility_label", + "value": "label" + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/ets/test/Ability.test.ets b/drumming/drummer/entry/src/ohosTest/ets/test/Ability.test.ets new file mode 100644 index 0000000..8aa3749 --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/ets/test/Ability.test.ets @@ -0,0 +1,35 @@ +import hilog from '@ohos.hilog'; +import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'; + +export default function abilityTest() { + describe('ActsAbilityTest', () => { + // Defines a test suite. Two parameters are supported: test suite name and test suite function. + beforeAll(() => { + // Presets an action, which is performed only once before all test cases of the test suite start. + // This API supports only one parameter: preset action function. + }) + beforeEach(() => { + // Presets an action, which is performed before each unit test case starts. + // The number of execution times is the same as the number of test cases defined by **it**. + // This API supports only one parameter: preset action function. + }) + afterEach(() => { + // Presets a clear action, which is performed after each unit test case ends. + // The number of execution times is the same as the number of test cases defined by **it**. + // This API supports only one parameter: clear action function. + }) + afterAll(() => { + // Presets a clear action, which is performed after all test cases of the test suite end. + // This API supports only one parameter: clear action function. + }) + it('assertContain', 0, () => { + // Defines a test case. This API supports three parameters: test case name, filter parameter, and test case function. + hilog.info(0x0000, 'testTag', '%{public}s', 'it begin'); + let a = 'abc'; + let b = 'b'; + // Defines a variety of assertion methods, which are used to declare expected boolean conditions. + expect(a).assertContain(b); + expect(a).assertEqual(a); + }) + }) +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/ets/test/List.test.ets b/drumming/drummer/entry/src/ohosTest/ets/test/List.test.ets new file mode 100644 index 0000000..794c7dc --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/ets/test/List.test.ets @@ -0,0 +1,5 @@ +import abilityTest from './Ability.test'; + +export default function testsuite() { + abilityTest(); +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/ets/testability/TestAbility.ets b/drumming/drummer/entry/src/ohosTest/ets/testability/TestAbility.ets new file mode 100644 index 0000000..9484761 --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/ets/testability/TestAbility.ets @@ -0,0 +1,50 @@ +import UIAbility from '@ohos.app.ability.UIAbility'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; +import hilog from '@ohos.hilog'; +import { Hypium } from '@ohos/hypium'; +import testsuite from '../test/List.test'; +import window from '@ohos.window'; +import Want from '@ohos.app.ability.Want'; +import AbilityConstant from '@ohos.app.ability.AbilityConstant'; + +export default class TestAbility extends UIAbility { + onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onCreate'); + hilog.info(0x0000, 'testTag', '%{public}s', 'want param:' + JSON.stringify(want) ?? ''); + hilog.info(0x0000, 'testTag', '%{public}s', 'launchParam:' + JSON.stringify(launchParam) ?? ''); + let abilityDelegator: AbilityDelegatorRegistry.AbilityDelegator; + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator(); + let abilityDelegatorArguments: AbilityDelegatorRegistry.AbilityDelegatorArgs; + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments(); + hilog.info(0x0000, 'testTag', '%{public}s', 'start run testcase!!!'); + Hypium.hypiumTest(abilityDelegator, abilityDelegatorArguments, testsuite); + } + + onDestroy() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onDestroy'); + } + + onWindowStageCreate(windowStage: window.WindowStage) { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageCreate'); + windowStage.loadContent('testability/pages/Index', (err, data) => { + if (err.code) { + hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? ''); + return; + } + hilog.info(0x0000, 'testTag', 'Succeeded in loading the content. Data: %{public}s', + JSON.stringify(data) ?? ''); + }); + } + + onWindowStageDestroy() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onWindowStageDestroy'); + } + + onForeground() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onForeground'); + } + + onBackground() { + hilog.info(0x0000, 'testTag', '%{public}s', 'TestAbility onBackground'); + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/ets/testability/pages/Index.ets b/drumming/drummer/entry/src/ohosTest/ets/testability/pages/Index.ets new file mode 100644 index 0000000..423b427 --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/ets/testability/pages/Index.ets @@ -0,0 +1,17 @@ +@Entry +@Component +struct Index { + @State message: string = 'Hello World'; + + build() { + Row() { + Column() { + Text(this.message) + .fontSize(50) + .fontWeight(FontWeight.Bold) + } + .width('100%') + } + .height('100%') + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/ets/testrunner/OpenHarmonyTestRunner.ets b/drumming/drummer/entry/src/ohosTest/ets/testrunner/OpenHarmonyTestRunner.ets new file mode 100644 index 0000000..917d27a --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/ets/testrunner/OpenHarmonyTestRunner.ets @@ -0,0 +1,47 @@ +import hilog from '@ohos.hilog'; +import TestRunner from '@ohos.application.testRunner'; +import AbilityDelegatorRegistry from '@ohos.app.ability.abilityDelegatorRegistry'; +import Want from '@ohos.app.ability.Want'; + +let abilityDelegator: AbilityDelegatorRegistry.AbilityDelegator | undefined = undefined +let abilityDelegatorArguments: AbilityDelegatorRegistry.AbilityDelegatorArgs | undefined = undefined + +async function onAbilityCreateCallback() { + hilog.info(0x0000, 'testTag', '%{public}s', 'onAbilityCreateCallback'); +} + +async function addAbilityMonitorCallback(err : Error) { + hilog.info(0x0000, 'testTag', 'addAbilityMonitorCallback : %{public}s', JSON.stringify(err) ?? ''); +} + +export default class OpenHarmonyTestRunner implements TestRunner { + constructor() { + } + + onPrepare() { + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner OnPrepare '); + } + + async onRun() { + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner onRun run'); + abilityDelegatorArguments = AbilityDelegatorRegistry.getArguments() + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator() + const bundleName = abilityDelegatorArguments.bundleName; + const testAbilityName = 'TestAbility'; + let lMonitor: AbilityDelegatorRegistry.AbilityMonitor = { + abilityName: testAbilityName, + onAbilityCreate: onAbilityCreateCallback, + }; + abilityDelegator.addAbilityMonitor(lMonitor, addAbilityMonitorCallback) + const want: Want = { + bundleName: bundleName, + abilityName: testAbilityName + }; + abilityDelegator = AbilityDelegatorRegistry.getAbilityDelegator(); + abilityDelegator.startAbility(want, (err, data) => { + hilog.info(0x0000, 'testTag', 'startAbility : err : %{public}s', JSON.stringify(err) ?? ''); + hilog.info(0x0000, 'testTag', 'startAbility : data : %{public}s',JSON.stringify(data) ?? ''); + }) + hilog.info(0x0000, 'testTag', '%{public}s', 'OpenHarmonyTestRunner onRun end'); + } +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/module.json5 b/drumming/drummer/entry/src/ohosTest/module.json5 new file mode 100644 index 0000000..4fc9701 --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/module.json5 @@ -0,0 +1,37 @@ +{ + "module": { + "name": "entry_test", + "type": "feature", + "description": "$string:module_test_desc", + "mainElement": "TestAbility", + "deviceTypes": [ + "default", + "tablet" + ], + "deliveryWithInstall": true, + "installationFree": false, + "pages": "$profile:test_pages", + "abilities": [ + { + "name": "TestAbility", + "srcEntry": "./ets/testability/TestAbility.ets", + "description": "$string:TestAbility_desc", + "icon": "$media:icon", + "label": "$string:TestAbility_label", + "exported": true, + "startWindowIcon": "$media:icon", + "startWindowBackground": "$color:start_window_background", + "skills": [ + { + "actions": [ + "action.system.home" + ], + "entities": [ + "entity.system.home" + ] + } + ] + } + ] + } +} diff --git a/drumming/drummer/entry/src/ohosTest/resources/base/element/color.json b/drumming/drummer/entry/src/ohosTest/resources/base/element/color.json new file mode 100644 index 0000000..3c71296 --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/resources/base/element/color.json @@ -0,0 +1,8 @@ +{ + "color": [ + { + "name": "start_window_background", + "value": "#FFFFFF" + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/resources/base/element/string.json b/drumming/drummer/entry/src/ohosTest/resources/base/element/string.json new file mode 100644 index 0000000..65d8fa5 --- /dev/null +++ b/drumming/drummer/entry/src/ohosTest/resources/base/element/string.json @@ -0,0 +1,16 @@ +{ + "string": [ + { + "name": "module_test_desc", + "value": "test ability description" + }, + { + "name": "TestAbility_desc", + "value": "the test ability" + }, + { + "name": "TestAbility_label", + "value": "test label" + } + ] +} \ No newline at end of file diff --git a/drumming/drummer/entry/src/ohosTest/resources/base/media/icon.png b/drumming/drummer/entry/src/ohosTest/resources/base/media/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..ce307a8827bd75456441ceb57d530e4c8d45d36c GIT binary patch literal 6790 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 { + // Defines a test suite. Two parameters are supported: test suite name and test suite function. + beforeAll(() => { + // Presets an action, which is performed only once before all test cases of the test suite start. + // This API supports only one parameter: preset action function. + }); + beforeEach(() => { + // Presets an action, which is performed before each unit test case starts. + // The number of execution times is the same as the number of test cases defined by **it**. + // This API supports only one parameter: preset action function. + }); + afterEach(() => { + // Presets a clear action, which is performed after each unit test case ends. + // The number of execution times is the same as the number of test cases defined by **it**. + // This API supports only one parameter: clear action function. + }); + afterAll(() => { + // Presets a clear action, which is performed after all test cases of the test suite end. + // This API supports only one parameter: clear action function. + }); + it('assertContain', 0, () => { + // Defines a test case. This API supports three parameters: test case name, filter parameter, and test case function. + let a = 'abc'; + let b = 'b'; + // Defines a variety of assertion methods, which are used to declare expected boolean conditions. + expect(a).assertContain(b); + expect(a).assertEqual(a); + }); + }); +} \ No newline at end of file diff --git a/drumming/drummer/hvigor/hvigor-config.json5 b/drumming/drummer/hvigor/hvigor-config.json5 new file mode 100644 index 0000000..1a47490 --- /dev/null +++ b/drumming/drummer/hvigor/hvigor-config.json5 @@ -0,0 +1,18 @@ +{ + "hvigorVersion": "3.0.9", + "dependencies": { + "@ohos/hvigor-ohos-plugin": "3.0.9" + }, + "execution": { + // "daemon": true, /* Enable daemon compilation. Default: true */ + // "incremental": true, /* Enable incremental compilation. Default: true */ + // "parallel": true, /* Enable parallel compilation. Default: true */ + // "typeCheck": false, /* Enable typeCheck. Default: false */ + }, + "logging": { + // "level": "info" /* Define the log level. Value: [ "debug" | "info" | "warn" | "error" ]. Default: "info" */ + }, + "debugging": { + // "stacktrace": false /* Disable stacktrace compilation. Default: false */ + } +} diff --git a/drumming/drummer/hvigor/hvigor-wrapper.js b/drumming/drummer/hvigor/hvigor-wrapper.js new file mode 100644 index 0000000..372eae8 --- /dev/null +++ b/drumming/drummer/hvigor/hvigor-wrapper.js @@ -0,0 +1 @@ +"use strict";var u=require("path"),D=require("os"),e=require("fs"),t=require("crypto"),r=require("child_process"),n="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},i={},C={},F=n&&n.__importDefault||function(u){return u&&u.__esModule?u:{default:u}};Object.defineProperty(C,"__esModule",{value:!0}),C.maxPathLength=C.isMac=C.isLinux=C.isWindows=void 0;const E=F(D),A="Windows_NT",o="Darwin";function a(){return E.default.type()===A}function c(){return E.default.type()===o}C.isWindows=a,C.isLinux=function(){return"Linux"===E.default.type()},C.isMac=c,C.maxPathLength=function(){return c()?1016:a()?259:4095},function(e){var t=n&&n.__createBinding||(Object.create?function(u,D,e,t){void 0===t&&(t=e);var r=Object.getOwnPropertyDescriptor(D,e);r&&!("get"in r?!D.__esModule:r.writable||r.configurable)||(r={enumerable:!0,get:function(){return D[e]}}),Object.defineProperty(u,t,r)}:function(u,D,e,t){void 0===t&&(t=e),u[t]=D[e]}),r=n&&n.__setModuleDefault||(Object.create?function(u,D){Object.defineProperty(u,"default",{enumerable:!0,value:D})}:function(u,D){u.default=D}),i=n&&n.__importStar||function(u){if(u&&u.__esModule)return u;var D={};if(null!=u)for(var e in u)"default"!==e&&Object.prototype.hasOwnProperty.call(u,e)&&t(D,u,e);return r(D,u),D};Object.defineProperty(e,"__esModule",{value:!0}),e.WORK_SPACE=e.HVIGOR_PROJECT_WRAPPER_HOME=e.HVIGOR_PROJECT_ROOT_DIR=e.HVIGOR_PROJECT_CACHES_HOME=e.HVIGOR_PNPM_STORE_PATH=e.HVIGOR_WRAPPER_PNPM_SCRIPT_PATH=e.PROJECT_CACHES=e.HVIGOR_WRAPPER_TOOLS_HOME=e.HVIGOR_USER_HOME=e.DEFAULT_PACKAGE_JSON=e.DEFAULT_HVIGOR_CONFIG_JSON_FILE_NAME=e.PNPM=e.HVIGOR=e.NPM_TOOL=e.PNPM_TOOL=e.HVIGOR_ENGINE_PACKAGE_NAME=void 0;const F=i(D),E=i(u),A=C;e.HVIGOR_ENGINE_PACKAGE_NAME="@ohos/hvigor",e.PNPM_TOOL=(0,A.isWindows)()?"pnpm.cmd":"pnpm",e.NPM_TOOL=(0,A.isWindows)()?"npm.cmd":"npm",e.HVIGOR="hvigor",e.PNPM="pnpm",e.DEFAULT_HVIGOR_CONFIG_JSON_FILE_NAME="hvigor-config.json5",e.DEFAULT_PACKAGE_JSON="package.json",e.HVIGOR_USER_HOME=E.resolve(F.homedir(),".hvigor"),e.HVIGOR_WRAPPER_TOOLS_HOME=E.resolve(e.HVIGOR_USER_HOME,"wrapper","tools"),e.PROJECT_CACHES="project_caches",e.HVIGOR_WRAPPER_PNPM_SCRIPT_PATH=E.resolve(e.HVIGOR_WRAPPER_TOOLS_HOME,"node_modules",".bin",e.PNPM_TOOL),e.HVIGOR_PNPM_STORE_PATH=E.resolve(e.HVIGOR_USER_HOME,"caches"),e.HVIGOR_PROJECT_CACHES_HOME=E.resolve(e.HVIGOR_USER_HOME,e.PROJECT_CACHES),e.HVIGOR_PROJECT_ROOT_DIR=process.cwd(),e.HVIGOR_PROJECT_WRAPPER_HOME=E.resolve(e.HVIGOR_PROJECT_ROOT_DIR,e.HVIGOR),e.WORK_SPACE="workspace"}(i);var s={},l={};Object.defineProperty(l,"__esModule",{value:!0}),l.logInfoPrintConsole=l.logErrorAndExit=void 0,l.logErrorAndExit=function(u){u instanceof Error?console.error(u.message):console.error(u),process.exit(-1)},l.logInfoPrintConsole=function(u){console.log(u)};var B=n&&n.__createBinding||(Object.create?function(u,D,e,t){void 0===t&&(t=e);var r=Object.getOwnPropertyDescriptor(D,e);r&&!("get"in r?!D.__esModule:r.writable||r.configurable)||(r={enumerable:!0,get:function(){return D[e]}}),Object.defineProperty(u,t,r)}:function(u,D,e,t){void 0===t&&(t=e),u[t]=D[e]}),d=n&&n.__setModuleDefault||(Object.create?function(u,D){Object.defineProperty(u,"default",{enumerable:!0,value:D})}:function(u,D){u.default=D}),f=n&&n.__importStar||function(u){if(u&&u.__esModule)return u;var D={};if(null!=u)for(var e in u)"default"!==e&&Object.prototype.hasOwnProperty.call(u,e)&&B(D,u,e);return d(D,u),D};Object.defineProperty(s,"__esModule",{value:!0});var _=s.executeBuild=void 0;const p=f(e),O=f(u),h=l;_=s.executeBuild=function(u){const D=O.resolve(u,"node_modules","@ohos","hvigor","bin","hvigor.js");try{const u=p.realpathSync(D);require(u)}catch(e){(0,h.logErrorAndExit)(`Error: ENOENT: no such file ${D},delete ${u} and retry.`)}};var P={},v={};!function(u){var D=n&&n.__importDefault||function(u){return u&&u.__esModule?u:{default:u}};Object.defineProperty(u,"__esModule",{value:!0}),u.hashFile=u.hash=u.createHash=void 0;const r=D(t),i=D(e);u.createHash=(u="MD5")=>r.default.createHash(u);u.hash=(D,e)=>(0,u.createHash)(e).update(D).digest("hex");u.hashFile=(D,e)=>{if(i.default.existsSync(D))return(0,u.hash)(i.default.readFileSync(D,"utf-8"),e)}}(v);var g={},m={},R={};Object.defineProperty(R,"__esModule",{value:!0}),R.Unicode=void 0;class y{}R.Unicode=y,y.SPACE_SEPARATOR=/[\u1680\u2000-\u200A\u202F\u205F\u3000]/,y.ID_START=/[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDF00-\uDF19]|\uD806[\uDCA0-\uDCDF\uDCFF\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE83\uDE86-\uDE89\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50\uDF93-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]/,y.ID_CONTINUE=/[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08BD\u08D4-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1CD0-\u1CD2\u1CD4-\u1CF9\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312E\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FEA\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7AE\uA7B0-\uA7B7\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB65\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE33\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDCA-\uDDCC\uDDD0-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3C-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB7\uDEC0-\uDEC9\uDF00-\uDF19\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDCA0-\uDCE9\uDCFF\uDE00-\uDE3E\uDE47\uDE50-\uDE83\uDE86-\uDE99\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDF00-\uDF44\uDF50-\uDF7E\uDF8F-\uDF9F\uDFE0\uDFE1]|\uD821[\uDC00-\uDFEC]|\uD822[\uDC00-\uDEF2]|\uD82C[\uDC00-\uDD1E\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4A\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDED6\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uDB40[\uDD00-\uDDEF]/,Object.defineProperty(m,"__esModule",{value:!0}),m.JudgeUtil=void 0;const I=R;m.JudgeUtil=class{static isIgnoreChar(u){return"string"==typeof u&&("\t"===u||"\v"===u||"\f"===u||" "===u||" "===u||"\ufeff"===u||"\n"===u||"\r"===u||"\u2028"===u||"\u2029"===u)}static isSpaceSeparator(u){return"string"==typeof u&&I.Unicode.SPACE_SEPARATOR.test(u)}static isIdStartChar(u){return"string"==typeof u&&(u>="a"&&u<="z"||u>="A"&&u<="Z"||"$"===u||"_"===u||I.Unicode.ID_START.test(u))}static isIdContinueChar(u){return"string"==typeof u&&(u>="a"&&u<="z"||u>="A"&&u<="Z"||u>="0"&&u<="9"||"$"===u||"_"===u||"‌"===u||"‍"===u||I.Unicode.ID_CONTINUE.test(u))}static isDigitWithoutZero(u){return/[1-9]/.test(u)}static isDigit(u){return"string"==typeof u&&/[0-9]/.test(u)}static isHexDigit(u){return"string"==typeof u&&/[0-9A-Fa-f]/.test(u)}};var N=n&&n.__importDefault||function(u){return u&&u.__esModule?u:{default:u}};Object.defineProperty(g,"__esModule",{value:!0}),g.parseJsonText=g.parseJsonFile=void 0;const b=N(e),S=N(D),w=N(u),H=m;var x;!function(u){u[u.Char=0]="Char",u[u.EOF=1]="EOF",u[u.Identifier=2]="Identifier"}(x||(x={}));let M,T,V,G,j,J,W="start",U=[],L=0,$=1,k=0,K=!1,z="default",q="'",Z=1;function X(u,D=!1){T=String(u),W="start",U=[],L=0,$=1,k=0,G=void 0,K=D;do{M=Q(),nu[W]()}while("eof"!==M.type);return G}function Q(){for(z="default",j="",q="'",Z=1;;){J=Y();const u=Du[z]();if(u)return u}}function Y(){if(T[L])return String.fromCodePoint(T.codePointAt(L))}function uu(){const u=Y();return"\n"===u?($++,k=0):u?k+=u.length:k++,u&&(L+=u.length),u}g.parseJsonFile=function(u,D=!1,e="utf-8"){const t=b.default.readFileSync(w.default.resolve(u),{encoding:e});try{return X(t,D)}catch(D){if(D instanceof SyntaxError){const e=D.message.split("at");if(2===e.length)throw new Error(`${e[0].trim()}${S.default.EOL}\t at ${u}:${e[1].trim()}`)}throw new Error(`${u} is not in valid JSON/JSON5 format.`)}},g.parseJsonText=X;const Du={default(){switch(J){case"/":return uu(),void(z="comment");case void 0:return uu(),eu("eof")}if(!H.JudgeUtil.isIgnoreChar(J)&&!H.JudgeUtil.isSpaceSeparator(J))return Du[W]();uu()},start(){z="value"},beforePropertyName(){switch(J){case"$":case"_":return j=uu(),void(z="identifierName");case"\\":return uu(),void(z="identifierNameStartEscape");case"}":return eu("punctuator",uu());case'"':case"'":return q=J,uu(),void(z="string")}if(H.JudgeUtil.isIdStartChar(J))return j+=uu(),void(z="identifierName");throw Eu(x.Char,uu())},afterPropertyName(){if(":"===J)return eu("punctuator",uu());throw Eu(x.Char,uu())},beforePropertyValue(){z="value"},afterPropertyValue(){switch(J){case",":case"}":return eu("punctuator",uu())}throw Eu(x.Char,uu())},beforeArrayValue(){if("]"===J)return eu("punctuator",uu());z="value"},afterArrayValue(){switch(J){case",":case"]":return eu("punctuator",uu())}throw Eu(x.Char,uu())},end(){throw Eu(x.Char,uu())},comment(){switch(J){case"*":return uu(),void(z="multiLineComment");case"/":return uu(),void(z="singleLineComment")}throw Eu(x.Char,uu())},multiLineComment(){switch(J){case"*":return uu(),void(z="multiLineCommentAsterisk");case void 0:throw Eu(x.Char,uu())}uu()},multiLineCommentAsterisk(){switch(J){case"*":return void uu();case"/":return uu(),void(z="default");case void 0:throw Eu(x.Char,uu())}uu(),z="multiLineComment"},singleLineComment(){switch(J){case"\n":case"\r":case"\u2028":case"\u2029":return uu(),void(z="default");case void 0:return uu(),eu("eof")}uu()},value(){switch(J){case"{":case"[":return eu("punctuator",uu());case"n":return uu(),tu("ull"),eu("null",null);case"t":return uu(),tu("rue"),eu("boolean",!0);case"f":return uu(),tu("alse"),eu("boolean",!1);case"-":case"+":return"-"===uu()&&(Z=-1),void(z="numerical");case".":case"0":case"I":case"N":return void(z="numerical");case'"':case"'":return q=J,uu(),j="",void(z="string")}if(void 0===J||!H.JudgeUtil.isDigitWithoutZero(J))throw Eu(x.Char,uu());z="numerical"},numerical(){switch(J){case".":return j=uu(),void(z="decimalPointLeading");case"0":return j=uu(),void(z="zero");case"I":return uu(),tu("nfinity"),eu("numeric",Z*(1/0));case"N":return uu(),tu("aN"),eu("numeric",NaN)}if(void 0!==J&&H.JudgeUtil.isDigitWithoutZero(J))return j=uu(),void(z="decimalInteger");throw Eu(x.Char,uu())},zero(){switch(J){case".":case"e":case"E":return void(z="decimal");case"x":case"X":return j+=uu(),void(z="hexadecimal")}return eu("numeric",0)},decimalInteger(){switch(J){case".":case"e":case"E":return void(z="decimal")}if(!H.JudgeUtil.isDigit(J))return eu("numeric",Z*Number(j));j+=uu()},decimal(){switch(J){case".":j+=uu(),z="decimalFraction";break;case"e":case"E":j+=uu(),z="decimalExponent"}},decimalPointLeading(){if(H.JudgeUtil.isDigit(J))return j+=uu(),void(z="decimalFraction");throw Eu(x.Char,uu())},decimalFraction(){switch(J){case"e":case"E":return j+=uu(),void(z="decimalExponent")}if(!H.JudgeUtil.isDigit(J))return eu("numeric",Z*Number(j));j+=uu()},decimalExponent(){switch(J){case"+":case"-":return j+=uu(),void(z="decimalExponentSign")}if(H.JudgeUtil.isDigit(J))return j+=uu(),void(z="decimalExponentInteger");throw Eu(x.Char,uu())},decimalExponentSign(){if(H.JudgeUtil.isDigit(J))return j+=uu(),void(z="decimalExponentInteger");throw Eu(x.Char,uu())},decimalExponentInteger(){if(!H.JudgeUtil.isDigit(J))return eu("numeric",Z*Number(j));j+=uu()},hexadecimal(){if(H.JudgeUtil.isHexDigit(J))return j+=uu(),void(z="hexadecimalInteger");throw Eu(x.Char,uu())},hexadecimalInteger(){if(!H.JudgeUtil.isHexDigit(J))return eu("numeric",Z*Number(j));j+=uu()},identifierNameStartEscape(){if("u"!==J)throw Eu(x.Char,uu());uu();const u=ru();switch(u){case"$":case"_":break;default:if(!H.JudgeUtil.isIdStartChar(u))throw Eu(x.Identifier)}j+=u,z="identifierName"},identifierName(){switch(J){case"$":case"_":case"‌":case"‍":return void(j+=uu());case"\\":return uu(),void(z="identifierNameEscape")}if(!H.JudgeUtil.isIdContinueChar(J))return eu("identifier",j);j+=uu()},identifierNameEscape(){if("u"!==J)throw Eu(x.Char,uu());uu();const u=ru();switch(u){case"$":case"_":case"‌":case"‍":break;default:if(!H.JudgeUtil.isIdContinueChar(u))throw Eu(x.Identifier)}j+=u,z="identifierName"},string(){switch(J){case"\\":return uu(),void(j+=function(){const u=Y(),D=function(){switch(Y()){case"b":return uu(),"\b";case"f":return uu(),"\f";case"n":return uu(),"\n";case"r":return uu(),"\r";case"t":return uu(),"\t";case"v":return uu(),"\v"}return}();if(D)return D;switch(u){case"0":if(uu(),H.JudgeUtil.isDigit(Y()))throw Eu(x.Char,uu());return"\0";case"x":return uu(),function(){let u="",D=Y();if(!H.JudgeUtil.isHexDigit(D))throw Eu(x.Char,uu());if(u+=uu(),D=Y(),!H.JudgeUtil.isHexDigit(D))throw Eu(x.Char,uu());return u+=uu(),String.fromCodePoint(parseInt(u,16))}();case"u":return uu(),ru();case"\n":case"\u2028":case"\u2029":return uu(),"";case"\r":return uu(),"\n"===Y()&&uu(),""}if(void 0===u||H.JudgeUtil.isDigitWithoutZero(u))throw Eu(x.Char,uu());return uu()}());case'"':case"'":if(J===q){const u=eu("string",j);return uu(),u}return void(j+=uu());case"\n":case"\r":case void 0:throw Eu(x.Char,uu());case"\u2028":case"\u2029":!function(u){console.warn(`JSON5: '${Fu(u)}' in strings is not valid ECMAScript; consider escaping.`)}(J)}j+=uu()}};function eu(u,D){return{type:u,value:D,line:$,column:k}}function tu(u){for(const D of u){if(Y()!==D)throw Eu(x.Char,uu());uu()}}function ru(){let u="",D=4;for(;D-- >0;){const D=Y();if(!H.JudgeUtil.isHexDigit(D))throw Eu(x.Char,uu());u+=uu()}return String.fromCodePoint(parseInt(u,16))}const nu={start(){if("eof"===M.type)throw Eu(x.EOF);iu()},beforePropertyName(){switch(M.type){case"identifier":case"string":return V=M.value,void(W="afterPropertyName");case"punctuator":return void Cu();case"eof":throw Eu(x.EOF)}},afterPropertyName(){if("eof"===M.type)throw Eu(x.EOF);W="beforePropertyValue"},beforePropertyValue(){if("eof"===M.type)throw Eu(x.EOF);iu()},afterPropertyValue(){if("eof"===M.type)throw Eu(x.EOF);switch(M.value){case",":return void(W="beforePropertyName");case"}":Cu()}},beforeArrayValue(){if("eof"===M.type)throw Eu(x.EOF);"punctuator"!==M.type||"]"!==M.value?iu():Cu()},afterArrayValue(){if("eof"===M.type)throw Eu(x.EOF);switch(M.value){case",":return void(W="beforeArrayValue");case"]":Cu()}},end(){}};function iu(){const u=function(){let u;switch(M.type){case"punctuator":switch(M.value){case"{":u={};break;case"[":u=[]}break;case"null":case"boolean":case"numeric":case"string":u=M.value}return u}();if(K&&"object"==typeof u&&(u._line=$,u._column=k),void 0===G)G=u;else{const D=U[U.length-1];Array.isArray(D)?K&&"object"!=typeof u?D.push({value:u,_line:$,_column:k}):D.push(u):D[V]=K&&"object"!=typeof u?{value:u,_line:$,_column:k}:u}!function(u){if(u&&"object"==typeof u)U.push(u),W=Array.isArray(u)?"beforeArrayValue":"beforePropertyName";else{const u=U[U.length-1];W=u?Array.isArray(u)?"afterArrayValue":"afterPropertyValue":"end"}}(u)}function Cu(){U.pop();const u=U[U.length-1];W=u?Array.isArray(u)?"afterArrayValue":"afterPropertyValue":"end"}function Fu(u){const D={"'":"\\'",'"':'\\"',"\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\v":"\\v","\0":"\\0","\u2028":"\\u2028","\u2029":"\\u2029"};if(D[u])return D[u];if(u<" "){const D=u.charCodeAt(0).toString(16);return`\\x${`00${D}`.substring(D.length)}`}return u}function Eu(u,D){let e="";switch(u){case x.Char:e=void 0===D?`JSON5: invalid end of input at ${$}:${k}`:`JSON5: invalid character '${Fu(D)}' at ${$}:${k}`;break;case x.EOF:e=`JSON5: invalid end of input at ${$}:${k}`;break;case x.Identifier:k-=5,e=`JSON5: invalid identifier character at ${$}:${k}`}const t=new Au(e);return t.lineNumber=$,t.columnNumber=k,t}class Au extends SyntaxError{}var ou={},au=n&&n.__createBinding||(Object.create?function(u,D,e,t){void 0===t&&(t=e);var r=Object.getOwnPropertyDescriptor(D,e);r&&!("get"in r?!D.__esModule:r.writable||r.configurable)||(r={enumerable:!0,get:function(){return D[e]}}),Object.defineProperty(u,t,r)}:function(u,D,e,t){void 0===t&&(t=e),u[t]=D[e]}),cu=n&&n.__setModuleDefault||(Object.create?function(u,D){Object.defineProperty(u,"default",{enumerable:!0,value:D})}:function(u,D){u.default=D}),su=n&&n.__importStar||function(u){if(u&&u.__esModule)return u;var D={};if(null!=u)for(var e in u)"default"!==e&&Object.prototype.hasOwnProperty.call(u,e)&&au(D,u,e);return cu(D,u),D},lu=n&&n.__importDefault||function(u){return u&&u.__esModule?u:{default:u}};Object.defineProperty(ou,"__esModule",{value:!0}),ou.isFileExists=ou.offlinePluginConversion=ou.executeCommand=ou.getNpmPath=ou.hasNpmPackInPaths=void 0;const Bu=r,du=lu(e),fu=su(u),_u=i,pu=l;ou.hasNpmPackInPaths=function(u,D){try{return require.resolve(u,{paths:[...D]}),!0}catch(u){return!1}},ou.getNpmPath=function(){const u=process.execPath;return fu.join(fu.dirname(u),_u.NPM_TOOL)},ou.executeCommand=function(u,D,e){0!==(0,Bu.spawnSync)(u,D,e).status&&(0,pu.logErrorAndExit)(`Error: ${u} ${D} execute failed.See above for details.`)},ou.offlinePluginConversion=function(u,D){return D.startsWith("file:")||D.endsWith(".tgz")?fu.resolve(u,_u.HVIGOR,D.replace("file:","")):D},ou.isFileExists=function(u){return du.default.existsSync(u)&&du.default.statSync(u).isFile()};var Ou=n&&n.__createBinding||(Object.create?function(u,D,e,t){void 0===t&&(t=e);var r=Object.getOwnPropertyDescriptor(D,e);r&&!("get"in r?!D.__esModule:r.writable||r.configurable)||(r={enumerable:!0,get:function(){return D[e]}}),Object.defineProperty(u,t,r)}:function(u,D,e,t){void 0===t&&(t=e),u[t]=D[e]}),hu=n&&n.__setModuleDefault||(Object.create?function(u,D){Object.defineProperty(u,"default",{enumerable:!0,value:D})}:function(u,D){u.default=D}),Pu=n&&n.__importStar||function(u){if(u&&u.__esModule)return u;var D={};if(null!=u)for(var e in u)"default"!==e&&Object.prototype.hasOwnProperty.call(u,e)&&Ou(D,u,e);return hu(D,u),D},vu=n&&n.__importDefault||function(u){return u&&u.__esModule?u:{default:u}};Object.defineProperty(P,"__esModule",{value:!0});var gu=P.initProjectWorkSpace=void 0;const mu=Pu(e),Ru=vu(D),yu=Pu(u),Iu=v,Nu=i,bu=g,Su=l,wu=ou;let Hu,xu,Mu;function Tu(u,D,e){return void 0!==e.dependencies&&(0,wu.offlinePluginConversion)(Nu.HVIGOR_PROJECT_ROOT_DIR,D.dependencies[u])===yu.normalize(e.dependencies[u])}function Vu(){const u=yu.join(Mu,Nu.WORK_SPACE);if((0,Su.logInfoPrintConsole)("Hvigor cleaning..."),!mu.existsSync(u))return;const D=mu.readdirSync(u);if(!D||0===D.length)return;const e=yu.resolve(Mu,"node_modules","@ohos","hvigor","bin","hvigor.js");mu.existsSync(e)&&(0,wu.executeCommand)(process.argv[0],[e,"--stop-daemon"],{});try{D.forEach((D=>{mu.rmSync(yu.resolve(u,D),{recursive:!0})}))}catch(D){(0,Su.logErrorAndExit)(`The hvigor build tool cannot be installed. Please manually clear the workspace directory and synchronize the project again.\n\n Workspace Path: ${u}.`)}}gu=P.initProjectWorkSpace=function(){if(Hu=function(){const u=yu.resolve(Nu.HVIGOR_PROJECT_WRAPPER_HOME,Nu.DEFAULT_HVIGOR_CONFIG_JSON_FILE_NAME);mu.existsSync(u)||(0,Su.logErrorAndExit)(`Error: Hvigor config file ${u} does not exist.`);return(0,bu.parseJsonFile)(u)}(),Mu=function(u){let D;D=function(u){let D=u.hvigorVersion;if(D.startsWith("file:")||D.endsWith(".tgz"))return!1;const e=u.dependencies,t=Object.getOwnPropertyNames(e);for(const u of t){const D=e[u];if(D.startsWith("file:")||D.endsWith(".tgz"))return!1}if(1===t.length&&"@ohos/hvigor-ohos-plugin"===t[0])return D>"2.5.0";return!1}(u)?function(u){let D=`${Nu.HVIGOR_ENGINE_PACKAGE_NAME}@${u.hvigorVersion}`;const e=u.dependencies;if(e){Object.getOwnPropertyNames(e).sort().forEach((u=>{D+=`,${u}@${e[u]}`}))}return(0,Iu.hash)(D)}(u):(0,Iu.hash)(process.cwd());return yu.resolve(Ru.default.homedir(),".hvigor","project_caches",D)}(Hu),xu=function(){const u=yu.resolve(Mu,Nu.WORK_SPACE,Nu.DEFAULT_PACKAGE_JSON);return mu.existsSync(u)?(0,bu.parseJsonFile)(u):{dependencies:{}}}(),!(0,wu.hasNpmPackInPaths)(Nu.HVIGOR_ENGINE_PACKAGE_NAME,[yu.join(Mu,Nu.WORK_SPACE)])||(0,wu.offlinePluginConversion)(Nu.HVIGOR_PROJECT_ROOT_DIR,Hu.hvigorVersion)!==xu.dependencies[Nu.HVIGOR_ENGINE_PACKAGE_NAME]||!function(){function u(u){const D=null==u?void 0:u.dependencies;return void 0===D?0:Object.getOwnPropertyNames(D).length}const D=u(Hu),e=u(xu);if(D+1!==e)return!1;for(const u in null==Hu?void 0:Hu.dependencies)if(!(0,wu.hasNpmPackInPaths)(u,[yu.join(Mu,Nu.WORK_SPACE)])||!Tu(u,Hu,xu))return!1;return!0}()){Vu();try{!function(){(0,Su.logInfoPrintConsole)("Hvigor installing...");for(const u in Hu.dependencies)Hu.dependencies[u]&&(Hu.dependencies[u]=(0,wu.offlinePluginConversion)(Nu.HVIGOR_PROJECT_ROOT_DIR,Hu.dependencies[u]));const u={dependencies:{...Hu.dependencies}};u.dependencies[Nu.HVIGOR_ENGINE_PACKAGE_NAME]=(0,wu.offlinePluginConversion)(Nu.HVIGOR_PROJECT_ROOT_DIR,Hu.hvigorVersion);const D=yu.join(Mu,Nu.WORK_SPACE);try{mu.mkdirSync(D,{recursive:!0});const e=yu.resolve(D,Nu.DEFAULT_PACKAGE_JSON);mu.writeFileSync(e,JSON.stringify(u))}catch(u){(0,Su.logErrorAndExit)(u)}(function(){const u=["config","set","store-dir",Nu.HVIGOR_PNPM_STORE_PATH],D={cwd:yu.join(Mu,Nu.WORK_SPACE),stdio:["inherit","inherit","inherit"]};(0,wu.executeCommand)(Nu.HVIGOR_WRAPPER_PNPM_SCRIPT_PATH,u,D)})(),function(){const u=["install"],D={cwd:yu.join(Mu,Nu.WORK_SPACE),stdio:["inherit","inherit","inherit"]};(0,wu.executeCommand)(Nu.HVIGOR_WRAPPER_PNPM_SCRIPT_PATH,u,D)}(),(0,Su.logInfoPrintConsole)("Hvigor install success.")}()}catch(u){Vu()}}return Mu};var Gu={};!function(t){var C=n&&n.__createBinding||(Object.create?function(u,D,e,t){void 0===t&&(t=e);var r=Object.getOwnPropertyDescriptor(D,e);r&&!("get"in r?!D.__esModule:r.writable||r.configurable)||(r={enumerable:!0,get:function(){return D[e]}}),Object.defineProperty(u,t,r)}:function(u,D,e,t){void 0===t&&(t=e),u[t]=D[e]}),F=n&&n.__setModuleDefault||(Object.create?function(u,D){Object.defineProperty(u,"default",{enumerable:!0,value:D})}:function(u,D){u.default=D}),E=n&&n.__importStar||function(u){if(u&&u.__esModule)return u;var D={};if(null!=u)for(var e in u)"default"!==e&&Object.prototype.hasOwnProperty.call(u,e)&&C(D,u,e);return F(D,u),D},A=n&&n.__importDefault||function(u){return u&&u.__esModule?u:{default:u}};Object.defineProperty(t,"__esModule",{value:!0}),t.executeInstallPnpm=t.isPnpmInstalled=t.environmentHandler=t.checkNpmConifg=t.PNPM_VERSION=void 0;const o=r,a=E(e),c=A(D),s=E(u),B=i,d=l,f=ou;t.PNPM_VERSION="7.30.0",t.checkNpmConifg=function(){const u=s.resolve(B.HVIGOR_PROJECT_ROOT_DIR,".npmrc"),D=s.resolve(c.default.homedir(),".npmrc");if((0,f.isFileExists)(u)||(0,f.isFileExists)(D))return;const e=(0,f.getNpmPath)(),t=(0,o.spawnSync)(e,["config","get","prefix"],{cwd:B.HVIGOR_PROJECT_ROOT_DIR});if(0!==t.status||!t.stdout)return void(0,d.logErrorAndExit)("Error: The hvigor depends on the npmrc file. Configure the npmrc file first.");const r=s.resolve(`${t.stdout}`.replace(/[\r\n]/gi,""),".npmrc");(0,f.isFileExists)(r)||(0,d.logErrorAndExit)("Error: The hvigor depends on the npmrc file. Configure the npmrc file first.")},t.environmentHandler=function(){process.env["npm_config_update-notifier"]="false"},t.isPnpmInstalled=function(){return!!a.existsSync(B.HVIGOR_WRAPPER_PNPM_SCRIPT_PATH)&&(0,f.hasNpmPackInPaths)("pnpm",[B.HVIGOR_WRAPPER_TOOLS_HOME])},t.executeInstallPnpm=function(){(0,d.logInfoPrintConsole)(`Installing pnpm@${t.PNPM_VERSION}...`);const u=(0,f.getNpmPath)();!function(){const u=s.resolve(B.HVIGOR_WRAPPER_TOOLS_HOME,B.DEFAULT_PACKAGE_JSON);try{a.existsSync(B.HVIGOR_WRAPPER_TOOLS_HOME)||a.mkdirSync(B.HVIGOR_WRAPPER_TOOLS_HOME,{recursive:!0});const D={dependencies:{}};D.dependencies[B.PNPM]=t.PNPM_VERSION,a.writeFileSync(u,JSON.stringify(D))}catch(D){(0,d.logErrorAndExit)(`Error: EPERM: operation not permitted,create ${u} failed.`)}}(),(0,f.executeCommand)(u,["install","pnpm"],{cwd:B.HVIGOR_WRAPPER_TOOLS_HOME,stdio:["inherit","inherit","inherit"],env:process.env}),(0,d.logInfoPrintConsole)("Pnpm install success.")}}(Gu),function(){Gu.checkNpmConifg(),Gu.environmentHandler(),Gu.isPnpmInstalled()||Gu.executeInstallPnpm();const D=gu();_(u.join(D,i.WORK_SPACE))}(); \ No newline at end of file diff --git a/drumming/drummer/hvigorfile.ts b/drumming/drummer/hvigorfile.ts new file mode 100644 index 0000000..f3cb9f1 --- /dev/null +++ b/drumming/drummer/hvigorfile.ts @@ -0,0 +1,6 @@ +import { appTasks } from '@ohos/hvigor-ohos-plugin'; + +export default { + system: appTasks, /* Built-in plugin of Hvigor. It cannot be modified. */ + plugins:[] /* Custom plugin to extend the functionality of Hvigor. */ +} diff --git a/drumming/drummer/hvigorw b/drumming/drummer/hvigorw new file mode 100644 index 0000000..ff6a29a --- /dev/null +++ b/drumming/drummer/hvigorw @@ -0,0 +1,48 @@ +#!/bin/bash + +# ---------------------------------------------------------------------------- +# Hvigor startup script, version 1.0.0 +# +# Required ENV vars: +# ------------------ +# NODE_HOME - location of a Node home dir +# or +# Add /usr/local/nodejs/bin to the PATH environment variable +# ---------------------------------------------------------------------------- + +HVIGOR_APP_HOME="`pwd -P`" +HVIGOR_WRAPPER_SCRIPT=${HVIGOR_APP_HOME}/hvigor/hvigor-wrapper.js +warn() { + echo "" + echo -e "\033[1;33m`date '+[%Y-%m-%d %H:%M:%S]'`$@\033[0m" +} + +error() { + echo "" + echo -e "\033[1;31m`date '+[%Y-%m-%d %H:%M:%S]'`$@\033[0m" +} + +fail() { + error "$@" + exit 1 +} + +# Determine node to start hvigor wrapper script +if [ -n "${NODE_HOME}" ];then + EXECUTABLE_NODE="${NODE_HOME}/bin/node" + if [ ! -x "$EXECUTABLE_NODE" ];then + fail "ERROR: NODE_HOME is set to an invalid directory,check $NODE_HOME\n\nPlease set NODE_HOME in your environment to the location where your nodejs installed" + fi +else + EXECUTABLE_NODE="node" + which ${EXECUTABLE_NODE} > /dev/null 2>&1 || fail "ERROR: NODE_HOME is not set and not 'node' command found in your path" +fi + +# Check hvigor wrapper script +if [ ! -r "$HVIGOR_WRAPPER_SCRIPT" ];then + fail "ERROR: Couldn't find hvigor/hvigor-wrapper.js in ${HVIGOR_APP_HOME}" +fi + +# start hvigor-wrapper script +exec "${EXECUTABLE_NODE}" \ + "${HVIGOR_WRAPPER_SCRIPT}" "$@" diff --git a/drumming/drummer/hvigorw.bat b/drumming/drummer/hvigorw.bat new file mode 100644 index 0000000..d570007 --- /dev/null +++ b/drumming/drummer/hvigorw.bat @@ -0,0 +1,64 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Hvigor startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +set WRAPPER_MODULE_PATH=%APP_HOME%\hvigor\hvigor-wrapper.js +set NODE_EXE=node.exe + +goto start + +:start +@rem Find node.exe +if defined NODE_HOME goto findNodeFromNodeHome + +%NODE_EXE% --version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: NODE_HOME is not set and no 'node' command could be found in your PATH. +echo. +echo Please set the NODE_HOME variable in your environment to match the +echo location of your NodeJs installation. + +goto fail + +:findNodeFromNodeHome +set NODE_HOME=%NODE_HOME:"=% +set NODE_EXE_PATH=%NODE_HOME%/%NODE_EXE% + +if exist "%NODE_EXE_PATH%" goto execute +echo. +echo ERROR: NODE_HOME is not set and no 'node' command could be found in your PATH. +echo. +echo Please set the NODE_HOME variable in your environment to match the +echo location of your NodeJs installation. + +goto fail + +:execute +@rem Execute hvigor +"%NODE_EXE%" "%WRAPPER_MODULE_PATH%" %* + +if "%ERRORLEVEL%" == "0" goto hvigorwEnd + +:fail +exit /b 1 + +:hvigorwEnd +if "%OS%" == "Windows_NT" endlocal + +:end diff --git a/drumming/drummer/oh-package-lock.json5 b/drumming/drummer/oh-package-lock.json5 new file mode 100644 index 0000000..ddc8a54 --- /dev/null +++ b/drumming/drummer/oh-package-lock.json5 @@ -0,0 +1,13 @@ +{ + "lockfileVersion": 1, + "ATTENTION": "THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.", + "specifiers": { + "@ohos/hypium@1.0.11": "@ohos/hypium@1.0.11" + }, + "packages": { + "@ohos/hypium@1.0.11": { + "resolved": "https://repo.harmonyos.com/ohpm/@ohos/hypium/-/hypium-1.0.11.tgz", + "integrity": "sha512-KawcLnv43C3QIYv1UbDnKCFX3MohtDxGuFvzlUxT/qf2DBilR56Ws6zrj90LdH6PjloJQwOPESuBQIHBACAK7w==" + } + } +} \ No newline at end of file diff --git a/drumming/drummer/oh-package.json5 b/drumming/drummer/oh-package.json5 new file mode 100644 index 0000000..692f9ce --- /dev/null +++ b/drumming/drummer/oh-package.json5 @@ -0,0 +1,12 @@ +{ + "license": "", + "devDependencies": { + "@ohos/hypium": "1.0.11" + }, + "author": "", + "name": "drawpart3", + "description": "Please describe the basic information.", + "main": "", + "version": "1.0.0", + "dependencies": {} +} diff --git a/drumming/figs/evolution.png b/drumming/figs/evolution.png new file mode 100644 index 0000000000000000000000000000000000000000..4ad4eae26c38ad7b475c9251f23f3f27fce7975b GIT binary patch literal 154563 zcmd?QWl&sS+V0&*aBJM9Y24j|OXJo!1b24}!Gc4u#@%V$H6+2E;0{59Cuo3#~$I;-+RM0c}t3ily%u{K7K&mZ@#+v-1l(%(8OwItHKS ztZm<>WnPlAC@3mH{QRS1v!2gN{X8B7&3&?2O zc!i~=!HV0Shp~t*D{pDl@`*uCZ;p|aj43?g?VmLO7Si)&0U`kbl7OH0!#r_1q{A$# zR;1-T36|;qXr9>GeW^+4ml+TsK>RoX?0Tg-+7fTeNysvp130)E1+g*fF7V(Z-A(IG zGcbp#(yiO}b!ArExSnlpVAg(POwYBp;@E31XA3N~IAzRbtZ6ya+3mZK9}F5SUmMk@ zrGi=!`S@7SOHl6glz$2C3a=~Q;O1GVsc0Wso{FWeiQg3H_8h&BX(Mjw2SXTt)9K~^ z3Rno%?o}KDwYc7PR%zg+R^9asPHOH4o}?Ud(LGr~ul=vyi`_S94hF>ID}qa|Q2a-R z{WFHl!&z%@CcsjTsmjcq6*8o<7?AG+(P=J@SQY-o!_~e;f^@hFaMp zrzYy0N-1?7#g`+$2Q)6=ytDcW)7wNuttX;GULK=lP}+)7hloBlIAf*zp^1LcBdDT7 z-H--IT(aaZ7Yp7VWS#%;PV`-ze$0KDp37DT5&AAZlzQ1eJC4+_0Ylh+yoN*0X0U*l zzf5CN&cM#0&YQEw4VqKf(2;6~B*I~)T%{Dt5~GmDdu|Ed;xjyR3NQqd)yHY%6TR{- z#1ak=Tq+v3i=%YRv}q_+Adj5Wkazrg?f^vMy!*%lMY({Fmm4LLJ&3S;vcghOQ!tZ0 z%kM;Ye0r#*!`e`xE>DbY$2C5hrNiC#sH#}kAcoy~+_KDr zD|MaZl^{5Xp|8PujKp)+k*AwBjXCLZftp#JTm%SnsQ?cJ5?7dwWUF(^8afd_5Q*0feGci2fH z(TxopAutQME~zD^0SwQ^g8-vB*E%65R-)sv!)Ru!OW6Zr_1w5Ap z3{3{KaWxXWV|e6csd1bv$x(Q_{~sP;_nr_zkGDhPQ!V5k8j!k>_MB}hrxoi3@@g?y z6PpY^w~%!$u@7jzQBAO&$B&83O5JenpfD-$ycX_i++#?8Q`Z?Za3=r>WP3?`xtLEK zXbBpSP;)8euL-PO4DZ{5NPsjr zPS(~$;l9X$XdqrR5oA0i`YN!lhYt`CCWf@YySCAs9E@fYS*?>Si>RAal%fZ8iEqfo zm(VBacJe+*xdb|L*hMO(s{N9w6T82zx-a*C7bkDKdFr8AK*ykU?iZU?Jo@iG^-;*w zbnZ*r1S;q+nLOGdZ*e62MG1qa;}+dgONKfMQ!|Y~6`O$*8H=5tnmh`lE?3ds zo-Q?O2`cnJ<74H%wYJfdce>6l#By-kS+1@(vzO{kQ^CG>$Pc8icZzxIYQov&hg`tfG~qdQ;f;yyewCN(S4 zfsb)6l&P8tox290QZ!YDk|qWC^!`FP*L8LSOX>(~Qu47N%zuGZ8Cp z?Vwbc71KC9Z**j;w^bt``N|DEjpAw43)4)&*TG9 z9E>eb4+q~thc0q9MXZD6jN%P<@WE+s@M_e5i=Vt?F{9s2G3*H3&}E8&=mweY+A@1e z_$XbIB>!%LKlBEe<^R&JvJ@YRrBBrgKoYmw6IZcplqS*(v`M8EfG`l6=+I%&y#?P} z42-q6q3DQf?&c&ss!)w|U#*vf=#)67>HX(&|4 z$PK@mT|6QmUR~Ju3_nRFSsER>VJQD@JLsWoMLNVrb58XRv)X>%@Ay79^2V7dGx>Yq z??Uqrn+$o%kd|26;VxBpQ(BWj8IkV;fj?;!PCii+r3hh9#z|h=r*A?>XZGKP7WwV? zmMzR1HS~=?^6qrdZEacQE$7JgdN4>Rxyfixym*xYo@4$vGd3a^m+w1nQD&UUHYf?g zahKISJn9yqcs)Oho#iDN<;DFDrHjFa{i&HICFkMEHp3dUsAgYipaR-L&JbcS5`3W_ zJF3j^1?XPlCrJoz6mP9Y8LB$fNH?h@6N?XY%J6mHy*Q`x!7^?&32p(OuVb-nrB-)F zD9a0GGG5OmKr6=ulj9qSB9?GclqE5z0#*0euJ`$)c~&YL==vSy(d%hEG04tifrW|n z_pF#KB>Zsh9m-T2(+2i+ml@pyUf2B)Yb`DZt8|m2===c*%dqn3(SXhF=-nm3A>$eKarj*FxDzOZ7_QL!&qD=c;|Fv0~@c6F>Y`RHbmeW!9 zoD>&7muEN=P|~hsb)r3=yF={d@6&#|&k;$7LLpJ80@r zj9eW1R*h`(cEy05U~%a?R;SCTUq{wgfy3l)ln@PViqGlIpY-=3{BhiTR~}O(m8Q*E z4#WrJm$;*mMF9@l*zsCRh0I;*yne(t%j{=6Lz`=&C!`(roe#E<^>$L7_Y687DCu!7 zoN8aoNozFHUFb;6*-&e#K(NZ^DX>eDbCW%+|8>*>$Er!gOg3^Mj=<#QJ|W*aKD{J` z>33aXZGOEAt~9`|8VfL{hKYd|58Jx(EiPM<{{g4imfP&g>=!q<{j^wc}A3%^Yt+2whBo`vl^Yj6w4o>};5IGJDpy!pgA>ZhG zdBzHBIc?_>hvcFfbEq^PVG_uSbX$u%^slNJ#S*)ttLo9b7G+bwS~L}nYFup(XK0{A zh^_rB%&MqsElWqs51{+ANpl$41dZgI3|aJ|&jdF9@Sg5sJ;%+H;6jST?ZKd?G#vJZ}>?c;Z!q2sW9;5*&$IF*Xa-Ha+}d7#`N zg2~fvb(}5Mb(%M zDR#4yO#HRuyYR;?NCPKGmTkzD-uJLE#!Gzip^^p-k3082n-mO46UxcXMoFy?^5Y(9 zogEcjc6KaUsk{cUqgE9o&29lnaTnR_qobBfN=xOJB6VA1|H;Ug`sh!i5blmrys? z%D`CbM`fjFI4i2WF^20^nPc?cYohYk3NyxW;hTHjrnGFdJvQ^MT1JJ^-IZ+R zjpR{JLYZ$#;0SqT=Tb;rpmKvRD8joi&VO*Cf5Jxpx;bt!nw^vPhT%8OtXJy?%@w;2 zvqL9H>x(31+68n4akZ^f&#MTGSq1~6`TTkTSS|TW-KqIRZ79pIQ+(&HpqJNGqw9xU z8u3oIqc?5!znz_DH*KCcC|Znu=K0?1ES;&`<}q1WVmojV=rBua4EhJiW1?J03#8Xb zCRh)^czu3aw~A}JQ=6kKDit!c%0I$c%qFFbzWO`*gHExnoiL} z3*PGsX_{vlFJi>mrxK+@KKRMVqhk>2!KHl{Dpf-FS+RS(RUN-+uD-5K+6Qj>iZRa_ zbK9i!5FKoIH-@EmcNq(MJ)S_XfH4Wi`R(rh4as4RFeJ{m1lci))Jg5uVqW z2L&oe4Yb!dypP`&`?$V;%k%3?xyelX9e(iy`6}r&!Ta?+g=3ZAa>X3HAP;IAyRO?MCs+*|n7-k$~q z6~I@SUb0XW!XjYXf)aG_0nMM|xXi-uPqjlb64w`YdaIFIe&5=iY?_@E;JZp9r!VP> z6_S`;98d@uib?)&f@_E1pn$z3=3_!w!>CPq97ZG(0|m&1yPidzg?%hxIH6lEx_Pu~ zn5O^Gjrs>LDEtSoYE#Njn`{$B5cA3XG$DUtR!m-R6S0+#D;Q3s`WxL_N=0gw6^5HZjIJzLzA&ArsDXBcAK?sBPY`^e`gk7U5c>ZoCPuUOqeP zxKwwKF8uY|&Q09koQr*VMGp_WJi4_Lbs3+V-esk;(wc%QI@hH}%A zGpBdHol-n>zTU>RVD8wZvb9so(-nj-%U>iKg*HURt@PP9qpp zRvMI5#)5#XMT@!yq%H>nX&UyY2k2Mb4`c1e#EsDhtAQI^xdJ$lb!D5(o@ zNB1o)B3#Z?GP2WiXl{2~X1=Z-|NNV!b$d)NL1tPeSk6t!P^%GH42pvh3RSWqoxF8k z`1`64P0RV6{4-I+?HYBVApB>x&~n`q#X&*CP4sxrtLoQmU*CkihwN_&jsDvHZkK)k zisq5v{p3vDuMY>CnB&2Aut(0ig959KfauHz3L4bCUZEp5vYnm}L_5DPx9@&7yub4z z@_bt8p=P*>JrBvIXsTSjT=x}?Ty7Cq*1M12?|JQHYb2P>rekd>(W#A^D_q2iw+$Ny}m52SD}ir}dHk}UhmSy0d<<@$c|3T8mQpWftl#pR#- z9&~7l=#pA)qo2G>bgCh-__K2Yv@c=zqcozYWX z&;tstS$oK_!s~WxBqX0t%@f7jvE6uO?j=%TFF(^%56Ps+lzARXjkZ-}8g~my=jZUJ zCQ@YE;Jd=>@m1lqvFq8I#3v=5aI~so0^Lg1*zo9!X)W%Uy<543LX9ppkg>lHD1MWn z2g@Z@>Ijm>?%5<0_6d{BwbVf;ige0Gz=3~a@N-3Lgr5C!=TtCR9ljO_-wvH{+KMMy zr=8I`C4olRf^O>;VhmLvf`aMCY?E~Hp$`0(t8F2JA^~Lr0|q} zjA&md2I`@X@1(%oF@v(*3%_@!VR>=dbDYx&I{T}P(!Rd&DLXwE=TTTs;r3Km3$A zTJ9={OaVSHQ4lCfRpS7~6LTY$dFR3pJ;T_S3U@sRxLePQB^|vbN|NFkRIExWw5YtC z-!LAlb_~RnC$7ZGoLyU2KKHQNs7u|Q6UtfQqhQ!o5hvhW_D;c5;weFK5G?f+ z@rR?tskt6cl;;t`@7vIrm|4BSF5^nWIFH3dt;-|`*@4u!^&EFVcG#4~5jqz@@=ZntZKU+ruQe|t@T%*FKdV)HR=I%GM+ zX688=`zuaQqdDenk|@%JKm zI=o+_@DY9~f-cvK$VsUF^?>^;@{~G$d?~DB?#XpdHv1P})LVOE5!Tt7yD?VefqWrTq zv4+|Cii?>t+!uP*V?s_T4u&8y#tC7QBvLWZak%-$gOvsg5t#sE?hlvMxVqAW6n$<+ z47_r89dywfBmik3MWtCd-SRfQ?@$dN_N-^bijX$Xp=e@qAjg8^EmAtdf>kqI9?f<} zNhTCM#tr8vF&}_d!XQ|PigU8$X}mc$Z1nal!)WNDm?8bbqNAsy6Oo1g!7}NT1Iw24 z(mpkIj>S3)Yz`rdkZIpB_3bw{K7P(k^giUOEw^FosfqeI1v#A>r_$vr7oat$Nc76k zd0D4%^vjC3pcO-N2;BHw8TfzBlN5yxj@;nk{ys@L{R3Ee+P3($x@AjV#}k|5d#Ic% z#)Ow`Wmw@`XX3wvoe!M&VkEI(5+mxosW*HiuVv3csQP+dvy4ZT53#pfK3RI-ErvNph%U`kfV%yjD0#&Q1QdMXlsIQC7t}d>m|E$Kd#EcG8w*;Pnhm;NAQk; z;y7A5>9mj@hlem)D2$*RvCZ#uNVN6AxYdFvrJNk1o^1L7%P6g7mT3B?8$6n#=yTlt z$w-|6VMa2mG|~-Vm<`wtr)wi|8QzG6D}zv*CnWd-&`KcBtrK<7-6Z=nQ`3(gSGf}l zM;Z`eW-!cqZuT!0f|?GlwTZsnSIpV^7arY*ufI}tSQ)6j<+JqBj47VzTxz$ra`kK< zmKR&=bum5uocr3+URE^HambMIfVVCNDdYCh6~A~++Ygj5Py`GUISR*Ek@zY5?7)~%rgj8OKQEZ;pz3NdEbEhBk2#IWApX5mN?z{e_?L;*H!9Y$qgII=|j`?MAYx-pGMyfho`8P zUd_$+2sCt!xV@Ed9sFR}?<+{VlzJ(^8*%eXF*;qd(RH7|Xy$-xUspg~Hgy|!Rb-;F zvR0F##Y?PQ?-@n28~=*GVEiUrofVpEU2OoRa`sn|N!a8BR-a>3oXKR&V8;eO0$_vqkd_=1L z4$wCkr;7|67j~8pgKD!fiB50!a98NWj?2WiE#nj7SWrjehsOL2y}`*Z;DNzG*j4cO zg>xtdZ(v#|;3Tln)I?5c+1b9TD3yqiHC!Fi|J*b9<|Hu3igXi^S@J4{V0s z}-|^@Nb3LtNhek;1QMLi3C!^)9a?s zlH70b>@Ijz3txSG2-6Ipld#mij!nkI1bL_AEA0NWYVR%nYTdd8f-;0_7Iz=0$Kcc~s>w7(`Tc0HNta zKm>$4JRriTH}3!fEm5>1^VqLeUTz{!pp7mhaa|NCAn)x+j z6TEqugcI)6J?Gh7mhZQ>Ftgp!r`ue+oF>f_*8DWzQ9NI1j?!knq<{1(RlZ&pcqp8MAf}jE(_X|V87VC z5&yQ}K$|w#Yts9@b*gEN3#)KV(SWbR`6s(v%YvRRr`dHBeF}hKOa*+l_fyMLaZAuw zNOVW4%VgNf-w0!1EQ7D~He!1a4J-O1q$SPrQ&njFxKDhj-!jAg0M@y~lo4Ia(JgWC zytDOOo1MzcPoVfBx~iZ40OCB+<0N;16SF4LA{K;IXPsN2yGqwbseG~YZV#r==rZWN zYh67inr)JT6y`7~y46f*2IF9g(644t<4xQTE3y;b(R8_IM4!Y z(XilNhm%^wM=f`SoKHAbwAo(rCpCTIuA%k47K9zGK? zL%$7`0|M5kX(5xD-o5rSC-lY&XLUG`P{faXX)?iOT5n~vGDttM=DjF^Tdf+Joo1pz z4S1sh+63_2`k>aYE2^x%ua)JUuh5>GZF@08yQTGsE}O`KkOmGYT`;Rc@l0z2;Oxi2 ztU^im;&gldt?ZK4|4-%djO$n>Tupr!gAmU%p)HXX z`-IZ{s29u9+U=T3aHb=Pw>mgD`_*cvcL6iZ5NsGd7Oy^FX%o zan5@BeUxLaCVAO#Y-hePvCY>_lrJAVTdg9`@aDYU`X>*Z zK@5o~6!@dk$TVH3j|X@Kc)!Ya;^_zyJWHHw1z|tC?t{L*YRZ?MH#?~gj=So!5w=^z z_%+wkIruqt3ft?2S*6yIe{jy&x9zjj>n57CR3X=y<5T9(mGC$TF}8rfQ#7E?X@!J| zGvlAezvWUVFIrT+K0r;UG`p>qR8crTao^GnTm1tFY`Jx9@X z%&pBY{99f5SN@SbKP|_=J9wS|Pc&il?6$n6o(UOxq;Y6zjg$(RQv@I-hm4PA%Ml_m z7RN~p^JdDYkWsqozc2{=bax+dLSH4JsHF=bSECpLMJa06R?^enCxoNj;Yp)b(JlnO zXZ1T@wEzCrjfd3TiG88Of{x@YEX^~t@SG}lKeFEFIkqZ!fxY}jYqdu`>CKZoH@$09 zn6m?j(eJ4FG>XWLm@9~gtP#%Fyf@@7tW-e&oFIENn2=+PQt7r(s`ctMRJp}Z31+R! zrHNGWrYKgiIL`bDGHQ;5_r;PF!yFG2uLs2`0OCN802@Wh2Oc$h14wiZRS5w!xNZ0b zpWeCA*9g>3b=#-&D!F41lJ!r`14b)>8!rIp+&{HNN{kMzNXG;?|B^+%^ID6@Rnp<; z_&f_0NQ6=$MYOcE5^uO()yu)kWDwzSZFzVUmFz+&Z%4fA?$v)HIDnn?d7LHzm^RIHLgkv(}m~<~0D0b-IOqKzU1T3ALf)ac0tsQ&_f7jS=!Avz5XEp^xEN9EbssK8N0>P>yh#A8B&AiexSfi&k>q zps8AK1{lAXTsmT)r;J>1ls7Zuf0qT8s_pkyN>fw565)^hSaJZGHYP38Bs3&U^1zzv z0)`=C9qgkvOW2i$ew08x)eSvDL|VS`IYN36Jt#P5e^Yl+CViCjg`zWbMyG3&Gd>W- zH4b+}H{@8{;G(0s2nms`$j#y|e@@hl_}2D&$?q>ourUWr?ci9G=J;^mjX!`Y!yY{q zu$wt`xfbZz))J1iP=WVjy1jF@hC*PhNARdk3Z>UwzFSV7R-_b)L`tBFA;l9~evXE! ze3G#GaFRZ8K?yMGRo%%Ub6888l%mNG%9{%zx6zBSoG!F<$5(*9L=wR zE~YTwB7wwSLAGVJ>^kZpYYNyv|3f&f%IOHlel(rHjl{qjkK-Oj=?Y8m)P{3|<*x(@x$- zcX6EY(dk0qYvH)=d0G33AC?PkwpW0>R5$Aa+o`iU_5~Pvmh6x)ckMG+?SI9~^aI?c zm)bv;1@pE%z8Q$Zhq+f8XS-6ok6mQ5Y;RXc9IJI6jEI}V4}5fY(y%tjpriAK4H+*cke=FVFDgE8zbs<#hD6Xjf--}jBGoYEbgKkiuithPU>3RV_{ zT!c_R%+$WL3eGy@Dh_TLdrh=YZ87}H^s!^;H`R60kGYqrS8qO>ZdZ$cJrA%o`SlMG zGOBuN*4tC?XJrWm_u(6?LkntbPvvpLpVpG}0@sgI?4$DVoY|L+8S=g8?5@hK&KL~@ z$>}N|K|696A^&0E{vQ+M7v2dX_3uA`+!aqW1_5o~8;Jqi2GpNj1HVCcH2yc~(#A3(L1fHGJl@JSh@MID6`#eBmf zhXtUs^iPN*=OwnEzR&xL&`U-`rK;VKO-m(3w~P@e(j>kZm0I83NG}1F0F;ac*L;Y=C(1ezD$d8l;+{Z41lC0_!FSMKUUTZ60 z>pKk(O)Z~Q7Am~*%mdAFMyW4Ev@mbCx0G@2M_UQi-|1Nga3V`t1f;nOxW5pZE00lF zd26!_46hu+T(imaO+<+m^w_P)d>j6@&E`07+1yO{+2s*)yD5y1aY5u5yJVoFTFuB> z#c<9HR*F;&w*a!BX`{-d1H|$yVX6-_pUxG>K`dm=OBqH*b)xDOyHTHnOP~x2YLA|d zV>3LSpZe!i7;h7J##3>urhR9vNLyea23xD`J>fS|TvRna`NleRTt4;vj*!EvHvbqE z#7m;XOBKkn&6$taQi*au@RwTRrme^es+AlAreaIv?~VAEv!jZjk-xI@*y4{81~Z1L zr+OJ|9zY+YM%M2Hr(KS%`GEvh(A!&WA0#0)lru(CqNt8=!=90;aqA8E&5&xjE{3r@ z{MOVucP5I)QaM!lef?*G+oZnX{fn)^Z+8Ra+~` zBI2BF*5gsG-}vCf`7<`S#O77k@M-psJm1Yk3qiuE*hLvoH0PetYD!|)_&OQkH^<91 zze*XG+t^~P6JQOIb#D52J1vg!@^PnfGz78{$A^Y;Iv92XC_x=E6{JOGlKV<&uDGty`xcVT!*xNE0^p5-L4}jk4%P+sEC+t0O zA-~;T$t|(p+de<~rdf3Ud6(7y9Yp?B*43~K* z%yR0>@HkD-)P&NU8C#uBQ@JZHUh+1=k2a@0n#GTv4(>?_yMHq_Z7LyQ8M+yieZbl% zFveoJy>E6Y6fiV7h`i3AJYHMI@OnS7tifg$T2|tIG9V@J|N2LZ+;2CK1n!ezp*M#p0?@rqgi5TwDl zTP42BYwXWrW5i?l0yaHZG+kC(EW0Ums#Wb;JUY!fq!=hbz&UP5U&y0N$60>-uP@K= zVapS%eRUblpjgN3tC`Y#GBqo$8aOmnz9o}G*R@9;1C%qyj*3{}S$NKjqEZ>CgU0|A z!$}e2JV694BGL1X?&el4c_x~O%YDfVVIU;XRCgVhViHcqLJviwl=?_Zn&rbmzUx3w zo{`Ic?n$e(^tgK9Ku(w;3?gf!uS88v}AeC_9;7+L3;|v8p@Jpa&#B+ioeBsOQ}m$1d<`=%B=d$O6_CJN^e>C9=pA z`+CGYtbTA~PM8PYvhu=*v$j{ZpUTOwx(UvQ|H5b4asAmGqiVPGY>wG(UP=BA8#YRV zjjEpt=`A<4_&uODbe?ewGUr&z5errX{;IQ?%gprmAE6HNNe1H zS#VQ-6vSF7*}pfbD&i%XEiLYzfU84sM`C$_!A@)lVQTkqd?8j#a_P&2g0|&4YF-_D zKv_bIwvcovV;bs7s|vi#L{}uHuxZ+YMM~AR^m7ry&5U0q!DGPUyN1K-N|6P@4(OO| zMuOe|T6%IZC4+fw4dE6=F_cTDL-b2yE-FQ;noTm$Q=vmk z1v3j7_e`H^HM8YQOH@>cS{de)1lx?hIK^r>7=%U>hOZl`e?_L~y>gkF|!CvgjFG~s#8YG77nOQ3#*ssE12**j$ z9SM%Ud|WvZ$0YU-K}6$*sL{SGRi)8o!WA}1tx_Uds#sKV$jV5cQNdk_TCkR(>Gx#z zatHJ5DtKbuYehCv7zf|OW{5z(r>OSG{b2jclTZl^xtZm*RQpqF!qh%8q0q%6R2{`J z#xm=$*B?dwg$AX)LZ1U}nLIx52{LlE(bm)PDW>V|LksJWdjn>k@`}Mj5xQ>zZlD99 zH(-w_WcqFa3Ej8Di+_Sri1oXerQQomK0wR41Rv6PL=lz(DfjDs^|aJrh5OEP1W18{^HxS zO;yRjk?Zn^|z1 zT5Bp5wdTb$SN=_fP1o9bnD#D;1JGL6Cq>#m9}Ey>3#jKypbVEDaeP$BuRmTkQm=FF z$niO0H8mESARmtfslv@jlAwbrr2$E0uuouoY?id0R+9*2ZTVhE$yGw6T(I%1C6l3l zJEx}i_f$;eFsj~UlVd*@8uoqZ9I$Jld$rb2L*LS3b2y1zrUI`k*72TQRlQ6HE6!&9 zuhD!vu6?D(`h6W<+Y5Ze3hl7Ryb&HLFY!Hrc^mao|oLy{L_tKrC?xr6;PvXU^P;JDt_LlpyNT%I}-CB#kqboAU0iT;={3{58I9 zjWFb8ZPs4mN!n4Z$+w^+Ezl6D83q=<^jJQ^l9p8o8v2rMs5)ZvL_x?s=i5=^_s`NqY;xN=tQ@0N*}8E-$0yXQ zJ<@V-h&s$&Bsmdg%FB81Au!Flr-gaZ$CzV+0HW2GG28}#ysS$Pd7 ztdNq~Ab$x&(Rgdt;hVaJPVu6EG{5PytF@jml{>FSMbA^B_(LeI%#AW>vSSbf8I4Gpq z)k|nhII{?7vz*kWdhMokJs60XUR%wP*9zeF7F|WeZ?!Q!Ka%g&DaMnqCetCWK>#urW3==AQw_ z3^NapB^TgVvg2t;T=DFFdjW$W5l`-MKmLv=zZ8Udm7EG5o~rkvanj;XA%qy$#>Sfa zAIQ|hKbBUHemYJuz+u|Sr%2#8o~GW#)O$bYwj|KqVfeM(4ye>TtQX_}D&Tz5=znXIF8US2nj#ItE>N5;x^vhAWsht5V*X4oWdfLA>=$E^r*k2!L9ii&FH+2)l1p z$5ZfOs+l$Z_XTaOlNxOqaylvR)QWp~)y1urZ7q!DCv%6)*msZ##j5 z)#<37y$iib)bh#Ypjy^?rNaHe$f>1gINWA`N%dX~FqYULy#^>nmZsr8?WkIu zA07oG* zYthD_kxD$`c831^i5Bv_YeC75=*A13U%od&aK<?bBlYK<-~QIiWXw&#Uwy`moT+k>!n|TUG_DoYVYA(j^k2(_AbZ{T zE{7u;{IYD~>aQ857GxI+;#@yOVqbppFC8jkTyoRIM4kb2zGld|K-h~sLO5Pm<*uA! zdF2id!@pI(V;<}9?XoiC*kbpW$H_sZ!#8=~p~Y|>ZNpnXiKbn$g3EbJX#RwC{UE6L z2jDXqxbq&SD2T#)>B5e!OS(hSsPf>P=9B7}nwSsjhgi|-t4+()r`8<+hD<`iN};q` zne(<=6C?HMX^Q7y%ME{2h1cY}Lc_iUtTBDAImgM-YU8M?;}Kr9;hbUKI#3zBD1Hj# zY^=={o-mV1m%W@N&DpE`i1k>k5*9?}Z3>x-FrncdJup{7Q+JlyCX%1GUng;jiJ^KO zX}BW3QEX8E0CyruHl}fJN=*D9MlG6|)G(y%T`+b+Q5*^jl(mX;V~8L$7PYb4Axr9` zjyE0xt_99}DX+qOC$}H{D!)}K!wFJg+E}k!%EN~*Gko9sByX64vI~tL-b{3pq~Fi5-Iy9r zh>vt$<8oaIzQi5zcl*4>H{ch-Ht@9f;rz#|ptD2PgP+yD;?J`6+7qvkl}5|6Z0&>I zVCz(0cS$nl`?xgO>cXp6F*+DzpV%q^!h2U!hoi6K@`{aoV+cBi%)9kLtG`uLxqdGt z+Phq#y)-N19G7~F zwX_xR7rY2gPi?&bS;!qxs*)BDS3I)LP?f{V#?k^ZXRdEk6nqUz&Tjee?tfADmO*iC zTf;615+K2y1`^zYyCy(zcW>Oip>arX_r@gzcXti$5VUb?Ah^5jkA2>|-+Rt?YkxoP z{_)=1)zwv9tNKT;wdR;(%{j*Nn2{yw6g@3l$Bp!3NfVh7_4Y}%DbXTL%|?RCGe6$* z=58OSQ;@ImB~xp}%kQEYH^ zf@aG!j;YMPl{xS*6G)kO;23SaJda9ay-PTsqkk2Zsf*&3ueU;7rfdzJQ`VKCrkKxD zkstAc`O{NJQW9coNN)!P41kQa3N*sDBy!Z5`kIocjU9LFFW zDjXsl9ERbat*3u}Uf-L){k+j`BGv4#d(1R*HE2|wG**6M*!a>^T!B!f-_*E3Jn@dN zL4e{dl@ZZ5$I<(fcaBNzKlF9wi=FywdtI;ZUFMii+6)pfqFquA7>n>N{dA)~!iot)NLRP`08A>>pd(BI|%v z{hZIS3d7V|Og%WSPnH4dZw%HeLFr}|{JMJ&YVFQb>=ZvgEk6ofeAn{szhfIU5WTaA zzh@j2?1}7Xy>f_n6!=YglIKIc^#@#bYp06G#NzpA^X;Gfr9?TtE;QBjoZT(E8^tf& zMx)O}quqkUTZxd`>p@=$o8MPy+OZMpTsb~QA0yncwU!et=kb8Fo`NF?rt^%=7X__qicgLzEDiq-?w6^1?!6LGd0 z8_KgXb6+n$>$(OHU)g3!&!%k~O4EkpXUKk{QlM?LN)wtSPeKxB>4Yo73z=c!k}h9F z`=lZ-wACzWliv`o8)~<>F7H@XKD@lxHb&%b!lBE~{Iq4StnN2JWio%rRZLwjM2aZBxUwLE({#tC>h|kc$>C zvE;Co$Wwx^i%`kwihETf6v*EowV9HUZ9B)rS-}&b9Il&1UG-gFUSnrdmiKbd$it;L zO(J+~i*@kv_AT9SaVjKHc(!g%XKQ?ZTFWZystLEgMYHkvw3Y3dIX25vk&pLGJ#wd7 zf@26%ZV~401Hwe*qfPHd5hVDwQu;YODhB=vg#Z6or%%2b85C8nUqT*`!6M+KdlMU( z2es60#EdlBP$p0S@UUX36UB=%5s5EijsaS|7lbEYjX3fr3ii8H;nV4g;caD8VI>$Z zS`X>#4`8j`P*t1vM7dza0_)_kfla0mvsE^|BGmwrxk;8C5*rfo#&f%r3@Dgt;gO1RJ0}@Z zE&PduV(v#H@j)v6R=)1Qa=2S{SQp*Ud$NoYLAO@TjG@VOvlPb*1%Y|=L!41tmqxuF z_kJY&ma#nk*@fHI7H@0sx`&|w`yK5;5f&AH!Ve)LT~s?biR9YLkH(1_Z%jb29VQ9f zHp4lS(rv)BqElyjLInP-iZc@dS^H$0YYQ5oxhrIE>X?esWEuYfnY&+kZMAx4@o z(3il<89dE+p3o*XgL#g5x_+WpZ!$8F@bQF${1fru={4;DEKp~L8>a6}EeI)fe~44K zX5*zMqJ&K+O2A;aC5AWF7peS$?`qM>tOmSZt@wLHMJFAkI1v8qhHBS^=(K(!a8ry@ zO#1G@d$c^lhfKY%B!+;w%S)Bf4a#HW`+R7x=iOJ-og7I#3ii(Rv^wUw067^imMECz zz@RNW(NK}xcjHr;{QA9twqE{gMo9C+LVRB)gOv9uG3##o7&1hUnC)B4d{x{+J^jf< z$w){KlFB^X&&@J-Ole`-WMsX!kB$*K!OJ!kriJl|4(~zqtNpYHxm4bsprW(YBcL;_ zq+gOz&lvBCp+J=)TlLh6Ga8JLQ0IU<_CV8O^LX#9_e*PF#u5wu63`0q5P^>4Q9W)!mLMB(+HX8V7L)kO` z{e3i+jnYyScocH3QVu&77ntu|hnU91D5wKsB2|h5R!YZBcTd?zc|8hA58t?=>~Qnz zRv5LJz`xZupCYwBeAHhN<`UNN*@87Xf86?zTrBbqQ!INu-Wg>$wrm@|y4mRhKNl6q zYQr{r9<^84v^F->7hzq@mlP2L++7vWM~dVSka5{_!^WyUe(MtmFrmBL#*x62%!?GA ze!2WkZ|j;{_7d-;SIPI0J&@fU-70jdw_!s`ZmF@~qfFhsaA0TMOx6IWistw%8TB@w zml90E4D86bv%TTm0k3+G(M&QV?GOx3So^o*F2Vi*S@0-Nq@j^b*`ipv{`ZL1!v4Y$ z#kLIBW3!Av>?=BQe`FUDYy~4e6}-%eetLC7R~}|z;~68_el&Cb4&`>v8^B#NZ?&B| zE&HU?!3to&CVMj2!b%~Nc~g{IsLP=$z}Ac`BgeA4=rS%;a>F&5N1wfuUZ7V<1cMv{ z9sO!VL$J+*ef)wQ=d3IS!`R!GSG-)zo(syZIwaE=(~Ns!g5$3oFD%5TW-rVpQ-I-G z$(NA(bA)wcC&R6Zbe=Y4e$T!+_$=}r6F6N8Tv~hP=5jl8XLXYhy)s%G>krIFU==|R z@RuH?We}}}p!aVNjOs+vyLXihXb$rfWWm1j(Bdw)AL8tqkcQD3gO zjYGwl0p$83yZ)9P84r4mvm1)cLt{r7cFBQ4h8WW0+28Cg?nLG!g45C0@T~|J08%C> z>nfXHP(`g3dcCVJ^YM4$?@YqyPD{;6AWYer>|kW_Uyjmzf!k6VZl7K#HZ)EdQB9z9 zwPmJ77D=^wrnhoyfR6cyL!QR=@in8vg0wK$Jv9RtlaGE(*|dr2fri$D?Rk^)^%aVafK>12p83X>~*OdM!&`A4I+{Sk>Ofv=@k>=zaDcoX{f%7Phg#`%j{PXtmA&w37FvohKQg8In_K9>lZ3{V_c?~5+>Yl(ec`EN`^i_jBnn* z+(vKOnp!z?e=e)6uW@Wq(b(erQn-3xxOp#nrYnk-C(tlQv;_pwXBtdjvv4byy$zL> zoAF!e8KqQhnYZ@!V<}0wOr=O<0Zcp#%ka~`d!;P{_ z>-m)E74yTr{0H(B>5|R6a~3|_@yfjif^@n$#9rzG>(9p}Dm)2vtw(W7p8ndq1IS7rHsHExm?DI=eaDR!Q8xwKTFVEZo$*lwrw150z=< z!F-A~UxFkaX>-lr3cS*z?$pJs8%zLFE`wiRys9A=xAPo5zZ3z3(%f(5uuyQcg5H|! zM~Hu*%u5p4uaTlAZ2vD97Bll0-6;=l6VK=!3Q9V{B~H8VaQncoHjQ6_R_I6d!5#z| z;TD>gPZ47fo7bDz(_A0i950ZE`+NP-qR*8Clj?%|ihlKk=@oH`7q@e{34HnBvTjr2 zQ9kK(&aA5o;XYtm$qhF?8N&b}hs#aLnNe;D7F!i6p~Qw2x8Bq zI3`6!r&aD!2+a?BJlYa%?9xVUQKcgmAP0t(i3U|)iRZ*(P04<^(x$?WG>E=QCNPJ% z1H$zHJKlkTWB#5ftDR;**e;OKQj{~qb+Jb+3B@WcR-nlv(9FbG z1ZlwIUsE`ltd5xRjHOX;g&Hx%%xYR|W)3F5BiF3p+-}ny0aN)f0GxC@*~jL#6Vi+z zPGd#G9(PWrRyPBpm#Tapv>i32op?7LjqOZ^VlBrjD={Fid5J}KXeRi~{qFP(fXLtE`&uz&AWsUP7G=)oi17M z>d1-3TJ4Oo#D7zy&OUuIzAz*H*%VkeCPlg|*v(#D{UN}l4T3>kPF`)z$-1e@fQDu5 zAg@0@iA>5%yq{&`qURlvG`Ee`GU8^rnbLY8w(L)lz?ncKb%(*AW6g(~r}>gVG3qYG z#0ltHINd<5bUI%*Q*G`9N6k;x$pE)Xc0(X`V;0||f$11>__53Wi4N586vs|&nHBuw z$3+Rl0A1vI*R~wXzNX*Pmy%TTN3w`fKG};I-2CDW(-&o2iAZzfi73Q#^licMw%SC7 z9=eg0Bk7|XqD_*&cyN)At-*UAtGmmRdaJ`V*rxB#Rx5HEiw75ynuf{7s+el=)i-rS zvUF^W4*?QAsan1A~E8|+tF3Z%*>rDPBe=9v}#Ld^U}apYgs7yk{Q`F|WO zdayB5-!3r^A0IOSyH;o(aF3wz)s2F#ix|qMBo;6fYUQBuAS?Hlry5|8XGGa(hk2mO zWfb##KhsDd*HB<;fnB1`R+Iu+k9lR6?3yjQwTo7BYRYaiAip?MW6aazrHI3O`wh1M zypB9G%*h!IJz)r!poly*$(#ugav=q`FjG91wh;2(>$f&3m zEVtJGG;Eh>9uv8yM!G_yttH!o3?!Ua`r6xqlrm2+SRPScl;JwNtlVsS-@1=ISETSg z=3ywL7svmxKWck>yt#t0CD+=1MbctRUrcYU3DizZpe!=ekWY|!Wlc-J&C=-m@rab7 zt=`K@<>;mqEll648eE3H8JK9gP$#NfqOo=He%dt=$588fOd(fb=NgT)iV|!;6>~lm zOqSd}vOi|k0$XoW%kZL6^`+FdM+2K*@E@eQyR?gMjSNy7hGvFGeskjg1Fr766Q6gw zt}&l+yW(g;@9VVNQ(r|ppGl$T8>?mTEU2%_3K-WU6xT58!)OmkAo3KA@zcX} z394eJ&-^uo)ByKE|8&WDl^go;?hm*xuzO&#oAl>B3;@qUMmD{rbcKllJEoxuZHJCelPs2xl90;cMf2xr%@wYayEnjj z^~=lE!^(XCcSXB)5-^6;HhOJjmT=E?EOjLvnh!e!Fas|XDrWYbu_ot=W!002iy*Ap z@5%8!km?rI`5y)O%(#Nt_N3~-Fn}kjqU9}?%tlF-IhY#Cp?$h z0-EY)J%27H1nE*HsK1>%o(DMi800Yn(n1g^2Zd^gA<^)hkZJLO2c2BHkTs_W{S*u*V6yOM^Xg7~Vk? zj=>${&dv88@a~%2tzrwM!gG>6+4rWVtB_rt^VRQlcT~^mbw%l~2O6xwL~A@%mPdYo zQdh{=Bstd0_G1GL8+qt^#LYa|0(<%y@ra{MDNia?Z=@%GpM?e}!iezYP|acxKXXH) z3@XTdYkCfSz__|rA3+ZWS{pHPAN z8z;2tXYZvlTd>&)Slc_zc&X|MfLHsBcP60WX;6=>4>nZmF;~YcfQc2QkKW=4$37qmnGq=cR3-j99=*^3K$> zbRjfG_O^KbwqF$tWxshEiO*q z?fAW%%!q7@57nMb>+Rph)}p7H1@#~5w$Reqv`*Q)se=pdk*NL!4pP06nf>~~-yHY= zuCyN3?TjyIzNqBsL(-|Kl2Il(u(W3HyJ56gb(KN(Zy?o6*k~5g-ox6i5Y@$T;9BwR z+OMmz#9?3I>X}Yw-^3b^f$(BIZ$w!$5KaoD+)=B?R-;uhXa-&6*N%}1?{BxW`;%>i zN-CEZs?u8Wl2-(V%ee+Wv^!nS-fL4ZI)0g;rR~DUq?u0xE3MODHk+lMH&b-=vA@Gv z_An(i1TXE~s8_4l6JCR@F6sauT)smG@q&8w;1c=4ob}^jJL=EHLeGfc)M!Xt{$iH8 z4Nn0$-2|Um(^;>IKW~K|ivMdGg(D7FYFjq1Vrv<;+ZdhuU}2@q=~}knRcWPgZ=h}U z^cA$Ii$AuVfa9B)V{^ZiShFIqH9LRjh0qDn+@zustU+Z^F!}>7|KnL*>i%9wO@Y?U~}SR|7}|$J!P-1s7I8o#m7qf2QLsb+D3b zuOX>t4Q`%oN@y`vnSmp8Jm zP`NhqZ*Slu7~u64JP$T-*n3iEA)GK)+N<{bQ5Ny6r{VrHm$auJN=H4oqLOdxyIoh5 z_B>F$@4B}}SLHzJM_mfGeHqK2uEdWiHEi3VcLM_)Trw9PHdI_+ zt?k9ya^~#fU)d$TbHdr;@)CgBMH8yLL_18w$W0O`GhO7r^YJvQY6Fp8@Z&{ZrmP;#-p4Fh~ zi*AQ5&$Y8$KwiyTg8_l)mTZd3E`MQQltIqqry##j8^vYSWj1{ zN=GtScq+$%RJ)u9Se|($QL{|^GEvmerjO8&3yFW3#~WNSlW-dZcNRaB=s~s>esQ{9 z&UvAhRy^Zfc(2VpG=l78p1y9Fu~ao8ZUQGX=O#=~a^XovjDQYPznEzCmU43kFis;> zPYEPJ@Ef@UPtpy-aDo?Aj8(+@n%t{Ar=_y}&f%@+Z$klVZfbX`Y|S=;Gh2XJ?$=&C zF%Zs*n|v-g&6tKmM4DU+hHJ!)(2~R}udgr3h5l|n%SA_;Srs>;vj&s~*e}PZ$8`J~ zrmK=&mSpa9Y;*ZtR|~-LLnZIHM*Y^yce+lAi`rgP(flwRQDNvqgLZB)SeL8csNQc& zT%nW09Acqbyja;#sQgQL-0VGf*`#IFoIw55&sOu2d^FWU%|bg3J{<0lN--JPHuF9o zN033Jw|@3r!+6V5^B-_Ro{LMb9?jsD_A0{+dS%K@mb_fIf6p~|HcIWc{AL3`*OcCr z<$iR9AE;q&o${2_P%m#Kd*Ni1xG-0>EbkM(o*WoU=pkdyw{>p!ctzRJXz=NofV#0) z*7;46U|^2bFm>rBbswn>%RoDm!836WQm(fyHcyEvTjM`#_E)f6XKRmK zeQ?Zxdo%KlHFm5@nrU$J`_gxavR~{P*+C%HkK~J^DtQdnQi%04dVoLRvWT;8cIr_Q z&3z;2$L@h)`Hz|#O$G{4#lM8n@g_pl6(jK`BH!90L+cUE6EHL^&fxtjyDYhFuMjxq zn`j!4+p}lu6C=Bc7ZA$&vH@{ks^$i`K8bqJm;7D7X`&w^EdRH}(K91xQ!*M1{IJ-- z)Bgtc<5QKZLSH%C4lRKCr2gTs6Tpd>v+_m>D(DwiBk5Go(rq8VH!8${I+*X1McG+5 z`D<+=%a-90R}#Mrol!8LS{EOfu09L;csbX;MG}$DRWY|p+#vI)kiH1fof)f+%pES{ zbZJcjB`{I1m$6NbGZuPfp?4|@qAm8RvWn-co!^99=4}yG^P5c$mDiGNSF|k8=u0db z7bjj~nk2SB`S}}`UN@0xQ%Z-7y2xMlOf3n9qPmth;Yfos_d1E-*$m&!K3I%g-8MIl z?oxKsPzh&Ghg}AX18IN7mtIR2KQvd0k$w#S@%Fh4*X@_`7y0jrIu_c8BbtQfjg-Eh zr(GwI8%%flDo33_UllD~c&-;-KvDz*O}Pb3%Q@3;MP-jxqDr@LE1O6D>7R9c>p*uY zk7Jb}r&}p3UiE2NvaiNVyXhYE{y3rfSVtr1iu8&2yydz2!o<*0KB8<7m{TWy*FSxU zR4MlKiwFOE1@PI@)uw~h0q?d^f9l*7wIV%c`q3ZeMpduabtA1M{Gs!08V@0l`F75s zu-aJ}cOi~2iS&^f->0$tdR>Ld`1;Hd-_gsHy47z^|99_gyxy@9OB7E6LDHzejL$A%lTMpi82;cu_rhR zLm#QPsSvb|);nUhILs8PI2dGG2-loBW)G-eNxw0k;!(A}j$DfR2(kedtKkgDo$cdw z)Fqo?@8hHNrOqT>S%DSor14UgO%rv>{O0?mBoOVHjRhkM4hdlYNsayA9@@=0mX|!k zvg;+fSG#ygf#MOE0zELD)22q96 zu(doAHFrw-NM>~uzJSvMP@nvfS~g#uynxe(FDQ1pr;K18bi`ue*sj`(k51$o z5}v;7e4}bOja5g~Bn?1)KY}fJXJ7)-u>YM8`Ka5_A+J+fv?##~_B_=~{|oI_X$R`# zFn{<)AG)EQ1S16&J_Kfp^lHZTlzbcXak(U4&)ZB3T}Lg%c&WZ{m{~P2ldpYfWQ6z3 z%{90sm5GK~RC^yx8q9ejtxKXnO_D2P<4zB`|w|rtb@0T?rA5 zUJ`1)U{Rr%818n1u9~R?-1rF?fT7P*BuWW2<4{-_Y7NKqS=_jBc4m8s72S5t`5|&k zqVpMK(L(!-wat4Ii_JTbhS==Z8M6G|SxuZOziB9MIdXr5XGqkP{ z@PQRQ*TN5jG0uEj8xAy;CxE~50<#BYQ0128;-2bBOn{J3Jx!Y<>P|-D?cgj@|M*%Ybqg@TE`fAAfA(Zage@RoM7#%GecV)VX7n?JP)DE!V|3CT%L zFWLk&FuRVNUSRFazQ8-H)%XV93>iKN$lNJ=Ok$G^Ura=0;sf+ZSzV^?cGz$v{nBm5 z<6z&DBXyUx@&y1@@qz4gDfY0Eo!OR&hKwiPFOT;JtyyN}05+bfMInqbqfbP@3w=s? z#B6&W%l8YEYme2oh$VT7WWYPCCxobIi`?C3kUqJ7M$}iPb-i*lx2S?dX$P^_xP~0d zN`d>cA*sZ~YcfrWvEdR;ZfG|XntQqZ5!foazI{4cfKr$|z7}5J+nG6`oFB z;SV9R6VXLq2K1}{XUO&`*SwavWc1$SbY3B2=AY(rM1y!Za>l>66Qpm09&)j1)3G2;; zSjjuU)7|L?=BC`X+!?g{&f*y#{QsHake{{Mn`k)?Q_GygSp>2V!H9*(CxxA0D zigUKl%dAvE5~#I5c%x@K&riJe^IqOJ{&@}2BgUqPH?G{&jEDKhRQml0BVT)cufia= z*8kuQR(22FDBI6~+N(OWwQnJv&a^VdlIU;eA@X0S!J_z0bj}50mZKxK#*W9-<0f0g zRBf)){(y^ncCWt%TijA#UGI{+^#Wc|XI`(&WF(y~HM~FG zi`a&9R|1<#~6oK*q(MU^h=O!qTNE0qEDIg)EIu&rRm zQAHo_zv!Uh{XZuuKX~R6MWC_YFkV-lp$w z`>q2Xt~MZ*t+Xx~Bq$6zNZhOxIyLS2 zXq#L@Xr^p>=fhUwqh!M$UT>?Eh|AVBSq;i;J6&HFT9fXzfRC>eX5$jAfa`o#Dx?wi z|FULayX@T1vV4TSSTl(CP3uycQ7npQTnVS!scoHjA)qMw@^!QKjE)fJ_XGxvHNOdYgp^HcHThTo z>)Q>lS!;=3Iw$nZAQe^)kQ1A&*)&S4S>MAnL~h9h)tKYr?I*F6v;3CiBLkOL}uR ziNrU`B~tIyQ|W$py*_4lYd&wLu~%P@MUsZ|oDk783bqMDP!j)mUPUGO&WRxFFy(v_)I$5Yc6;jgUa4>%j7e@k1qD*rZZL1XDH6hTDos#=-4 z<08P*%Lw)Zzh&!3o5geS%^UTeiIo+Zey^rft)NK(5NUo(9nKaI8oqzLsg&$8t8GrL z8@2b4|E%opV3;!ItLQD$bORLAD?6_oY-Bjxt%d}e;PkKb zFwwpvb7I8UZnWINQ_oVdKpmEdV%zV(acD3@BXxi%NZaoN8S{nY8 z9Y1arq0HIP$KB|gZ_M=A7*uX++=V9k;vI?fSX5f*k!f{uhk!|mv=zh;1HP!+8?3Ob zy)+mBO=~PheYLNTcKMGEm+u`Z3Sx+?cFy0W>ZpF?Wu!+7G7$YUP8`om=)ol+1jr= z-aDZXbPnY~(X#-sTzf?h&bj&;qOTdLlH+CwD>Eft9CCz=Qw==aKDRsOc{9Gfx`W~h z%X!GnEO6WUyQ;%Wt$NcRa2SgWcP8}I5u0fJi(?i}+H2Cbl0$oFzvW?>4M?3u4eCit zZ1t}6#eS8WbX=jtGlA{T4EwrQW;!cLC5tkh6ajts3SWvFmAa0+#xuS9W8i&MWt_=f z@!uj`f!pAj$v|jFJA7jvc>)92sx!ft;vcKj@37@5BHuk`I9nD&Z3~FSn?Y@2=j56( zL8311D{-@Nlc}VnGA;b^MA}k_+EV0@Zz2d-X)W`^If5N|FWbroiivvJe;J}+_5%^N zEA_SfhhHh=Z~aOtHLeF!iTc~>G5(pcRqD2hy70Q=Ws5Er%9CCka)*OWds->_3FQU( zIfXey^F+OhigSe@4y*8eylSqFvW|+lpJ{z4W zg6$UQs6_jxu&Ti0+h4*eCycLRLe&%;XZ34{B4(75_M3OC=u}g2gyA(Hl~-_cGVV&} zO~0d6VE^!Bs?^qTLrVIOb0hOwQ$2w&`d=(qZ#GnszNR{?1oOvr6 zh1Q)@W2B4(MziMx#o=~YN0p4%1ye!lvkzb9!DLUxQhj}LHfTel$+o4x341+!r2nO! zVrc&SmwKw7Y3kqAQ))tgr=EiN5@g__{7XBPWytoIc1mpR*S~wemj1^31u0pn_r=9~ zN~Ua3BpAzbIIv#bsN5qSy#k?oMLdXh0i$908qFvL8Iz5Fz|q`Rck-ENRN0I~zCF5= zZs6E@om9d@$NWGW d@zSX%A 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 literal 0 HcmV?d00001