More on FLTK glpuzzle logic

There is a complete structure of nodes and the way that the solution is found is by using a back pointer. Once the solution is identified, it takes its back pointer and marks it as a solution pointer. All possible moves up to that point are mapped, but for any set of moves from a specific game position, only one will lead to a solution.

The second part of this is how the list of nodes is generated and that could be depth first and so would identify many dead ends and loops as they happened.

I used the debian diagram editor to demonstrate the relationships. Here the moves 1,2,4 are all different moves from the same puzzle condition. Move 3 is from puzzle condition 2 and was not a solution and thus the back pointer is unused. The move numbers indicate in which order they are checked and have nothing to do with their dependency.

Strangely, once I discovered how the game worked it is exactly as I imagined that I would program it without looking at the code. There is a list of puzzles that are generated and each is walked until a solution is found. In this case there are 80 free paths that result in potential solutions and I assume if I keep running it, that it will generate all paths and I can go back and find the valid multiple solutions from the back pointers.

So that does work and tomorrow I can add the graph with colors for dead ends and loops and cross-links and solve paths. Which brings up an interesting thought. Of course I could map any point to any other point as it is based on valid moves. I suppose a stat that I could generate is the farthest path between 2 nodes and the range of distances to solutions.

solvePuzzle number of elements is 24780 and poss= 152

That is horrible. I thought there were a couple more ways to solve and there are 152 different ways. The picture is #152. That is just so bad. I still haven't answered why I would assume that the tree was vastly smaller. I guess it is just the same as everybody, assumptions and ignorance. Now I need to see where these are located and the length of the paths. I guess I ignored the positions that didn't make a lot of difference and so there are only really a dozen truly different solutions. That makes me feel a bit better. I guess there really aren't that many unique solutions. There are many states where it is solved and the other pieces are moved about, but they are not states that move from unsolved to solved. That is the next analysis.

115 moves to path number 2 at 23943 !
115 moves to path number 3 at 23982 !
115 moves to path number 6 at 24075 !
117 moves to path number 8 at 24112 !
46 moves to path number 69 at 24674 !
46 moves to path number 71 at 24682 !
22 moves to path number 77 at 24695 !
22 moves to path number 80 at 24701 !
solvePuzzle number of elements is 24780 and poss= 152

So there are really only 8 truly unique solution paths and the others are puzzles that are already solved and have pieces moved about without affecting the solution. So I feel even better about what I thought. I did miss one major branch, and its mirror image, but that does tell me something. In looking at the problem I failed to wander back far enough to see a branch as it seemed to be less and less likely. I suppose that is that hidden valley issue of stable states.

I now have the procedures to display the data, but I am considering a cave like structure or maybe a strange mountain range with tunnels and colors.

115 from 0 - path 1 at 23903 length 115 intersect 0 116
114 from 3 - path 2 at 23943 length 117 intersect 1 116
115 from 4 - path 6 at 24075 length 119 intersect 1 118
117 from 0 - path 8 at 24112 length 117 intersect 0 118
46 from 90 - path 69 at 24674 length 136 intersect 1 135
46 from 90 - path 71 at 24682 length 136 intersect 2 135
22 from 116 - path 77 at 24695 length 138 intersect 69 137
22 from 116 - path 80 at 24701 length 138 intersect 71 137
solvePuzzle number of elements is 24780 and poss= 152

This is quite odd and there seems to be a path that is 47. This does have something to solution for Rubik's cube also and so I may extend it for that. Presently I have a good layout for the data and will implement moves of a specific piece type as a dimension. This is more realistic and so there are really 8 solutions in two categories and perhaps I was right about seeing the entire tree in my head. Its always iffy with the mind.

Mind to the 5th power

This is a puzzle I could cheat, but it is solvable. It comes with the FLTK as a test program.

I do see how empathy sympathy and emulation takes place. It is like a mind in a mind and much like wearing a people suit. So now I can think of how people think of other people. It would be a recursive thing as at that point it merges. That is an interesting thing as the "I know you know" riddle does not expand to infinity as one might possibly conjecture.

