⚡ MiltonMarketing.com Powered by Rocket.net – Managed WordPress Hosting

Home
Blog
Downloads
Forum
Games
FAQs
News
Events
Shop
Code
Contact

About Us
Contact Us
Have questions? Reach out to us anytime through our Contact page.

Our Privacy Policy – Legal Disclaimer – Site Content Policy
Read our Privacy Policy, Legal Disclaimer, and Site Content Policy to understand how we protect your data, your rights, and the rules for using our site.

Book a meeting.
Schedule a meeting with us at your convenience.

Our Partners
Find out who we work with and how we create synergies with our partners.

Our Products & Services
Products & Services
Explore our full range of products and services designed to meet your needs.

Help Desk Support
Get fast, reliable support from our helpdesk team—here when you need us.

Virii8Social
Enter Virii8Social — your space to build, connect, and bring communities to life.

Free Website
Get a free website—just add a link back to us.

WordPress
Your hub for all things WordPress—guides, tips, tools, themes, and tutorials in one place.

Setup WordPress
Let us help you set up WordPress—fast, clean, and done right.

JBD After Hour Notary
JBD After Hour Notary – Reliable notary services, available when others aren’t.

Spiritual Medium
Curabitur at lacus ac velit ornare lobortis curabitur. Quisque ut nisi aenean massa.

Autonomous Car Algorithm
An autonomous driving car with sentinel-like abilities uses a constantly vigilant, multi-sensor AI system that not only navigates and avoids hazards but also actively anticipates threats, protects occupants, and adapts in real time to maintain maximum safety and situational awareness.
- Services
- Helpdesk Support
Health
Login
Register

Approx. read time: 5.3 min.

Post: The Berry Seed of an Idea: Dreaming Up “Poons”

The Berry Seed of an Idea: Dreaming Up “Poons”

On a warm summer’s day, my family and I set out for an adventure at a local strawberry farm, little knowing that our outing would sow the seeds for a brand new game concept. The sun was high, and the rows of strawberry plants stretched endlessly, beckoning us to find the juiciest picks.

Poons tower defense game

As we delved into the berry bushes, our baskets began to fill, and the sweet aroma of ripe strawberries filled the air. It was during this picturesque family moment that we stumbled upon a peculiar strawberry. Unlike any we had seen before, this strawberry was whimsically shaped like a balloon with a tiny hole in it. Intrigued and amused, we held it up, marveling at its odd form.

The discovery quickly turned into a playful moment, as strawberries began flying through the air. Our laughter mingled with the sounds of berries squishing underfoot, transforming our berry picking into a joyous food fight. We left the farm that day with stained clothes, sticky hands, and happy hearts.

Fast forward to a night not long ago, when the memory of that peculiar strawberry drifted into my dreams. It transformed into a game idea: strawberry-shaped balloons, reminiscent of that odd strawberry, floating across a digital landscape. In the dream, these strawberries needed to be strategically popped or diverted by placing towers, combining humor with challenge in a game setting.

Waking from the dream, I was struck by the clarity and fun of the concept. It felt like a perfect blend of that joyful, spontaneous day and a playful challenge that could bring smiles to players’ faces. Motivated by the vivid dream and our memorable day at the farm, I began sketching the first designs for “Poons.”

The game is still in its early stages, but the core idea is clear: it will capture the spirit of that summer day, turning a family moment into a game that everyone can enjoy, blending strategy, fun, and the whimsicality of those strawberry-shaped balloons. As I continue developing “Poons,” I’m excited to bring a piece of that laughter-filled day into players’ homes.

The peculiar strawberry that started it all:

Poons tower defense game

Copy to Clipboard

' Bernard Aybout vb.net Poons game. 2024-05-10
' Pseudo Algorithm for game. Ver 1.0

Imports System.Windows.Forms.VisualStyles.VisualStyleElement.Rebar

Public Class form1_maingameplay

' Variables for storing tile information and messaging
    Private tiles() As Tile
    Private messageText As String
    Private currentIndex As Integer

' Start typing a message in a textbox
    StartTypingMessage(userText As String):
        Initialize messageText and currentIndex
        Clear TextBox1_inside_panel1_messagebox
        Set Timer1_panel1_messagebox_text interval and start the timer

' Create a grid of picture boxes centered on the screen
    CreatePictureBoxGridCentered():
        Clear any old tiles if they exist
        Calculate screen and grid dimensions
        Initialize tiles array
        Populate grid with scenery images and tooltips
        Generate snake path and apply patches over remaining scenery

