From 3639fe24f1f7335c8b6ffd13655ff44bc49f0be5 Mon Sep 17 00:00:00 2001
From: Damnae <damnaee@gmail.com>
Date: Fri, 25 Oct 2024 18:47:03 +0200
Subject: [PATCH] Fix dynamic key display.

---
 src/gamecore/DynamicKey.vue                   | 26 +++++++++++++++++++
 src/gamecore/ModifierLink.vue                 |  2 +-
 src/gamecore/tasks/ByCompareDynamicValue.vue  |  7 ++---
 src/gamecore/tasks/DefineDynamicValue.vue     |  5 ++--
 .../tasks/RandomSelectDynamicValue.vue        | 11 +++-----
 src/gamecore/tasks/SetDynamicValue.vue        |  7 ++---
 .../tasks/SetDynamicValueByAddValue.vue       |  7 ++---
 .../SetDynamicValueByAttackDamageData.vue     |  7 ++---
 .../SetDynamicValueByBehaviorFlagCount.vue    |  8 +++---
 .../SetDynamicValueByBreakBaseDamage.vue      |  8 +++---
 .../tasks/SetDynamicValueByChangeValue.vue    | 11 +++-----
 .../tasks/SetDynamicValueByCharacterCount.vue |  8 +++---
 .../tasks/SetDynamicValueByCopying.vue        | 11 +++-----
 .../tasks/SetDynamicValueByCurrentBP.vue      | 11 +++-----
 .../SetDynamicValueByDamageDataProperty.vue   |  8 +++---
 .../tasks/SetDynamicValueByHPRatio.vue        |  8 +++---
 .../SetDynamicValueByHardLevelProperty.vue    |  8 +++---
 .../SetDynamicValueByHealDataProperty.vue     |  8 +++---
 src/gamecore/tasks/SetDynamicValueByMaxBP.vue | 11 +++-----
 .../tasks/SetDynamicValueByModifierValue.vue  |  8 +++---
 .../tasks/SetDynamicValueByProperty.vue       |  8 +++---
 .../tasks/SetDynamicValueByRandom.vue         | 12 +++------
 .../tasks/SetDynamicValueBySPChange.vue       | 11 +++-----
 ...SetDynamicValueBySkillMaxHitSplitCount.vue |  8 +++---
 .../tasks/SetDynamicValueByStatusCount.vue    |  8 +++---
 .../tasks/SetDynamicValueByVariateType.vue    | 12 +++------
 src/gamecore/tasks/SetDynamicValueInRange.vue | 12 +++------
 .../tasks/SetModifierDynamicValue.vue         | 10 +++----
 .../tasks/SortByModifierDynamicFloat.vue      |  8 +++---
 .../tasks/TriggerModifierCustomEvent.vue      |  8 +++---
 .../tasks/WriteCustomValueToStatistic.vue     |  8 +++---
 31 files changed, 118 insertions(+), 167 deletions(-)
 create mode 100644 src/gamecore/DynamicKey.vue

diff --git a/src/gamecore/DynamicKey.vue b/src/gamecore/DynamicKey.vue
new file mode 100644
index 0000000..9890193
--- /dev/null
+++ b/src/gamecore/DynamicKey.vue
@@ -0,0 +1,26 @@
+<script setup lang="ts">
+  import useHashStore from '@/common/hashstore';
+
+  const props = defineProps<{dynamicKey:string|{Value:string}, contextScope?:string}>()
+
+  if (typeof(props.dynamicKey) == 'string')
+    useHashStore().register(props.dynamicKey, true)
+  else if (typeof(props.dynamicKey) == 'object')
+    useHashStore().register(props.dynamicKey.Value, true)
+</script>
+
+<template>
+  <em v-if="contextScope">{{ contextScope }}.</em>
+  <template v-if="typeof(dynamicKey) == 'string'">
+      <em>{{ dynamicKey }}</em>
+  </template>
+  <template v-else-if="typeof(dynamicKey) == 'object'">
+      <em>{{ dynamicKey.Value }}</em>
+  </template>
+  <template v-else>
+      <em>?{{ dynamicKey }}?</em>
+  </template>
+</template>
+
+<style scoped>
+</style>
\ No newline at end of file
diff --git a/src/gamecore/ModifierLink.vue b/src/gamecore/ModifierLink.vue
index d7b32e4..8d9350d 100644
--- a/src/gamecore/ModifierLink.vue
+++ b/src/gamecore/ModifierLink.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
   import { inject } from 'vue';
 
