event_whenthisspriteclicked

Author: takaokouji

src/lib/ruby-generator/event.js

@@ -9,17 +9,17 @@ export default function (Generator) {
         return `${Generator.spriteName()}.when(:flag_clicked) do\n`;
     };
 
-    Generator.event_whenthisspriteclicked = function (block) {
-        block.isStatement = true;
-        return `${Generator.spriteName()}.when(:click) do\n`;
-    };
-
     Generator.event_whenkeypressed = function (block) {
         block.isStatement = true;
         const key = Generator.quote_(Generator.getFieldValue(block, 'KEY_OPTION') || null);
         return `${Generator.spriteName()}.when(:key_pressed, ${key}) do\n`;
     };
 
+    Generator.event_whenthisspriteclicked = function (block) {
+        block.isStatement = true;
+        return `${Generator.spriteName()}.when(:clicked) do\n`;
+    };
+
     Generator.event_whenbackdropswitchesto = function (block) {
         block.isStatement = true;
         const backdrop = Generator.quote_(Generator.getFieldValue(block, 'BACKDROP') || null);

src/lib/ruby-to-blocks-converter/event.js

@@ -60,8 +60,18 @@ const EventConverter = {
             rubyBlock) {
             switch (args[0].value) {
             case 'flag_clicked':
+            case 'clicked':
                 if (args.length === 1) {
-                    block = this._createBlock('event_whenflagclicked', 'hat');
+                    let opcode;
+                    switch (args[0].value) {
+                    case 'flag_clicked':
+                        opcode = 'event_whenflagclicked';
+                        break;
+                    case 'clicked':
+                        opcode = 'event_whenthisspriteclicked';
+                        break;
+                    }
+                    block = this._createBlock(opcode, 'hat');
                     this._setParent(rubyBlock, block);
                 }
                 break;

test/unit/lib/ruby-to-blocks-converter/event.test.js

@@ -181,4 +181,75 @@ describe('RubyToBlocksConverter/Event', () => {
             expect(res).toBeFalsy();
         });
     });
+
+    describe('event_whenthisspriteclicked', () => {
+        test('normal', () => {
+            code = 'self.when(:clicked) { bounce_if_on_edge }';
+            expected = [
+                {
+                    opcode: 'event_whenthisspriteclicked',
+                    next: {
+                        opcode: 'motion_ifonedgebounce'
+                    }
+                }
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+
+            code = 'self.when(:clicked) { bounce_if_on_edge; move(10) }';
+            expected = [
+                {
+                    opcode: 'event_whenthisspriteclicked',
+                    next: rubyToExpected(converter, target, 'bounce_if_on_edge; move(10)')[0]
+                }
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+        });
+
+        test('hat', () => {
+            code = `
+                bounce_if_on_edge
+                self.when(:clicked) do
+                end
+                bounce_if_on_edge
+            `;
+            expected = [
+                rubyToExpected(converter, target, 'bounce_if_on_edge')[0],
+                {
+                    opcode: 'event_whenthisspriteclicked'
+                },
+                rubyToExpected(converter, target, 'bounce_if_on_edge')[0]
+            ];
+            convertAndExpectToEqualBlocks(converter, target, code, expected);
+        });
+
+        test('invalid', () => {
+            [
+                'self.when(:clicked)'
+            ].forEach(s => {
+                convertAndExpectToEqualRubyStatement(converter, target, s, s);
+            });
+
+            [
+                'self.when(:clicked, 1) { bounce_if_on_edge }',
+                'self.when(:click) { bounce_if_on_edge }'
+            ].forEach(s => {
+                expect(converter.targetCodeToBlocks(target, s)).toBeTruthy();
+                const blockId = Object.keys(converter.blocks).filter(id => converter.blocks[id].topLevel)[0];
+                expect(converter.blocks[blockId].opcode).toEqual('ruby_statement_with_block');
+            });
+        });
+
+        test('error', () => {
+            code = `
+                forever do
+                  self.when(:clicked) do
+                  end
+                end
+            `;
+            const res = converter.targetCodeToBlocks(target, code);
+            expect(converter.errors).toHaveLength(1);
+            expect(converter.errors[0].row).toEqual(2);
+            expect(res).toBeFalsy();
+        });
+    });
 });