This commit was generated by cvs2svn to compensate for changes in r14136,

which included commits to RCS files with non-trunk default branches.

xtrn/dicewarz/dice.doc

+           ************************************
+           *****  BBS DICE WARZ (2008)   ******
+           ** for use with Synchronet v3.14+ **
+           ***  by Matt Johnson  **************
+           ************************************
+
+This game was modelled after "Dice Wars" which is a web-interface strategy 
+game involving dice, similar to Risk. 
+	
+The object of the game is to conquer the map by rolling dice against 
+neighboring tiles. The game can be played by 4 to 7 players, and can 
+be either 1 human player vs. all computer players, all human vs. human 
+players, or a mix of humans and computers. 
+	
+While the settings can be adjusted, the default maximum dice per tile is 8, 
+and the default maximum reserve dice is 30.
+
+                  ####GAMEPLAY#### 
+
+When it is your turn, you press "T" to start your turn, and then "A" to 
+begin attacking. Use the arrow keys to move around the map, and the [ENTER] 
+key to select a territory. It would make sense to not attack a tile when 
+the odds are against you. You are not required to make an attack at all, 
+and you can simply press "E" to end your turn immediately if you only wish 
+to place reinforcements.
+
+Example: 
+  Attacking tile's dice: 2 (6 + 6)
+  Defending tile's dice: 8 (6 + 6 + 6 + 6 + 6 + 6 + 6 + 6)
+	
+In this scenario, the highest possible roll you can get as the attacker is 
+a 12, whereas the highest roll the defender can get is 48. You will most 
+likely lose, and would be better off attacking somewhere else.
+
+When rolling dice against another player, all ties go to the defender. 
+
+If you win the dice roll, the defending tile becomes yours, and all but 
+one of your dice are automatically moved to the tile. The remaining die 
+is left behind on the tile from which you attacked.
+
+When you are finished attacking press "E" to end your turn, and you will 
+be given reinforcement dice equal to the largest number of CONNECTED 
+tiles you possess. This creates a secondary objective in the game which 
+is to connect as many of your tiles on board as possible, so as to get 
+more reinforcements. These are placed randomly on your tiles. 
+
+If all of your tiles have reached the maximum number of dice per tile, 
+any remaining reinforcements will be added to a reserve, up to a maximum 
+of 30 dice. These reserve dice will be placed at the end of your turn 
+along with your regular reinforcements as needed, unless all of your 
+territories are already full.
+
+The game is over (for you) when you have either conquered all of the 
+tiles on the board, or had all of your tiles taken over by other players.
+
+                  ####SCORING#### 
+
+1st place: +2 points
+2nd place: +1 point
+3rd place: no change
+4th place: -1 point
+5th place: -2 points
+6th place: -2 points
+7th place: -2 points
+
+                  ####THANKS TO#### 
+
+Landis for his coding advice.
+Chrispi for his relentless bug detection.
+
+Now everyone go get killed!

xtrn/dicewarz/diceroll.js

+//#########################DICE ROLLING FUNCTIONS############################
+function	RollDice(a,b)
+{								//MAIN DICE ROLLING FUNCTION
+	var totals=[0,0];
+	var x=menuColumn;		var y=16;
+	ClearArea(y);
+
+	bc=console.ansi(BG_RED);
+	fc=console.ansi(LIGHTGRAY);
+
+	FancyRoll(a,x,y,fc,bc);
+	xx=x;
+	yy=y;
+	for(aa=0;aa<a;aa++)
+	{
+		rand=(random(6)+1);
+		dice[rand].display(xx,yy,fc,bc);
+		xx+=4;
+		totals[0]+=rand;
+	}
+	mswait(50);
+
+	y+=4;
+	bc=console.ansi(BG_LIGHTGRAY);
+	fc=console.ansi(RED);
+
+	FancyRoll(b,x,y,fc,bc);
+	xx=x;
+	yy=y;
+	for(bb=0;bb<b;bb++)
+	{
+		rand=(random(6)+1);
+		totals[1]+=rand;
+		dice[rand].display(xx,yy,fc,bc);
+		xx+=4;
+	}
+	console.gotoxy((menuColumn+1),24);
+	console.cleartoeol();
+	printf("\1n\1r\1hAttacker: " + totals[0] + "\1n   Defender: " + totals[1]);
+	return totals;
+}
+function	FancyRoll(qty,x,y,fc,bc)
+{								//"ROLLING DICE" DISPLAY
+	for(roll=0;roll<8;roll++)
+	{
+		xx=x;
+		yy=y;
+		for(dr=0;dr<qty;dr++)
+		{
+			dice[random(6)+1].display(xx,yy,fc,bc);
+			xx+=4;
+		}
+		mswait(40);
+	}
+}
+function	Die(number)
+{								//DICE CLASS
+	this.number=number;
+	this.line1="   ";
+	this.line2="   ";
+	this.line3="   ";
+	this.dot="\xFE";
+
+	if(this.number==2 || this.number==3)
+	{
+		this.line1=this.dot+"  ";
+		this.line3="  "+this.dot;
+	}
+	if(this.number==4 || this.number==5 || this.number==6) 	
+	{
+		this.line1=this.dot+" "+this.dot;
+		this.line3=this.dot+" "+this.dot;
+	}
+	if(this.number==1 || this.number==3 || this.number==5)
+		this.line2=" "+this.dot+" ";
+	if(this.number==6)	
+		this.line2=this.dot+" "+this.dot;
+	this.display=function(x,y,b,f)
+	{
+		console.gotoxy(x,y); y++;
+		printf(f + b + this.line1);
+		console.gotoxy(x,y); y++;
+		printf(f + b + this.line2);
+		console.gotoxy(x,y);
+		printf(f + b + this.line3);
+		printf(blackBG);
+	}
+}
+function	LoadDice()
+{								//INITIALIZE SIX SIDED DICE OBJECTS
+	dice_=[];
+	for(d=1;d<=6;d++)
+	{
+		dice_[d]=new Die(d);
+	}
+	return dice_;
+}