' Generate a snake-like path for the game
    GenerateSnakePath(numRows, numCols, pathPercentage):
        Calculate the required number of path tiles
        Initialize path from a random starting point
        Loop to create a path based on available movements and set path images and tooltips

' Place visual patches over scenery tiles
    PlacePatchesOverScenery(numRows, numCols):
        Prepare list of scenery tiles
        Randomize start points and apply patches with specified sizes and types
        Set images and tooltips for patches

' Handle game form load events
    form1_maingameplay_Load(sender, e):
        Set application icon
        Create centered picture box grid

' Handle key down events for exiting the game
    form1_maingameplay_KeyDown(sender, e):
        If escape key pressed, confirm exit and handle response

' Display how to play instructions
    ToolStripMenuItem1_howtoplay_Click(sender, e):
        Display gameplay instructions in a panel and start typing the message

' Display and update text in a message box periodically
    Timer1_panel1_messagebox_text_Tick(sender, e):
        Append characters to message box or stop the timer

' Regenerate the game map
    RegenerateMapToolStripMenuItem_Click(sender, e):
        Recreate the picture box grid centered

End Class

' Class to hold picture box and type information for tiles
Public Class Tile:
    PictureBox As PictureBox
    Type As TileType

' Constructor
    Sub New(picturebox, type):
        Initialize PictureBox and Type

' Enum for tile types
Public Enum TileType:
    Scenery, Path, Water, Mountain

“Poons,” the random map generation is primarily focused on creating a snake-like path and placing visual patches over scenery, which includes various tile types like water and mountains. Here’s a detailed breakdown of how each component works:

Table of Contents

9 Minutes Read

1. Generating a Snake-Like Path

The generation of a snake-like path involves a few key steps:

Initialization: The path starts at a random position on the leftmost column of the grid (for simplicity, often the first column).
Path Tile Count: You calculate the total number of path tiles needed based on a percentage of the total grid tiles. This percentage determines how much of the map the path will cover.
Path Creation: The path is generated tile by tile. Starting from the initial position, you decide the next tile in the path based on available movements:
- Right: Moves the path horizontally to the right.
- Down and Up: Moves the path vertically up or down.
- Checking Availability: Each potential move is checked to ensure it doesn’t overlap with already placed path tiles and stays within grid boundaries.
Random Movement Decision: Among the possible movements (right, up, down), a random choice is made to determine the next tile of the path.
Visual Update: Each chosen tile is visually updated to display the path image, and its type is set to ‘Path’.

2. Placing Patches Over Scenery

After the path is generated, the next part of random map generation involves placing different types of patches (like water and mountain) randomly over the remaining ‘Scenery’ tiles:

Selection of Start Points: You first identify all tiles that are still marked as ‘Scenery’ and eligible for transformation into a patch type.
Randomization: The start points for patches are shuffled to ensure randomness in their placement.
Patch Application:
- Type and Size: Each patch’s type (water or mountain) and size (number of tiles it covers) are randomly determined.
- Patch Growth: Starting from a selected tile, the patch expands outwards up to the determined size. The expansion tries to randomly choose adjacent tiles that are still marked as ‘Scenery’.
- Bound Checking: Expansion is controlled to stay within grid boundaries and not overlap with existing paths or other patches.
- Visual and Type Update: As each tile is included in a patch, its visual representation and type are updated to reflect the patch.

3. Randomness and Constraints

The randomness in this process comes from:

The initial starting point of the path.
The direction choices for path extension.
The selection and starting points of the patches.
The random determination of patch sizes and types.

Constraints include:

Ensuring the path does not cross over itself.
Keeping patches within the grid and avoiding overlap with the path.
Managing the total number of tiles each patch type can cover.

This method of map generation allows each game to present a unique challenge, as the layout will differ each time, affecting the strategic decisions players must make when placing their towers.

Full game template/framework to be released soon for testing and suggestions….

Full game template/framework 1.0 released.

Copy to Clipboard

'Bernard Aybout's Blog MiltonMarketing.com
'Poons 1.0 framework.
'
'

Imports System.Windows.Forms.VisualStyles.VisualStyleElement.Rebar

Public Class form1_maingameplay

Private tiles() As Tile ' Array to hold the state of each tile

Private messageText As String
    Private currentIndex As Integer

