ReviewSpindle
A gateway between articles and affiliate links.

Key features:
* It dynamically updates the suggestion list with bold character recognition.
* The suggestion list can be navigated using arrow keys and mouse.
* When using arrow keys, movement takes over from mouse location.

The application JS code is easily available through viewing the source. The PHP used is just a 2-dimensional array with titles and urls. And a foreach-loop to check for form submits, along with populating the JS version of the array.

Pseudo formula:

// Acronyms used to save space.
New style.left = PCW+((E.X-PCX)-(MDX-PCX))
New style.top = PCH+((E.Y-PCY)-(MDY-PCY))

// PCW/PCH = Previous Container Width/Height.
// E.X/E.Y = Event X/Y.
// PCX/PCY = Previous Container Left/Top.
// MDX/MDY = Mouse Down X/Y (where you clicked).

With this formula you will resize the layer relative to where you clicked on it. An extended version of the movement formula. In effect it will take the existing width/height and add the amount of pixel movement as a positive or negative number.

My example, just view the source to see my code.

Pseudo formula:

New style.left = MovingMouseX-(PushedMouseX-PreviousStyleLeft)
New style.top = MovingMouseY-(PushedMouseY-PreviousStyleTop)

With this formula you will move the layer relative to where you clicked on it.

My example, just view the source to see my code.

Web Galaxy currently has 10 solar systems with 30 asteroids in every system by default. Web browsers may lag when running more than 30-50 asteroids in the solar system view through the asteroid movement engine, I want to avoid that. If I were to add support for more player activity I would probably want to build more solar systems instead.

Technical
Mainly Javascript functionality. DHTML for effects, AJAX for real-time database updates, PHP and MySQL for back-end. The whole project consists of 15 images and 6 web files, 903KiB in total size. Game is wrapped in a very simple and basic user login system, just enough to keep players separated. The game should work without cookies as well.

I started making the game Feb. 9, 2010. Game was considered completed enough for testing on the Feb. 15, 2010. And that is where it is right now until I decide to put more work into it. The next step would be to create a messaging and/or chat system between players.

Gameplay illustrations:

You can try out the game yourself here.

IE would not recognize the session at all. IE did not block the cookies either, and I tested the SID constant thoroughly, it was not getting populated either.

The problem
In the same browser application I had open – just in another tab – I was logged into a HTTP AUTH session on another site, though under the same domain.

Of some reason IE seems to mix up the processes when opening up different tabs or windows through the same opened application. This way it doesn’t seem to properly keep track of which sessions belong to which processes.

The solution
Exit the IE application and start a new one. If I open up my session based website in the first tab, it works. It also works fine after opening the HTTP AUTH website in a second tab. But I don’t know how stable this is.

Just another IE annoyance…

The most logical place to look, is in:
wp-includes/js/tinymce/plugins/spellchecker/editor_plugin.js

Changes made there however doesn’t reflect in the administration editor. You also need to make changes in:
/wp-admin/includes/post.php

By default, spell checker uses the google gmail engine. This does not support the norwegian language in my case. So I changed over to the pspell engine. This is what I did to make that work for me:

(on the server, a debian box)
// Check first if you already have your language available.
#aspell dicts
-bash: aspell: command not found

// I did not, so I had to install it and make PHP support it as well.
#apt-get install aspell-no php5-pspell

// Reload the apache web server to reflect PHP update.
#/etc/init.d/apache2 reload

// Verify installation
#aspell dicts
nb
nn
no

... Looks good.

Next you change the engine in this file:
/wp-includes/js/tinymce/plugins/spellchecker/config.php

from: $config['general.engine'] = ‘GoogleSpell’;
to: $config['general.engine'] = ‘PSpell’;

That’s it.

(Debian based example).

First, stop the daemon:

#/etc/init.d/mysqld stop

Second, start mysql without privileges:

#mysqld --skip-grant-tables &

Third, connect to the daemon and make changes:

#mysql
#UPDATE mysql.user SET Password=PASSWORD('NewPassword') WHERE User='root';
#FLUSH PRIVILEGES;
#quit

Now stop the daemon and start it normally:

#/etc/init.d/mysql stop
#/etc/init.d/mysql start

It might be sufficient with a simple restart, but I like it the explicit way to be sure.

For more information on this subject, visit the official MySQL reference:
http://dev.mysql.com/doc/refman/5.0/en/resetting-permissions.html#resetting-permissions-unix

IdleGuard
A small program (72kb) that – so far – every 5 minutes “pushes” the space key for you which should reset the ingame logout timer. It is extremely CPU cycle friendly (no loop stress/block/hang), and will require practically zero resources to keep running.

Is it safe to use?
Yes. The program does not hack or manipulate any memory space of any software. It simply sends a virtual key code into the windows keyboard stream.

Can I only use this with games?
It should work on any applications and systems that would otherwise kick you for being idle for too long.

Vista note
The Windows Vista User Interface Privilege Isolation (UIPI) might prevent this program to run properly or even crash as I have not bothered to error-handle such an event. You should be able to solve this by either turning off UAC or simply run it as administrator.

You can download the program here (win32 executable, no dependencies).