xtrn/dicewarz/dicewarz.bin

+                                                                                G G G G GG    G G G  G GG G G G  G G G G GG  p pp       p pp    p pp p pp    p pp p pp    p pp p pp GG G  G G G     GG G   G G G  G G G   GG G  GG G   p p p        p p p     p p p  p p p     p p p  p p p     p p p  p p p G GG G GG     G GG  G GG  G GG   G GG G GG  p pp       p pp    p pp p pp    p pp p pp    p pp p pp                                                                                G GG   G GG  G GG  G GG      G GG      p pp       p pp  p pp     p pp  p pp   p pp     p pp  G G G    GG G   G G G   GG G       G G G       p p p        p p p   p p p      p p p   p p p    p p p      p p p G GG   G GG  G GG  G GG      G GG G GG  p pp       p pp  p pp p pp p pp  p pp   p pp     p pp                               GG G                      p p p                        G G G   G GG  G GG  G G G      G G G G GG  p pp  p pp  p pp  p pp p pp p pp  p pp p pp     p pp    G G G    G G G  G GG   GG G       G G G       p p p   p p p   p p p   p p p      p p p   p p p  p p p      p p p    G GG   G GG  G GG   G GG       G GG      p pp  p pp  p pp  p pp     p pp  p pp p pp     p pp                                                                                    G G G G G G     G G G  G G G G G G   G G G G GG    p pp   p pp    p pp     p pp  p pp   p pp  p pp p pp GG G  GG G     GG G   G G G  G G G   GG G  GG G     p p p    p p p     p p p      p p p   p p p    p p p   p p p  p p p G G G  G GG     G G G   G GG  G GG   G G G G GG    p pp   p pp    p pp     p pp  p pp   p pp  p pp p pp                                                                                                 For Synchronet v	3.	14+	 	- [	HTTP:	/	/	SYNCHRO.	NET]	                                                                                                          B	y	 M	a	t	t	 	J	o	h	n	s	o	n	 	[	2008]	 	-	 T	h	e	 	B	R	o	K	E	N	 	B	u	B	B	L	E	 	B	B	S	 	[	HTTP:	/	/	MDJ.	ATH.	CX]	       
\ No newline at end of file

xtrn/dicewarz/display.js

+//##########################DISPLAY FUNCTIONS#################################
+function 	ClearLine(row,toColumn)
+{
+	console.gotoxy(1,row);
+	for(col=0;col<toColumn;col++)
+	{
+		console.putmsg(" ");
+	}
+}
+function	ClearArea(fromRow,fromColumn,qty)
+{
+	xx=fromColumn;
+	yy=fromRow;
+	for(ccc=0;ccc<qty;ccc++)
+	{
+		console.gotoxy(xx,yy); yy++;
+		console.cleartoeol();
+	}
+}
+function	Wrap(msg,lst)
+{
+	var coords=console.getxy();
+	console.putmsg(msg);
+	console.gotoxy(30,coords.y); coords.y++;
+	console.putmsg("\1w\1h: ");
+	if(!lst.length) 
+	{
+		console.crlf();
+		return;
+	}
+	var bb=0;
+	var delimiter="\1n\1g,";
+	for(aa=0;aa<lst.length;aa++)
+	{
+		if(bb>=16)
+		{
+			var check=console.getxy();
+			if(check.x>77) {
+				console.gotoxy(32,coords.y); coords.y++;
+				bb=0;
+			}
+		}
+		if(aa==lst.length-1) delimiter="";
+		console.putmsg("\1h\1g" + lst[aa] + delimiter);
+		bb++;
+	}
+	console.crlf();
+}
+function 	PrintPadded(string,length,padding,justification)
+{
+	var padlength=length-console.strlen(string);
+	var newstring=string;
+	var padded="\1k";
+	for(p=0;p<padlength;p++) padded+=padding;
+	if(justification=="left") newstring+=(padded);
+	if(justification=="right") newstring=(padded + newstring);
+	return(newstring);
+}
+function 	DrawLine(color,length,character)
+{
+	var printchar= "\xC4";
+	if(character) printchar=character;
+	for(i=0;i<length;i++) console.putmsg(color + printchar);
+}
+function 	DrawVerticalLine(color/*, side*/)
+{
+	var ly=1;
+	var lx=menuColumn-1;
+	
+/*	OPTIONAL CODE FOR BOXING IN GAME AREA
+	
+	var topside="\xB4";
+	var bottomside="\xD9";
+	
+	//PARAMETER FOR DRAWING LEFT-HAND OR RIGHT-HAND SIDE OF BOXED IN AREA
+	if(side) 
+	{
+		lx=1;
+		topside="\xC3";
+		bottomside="\xC0";
+	}
+ 	console.gotoxy(lx,ly); ly++
+	console.putmsg(color + "\xB3");
+	console.gotoxy(lx,ly); ly++
+	console.putmsg(color + topside); 
+*/
+	for(;ly<=24;ly++)
+	{
+		console.gotoxy(lx,ly);
+		console.putmsg(color + "\xBA");
+	}
+//	console.gotoxy(lx,ly);
+//	console.putmsg(color + bottomside);
+}
+function 	WipeCursor(lr)			//SEND CURSOR TO BOTTOM RIGHT CORNER OF SCREEN
+{	
+	if(lr=="left") { side=1; row=24; }
+	else { side=79; row=1; }
+	console.gotoxy(side,row);
+}
+function 	GetColor(color, intensity)
+{									//TAKE A STRING AND RETURN THE CORRESPONDING ANSI COLOR CODE
+	if(intensity=="high") inten="\1h";
+	else inten="\1n";
+	
+	if(color=="black") return (inten+"\1k");
+	if(color=="grey") return ("\1k\1h");
+	if(color=="cyan") return (inten+"\1c");
+	if(color=="yellow") return (inten+"\1y");
+	if(color=="green") return (inten+"\1g");
+	if(color=="white") return (inten+"\1w");
+	if(color=="red") return (inten+"\1r");
+	if(color=="blue") return (inten+"\1b");
+	if(color=="magenta") return (inten+"\1m");
+    else return false;
+}
+function 	QueueMessage(message,x,y)
+{
+	messages.push({'msg':message,'x':x,'y':y});
+}
+function 	DisplayMessages()
+{
+	for(mess in messages) {
+		var x=messages[mess].x;
+		var y=messages[mess].y;
+		var msg=messages[mess].msg;
+		
+		console.gotoxy(x,y+1);
+		console.putmsg(msg);
+		console.cleartoeol();
+		mswait(500);
+	}
+	messages=[];
+}
+function 	PutMessage(message,x,y)
+{
+	console.gotoxy(x,y+1);
+	console.putmsg(message);
+	mswait(750);
+	console.gotoxy(x,y+1);
+	console.cleartoeol();
+}
+function	ShowWinner(g)
+{
+	ClearArea(16,menuColumn,9);
+	console.gotoxy(51,17);
+	console.putmsg("\1n\1r\1hThis game was won by: ");
+	console.gotoxy(53,18);
+	if(g.winner>=0)
+	{
+		console.putmsg("\1n\1r\1h" + system.username(g.winner));
+	}
+	else
+	{
+		console.putmsg("\1n\1r\1hcomputer player");
+	}
+	WipeCursor("left");
+}