-  defineProps<{modifierName?:string|{Value:string}}>()
+  defineProps<{modifierName:string|{Value:string}}>()
   
   const createModifierRoute = inject<(key:string) => object>('createModifierRoute') as (key:string) => object
 </script>
diff --git a/src/gamecore/tasks/ByCompareDynamicValue.vue b/src/gamecore/tasks/ByCompareDynamicValue.vue
index b636f08..bf50c1c 100644
--- a/src/gamecore/tasks/ByCompareDynamicValue.vue
+++ b/src/gamecore/tasks/ByCompareDynamicValue.vue
@@ -1,9 +1,9 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, DynamicExpression, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -14,9 +14,6 @@
     CompareType:string
     CompareValue:DynamicExpression
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
@@ -25,7 +22,7 @@
     <template v-if="node.TargetType">
       <em><EvaluateTargetType :target="node.TargetType" /></em>'s
     </template>
-    <em v-if="node.ContextScope">{{ node.ContextScope }}.</em><em>{{ node.DynamicKey }}</em> is
+    <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" /> is
     <em>{{ node.CompareType }}</em> to
     <em><EvaluateExpression :expression="node.CompareValue" /></em>
 
diff --git a/src/gamecore/tasks/DefineDynamicValue.vue b/src/gamecore/tasks/DefineDynamicValue.vue
index 21a3d3f..ff16ce8 100644
--- a/src/gamecore/tasks/DefineDynamicValue.vue
+++ b/src/gamecore/tasks/DefineDynamicValue.vue
@@ -2,7 +2,8 @@
   import { GamecoreTask, GamecoreTargetType, DynamicExpression, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
-import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -17,7 +18,7 @@ import EvaluateTargetType from '../EvaluateTargetType.vue';
 <template>
   <BlockLayout :source="node">
 
-    Define <em v-if="node.ContextScope">{{ node.ContextScope }}.</em><em>{{ node.DynamicKey }}</em>
+    Define <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     <template v-if="node.TargetType">
       on <em><EvaluateTargetType :target="node.TargetType" /></em>
     </template>
diff --git a/src/gamecore/tasks/RandomSelectDynamicValue.vue b/src/gamecore/tasks/RandomSelectDynamicValue.vue
index 1b6da67..2e12a99 100644
--- a/src/gamecore/tasks/RandomSelectDynamicValue.vue
+++ b/src/gamecore/tasks/RandomSelectDynamicValue.vue
@@ -1,10 +1,8 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-    DynamicExpression, 
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, DynamicExpression, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -13,15 +11,12 @@
     ContextScope:string
     ValueList?:DynamicExpression[]
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em v-if="node.ContextScope">{{ node.ContextScope }}.</em><em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     to a random value in 
     <template v-for="value in node.ValueList">
       <em><EvaluateExpression :expression="value" /></em>, 
diff --git a/src/gamecore/tasks/SetDynamicValue.vue b/src/gamecore/tasks/SetDynamicValue.vue
index d2757b3..6356e68 100644
--- a/src/gamecore/tasks/SetDynamicValue.vue
+++ b/src/gamecore/tasks/SetDynamicValue.vue
@@ -1,8 +1,8 @@
 <script setup lang="ts">
   import { GamecoreTask, DynamicExpression, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -11,15 +11,12 @@
     ContextScope:string
     Value?:DynamicExpression
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em v-if="node.ContextScope">{{ node.ContextScope }}.</em><em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     to <em><EvaluateExpression :expression="node.Value" /></em>
 
   </BlockLayout>
diff --git a/src/gamecore/tasks/SetDynamicValueByAddValue.vue b/src/gamecore/tasks/SetDynamicValueByAddValue.vue
index 895a592..479fafe 100644
--- a/src/gamecore/tasks/SetDynamicValueByAddValue.vue
+++ b/src/gamecore/tasks/SetDynamicValueByAddValue.vue
@@ -1,9 +1,9 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, DynamicExpression, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -15,9 +15,6 @@
     Min:DynamicExpression
     Max:DynamicExpression
   }
-
-  if (node.Key)
-    useHashStore().register(node.Key, true)
 </script>
 
 <template>
@@ -29,7 +26,7 @@
     <template v-if="node.TargetType">
       <em><EvaluateTargetType :target="node.TargetType" /></em>'s
     </template>
-    <em v-if="node.ContextScope">{{ node.ContextScope }}.</em><em>{{ node.Key }}</em>,
+    <DynamicKey :dynamicKey="node.Key" :contextScope="node.ContextScope" />,
     clamp between <em><EvaluateExpression :expression="node.Min" /></em>
     and <em><EvaluateExpression :expression="node.Max" /></em>
 
diff --git a/src/gamecore/tasks/SetDynamicValueByAttackDamageData.vue b/src/gamecore/tasks/SetDynamicValueByAttackDamageData.vue
index f9dfe80..27c67c2 100644
--- a/src/gamecore/tasks/SetDynamicValueByAttackDamageData.vue
+++ b/src/gamecore/tasks/SetDynamicValueByAttackDamageData.vue
@@ -1,8 +1,8 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -11,15 +11,12 @@
     DynamicKey:string
     ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em v-if="node.ContextScope">{{ node.ContextScope }}.</em><em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByBehaviorFlagCount.vue b/src/gamecore/tasks/SetDynamicValueByBehaviorFlagCount.vue
index 5b00378..3a5f4a2 100644
--- a/src/gamecore/tasks/SetDynamicValueByBehaviorFlagCount.vue
+++ b/src/gamecore/tasks/SetDynamicValueByBehaviorFlagCount.vue
@@ -1,25 +1,23 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
     BehaviorFlag:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByBreakBaseDamage.vue b/src/gamecore/tasks/SetDynamicValueByBreakBaseDamage.vue
index 6b3e176..6f2df16 100644
--- a/src/gamecore/tasks/SetDynamicValueByBreakBaseDamage.vue
+++ b/src/gamecore/tasks/SetDynamicValueByBreakBaseDamage.vue
@@ -1,24 +1,22 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByChangeValue.vue b/src/gamecore/tasks/SetDynamicValueByChangeValue.vue
index 331059c..6881acf 100644
--- a/src/gamecore/tasks/SetDynamicValueByChangeValue.vue
+++ b/src/gamecore/tasks/SetDynamicValueByChangeValue.vue
@@ -1,23 +1,20 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em> to the change value
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" /> to the change value
 
   </BlockLayout>
 </template>
diff --git a/src/gamecore/tasks/SetDynamicValueByCharacterCount.vue b/src/gamecore/tasks/SetDynamicValueByCharacterCount.vue
index 9c1e173..008a83d 100644
--- a/src/gamecore/tasks/SetDynamicValueByCharacterCount.vue
+++ b/src/gamecore/tasks/SetDynamicValueByCharacterCount.vue
@@ -1,27 +1,25 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
   import AnyTask from '../AnyTask.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
     Predicate?:GamecoreTask
     AliveOnly?:boolean
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     to the {{ node.AliveOnly ? 'alive' : '' }} character count 
     <template v-if="node.ReadTargetType">
       in <em><EvaluateTargetType :target="node.ReadTargetType" /></em>
diff --git a/src/gamecore/tasks/SetDynamicValueByCopying.vue b/src/gamecore/tasks/SetDynamicValueByCopying.vue
index 37262f5..0f195ee 100644
--- a/src/gamecore/tasks/SetDynamicValueByCopying.vue
+++ b/src/gamecore/tasks/SetDynamicValueByCopying.vue
@@ -1,8 +1,8 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -15,11 +15,6 @@
     ContextScope:string
     TargetContextScope:string
   }
