Mechanisms

README.md

@@ -9,3 +9,13 @@
 5. Once all dependencies have been installed, run ```npm run start```
 6. Navigate to localhost:3000 in the browser to open the frontend
 7. Make sure any python backends are running on your PC.
+
+## Known Issues
+1. Mechanisms aren't limited to init
+2. Mechanisms aren't limited to only Robot or Mechanism class
+3. There is no default Robot class
+4. No way to specify whether an opmode is auto or teleop
+5. Workspace can have blocks
+6. No Robot workspace yet
+7. No Mechanism workspace yet
+8. Something weird is going on with currentModule getting unset

src/blocks/mrc_class_method_def.ts

@@ -45,7 +45,6 @@ export type Parameter = {
 type ClassMethodDefBlock = Blockly.Block & ClassMethodDefMixin & Blockly.BlockSvg;
 interface ClassMethodDefMixin extends ClassMethodDefMixinType {
     mrcCanChangeSignature: boolean,
-    mrcCanDelete: boolean,
     mrcReturnType: string,
     mrcParameters: Parameter[],
     mrcPythonMethodName: string,
@@ -58,10 +57,6 @@ type ClassMethodDefExtraState = {
      * Can change name and parameters and return type
      */
     canChangeSignature: boolean,
-    /**
-     * Can delete from class
-     */
-    canDelete: boolean,
     /**
      * The return type of the function.
      * Use 'None' for no return value.
@@ -100,7 +95,6 @@ const CLASS_METHOD_DEF = {
         this: ClassMethodDefBlock): ClassMethodDefExtraState {
         const extraState: ClassMethodDefExtraState = {
             canChangeSignature: this.mrcCanChangeSignature,
-            canDelete: this.mrcCanDelete,
             returnType: this.mrcReturnType,
             params: [],
         };
@@ -124,7 +118,6 @@ const CLASS_METHOD_DEF = {
         extraState: ClassMethodDefExtraState
     ): void {
         this.mrcCanChangeSignature = extraState.canChangeSignature;
-        this.mrcCanDelete = extraState.canDelete;
         this.mrcPythonMethodName = extraState.pythonMethodName ? extraState.pythonMethodName : '';
         this.mrcReturnType = extraState.returnType;
         this.mrcParameters = [];
@@ -157,7 +150,6 @@ const CLASS_METHOD_DEF = {
             //Case because a current bug in blockly where it won't allow passing null to Blockly.Block.setMutator makes it necessary.
             (this as Blockly.BlockSvg).setMutator( null );
         }
-        this.setDeletable(this.mrcCanDelete);
         this.mrcUpdateParams();
     },
     compose: function (this: ClassMethodDefBlock, containerBlock: any) {
@@ -347,6 +339,7 @@ export const setup = function() {
 
 import { Order, PythonGenerator } from 'blockly/python';
 
+
 export const pythonFromBlock = function (
     block: ClassMethodDefBlock,
     generator: PythonGenerator,
@@ -404,6 +397,11 @@ export const pythonFromBlock = function (
         '(' +
         paramString +
         '):\n';
+
+    if(block.mrcPythonMethodName == '__init__'){
+        code +=  generator.INDENT + "self.mechanisms = [];\n"
+
+    }    
 
     code +=
         xfix1 +

src/blocks/mrc_mechanism.ts

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2025 Porpoiseful LLC
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @fileoverview Create a mechanism with a name of a certain type
+ * @author [email protected] (Alan Smith)
+ */
+import * as Blockly from 'blockly';
+import { Order, PythonGenerator } from 'blockly/python';
+
+import { MRC_STYLE_FUNCTIONS } from '../themes/styles'
+import { createFieldNonEditableText } from '../fields/FieldNonEditableText';
+import { ExtendedPythonGenerator } from '../editor/extended_python_generator';
+import { getAllowedTypesForSetCheck, getOutputCheck } from './utils/python';
+
+export const BLOCK_NAME = 'mrc_mechanism';
+export const OUTPUT_NAME = 'mrc_mechansim';
+
+export type ConstructorArg = {
+  name: string,
+  type: string,
+};
+
+type MechanismExtraState = {
+  importModule?: string,
+  params?: ConstructorArg[],
+}
+
+type MechanismBlock = Blockly.Block & MechanismMixin;
+interface MechanismMixin extends MechanismMixinType {
+  mrcArgs: ConstructorArg[],
+  mrcImportModule: string,
+
+}
+type MechanismMixinType = typeof MECHANISM_FUNCTION;
+
+const MECHANISM_FUNCTION = {
+  /**
+    * Block initialization.
+    */
+  init: function (this: MechanismBlock): void {
+    this.setStyle(MRC_STYLE_FUNCTIONS);
+    this.appendDummyInput()
+      .appendField(new Blockly.FieldTextInput('my_mech'), 'NAME')
+      .appendField('of type')
+      .appendField(createFieldNonEditableText(''), 'TYPE');
+    this.setPreviousStatement(true);
+    this.setNextStatement(true);
+  },
+
+  /**
+    * Returns the state of this block as a JSON serializable object.
+    */
+  saveExtraState: function (this: MechanismBlock): MechanismExtraState {
+    let extraState: MechanismExtraState = {
+    };
+    extraState.params = [];
+    this.mrcArgs.forEach((arg) => {
+      extraState.params!.push({
+        'name': arg.name,
+        'type': arg.type,
+      });
+    });    
+    if (this.mrcImportModule) {
+      extraState.importModule = this.mrcImportModule;
+    }
+    return extraState;
+  },
+  /**
+  * Applies the given state to this block.
+  */
+  loadExtraState: function (this: MechanismBlock, extraState: MechanismExtraState): void {
+    this.mrcImportModule = extraState.importModule ? extraState.importModule : '';
+    this.mrcArgs = [];
+
+    if(extraState.params){
+      extraState.params.forEach((arg) => {
+        this.mrcArgs.push({
+          'name': arg.name,
+          'type': arg.type,
+        });
+      });
+    }
+    this.mrcArgs = extraState.params ? extraState.params : [];
+    this.updateBlock_();
+  },
+  /**
+     * Update the block to reflect the newly loaded extra state.
+     */
+    updateBlock_: function(this: MechanismBlock): void {
+      // Add input sockets for the arguments.
+      for (let i = 0; i < this.mrcArgs.length; i++) {
+        const input = this.appendValueInput('ARG' + i)
+            .setAlign(Blockly.inputs.Align.RIGHT)
+            .appendField(this.mrcArgs[i].name);
+        if (this.mrcArgs[i].type) {
+          input.setCheck(getAllowedTypesForSetCheck(this.mrcArgs[i].type));
+        }
+      }
+    }
+}
+
+export const setup = function () {
+  Blockly.Blocks[BLOCK_NAME] = MECHANISM_FUNCTION;
+}
+
+//TODO: This needs to cause our own init to create the mechanisms line
+export const pythonFromBlock = function (
+  mechanismBlock: MechanismBlock,
+  generator: ExtendedPythonGenerator,
+) {
+  if (mechanismBlock.mrcImportModule) {
+    generator.addImport(mechanismBlock.mrcImportModule);
+  }
+  let code = 'self.mechanisms["' + mechanismBlock.getFieldValue('NAME') + '"] = '
+    + mechanismBlock.getFieldValue('TYPE') + '('
+
+  for (let i = 0; i < mechanismBlock.mrcArgs.length; i++) {
+      let fieldName = 'ARG' + i;
+      if(i != 0){
+        code += ', '
+      }
+      code += mechanismBlock.mrcArgs[i].name + ' = ' + generator.valueToCode(mechanismBlock, fieldName, Order.NONE);
+    }
+
+  code += ')' + "\n"
+
+  return code
+}

src/blocks/setup_custom_blocks.ts

@@ -9,6 +9,7 @@ import * as MiscComment from './mrc_misc_comment';
 import * as MiscEvaluateButIgnoreResult from './mrc_misc_evaluate_but_ignore_result';
 import * as SetPythonVariable from './mrc_set_python_variable';
 import * as ClassMethodDef from './mrc_class_method_def';
+import * as Mechanism from './mrc_mechanism';
 
 const customBlocks = [
   CallPythonFunction,
@@ -20,6 +21,7 @@ const customBlocks = [
   MiscComment,
   MiscEvaluateButIgnoreResult,
   SetPythonVariable,
+  Mechanism,
 ];
 
 export const setup = function(forBlock: any) {

src/editor/extended_python_generator.ts

@@ -159,30 +159,37 @@ export class ExtendedPythonGenerator extends PythonGenerator {
     this.definitions_['import_' + importModule] = 'import ' + importModule;
   }
 
-  workspaceToCode(workspace?: Blockly.Workspace): string {
-    let code = super.workspaceToCode(workspace);
+  finish(code: string): string {
     if (!this.currentModule) {
-      return code;
-    }
-
+      return super.finish(code);
+    }    
     let className = this.currentModule.moduleName;
     let classType = this.currentModule.moduleType;
-
     this.addImport(classType);
 
-    let prefix = "";
-    for (let key in this.definitions_) {
-      prefix += this.definitions_[key] + "\n";
-    }
-    if (prefix) {
-      prefix += "\n";
+    // Convert the definitions dictionary into a list.
+    const imports = [];
+    const definitions = [];
+    for (let name in this.definitions_) {
+      const def = this.definitions_[name];
+      if (def.match(/^(from\s+\S+\s+)?import\s+\S+/)) {
+        imports.push(def);
+      } else {
+        definitions.push(def);
+      }
     }
+    // Call Blockly.CodeGenerator's finish.
+    code = Blockly.CodeGenerator.prototype.finish(code);
+    this.isInitialized = false;
 
     let class_def = "class " + className + "(" + classType + "):\n";
     if (!code) {
       code = "pass";
     }
-    return prefix + class_def + this.prefixLines(code, this.INDENT);
+
+    this.nameDB_!.reset();
+    const allDefs = imports.join('\n') + '\n\n' + definitions.join('\n\n');
+    return allDefs.replace(/\n\n+/g, '\n\n').replace(/\n*$/, '\n\n\n') + class_def + this.prefixLines(code, this.INDENT);
   }
 }
 

src/modules/opmode_start.json

@@ -0,0 +1,38 @@
+{
+    "blocks": {
+        "languageVersion": 0,
+        "blocks": [
+            {
+                "type": "mrc_class_method_def",
+                "id": "ElbONc{)s(,UprTW(|1C",
+                "x": 10,
+                "y": 10,
+                "deletable": false,
+                "extraState": {
+                    "canChangeSignature": false,
+                    "returnType": "None",
+                    "params": [],
+                    "pythonMethodName": "__init__"
+                },
+                "fields": {
+                    "NAME": "init"
+                }
+            },
+            {
+                "type": "mrc_class_method_def",
+                "id": "wxFAh6eaR1|3fTuV:UAd",
+                "x": 10,
+                "y": 200,
+                "deletable": false,
+                "extraState": {
+                    "canChangeSignature": false,
+                    "returnType": "None",
+                    "params": []
+                },
+                "fields": {
+                    "NAME": "loop"
+                }
+            }
+        ]
+    }
+}

src/storage/common_storage.ts

@@ -22,7 +22,8 @@
 import * as Blockly from 'blockly/core';
 
 import {Block} from "../toolbox/items";
-import {create as createOpMode} from '../modules/mrc_module_opmode'
+import startingOpModeBlocks from '../modules/opmode_start.json'; 
+
 import {extendedPythonGenerator} from '../editor/extended_python_generator';
 
 // Types, constants, and functions related to modules, regardless of where the modules are stored.
@@ -44,8 +45,8 @@ export type Workspace = Module & {
 };
 
 export const MODULE_TYPE_WORKSPACE = 'workspace';
-export const MODULE_TYPE_OPMODE = 'opmode';
-export const MODULE_TYPE_MECHANISM = 'mechanism';
+export const MODULE_TYPE_OPMODE = 'OpMode';
+export const MODULE_TYPE_MECHANISM = 'Mechanism';
 
 export const MODULE_NAME_PLACEHOLDER = '%module_name%';
 
@@ -157,8 +158,8 @@ export function newOpModeContent(workspaceName: string, opModeName: string): str
   // Create a headless blockly workspace.
   const headlessBlocklyWorkspace = new Blockly.Workspace();
   headlessBlocklyWorkspace.options.oneBasedIndex = false;
-  createOpMode(headlessBlocklyWorkspace, false);
-
+  Blockly.serialization.workspaces.load(startingOpModeBlocks, headlessBlocklyWorkspace);
+  
   extendedPythonGenerator.setCurrentModule(module);
   const pythonCode = extendedPythonGenerator.workspaceToCode(headlessBlocklyWorkspace);
   const exportedBlocks = JSON.stringify(extendedPythonGenerator.getExportedBlocks(headlessBlocklyWorkspace));