Private Sub StartTypingMessage(ByVal userText As String)
        messageText = userText
        currentIndex = 0
        TextBox1_inside_panel1_messagebox.Text = String.Empty

' Configure and start the timer
        Timer1_panel1_messagebox_text.Interval = 100 ' Adjust the interval for typing speed
        Timer1_panel1_messagebox_text.Start()
    End Sub

Private Sub CreatePictureBoxGridCentered()
        ' Check and clear any old tiles if already initialized
        If tiles IsNot Nothing Then
            For Each tile As Tile In tiles
                If tile IsNot Nothing AndAlso tile.PictureBox IsNot Nothing Then
                    Me.Controls.Remove(tile.PictureBox)
                    tile.PictureBox.Dispose()
                End If
            Next
        End If

' Screen dimensions
        Dim screenWidth As Integer = Screen.PrimaryScreen.Bounds.Width
        Dim screenHeight As Integer = Screen.PrimaryScreen.Bounds.Height
        Dim pictureBoxSize As New Size(60, 60)
        Dim margin As Integer = 70
        Dim usableScreenWidth As Integer = screenWidth - 2 * margin
        Dim usableScreenHeight As Integer = screenHeight - 2 * margin
        Dim numRows As Integer = usableScreenHeight \ pictureBoxSize.Height
        Dim numCols As Integer = usableScreenWidth \ pictureBoxSize.Width
        Dim startX As Integer = (screenWidth - numCols * pictureBoxSize.Width) \ 2
        Dim startY As Integer = (screenHeight - numRows * pictureBoxSize.Height) \ 2

' Initialize the tiles array to match grid dimensions
        ReDim tiles(numRows * numCols - 1)

' Initialize all tiles as default scenery (using the image)
        Dim index As Integer = 0
        For row As Integer = 0 To numRows - 1
            For col As Integer = 0 To numCols - 1
                Dim pictureBox As New PictureBox() With {
                .Size = pictureBoxSize,
                .Location = New Point(startX + col * pictureBoxSize.Width, startY + row * pictureBoxSize.Height),
                .BorderStyle = BorderStyle.FixedSingle,
                .Image = My.Resources.scenery_img, ' Set the scenery image
                .SizeMode = PictureBoxSizeMode.StretchImage
            }
                tiles(index) = New Tile(pictureBox, TileType.Scenery)
                Me.Controls.Add(pictureBox)

' Set tooltip for initial "Scenery" type
                ToolTip1.SetToolTip(pictureBox, "Scenery")
                index += 1
            Next
        Next

' Generate and apply the path
        GenerateSnakePath(numRows, numCols, 0.25)

' Apply patches over the remaining scenery
        PlacePatchesOverScenery(numRows, numCols)
    End Sub

Private Sub GenerateSnakePath(numRows As Integer, numCols As Integer, pathPercentage As Double)
        Dim rand As New Random()
        Dim totalTiles As Integer = numRows * numCols
        Dim requiredPathTiles As Integer = CInt(Math.Ceiling(totalTiles * pathPercentage))

' Initialize the path from the leftmost column at a random row
        Dim currentRow As Integer = rand.Next(1, numRows - 1)
        Dim currentCol As Integer = 0
        Dim pathTiles As New List(Of Tuple(Of Integer, Integer))()

pathTiles.Add(Tuple.Create(currentRow, currentCol))
        tiles(currentRow * numCols + currentCol).PictureBox.Image = My.Resources.path_img ' Set path image
        tiles(currentRow * numCols + currentCol).Type = TileType.Path
        ToolTip1.SetToolTip(tiles(currentRow * numCols + currentCol).PictureBox, "Path") ' Set tooltip for path

' Movement directions: right, down, up, left
        Dim directions As New List(Of Tuple(Of Integer, Integer)) From {
        Tuple.Create(0, 1),  ' right
        Tuple.Create(1, 0),  ' down
        Tuple.Create(-1, 0), ' up
        Tuple.Create(0, -1)  ' left
    }

' Generate the path until reaching the rightmost column or required tiles count
        While pathTiles.Count < requiredPathTiles AndAlso currentCol < numCols - 1
            ' Find potential movements (example)
            Dim possibleMoves As New List(Of Tuple(Of Integer, Integer))

' Check right movement
            Dim newCol As Integer = currentCol + 1
            If newCol < numCols AndAlso Not pathTiles.Contains(Tuple.Create(currentRow, newCol)) Then
                possibleMoves.Add(Tuple.Create(currentRow, newCol))
            End If