How do I use it?
Just start it, it will open a small window that you can close when you don’t need it running anymore. As long as you run it, it will “push” the space key for you every 5 minutes. Remember to have your game or program in focus while it’s running.

-

SELECT COUNT(1) AS RowCount FROM table

Unless you know where to look:

SELECT COUNT(1) AS ColumnCount
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_NAME='tablename';

This should work from SQL server 2000 and MySQL 5 and upwards.

Differences between MSSQL and MySQL.
In MySQL you can add the TABLE_SCHEMA to the WHERE clause in order to define what database contains the table you are looking for, to count columns. In MSSQL it seems to only contain “dbo” which doesn’t help much.

There are most likely other places to look for that information, I just haven’t had any need for it yet. And if your user only has access to 1 database, you shouldn’t need it anyway.

How does it work?
A key is generated on the first page that also encrypts the string (or code if you want). The same key is used on the second page to decrypt it. Consider the functions below for more information. On the bottom you’ll find a test script to see the effect of the functions.

Generating a random string value in PHP (e.g a Captcha code):

function CreateRandomStringPHP() {
  $code = substr(str_shuffle('abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'),0,5);
  return $code;
}

If you are using another language, consider using a function like this:

function CreateRandomString() {
  $Characters = array(
  'a','b','c','d','e','f','g','h','i','j','k','m','n','p','q','r','s','t','u','v','w','x','y','z',
  'A','B','C','D','E','F','G','H','J','K','L','M','N','P','Q','R','S','T','U','V','W','X','Y','Z',
  '2','3','4','5','6','7','8','9');

  $Code = '';
  for( $loop_b = 1; $loop_b <= 5; $loop_b++ ) {
    $Code .= $Characters[mt_rand(0,count($Characters)-1)];
  }

  return $Code;
}

Both of the above functions will generate a 5-length value. This will provide one value out of 550731776 possible combinations which should be enough for most needs.

The lock (or encrypt) function:

/*
  str LockCode(str $code, str $key)

  A codelock function (or encryption if you want).
  I wrote because I wanted a nice solution for keeping codes
  such as Captcha codes safe and secure for transferring between
  sites.

  It takes a $code of random length and locking $key as parameters.
  You'll need to use the same key to unlock it.

  The value this function returns, is simply a set of location
  coordinates in the key where the characters of the $code is found.
  This is again merged together with the lengths of every coordinate,
  since every coordinate can be 1 or 2 in length as long as the $key
  is under 100 characters in length (0-99).

  In the end, it should provide a safely locked $code, based on that
  you keep the $key hidden. Do NOT show it in your HTML. The key
  used in this example, with 56 alphanumeric characters where I have
  stripped out the following chars: 1, I, l, o, O and 0 (they are
  unpractical) has 7,9164324866862966607842406018063e+97
  combinations. This should be enough to keep the $code safe...
*/
function LockCode($code,$key) {
  $key_chars = str_split($key);
  $code_chars = str_split($code);
  $LockedKeyCoords = '';
  $LockedCoordLengths = '';

  foreach($code_chars as $c_char) {
    for($loop_a=0; $loop_a<count($key_chars); $loop_a++) {
      if($c_char==$key_chars[$loop_a]) {
        $LockedKeyCoords .= (string)$loop_a;
        $LockedCoordLengths .= (string)strlen($loop_a);
      }
    }
  }

  return $LockedKeyCoords . $LockedCoordLengths;
}

The unlock (or decrypt) function:

/*
  str UnlockCode(str $coords, str $key, int $keylength)

  The unlock function introduces a new parameter: $Keylength.
  This defines how many characters your $code was before you locked it.
*/
function UnlockCode($coords,$key,$keylength) {
  $key_chars = str_split($key);
  $keylengths = str_split(substr($coords,-$keylength));
  $UnlockedCode = '';

  foreach($keylengths as $length) {
    $UnlockedCode .= $key_chars[(int)substr($coords,0,(int)$length)];
    $coords = substr($coords,(int)$length);
  }

  return $UnlockedCode;
}

PHP code to test with:

/*
  The $Key MUST contain the characters you use to create the
  code with. Using the same string as you did to make the $Code
  with is a good choice. Generate a key on a standalone page,
  then use the same key on the page that locks the string, and
  on the page that unlocks the string.

  If you want a new random key every time you use the locking
  functions, you'll have to use a database system to store and
  retrieve them. And use sessions for identifying the keys. This
  would make a separate article, so I won't explain how to do it
  here.
*/
$Key = str_shuffle('abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789');

// Test it out.
$Code = CreateRandomStringPHP();
$LockedCode = LockCode($Code,$Key);
echo 'Key used: '. $Key .'<br><br>';
echo 'New code: '. $Code .'<br>';
echo 'Locked code: '. $LockedCode .'<br>';
echo 'Unlocked code: '. UnlockCode($LockedCode,$Key,5) .'<br><br>';
echo 'Reload this page to generate new results.';

The above testing code would produce something like this:

Key used: F7AYMQTscfHEPvSBXw5C3eWhj6kUxbn2ayrtGzNiqDV4m9ugJLKZpR8d

New code: c42yV
Locked code: 84331334212222
Unlocked code: c42yV

You can try it out yourself here (opens in a new window).