The next puzzle is to assume that galaxies are not moving away from us at any speed other than general wandering motion. What would cause light to shift red in wavelength proportional to the distance it travels? It seems a simple puzzle, but when you have solved a puzzle it always seems easy and when you start it is unknown whether it will ever resolve. That is how I felt when I started this puzzle shown which is glpuzzle.cxx with FLTK. It is a tricky one and it took several runs to be able to model what I wanted to do and how to achieve it.

It has a solve option, but the solver does not pull the white cube out, that can only be done when it is solved. The code is quite another puzzle and how the solve takes place there is a new thing to understand. Funny that it is called Faster than Light Tool Kit as I was discussing a little light trick that I know. I suppose it could be called the Cherenkov tool kit too.

I was wrong, when the puzzle is solved by the machine it does allow you to move the white block. It does however solve it with a different handedness than I did myself, which is interesting in itself as there are obviously two ways to solve and I wonder what the decision tree looks like?

After three days this looks absurdly easy and the difference between left and right hand solves is obvious just looking at the puzzle. It seems to reinforce my new understanding that original thought takes place inside a brain cell and it requires the growth of dendrites and axons to establish a larger framework. I can see the entire tree and traverse it in my head now.

Cheating Checkers

If you read my blog ( which nobody really does except me, so I guess it is like talking to myself ) you know how much I like to cheat games. The FLTK has some examples that come with the source and it is OpenGL tool kit. An interesting thing they have done is go one step further and include configure in the make file. It is not even challenging to start from source and get the finished product. It requires the ability to type the word make in a terminal which could be daunting for some, but that has to be purely psychological. I am sure there are 7 year olds that actually do this.

Anyway I am goofing with the source to see what I can learn from the fact that it is a solved game and extend the logic a bit to boards that have many more checkers.

Strange things are happening in the intertubes and why IDK.

It has a lot of interesting things that are in the package and this is the equivalent of "gears" I guess. I am getting the idea that I can take all these projects and bind them into one interface that allows all the features to be shared. Something like a generic UI that does gimp-like and blender-like and ImagigeMagick things from the library interface. It hasn't gelled yet, but I am sure it is possible to automatically discover the proper libraries and functions and meta code it from scratch on initial invocation.

Image openGL and meta UI

I have been working with scripts, ImageMagick source ( which includes the source for display ) along with the source of many other packages in an attempt to integrate all the graphical techniques as an interface through a common program structure in the complex of antfarmgl.

I also got the package:

sudo apt-get install gbrainy

Which is a Google code game that has logic puzzles. In addition I completed SuperTuxKart challenges to see what happens and if it is coherent for the complete game and discovered an interesting "Easter Egg" which I will not reference here as that would be a spoiler.

Many of the effects that can be achieved with convert can be created by loading images with display and using the menus. The clock above was sheared from the menu command.

New scripts are appearing all the time and some are very elegant. I am planning to contribute a polygon fitting algorithm that operates like this: A reverse texture lookup is used to identify areas of the image along with hole fill and a kind of image gravity. After that polygons are created in OpenGL for each element identified at a very low level. It is then rendered in 3D with lighting and then a light direction and type is fitted if possible. It proceeds through the image collecting parts in a manner similar in some aspects to a genetic polygon fitting algorithm which I saw on Robert Alsing's web log. The result uses surface geometry and lighting to further establish the coherence of the image and association of parts along with guesses of how it projects into zero space ( blackness ) or reflective blooms (100% white ) where there is no method to associate without context.

As a result, the polygons form a surface which is a 3D model and not a 2D surface such that it can technically be used as a model when it resolves. The time of completion varies widely across image types. I discovered a method to compress video files in the process and it could compress already compressed video by another 50% beyond a format like mp4 or such. I am continuing to experiment with that and may have a demo image at some time in the indeterminate infinite future.

Inside and outside the Kart in SVG

The source for Super Tux Kart is well laid out and has good style. It includes instructional information about methods, and has an overall structure that is professional. I look forward to doing some personal mods that travel through molecules or in n-space. Nice work.

The image is of a concept that is of recent concern. It is design by recursion. Stepping back from any project and asking how can the entire process be modified to control a program that creates the end result. An example that I implemented recently is a script to use ImageMagick to produce textures as part of `make`. Instead of editing images and saving them as textures, the script is modified to create the graphics on the destination platform. What this gains is the bandwidth compression from a 4 megabyte image to a 10 line script. It is possible to pass the script as the knowledge of how to make the image.