-
-  if (node.FromDynamicKey)
-    useHashStore().register(node.FromDynamicKey, true)
-  if (node.ToDynamicKey)
-    useHashStore().register(node.ToDynamicKey, true)
 </script>
 
 <template>
@@ -29,12 +24,12 @@
     <template v-if="node.FromTargetType">
       <em><EvaluateTargetType :target="node.FromTargetType" /></em>'s
     </template>
-    <em v-if="node.TargetContextScope">{{ node.TargetContextScope }}.</em><em>{{ node.FromDynamicKey }}</em>
+    <DynamicKey :dynamicKey="node.FromDynamicKey" :contextScope="node.TargetContextScope" />
     to 
     <template v-if="node.ToTargetType">
       <em><EvaluateTargetType :target="node.ToTargetType" /></em>'s
     </template>
-    <em v-if="node.ContextScope">{{ node.ContextScope }}.</em><em>{{ node.ToDynamicKey }}</em>
+    <DynamicKey :dynamicKey="node.ToDynamicKey" :contextScope="node.ContextScope" />
 
   </BlockLayout>
 </template>
diff --git a/src/gamecore/tasks/SetDynamicValueByCurrentBP.vue b/src/gamecore/tasks/SetDynamicValueByCurrentBP.vue
index a22abd9..5c40e0c 100644
--- a/src/gamecore/tasks/SetDynamicValueByCurrentBP.vue
+++ b/src/gamecore/tasks/SetDynamicValueByCurrentBP.vue
@@ -1,23 +1,20 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em> to the current skill point count
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" /> to the current skill point count
 
   </BlockLayout>
 </template>