xtrn/dicewarz/lock.js

+function	Locked(fileName,timeOut)
+{
+	var fname=(game_dir+fileName+".lck");
+	if(file_exists(fname))
+	{
+		if(!timeOut) return true;
+		var max_attempts=20;
+		for(attempt=0;attempt<max_attempts;attempt++)
+		{
+			if(file_exists(fname))
+			{
+				mswait(250);
+			}
+			else return false;
+		}
+	}
+	else return false;
+	return true;
+}
+function	Lock(fileName)
+{
+	var fname=(game_dir+fileName+".lck");
+	var lockfile=new File(fname);
+		lockfile.open('we', false); 
+	if(!lockfile.is_open) 
+		return false;
+	else 
+	{
+		lockfile.close();
+		activeGame=fileName;
+		js.on_exit("Unlock(activeGame)");
+		return fileName;
+	}
+}
+function	Unlock(fileName)
+{
+	if(fileName==-1 || !fileName) return;
+	var fname=(game_dir+fileName+".lck");
+	file_remove(fname);
+}
+function	UnlockAll()
+{
+	var lockList=directory(game_dir + "*.lck"); 		
+	if(lockList.length)
+	{
+		for(lf in lockList)
+		{	
+			file_remove(lockList[lf]);
+		}
+	}
+}

xtrn/dicewarz/maps.js