The drawing above is my first attempt to use the "NEW" and improved Inkscape. (It didn't turn out too well as I was stunned by the number of new tools and need to have a bit of practice with the filters as many are completely new concepts.) It is way more elegant and so many new features. It is typical of the new Linux packages. If you tried Linux a year ago and again today, it would stun you to see how far it has progressed. This is the true power of open source becoming evident.It is not so much the improvement that surprises me, it is the rate of improvement. The interaction is becoming more coherent and the applications are improving exponentially in stages. I suspect that in as little as a few months it will again double in utility. The integration of XML and SVG along with standardized interfaces makes it possible to reuse in ways that I never suspected would be possible. The extensions of export from Inkscape is something I have to learn and also connect to my `blender` and `gimp` scheme and Python scripts. Lots of wonderful new things are happening.

sudo apt-get source supertuxkart

Supertuxkart

The developers have been really active and the changes to `supertuxcart` are phenomenal. Appreciation has to be given to the device driver developers also as this is running with open source graphic DRI acceleration. The game was interesting before, but now it seems professional and certainly would be very entertaining for children. I do enjoy it myself, but my favorite sport is to look at the code and change the game to see if I understand the process and hopefully learn something new.

I have been checking out all the new versions of the packages available through debian and these are becoming more usable and professional by leaps and bounds. Whatever they are doing, they should keep doing it that way. Here is a link at Wikipedia to the history of this game. The strange thing is they are trying to delete the Wikipedia entry, but why?

I understand now why the distribution is being slimmed down as the packages are becoming more elegant and complex and as a result larger amounts of data and code involved. Thanks to those developers, they have some real programming talent and an eye for the art.

Fire like will

This is pretty much the logic of the chase in lesson21 within the windowed quote below, and I wouldn't expect it to be very sophisticated as it is just an example. The SDL sound works and the openGL is without err that I see. It uses fine position and integer position to define the interaction and it uses a number rather than a #define and I will certainly grep and sed that out or actually I think I will leave everything as it is and rip this section out to a separate file that does the hunting and escape logic. I hate fighting the computer when it has advantage and so I will let the computer struggle with itself and see how to improve the wolf and prey in stages so they continually increase their talent.

The goal is to have a hunt and avoid that is effective. I see the avoidance of the hunter as time when applied to a real scenario and it is adjusted to force the computer to make choices that are less than optimal but act in real time as you could possibly make it perfect in its choice, but it might be doomsday before it decided and acted. Life requires action in context and this hunter is the fire that drives the beast to act. This should be relatively easy to implement as a malloc'd tree

The balance of the drive and search should ultimately yield a strategy that is optimum for the particular situation and the talent of the seeker. I see now there won't be much of the original game left when I am through as window code and SDL and time and randomness is something I have already implemented and I mainly wanted to see this below and analyze it as a predator prey relationship.

        if (!gameOver) {
            for (loop1 = 0; loop1 < (stage * level); loop1++) {
                if ((enemy[loop1].x < player.x) &&
                    (enemy[loop1].fy == enemy[loop1].y * 40)) {
                    enemy[loop1].x++;
                }

The code should be very obvious as fy is "fine" y or dots on the screen for smooth movement and the integers are positions on the limited grid. The array indexed [loopl] simply allows a structure for each predator when there are multiple predators and a single prey. I am thinking now that I might experiment with the nature of pack behavior for some insight into that also.

I am definitely ripping everything out of this in concept and using my own code as it suffers the same issues as `einstein` like failure to scale, things that should be variable are numbers instead of even define and too many printfs to indicate things that are obvious. I really am only left with a concept and an intent and "Y Meistr"," Y Blaidd Ofn".

So I will simply incorporate the concepts in my code and perhaps that is all I wanted out of this is a framework to consider "drive" and real time in the context of finding solutions in an n-Dimensional probabilistic decision tree structure.

This looks like a lot of fun and the implementation of expanding and contracting decision trees in many dimensions with an underlying matrix construction should be very entertaining when displayed in OpenGL and rotated through dimensions. I can retrofit that to the `einstein` like puzzle with probabilities set at 100% since that system is unambiguous in its solutions. All in all it looks to be very informative in what I learn about making matrices, Markov chains, trees, and decisions interact in a real world scenario. It needs a web interface to allow it to look for real information and I probably will implement something akin to page rank for my own interests. Probably something that looks for key information about my interests and attempts to correlate them and reduce redundancy using a weighted structure based on my valuation of the general quality of information source.

More single-stein puzzle changes

I have decided to change the way hints act and this may be valuable for larger puzzles and unusually shaped puzzles. I have a feeling that in the final state this will have amino acids as puzzle pieces and that the dimensions of the puzzle will be 4D and will be able to be represented as WebGL objects that interact with javascript.

I think that I need an animation for when the puzzle solves itself and it takes pieces and orients the hints as they are in the puzzle when it has found their position. Also I wanted to make middle mouse button flip the pieces in a dimension. Perhaps I need [<shift> (left , middle and right)].( mouse buttons ) to swap in 4 space. That makes sense.

Quote from Wikipedia ( I am getting tired of spell check on Wikipedia and not Google or Microsoft. Show some respect guys(My apologies as it is Firefox and if you select Wikipedia and right click you can add it to the dictionary, my mistake ) and add it, it is one of the most visited sites on the web. ).

Stein is a German word meaning "stone"

I think that single-stein is a better name. I can say it means that if you have more than a single Stein of beer you can't solve it. Besides that it could be interpreted as "ein stein".

As far as the SOAP interface to Google, I am not sure that it is the origin of spell corrections, and I will look into the process and try to leave any answer I find here, where the question is.

I am going to see if I can make the code work with rectangular puzzles of 1x2 1x3 2x4 etc and modify the methods in general to use the arrays in such a way that they can be malloc(ated) on the fly with my linked list memory management for a synthetic imagination.

So I suppose where all this is headed is a merger of one-stein, my protein analyzer, neurological genotype to phenotype, antfarmgl, MakeHuman, WebGL , meta code generator, and nano machines. It seems a reasonable mixture and it allows a virtual web interface to a world of a synthetic universal constructor, which can be tele-piped any where there is a protocol match. It is my vision of space travel. I could have a receiver anywhere and it would translate a sequence as an effective construction. I makes sense really. It is what tele-computing should be about. In the end everybody has the physical reality of an object if they choose. I suppose it is like teleportation.

So the nature of protein operation in computation is that it is method, object, operator, operand, and product all at once and I have considered this in my meta code generation. The biggest hurdle is to represent the inherent parallelism of the system, as each element acts as a specific instruction set CPU and is also a product. Very odd, but that is just the way it is. I have discovered some very interesting consequence of how these things act and it certainly helps in understanding why it operates the way it does.

I can imagine a future where a family fails to restrict access to the net and as a result the child has downloaded a bear, selected print to reality, and the parents find a Grizzly bear in the closet. You might think that is science fiction, but I consider it something that is likely to happen, and as such is mere speculation upon the consequence of that which has already been devised.

So, people will be downloading files of their favorite person and some day that person will chance to meet themselves in the supermarket and be really upset that somebody is copying them. It could happen and perhaps sooner than we have the sense to figure out what strange things will happen as a result. I can think of hundreds of ways that it could go awry and well that is the danger of knowing, which is just less dangerous than not knowing, but sometimes I wonder, by how much?

All of the methods and concepts are becoming coherent for me and the analogous process is helping to make everything fit well. It seems it will solve to a single relationship of some sort. I have noticed and I know that many would like to have "folding@home" work and they have many good ideas to find the function and structure of proteins, but they lack what I have, which is the equation that defines the universe, and to me it is simple. How would I rate the worth of this knowledge? IDK. If it quickly solves the dilemma of protein function it is worth a billion fortunes. The problem is that someone will take the idea and "sell" the product to others, when I would not give them this answer to use as a tool to enslave others, either physically or economically.

It is the worst problem of all, what to do with the evil "Master" of "Gallifrey", and all his monstrous tricks? I had an interesting thought. The "Tardis" is alive and the "Doctor" were really killed, what would it do? I know Dr Who is just fiction, but the consideration remains the same if someone were to implement such a thing. Don't you wonder that also, Alice Infinity?

Tutorial corrections side effect

I just wondered if snapshot would snapshot snapshot ....I know you know.

It is an interesting game and I have never seen one like it. I suppose all this is just a minor blemish. Here is a very interesting link at Wikipedia that is pertinent.

I really appreciate the production of tutorials at NeHe and I always have a lot of fun taking them apart and putting them back together. I ran out of things to do with WebGL and so I decided to build a model of a planet and bombard it with meteorites and in my own round about way am still headed there. I am just correcting things because that is what I do, compulsively. A reference to Wikipedia about DIBs. And below is the things I added to make everything work right for BMP load, however I have a sneaking feeling that this has the same issues in RIFF, so I will go clean that now. It is from Lesson 21 at NeHe Linux GLX. It is that int thing that I complained about before, and I dismissed it for lack of time until now. I have done compatible Int 0x10 bios, VESA, SVGA, DRV, and application files for video and I have seen and dealt with DIB (BMP) formats a thousand times at least.

It seems that NeHe could just have '#include "dib_load.h"' or link to a loader that was common and then their site would not get speckled with incomplete code when a change is made, it is a design issue I suppose and I know it is for learning, but this is not what to teach people. (uint32_t) is NOT (long int)! I suppose I am being picky for a free resource, but if lots of people learn the wrong way to do something you end up with code everywhere that is difficult to use by no fault of the student. string.h was just added for a strlen warning and stdint.h is needed for the definitions of uint32_t.

#include <string.h>
#include <stdint.h>
struct bmpfile_magic {
  unsigned char magic[2];
};
 
struct bmpfile_header {
  uint32_t filesz;
  uint16_t creator1;
  uint16_t creator2;
  uint32_t bmp_offset;
};
    uint32_t bfOffBits;
    uint32_t biSizeImage;
printf("%d is not _always_ %d.\n",
sizeof(long int),sizeof(uint32_t));

#define PLANE_SIZE 2
#define BPP_SIZE 2
#define AXIS_SIZE 4

Clarifying nD logic

DIMENSION VIEWS

GROUP ASSOCIATIVE DIMENSION VIEW

SPATIAL ASSOCIATIVE DIMENSION VIEW

Using the `einstein` game with a puzzle size of 2x2 as an example, in this partially solved case, "A" is determined to be associated with "2" in the second set and "B" is determined to be associated with "1" in the second set and yet the visualization of the outcome has no information as to the potential solution or restriction of possibilities, and a obvious possibility of what would resolve the puzzle. In the top image it is shown in the associative dimension and bottom is the normal way to represent position within the 2D puzzle space.

Thus I could look at a problem in a different dimension and represent the relationships in space as being associations, thus making it quite obvious what the choices to solution entail. In the top view, it is shown that the puzzle is "solved in a particular dimension".

In a way, or perhaps a dimension, this has something to do with

space

As an extension of matrix math I am generating and solving matrices which expand into nD spaces and use an additional operator to extend its nature as a type of "universal mathematical constructor".

BTW: In passing or possibly, En passant, I have noticed that the patent trolls are very busy in the area of delivering content and attempting to patent the concept of delivering structured content. I am sure they will make everybody unhappy and reduce everybody's productivity and possibly profit a few Shillings while destroying millions of man hours of honest effort. IDK. It is what trolls do.

Articulating Interconnections (AI)

This is the file "graph.ps"

Below is the file which is used as input for the graphviz generator. It is the output of the code generator and represents an internal relationship of parts. The image is the visual product file.

This is the file "graph.viz"

graph G
{
        edge [len=2];

        State1 -- State2 [label="Method 1"];
        State1 -- State3 [label="Method 4"];
        State1 -- State4 [label="Method 5"];
        State4 -- State5 [label="Method 6"];
        State8 -- State7 [label="Method 7"];
        State4 -- State8 [label="Method 8"];
        State9 -- State10 [label="Method 9"];
        State8 -- State9 [label="Method 10"];
        State8 -- State1 [label="Method 11"];
}

To put it all together: here is the command line that uses the input file and generates the output file from the relationships.

dot -Tps graph.viz -o graph.ps

To perform a test it only requires you to run the shell script above after creating the graph file and it will create the post script output. In my case, the program generator creates the "graph.viz" file from its tree information and executes `dot` to generate the image reference of the structure of a decision. This is very rudimentary and I have devised a method to articulate the product in 3D, and even nD by rotating through the factorial interaction of dimensions to view a different aspect of the associative structure. Here is something I am investigating today in neural nets at "ai-junkie". I am sure I will learn something new. I have several relationships which are incomplete in my coherent understanding of the entire process of intelligence articulation , however I know the "shape of the information" in several dimensions and will soon find it.

One 3D method possible for code relationships. I find this interesting as I can use it to discover some dependency relationships that I wonder about.

 Thu Dec 31 09:30 AM$ ./cinclude2dot.pl -i /usr/include HelloMe.c>HelloMe.dot
 Thu Dec 31 09:30 AM$ cat HelloMe.dot | springgraph -s 1 >spring.png

Some astounding PovRay images.

Nine dimensions in three

The white lines are associations and the blue indicate possibilities not excluded at the time of this display. This is an 8x8 puzzle with 2 spatial relationships. The visible matrix of 2x2 and 3x3 puzzles take up simple recognizable shapes that do not differ, and also have no handedness.

This is the attempt to display a nine dimensional relationship in three. I suppose it is entertaining and I prefer it to looking at the lists of associations and possibilities and exclusions. It is incomplete and I need to add some more logic to make it think properly. It may take some time, as this is getting ever so complex in the associations. I have been trying to be sloppy so I can trigger my fault handler and I managed to do that one more time. It is almost too easy. I use kate, the KDE editor, open a terminal in the program and do a make and then run the program in the partial window terminal. I was editing a section and typed the wrong index for an array and bang! fault handler. The funny thing is that with the line number and module displayed on the terminal and line numbers and file name in kate, I only had to look up, click on the top portion of the screen, enter the proper number , press (Control)+s, to save, click back to the terminal and run make and execute again, success. It almost seems too easy, I expect some pain with debugging and that is what makes it rewarding, when you stop banging you head on the wall.

ADDED: The matrix is working very well now and the above image is a solved array wher the thin reddish lines indicate paradoxical connections and the white lines indicate associated elements. This matrix and its methods in conjunction with a 2 dimensional imagination allows for some puzzles that may not be humanly solvable when used to devise puzzle hints, as such I will have a configuration option to enable this feature for entertainment only.Now I am focused on the finalization of save, help, and configure, along with packaging and auto configure for install to test for needed dev files for a source build. The image below , from a different solution, which shows paradoxical or impossible connections in dark red, may better demonstrate the visualization technique.

The game with N space intelligence

In this case, "B is left of 1" is sufficient information to solve the puzzle. In the past I had seen hints that were redundant in many ways and I modified the selection code to make the puzzle generator a bit smarter. I still have to make the triples smarter, but that will be another day, as I need to deal with some real life issues that have "teleputted" on me.

Purpose for the game

{ }

I finally decided what I am going to do with the game I have been working on for a couple months now. I am going to make the solution a set of linear equations in a matrix and a circuit that can operate with ins and outs, so that it can be combined with other game solutions to produce a larger circuit. When there are NxN games or sets of linear equations, they become the new elements of the game and thus it generates combinations of sets which function. I need to have a criteria for selection of the elements and a structure that allows them to be associated. Matrix calculations should not be difficult, but circuits could be complex. I think I will make a set which is an image of a program element. I think it would also be output as a set of three dimensional arrangements that describe a visual object in 6 dimensions, with 6 parts. That should be fun and could generate some interesting results.

I have extended the concept and decided that the elements will also be sets for biomorph and genetic sequences. As such, the sequences will produce 6 strands of DNA with 6 genes that will be used as input for biomorphs and MakeHuman, and thus generate objects that can be imported and moderated in Blender. So, the arrays can be continually evolving neural circuits, protein sequences, gene sets, body plans, logic gate arrays, program instructions, and control elements. This means that as the game is played, new organisms are generated and these create animated creatures in Blender, which can be further modified and placed back as starting sets. I am sure this will generate some very odd results. I suppose I can incorporate the basic rules of start frames in DNA and introns, exons, and promoters, inhibitors, and other things that might lead me to sensible solutions for mitochondrial control systems. This seems the rational approach, as it leads to the solution to the complexity of dealing with parallel, ballistic biochemical systems.

Looking into other dimensions

I am fairly certain I have the way to portray the problems in their other dimensions and I am going to implement that before I move on to Markov and probability implementations and the possibility of deterministic molecular computing. The image shows a 7x7 with some new textures I created and some stock images from the web. I am not completely sure about the copyright on some of the images in set 7 bottom, so I will switch them for images I created in blender. Half of them are already outputs from blends or SVG or gimp, but I just took images at random and applied convert 256x256\! to force the sizes. I am going to do some png manipulation in openGL today to satisfy my curiosity and refresh my use of other file formats and sizes with GL. I do think that looking at these problems in the other dimensions will prove useful. When dealing with matrix computation, I observed some very unusual relationships in the study of linear equations. I tink I will use the mouse scroll buttons to scroll through the other dimensions.

War Games doomsday TicTacToe in openGL

I was thinking about doing an automatic "kmines" solver and realized that "kmines" is inherently ambiguous and there are states that have no solution. It means that you guess and get blowed up sometimes. I don't like that, I only like games that I win. Instead I took my TicTacToe game that was a console game and made it part of the puzzler. I added some more sophisticated methods so it looked more like the War Games display. I did a solution selection that checked for solutions of equal value and made a random choice within that group. Obviously the number of choices is 1, at times, and so it really only influences the second play to any extent. It does look like random directed play, which it is. The images and graphics from that movie seem so silly when I can do thousands of times that on a home computer. The weighted matrix was interesting to implement and it made me want to do some Hidden Markov arrays. It is a natural progression and I am working toward my same old goal of antfarmgl, but I am taking a sideways run at the system again, because it has become "emergent" in an unexpected way. One could say that emergent phenomenon are always unexpected and that is probably true, independent of the level of analysis. I suppose it depends on how emergent is defined, as there are some things which are considered emergent and predictable.

From an analysis standpoint and with understanding of AI, that movie was so horribly logically flawed that it seems a joke now. At the time it was made, I thought it was feasible, now I see it is sooo... out of date and naive.

Nine Nines the hard way

You can see what the matrix looks like when there are only 2 members to a set. And below the 9x9 has 7,290 associations.

I modified the display code so that it scales to match the puzzle size and maintains the framework. I also made a mod so that I could test puzzle size 8 and 9. I had to fix a small err in one of the hints procedures, but other than that I encountered no new serious errs. Stressing the code and pushing it to its limits is a good way to remove bugs before they show up in use. I have a high confidence that the code is teflon coated, perhaps not invincible, but well hardened. 9x9 is VERY slow and takes 20 seconds to find a usable hint collection that solves the puzzle. It does however do that without flaw or complaint and the matrix operating display is truly impressive. For the puzzle to be truly usable at 9x9 it would need some unique symbols, polygons, and math operands. I may just take some pictures from somewhere and add them as unique elements. I don't think there is such a thing as a 9 sided dice set, but after Googling I see it described at Wikipedia along with Platonic solids dice..

It sparkles when it thinks

It does sparkle when it is thinking about solving puzzles. Also you can see that my openGL textured font has some small La^Tex like function. A static image hardly does this program justice now and so you need to get the source for it when I put up a new version. It is almost mesmerizing. It rotates to show different aspects of the associations and changes states as it decides the possibility relationships. It reminds me of the crystal creature from Star Trek, except this is real and it thinks, and it isn't a bush painted with transparent gloss enamel spinning on a string while actors pretend it is a creature. This is a real thing that thinks. I think I have gone as far as I can go with this in the form it started as. I suppose I will get creative and take this to the next level of 3D characters that think this way and wander about a maze to solve it. I will finish the code, post it at Google and start a new project with this at the core. I am going to add F1 help to list the options that are key actions and then consider it a done deal. It contains a lot of interesting code, IMHO, and so it is worth a look and maybe somebody can make something of it.

Spooky Puzzler Matrix

As can be seen the matrix relationships are shown behind the portrayal of the associative dimension that uses position ( the puzzle squares in order ). It was easy to write this as I have done enough GL so that it just flows. It is a bit spooky as this describes a matrix relationship that I do not completely understand, and yet I can make it, operate it and use it. It is odd in practice to establish the hints as methods upon matrix elements that act in parallel, rather than as separate methods which are applied in sequence. The matrix comprises a dynamic form which changes with each piece of information and mutates continuously. I am now thinking about a third matrix which is the matrix of methods interaction which is a factorial array. That is going to be even more spooky.

I have spent a lot of time with this game concept , but it has been a valuable learning experience. I have learned some very interesting things about logic itself, in the process. I have a feeling that as a result of this I will have a new mathematical tool that I can use for many different purposes. I intend to implement probability associations and formula relationships within the matrix and this game is a simple sub set of those concepts. In the game probability is 1 and there are only unary mathematical relationships.

elementZ=Zbase+Zspacing*(float)i;
elementX=XYbase*sin( 2.0 * M_PI * ( (float)j / (float)PUZZLE_SIZE ) );
elementY=XYbase*cos( 2.0 * M_PI * ( (float)j / (float)PUZZLE_SIZE ) );

The elements are applied to positions about a cylinder which extends in length as the rows and the steps about the circumference are the columns. The net result is 6^4 connections.

I added a kind of openGL La^Tex in my code and that is interesting and even mildly amusing that I can have formulas and symbols generated in the flow of events. Many of the enhancements and fixes are incorporated and I plan to tar.gz it and put a new cleaner version up at the Google code site.

Make me wonder

This is how I changed the make file to get what I want. I want the objects that are linked to the main program to be recompiled when a change is made in the headers. I also wanted to have a quick command to allow the use of gdb or kdb. For the sake of some education, the names with = are substituted when the name is encountered preceded by $ and enclosed in () like $(NAME). It substitutes all of the text, except the line continuation mark '\' , before it executes the make action. In this case 'DEBUGIT = -g' and '$(DEBUGIT)' would be replaced with just the two characters '-g' . One odd thing about make files, is that there MUST be a tab on the line after a line using ':' Obviously or not, the lines with # are comment lines and are ignored by make.

LIBS  = -lGL -lglut -lSDL_mixer
PROJECT = puzzler
CC = gcc -Wall -W -ansi -pedantic 

# This is the flag to add to get debug symbols for GDB
# See man gcc with search '/-g ' with the space!
# That is vi command '/' = search
# This will make the code slow usually and -O can be used
DEBUGIT = -g


OBJECTS =  $(PROJECT)_gl.o $(PROJECT)_game.o $(PROJECT)_sdl.o $(PROJECT)_textures.o \
  $(PROJECT)_save.o $(PROJECT)_matrix.o $(PROJECT)_menu.o

SOURCES =  $(PROJECT)_gl.c $(PROJECT)_game.c $(PROJECT)_sdl.c $(PROJECT)_textures.c \
  $(PROJECT)_save.c $(PROJECT)_matrix.c $(PROJECT)_menu.c

#Build is dependent on changes to makefile also
DEPENDS = makefile $(PROJECT).h $(PROJECT).c $(PROJECT)_game.c \
  $(PROJECT)_sdl.c $(PROJECT)_save.c $(PROJECT)_gl.c $(PROJECT)_textures.c \
  $(PROJECT)_matrix.c $(PROJECT)_menu.c $(PROJECT)_game.h $(OBJECTS)

puzzler:  $(DEPENDS)
  $(CC) -c  $(SOURCES)
  $(CC) $(PROJECT).c -o $(PROJECT) $(OBJECTS) $(LIBS)
#  strip $(PROJECT)
#  ls -la $(PROJECT)

#Create the debug version, if needed
puzzlerD:
  $(CC) $(DEBUGIT) -c $(SOURCES)
  $(CC) $(DEBUGIT)    $(PROJECT).c -o $(PROJECT) $(OBJECTS) $(LIBS)