' Check vertical movements (up and down)
            For Each direction In {directions(1), directions(2)}
                Dim newRow As Integer = currentRow + direction.Item1
                If newRow >= 0 AndAlso newRow < numRows AndAlso Not pathTiles.Contains(Tuple.Create(newRow, currentCol)) Then
                    possibleMoves.Add(Tuple.Create(newRow, currentCol))
                End If
            Next

' If no moves are possible, exit
            If possibleMoves.Count = 0 Then Exit While

' Choose the next move randomly
            Dim nextMove = possibleMoves(rand.Next(possibleMoves.Count))
            currentRow = nextMove.Item1
            currentCol = nextMove.Item2

pathTiles.Add(nextMove)
            tiles(currentRow * numCols + currentCol).PictureBox.Image = My.Resources.path_img
            tiles(currentRow * numCols + currentCol).Type = TileType.Path
            ToolTip1.SetToolTip(tiles(currentRow * numCols + currentCol).PictureBox, "Path")
        End While
    End Sub

Private Sub PlacePatchesOverScenery(numRows As Integer, numCols As Integer)
        Dim rand As New Random()
        Dim patchTypes As TileType() = {TileType.Water, TileType.Mountain}
        Dim tilesToProcess As New List(Of Tuple(Of Integer, Integer))()

' Prepare list of potential start points for patches, only for remaining scenery tiles
        For i As Integer = 0 To tiles.Length - 1
            If tiles(i).Type = TileType.Scenery Then
                tilesToProcess.Add(New Tuple(Of Integer, Integer)(i \ numCols, i Mod numCols))
            End If
        Next

' Shuffle the list to randomize start points
        tilesToProcess = tilesToProcess.OrderBy(Function(x) rand.Next()).ToList()

' Limit patches to 10% of total tiles for each type
        Dim totalTiles As Integer = tiles.Length
        Dim maxPatchTiles As Integer = CInt(totalTiles * 0.1) ' 10% of total tiles
        Dim waterTilesCount As Integer = 0
        Dim mountainTilesCount As Integer = 0

' Place patches ensuring they are of size 3 to 5 tiles
        For Each startTile In tilesToProcess
            Dim row As Integer = startTile.Item1
            Dim col As Integer = startTile.Item2
            Dim index As Integer = row * numCols + col

If tiles(index).Type = TileType.Scenery Then
                Dim patchType As TileType = patchTypes(rand.Next(patchTypes.Length))
                Dim patchSize As Integer = rand.Next(3, 6) ' Random patch size between 3 and 5 tiles

' Check the patch type and control the number of tiles
                Dim currentPatchCount As Integer = If(patchType = TileType.Water, waterTilesCount, mountainTilesCount)
                If currentPatchCount + patchSize > maxPatchTiles Then
                    patchSize = maxPatchTiles - currentPatchCount ' Adjust size to not exceed limit
                End If

If patchSize > 0 Then ' Proceed only if there's room for more tiles of this type
                    FillPatch(row, col, numRows, numCols, patchType, patchSize)
                    If patchType = TileType.Water Then
                        waterTilesCount += patchSize
                    Else
                        mountainTilesCount += patchSize
                    End If
                End If
            End If
        Next
    End Sub

' Helper method for patch filling
    Private Sub FillPatch(row As Integer, col As Integer, numRows As Integer, numCols As Integer, patchType As TileType, patchSize As Integer)
        Dim queue As New Queue(Of Tuple(Of Integer, Integer))
        queue.Enqueue(New Tuple(Of Integer, Integer)(row, col))
        Dim processed As Integer = 0

While queue.Count > 0 AndAlso processed < patchSize
            Dim current As Tuple(Of Integer, Integer) = queue.Dequeue()
            Dim r As Integer = current.Item1
            Dim c As Integer = current.Item2
            Dim idx As Integer = r * numCols + c

If r >= 0 AndAlso r < numRows AndAlso c >= 0 AndAlso c < numCols AndAlso tiles(idx).Type = TileType.Scenery Then
                tiles(idx).PictureBox.Image = If(patchType = TileType.Water, My.Resources.water_img, My.Resources.mountain_img)
                tiles(idx).Type = patchType
                processed += 1

' Set tooltip for the new patch type
                ToolTip1.SetToolTip(tiles(idx).PictureBox, If(patchType = TileType.Water, "Water", "Mountain"))