+function	NewGame(minp,maxp,n)
+{
+	this.status=-1;
+	this.minPlayers=minp;
+	this.maxPlayers=maxp;
+	this.gameNumber=n;
+	this.players=[];
+	this.users=[];
+	this.fixedPlayers=false;
+	this.singlePlayer=false;
+	this.lastModified=0;
+	this.fileName="";
+	
+	this.addPlayer=function(userNumber,vote)
+	{
+		GameLog("adding player: " + userNumber + " vote: " + vote);
+		if(userNumber) this.users[userNumber]=this.players.length;
+		this.players.push(new Player(userNumber,vote));
+	}
+	this.tallyVotes=function()
+	{
+		var trueVotes=0;
+		for(v in this.players)
+		{
+			if(this.players[v].user>0 && this.players[v].vote==1) 
+			{
+				trueVotes++;
+				GameLog("player " + v + " voted to start");
+			}
+		}
+		GameLog("votes to start: " + trueVotes);
+		GameLog("human players: " + this.countHumanPlayers());
+		GameLog("total players: " + this.countPlayers());
+		if(trueVotes==this.countHumanPlayers()) 
+		{
+			GameLog("true votes meets number of humans");
+			if(this.countPlayers()>=this.minPlayers) 
+			{	
+				GameLog("number of players meets minimum");
+				return true;
+			}
+		}
+		else return false;
+	}
+	this.countHumanPlayers=function()
+	{
+		var count=0;
+		for(pppp in this.players)
+		{
+			if(this.players[pppp].user>0) count++;
+		}
+		return count;
+	}
+	this.countPlayers=function()
+	{
+		var count=0;
+		for(pppp in this.players)
+		{
+			count++;
+		}
+		return count;
+	}
+	this.GetVote=function(playerNumber)
+	{
+		if(this.players[playerNumber].vote==0) return("wait");
+		else return("start");
+	}
+	this.removePlayer=function(playerNumber)
+	{
+		this.players.splice(playerNumber,1);
+		this.users.splice(user.number,1);
+	}
+}
+function 	Map(c,r,p,gn) 				
+{								
+									//OBJECT VARIABLES
+	this.grid=[]; 						//ROWS * COLUMNS IN LENGTH, TRACKS GRID OCCUPANCY
+	this.status=1;						//GAME STATUS INDICATOR
+	this.takingTurn=false;
+	this.singlePlayer=false;
+	this.eliminated=[];
+	this.lastEliminator=-1;
+	this.lastMapPosition=-1;
+	this.winner=-1;
+	this.lastModified=-1;
+	this.fileName="";
+	this.gameNumber=gn;
+	
+	this.rows=r;						//MAP ROWS 
+	this.columns=c;						//MAP COLUMNS
+	this.maxDice=maxDice;					//MAXIMUM DICE PER TERRITORY
+	this.maxPlayers=p;					//NUMBER OF PLAYERS IN GAME
+	this.nextTurn=0;
+
+	this.playerTerr=-1;					//InitIALIZE TERRITORIES PER PLAYER (SET DURING Init BY this.SetMap())
+	this.used=[];						//InitIALIZE USED MAP SECTORS (FOR GENERATION OF MAP)
+	this.turnOrder=[];					//InitIALIZE PLAYER TURN ORDER
+	this.players=[];					//InitIALIZE PLAYER DATA
+	this.users=[];						//ATTACH SYSTEM USER NUMBER TO GAME PLAYER NUMBER
+	
+	this.total=this.columns*this.rows;	//TOTAL NUMBER OF POSSIBLE GRID LOCATIONS
+	this.mapSize=-1;					//InitIALIZE MAP SIZE (NOT THE SAME AS TOTAL)
+	this.minTerr=6;						//MINIMUM FOR RANDOM TERRITORY GENERATION PER PLAYER
+	this.maxTerr=11;					//MAXIMUM FOR RANDOM TERRITORY GENERATION PER PLAYER
+	
+	//NOTIFY NEXT PLAYER OF TURN 
+	//TODO:  FIGURE OUT WHY THE GAME (OR THE BBS) IS SENDING DUPLICATE TELEGRAM NOTICES FOR THE SAME TURN
+	this.Notify=				function()	//NOTIFY NEXT PLAYER OF TURN
+	{
+		nextTurn=this.nextTurn;
+		nextTurnPlayer=this.players[this.turnOrder[nextTurn]].user;
+		
+		if(nextTurnPlayer>0 && !this.singlePlayer && nextTurnPlayer!=user.number) 
+		{
+			DeliverMessage(nextTurnPlayer,this.gameNumber);
+			GameLog("next player notified of turn: " + system.username(nextTurnPlayer));
+		}
+		else
+		{
+			while(1)
+			{
+				if(nextTurn==this.maxPlayers-1) nextTurn=0;
+				else nextTurn++;
+				nextTurnPlayer=this.players[this.turnOrder[nextTurn]].user;
+				if(nextTurnPlayer==this.players[this.turnOrder[this.nextTurn]].user) 
+				{
+					GameLog("all other human players eliminated, no other players notified");
+					break;
+				}
+				else if(nextTurnPlayer>0 && nextTurnPlayer!=user.number && this.status!=0) 
+				{
+					DeliverMessage(nextTurnPlayer,this.gameNumber);
+					GameLog("skipped computer notices, next human user notified of turn: " + system.username(nextTurnPlayer));
+					break;
+				}
+			}
+		}
+	}
+	this.FindDaysOld=			function()	//DETERMINE THE LAST TIME A GAME FILE WAS MODIFIED (LAST TURN TAKEN)
+	{
+		daysOld=(time()-this.lastModified)/daySeconds;
+		return daysOld;
+	}
+	this.CheckElimination=		function()
+	{
+		GameLog("checking game elimination data");
+		var numEliminated=this.eliminated.length;
+		var humans=this.CountActiveHumans();
+		if(numEliminated==(this.maxPlayers-1) || humans==0)
+		{
+			this.status=0;
+			if(this.lastEliminator==(-1))
+			{	
+				if(this.singlePlayer)
+				{
+					scores[user.number].losses++;
+				}
+				GameLog("game over - computer winner");
+				return true;
+			}
+			else
+			{	//THE GAME IS OVER BECAUSE  A HUMAN PLAYER WON
+				GameLog("game over - player winner");
+				this.winner=this.lastEliminator;
+				this.AssignPoints();
+				return true;
+			}
+		}
+		else return false;
+	}
+	this.CountActiveHumans=		function()
+	{
+		count=0;
+		for(ply in this.players)
+		{
+			if(this.players[ply].user>0 && !this.players[ply].eliminated) count++;
+		}
+		return count;
+	}
+	this.AssignPoints=			function()	//TODO: REWORK SCORING SYSTEM COMPLETELY
+	{
+		scores=games.LoadRankings();
+		
+		if(this.singlePlayer) 
+		{
+			scores[this.winner].wins+=1;
+			GameLog("adding win to user " + this.winner);
+		}
+		else 
+		{
+			scores[this.winner].score+=2;
+			GameLog("giving 2 points to user " + this.winner);
+		}
+		games.StoreRankings();
+	}
+	this.EliminatePlayer=		function(playerNumber,eliminator)
+	{
+		dead=this.players[playerNumber];
+		dead.eliminated=true;
+		this.eliminated.push(playerNumber);
+		this.lastEliminator=eliminator;
+		if(dead.user>0) 
+		{
+			//TODO: SEE SCORING SYSTEM
+			pointBuffer=7-this.maxPlayers;
+			pts=points[pointBuffer+(this.eliminated.length-1)];
+
+			scores=games.LoadRankings();
+			scores[dead.user]+=pts;
+			GameLog("giving " + pts + " points to user " + dead.user + " : actual points stored " + scores[dead.user]);
+			games.StoreRankings();
+		}
+		GameLog("player " + playerNumber + " eliminated");
+	}
+	this.SetEliminated=			function()
+	{										//RUNS AT STARTUP, STORING GAME ELIMINATION DATA UPON LOADING EACH GAME
+		this.eliminated=[];
+		for(elp in this.players)
+		{
+			if(this.players[elp].territories.length<=0) 
+			{
+				this.eliminated.push(elp);
+				this.players[elp].eliminated=true;
+			}
+			else this.lastEliminator=this.players[elp].user;
+		}
+		if(this.status==0) this.winner=this.lastEliminator;
+	}
+	this.GetNextTurn=			function()
+	{
+		GameLog("assigning next turn in turn order");
+		if(this.nextTurn==this.maxPlayers-1) this.nextTurn=0;
+		else this.nextTurn++;
+		nextPlayer=this.turnOrder[this.nextTurn];
+		while(this.players[nextPlayer].eliminated) 
+		{
+			if(this.nextTurn==this.maxPlayers-1) this.nextTurn=0;
+			else this.nextTurn++;
+			nextPlayer=this.turnOrder[this.nextTurn];
+		}
+	}
+	this.SetMap=				function()	
+	{										//SET MAP SIZE
+		this.playerTerr=this.minTerr+random(this.maxTerr-this.minTerr);
+		this.mapSize=this.maxPlayers*(this.playerTerr);
+	}								
+	this.DisplayGrid=			function()
+	{										//DISPLAYS THE LOCATION DATA FOR EACH COMPANY
+		DrawVerticalLine("\1w\1h");
+		for(uu in this.used)
+		{
+			this.grid[uu].displayBorder(border_color);
+		}
+	}
+	this.SetGrid=				function()
+	{
+		for(uu in this.used)
+		{
+			this.grid[uu].setBorder(this.grid);
+		}
+	}
+	this.Redraw=				function()
+	{
+		this.DisplayPlayers();
+		this.DisplayGrid();
+		this.displayGame();
+		WipeCursor("left");
+	}
+	this.displayGame=			function()
+	{										//DISPLAY EACH PLAYER'S TERRITORIES
+		for(ply in this.players)
+		{
+			for(ter in this.players[ply].territories)
+			{
+				territory=this.players[ply].territories[ter];
+				this.grid[territory].show();
+			}
+		}
+	}	
+	this.getXY=					function(place)
+	{										//TAKE A GRID INDEX, AND RETURNS THE CORRESPONDING X AND Y COORDINATES FOR DISPLAY
+		x=this.map_column;
+		y=this.map_row;
+		x+=((place%this.columns)*2);
+		y+=(parseInt(index/this.columns));
+		console.gotoxy(x,y);
+		return(0);
+	}
+	this.Reinforce=				function(playerNumber)
+	{
+		numDice=this.FindConnected(playerNumber);
+		placed=this.PlaceDice(playerNumber,numDice);
+		if(this.winner<0) this.CheckElimination();
+		this.GetNextTurn();
+		if(!this.singlePlayer) this.Notify(this.gameNumber);
+		return placed;
+	}
+	this.CanAttack=				function(playerNumber,mapLocation)
+	{										//RETURNS TRUE IF PLAYER : playerNumber CAN ATTACK FROM GRID INDEX : mapLocation
+		if(mapLocation>=0)		//IF A LOCATION IS PROVIDED, RETURN AN ARRAY OF NEIGHBORING TERRITORIES THAT CAN BE ATTACKED
+		{
+			GameLog("reference location provided: " + mapLocation);
+			options=[];
+			if(this.grid[mapLocation].dice>1)
+			{
+				dirs=this.LoadDirectional(mapLocation);
+				for(dir in dirs)
+				{
+					current=dirs[dir];
+					if(this.grid[current]) 
+					{
+						if(this.grid[current].player!=playerNumber) options.push(current);
+					}
+				}
+			}
+			if(options.length) return options;
+		}
+		else				//OTHERWISE, SIMPLY DETERMINE WHETHER THE PLAYER CAN ATTACK AT ALL, AND RETURN TRUE OR FALSE
+		{
+			GameLog("no reference location provided");
+			if(this.players[playerNumber].territories.length==this.players[playerNumber].totalDice) return false;
+			for(terr in this.players[playerNumber].territories)
+			{
+				currentTerritory=this.players[playerNumber].territories[terr];
+				if(this.grid[currentTerritory].dice>1)
+				{
+					dirs=this.LoadDirectional(currentTerritory);
+					for(dir in dirs)
+					{
+						current=dirs[dir];
+						if(this.grid[current]) 
+						{
+							if(this.grid[current].player!=playerNumber) return true;
+						}
+					}
+				}
+			}
+		}
+		return false;
+	}
+	this.LoadDirectional=		function(mapLocation)
+	{
+		current=this.grid[mapLocation];
+		n=current.North;
+		s=current.South;
+		nw=current.Northwest;
+		ne=current.Northeast;
+		sw=current.Southwest;
+		se=current.Southeast;
+		dirs=[n,s,nw,ne,sw,se];
+		return dirs;
+	}
+	this.FindConnected=			function(playerNumber)
+	{										//SCANS ENTIRE MAP AND RETURNS THE NUMBER EQUAL TO THE PLAYER'S LARGEST CLUSTER OF CONNECTED TILES
+		largest_cluster=1;
+		terr=this.players[playerNumber].territories;
+		var checked=[];
+		var counted=[];
+		var tocheck=[];
+		y=10;
+		for(tttt in terr)
+		{
+			count=1;
+			tocheck.push(terr[tttt]);
+			while(tocheck.length)
+			{	
+				loc=tocheck.shift();
+				current=this.grid[loc];
+				
+				if(!checked[current.location])
+				{
+					dirs=ScanProximity(current.location);
+					for(ddd in dirs)
+					{
+						dir=dirs[ddd];
+						if(this.grid[dir] && !checked[dir]) 
+						{
+							if(this.grid[dir].player==playerNumber) 
+							{ 
+								tocheck.push(dir); 
+								if(!counted[dir]) 
+								{ 
+									count++; 
+									counted[dir]=true;
+								}
+							}
+						}
+					}
+					checked[current.location]=true;
+				}
+			}
+			if(count>largest_cluster) largest_cluster=count;
+		}
+		return largest_cluster;
+	}
+	this.DisplayPlayers=		function()
+	{										//DISPLAY PLAYER INFO (RIGHT SIDE)
+		xxx=menuColumn;
+		yyy=menuRow;
+		for(ply=0;ply<this.maxPlayers;ply++)
+		{
+				playerNumber=this.turnOrder[ply];
+				player=this.players[playerNumber];
+				if(player.eliminated) { player.bColor=blackBG; player.fColor="\1n\1k\1h"; }
+				
+				console.gotoxy(xxx,yyy); yyy++;
+				console.putmsg(PrintPadded(player.bColor + player.fColor + " " + GetUserName(player,playerNumber) + ":",36," ", "left"));
+				console.gotoxy(xxx,yyy); yyy++;
+				console.putmsg(player.fColor + player.bColor+ " LAND: " + PrintPadded(player.fColor + player.territories.length,3," ", "right"));
+				console.putmsg(player.fColor + player.bColor+ " DICE: " + PrintPadded(player.fColor + player.totalDice,3," ", "right"));
+				console.putmsg(player.fColor + player.bColor+ " RSRV: " + PrintPadded(player.fColor + player.reserve,3," ", "right") + " ");
+		}
+		console.print(blackBG);
+	}
+	this.ShufflePlayers=		function()
+	{										//Generate TURN ORDER (this.turnOrder[])
+		for(pp=0;pp<this.maxPlayers;pp++)
+		{
+			var rand=random(this.maxPlayers);
+			if(this.turnOrder[rand]>=0) pp--;
+			else this.turnOrder[rand]=pp;
+		}
+	}
+	this.GeneratePlayers=		function()
+	{
+		for(pl=0;pl<this.maxPlayers;pl++)
+		{
+			userNumber=this.players[pl].user;
+			this.users[userNumber]=pl;
+			this.players[pl].setColors(pl);
+			this.players[pl].starting_territories=this.playerTerr;
+		}
+		this.ShufflePlayers();
+	}
+	this.GenerateMap=			function()
+	{										//RANDOMLY Generate NEW LAND
+		var unused=[];
+		for(mi=0;mi<this.total;mi++) unused.push(mi);
+		randa=random(unused.length);
+		locationa=unused[randa];
+		this.grid[locationa]=new Territory(locationa);
+		this.used[locationa]=true;
+		unused.splice(randa,1); 
+		
+		for(ms=1;ms<this.mapSize;ms++)
+		{
+			randb=random(unused.length);
+			locationb=unused[randb];
+			prox=ScanProximity(locationb);
+			if(this.LandNearby(prox, this.used))
+			{
+	 			this.grid[locationb]=new Territory(locationb);
+				this.used[locationb]=true;
+				unused.splice(randb,1); 
+			}
+			else ms--;
+		}
+		var territories=[];
+		for(mt in this.used)
+		{
+			territories.push(mt);
+		}
+		for(ply in this.players)
+		{
+			for(tt=0;tt < this.playerTerr; tt++)
+			{
+				rand=random(territories.length);
+				location=territories[rand];
+				if(this.grid[location].player>=0) tt--;
+				else 
+				{
+					this.grid[location].assign(ply,this.players[ply]);
+					this.players[ply].territories.push(location);
+				}
+			}
+			this.PlaceDice(ply,this.playerTerr);
+		}
+		this.CountDiceAll();
+	}	
+	this.LandNearby=			function(proximity)
+	{										//CHECK IMMEDIATE AREA FOR LAND
+		for(px in proximity)
+		{
+			location=proximity[px];
+			if(this.used[location]) 
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+	this.PlaceDice=				function(playerNum, numDice)
+	{										//RANDOMLY PLACE X NUMBER OF DICE ON PLAYER TERRITORIES
+		playerNumber=parseInt(playerNum);
+		this.CountDice(playerNumber);
+		toPlace=numDice;
+		fulldice=false;
+		placed=[];
+		GameLog("Player " + (playerNumber+1) + " Placing " + numDice + " reinforcements");
+		for(sd=0;sd<numDice;sd++)
+		{
+			rand=random(this.players[playerNumber].territories.length);
+			terr=this.players[playerNumber].territories[rand];
+
+			if(this.players[playerNumber].totalDice==(this.players[playerNumber].territories.length*this.maxDice)) 	//IF ALL OF THIS PLAYER'S TERRITORIES HAVE THE MAXIMUM
+			{ 									  						//AMOUNT OF DICE  PUSH DICE INTO PLAYER'S RESERVE
+				GameLog("all territories full");
+				fulldice=true;
+				reserveCap=(30-this.players[playerNumber].reserve);
+				if(reserveCap>0)
+				{
+					GameLog("reserve: " + this.players[playerNumber].reserve + " reserve cap: " + reserveCap + " adding: " + toPlace);
+					if(reserveCap>=toPlace) this.players[playerNumber].reserve+=toPlace;
+					else this.players[playerNumber].reserve+=reserveCap;
+				}
+				return placed;
+			}
+			else if(this.grid[terr].dice<this.maxDice) 
+			{
+				GameLog("dice placed on: " + terr);
+				this.grid[terr].dice++;
+				placed.push(terr);
+				this.players[playerNumber].totalDice++;
+				toPlace--;
+			}
+			else
+			{
+				GameLog("territory: " + terr + " full: " + this.grid[terr].dice);
+				if(this.players[playerNumber].territories.length==1) return placed;
+				sd--;
+			}
+		}
+		if(this.players[playerNumber].reserve>0)
+		{
+			GameLog("placing reserves");
+			if(this.players[playerNumber].totalDice==(this.players[playerNumber].territories.length*this.maxDice)) 	//IF ALL OF THIS PLAYER'S TERRITORIES HAVE THE MAXIMUM
+			{ 									  						//AMOUNT OF DICE  PUSH DICE INTO PLAYER'S RESERVE
+				GameLog("all territories full");
+				fulldice=true;
+			}
+			else
+			{
+				while(this.players[playerNumber].reserve>0)
+				{
+					rand=random(this.players[playerNumber].territories.length);
+					terr=this.players[playerNumber].territories[rand];
+					if(this.grid[terr].dice<this.maxDice)
+					{
+						this.grid[terr].dice++;
+						placed.push(terr);
+						this.players[playerNumber].totalDice++;
+						this.players[playerNumber].reserve--;
+						if(this.players[playerNumber].totalDice==(this.players[playerNumber].territories.length*this.maxDice)) 	//IF ALL OF THIS PLAYER'S TERRITORIES HAVE THE MAXIMUM
+						{
+							GameLog("all territories full");
+							return placed;
+						}
+					}
+				}
+			}
+		}
+		return placed;
+	}
+	this.CountDice=				function(playerNumber)
+	{										//COUNT DICE TOTALS FOR EACH PLAYER
+		this.players[playerNumber].totalDice=0;
+		for(td in this.players[playerNumber].territories)
+		{
+			terr=this.players[playerNumber].territories[td];
+			this.players[playerNumber].totalDice+=this.grid[terr].dice;
+		}
+	}
+	this.CountDiceAll=			function()
+	{
+		for(ppp in this.players)
+		{
+			this.CountDice(ppp);
+		}
+	}
+	this.Init=					function()
+	{										//InitIALIZE GAME
+		this.SetMap();
+		GameLog("map size set");
+		this.GeneratePlayers();
+		GameLog("players Generated");
+		this.GenerateMap(this.columns, this.rows);
+		GameLog("map Generated");
+		this.SetGrid();
+		GameLog("grid set");
+	}
+									//END METHODS 
+}

xtrn/dicewarz/menu.js

+function 	Menu(title,x,y,color,hkey_color)		
+{								//MENU CLASSES
+	this.title=title;
+	this.disabled=[];
+	this.disabled_color="\1k\1h";
+	this.items=[];
+	var orig_x=x;
+	var orig_y=y;
+
+	this.showline=function()
+	{
+		var yyyy=orig_y;
+		console.gotoxy(xxxx,yyyy); yyyy++;
+		console.cleartoeol();
+		DrawLine("\1w\1h",79); console.crlf();
+	}
+	this.display=function()
+	{
+		var yyyy=orig_y;
+	
+		var clear=5;
+		var cleared=0;
+		for(i in this.items)
+		{
+			if(!this.disabled[i])
+			{
+				console.gotoxy(orig_x,yyyy); yyyy++;
+				console.putmsg(this.items[i].text);
+				console.cleartoeol();
+				cleared++;
+			}
+		}
+		for(i=cleared;i<clear;i++)
+		{
+			console.gotoxy(orig_x,yyyy); yyyy++;
+			console.cleartoeol();
+
+		}
+		WipeCursor("right");
+	}
+	this.disable=function(item)
+	{
+		this.disabled[item]=true;
+		this.items[item].Init(this.disabled_color,this.disabled_color)
+	}
+	this.enable=function(item)
+	{
+		this.disabled[item]=false;
+		this.items[item].Init(color,hkey_color);
+	}
+	this.add=function(items)
+	{
+		for(i=0;i<items.length;i++)
+		{
+			hotkey=this.getHotKey(items[i]);
+			this.items[hotkey]=new MenuItem(items[i],hotkey,color,hkey_color);
+			this.items[hotkey].Init(color,hkey_color);
+		}
+	}
+	this.displayTitle=function()
+	{
+		printf("\1h\1w" + this.title);
+	}
+	this.getHotKey=function(item)
+	{
+		keyindex=item.indexOf("~")+1;
+		return item.charAt(keyindex);
+	}	
+	this.displayHorizontal=function()
+	{
+		ClearLine(1,48);
+		console.gotoxy(orig_x,orig_y);
+		for(i in this.items)
+		{
+			console.putmsg(this.items[i].text + " ");
+		}
+		WipeCursor("left");
+	}
+}
+function 	MenuItem(item,hotkey,color,hkey_color)
+{								//MENU ITEM OBJECT
+	this.displayColor=color;
+	this.keyColor=hkey_color;
+	this.item=item;
+	
+	this.hotkey=hotkey;
+	this.Init=function(color,hkey_color)
+	{
+		this.text=this.item.replace(("~" + hotkey) , (color + "[" + hkey_color + hotkey + color + "]"));
+	}
+}
\ No newline at end of file

xtrn/dicewarz/player.js

+function	Player(userNumber, vote)
+{
+	this.user=userNumber;
+	this.territories=[];
+	this.totalDice=0;
+	this.bColor="";
+	this.bfColor="";
+	this.fColor="";
+	this.starting_territories=0;
+	this.reserve=0;
+	this.eliminated=false;
+	this.vote=vote;
+
+	this.setColors=function(num)
+	{
+		this.bColor=console.ansi(bColors[num]);
+		this.bfColor=console.ansi(bfColors[num]);
+		this.fColor=fColors[num];
+	}
+	this.removeTerritory=function(territory)
+	{
+		for(rem in this.territories)
+		{
+			if(this.territories[rem]==territory)
+			{
+				this.territories.splice(rem,1);
+			}
+		}
+	}
+	this.countTerritory=function()
+	{
+		count=0;
+		for(tt in this.territories)
+		{
+			count++;
+		}
+		return count;
+	}
+}

xtrn/dicewarz/territory.js

+function 	Territory(location)	
+{								
+	this.dice=1;
+	this.player=-1;
+	this.bColor=-1;
+	this.fColor=-1;
+	this.bfColor=-1;
+	this.x=-1;
+	this.y=-1;
+	this.location=location;
+
+	this.topLeft=">";
+	this.topRight="<";
+	this.bottomLeft=">";
+	this.bottomRight="<";
+
+	this.North=-1;
+	this.South=-1;
+	this.Northwest=-1;
+	this.Northeast=-1;
+	this.Southwest=-1;
+	this.Southeast=-1;
+
+										//OBJECT METHODS
+	this.setBorder=			function(data)
+	{										//CHECK PROXIMITY AND ASSIGN BORDER CHARACTERS
+		proximity=ScanProximity(this.location);
+		this.North=proximity[0];
+		this.South=proximity[1];
+		this.Northwest=proximity[2];
+		this.Northeast=proximity[3];
+		this.Southwest=proximity[4];
+		this.Southeast=proximity[5];
+		if(!data[this.North])
+		{
+			if(!data[this.Northwest]) this.topLeft=".";
+			if(!data[this.Northeast]) this.topRight=".";
+		}
+		if(!data[this.South])
+		{
+			if(!data[this.Southwest]) this.bottomLeft="`";
+			if(!data[this.Southeast]) this.bottomRight="'";
+		}
+	}
+	this.assign=			function(number,player)
+	{										//GIVE PLAYER OWNERSHIP OF THIS TERRITORY
+		this.player=number;
+		this.bColor=player.bColor;
+		this.bfColor=player.bfColor;
+		this.fColor=player.fColor;
+	}
+	this.show=				function()
+	{										//DISPLAY THIS TERRITORY ON THE MAP
+//		ALTERNATE MAP POSITION DISPLAY
+//		display=(this.bfColor + ""+ blackBG + this.bColor + this.fColor + " " + this.dice + " " + blackBG + this.bfColor + "");
+
+		display=(this.bfColor + "\xFE"+ blackBG + this.bColor + this.fColor + " " + this.dice + " " + blackBG + this.bfColor + "\xFE");
+		console.gotoxy(this.x-1, this.y);
+		console.putmsg(display);
+	}
+	this.displayBorder=		function(color)
+	{										//DISPLAY THIS TERRITORY'S BORDER ON THE MAP
+		console.gotoxy(this.x-2, this.y);	
+		printf(color + "<");				
+		console.gotoxy(this.x+4, this.y);
+		printf(color + ">");
+		console.gotoxy(this.x-1, this.y-1);
+		printf(color+this.topLeft);
+		DrawLine(color,3);
+		printf(this.topRight);
+		console.gotoxy(this.x-1, this.y+1);	
+		printf(color+this.bottomLeft)
+		DrawLine(color,3)
+		printf(this.bottomRight);
+	}
+	this.displaySelected=	function(color)
+	{										//DISPLAY THIS TERRITORY'S BORDER ON THE MAP
+		console.gotoxy(this.x-2, this.y);	
+		printf(color + "<");				
+		console.gotoxy(this.x+4, this.y);
+		printf(color + ">");
+		console.gotoxy(this.x-1, this.y-1);
+		printf(color+".");
+		DrawLine(color,3);
+		printf(color+".");
+		console.gotoxy(this.x-1, this.y+1);	
+		printf(color+"`")
+		DrawLine(color,3)
+		printf(color+"'");
+	}
+	this.getXY=				function(loc,sc,sr)
+	{										//ASSIGN DISPLAY COORDINATES FOR MAP
+		var startX=sc;
+		var startY=sr;
+		offset=loc%columns;
+		if(offset%2==1) startY++;
+		startX+=(offset*5);
+		startY+=(parseInt(loc/columns)*2);
+		this.x=startX;
+		this.y=startY;
+	}
+	
+	this.getXY(this.location,startColumn,startRow);
+}