diff --git a/src/gamecore/tasks/SetDynamicValueByDamageDataProperty.vue b/src/gamecore/tasks/SetDynamicValueByDamageDataProperty.vue
index e543b31..f722136 100644
--- a/src/gamecore/tasks/SetDynamicValueByDamageDataProperty.vue
+++ b/src/gamecore/tasks/SetDynamicValueByDamageDataProperty.vue
@@ -1,25 +1,23 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
     Property:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     to 
     <template v-if="node.ReadTargetType">
       <em><EvaluateTargetType :target="node.ReadTargetType" /></em>'s
diff --git a/src/gamecore/tasks/SetDynamicValueByHPRatio.vue b/src/gamecore/tasks/SetDynamicValueByHPRatio.vue
index 8c926df..2bcb63d 100644
--- a/src/gamecore/tasks/SetDynamicValueByHPRatio.vue
+++ b/src/gamecore/tasks/SetDynamicValueByHPRatio.vue
@@ -1,24 +1,22 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByHardLevelProperty.vue b/src/gamecore/tasks/SetDynamicValueByHardLevelProperty.vue
index 8c5e078..7b28184 100644
--- a/src/gamecore/tasks/SetDynamicValueByHardLevelProperty.vue
+++ b/src/gamecore/tasks/SetDynamicValueByHardLevelProperty.vue
@@ -1,25 +1,23 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
     Property?:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByHealDataProperty.vue b/src/gamecore/tasks/SetDynamicValueByHealDataProperty.vue
index db1827f..bdaabf7 100644
--- a/src/gamecore/tasks/SetDynamicValueByHealDataProperty.vue
+++ b/src/gamecore/tasks/SetDynamicValueByHealDataProperty.vue
@@ -1,25 +1,23 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
     Property:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByMaxBP.vue b/src/gamecore/tasks/SetDynamicValueByMaxBP.vue
index dc388fa..937b526 100644
--- a/src/gamecore/tasks/SetDynamicValueByMaxBP.vue
+++ b/src/gamecore/tasks/SetDynamicValueByMaxBP.vue
@@ -1,23 +1,20 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em> to the max skill point count
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" /> to the max skill point count
 
   </BlockLayout>
 </template>
diff --git a/src/gamecore/tasks/SetDynamicValueByModifierValue.vue b/src/gamecore/tasks/SetDynamicValueByModifierValue.vue
index ef11a82..06144dd 100644
--- a/src/gamecore/tasks/SetDynamicValueByModifierValue.vue
+++ b/src/gamecore/tasks/SetDynamicValueByModifierValue.vue
@@ -1,29 +1,27 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, DynamicExpression, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
   import ModifierLink from '@/gamecore/ModifierLink.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     ModifierName:string
+    ContextScope:string
     DynamicKey:string
     ValueType?:string
     Multiplier?:DynamicExpression
   }
-  
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
     
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to <em><EvaluateExpression :expression="node.Multiplier" /></em>× of
     <template v-if="node.ModifierName">
diff --git a/src/gamecore/tasks/SetDynamicValueByProperty.vue b/src/gamecore/tasks/SetDynamicValueByProperty.vue
index c30c393..f4e7a76 100644
--- a/src/gamecore/tasks/SetDynamicValueByProperty.vue
+++ b/src/gamecore/tasks/SetDynamicValueByProperty.vue
@@ -1,25 +1,23 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
     Value?:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByRandom.vue b/src/gamecore/tasks/SetDynamicValueByRandom.vue
