user: password:
GameGround - multiplayer platform for strategy games.
1. Running

Java Runtime Environment (JRE) version Java SE 7 or newer is required to run GameGround client.

Both GameGround server and client are continuously in active development, it is expected that sooner or later you will encounter one of the following messages while trying to connect to the server:

  • The GameGround server reported error condition: Your client version is not supported.
  • The client you are running is outdated by ...

Both messages mean more or less the same: new version of client and/or server has been released and especially client version you are currently running has been superseded by newer one.

First message is definitive, some change in the protocol has been introduced which renders old client unusable and you have no other choice but to upgrade to newest version. Second message is just a notification that some minor improvements were introduced to the client and new and possibly better version is available for download. In latter case you are not bound to upgrade right away but you are strongly encouraged to do so.

How to upgrade.

To upgrade GameGround client you need to clear Java caches.

There are several ways to do that depending on the vendor of JRE you are using:

  • First you can try to start jcontrol, then navigate to Settings... and there click Delete Files... button and finally confirm in the popup that follows.
  • If procedure above fails, you can try to run "javaws -uninstall" from your command prompt.

If none of the above works for you, you need to consult your particular JRE vendor documentation on how to clear its cache.

huginn - programming language with no quirks, so simple every child can master it.
Fork me on GitHub
git clone https://codestation.org/repo/huginn.git
git clone https://github.com/AmokHuginnsson/huginn.git
git clone https://bitbucket.org/huginn/huginn.git

Huginn is a computer programming language with following traits:

  • interpretedmultiplatform, what you type is what you got
  • imperativeuse statements to change a program's state
  • functional stylefunctions, lambdas and closures are first class citizens
  • object orienteduser defined types, composition, inheritance, exceptions
  • introspective, non-reflective type systemuser defined types are fixed and immutable at runtime,
    no monkey patching
  • strongly typedabsolutely no implicit value conversions and no implicit type coercion
  • dynamically typedfinal type consistency checks are done at runtime
  • duck typinga set of members determine the valid semantics of a type
  • no quirks guaranteesemantics is consistent across types in all contexts
  • support arbitrary precision calculations per built-in type precision is restricted only by the amount of hardware resources
  • interpreter/executor trivially embeddable in C++ code
    #include <yaal/tools/hhuginn.hxx>
    void foo( HStreamInterface& src_ ) {
    	HHuginn h;
    	h.load( src_ );
    	if ( h.parse() && h.compile() && h.execute() ) {
    		cout << "ok" << endl;

Example program written in Huginn language:

Editor (vim) - pow.hgn (Try it online!) [+line no]
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
#! /bin/sh
exec huginn -E "${0}" "${@}"
#! huginn

/* First Huginn program. */

import Algorithms as algo;

main( argv_ ) {
	print( "Hello World!\n" );
	argc = size( argv_ );
	print( "number of arguments: {}\n".format( argc ) );
	for ( i, arg : algo.enumerate( argv_ ) ) {
		print( "argv_[{}]: {}\n".format( i, arg ) );
	if ( argc >= 3 ) {
		base = number( argv_[1] );
		exp = number( argv_[2] );
		print( "{} ^ {} = {}\n".format( argv_[1], argv_[2], base ^ exp ) );
	} else {
		print( "Not enough arguments to calculate power.\n" );
	return ( 0 );


Terminal - shell session [–line no]
[amok@vegeta](2/1)~/$ ./pow.hgn 3 333
Hello World!
number of arguments: 3
argv_[0]: ./pow.hgn
argv_[1]: 3
argv_[2]: 333
3 ^ 333 = 76098802313205980972042586726503278072789635637207786511701003\