hikkaku 0.1.0

package/src/blocks/motion.ts

@@ -0,0 +1,146 @@
+import { fromPrimitiveSource } from '../compiler/block-helper'
+import { block, valueBlock } from '../compiler/composer'
+import type { PrimitiveSource } from '../compiler/types'
+
+export const moveSteps = (steps: PrimitiveSource<number>) => {
+  return block('motion_movesteps', {
+    inputs: {
+      STEPS: fromPrimitiveSource(steps),
+    },
+  })
+}
+
+export const gotoXY = (
+  x: PrimitiveSource<number>,
+  y: PrimitiveSource<number>,
+) => {
+  return block('motion_gotoxy', {
+    inputs: {
+      X: fromPrimitiveSource(x),
+      Y: fromPrimitiveSource(y),
+    },
+  })
+}
+
+export const changeXBy = (dx: PrimitiveSource<number>) => {
+  return block('motion_changexby', {
+    inputs: {
+      DX: fromPrimitiveSource(dx),
+    },
+  })
+}
+
+export const changeYBy = (dy: PrimitiveSource<number>) => {
+  return block('motion_changeyby', {
+    inputs: {
+      DY: fromPrimitiveSource(dy),
+    },
+  })
+}
+
+export const setX = (x: PrimitiveSource<number>) => {
+  return block('motion_setx', {
+    inputs: {
+      X: fromPrimitiveSource(x),
+    },
+  })
+}
+
+export const setY = (y: PrimitiveSource<number>) => {
+  return block('motion_sety', {
+    inputs: {
+      Y: fromPrimitiveSource(y),
+    },
+  })
+}
+
+export const goTo = (target: string) => {
+  return block('motion_goto', {
+    fields: {
+      TO: [target, null],
+    },
+  })
+}
+
+export const turnRight = (degrees: PrimitiveSource<number>) => {
+  return block('motion_turnright', {
+    inputs: {
+      DEGREES: fromPrimitiveSource(degrees),
+    },
+  })
+}
+
+export const turnLeft = (degrees: PrimitiveSource<number>) => {
+  return block('motion_turnleft', {
+    inputs: {
+      DEGREES: fromPrimitiveSource(degrees),
+    },
+  })
+}
+
+export const pointInDirection = (direction: PrimitiveSource<number>) => {
+  return block('motion_pointindirection', {
+    inputs: {
+      DIRECTION: fromPrimitiveSource(direction),
+    },
+  })
+}
+
+export const pointTowards = (target: string) => {
+  return block('motion_pointtowards', {
+    fields: {
+      TOWARDS: [target, null],
+    },
+  })
+}
+
+export const glide = (
+  seconds: PrimitiveSource<number>,
+  x: PrimitiveSource<number>,
+  y: PrimitiveSource<number>,
+) => {
+  return block('motion_glidesecstoxy', {
+    inputs: {
+      SECS: fromPrimitiveSource(seconds),
+      X: fromPrimitiveSource(x),
+      Y: fromPrimitiveSource(y),
+    },
+  })
+}
+
+export const glideTo = (seconds: PrimitiveSource<number>, target: string) => {
+  return block('motion_glideto', {
+    inputs: {
+      SECS: fromPrimitiveSource(seconds),
+    },
+    fields: {
+      TO: [target, null],
+    },
+  })
+}
+
+export const ifOnEdgeBounce = () => {
+  return block('motion_ifonedgebounce', {})
+}
+
+export const setRotationStyle = (
+  style: 'all around' | 'left-right' | "don't rotate",
+) => {
+  return block('motion_setrotationstyle', {
+    fields: {
+      STYLE: [style, null],
+    },
+  })
+}
+
+export const getX = () => {
+  return valueBlock('motion_xposition', {})
+}
+
+export const getY = () => {
+  return valueBlock('motion_yposition', {})
+}
+
+export const getDirection = () => {
+  return valueBlock('motion_direction', {})
+}

package/src/blocks/operator.ts