' Enqueue neighboring tiles to form a patch
                Dim neighbors As Tuple(Of Integer, Integer)() = {
                Tuple.Create(r - 1, c), Tuple.Create(r + 1, c),
                Tuple.Create(r, c - 1), Tuple.Create(r, c + 1)
            }

For Each neighbor In neighbors
                    Dim nRow As Integer = neighbor.Item1
                    Dim nCol As Integer = neighbor.Item2
                    Dim neighborIdx As Integer = nRow * numCols + nCol
                    If nRow >= 0 AndAlso nRow < numRows AndAlso nCol >= 0 AndAlso nCol < numCols AndAlso
                    tiles(neighborIdx).Type = TileType.Scenery Then
                        queue.Enqueue(neighbor)
                    End If
                Next
            End If
        End While
    End Sub

' Fill a patch with a specified type, ensuring a minimum patch size

' Show error message
    Private Sub ShowErrorMessage(title As String, message As String)
        MessageBox.Show(message, title, MessageBoxButtons.OK, MessageBoxIcon.Error)
    End Sub

' Initialize the form with a grid when loaded
    Private Sub form1_maingameplay_Load(sender As Object, e As EventArgs) Handles Me.Load
        Me.Icon = My.Resources.appicon

CreatePictureBoxGridCentered()
    End Sub

' Handle key down events
    Private Sub form1_maingameplay_KeyDown(sender As Object, e As KeyEventArgs) Handles Me.KeyDown
        If e.KeyCode = Keys.Escape Then
            ' Ask the user if they're sure about exiting
            Dim result As DialogResult = MessageBox.Show("Are you sure you want to exit the game?", "Exit Game", MessageBoxButtons.YesNo, MessageBoxIcon.Question)

' Exit the application if the user clicks 'Yes'
            If result = DialogResult.Yes Then
                Application.Exit()
            Else
                ' Prevent further handling of this key if 'No' is clicked
                e.Handled = True
            End If
        End If
    End Sub

Private Sub BUILDToolStripMenuItem_Click(sender As Object, e As EventArgs) Handles BUILDToolStripMenuItem.Click

form_build.Show()
        form_Build.BringToFront()
    End Sub

Private Sub ExitGameToolStripMenuItem_Click(sender As Object, e As EventArgs) Handles ExitGameToolStripMenuItem.Click
        ' Ask the user if they're sure about exiting
        Dim result As DialogResult = MessageBox.Show("Are you sure you want to exit the game?", "Exit Game", MessageBoxButtons.YesNo, MessageBoxIcon.Question)

' Exit the application if the user clicks 'Yes'
        If result = DialogResult.Yes Then
            Application.Exit()

End If

End Sub

Private Sub Timer1_panel1_messagebox_text_Tick(sender As Object, e As EventArgs) Handles Timer1_panel1_messagebox_text.Tick
        ' Append one character at a time from the message text
        If currentIndex < messageText.Length Then
            TextBox1_inside_panel1_messagebox.AppendText(messageText(currentIndex))
            currentIndex += 1
        Else
            ' Stop the timer once the entire message is displayed
            Timer1_panel1_messagebox_text.Stop()
        End If
    End Sub

Private Sub ToolStripMenuItem1_howtoplay_Click(sender As Object, e As EventArgs) Handles ToolStripMenuItem1_howtoplay.Click
        ' Retrieve the screen resolution and form size
        Dim screenBounds As Rectangle = Screen.PrimaryScreen.Bounds
        Dim formCenterX As Integer = Me.Left + Me.Width \ 2
        Dim formCenterY As Integer = Me.Top + Me.Height \ 2

' Calculate the panel's top-left coordinates
        Dim panelCenterX As Integer = Panel1_messagebox.Width \ 2
        Dim panelCenterY As Integer = Panel1_messagebox.Height \ 2
        Dim panelLeft As Integer = formCenterX - panelCenterX
        Dim panelTop As Integer = formCenterY - panelCenterY

' Move the panel to the calculated position
        Panel1_messagebox.Location = New Point(panelLeft, panelTop)

Panel1_messagebox.Visible = True

StartTypingMessage("Each round in Poons lasts 40 seconds and features a randomly generated map. The path for balloons, which look like indented strawberry-shaped balloons, runs continuously across the map from one side to the other. During this time, poons are released, and players must place turret units along the path to pop them. Each turret has unique abilities and upgrades that improve their effectiveness. Strategically placing and upgrading these units is crucial to popping as many poons as possible before the round ends. It's summer, so let's pop some poons!")