index 7d94e50..6086b06 100644
--- a/src/gamecore/tasks/SetDynamicValueByRandom.vue
+++ b/src/gamecore/tasks/SetDynamicValueByRandom.vue
@@ -1,27 +1,23 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-    DynamicExpression, 
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, DynamicExpression, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     DynamicKey:string
+    ContextScope:string
     Min?:DynamicExpression
     Max?:DynamicExpression
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     to a random value between <em><EvaluateExpression :expression="node.Min" /></em> 
     and <em><EvaluateExpression :expression="node.Max" /></em> 
 
diff --git a/src/gamecore/tasks/SetDynamicValueBySPChange.vue b/src/gamecore/tasks/SetDynamicValueBySPChange.vue
index 59dbcde..091d8f9 100644
--- a/src/gamecore/tasks/SetDynamicValueBySPChange.vue
+++ b/src/gamecore/tasks/SetDynamicValueBySPChange.vue
@@ -1,23 +1,20 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em> to the change in energy
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" /> to the change in energy
 
   </BlockLayout>
 </template>
diff --git a/src/gamecore/tasks/SetDynamicValueBySkillMaxHitSplitCount.vue b/src/gamecore/tasks/SetDynamicValueBySkillMaxHitSplitCount.vue
index a9bfda0..fa69883 100644
--- a/src/gamecore/tasks/SetDynamicValueBySkillMaxHitSplitCount.vue
+++ b/src/gamecore/tasks/SetDynamicValueBySkillMaxHitSplitCount.vue
@@ -1,24 +1,22 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
  </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em> to
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" /> to
     <template v-if="node.ReadTargetType">
       <em><EvaluateTargetType :target="node.ReadTargetType" /></em>'s
     </template>
diff --git a/src/gamecore/tasks/SetDynamicValueByStatusCount.vue b/src/gamecore/tasks/SetDynamicValueByStatusCount.vue
index 4f7d085..c5cda92 100644
--- a/src/gamecore/tasks/SetDynamicValueByStatusCount.vue
+++ b/src/gamecore/tasks/SetDynamicValueByStatusCount.vue
@@ -1,24 +1,22 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     ReadTargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
 
     to 
     <template v-if="node.ReadTargetType">
diff --git a/src/gamecore/tasks/SetDynamicValueByVariateType.vue b/src/gamecore/tasks/SetDynamicValueByVariateType.vue
index 4243350..c0c7ac7 100644
--- a/src/gamecore/tasks/SetDynamicValueByVariateType.vue
+++ b/src/gamecore/tasks/SetDynamicValueByVariateType.vue
@@ -1,26 +1,22 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-    GamecoreTargetType,
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     TargetType?:GamecoreTargetType
     DynamicKey:string
+    ContextScope:string
     VariateType?:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     to <em>{{ node.VariateType }}</em>
 
   </BlockLayout>
diff --git a/src/gamecore/tasks/SetDynamicValueInRange.vue b/src/gamecore/tasks/SetDynamicValueInRange.vue
index 7d94e50..6086b06 100644
--- a/src/gamecore/tasks/SetDynamicValueInRange.vue
+++ b/src/gamecore/tasks/SetDynamicValueInRange.vue
@@ -1,27 +1,23 @@
 <script setup lang="ts">
-  import { GamecoreTask, 
-    DynamicExpression, 
-  } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
+  import { GamecoreTask, DynamicExpression, } from '@/sources/gamecore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     DynamicKey:string
+    ContextScope:string
     Min?:DynamicExpression
     Max?:DynamicExpression
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set <em>{{ node.DynamicKey }}</em>
+    Set <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     to a random value between <em><EvaluateExpression :expression="node.Min" /></em> 
     and <em><EvaluateExpression :expression="node.Max" /></em> 
 
diff --git a/src/gamecore/tasks/SetModifierDynamicValue.vue b/src/gamecore/tasks/SetModifierDynamicValue.vue
index eea1177..af39b41 100644
--- a/src/gamecore/tasks/SetModifierDynamicValue.vue
+++ b/src/gamecore/tasks/SetModifierDynamicValue.vue
@@ -1,10 +1,10 @@
 <script setup lang="ts">
   import { GamecoreTask, DynamicExpression, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
   import ModifierLink from '@/gamecore/ModifierLink.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -12,12 +12,10 @@
     TargetType:GamecoreTargetType
     ModifierName:string
     DynamicKey:string
+    ContextScope:string
     NewValue?:DynamicExpression
     ModifyFunction:string
   }
