Your program can issue push commands to any entity within a radius of 1 from you, resulting in you and your target having your speeds changed to point away from eachother and at a given speed. The push speed is directly adjustable, but the direction isn't. Push speed is under the same limitations as a move command, and thus can't be stronger than 1. If two people push the same target at once, the target has its speed set to 0. All pushes are calculated after the moves.

Your program can issue push commands to any entity within a radius of 1 from you, resulting in you and your target having your speeds changed to point away from eachother and at a given speed. The push speed is directly adjustable, but the direction isn't. Push speed is under the same limitations as a move command, and thus can't be stronger than 1. If two people push the same target at once, the target is pushed in the resultant direction. Pushing will take into account the target's move command, if there was one.

Your program can issue push commands to any entity within a radius of 1 from you, resulting in you and your target having your speeds changed to point away from eachother and at a given speed. The push speed is directly adjustable, but the direction isn't. Push speed is under the same limitations as a move command, and thus can't be stronger than 1.

Your program can issue push commands to any entity within a radius of 1 from you, resulting in you and your target having your speeds changed to point away from eachother and at a given speed. The push speed is directly adjustable, but the direction isn't. Push speed is under the same limitations as a move command, and thus can't be stronger than 1. If two people push the same target at once, the target has its speed set to 0. All pushes are calculated after the moves.

#Global Warmth king-of-the-hill

This KOTH takes place on a nice iceberg of circular surface which gradually shrinks. The goal is to be the last entry to fall off the iceberg. Each turn, participants can either move in a certain direction (or none), or if they are near enough, can push other participants. Each participant will start at a equal distance from the center, and will have access to the following data:

• Current iceberg radius
• Positions and speeds of the other entries
• Its own position and speed

##Details

• Since you're competing on ice, if you don't use your turn to move, you will move on the same direction you were last heading.
• If a competitor falls off the iceberg, it's not mentioned anymore in the entity list.
• All positions are relative to the center of the iceberg.
• A entry is considered to fall off the iceberg if its distance from the center is greater than the iceberg's radius.
• If the distance to any other participant is less than or equal to 1, you may push the participant, forcibly changing its direction of movement. The pushes will be applied after all the move commands, so you will not be penalized for being executed before your target. (The direction of the push is from your position to the target's, with a given force, and will affect you equally in opposite directions) It's important to note that the direction will be set, not simply influenced by the push.
• Entries do not have a physical radius, so they cannot bump on eachother.
• The rate at which the iceberg shrinks is unknown to you. It will depend on the participant's ability of staying clustered, and possibly other factors too. Don't try to calculate it.
• Your speed will be capped so it may never exceed 1 in any direction. (Think of a unit circle)
• The code will run on a Ubuntu 12.04 LTS virtual machine, with a measly 1GB of RAM.

##Execution

The program will be executed once for each step of the game, thus it may not share any variables with the previous instance.

Your entry must be easily executable in the above mentioned configuration, any extra packages required must be listed in the answer. Your program must receive input from STDIN and return data to STDOUT in CSV format. The control program will output a list of numbers according to the following format (f_ = float, i_ = integer):

f_icebergRadius, i_ent_count                           #The iceberg's current radius and the number of participants
i_ent_id, f_ent_x, f_ent_y, f_ent_speedx, f_ent_speedy #REPEATS FOR EACH ENTITY (total i_ent_count lines)

Your entry is always the first of the list. Practical example of the input passed:

1.0, 2              #Iceberg of radius 1, 2 participants
0.0, 1.0, 0.0, 0.0  #Your data
0.0, -1.0, 0.0, 0.0 #Opponent data

Your output should either be (f_ = float, i_ = integer, s_ = string):

move, f_speedx, f_speedy

or

push, i_ent_id, f_force

These names should be pretty self-explanatory, you can either modify your speed to a value, or push a entity when near.

This format is flexible, you can use any character to separate each column, as long as it doesn't match the regex [.0-9a-z] (Yes, uppercase letters are valid separators). It might even be a different separator for each field, as long as you avoid that regex.
The input passed to your STDIN will always be separated by a comma (,), with no surrounding whitespace

##Scoring

What do you think? The controller code hasn't been written yet, asking for suggestions. Is the input format ok? I find it a bit confusing, but at least it is easy to parse in languages with not so many text handling functions.

I'll create a controller/runner and upload it to a GitHub repository when it's finished.

Global Warming king-of-the-hill

This KOTH takes place on a melting iceberg. You must stay on it as long as possible, and preferrably, be the last man standing.

The field is a perfectly circular iceberg which shrinks at a unknown rate, in the center of a 2D plane. Gameplay is executed in turns on which your program will be called with the current status of the iceberg and other participants. Each turn you may either change your movement direction or push someone near you (or neither).

Movement and positioning

Positioning is in a 2D plane of floating point coordinates, and movement is a speed of x and y components. When issuing a move command, your entry will keep moving in that direction until you explicitly tell it to stop or change direction with another move command (or a push, more on this soon). The maximum move speed is 1.0 in magnitude, and if you ask to move further than that, your speed will be adjusted to conform this limit.

Pushing

Your program can issue push commands to any entity within a radius of 1 from you, resulting in you and your target having your speeds changed to point away from eachother and at a given speed. The push speed is directly adjustable, but the direction isn't. Push speed is under the same limitations as a move command, and thus can't be stronger than 1.

Input

Each round, your program will be invoked from the command line, with a CSV document being passed to its STDIN. The first line of this document provides the current iceberg radius (floating point number) and the amount of remaining competitors (integer)

After this "header", there will be one line for each remaining competitor in the following format (which is on its turn on the format type(variable)):

string(entity id),float(x),float(y),float(velocity x),float(velocity y)

Your entry will always be the first item on the list.

Example input:

12.4,2
1af3b,10.22,5.42,0.0,0.7
d5e86,-2.18,6.66,0.6,-0.2
\

(the \ is a trailing newline, represented like that for clarity)

Output

Your program will process the given input and output a ASV (Anything Separated Values) document. A ASV is like a CSV, except everything that doesn't match the regex [.0-9a-z] is considered a separator (even uppercase letters). If your program emits more than 1 line, only the last one is considered.

For movement:

move,float(velocity x),float(velocity y)

For pushing:

push,string(entity id),float(strength)

To do nothing, simply don't output anyting

Where move and push are string literals.

Example:

move,0.0,0.7

or

push,d5e86

The following lines are valid outputs for your program:

moveA0.0A0.7
moveX0.0Y0.7
move!0.0:0.7

Detailed Rules and remarks

A list of important points to consider:

• You can skip your turn by returning no output, but this will make you keep moving in the direction you ere headed to.
• If a competitor loses, it will not show up on the participants list (see below)
• A player is considered to fall from the iceberg if their distance from the center is greater than the iceberg's radius.
• Entries do not have a physical radius, so they cannot bump on eachother (except for the push command)
• You can't know the shrinking rate of the iceberg.

Scoring

Examples in pseudocode

Antisocial - pushes everyone away from him, doesn't care about where he is.

#!/bin/env pseudocode
data = read_csv(stdin)
foreach line in data.range(1,data[0,1]):
    if distance(me, line[1], line[2]) <= 1:
        write_csv_line(stdout, ["push", line[0], 1.0])