End Sub

Private Sub TextBox1_inside_panel1_messagebox_Click(sender As Object, e As EventArgs) Handles TextBox1_inside_panel1_messagebox.Click

If Timer1_panel1_messagebox_text.Enabled = True Then
            ' Stop the timer to prevent further text updates
            Timer1_panel1_messagebox_text.Stop()
            TextBox1_inside_panel1_messagebox.Text = messageText
        Else
            Panel1_messagebox.Visible = False
        End If

End Sub

Private Sub RegenerateMapToolStripMenuItem_Click(sender As Object, e As EventArgs) Handles RegenerateMapToolStripMenuItem.Click

CreatePictureBoxGridCentered()
    End Sub
End Class

' Tile class to hold a PictureBox and type
Public Class Tile
    Public Property PictureBox As PictureBox
    Public Property Type As TileType

Public Sub New(picturebox As PictureBox, type As TileType)
        Me.PictureBox = picturebox
        Me.Type = type
    End Sub
End Class

' Enum representing the type of a tile
Public Enum TileType
    Scenery
    Path
    Water
    Mountain
End Enum

This is an animated gif of full game template/framework 1.0 gameplay: I Run the game, regenerate map a few times. Show how prompts are typed out like a typewriter when game communicates with user.

Regenerated map 300 times with a unique continuous path and error free map setup each time.

Download Poons Ver 1.0 Now

[wpdm_package id=’32928′]

Health FAQs

Visual Basic .NET FAQs

What is the use of New Keyword in VB.NET?

How Does the Bubble Sort Algorithm Work in VB.NET?

ADDING CONTENT USING A WEB API

What is the default value for Boolean variable in VB.NET?

Introduction to JavaScript – Libraries

WP Cost Estimation and Payment Forms Builder has been Exploited

Computer Programming Sorting Algorithms

Linux Kernel Prior to 5.0.8 Vulnerable to Remote Code Execution

Microsoft warns wormable Windows bug could lead to another WannaCry

Assembly Language FAQs

From Teen Dreams to Adult Realities: A Humorous Leap Through Time

Learning computer programming, with no teachers and no tuition

My Ultimate Tech Shopping Spree Adventure

I am a dedicated technology enthusiast with over 45 years of life experience, passionate about computers, AI, emerging technologies, and their real-world impact. As the founder of my personal blog, MiltonMarketing.com, I explore how AI, health tech, engineering, finance, and other advanced fields leverage innovation—not as a replacement for human expertise, but as a tool to enhance it. My focus is on bridging the gap between cutting-edge technology and practical applications, ensuring ethical, responsible, and transformative use across industries. MiltonMarketing.com is more than just a tech blog—it's a growing platform for expert insights. We welcome qualified writers and industry professionals from IT, AI, healthcare, engineering, HVAC, automotive, finance, and beyond to contribute their knowledge. If you have expertise to share in how AI and technology shape industries while complementing human skills, join us in driving meaningful conversations about the future of innovation. 🚀

The Berry Seed of an Idea: Dreaming Up “Poons”

⚡ MiltonMarketing.com Powered by Rocket.net – Managed WordPress Hosting

About Us

Contact Us

Our Privacy Policy – Legal Disclaimer – Site Content Policy

Book a meeting.

Our Partners

Our Products & Services

Products & Services

Help Desk Support

Virii8Social

Free Website

WordPress

Setup WordPress

JBD After Hour Notary

Spiritual Medium

Autonomous Car Algorithm

The peculiar strawberry that started it all:

1. Generating a Snake-Like Path

2. Placing Patches Over Scenery

3. Randomness and Constraints

Constraints include:

Full game template/framework to be released soon for testing and suggestions….

Full game template/framework 1.0 released.

This is an animated gif of full game template/framework 1.0 gameplay: I Run the game, regenerate map a few times. Show how prompts are typed out like a typewriter when game communicates with user.

Regenerated map 300 times with a unique continuous path and error free map setup each time.

Download Poons Ver 1.0 Now

Related Posts:

Convert Celsius to Fahrenheit

🍪 Get the Value of a Browser Cookie via JavaScript

📋 Copy Text to Clipboard with JavaScript

🎨 Convert RGB to Hexadecimal

Super Mario Bro’s

Portals of Hellion: Shattered Realms RPG

About the Author: Bernard Aybout (Virii8)

Privacy Policy – Legal Disclaimer – Site Content Policy