");
	    print_r($da);
	}

	if($curTime >= $dopChgTime)	//if past rollover time
	{
	    //--------------------------------------------
	    //find new jdStart for next day of play
	    //--------------------------------------------

	    $jd = $jdStart + 1;
	    $jdStart = -1;

	    while($jdStart < 0)
	    {
		$dow = (jddayofweek($jd,0));

		if($SUSDaysUsed[$dow] == 0) {	//day not day of play
			$jd++;
			continue;
		}
		$jdStart = $jd;

	    }
	    $dbjds = $jdStart;
	    $daysRollover++;		        //at least one DOP to rollover

	    if($logging)
	    {
		$str = "Time rollover: NextDOP=> jdStart=$jdStart  dbjds=$dbjds";
		//WriteToLogFile($str,'data');
	    }

	    if($debug) { echo("
rollover: curTime=$curTime | dopChgTime=$dopChgTime | new jdStart=$jdStart dbjds=$dbjds"); }
	}
    }
    //---------------------------------

    if($daysRollover > $statLen) { $daysRollover = $statLen; }  // if move to new day

    if($daysRollover > 0)
    {

	if($debug) { echo("
Perform rollover: daysRollover=$daysRollover statLen=$statLen"); }
	if($logging) {
	    PruneLogFile();
	    WriteToLogFile('','header');
	    WriteToLogFile($jdDOPstr,'data');
	    $line = "Perform rollover: daysRollover=$daysRollover statLen=$statLen jdStart=$jdStart\n";
	    WriteToLogFile($line, "data");
	}

	//----------------------------------------
	//backup the database before rolling over
	//----------------------------------------
	MyBackupDB($rolloverDOW);
	$foo = $_SESSION['susname'];
	if($debug) { echo("
BackupFiles: daysRollover=$daysRollover SUSName=$foo rolloverDOW=$rolloverDOW"); }
	if($logging) {
	    $line = "BackupFiles: daysRollover=$daysRollover SUSName=$foo rolloverDOW=$rolloverDOW\n";
	    WriteToLogFile($line, "data");
	}

	//---------------------------
	//reset player ptype entries
	//---------------------------
	$rc = MyResetPType();
	WriteToLogFile("ResetPType(): $rc resets\n", "data");

	//-----------------------
	//rollover the database
	//-----------------------
	for($i=0; $i<$daysRollover; $i++)
	{
	    if(!is_int($jdStart = MyRollover(0)))
	    {
		echo "
Rollover:$jdStart";
		exit;
	    }

	    //pop the Tables file (tables.ser)
	    if(file_exists($TablesFileName))
	    {
		$Tables = unserialize(file_get_contents($TablesFileName));

		if($Tables)
		{
		    ksort($Tables);
		    array_shift($Tables);
		    $Tables[2][0]['table'] = -1;
		    file_put_contents($TablesFileName, serialize($Tables));
		}
	    }
	    if($debug) { echo("
PopStatusFile: daysRollover=$daysRollover"); }
	    if($logging) {
		$line = "PopStatusFile: daysRollover=$daysRollover\n";
		WriteToLogFile($line, "data");
		//WriteToLogFile("", "blank");
	    }
	}

	//---------------------------------------
	//remove the tables csv file (tables.csv)
	//---------------------------------------
	
	if(file_exists($TablesCsvFileName))
	{
	    //fclose($TablesCsvFileName);
	    unlink($TablesCsvFileName);
	}

	MyGetPlayerInfo();	//reads player files after writing

	$SUSRemindTime = abs($SUSRemindTime); //Reset reminder sent status
	$_SESSION['susremindtime'] = $SUSRemindTime;
	WriteCfgFile();

	//------------------------
	//Clean the database
	//------------------------
/*
	CleanDB();  //strip_tags() and recalc the high seq values

	$line = "CleanDB() has finished\n";
	WriteToLogFile($line, "data");
*/
    }

    return $jdStart;
}
//--------------------------------------------------------------------------------
function listPids() {
//--------------------------------------------------------------------------------
global $Players;

$_SESSION['susnoplayers'] = $NumDBPlayers = count($Players);

$n=0;
$pids = array();

    for($p=0; $p<$NumDBPlayers; $p++)
    {
	if($Players[$p]['login'] == 'Guest') {
		continue;
	}
	$pids[$n++] = $Players[$p]['pid'];
    }

    $nG = $n;

    for($p=0; $p<$NumDBPlayers; $p++)
    {
	if($Players[$p]['login'] != 'Guest') {
		continue;
	}
	$pids[$n++] = $Players[$p]['pid'];
    }

    $pids[$n++] = $nG;

    return $pids;
}
//--------------------------------------------------------------------------------
function CalcDraw($doTables, $ndxDOP = -1) {
//--------------------------------------------------------------------------------
//WriteToLogFile("\nCalcDraw($doTables)","data");
//echo "
CalcDraw: doTables = $doTables  ndxDOP = $ndxDOP";

global $SUSMaxGames;
global $SUSMaxTables;
global $SUSDaysUsed;
global $SUSDaysToSkip;
global $SUSNumPPG;			//Number players per game
global $SUSSubEqReg;
global $SUSNoDays;
global $SUSAllowHalfGames;
global $SUSNotifyOnOff;

global $Players;
global $Status;
global $Systemdata;

global $maxTables;	    //max tables for each day of play

global $calcCnt;

//update player files

//writePlayerFiles($_SESSION['susdbname']);
$_SESSION['susnoplayers'] = $NumDBPlayers = count($Players);

//arrays of available player info

$sortPid    = array();	    //player pid
$sortSeq    = array();	    //player signup sequence
$sortType   = array();	    //player type
$sortUsed   = array();	    //player already used in draw
$sortAvg    = array();	    //player pair's master pt avg

$tableTeam  = array();  //pids of team partners
			    //'pid1','pid2','posn','seq','mpavg'

$GamesPerDay = array();
$nTeam = 0;		    //number of teams
$nATDays    = $_SESSION['numtabledays'];    //number of days to assign tables

//general variables

$table	    = array();	    //holding queue to make a table
$nT = 0;		    //number of tables
$ppt = 4;		    //players per table
$p  = 0;		    //index into Players array
$s  = 0;		    //index into Status array
$n  = 0;		    //index into sort arrays
$nQ = 0;		    //number in holding queue
$nA = 0;		    //number in available players
//----------------------------------------------------------
    //----------------------------
    //set max tables for each day
    //----------------------------

    $jd = $Systemdata['jdstart'][0];

    for($d=0; $d<$SUSNoDays; $d++)	    //for each day of play
    {
	$k = -1;
	while($k < 0)	//set max tables for next day of play
	{
	    $dow = jddayofweek($jd,0);	    //get day of the week

	    if($SUSDaysUsed[$dow] != 0)	    //if this is day of play
	    {
		$maxTables[$d] = $SUSMaxTables[$dow]; //set max tables for this day
		$k = 1;
	    }

	    $jd++;	//try next day
	}
    }
    //-----------------------
    //set status for each day
    //-----------------------
    for($d=0; $d<$SUSNoDays; $d++)
    {

	$GamesPerDay[$d] = 0;
	$sortPid    = array();	    //player pid
	$sortSeq    = array();	    //player signup sequence
	$sortType   = array();	    //player type
	$sortUsed   = array();	    //player already used in draw
	$sortAvg    = array();	    //player pair's master pt avg
	$table	    = array();	    //holding queue to make a table
	$nTeam	    = 0;	    //number of teams
	$tableTeam  = array();	    //pids of team partners
					//'pid1','pid2','posn','seq','mpavg'
	$n = 0;
	$nT = 0;

	//--------------------------------------------
	//build arrays of available player information
	//--------------------------------------------
	for($s=0; $s<$NumDBPlayers; $s++)
	{
	    $status = $Status[$s][$d]['status'];
	    if($status == 'A' || $status == 'P')
	    {

		$Status[$s][$d]['prevstatus'] = $status;
		$Status[$s][$d]['status'] = 'A';

		$chgpid = $Status[$s][$d]['pid'];
		$_SESSION['changed_pids'][] = $chgpid;

		$sortUsed[$n]   = 0;
		$sortSeq[$n]    = $Status[$s][$d]['seq'];
		$sortPid[$n]    = $Status[$s][$d]['pid'];
		$p = PlayerIndex($sortPid[$n]);
		if($d == 0) //account for cutoff ptype
		{
		    $sortType[$n]   = $Players[$p]['ptype'];
		} else {
		    $sortType[$n]   = $Players[$p]['ptype'] & 1;
		}
		$n++;
	    }
	}

	$nA = $n;
	if($nA == 0) { continue; }	//loop if no available players
	//-------------------------------------
	//sort arrays into signup sequence order
	//-------------------------------------
	array_multisort($sortSeq, SORT_NUMERIC, SORT_ASC, $sortPid, $sortType);

	if($SUSSubEqReg == 0)
	{
	    //array_multisort($sortType, SORT_NUMERIC, SORT_ASC, $sortPid, $sortSeq);
	    //array_multisort is not a stable sort so have to do the following

	    $acnt = count($sortType);
	    $regs_0 = array();	//indexs for regulars
	    $iregs_0 = 0;
	    $regs_10 = array();	//indexs for regulars on waiting list
	    $iregs_10 = 0;
	    $subs_1 = array();	//indexs for subs
	    $isubs_1 = 0;
	    $subs_11 = array();	//indexs for subs on waiting list
	    $isubs_11 = 0;

	    for($i=0; $i<$acnt; $i++)		//separate regulars and subs
						//and sort by player type
	    {
		switch($sortType[$i])
		{
		case  0:			//regular
		    $regs_0[$iregs_0] = $i;
		    $iregs_0++;
		    break;

		case  10:			//regular on waiting list
		    $regs_10[$iregs_10] = $i;
		    $iregs_10++;
		    break;

		case 1:				//sub 
		    $subs_1[$isubs_1] = $i;
		    $isubs_1++;
		    break;

		case 11:			//sub on waiting list
		    $subs_11[$isubs_11] = $i;
		    $isubs_11++;
		    break;
		}
	    }

	    $tempSeq = array();
	    $tempPid = array();
	    $tempType = array();
	    $j = 0;

	    for($i=0; $i<$iregs_0; $i++)		//regulars
	    {
		$tempSeq[$j] = $sortSeq[$regs_0[$i]];
		$tempPid[$j] = $sortPid[$regs_0[$i]];
		$tempType[$j] = $sortType[$regs_0[$i]];
		$j++;
	    }

	    for($i=0; $i<$isubs_1; $i++)		//subs 
	    {
		$tempSeq[$j] = $sortSeq[$subs_1[$i]];
		$tempPid[$j] = $sortPid[$subs_1[$i]];
		$tempType[$j] = $sortType[$subs_1[$i]];
		$j++;
	    }

	    for($i=0; $i<$iregs_10; $i++)		//regulars on waiting list
	    {
		$tempSeq[$j] = $sortSeq[$regs_10[$i]];
		$tempPid[$j] = $sortPid[$regs_10[$i]];
		$tempType[$j] = $sortType[$regs_10[$i]];
		$j++;
	    }

	    for($i=0; $i<$isubs_11; $i++)		//subs on waiting list
	    {
		$tempSeq[$j] = $sortSeq[$subs_11[$i]];
		$tempPid[$j] = $sortPid[$subs_11[$i]];
		$tempType[$j] = $sortType[$subs_11[$i]];
		$j++;
	    }

	    for($i=0; $i<$acnt; $i++)		//put sorted values back in sort arrays
	    {
		$sortSeq[$i] = $tempSeq[$i];
		$sortPid[$i] = $tempPid[$i];
		$sortType[$i] =  $tempType[$i];
	    }
	}

	//--------------------------
	//set status in Status array
	//--------------------------
	$nQ = 0;
	$n = 0;
	while($n<$nA)
	{
	    if($sortUsed[$n] == 0)
	    {
		$table[$nQ] = $sortPid[$n];	    //add next player to table
		$sortUsed[$n] = 1;		    //show player used

		$s = StatusIndex($sortPid[$n]);	    //index to players status info
		$pp = $Status[$s][$d]['partner'];   //player's partner

		if($pp != 0)			    //if player has a partner
		{
		    //find player's partner
		    $i = -1;
		    for($j=$n+1; $j<$nA; $j++)
		    {
			if($sortPid[$j] == $pp && $sortUsed[$j] == 0)
			{
			    $i = $j;		    //index of player's partner
			    break;
			}
		    }

		} else {			    //player has no partner

		    //find a partner for the player
		    $i = -1;
		    for($j=$n+1; $j<$nA; $j++)
		    {
			$s = StatusIndex($sortPid[$j]);	    //index to players status info
			$pp = $Status[$s][$d]['partner'];   //player's partner
			
			if($pp == 0 && $sortUsed[$j] == 0)  //if player has no partner
			{
			    $i = $j;		    //index of player's partner
			    break;
			}
		    }
		}

		if($i >= 0)			    //if found a partner
		{
		    //add both to teams table
		    $tableTeam[$nTeam]['pid1'] = $table[$nQ];
		    $tableTeam[$nTeam]['pid2'] = $sortPid[$i];
		    $s = StatusIndex($table[$nQ]);	    //index to players status info
		    $tableTeam[$nTeam]['posn'] = $Status[$s][$d]['posn'];
		    $tableTeam[$nTeam]['seq'] = $Status[$s][$d]['seq'];

		    if($_SESSION['nmplevels'] > 0)
		    {
			$ndx = PlayerIndex($table[$nQ]);
			$avg = $Players[$ndx]['masterpts'];

			$ndx = PlayerIndex($sortPid[$i]);
			$avg += $Players[$ndx]['masterpts'];

			$tableTeam[$nTeam]['mpavg'] = $avg/2;

		    } else {

			$tableTeam[$nTeam]['mpavg'] = 0;
		    }

		    $nTeam++;

		    //add both to table
		    $nQ++;			    //add player
		    $table[$nQ] = $sortPid[$i];	    //add partner
		    $sortUsed[$i] = 1;		    //show partner used
		    $nQ++;			    //add partner
		}
		//-------------------
		//update Status array
		//-------------------
		    if($nQ == $ppt)
		    {
			for($i=0; $i<$ppt; $i++)
			{
			    $s = StatusIndex($table[$i]);	    //index to players status info
			    //$Status[$s][$d]['prevstatus'] = $Status[$s][$d]['status'];
			    $Status[$s][$d]['status'] = 'P';

			    $chgpid = $Status[$s][$d]['pid'];
			    $_SESSION['changed_pids'][] = $chgpid;
			}
			$nQ = 0;
			$nT++;
		    }
	    }	//if player not already used

	    //if($SUSMaxGames > 0 && $nT >= $SUSMaxGames) break;
	    if($maxTables[$d] > 0 && $nT >= $maxTables[$d]) { break; }
	    $n++;

	} //for each available player

	if($SUSAllowHalfGames != 0)
	{
	    if($nQ == 2)
	    {
		for($i=0; $i<2; $i++)
		{
		    $s = StatusIndex($table[$i]);	    //index to players status info
		    //$Status[$s][$d]['prevstatus'] = $Status[$s][$d]['status'];
		    $Status[$s][$d]['status'] = 'P';

		    $chgpid = $Status[$s][$d]['pid'];
		    $_SESSION['changed_pids'][] = $chgpid;
		}
		$nQ = 0;
		$nT++;
	    }
	}
	$GamesPerDay[$d] = $nT;

	//--------------------------------------------
	//assign tables and abort if only doing tables
	//--------------------------------------------
	if($d < $nATDays && $doTables != 0)
	{
	    if($ndxDOP < 0 || ($ndxDOP >= 0 && $ndxDOP == $d))
	    {
		if( $nTeam > 0)
		{
		    $sortAvg = array();

		    for($i=0; $i<$nTeam; $i++)
		    {
			$sortAvg[$i] = $tableTeam[$i]['mpavg'];
		    }

		    array_multisort($sortAvg, SORT_NUMERIC, SORT_DESC, $tableTeam);

		    AssignTables($d, $nTeam, $tableTeam);
		}
	    }
	}
    } //for each day

    //-------------------------------
    //clean up status for 'A' players
    //-------------------------------
    for($s=0; $s<$NumDBPlayers; $s++)
    {
	for($d=0; $d<$SUSNoDays; $d++)
	{
	    if($Status[$s][$d]['status'] == 'A')
	    {
		$Status[$s][$d]['table'] = 0;
		$Status[$s][$d]['tableposn'] = 0;

		$chgpid = $Status[$s][$d]['pid'];
		$_SESSION['changed_pids'][] = $chgpid;
	    }
	}
    }

    //------------------------------------
    //Send Notifications and update ptype
    //------------------------------------
    $cnt = 0;

    for($s=0; $s<$NumDBPlayers; $s++)
    {
	$pid = $Players[$s]['pid'];

	$pNdx = PlayerIndex($pid);
	$statusNdx = StatusIndex($pid);

	$flag = 0;
	$PStat = $Status[$statusNdx][0]['prevstatus'];
	$CStat = $Status[$statusNdx][0]['status'];

	if($CStat === 'P')  //if is playing now then
	{		    //reset any residual cutoff ptype
	    if($Players[$pNdx]['ptype'] == 10)
	    { $Players[$pNdx]['ptype'] = 0; $flag++;}

	    if($Players[$pNdx]['ptype'] == 11)
	    { $Players[$pNdx]['ptype'] = 1; $flag++;}

	    if($flag > 0)
	    {
		$ptype = $Players[$pNdx]['ptype'];
		MyUpdatePType($pid, $ptype);
		$flag = 0;
	    }
	}

	if($PStat != $CStat)
	{

	    if($PStat === 'P')    //if was playing and not now
	    {
		SendNotifications($pid, 0);  //send not playing notice
		$Status[$statusNdx][0]['prevstatus'] = $Status[$statusNdx][0]['status'];

		$chgpid = $Status[$statusNdx][0]['pid'];
		$_SESSION['changed_pids'][] = $chgpid;
		$cnt++;

	    } elseif($CStat === 'P')    //if was not playing then is now
	    {
		SendNotifications($pid, 1);  //send playing notice
		$Status[$statusNdx][0]['prevstatus'] = $Status[$statusNdx][0]['status'];

		$chgpid = $Status[$statusNdx][0]['pid'];
		$_SESSION['changed_pids'][] = $chgpid;
		$cnt++;
	    }	
	}	
    }

    $rc = MyUpdateStatus();

    $_SESSION['gamesperday']  = $GamesPerDay;

    return 0;
}
//--------------------------------------------------------------------------------
function AssignTables($ndxDOP, $nTeam, $tableTeam) {
//  $ndxDOP	=   day index
//  $nTeam	=   Number of teams
//  $tableTeam	=   See DBIndexGlobals.txt in includes for description
//--------------------------------------------------------------------------------
//WriteToLogFile("\nAssignTables($nTeam, $tableTeam)","data");
//echo "
AssignTables: ndxDOP = $ndxDOP nTeam = $nTeam 
";
//print_r($tableTeam);

global $Players;
global $Status;
global $Systemdata;
global $SUSNoDays;
global $SUSTitle;
global $SUSAllowHalfGames;
global $Headings;
global $maxTables;	    //max tables for each day of play

$TablesFileName = $_SESSION['path_tables'];

if(file_exists($TablesFileName) === FALSE)
{
    $Tables = array();

    $nATDays   = $_SESSION['numtabledays'];

    for($i=0; $i<$nATDays; $i++)
	$Tables[$i][0]['table'] = -1;

    $rc = file_put_contents($TablesFileName, serialize($Tables));
    if($rc === FALSE) { echo("
Cannot initialize $TablesFileName"); }

} else {
    $Tables = unserialize(file_get_contents($TablesFileName));

    if($Tables === FALSE)
    {
	$Tables = array();

	$nATDays   = $_SESSION['numtabledays'];
	for($i=0; $i<$nATDays; $i++)
	    $Tables[$i][0]['table'] = -1;
    } else {
	unset($Tables[$ndxDOP]);
	$Tables[$ndxDOP][0]['table'] = -1;
    }
}

$NumDBPlayers = count($Players);

$tableTeam[]	= array();	    //pids of team partners
				    //each[i] has 'pid1','pid2','posn','seq','mpavg'

$d = 0;
$d = $ndxDOP;
$nTables	= intval($nTeam / 2);	    //number of tables
$nHalfTables	= $nTeam % 2;	    //Number of half teams
$nTT = $nTables + $nHalfTables;	    //number of total tables

//$foo = $maxTables[$ndxDOP];
//echo "
ndxDOP=$ndxDOP | Play=$NumDBPlayers | maxTables=$foo | nTeam=$nTeam | nTables=$nTables | nHalfTables=$nHalfTables | nTT=$nTT";

$_SESSION['tablesfull'][$ndxDOP] = 0;

if($nHalfTables == 0 && $nTables >= $maxTables[$ndxDOP])
{
    $_SESSION['tablesfull'][$ndxDOP] = 1;
}

$nt		= 0;		    //current index into $table
$table[]	= array();	    //table assignments [table][0=>NS  1=>EW]
				    //ndx into $tableTeam

$nNS = 0;			    //number of teams requesting NS
$teamNS		= array();	    //NS pairs from $tableTeam

$nEW = 0;			    //number of teams requesting EW
$teamEW		= array();	    //EW pairs from $tableTeam

$nDC = 0;			    //number of teams requesting DC
$teamDC		= array();	    //DC pairs from $tableTeam

    //-----------------------------
    //init $table array to no teams
    //-----------------------------
    for($t=0; $t<$nTT; $t++)
    {
	$table[$t][0] = -1;
	$table[$t][1] = -1;
    
    }

    //------------------------------------------------
    //if only one player pair then don't assign tables
    //------------------------------------------------
    if($nTables <= 0) { return; }

    //------------------------------------------------
    //count each position request and save index to it
    //------------------------------------------------

    for($t=0; $t<$nTeam; $t++)
    {
	switch($tableTeam[$t]['posn'])
	{
	case 0:	    //Don't Care (DC)

	    $teamDC[$nDC++] = $tableTeam[$t];
	    break;

	case 1:	    //NS requested

	    $teamNS[$nNS++] = $tableTeam[$t];
	    break;

	case 2:	    //EW requested

	    $teamEW[$nEW++] = $tableTeam[$t];
	    break;
	}
    }
/*
if($ndxDOP == 0)
{
echo("
\$tableTeam
");
print_r($tableTeam);
echo("
\$teamNS
");
print_r($teamNS);
echo("
\$teamEW
");
print_r($teamEW);
echo("
\$teamDC
");
print_r($teamDC);
echo("
----------------------------------------------------------------");
}
*/
    //------------------------------------------
    //populate NS/EW directions to form tables
    //------------------------------------------

    $moving = 1;
    while($moving > 0)
    {
	if($nNS > $nEW)	    //if there are more NS than EW
	{
	    if($nDC > 0)
	    {   //if there are DCs available
		//move DC -> EW
		$teamEW[$nEW++] = $teamDC[0];
		unset($teamDC[0]);
		$teamDC = array_values($teamDC);
		$nDC = count($teamDC);
		
	    } elseif(($nNS-$nEW) > 1)
	    {   //if there are extra NSs
		//move NS -> EW
		$teamEW[$nEW++] = $teamNS[0];
		unset($teamNS[0]);
		$teamNS = array_values($teamNS);
		$nNS = count($teamNS);
	    } else {
		$moving = 0;
	    }
	} elseif($nEW > $nNS)	    //if there are more EW than NS 
	{
	    if($nDC > 0)
	    {   //if there are DCs available
		//move DC -> NS
		$teamNS[$nNS++] = $teamDC[0];
		unset($teamDC[0]);
		$teamDC = array_values($teamDC);
		$nDC = count($teamDC);
		
	    } elseif(($nEW-$nNS) > 1)
	    {   //if there are extra EWs
		//move EW -> NS
		$teamNS[$nNS++] = $teamEW[0];
		unset($teamEW[0]);
		$teamEW = array_values($teamEW);
		$nEW = count($teamEW);
	    } else {
		$moving = 0;
	    }
	} else {	//if NS == EW
	    if($nDC > 0)
	    {   //if there are DCs available
		//move DC -> NS
		$teamNS[$nNS++] = $teamDC[0];
		unset($teamDC[0]);
		$teamDC = array_values($teamDC);
		$nDC = count($teamDC);
	    } else {
		$moving = 0;
	    }
	}
    }
    //------------------------------------------
    //sort NS/EW directions to match players
    //------------------------------------------
    //--------
    //sort NS
    //--------
    $sortAvg = array();

    for($i=0; $i<$nNS; $i++)
    {
	$sortAvg[$i] = $teamNS[$i]['mpavg'];
    }

    array_multisort($sortAvg, SORT_NUMERIC, SORT_DESC, $teamNS);

//echo "
teamNS
";
//print_r($teamNS);

    //--------
    //sort EW
    //--------
    $sortAvg = array();

    for($i=0; $i<$nEW; $i++)
    {
	$sortAvg[$i] = $teamEW[$i]['mpavg'];
    }

    array_multisort($sortAvg, SORT_NUMERIC, SORT_DESC, $teamEW);

//echo "
teamEW
";
//print_r($teamEW);
    
    //-----------------------------------
    //update the players status database
    //and create $Tables file
    //-----------------------------------

    for($t=0; $t<$nTT; $t++)
    {
	$Tables[$ndxDOP][$t]['table'] = $t+1;

	if($t < $nNS)
	{
	    $pid1ns=$teamNS[$t]['pid1'];
	    $ndxS = StatusIndex($pid1ns);
	    $Status[$ndxS][$d]['table'] = $t+1;
	    $Status[$ndxS][$d]['tableposn'] = 1;

	    $chgpid = $Status[$ndxS][$d]['pid'];
	    $_SESSION['changed_pids'][] = $chgpid;

	    $pid2ns=$teamNS[$t]['pid2'];
	    $ndxS = StatusIndex($pid2ns);
	    $Status[$ndxS][$d]['table'] = $t+1;
	    $Status[$ndxS][$d]['tableposn'] = 1;

	    $chgpid = $Status[$ndxS][$d]['pid'];
	    $_SESSION['changed_pids'][] = $chgpid;
	    
	    //make $Tables entry
	    $Tables[$ndxDOP][$t]['pid1ns'] = $pid1ns;
	    $Tables[$ndxDOP][$t]['pid2ns'] = $pid2ns;
	    $Tables[$ndxDOP][$t]['partns'] = ($Status[$ndxS][$d]['partner'] != 0) ? 1 : 0;
	    $Tables[$ndxDOP][$t]['mpavgns']  = intval($teamNS[$t]['mpavg']);

	}

	if($t <= $nTables)
	{
	    if($t < $nEW)
	    {
		$pid1ew=$teamEW[$t]['pid1'];
		$ndxS = StatusIndex($pid1ew);
		$Status[$ndxS][$d]['table'] = $t+1;
		$Status[$ndxS][$d]['tableposn'] = 2;

		$chgpid = $Status[$ndxS][$d]['pid'];
		$_SESSION['changed_pids'][] = $chgpid;

		$pid2ew=$teamEW[$t]['pid2'];
		$ndxS = StatusIndex($pid2ew);
		$Status[$ndxS][$d]['table'] = $t+1;
		$Status[$ndxS][$d]['tableposn'] = 2;

		$chgpid = $Status[$ndxS][$d]['pid'];
		$_SESSION['changed_pids'][] = $chgpid;

		//make $Tables entry
		$Tables[$ndxDOP][$t]['pid1ew'] = $pid1ew;
		$Tables[$ndxDOP][$t]['pid2ew'] = $pid2ew;
		$Tables[$ndxDOP][$t]['partew'] = ($Status[$ndxS][$d]['partner'] != 0) ? 1 : 0;
		$Tables[$ndxDOP][$t]['mpavgew']  = intval($teamEW[$t]['mpavg']);
	    }

	} else {
	    $Tables[$ndxDOP][$t]['pid1ew'] = -1;
	    $Tables[$ndxDOP][$t]['pid2ew'] = -1;
	    $Tables[$ndxDOP][$t]['partew'] = 0;
	    $Tables[$ndxDOP][$t]['mpavgew'] = 0;
	}
    }

    $rc = file_put_contents($TablesFileName, serialize($Tables));
    if($rc === FALSE) { echo("
Cannot write $TablesFileName"); }

/*
if($ndxDOP == 0)
{
$foo = count($Tables[$ndxDOP]);
echo "
ndxDOP = $ndxDOP   nT = $foo
";
echo "
";
print_r($Tables[$ndxDOP]);
echo "

";
}
*/

/*
$cnt = count($Tables);
echo("
nTables=$cnt
");
print_r($Tables);
print_r($tableTeam);
exit;
*/
}
//--------------------------------------------------------------------------------
function CheckNotifyTime() {
//--------------------------------------------------------------------------------
global $SUSNotifyTime;
global $SUSDOPChgHour;
global $Systemdata;

    if($SUSNotifyTime <= 0) { return 1; }

    //-----------------------------------------------
    //get julian day number from Systemdata database
    //-----------------------------------------------
    $jdPlayers = $Systemdata['jdstart'][0];

    if($jdPlayers <= 0) { return 0; }

    //-----------------------------
    //get today's julian day number
    //-----------------------------
    $jd	    = cal_to_jd(CAL_GREGORIAN,date("m"),date("d"),date("Y"));
    $jdToday    = $jd;

    //------------------------
    //return if today not DOP
    //------------------------
    if($jdToday != $jdPlayers) { return 0; }
    
    //------------------------
    //return if today blocked
    //------------------------
    if($Systemdata['signupblock'][0] != 0) { return 0; }

    //-------------------
    //check notify time
    //-------------------

    //get date/time array
    $da = cal_from_jd($jdPlayers, CAL_GREGORIAN);

    //get unix time for notify
    $nt = $SUSDOPChgHour - $SUSNotifyTime;
    $notifyTime = mktime($nt,0,0,$da['month'],$da['day'],$da['year']);

    //get current time
    $curTime = time();

    if($curTime >= $notifyTime)	//if past notify time
    {
	return 1;
    }

    return 0;
}
//--------------------------------------------------------------------------------
function SendNotifications($pid, $type) {
//--------------------------------------------------------------------------------
global $SUSNoDays;
global $SUSTitle;
global $SUSAdminEmail;
global $SUSNotifyAdmin;
global $SUSNotifyOnOff;
global $Headings;

global $Players;
global $Status;
global $Systemdata;

$flname = array();

    if($SUSNotifyOnOff <= 0) { return; }

    $playerNdx = PlayerIndex($pid);

    $flname = MakeFLName($Players[$playerNdx]['name']);

    //send the admins an email 
    if($SUSNotifyAdmin != 0 && strlen($SUSAdminEmail) > 0)
    {
	if(CheckNotifyTime() != 0)
	{
	    $toAddr = $SUSAdminEmail;
	    //$fromAddr = "postmaster@bridgesignup.com";
	    $fromAddr = "no-reply@bridgesignup.com";
	    $msgTitle = "Notification from $SUSTitle";
	    $stat = ($type == 0) ? '"Not Playing"' : '"Playing"';
	    $msgBody = "$flname: Playing status changed to $stat.";
	    SendSMTPMail($toAddr, $fromAddr, $msgTitle, $msgBody, "");
	    //echo "
SendNotifications: $toAddr, $fromAddr, $msgTitle, $msgBody";
	}
    }

    if($Players[$playerNdx]['login'] == 'Guest' || $Players[$playerNdx]['notify'] == 0) { return; }

    $date = $_SESSION['headings'][0];
    $toAddr = $Players[$playerNdx]['email'];
    //$fromAddr = "postmaster@bridgesignup.com";
    $fromAddr = "no-reply@bridgesignup.com";
    $msgTitle = "Notification from $SUSTitle";
    $msgBody = "$flname, \n";

    if($type == 0)
    {
	$msgBody .= "Your playing status for the next game on $date has changed to \"Not Playing\".";
    } else {
	$msgBody .= "Your playing status for the next game on $date has changed to \"Playing\".";
    }
    $msgFlag = 1;

    SendSMTPMail($toAddr, $fromAddr, $msgTitle, $msgBody, "");
    //echo "
SendNotifications: $toAddr, $fromAddr, $msgTitle, $msgBody";

    return;
}
//--------------------------------------------------------------------------------
//==============PHP End ======================================================== ?>