@@ -0,0 +1,219 @@
+import { fromPrimitiveSource } from '../compiler/block-helper'
+import { valueBlock } from '../compiler/composer'
+import type { PrimitiveSource } from '../compiler/types'
+
+export const add = (a: PrimitiveSource<number>, b: PrimitiveSource<number>) => {
+  return valueBlock('operator_add', {
+    inputs: {
+      NUM1: fromPrimitiveSource(a),
+      NUM2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const subtract = (
+  a: PrimitiveSource<number>,
+  b: PrimitiveSource<number>,
+) => {
+  return valueBlock('operator_subtract', {
+    inputs: {
+      NUM1: fromPrimitiveSource(a),
+      NUM2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const multiply = (
+  a: PrimitiveSource<number>,
+  b: PrimitiveSource<number>,
+) => {
+  return valueBlock('operator_multiply', {
+    inputs: {
+      NUM1: fromPrimitiveSource(a),
+      NUM2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const divide = (
+  a: PrimitiveSource<number>,
+  b: PrimitiveSource<number>,
+) => {
+  return valueBlock('operator_divide', {
+    inputs: {
+      NUM1: fromPrimitiveSource(a),
+      NUM2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const lt = (
+  a: PrimitiveSource<number | string>,
+  b: PrimitiveSource<number | string>,
+) => {
+  return valueBlock('operator_lt', {
+    inputs: {
+      OPERAND1: fromPrimitiveSource(a),
+      OPERAND2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const equals = (
+  a: PrimitiveSource<number | string>,
+  b: PrimitiveSource<number | string>,
+) => {
+  return valueBlock('operator_equals', {
+    inputs: {
+      OPERAND1: fromPrimitiveSource(a),
+      OPERAND2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const gt = (
+  a: PrimitiveSource<number | string>,
+  b: PrimitiveSource<number | string>,
+) => {
+  return valueBlock('operator_gt', {
+    inputs: {
+      OPERAND1: fromPrimitiveSource(a),
+      OPERAND2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const and = (
+  a: PrimitiveSource<boolean>,
+  b: PrimitiveSource<boolean>,
+) => {
+  return valueBlock('operator_and', {
+    inputs: {
+      OPERAND1: fromPrimitiveSource(a),
+      OPERAND2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const or = (
+  a: PrimitiveSource<boolean>,
+  b: PrimitiveSource<boolean>,
+) => {
+  return valueBlock('operator_or', {
+    inputs: {
+      OPERAND1: fromPrimitiveSource(a),
+      OPERAND2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const not = (operand: PrimitiveSource<boolean>) => {
+  return valueBlock('operator_not', {
+    inputs: {
+      OPERAND: fromPrimitiveSource(operand),
+    },
+  })
+}
+
+export const random = (
+  from: PrimitiveSource<number>,
+  to: PrimitiveSource<number>,
+) => {
+  return valueBlock('operator_random', {
+    inputs: {
+      FROM: fromPrimitiveSource(from),
+      TO: fromPrimitiveSource(to),
+    },
+  })
+}
+
+export const join = (
+  a: PrimitiveSource<string>,
+  b: PrimitiveSource<string>,
+) => {
+  return valueBlock('operator_join', {
+    inputs: {
+      STRING1: fromPrimitiveSource(a),
+      STRING2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const letterOf = (
+  letter: PrimitiveSource<number>,
+  text: PrimitiveSource<string>,
+) => {
+  return valueBlock('operator_letter_of', {
+    inputs: {
+      LETTER: fromPrimitiveSource(letter),
+      STRING: fromPrimitiveSource(text),
+    },
+  })
+}
+
+export const length = (text: PrimitiveSource<string>) => {
+  return valueBlock('operator_length', {
+    inputs: {
+      STRING: fromPrimitiveSource(text),
+    },
+  })
+}
+
+export const contains = (
+  text: PrimitiveSource<string>,
+  substring: PrimitiveSource<string>,
+) => {
+  return valueBlock('operator_contains', {
+    inputs: {
+      STRING1: fromPrimitiveSource(text),
+      STRING2: fromPrimitiveSource(substring),
+    },
+  })
+}
+
+export const mod = (a: PrimitiveSource<number>, b: PrimitiveSource<number>) => {
+  return valueBlock('operator_mod', {
+    inputs: {
+      NUM1: fromPrimitiveSource(a),
+      NUM2: fromPrimitiveSource(b),
+    },
+  })
+}
+
+export const round = (value: PrimitiveSource<number>) => {
+  return valueBlock('operator_round', {
+    inputs: {
+      NUM: fromPrimitiveSource(value),
+    },
+  })
+}
+
+export type MathOpOperator =
+  | 'abs'
+  | 'floor'
+  | 'ceiling'
+  | 'sqrt'
+  | 'sin'
+  | 'cos'
+  | 'tan'
+  | 'asin'
+  | 'acos'
+  | 'atan'
+  | 'ln'
+  | 'log'
+  | 'e ^'
+  | '10 ^'
+
+export const mathop = (
+  operator: MathOpOperator,
+  value: PrimitiveSource<number>,
+) => {
+  return valueBlock('operator_mathop', {
+    inputs: {
+      NUM: fromPrimitiveSource(value),
+    },
+    fields: {
+      OPERATOR: [operator, null],
+    },
+  })
+}

package/src/blocks/procedures.ts

@@ -0,0 +1,208 @@
+import { fromPrimitiveSource } from '../compiler/block-helper'
+import { block, valueBlock } from '../compiler/composer'
+import type { PrimitiveSource } from '../compiler/types'
+
+export type ProcedureArgumentDefault = string | boolean
+
+export interface ProcedureProcLabel {
+  type: 'label'
+  text: string
+}
+export interface ProcedureProcBoolean<T = string> {
+  type: 'boolean'
+  name: T
+}
+export interface ProcedureProcStringOrNumber<T = string> {
+  type: 'stringOrNumber'
+  name: T
+}
+export type ProcedureProc =
+  | ProcedureProcLabel
+  | ProcedureProcBoolean
+  | ProcedureProcStringOrNumber
+
+export const procedureLabel = (text: string): ProcedureProcLabel => {
+  return {
+    type: 'label',
+    text,
+  }
+}
+
+export const procedureBoolean = <T extends string>(
+  name: T,
+): ProcedureProcBoolean<T> => {
+  return {
+    type: 'boolean',
+    name,
+  }
+}
+
+export const procedureStringOrNumber = <T extends string>(
+  name: T,
+): ProcedureProcStringOrNumber<T> => {
+  return {
+    type: 'stringOrNumber',
+    name,
+  }
+}
+
+type OnlyArgProc<T> = T extends { type: 'label' } ? never : T
+
+export interface ProcedureReferenceBase {
+  isProcedureArgument: true
+
+  name: string
+  type: 'boolean' | 'stringOrNumber'
+  id: string
+}
+export interface ProcedureBooleanReference extends ProcedureReferenceBase {
+  type: 'boolean'
+}
+export interface ProcedureStringOrNumberReference
+  extends ProcedureReferenceBase {
+  type: 'stringOrNumber'
+}
+export type ProcedureReference =
+  | ProcedureBooleanReference
+  | ProcedureStringOrNumberReference
+
+type ReferencesByProcs<T extends ProcedureProc[]> = {
+  [K in OnlyArgProc<T[number]>['name']]: OnlyArgProc<T[number]> extends {
+    type: infer U
+  }
+    ? U extends 'boolean'
+      ? ProcedureBooleanReference
+      : U extends 'stringOrNumber'
+        ? ProcedureStringOrNumberReference
+        : never
+    : never
+}
+
+export const defineProcedure = <T extends ProcedureProc[]>(
+  proclist: T,
+  stack?: (references: ReferencesByProcs<T>) => void,
+  /**
+   * If true, the procedure will run without screen refresh until it completes.
+   * This can make the procedure run faster, but the screen will not update until the procedure is done.
+   */
+  warp = false,
+) => {
+  const proccode = proclist
+    .map((proc) => {
+      switch (proc.type) {
+        case 'label':
+          return proc.text
+        case 'boolean':
+          return '%b'
+        case 'stringOrNumber':
+          return '%s'
+        default:
+          throw new Error('Unknown procedure proc type')
+      }
+    })
+    .join(' ')
+
+  const argumentProcs = proclist.filter((proc) => proc.type !== 'label')
+
+  const argumentids = argumentProcs.map(() => {
+    // Generate a random ID for each argument
+    return Math.random().toString(36).substring(2, 15)
+  })
+  const argumentnames = argumentProcs.map((proc) => {
+    return proc.name
+  })
+  const argumentdefaults = argumentProcs.map((proc) => {
+    switch (proc.type) {
+      case 'boolean':
+        return 'false'
+      case 'stringOrNumber':
+        return ''
+      default:
+        throw new Error('Unknown procedure proc type')
+    }
+  })
+
+  const prototype = block('procedures_prototype', {
+    mutation: {
+      tagName: 'mutation',
+      children: [],
+      proccode,
+      argumentids: JSON.stringify(argumentids),
+      argumentnames: JSON.stringify(argumentnames),
+      argumentdefaults: JSON.stringify(argumentdefaults) as unknown as (
+        | string
+        | boolean
+      )[],
+      warp: warp.toString() as 'true' | 'false',
+    },
+    isShadow: true,
+  })
+
+  const definition = block('procedures_definition', {
+    inputs: {
+      custom_block: [1, prototype.id],
+    },
+    topLevel: true,
+  })
+  const references = Object.fromEntries(
+    argumentProcs.map((proc, index) => {
+      return [
+        proc.name,
+        {
+          isProcedureArgument: true,
+          name: proc.name,
+          type: proc.type,
+          id: argumentids[index],
+        } as ProcedureReference,
+      ]
+    }),
+  )
+  stack?.(references as ReferencesByProcs<T>)
+  return definition
+}
+
+export const callProcedure = (
+  proccode: string,
+  argumentIds: string[],
+  inputs: Record<string, PrimitiveSource<string | number | boolean>>,
+  warp = false,
+) => {
+  const resolvedInputs: Record<
+    string,
+    ReturnType<typeof fromPrimitiveSource>
+  > = {}
+  for (const [key, value] of Object.entries(inputs)) {
+    resolvedInputs[key] = fromPrimitiveSource(value)
+  }
+  return block('procedures_call', {
+    inputs: resolvedInputs,
+    mutation: {
+      tagName: 'mutation',
+      children: [],
+      proccode,
+      argumentids: JSON.stringify(argumentIds),
+      warp,
+    },
+  })
+}
+
+export const argumentReporterStringNumber = (
+  reference: ProcedureStringOrNumberReference,
+) => {
+  return valueBlock('argument_reporter_string_number', {
+    fields: {
+      VALUE: [reference.name, null],
+    },
+  })
+}
+
+export const argumentReporterBoolean = (
+  reference: ProcedureBooleanReference,
+) => {
+  return valueBlock('argument_reporter_boolean', {
+    fields: {
+      VALUE: [reference.name, null],
+    },
+    isShadow: false,
+  })
+}

package/src/blocks/sensing.ts

@@ -0,0 +1,129 @@
+import { fromPrimitiveSource } from '../compiler/block-helper'
+import { block, valueBlock } from '../compiler/composer'
+import type { PrimitiveSource } from '../compiler/types'
+
+export const getMouseX = () => {
+  return valueBlock('sensing_mousex', {})
+}
+export const getMouseY = () => {
+  return valueBlock('sensing_mousey', {})
+}
+
+export type CurrentMenu =
+  | 'year'
+  | 'month'
+  | 'date'
+  | 'dayofweek'
+  | 'hour'
+  | 'minute'
+  | 'second'
+export type DragMode = 'draggable' | 'not draggable'
+
+export const touchingObject = (target: string) => {
+  return valueBlock('sensing_touchingobject', {
+    inputs: {
+      TOUCHINGOBJECTMENU: fromPrimitiveSource(target),
+    },
+  })
+}
+
+export const touchingColor = (color: PrimitiveSource<string>) => {
+  return valueBlock('sensing_touchingcolor', {
+    inputs: {
+      COLOR: fromPrimitiveSource(color),
+    },
+  })
+}
+
+export const colorTouchingColor = (
+  color: PrimitiveSource<string>,
+  targetColor: PrimitiveSource<string>,
+) => {
+  return valueBlock('sensing_coloristouchingcolor', {
+    inputs: {
+      COLOR: fromPrimitiveSource(color),
+      COLOR2: fromPrimitiveSource(targetColor),
+    },
+  })
+}
+
+export const distanceTo = (target: string) => {
+  return valueBlock('sensing_distanceto', {
+    fields: {
+      DISTANCETOMENU: [target, null],
+    },
+  })
+}
+
+export const getTimer = () => {
+  return valueBlock('sensing_timer', {})
+}
+
+export const resetTimer = () => {
+  return block('sensing_resettimer', {})
+}
+
+export const setDragMode = (mode: DragMode) => {
+  return block('sensing_setdragmode', {
+    fields: {
+      DRAG_MODE: [mode, null],
+    },
+  })
+}
+
+export const getMouseDown = () => {
+  return valueBlock('sensing_mousedown', {})
+}
+
+export const getKeyPressed = (key: PrimitiveSource<string>) => {
+  return valueBlock('sensing_keypressed', {
+    inputs: {
+      KEY_OPTION: fromPrimitiveSource(key),
+    },
+  })
+}
+
+export const current = (menu: CurrentMenu) => {
+  return valueBlock('sensing_current', {
+    fields: {
+      CURRENTMENU: [menu, null],
+    },
+  })
+}
+
+export const getAttributeOf = (property: string, target: string) => {
+  return valueBlock('sensing_of', {
+    fields: {
+      PROPERTY: [property, null],
+      OBJECT: [target, null],
+    },
+  })
+}
+
+export const daysSince2000 = () => {
+  return valueBlock('sensing_dayssince2000', {})
+}
+
+export const getLoudness = () => {
+  return valueBlock('sensing_loudness', {})
+}
+
+export const isLoud = () => {
+  return valueBlock('sensing_loud', {})
+}
+
+export const askAndWait = (question: PrimitiveSource<string>) => {
+  return block('sensing_askandwait', {
+    inputs: {
+      QUESTION: fromPrimitiveSource(question),
+    },
+  })
+}
+
+export const getAnswer = () => {
+  return valueBlock('sensing_answer', {})
+}
+
+export const getUsername = () => {
+  return valueBlock('sensing_username', {})
+}