-
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
@@ -38,7 +36,7 @@
       <template v-else>
         this modifier's
       </template>
-      <em>{{ node.DynamicKey }}</em>
+      <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
       <template v-if="node.TargetType">
         on <em><EvaluateTargetType :target="node.TargetType" /></em>
       </template>
@@ -56,7 +54,7 @@
       <template v-else>
         this modifier's
       </template>
-      <em>{{ node.DynamicKey }}</em>
+      <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
       to <em><EvaluateExpression :expression="node.NewValue" /></em>
 
     </template>
diff --git a/src/gamecore/tasks/SortByModifierDynamicFloat.vue b/src/gamecore/tasks/SortByModifierDynamicFloat.vue
index 45e54fe..68ad9db 100644
--- a/src/gamecore/tasks/SortByModifierDynamicFloat.vue
+++ b/src/gamecore/tasks/SortByModifierDynamicFloat.vue
@@ -1,8 +1,8 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import ModifierLink from '@/gamecore/ModifierLink.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -10,10 +10,8 @@
     ReadTargetType?:GamecoreTargetType
     ModifierName:string
     DynamicFloatKey:string
+    ContextScope:string
   }
-  
-  if (node.DynamicFloatKey)
-    useHashStore().register(node.DynamicFloatKey, true)
 </script>
 
 <template>
@@ -26,7 +24,7 @@
     <template v-else>
       this modifier's
     </template>
-    <em>{{ node.DynamicFloatKey }}</em>
+    <DynamicKey :dynamicKey="node.DynamicFloatKey" :contextScope="node.ContextScope" />
 
   </BlockLayout>
 </template>
diff --git a/src/gamecore/tasks/TriggerModifierCustomEvent.vue b/src/gamecore/tasks/TriggerModifierCustomEvent.vue
index f1b09b1..eebce57 100644
--- a/src/gamecore/tasks/TriggerModifierCustomEvent.vue
+++ b/src/gamecore/tasks/TriggerModifierCustomEvent.vue
@@ -1,9 +1,9 @@
 <script setup lang="ts">
   import { GamecoreTask, GamecoreTargetType, DynamicExpression, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateTargetType from '../EvaluateTargetType.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
@@ -12,12 +12,10 @@
     CasterFilter?:GamecoreTargetType
     EventType?:string
     DynamicKey?:string
+    ContextScope:string
     Value?:DynamicExpression
     MaxNumber?:DynamicExpression
   }
-  
-  if (node.DynamicKey)
-    useHashStore().register(node.DynamicKey, true)
 </script>
 
 <template>
@@ -39,7 +37,7 @@
     </template>
     
     <template v-if="node.DynamicKey">
-      with <em>{{ node.DynamicKey }}</em>
+      with <DynamicKey :dynamicKey="node.DynamicKey" :contextScope="node.ContextScope" />
     </template>
     <template v-if="node.Value">
       set to <em><EvaluateExpression :expression="node.Value" /></em>
diff --git a/src/gamecore/tasks/WriteCustomValueToStatistic.vue b/src/gamecore/tasks/WriteCustomValueToStatistic.vue
index af17507..28da0eb 100644
--- a/src/gamecore/tasks/WriteCustomValueToStatistic.vue
+++ b/src/gamecore/tasks/WriteCustomValueToStatistic.vue
@@ -1,24 +1,22 @@
 <script setup lang="ts">
   import { GamecoreTask, DynamicExpression, } from '@/sources/gamecore';
-  import useHashStore from '@/common/hashstore';
   import BlockLayout from '@/components/BlockLayout.vue';
   import EvaluateExpression from '../EvaluateExpression.vue';
+  import DynamicKey from '@/gamecore/DynamicKey.vue';
 
   const props = defineProps<{node:GamecoreTask}>()
   const node = props.node as unknown as 
   {
     CustomKey:string
+    ContextScope:string
     CustomValue?:DynamicExpression
   }
-
-  if (node.CustomKey)
-    useHashStore().register(node.CustomKey, true)
 </script>
 
 <template>
   <BlockLayout :source="node">
 
-    Set statistic <em>{{ node.CustomKey }}</em>
+    Set statistic <DynamicKey :dynamicKey="node.CustomKey" :contextScope="node.ContextScope" />
     to <em><EvaluateExpression :expression="node.CustomValue" /></em>
 
   </BlockLayout>