From Jay is Games
by joelybean on April 23, 2014 11:00 PM
by joelybean on April 23, 2014 11:00 PM
by pozirk on April 23, 2014 08:45 PM
* I have released Rainbow Lines on Google Play.
I have decide to make two separate versions of the game: with HD graphics and without, otherwise game file size is too big.
* Updated AdMob ANE to comply with the latest AdMob/Google Mobile Ads/Google Play/AdSense changes. New ANE is much heavier and throws numerous warnings, but seems to work fine.
Old version is deprecated and “Google Play will stop accepting new or updated apps that use the old standalone Google Mobile Ads SDK v6.4.1 or lower. You must upgrade to the Google Play version of the Mobile Ads SDK by then.”
As usual, available it is at GitHub: https://github.com/pozirk/ANEAdMob
* Match Jong is somewhat in freezed state at the moment, but I have a playable demo, and my artist is ready to start preparing graphics. Going to start working on the game soon.
* Little by little, I’m releasing free version of All-in-One Mahjong 2 with updated AdMob ANE, of course.
All-in-One Mahjong 2 FREE is already available on Google Play.
by Satori on April 23, 2014 04:00 PM
by kimberlyfelix on April 23, 2014 01:00 PM
by elle on April 23, 2014 04:00 AM
by Eric on April 22, 2014 08:30 PM
Hey guys! For those of you who celebrate/recognize the Easter holiday season, I hope you all had a great holiday! For the rest of you, I hope you all had a great weekend!
We haven’t had a poll on here in a bit, so here goes:
Which game or games did you play over the weekend/holiday?
by LDora on April 22, 2014 06:00 PM
by Lori.h on April 22, 2014 04:00 PM
by LDora on April 22, 2014 01:00 PM
by freezairmsilvereye on April 21, 2014 04:00 PM
by pixelpracht on April 21, 2014 01:07 PM
There are striking similarities between my current project Core Society and Grove Script which was the first domain specific programming language I’ve ever written. It was a really fun project on two levels: It’s fun to come up with a domain specific language of your own and then write a parser for it and an interpreter, where, for a change, optimization for speed is actually justified. But once you have established that new interface to talk to your computer the *real* fun can begin: To figure out how to use that new language and see what you can do with it. When you already know a systems inner workings and can change it on a whim if something doesn’t please you the learning experience isn’t even painful. Core Society is like this. It’s about programming cellular automata.
Cellular Automata are a well known concept in computer science. Typically you have a regular grid of cells, each in one of a finite number of states. Based on a set of rules you can look at a cell and it’s neighbours and decide on the cell’s next state. Now you just apply these rules repeatedly to all cells in the grid. It’s amazing to think about the complexity that can emerge from even simple setups. Take Conway’s Game of Life for example where each cell has only two possible states (on/off) and where only four simple rules define a cells next state based on itself and the local neighbours. And despite that it’s not only capable of generating complex evolving patterns, you can even build a Universal Turing Machine with it!
Conway’s Game of Life is a simple rule based system, quite in contrast to God’s Game of Life
But why simple rules and simple cell states? When I hear the word ‘Cell’ I think of the building blocks of all known living organisms, capable of self-replication and functionally quite complex. I wanted to step away from simple, rule based systems and towards the complexity of living cells. Why not build a cellular automaton where each cell is a fully programmable little computer? No external rules would decide how a cell’s state would change – only the initial programming of the cores would determine the course of the simulation.
I’ve never written an emulator before but that was exactly what I needed to do next – just that I wasn’t emulating an already existing computer system but a system I had yet to define. A system specifically designed to serve as a programmable cell in a CA.
The architecture I’ve settled with acts like a von Neumann machine where instruction and data share the 256 16bit words of memory. That means the whole memory is mapped to an 8bit address space. Because I can’t use less than a word (16 bit) to encode an instruction I figured there are enough bits left to encode additional information along with the instruction – including the target address the operation is meant to operate on. All other computer systems I know don’t have instructions that operate directly on memory. Not only because they have a far larger amount of addressable memory but also because they are designed to run efficient on physical hardware and memory access is a bottleneck. Thus most CPU’s have a couple of registers to store binary data in. When you program for those CPU’s in assembler you typically spend a lot of instructions copying data between registers and memory and I was pretty excited about a chance to get away without it. Apart from that a lot of the basic instructions in CoreSociety’s assembly language will look familiar if you know other assembly languages. Here’s the full list.
After planning the instruction set from a semantic point of view I needed to figure out how to map the instruction and all relevant parameters to one or, if the instruction is more complex, two words of memory.
To be memory-efficient not all bits encode the same kind of information in every instruction. For example not all instructions have a second parameter. The INC instruction just increases the value at the given address, while the SET instruction replaces the value at a given address with a new value that also needs to be supplied. If an instruction expects a second parameter the next word following the instruction is assumed to encode this parameter.
Here’s how it works in detail: The highest four bit of an instruction word always encode the instruction group. If a group consists of complex operations that require two operands only 2 bits are available to identify the group member. The 3rd bit (Param Flag) will encode whether the following parameter word, that encodes the second operand, is interpreted as a numeric value or as a pointer to an address. So there are 16 distinct groups possible that can either consist of 4 complex or 8 simple instructions. More then enough for our needs.
The next bit is the Target Flag and it tells the processor how the lower 8bits of the instruction word, that always encode the first operand of the operation, are to be interpreted. When it’s set the operation’s target is not an address but a numeral value or an address reached by indirection. Indirection means the passed address is not used directly as the target but read to get another address which is then used as a target.
When a second parameter is required the word after the instruction can either be interpreted as a 16 bit numeric value or an address that can be either supplied direct or by (recursive) indirection.
To verify the architecture I’ve build a prototype IDE to write and run core programs in. Basically you write a listing of a custom assembly language which is immediately compiled into a core’s memory. The core’s memory is visualized as colored blocks and also written out in HEX numbers. You can step through the code and watch the operations change the memory. The assembly language is pretty simple. There’s a 3-letter mnemonic assigned to each instruction followed by one or two operands. You can use labels to assign names to specific memory addresses and use those names instead of the actual address. Comments are also supported.
This is the IDE where the cell-programms are written and tested. Click for an unscaled version!
It’s surprising what you can do with just 512 bytes. A program to calculate prime numbers that I wrote as an early test-case was only 17 words long, leaving more then enough room to store the primes. Another positive side-effect of such tiny memory is that you can visualize all the data with a couple hundred pixels. I found it pretty fascinating to watch the little cores work!
A core viewed in the IDE spending 255 energy on calculating primes. The last primes it finds is 19, then he runs out of energy.
The next step after implementing the virtual system that would represent a cell in the Cellular Automata was to put a bunch of them together in a grid so that they could start interacting.
This is the GRID the simulation takes place. Each tick the core with the highest unbound energy get’s to execute an instruction. Energy is distributed cyclical until the energy budget is spend!
With the basic set of instructions in place I needed to figure out the rules by which cores (e.g. the cells) would be able to interact with their neighbours and how the system would decide which core would get to execute an instruction next. The straight-forward solution would be to just let them execute one instruction one after another and to add some instructions to read and write the memory of neighbouring cores.
But I’ve settled with something more complex. I had this grand vision that Core Society might evolve into a platform for competitive programming games. Like an arena where you’d try to write the perfect program to beat a challenge or compete with other programs for grid space. So I added an energy mechanic that governs the execution and interaction of programs. Energy is a precious resource that each core accumulates over time. It is spend when a core executes instructions. A core can spend energy to shield itself, preventing adjacent cores from writing into it’s memory. It can also reserve an amount of energy that when released allows the core to execute a number of instructions uninterrupted. There is an instructions that allows you to transfer energy into a neighbouring core. And one to drain energy from it, respectively.
So with a few bytes a core can be programmed to copy it’s program to neighbouring cores. Once the program has spread over multiple cores those can work together to establish dominance of the grid against competing programs or fulfil whatever goals they were programmed to.
Last but not least – to facilitate the creation of scenarios – I added an instruction to raise and one to lower a global score. It serves as a metric to gauge efficiency of a solution to a scenario. Obviously the more excess energy you can spend on raising the score the better the final score will be. The initial board state could involve some cores that lower the score constantly so a high scoring solution would need to be very efficient in gaining control of these cores as fast as possible.
The green core is calculating primes, supported by the grey cores who provide it with energy! The blue cores try to prevent the red core from taking over the board by spending their energy to keep a shield up and supporting neighbours.
If you’d like to see more than animated gifs I’d suggest you check out Core Society’s Github repository or download it’s content as a ZIP. It includes a precompiled executable, full source-code, documentation and a couple of scenarios including reference solutions.
by LDora on April 21, 2014 01:00 PM
by Kyh on April 20, 2014 06:00 PM
by dsrtrosy1 on April 20, 2014 04:00 PM
by freezairmsilvereye on April 20, 2014 01:00 PM
by JohnB on April 20, 2014 05:00 AM
by LDora on April 19, 2014 07:00 PM
by starchild on April 19, 2014 05:30 PM
by freezairmsilvereye on April 19, 2014 04:00 PM
by Lori.h on April 19, 2014 01:00 PM
by joelybean on April 18, 2014 10:00 PM
by LDora on April 18, 2014 04:00 PM
by dsrtrosy1 on April 18, 2014 01:00 PM
by Ferret on April 17, 2014 08:46 PM
The mining facilities on Xolara are swarmed by alien creatures that need to be turned into piles of red goo. Build effective defenses, gather precious minerals and repel the invasion while upgrading your towers and abilities.
Eight new Quests are now available!
by dsrtrosy1 on April 17, 2014 04:00 PM
by Eric on April 17, 2014 03:00 PM
by LDora on April 17, 2014 01:00 PM
by LDora on April 16, 2014 03:00 PM
by Lori.h on April 16, 2014 01:00 PM
by Colm on April 16, 2014 09:18 AM
The last week has been an important one for me. I've given up my job and become a fulltime indie game developer, I've released the first trailer for Guild of Dungeoneering and launched the game on Steam Greenlight.
Indie can be hard to define and is definitely a bit too overloaded these days, but it explains quite well what I'm trying to do. I'll be mostly working by myself making games. I like to compare myself to a writer who has decided to give up the day job and focus entirely on finishing that first novel.
So this has been in the works for a couple of months. Fred (who is doing all the art for Guild of Dungeoneering) came up with the script, the jokes, did all the animation, picked the music and even did the voiceover for it!! Talented fellow! Have a look yourself:
We released this last Wednesday at the same time as a big press blitz I coordinated which has led to quite a few people writing about us, which is fantastic! I'll write up a longer post about the experience later on.
We also launched on Steam Greenlight at the same time, to try and maximise any press exposure we got for the trailer and convert as much of it as possible into Greenlight votes and attention.
So far this is going well, though not quite the rocketship to the top I was hoping for. As of this writing we are 42% of the way to the top 100 with 2,910 yes votes. Sadly a massive proportion of visits to the page has been from within Greenlight itself, so despite getting some big numbers to the main game page in the last few days they haven't quite translated into Greenlight traffic. That said, I'm sure anyone who's looking at the game page and clicks through to greenlight is pretty likely to throw down a yes vote.
I do have some more ideas to get extra traffic onto greenlight so more on that when it's ready. I'll also write up a much longer post on the whole experience once we're through. Oh and if you've voted for the game - Thanks! It's really appreciated!
by elle on April 16, 2014 04:00 AM
by Eric on April 15, 2014 10:46 PM
by dsrtrosy1 on April 15, 2014 06:00 PM
by LDora on April 15, 2014 05:30 PM
by Johnny123 on April 15, 2014 04:00 PM
by kimberlyfelix on April 15, 2014 01:00 PM
by JohnB on April 14, 2014 10:00 PM
by LDora on April 14, 2014 06:00 PM
by elle on April 14, 2014 04:00 PM
by starchild on April 14, 2014 01:00 PM
by JohnB on April 14, 2014 06:00 AM
by JohnB on April 13, 2014 07:00 PM
by Johnny123 on April 13, 2014 04:00 PM
by joelybean on April 13, 2014 01:00 PM
by LDora on April 13, 2014 10:00 AM
by JohnB on April 12, 2014 09:00 PM
by LDora on April 12, 2014 01:00 PM
by LDora on April 11, 2014 10:00 PM
by Chris on April 11, 2014 05:23 PM
If you run a Flash game portal and you were hosting games from MochiMedia, or running MochiAds or Live Updates, then you are probably looking for a way to replace those games. Good news! You can easily find working versions, or replacements of these games on FlashGameDistribution.com.
FGD has a dedicated feed for portal owners who are looking to replace their Mochi games. You can access this feed at FGD’s feed page. Here you can access the whole database of games we have on our system, currently weighing in at 26,000+ games. And you can tailor your feed as you see fit, either targeting ex-mochi games specifically, recent games, top games, or even get a feed of our entire database. If you have an account on FGL, just login with the same credentials, if you don’t, register on FGL and you’ll be able to login to FGD and access the feed.
The easiest way to add our games to your website is to use our php feed. Including your desired php feed will allow you to add the list of games into an array directly into the variable $fgd_games. Putting the following line (below) in your php script will allow you to embed the games directly into your page, and then you can do whatever you want with the included array (like adding your games to your database!).
If you are looking for high scores and achievements check out GamerSafe and our Data Bridge. With the Mochi API now gone, many users of their Flash APIs have been signing up for GamerSafe. The GamerSafe Data Bridge allows games that integrate our GamerSafe scoreboards and achievements to pass that player activity data to your portals. You can find out more about how the Data Bridge works on the GamerSafe website. Please contact Steve (email@example.com) if you have any questions about GamerSafe or the Data Bridge.
Also, if you register your portal with GamerSafe we share 10% of the gross earnings of all in-game purchases on your portal.
Also remember, if you are interested in mobile, we have a number of great offerings:
- Mobile Platform – FGL can help you find and publish native game apps to multiple app marketplaces. We also help you monetize by providing tools for handling cross promotion, ads, and much more. If you are interested in our Mobile Platform please contact Adam (firstname.lastname@example.org)
- HTML5 games – FGL has been receiving hundreds of HTML5 games over the last few months. If you are interested in licensing HTML5 games please contact Matt (email@example.com)
- HTML5 Portal in a Box – If you run a portal, the chances are that you are getting traffic from mobile devices. FGL has an easy solution for engaging and monetizing that mobile traffic. We are currently looking to work with a few interested portals for early access into this system. If you are interested, please contact Chris (firstname.lastname@example.org)
by freezairmsilvereye on April 11, 2014 04:00 PM
at April 11, 2014 01:34 PM
As a quick follow up to the last post where I was trying to fix the tiny slow down in the game I had a bit of a break through. Reducing the size of my pooled objects made a really large difference ( I was just pre-pooling too many items, mainly as a safety net ).
With those pools reduced it's a lot smoother now, which I'm pleased about.
Set up a twitter account for the game ( @DN8Pulse ) , as I think it's going to be an easy way to get quick feedback from players.
And to hopefully finish off the twitter / social stuff I've added a "Tweet your score" option to the game over screen. I thought rather than just a bland text tweet a custom image may be cool, and that's what you can see above there.
( It's all done using Movieclips and Sprites in Flash, so didn't take a fraction of the time to have done it in Starling, and it's just so nice being able to layer and position things in an IDE ).
I've just finished the Orbs power-ups, these are two droids that spin around your ship blocking baddie bullets. If a bullet hits one rather than just being destroyed, it's rebounded back at the baddies, which should hopefully be slightly more than a nice touch.
A bit of a slow week really, more focused on the fluff rather than getting levels and baddies in there. There's still more to do than I'd hoped for, it should be coming to a close now.
by LDora on April 11, 2014 01:00 PM
by Eric on April 11, 2014 10:08 AM
I come across SO many crab tanks on the server, and I love it. I’m tempted to set up a separate page just for featured crab tanks, as this is the second one I’ve featured.
In fact, the more I think about that, the more like a great idea it sounds. Hmm..
Today’s Featured Tank is the Crabopoculeps!!!
By: Nik 90ko
Tank ID: E10010527
(Know of some awesome tanks you want me to show off? Post the code in the comments!)
by LDora on April 11, 2014 04:00 AM
by LDora on April 10, 2014 10:00 PM
by kimberlyfelix on April 10, 2014 04:00 PM
by Lori.h on April 10, 2014 01:00 PM
by JohnB on April 09, 2014 11:00 PM
by LDora on April 09, 2014 06:00 PM
by Satori on April 09, 2014 04:00 PM