gridcontrol.cs

英国几乎所有的报纸都刊登数独游戏

				}
			
				int HB=(int)(row/Constants.nbOfLines);
				int VB=(int) (col/Constants.nbOfLines);            
                          
				for(int i=HB*Constants.nbOfLines;i<(HB+1)*Constants.nbOfLines;i++)
				{
					for(int j=VB*Constants.nbOfLines;j<(VB+1)*Constants.nbOfLines;j++)
					{
						if(i!=row && j!=col )
						{
							searchCandidates(i,j);
						}
					}
				}
			}

		}

		/// <summary>
		/// searches candidate nbs for a cell given by row,col 
		/// </summary>
		/// <param name="row">row</param>
		/// <param name="col">column</param>
		public void searchCandidates(int row,int col)
		{
			if(cellGrid[row,col].cellData.problemNb!=Constants.NoNumber)
			{
                cellGrid[row,col].cellData.candidateNb.Clear();
				return;
			}
			
			int HB=(int)(row/Constants.nbOfLines);
			int VB=(int) (col/Constants.nbOfLines);
            
			//clear the existing list
			cellGrid[row,col].cellData.candidateNb.Clear();
            
			
			foreach (int number in new int[9]{1,2,3,4,5,6,7,8,9})
			{
				cellGrid[row,col].cellData.candidateNb.Add(number);
			}                   
            
			for(int i=0;i<9;i++)
			{
				cellGrid[row,col].cellData.candidateNb.Remove(cellGrid[row,i].cellData.problemNb);
				cellGrid[row,col].cellData.candidateNb.Remove(cellGrid[i,col].cellData.problemNb);
			}
                          
			for(int i=HB*Constants.nbOfLines;i<(HB+1)*Constants.nbOfLines;i++)
			{
				for(int j=VB*Constants.nbOfLines;j<(VB+1)*Constants.nbOfLines;j++)
				{
					cellGrid[row,col].cellData.candidateNb.Remove(cellGrid[i,j].cellData.problemNb);                                    
				}
			}			
		}
		
		/// <summary>
		/// Raises all the events related to a game start
		/// </summary>
		private void ExecuteStartGame()
		{
			isGameStarted=true;
			OnStartGame(EventArgs.Empty);		
		}

		/// <summary>
		/// Check if Game has ended
		/// </summary>
		private void CheckEndGame()
		{
			int row,col;
			if(varify(out row,out col))
				OnEndGame(EventArgs.Empty);			
		}

		/// <summary>
		/// Returns true if the current grid follows all rules of su doku else the
		/// Index of wrong entry in the wRow,wCol
		/// </summary>
		/// <param name="wRow"></param>
		/// <param name="wCol"></param>
		/// <returns></returns>
		internal bool varify(out int wRow,out int wCol)
		{
			for(int row=0;row<Constants.nbOfCells;row++)
			{
				for(int col=0;col<Constants.nbOfCells;col++)
				{
					int HB=(int)(row/Constants.nbOfLines);
					int VB=(int) (col/Constants.nbOfLines);
					int nb=cellGrid[row,col].cellData.problemNb;
					if(nb==Constants.NoNumber)
						continue;
					for(int i=0;i<Constants.nbOfCells;i++)
					{
						if((cellGrid[row,i].cellData.problemNb==nb && i!=col) || (cellGrid[i,col].cellData.problemNb ==nb && i!=row))
						{
							wRow=row+1;
							wCol=col+1;
							return false;
						}
					}
                          
					for(int i=HB*3;i<(HB+1)*3;i++)
					{
						for(int j=VB*3;j<(VB+1)*3;j++)
						{
							if(cellGrid[i,j].cellData.problemNb==nb && i!=row && i!=col)
							{
								wRow=row+1;
								wCol=col+1;
								return false;
							}                                    
						}
					}      
				}
			}

			wRow=wCol=Constants.NoNumber;
			return true;
		}

		/// <summary>
		/// Load Data in the Grid 
		/// </summary>
		/// <param name="completeGrid">The complete Grid</param>
		/// <param name="problemGrid">The problem Grid</param>
		public void LoadData(int [,]completeGrid,int [,]problemGrid)
		{
			this.currentlyFilledCells=0;
			for(int row=0;row<Constants.nbOfCells;row++)
			{
				for(int col=0;col<Constants.nbOfCells;col++)
				{
					this.cellGrid[row,col].cellData.originalNb=completeGrid[row,col];
					this.cellGrid[row,col].cellData.problemNb=problemGrid[row,col];
					if(problemGrid[row,col]==Constants.NoNumber)
						this.cellGrid[row,col].cellData.readOnly=false;
					else 
					{
						this.cellGrid[row,col].cellData.readOnly=true;
						this.currentlyFilledCells++;
					}
					this.cellGrid[row,col].CheckedNbs.Clear();
				}
			}
			
			for(int row=0;row<Constants.nbOfCells;row++)
			 {
				 for(int col=0;col<Constants.nbOfCells;col++)
				 {
					 searchCandidates(row,col);
				 }
			 }

            this.redrawBool=true;
			Invalidate();
		}

		/// <summary>
		/// Save game to file
		/// </summary>
		/// <param name="fileName">name of file to save</param>
		public  void SaveGameToFile( string fileName)
		{
			XmlTextWriter xtw = new XmlTextWriter(fileName,System.Text.UTF8Encoding.UTF8);

			xtw.WriteStartDocument();
			/*tw.WriteStartElement("mapConfiguration");

			// save map info
			//tw.WriteStartElement("mapInfo");

			//tw.WriteStartAttribute("mapType", string.Empty);
			//tw.WriteRaw(mapType.ToString());
			//tw.WriteEndAttribute();

			tw.WriteStartAttribute("cellNumber", string.Empty);
			tw.WriteRaw(mapData.CellDataArray.GetLength(0).ToString());
			tw.WriteEndAttribute();

			tw.WriteStartAttribute("currentTime", string.Empty);
			tw.WriteRaw(time.ToString());
			tw.WriteEndAttribute();

			tw.WriteEndElement();
			*/

			// save map data
			xtw.WriteStartElement("mapData");
			
			string checkedNbStr;
			//int cellsNumber = mapData.CellDataArray.GetLength(0);
			for (int row=0 ; row<Constants.nbOfCells ; row++)
			{
				for (int col=0 ; col<Constants.nbOfCells ; col++)
				{
					xtw.WriteStartElement("Data");

					// original nb attribute
					xtw.WriteStartAttribute("originalNumber", string.Empty);
					xtw.WriteRaw(cellGrid[row,col].cellData.originalNb.ToString());
					xtw.WriteEndAttribute();

					
					// read only attribute
					xtw.WriteStartAttribute("readonly", string.Empty);
					xtw.WriteRaw(cellGrid[row,col].cellData.readOnly.ToString());
					xtw.WriteEndAttribute();

					// selected number attribute
					xtw.WriteStartAttribute("problemNumber", string.Empty);
					xtw.WriteRaw(cellGrid[row,col].cellData.problemNb.ToString());
					xtw.WriteEndAttribute();

					// marked values attribute
					xtw.WriteStartAttribute("checkedNumbers", string.Empty);
					
					checkedNbStr= "";
					for (int k=0 ; k< cellGrid[row,col].CheckedNbs.Count; k++)
					{
						checkedNbStr+=((int)cellGrid[row,col].CheckedNbs[k]).ToString();
					}

					xtw.WriteRaw(checkedNbStr);
					
					//xtw.WriteEndAttribute();

					xtw.WriteEndElement();
				}
			}

			xtw.WriteEndElement();
			xtw.Close();
		}

		/// <summary>
		/// Load game data from file
		/// </summary>
		/// <param name="fileName">name of file to be loaded</param>
		public  void LoadGameFromFile(string fileName)
		{
			// check that file exists
			if(!File.Exists(fileName))
			{
				MessageBox.Show("The specified does not exist","Error"); 
				return;
			}
			
			try
			{
				this.currentlyFilledCells=0;
				System.Xml.XmlDocument xdoc = new XmlDocument();
				xdoc.Load(fileName);
				XmlElement root = xdoc.DocumentElement;
				System.Xml.XmlNodeList nodeList;
				//System.Xml.XmlNode node;
				
				//time = Convert.ToInt32(node.Attributes["currentTime"].Value);

				// load map data
			
				nodeList = root.ChildNodes;//.Item(0).ChildNodes;
				
				bool readOnly=false;;
				int onb=0,pnb=0;
				int k=0;
      			string checkedNbStr;
				
				for (int row=0 ; row<Constants.nbOfCells ; row++)
				{
					for (int col=0 ; col<Constants.nbOfCells ; col++)
					{
						readOnly=Convert.ToBoolean(nodeList.Item(k).Attributes["readonly"].Value);
						pnb= Convert.ToInt32(nodeList.Item(k).Attributes["problemNumber"].Value);
						onb=Convert.ToInt32(nodeList.Item(k).Attributes["originalNumber"].Value);

                        //check for invalid nb
						if((!Constants.validNbs.Contains(onb) && onb !=Constants.NoNumber)
							|| (!Constants.validNbs.Contains(pnb) && pnb !=Constants.NoNumber) )
                            throw new Exception();				
						
						cellGrid[row,col].cellData.readOnly =readOnly;
						cellGrid[row,col].cellData.problemNb=pnb;
						cellGrid[row,col].cellData.originalNb= onb;

						if(pnb!=Constants.NoNumber)
						{
							this.currentlyFilledCells++;
						}

						checkedNbStr = Convert.ToString(nodeList.Item(k).Attributes["checkedNumbers"].Value);
						
						cellGrid[row,col].CheckedNbs.Clear();
						for (int m=0 ; m<checkedNbStr.Length ;m++)
						{
							cellGrid[row,col].CheckedNbs.Add(Convert.ToInt32(checkedNbStr[m].ToString()));
						}
						k++;
					}
				}
				for(int row=0;row<Constants.nbOfCells;row++)
				{
					for(int col=0;col<Constants.nbOfCells;col++)
					{
						searchCandidates(row,col);
					}
				}
				redrawBool=true;
				Invalidate();
				this.Enabled=true;
			}
			catch(Exception ex)
			{
				MessageBox.Show("The File "+fileName+" is corrupt\n"+ex.Message,"Error");
				return;
			}
		}

		public void showNext()
		{
			for(int row=0;row<Constants.nbOfCells;row++)
			{
				for(int col=0;col<Constants.nbOfCells;col++)
				{
				   if(cellGrid[row,col].cellData.problemNb!=Constants.NoNumber)
				    	continue;
					int HB=(int)(row/Constants.nbOfLines);
					int VB=(int) (col/Constants.nbOfLines);
					if(cellGrid[row,col].cellData.candidateNb.Count==1)
					{						
						cellGrid[row,col].cellData.problemNb=(int)cellGrid[row,col].cellData.candidateNb[0];
						currentlyFilledCells++;
						autoUpdateMarkedCandidates(row,col);
						redrawBool=true;
						Invalidate();
						return;						
					}
						
					else   //find nb that cannot come into any cell of that block
					{
						for(int index=0;index<cellGrid[row,col].cellData.candidateNb.Count;index++)
						{
							int number=(int)cellGrid[row,col].cellData.candidateNb[index];
							bool found=false;
							for(int i=HB*Constants.nbOfLines;i<(HB+1)*Constants.nbOfLines;i++)                                
								for(int j=VB*Constants.nbOfLines;j<(VB+1)*Constants.nbOfLines;j++)                                    
									if(cellGrid[i,j].cellData.candidateNb.Contains(number) && !(i==row && j==col))
									{
										j=(VB+1)*Constants.nbOfLines; //exit from loop
										i=(HB+1)*Constants.nbOfLines;
										found =true;
									}                                   
							if(found)
								continue;
							else
							{
								//	MessageBox.Show("nb found");
								//the candidate  nb is found                                   
								cellGrid[row,col].cellData.problemNb=number;								
								//cellGrid[row,col].cellData.candidateNb.Clear();
								autoUpdateMarkedCandidates(row,col);
								currentlyFilledCells++;
								redrawBool=true;
								Invalidate();
								return;
							}
						}											
					}
					
				}
			}
		}
	}
}