Thursday, September 18, 2008

Integer-Alterations On a Grid (fun)

This game is unoriginal, in that, not only do I steal ideas from my own games I
have posted here in the past, but from other people's games also.
But, anyway, this game seems as if it would be SO fun to play that I HAD
to post it!
2 players.
Played on n-by-n grid (as many of my games are).
One player makes up n integer-alteration rules (see below for examples)
for the n rows, one rule per row.
And the other player makes up n rules for the n columns, one rule per
"Rule": a (meta)mathematical rule which changes any input integer into an
output integer.
At the game's beginning, after the rules are created, each player gets 3
random integers, from 1 to n.
A player's first 2 random integer give the coordinate of the square the
player starts in, the last integer gives the player's starting integer.
And what player moves first is then chosen randomly.
(But no more randomnes is in the game once play begins.)
At each turn, a player can choose to apply the row-rule OR the
column-rule to his/her integer. (Each player has their own integer which
is altered.)
A new integer m is generated for this player, which the player writes in
the square he/she is currently at.
The player can then choose to move either up, down, left, or right,
without regard to what integers (s)he must "jump over", that number (m)
of grid-squares.
And the grid is considered topologically a torus, ie. going off the right
edge, for example, brings you back to the left side
(and the same (mod n)-topology for right-to-left or vertical moves).
(So, for example, a move from column 3 to the right 7 squares, on an n =
6 grid, gets the player to column 2, which is one square to the *left* of
where (s)he started.)
But a player must only move to a square *without* an integer (written
there by either player) already in it.
And the game's winner is the last player able to move.
*Be Creative in coming up with rules!
*The output integers' signs are, in practice, insignificant, since you
can move right OR left, up OR down. But an output of 0 is to be avoided!
*Start out with easy rules as you first learn how to play this game, or
if you simply are poor at math. It would be less fun to play this game if
you must spend an hour calculating each of your integers!
Example of rules:
(For n=6)
A) m = m+1;
B) m = 2*m;
C) m = m + sum of distinct primes dividing all already-written
neighboring integers;
D) m = d(|m|)*phi(|m|) -m; (d(m) is number-of-divisors function, phi(m)
is Euler-phi function.)
E) m = (numerator)-(denominator) of reduced rational,
sum{k=1 to |m|} 1/k;
F) m = m + number of already-written integers in row F.
1) m = ceiling(sqrt(|m|))
2) m = ceiling(secant(m)), m in radians;
3) m = number of primes <= |m|;
4) m = 2^|m| - m;
5) m = number of divisors in product of all aready-written integers in
column 1;
6) m = ceiling((|m|th Fibonacci number)/(|m|_th prime)).
(Yes, computers might be needed for some kinds of rules, and are allowed.)

Included among the rules can be those which give an output as a result
of an
if/then question, such as:
m = m+3 if m is a prime; m = m^2 otherwise.
But I would discourage such rules which pretty much give the same
output no matter what is inputted, such as 'm = 4' or anything less
obviously of one-output. (Even such rules as m = floor(|m|^(1/|m|)),
which only outputs 1 unless m is 0, should probably be discouraged im
most cases.)
Goal of game = FUN!

Possibly you could have rules which vary m based on the other player's
rules in the columns, if your rules are in the rows, and vice versa.
Such as, for row-rule:
m = value attained by square's column-rule + 1
(or something more creative)
You CAN have rules which give you a range of possible values, and
which value is used is determined by the player.
But, remember, both players are subject to the same rules. So an
advantage to you is also an advantage for your opponent.

(As far as "m = floor(|m|^(1/|m|))", since no player can land on a
square with an m of 0, this rule is equivalent to m = 1. )

Leroy Quet

No comments: