Formula to fill any magic square.

sub oddmagic{
    my $order=shift;
    if( $order%2 != 1 ){ return warn "$order not odd\n" }
    my @ordinary=@{(shift)};
    my @break=@{(shift)};
    my @x=(0,($order-1)/2);
    my @square;
    for( 1..$order*$order ){
        if( $square[$x[0]%$order][$x[1]%$order] ){
            $x[0] += $break[0]-$ordinary[0];
            $x[1] += $break[1]-$ordinary[1];
        }
        $square[$x[0]%$order][$x[1]%$order] = $_;
        $x[0] += $ordinary[0]; $x[1] += $ordinary[1];
    }
    return @square;  
}


my @s = oddmagic(7,[-1,1],[1,0]);
for( @s ){
    printf"%3d"x@$_,@$_;
    print"\n";
}

Hi Mateen,

Below isthe code which embeds the logic of the game. With little modification it will immediately run in C# or C++.  It's modularized and well structured. Have a look at it.

////////////////////////////////Code for game/////////////////
int dimension;
int StartP;
Point CurrentP=StartP;
int i=1;

do
{
      
      PrintI(CurrentP,i);
      CurrentP=GetNext(CurrentP);
      i++;

}while(i<=dimension*dimension)

point GetNext(point CurrentP)
{
      
      CurrentP.x=IncrementX(CurrentP.x);
      CurrentP.Y=IncrementY(CurrentP.Y);
      return CurrentP;
}

int IncrementX(int i)
{
      i++;
      if(i>dimension)
      {
            i=0;
      }
      return i;
}

int IncrementY(int i)
{
      i--;
      if(i<0)
      {
            i=dimension;
      }
      return i;
}

Naishal.

#!/usr/bin/perl
#another constuction of odd and even squares
use strict;
use warnings;
sub oddLoubere{
    my $order=shift;
    if( $order%2 != 1 ){ return warn "$order not odd\n" }
    my @ordinary=@{(shift)};
    my @break=@{(shift)};
    my @x=(0,($order-1)/2);
    my @magic;
    for( 1..$order*$order ){
        if( $magic[$x[0]%$order][$x[1]%$order] ){
            $x[0] += $break[0]-$ordinary[0];
            $x[1] += $break[1]-$ordinary[1];
        }
        $magic[$x[0]%$order][$x[1]%$order] = $_;
        $x[0] += $ordinary[0]; $x[1] += $ordinary[1];
    }
    return @magic;  
}

sub oddConway{
    my $order=shift;
    if( $order%2 != 1 ){ return warn "$order not odd\n" }
    my @x=(0,($order-1)/2);
    my @magic;
    my @even;
    for my $n ( 1..$order*$order ){
        if( $n%2 ){
            $magic[$x[0]][$x[1]] = $n;
        }else{
            push @even,$n;
        }
        $_ += 0.5 for @x;
        if( $x[1]+$x[0] > ($order-1)*3/2 ){
            $_ += ($n%2)/2 for @x;
            while( @even ){
                $_ %= $order for @x;  
                $magic[$x[0]][$x[1]] = shift @even;
                $_ += 1 for @x;
            }
            $_ %= $order for @x;
            $_ += ($n%2)/2 for @x;
            $x[1] -= 1;
       }
    }
    return @magic;
}

sub even4{
    my $n=shift;
    return warn "$n not a multiple of 4\n" if $n%4;
    my @magic;
    for( 1..$n*$n ){
        my($r,$c) = (int(($_-1)/$n),($_-1)%$n);
        $magic[$r][$c] = ($r+$c)%8==3||($r-$c)%8==0?$n*$n+1-$_:$_;
    }
    return @magic;
}

sub even{
    my $n=shift;
    return warn "$n not even\n" if $n%2;
    return warn "no magic square of order 2\n" if $n<4;
    return even4($n) if $n%4 == 0;
    my @magic=(
    (map{[($n*$n*3/4)x($n/4),(0)x($n/4+1),($n*$n/2)x($n/4+2),($n*$n/4)x($n/4-1)]}1..$n/2),
    (map{[(0)x($n/4),($n*$n*3/4)x($n/4+1),($n*$n/4)x($n/4+2),($n*$n/2)x($n/4-1)]}1..$n/2),
    );
    @{$magic[$n/4]}[0,$n/4] = @{$magic[$n/4]}[$n/4,0];
    @{$magic[3*$n/4]}[0,$n/4] = @{$magic[3*$n/4]}[$n/4,0];
    my @s = oddLoubere($n/2,[2,1],[1,0]);
    for my $r (0..$n-1){ for my $c (0..$n-1){
        $magic[$r][$c] += $s[$r%($n/2)][$c%($n/2)];
    }}
    return @magic;
}

sub printsquare{
  my $w = length(@_**2)+1;
  for( @_ ){
    printf"%${w}d"x@$_,@$_;
    print"\n";
  }
  print "\n";
}

for( 3,5,7 ){
    printsquare(oddLoubere($_,[-1,1],[1,0]));
    printsquare(oddConway( $_ ));
}
for( 4,8,12 ){
    printsquare(even4($_));
}
for( 6,10,14 ){
    printsquare(even($_));
}