Canonirag_imple

.github/workflows/run_plugin_tests.yml

@@ -0,0 +1,31 @@
+name: Plugin Tests
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+    streamlit:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Check out code
+              uses: actions/checkout@v2
+
+            - name: Set up Python 3.12
+              uses: actions/setup-python@v2
+              with:
+                python-version: 3.12
+
+            - name: Install dependencies
+              run: |
+                python -m pip install --upgrade pip
+                pip install -e .
+                pip install pytest
+
+            - name: Install Plugin
+              run: pip install -e support/plugins/streamlit
+
+            - name: Run tests
+              run: pytest support/plugins/streamlit

.github/workflows/run_pytest.yml

@@ -1,4 +1,4 @@
-name: Run Tests
+name: Tests
 
 on:
   pull_request:
@@ -25,4 +25,4 @@ jobs:
         pip install pytest
 
     - name: Run tests
-      run: pytest -x
+      run: pytest -x

.pre-commit-config.yaml

@@ -18,10 +18,10 @@ repos:
         additional_dependencies: [pep8-naming, flake8_import_order, flake8_docstrings, flake8_comprehensions, flake8_bugbear, flake8_annotations, flake8_simplify]
         exclude: "examples|vendor|langserve/tests"
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.8.0
+    rev: v1.10.1
     hooks:
       - id: mypy
-        exclude: 'venv|__jac_gen__|tests|stubs|support|vendor|examples/reference|setup.py'
+        exclude: 'venv|__jac_gen__|tests|stubs|support|vendor|examples/reference|setup.py|generated'
         args:
           - --follow-imports=silent
           - --ignore-missing-imports

examples/manual_code/circle_pure.impl.jac

@@ -1,8 +1,8 @@
 """Enum for shape types"""
 
 :enum:ShapeType {
-    CIRCLE="Circle",
-    UNKNOWN="Unknown"
+    CIRCLE = "Circle",
+    UNKNOWN = "Unknown"
 }
 
 """Function to calculate the area of a circle."""
@@ -23,6 +23,10 @@
 }
 
 :can:main_run {
-    print(f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}");
-    print(f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}");
+    print(
+        f"Area of a circle with radius {RAD} using function: {calculate_area(RAD)}"
+    );
+    print(
+        f"Area of a {c.shape_type.value} with radius {RAD} using class: {c.area()}"
+    );
 }

examples/reference/import_include_statements.jac

@@ -1,7 +1,8 @@
 import:py os;
 import:py from math, sqrt as square_root;
 import:py datetime as dt;
-import:jac from base_module_structure, add, subtract;
+import:jac from base_module_structure, add;
+import from base_module_structure, subtract;
 
 with entry {
     for i in range(int(square_root(dt.datetime.now().year))) {

examples/rpg_game/README.md

@@ -18,7 +18,7 @@ Here there are no significant changes are required for the code structure other
 
 ## Less Py more Jac : [jac_impl_2](./jac_impl/jac_impl_2/)
 
-In this iteration of the jac implementation for the RPG, some of the unique features of Jaclang, such as ```has``` variables, were explored. This feature allows for definitions of fields which will self initialize with an auto geneerate ```init```. Furthermore, previously dynamically typed variables has been updated with type annotations.
+In this iteration of the jac implementation for the RPG, some of the unique features of Jaclang, such as ```has``` variables, were explored. This feature allows for definitions of fields which will self initialize with an auto generated ```init```. Another change made was that ```init``` functions has been completely removed from the codebase which means only auto generated initialization functions are used using ```has``` variables. However, as there are requirements to run some initialization operations ```postinit``` function is used which will run at the end of the auto generated ```init```. Furthermore, previously dynamically typed variables has been updated with type annotations.
 
 ![Jac_1 Vs Jac_2](./Diagrams/Jac_impl_2_comparison.png)
 
@@ -28,8 +28,6 @@ This is where we brought out the big guns. Jaclang has a feature where a functio
 
 ![Jac_2 Vs Jac3](./Diagrams/Jac_impl_3_comparison.png)
 
-Another change made was that ```init``` functions has been completely removed from the codebase which means only auto generated initialization functions are used using ```has``` variables. However, as there are requirements to run some initialization operations ```postinit``` function is used which will run at the end of the auto generated ```init```.
-
 ## Data-Spatial Programming! : [jac_impl_4](./jac_impl/jac_impl_4/)
 
 This implementation is the BOMB! This is the first ever game written in a data-spatial architecture where each level is a node on a graph while the game itself is a walker, traversing on the graph.
@@ -40,4 +38,8 @@ Without making significant changes to the existing codebase in [jac_impl_3](./ja
 
 ## LLM Generating Maps! : [jac_impl_5](./jac_impl/jac_impl_5/)
 
-If the previous version was the BOMB this implementation would be an ICBM. This is a replica of [jac_impl_4](./jac_impl/jac_impl_4/) with an addition AI based map generation feature. This simple game is the world's first game having procedurally generated maps using LLMs based on previous gameplays. This specific implementation requires an OpenAI API key to operate which will generate playable maps using 'gpt-4'.
+If the previous version was the BOMB this implementation would be an ICBM. This is a replica of [jac_impl_4](./jac_impl/jac_impl_4/) with an addition AI based map generation feature. This simple game is the world's first game having procedurally generated maps using LLMs based on previous gameplays. This specific implementation requires an OpenAI API key to operate which will generate playable maps using 'gpt-4'. But you can use any model that are [available to use with jac-lang](https://www.jac-lang.org//learn/with_llm/).
+
+## Refined Map Generation! : [jac_impl_6](./jac_impl/jac_impl_6/)
+
+The previous implementation introduced the usage of LLMs to generate each level map. How the LLM implementation is somewhat trivial, and straightforward, which will not be the case of a robust map generator. This is a replica of [jac_impl_5](./jac_impl/jac_impl_5/) with a reimagined version of the map generation feature. In this case we are not generating the entire map, but generated map configurations which allows a symbolic function to generate the map. This new approach is an object-oriented approach which is less prone to generate unplayable maps. Additionally, this version does not utilize any assistance with semstrings, which are optional in mtllm.

examples/rpg_game/RPG_DSP_journey.md

@@ -20,9 +20,9 @@ This is a tutorial on how to build the same game in Jaclang. Two different imple
   - [Data Spatial Implementation](#data-spatial-implementation)
     - [Data Spatial architecture](#data-spatial-architecture)
   - [Converting RPG into Data-spatial Architecture](#converting-rpg-into-data-spatial-architecture)
-    - [main.jac](#mainjac)
+    - [game\_obj.jac](#game_objjac)
     - [sprite.jac, config.jac \& map.jac](#spritejac-configjac--mapjac)
-    - [Runtime Logic of the program : DSP.jac](#runtime-logic-of-the-program--dspjac)
+    - [Runtime Logic of the program : main\_dsp.jac](#runtime-logic-of-the-program--main_dspjac)
       - [Nodes and Walkers](#nodes-and-walkers)
       - [Start Screen node](#start-screen-node)
       - [Level node](#level-node)
@@ -399,18 +399,17 @@ The game built in the conventional program can be converted into the data spatia
 
 The fully implemented Data-spatial version can be found at [jac_impl_4](.//jac_impl/jac_impl_4/) if you want to jump in straight.
 
-### main.jac
+### game_obj.jac
 
-The only difference in this file is the runtime logic has been removed from here. This is because the main difference in this data-spatial implementation is that the program runtime runs as a graph. Nothing else needs to happen in this file.
+This is a direct copy of the main.jac file in previous implementations. The only difference in this file is the runtime logic has been removed from here. This is because the main difference in this data-spatial implementation is that the program runtime runs as a graph. Nothing else needs to happen in this file.
 
 ### sprite.jac, config.jac & map.jac
 
 No changes are required on these files as well.
 
-### Runtime Logic of the program : [DSP.jac](.//jac_impl/jac_impl_4/DSP.jac)
+### Runtime Logic of the program : [main.jac](.//jac_impl/jac_impl_4/main.jac)
 
 This new file will include the supporting architecture for the build of the data-spatial implementation and the runtime logic for graph traversal.
-The imports for this file would be the same as for the main.jac while it will include the main.jac file as well.
 
 ```python
 import:py pygame;
@@ -420,7 +419,7 @@ import:py random;
 include:jac sprites;
 include:jac config;
 include:jac map;
-include:jac main;
+include:jac game_obj;
 ```
 
 Now the visualization of the graph is really important in order to build the architecture.
@@ -506,3 +505,5 @@ with entry {
     root spawn game();
 }
 ```
+
+<!-- TODO: need to add impl 5 and 6 -->

examples/rpg_game/jac_impl/jac_impl_2/main.jac

@@ -26,7 +26,7 @@ obj Game {
         intro_background: pygame.surface.Surface = pygame.image.load('../img/introbackground.png'),
         go_background: pygame.surface.Surface = pygame.image.load('../img/gameover.png');
 
-    can init() {
+    can postinit() {
         pygame.<>init();
         self.font = pygame.font.Font(GENERAL_FONT, 32);
     }

examples/rpg_game/jac_impl/jac_impl_2/sprites.jac

@@ -30,21 +30,23 @@ obj Spritesheet {
 Object for the player with type pygame.sprite.Sprite
 """
 obj Player :pygame.sprite.Sprite: {
+    has game: Game,
+        x: int,
+        y: int;
     has _layer: int = PLAYER_LAYER,
         width: int = TILESIZE,
         height: int = TILESIZE,
         x_change: int = 0,
         y_change: int = 0,
         facing: str = 'down',
-        animation_loop: int = 1;
+        animation_loop: float = 1;
 
-    can init(game: None, x: int, y: int) {
-        self.game = game;
+    can postinit() {
         self._layer = PLAYER_LAYER;
-        self.groups = self.game.all_sprites;
-        pygame.sprite.Sprite.init(self, self.groups);
-        self.x = x * TILESIZE;
-        self.y = y * TILESIZE;
+        self._groups = self.game.all_sprites;
+        pygame.sprite.Sprite.init(self, self._groups);
+        self.x*=TILESIZE;
+        self.y*=TILESIZE;
         self.image = self.game.character_spritesheet.get_sprite(3, 2, self.width, self.height);
         self.rect = self.image.get_rect();
         self.rect.x = self.x;
@@ -201,20 +203,22 @@ obj Player :pygame.sprite.Sprite: {
 Object for enemies with type pygame.sprite.Sprite
 """
 obj Enemy :pygame.sprite.Sprite: {
+    has game: Game,
+        x: int,
+        y: int;
     has _layer: int = ENEMY_LAYER,
         width: inr = TILESIZE,
         height: int = TILESIZE,
         x_change: int = 0,
         y_change: int = 0,
-        animation_loop: int = 0,
+        animation_loop: float = 0,
         movement_loop: int = 0;
 
-    can init(game: None, x: int, y: int) {
-        self.game = game;
-        self.groups = (self.game.all_sprites, self.game.enemies);
-        pygame.sprite.Sprite.__init__(self, self.groups);
-        self.x = x * TILESIZE;
-        self.y = y * TILESIZE;
+    can postinit() {
+        self._groups = (self.game.all_sprites, self.game.enemies);
+        pygame.sprite.Sprite.__init__(self, self._groups);
+        self.x*=TILESIZE;
+        self.y*=TILESIZE;
         self.image = self.game.enemy_spritesheet.get_sprite(3, 2, self.width, self.height);
         self.facing = random.choice(['up', 'down', 'left', 'right']);
         self.max_travel = random.randint(7, 30);
@@ -334,16 +338,18 @@ obj Enemy :pygame.sprite.Sprite: {
 Object for blocks (Walls) with type pygame.sprite.Sprite
 """
 obj Block :pygame.sprite.Sprite: {
+    has game: Game,
+        x: int,
+        y: int;
     has _layer: int = BLOCK_LAYER,
         width: int = TILESIZE,
         height: int = TILESIZE;
 
-    can init(game: None, x: int, y: int) {
-        self.game = game;
-        self.groups = (self.game.all_sprites, self.game.blocks);
-        pygame.sprite.Sprite.init(self, self.groups);
-        self.x = x * TILESIZE;
-        self.y = y * TILESIZE;
+    can postinit() {
+        self._groups = (self.game.all_sprites, self.game.blocks);
+        pygame.sprite.Sprite.init(self, self._groups);
+        self.x*=TILESIZE;
+        self.y*=TILESIZE;
         self.image = self.game.terrain_spritesheet.get_sprite(960, 448, self.width, self.height);
         self.rect = self.image.get_rect();
         self.rect.x = self.x;
@@ -355,16 +361,18 @@ obj Block :pygame.sprite.Sprite: {
 Object for ground with type pygame.sprite.Sprite
 """
 obj Ground :pygame.sprite.Sprite: {
+    has game: Game,
+        x: int,
+        y: int;
     has _layer: int = GROUND_LAYER,
         width: int = TILESIZE,
         height: int = TILESIZE;
 
-    can init(game: None, x: int, y: int) {
-        self.game = game;
-        self.groups = self.game.all_sprites;
-        pygame.sprite.Sprite.init(self, self.groups);
-        self.x = x * TILESIZE;
-        self.y = y * TILESIZE;
+    can postinit() {
+        self._groups = self.game.all_sprites;
+        pygame.sprite.Sprite.init(self, self._groups);
+        self.x*=TILESIZE;
+        self.y*=TILESIZE;
         self.image = self.game.terrain_spritesheet.get_sprite(64, 352, self.width, self.height);
         self.rect = self.image.get_rect();
         self.rect.x = self.x;
@@ -376,15 +384,17 @@ obj Ground :pygame.sprite.Sprite: {
 Object class for buttons used in the game (Start, Restart)
 """
 obj Button {
-    can init(x: int, y: int, width: int, height: int, fg: tuple, bg: tuple, content: str, fontsize: int) {
-        self.font = pygame.font.Font(GENERAL_FONT, fontsize);
-        self.content = content;
-        self.x = x;
-        self.y = y;
-        self.width = width;
-        self.height = height;
-        self.fg = fg;
-        self.bg = bg;
+        has x: int,
+        y: int,
+        width: int,
+        height: int,
+        fg: tuple,
+        bg: tuple,
+        content: str,
+        fontsize: int;
+
+    can postinit() {
+        self.font = pygame.font.Font(GENERAL_FONT, self.fontsize);
         self.image = pygame.Surface((self.width, self.height));
         self.image.fill(self.bg);
         self.rect = self.image.get_rect();
@@ -411,17 +421,17 @@ obj Button {
 Object class for attacks by the player
 """
 obj Attack :pygame.sprite.Sprite: {
+    has game: Game,
+        x: int,
+        y: int;
     has _layer: int = ATTACK_LAYER,
         width: int = TILESIZE,
         height: int = TILESIZE,
-        animation_loop: int = 0;
+        animation_loop: float = 0;
 
-    can init(game: None, x: int, y: int) {
-        self.game = game;
-        self.groups = (self.game.all_sprites, self.game.attacks);
-        pygame.sprite.Sprite.init(self, self.groups);
-        self.x = x;
-        self.y = y;
+    can postinit() {
+        self._groups = (self.game.all_sprites, self.game.attacks);
+        pygame.sprite.Sprite.init(self, self._groups);
         self.image = self.game.attack_spritesheet.get_sprite(0, 0, self.width, self.height);
         self.rect = self.image.get_rect();
         self.rect.x = self.x;