UI Surface

TileUIAreaFMAC.hx test:
The red area is my UI surface where UI components can be attached.
Not much now, but this is progress for me:

I am working on my own UI framework that plugs into my own rendering framework. I don’t want to be a programmer that gets stuck in the “never makes a game because always working on an engine.” But I think I am onto something.
I don’t want to suffer from “not made here syndrome”. But I’ve been unable
to get any Haxe-based UI libraries to work. So I am creating my own.

Also: Making this UI library seems like a decent point of entry to test out
the useability of my TileMapUpdateMGR that I’ve designed for use in games.

I would not advise someone to try to make an engine if they have never worked
with an engine before to make an actual game. You just don’t understand
what needs to be coded.

I made that mistake before and coded an abomination.
And then I worked with the Flixel engine and got a whole lot smarter.

…. I didn’t realize I had this much to say on what I am doing.
Maybe this is why I’ve been feeling stressed lately.

This may not look like much. But it is the beginning of implementing my
decoupled tile-based framework that will use my FMAC pattern.

//What is FMAC pattern?
FMAC == a modified MVC patter. (Model View Controller)

FMAC = “Flyweight Model Ask Controller”
The controller in this case is an API interface.
Not an actually GUI of any sort.

“ASK” replaces “VIEW”
Because a managing class asks the FMAC object for a chunk of graphics
that is can put together to use for rendering.

//Why make this?
1: A decoupling experiment:
Technology changes, and I am experimenting with decoupling systems
in ways that will give the code maximum refactor ability when it one dayneeds to be written in another language.

I found that I am keen to:
1. Wiring up systems using bound functions.
(Aka: Functions As Variables / function pointers.)

2. Using tile map structures.

I read an article that mentioned many companies suffer from
having to develop in a certain language because all of their prior systems
were written in that language. One way to fix that is to have a whole bunch
of running .exe modules on your server that communicate with each other
using HTTP protocol.

I like this idea of standardizing information.
So my bound functions simply have a certain function signature and they
can plug in wherever they are needed. Which is an abstraction of that
kind of protocol thinking.

2: A 2ndary problem solved… HaxeUI.
I haven’t been able to get any HaxeUI to work.
And I’d like to avoid “not made here syndrome” but looks like I am going
to use the framework I am creating to make UI code as well.

With all of my code existing on the same decoupled framework…
Things should run somewhat smoothly.

//Why decoupled code?
1. Attempting to maximize refactor ability to other languages by
minimizing dependencies.

The rendering’s only dependency is the “copyPixels” command.
Input dependencies are more complex, so there is one language
specific input module that plugs into the more generic input modules of
my code.

Rather than wire up event listeners to all of my systems,
every system that can take user input has functions like

A decoupled function that relies on my more coupled event listener manager
code to call.

A more standeard way to do events would be for the class to have an
onClick(evt:Event); function.

The way I am doing things is a bit odd. And seems a bit convoluted.
But I think I am onto something.


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s