                                                              
r͈̈́   1`9999v 5sǍs1000s                                                              OPTIONESP                  ö́2003/12/14 11:41
 OLD      NEW 
E:\tools\}[W\MJSim_000200\MJSim\MJSim.cpp                      2003/12/13 00:18 FILE E:\tools\}[W\MJSim_000300\MJSim\MJSim.cpp                      2003/12/14 09:22
STATUS
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9      ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                              
                                                                                                                                                                                          
#include "stdafx.h"                                                                             #include "stdafx.h"                                                                       
#include "Mahjong.h"                                                                            #include "Mahjong.h"                                                                      
#include "Hantei.h"                                                                             #include "Hantei.h"                                                                       
#include "MJSim.h"                                                                              #include "MJSim.h"                                                                        
                                                                                                                                                                                          
//擾                                                                                      //擾                                                                                
//Kyoku:ǁAIndex:ʒu                                                                      //Kyoku:ǁAIndex:ʒu                                                                
int GetZikaze(int Index, int Kyoku){return (Index + 4 - (Kyoku % 4)) % 4;}                      int GetZikaze(int Index, int Kyoku){return (Index + 4 - (Kyoku % 4)) % 4;}                
//z̍Ō̈ʒu擾                                                                        //z̍Ō̈ʒu擾                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S001)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
// * ͂̍Ō̈ʒu/擾 GetLastIndex(MJGAME::Kawa)                                  ύX // * ͂̍Ō̈ʒu/擾 GetLastIndex(MJTAKU::Kawa)                                 
// * R̎cc擾 GetLastIndex(MJGAME::Tsumo)                                        ύX // * R̎cc擾 GetLastIndex(MJTAKU::Tsumo)                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E001)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
int GetLastIndex(int *Data)                                                                     int GetLastIndex(int *Data)                                                               
{                                                                                               {                                                                                         
	for(int i = 0; Data[i] != 0; i++);                                                             	for(int i = 0; Data[i] != 0; i++);                                                       
	return i;                                                                                      	return i;                                                                                
}                                                                                               }                                                                                         
//J̐擾                                                                                //J̐擾                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S002)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
int GetKanNum(MJGAME *Game)                                                                ύX int GetKanNum(MJTAKU *Taku)                                                               
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E002)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
{                                                                                               {                                                                                         
	int k = 0;                                                                                     	int k = 0;                                                                               
	for(int i = 0; i < 4; i++){                                                                    	for(int i = 0; i < 4; i++){                                                              
		for(int j = 0; j < 4; j++){                                                                   		for(int j = 0; j < 4; j++){                                                             
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S003)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
			switch(Game->Player[i].Furo[j].Type){                                                   ύX 			switch(Taku->Player[i].Furo[j].Type){                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E003)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
			case MJFORO_ANKAN:case MJFORO_MINKAN:k++;                                                    			case MJFORO_ANKAN:case MJFORO_MINKAN:k++;                                              
			}                                                                                            			}                                                                                      
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
	return k;                                                                                      	return k;                                                                                
}                                                                                               }                                                                                         
//t[擾                                                                                  //t[擾                                                                            
int GetFuroNum(MJFURO *Furo)                                                                    int GetFuroNum(MJFURO *Furo)                                                              
{                                                                                               {                                                                                         
	for(int i = 0; i < 4; i++){                                                                    	for(int i = 0; i < 4; i++){                                                              
                                                                                              
//̎                                                                                //̎                                                                          
int GetSeed()                                                                                   int GetSeed()                                                                             
{                                                                                               {                                                                                         
	GUID guid;                                                                                     	GUID guid;                                                                               
	CoCreateGuid(&guid);                                                                           	CoCreateGuid(&guid);                                                                     
	int seed = guid.Data1 + guid.Data2 + guid.Data3;                                               	int seed = guid.Data1 + guid.Data2 + guid.Data3;                                         
	for(int i = 0; i < 8; i++){seed += guid.Data4[i];}                                             	for(int i = 0; i < 8; i++){seed += guid.Data4[i];}                                       
	return seed;                                                                                   	return seed;                                                                             
}                                                                                               }                                                                                         
//\                                                                                        //\                                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S004)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
void TakuDisp(int Msg, int Index, MJGAME *Game);                                           ύX void TakuDisp(int Msg, int Index, MJTAKU *Taku);                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E004)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
//オ_vZNX                                                                            //オ_vZNX                                                                      
//MahjongNXg                                                                     //MahjongNXg                                                               
class CMJAgari{                                                                                 class CMJAgari{                                                                           
	Mahjong m_MJ;                                                                                  	Mahjong m_MJ;                                                                            
	bool m_IsRon;                                                                                  	bool m_IsRon;                                                                            
public:                                                                                         public:                                                                                   
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S005)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJGAME *m_Game;                                                                           ύX 	MJTAKU *m_Taku;                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E005)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
private:                                                                                        private:                                                                                  
	void ConvetTehai(int Index, bool IsRon);                                                       	void ConvetTehai(int Index, bool IsRon);                                                 
public:                                                                                         public:                                                                                   
	bool Calc(int Index, bool IsRon);	//vZs                                                   	bool Calc(int Index, bool IsRon);	//vZs                                             
	int Fu(){return (int)m_MJ.m_Yaku.fu;}                                                          	int Fu(){return (int)m_MJ.m_Yaku.fu;}                                                    
	int Han(){return (int)m_MJ.m_Yaku.fan;}                                                        	int Han(){return (int)m_MJ.m_Yaku.fan;}                                                  
	int Score(){return (int)m_MJ.m_Yaku.score;}                                                    	int Score(){return (int)m_MJ.m_Yaku.score;}                                              
	int YakuNum(){return m_MJ.m_Yaku.YakuNum();}                                                   	int YakuNum(){return m_MJ.m_Yaku.YakuNum();}                                             
	string YakuName(int Index){return ::GetYakuName(m_MJ.m_Yaku.GetYaku(Index));}                  	string YakuName(int Index){return ::GetYakuName(m_MJ.m_Yaku.GetYaku(Index));}            
	bool IsRon(){return m_IsRon;}                                                                  	bool IsRon(){return m_IsRon;}                                                            
                                                                                              
};                                                                                              };                                                                                        
bool CMJAgari::Calc(int Index, bool IsRon)                                                      bool CMJAgari::Calc(int Index, bool IsRon)                                                
{                                                                                               {                                                                                         
	m_IsRon = IsRon;                                                                               	m_IsRon = IsRon;                                                                         
	m_MJ.Init();	//                                                                          	m_MJ.Init();	//                                                                    
	ConvetTehai(Index, IsRon);                                                                     	ConvetTehai(Index, IsRon);                                                               
	return m_MJ.YHM_YakuHantei(IsRon) ? true : false;	//_vZs                               	return m_MJ.YHM_YakuHantei(IsRon) ? true : false;	//_vZs                         
}                                                                                               }                                                                                         
void CMJAgari::ConvetTehai(int Index, bool IsRon)                                               void CMJAgari::ConvetTehai(int Index, bool IsRon)                                         
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S006)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game->Player[Index];                                                ύX 	MJPLAYER *Player = &m_Taku->Player[Index];                                               
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E006)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	m_MJ.m_Tehai.Reset();                                                                          	m_MJ.m_Tehai.Reset();                                                                    
	                                                                                               	                                                                                         
	m_MJ.m_Tehai.is_menzen = GetFuroNum(Player->Furo) == 0 ? TRUE : FALSE;                         	m_MJ.m_Tehai.is_menzen = GetFuroNum(Player->Furo) == 0 ? TRUE : FALSE;                   
	m_MJ.m_Tehai.is_ron = IsRon;                                                                   	m_MJ.m_Tehai.is_ron = IsRon;                                                             
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S007)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_MJ.m_Tehai.jikaze = GetZikaze(Index, m_Game->Kyoku);                                    ύX 	m_MJ.m_Tehai.jikaze = GetZikaze(Index, m_Taku->Kyoku);                                   
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E007)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	//v̕ϊ                                                                                   	//v̕ϊ                                                                             
	int ConvertHai[] = {                                                                           	int ConvertHai[] = {                                                                     
		0,0,1,2,3,4,5,6,7,8,                                                                          		0,0,1,2,3,4,5,6,7,8,                                                                    
		0,9,10,11,12,13,14,15,16,17,                                                                  		0,9,10,11,12,13,14,15,16,17,                                                            
		0,18,19,20,21,22,23,24,25,26,                                                                 		0,18,19,20,21,22,23,24,25,26,                                                           
		0,27,0,28,0,29,0,30,0,0,                                                                      		0,27,0,28,0,29,0,30,0,0,                                                                
		0,31,0,32,0,33                                                                                		0,31,0,32,0,33                                                                          
	};                                                                                             	};                                                                                       
	int TehaiNum = 0;                                                                              	int TehaiNum = 0;                                                                        
                                                                                              
	//(v낤Ƃ邽)                                                                   	//(v낤Ƃ邽)                                                             
	for(i = 1; i < 4; i++){                                                                        	for(i = 1; i < 4; i++){                                                                  
		switch(Player->Furo[i].Type){                                                                 		switch(Player->Furo[i].Type){                                                           
		case MJFORO_CHI:	m_MJ.m_Tehai.AddChi(Player->Furo[i].Hai);break;                              		case MJFORO_CHI:	m_MJ.m_Tehai.AddChi(Player->Furo[i].Hai);break;                        
		case MJFORO_PON:	m_MJ.m_Tehai.AddPon(Player->Furo[i].Hai);break;                              		case MJFORO_PON:	m_MJ.m_Tehai.AddPon(Player->Furo[i].Hai);break;                        
		case MJFORO_MINKAN:	m_MJ.m_Tehai.AddMinkan(Player->Furo[i].Hai);break;                        		case MJFORO_MINKAN:	m_MJ.m_Tehai.AddMinkan(Player->Furo[i].Hai);break;                  
		case MJFORO_ANKAN:	m_MJ.m_Tehai.AddAnkan(Player->Furo[i].Hai);break;                          		case MJFORO_ANKAN:	m_MJ.m_Tehai.AddAnkan(Player->Furo[i].Hai);break;                    
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S008)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_MJ.m_Bakaze = m_Game->Kyoku % 4;                                                        ύX 	m_MJ.m_Bakaze = m_Taku->Kyoku % 4;                                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E008)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_MJ.m_IsHaitei = FALSE;                                                                       	m_MJ.m_IsHaitei = FALSE;                                                                 
	m_MJ.m_IsRinshan = FALSE;                                                                      	m_MJ.m_IsRinshan = FALSE;                                                                
	m_MJ.m_IsChankan = FALSE;                                                                      	m_MJ.m_IsChankan = FALSE;                                                                
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S009)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	for(i = 0; i < GetKanNum(m_Game); i++){                                                   ύX 	for(i = 0; i < GetKanNum(m_Taku); i++){                                                  
		m_MJ.YHM_SetDoraIndicator(i, m_Game->Yama[4 + i]);                                       ύX 		m_MJ.YHM_SetDoraIndicator(i, m_Taku->Yama[4 + i]);                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E009)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
int CMJAgari::GetShanten(int Index)                                                             int CMJAgari::GetShanten(int Index)                                                       
{                                                                                               {                                                                                         
	ConvetTehai(Index, FALSE);                                                                     	ConvetTehai(Index, FALSE);                                                               
	return Hantei::CalcShantenValue(m_MJ.m_Tehai);                                                 	return Hantei::CalcShantenValue(m_MJ.m_Tehai);                                           
}                                                                                               }                                                                                         
//vC[AI                                                                                  //vC[AI                                                                            
class CMJAI{                                                                                    class CMJAI{                                                                              
public:                                                                                         public:                                                                                   
	string m_Name;                                                                                 	string m_Name;                                                                           
	int m_Index;	//ǂɍĂ邩B0:NƁ`                                                    	int m_Index;	//ǂɍĂ邩B0:NƁ`                                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S010)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJGAME *m_Game;                                                                           ύX 	MJTAKU *m_Taku;                                                                          
	MJGAME m_GameCopy;                                                                        ύX 	MJTAKU m_TakuCopy;                                                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E010)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	HINSTANCE m_AI;	//DLLnh                                                                  	HINSTANCE m_AI;	//DLLnh                                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S011)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	typedef void (*AIACTION)(int, int, MJGAME*);                                              ύX 	typedef void (*AIACTION)(int, int, MJTAKU*);                                             
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E011)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	AIACTION AIAction;	//֐ւ̃|C^                                                          	AIACTION AIAction;	//֐ւ̃|C^                                                    
	                                                                                               	                                                                                         
	~CMJAI(){FreeLibrary(m_AI);}                                                                   	~CMJAI(){FreeLibrary(m_AI);}                                                             
	void Load(int Number);	//DLL[h                                                       	void Load(int Number);	//DLL[h                                                 
	void Action(int Msg);                                                                          	void Action(int Msg);                                                                    
};                                                                                              };                                                                                        
void CMJAI::Action(int Msg)                                                                     void CMJAI::Action(int Msg)                                                               
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S012)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	memcpy(&m_GameCopy, m_Game, sizeof(MJGAME));                                              ύX 	memcpy(&m_TakuCopy, m_Taku, sizeof(MJTAKU));                                             
	m_GameCopy.Tsumo = m_GameCopy.Yama + (m_Game->Tsumo - m_Game->Yama);                      ύX 	m_TakuCopy.Tsumo = m_TakuCopy.Yama + (m_Taku->Tsumo - m_Taku->Yama);                     
	AIAction(Msg, m_Index, &m_GameCopy);                                                      ύX 	AIAction(Msg, m_Index, &m_TakuCopy);                                                     
	memcpy(&m_Game->Player[m_Index].Action,                                                   ύX 	memcpy(&m_Taku->Player[m_Index].Action,                                                  
		&m_GameCopy.Player[m_Index].Action, sizeof(MJACTION));                                   ύX 		&m_TakuCopy.Player[m_Index].Action, sizeof(MJACTION));                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E012)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
}                                                                                               }                                                                                         
void CMJAI::Load(int Number)                                                                    void CMJAI::Load(int Number)                                                              
{                                                                                               {                                                                                         
	stringstream key;                                                                              	stringstream key;                                                                        
	char buf[256];                                                                                 	char buf[256];                                                                           
                                                                                                                                                                                          
	key << "AI" << Number;	//L[                                                                	key << "AI" << Number;	//L[                                                          
	GetPrivateProfileString("AI", key.str().c_str(), "", buf, 256, ".\\MJSim.ini");                	GetPrivateProfileString("AI", key.str().c_str(), "", buf, 256, ".\\MJSim.ini");          
	if(buf[0] == NULL){                                                                            	if(buf[0] == NULL){                                                                      
		cout << "init@C̓ǂݍ݂Ɏs܂B:" << key.str() << endl;                        		cout << "init@C̓ǂݍ݂Ɏs܂B:" << key.str() << endl;                  
                                                                                              
	if(m_AI == NULL){                                                                              	if(m_AI == NULL){                                                                        
		cout << "DLL[hł܂B:" << buf << endl;                                            		cout << "DLL[hł܂B:" << buf << endl;                                      
		throw;                                                                                        		throw;                                                                                  
	}                                                                                              	}                                                                                        
	AIAction = (AIACTION)GetProcAddress(m_AI, "AIAction");                                         	AIAction = (AIACTION)GetProcAddress(m_AI, "AIAction");                                   
	if(AIAction == NULL){                                                                          	if(AIAction == NULL){                                                                    
		cout << "DLLAIAction֐܂B" << buf << endl;                                     		cout << "DLLAIAction֐܂B" << buf << endl;                               
		throw;                                                                                        		throw;                                                                                  
	}                                                                                              	}                                                                                        
	m_Name = buf;                                                                                  	m_Name = buf;                                                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S013)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
}                                                                                          ύX 	cout << buf << " OK" << endl;                                                            
//V~[^                                                                         ύX }                                                                                         
class CMJSim{                                                                              ύX //V~[^                                                                        
	MJGAME m_Game;                                                                            ύX class CMJSim{                                                                             
	CMJAI *m_AI[4];                                                                           ύX 	MJTAKU m_Taku;                                                                           
                                                                                           ǉ 	CMJAI *m_AI[4];	//AI͂ʂăANZXBQ[̏ꏊɑΉ邽         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E013)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	CMJAI m_AIInstance[4];                                                                         	CMJAI m_AIInstance[4];                                                                   
	CMJAgari m_Agari;                                                                              	CMJAgari m_Agari;                                                                        
	fstream m_File;                                                                                	fstream m_File;                                                                          
	vector<int> m_Log;                                                                             	vector<int> m_Log;                                                                       
	//C̊֐                                                                                 	//C̊֐                                                                           
	void Game();	//Jn                                                                      	void Game();	//Jn                                                                
	void Kyoku();	//ǊJn                                                                         	void Kyoku();	//ǊJn                                                                   
	void Reaction();	//̂Ĕvɑ΂郊ANV                                                  	void Reaction();	//̂Ĕvɑ΂郊ANV                                            
	//ANV̏                                                                             	//ANV̏                                                                       
	void Agari(int Index, bool IsRon);                                                             	void Agari(int Index, bool IsRon);                                                       
	void Sutehai(int Index);                                                                       	void Sutehai(int Index);                                                                 
	void Richi(int Index);                                                                         	void Richi(int Index);                                                                   
	void Ankan(int Index);                                                                         	void Ankan(int Index);                                                                   
	void Kakan(int Index);                                                                         	void Kakan(int Index);                                                                   
	void Minkan(int Index);                                                                        	void Minkan(int Index);                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S014)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	void Pon(int Index);                                                                      ύX 	void Rinsyan(int Index);                                                                 
	void Chi(int Index);                                                                      ύX 	void Pon(int Index);                                                                     
	void Ryukyoku();                                                                          ύX 	void Chi(int Index);                                                                     
	void Action(int Index, int ActionType);                                                   ύX 	void Ryukyoku();                                                                         
                                                                                           ǉ 	void Action(int Index);                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E014)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	//ANV`FbN                                                                           	//ANV`FbN                                                                     
	void CheckActionForTsumo(int Index);                                                           	void CheckActionForTsumo(int Index);                                                     
	void CheckSutehai(int Index);                                                                  	void CheckSutehai(int Index);                                                            
	void CheckAnkan(int Index);                                                                    	void CheckAnkan(int Index);                                                              
	void CheckKakan(int Index);                                                                    	void CheckKakan(int Index);                                                              
	void CheckActionForReaction(int Index);                                                        	void CheckActionForReaction(int Index);                                                  
	void CheckMinkan(int Index);                                                                   	void CheckMinkan(int Index);                                                             
	void CheckPon(int Index);                                                                      	void CheckPon(int Index);                                                                
	void CheckChi(int Index);                                                                      	void CheckChi(int Index);                                                                
	//̑                                                                                       	//̑                                                                                 
                                                                                              
		MJAGARI_RYUKYOKU,                                                                             		MJAGARI_RYUKYOKU,                                                                       
		MJAGARI_AGARI,                                                                                		MJAGARI_AGARI,                                                                          
		MJAGARI_CHONBO                                                                                		MJAGARI_CHONBO                                                                          
	};                                                                                             	};                                                                                       
public:                                                                                         public:                                                                                   
	CMJSim();                                                                                      	CMJSim();                                                                                
	void Run();                                                                                    	void Run();                                                                              
};                                                                                              };                                                                                        
CMJSim::CMJSim()                                                                                CMJSim::CMJSim()                                                                          
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S015)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_Agari.m_Game = &m_Game;                                                                 ύX 	m_Agari.m_Taku = &m_Taku;                                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E015)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	m_File.open("MJSimScore.txt", ios::out);                                                       	m_File.open("MJSimScore.txt", ios::out);                                                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S016)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	//debug {͌֒ǉ                                                              ύX 	//֒ǉꍇ                                                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E016)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	//m_File.open("MJSimScore.txt", ios::out | ios::app);                                          	//m_File.open("MJSimScore.txt", ios::out | ios::app);                                    
    if(m_File.is_open() == 0){                                                                      if(m_File.is_open() == 0){                                                            
		cout << "t@CJ܂B";                                                             		cout << "t@CJ܂B";                                                       
		throw;                                                                                        		throw;                                                                                  
	}                                                                                              	}                                                                                        
	//AI[h                                                                               	//AI[h                                                                         
	for(int i = 0; i < 4; i++){m_AIInstance[i].Load(i);}                                           	for(int i = 0; i < 4; i++){m_AIInstance[i].Load(i);}                                     
}                                                                                               }                                                                                         
void CMJSim::Run()                                                                              void CMJSim::Run()                                                                        
{                                                                                               {                                                                                         
	int i = 1;                                                                                     	int i = 1;                                                                               
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S017)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	while(1){                                                                                 ύX 	while(true){                                                                             
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E017)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		cout << i++;                                                                                  		cout << i++;                                                                            
		Game();                                                                                       		Game();                                                                                 
		cout << endl;                                                                                 		cout << endl;                                                                           
		if(GetKeyState(VK_SHIFT) < 0){break;}                                                         		if(GetKeyState(VK_SHIFT) < 0){break;}                                                   
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::Game()                                                                             void CMJSim::Game()                                                                       
{                                                                                               {                                                                                         
	int i;                                                                                         	int i;                                                                                   
	//Q[f[^                                                                           	//Q[f[^                                                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S018)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	memset(&m_Game, 0, sizeof(m_Game));                                                       ύX 	memset(&m_Taku, 0, sizeof(m_Taku));                                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E018)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	//ꏊ                                                                                     	//ꏊ                                                                               
	for(i = 0; i < 4; i++){m_AI[i] = &m_AIInstance[i];}                                            	for(i = 0; i < 4; i++){m_AI[i] = &m_AIInstance[i];}                                      
	srand(GetSeed());                                                                              	srand(GetSeed());                                                                        
	for(i = 0; i < 4; i++){swap(m_AI[i], m_AI[rand() % 4]);}                                       	for(i = 0; i < 4; i++){swap(m_AI[i], m_AI[rand() % 4]);}                                 
                                                                                                                                                                                          
	//ꏊ܂̂Ńf[^Zbg                                                             	//ꏊ܂̂Ńf[^Zbg                                                       
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
		//AĨf[^Zbg                                                                          		//AĨf[^Zbg                                                                    
		m_AI[i]->m_Index = i;                                                                         		m_AI[i]->m_Index = i;                                                                   
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S019)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_AI[i]->m_Game = &m_Game;                                                               ύX 		m_AI[i]->m_Taku = &m_Taku;                                                              
		//MJGAMẼvC[f[^Zbg                                                     ύX 		//MJTAKŨvC[f[^Zbg                                                    
		m_Game.Player[i].Score = 27000;                                                          ύX 		m_Taku.Player[i].Score = 27000;                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E019)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
                                                                                                                                                                                          
	LogGameStart();                                                                                	LogGameStart();                                                                          
	CallAllAI(MJMSG_GAMESTART);                                                                    	CallAllAI(MJMSG_GAMESTART);                                                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S020)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	while(m_Game.Kyoku < 4){                                                                  ύX 	while(m_Taku.Kyoku < 4){                                                                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E020)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		LogKyokuStart();                                                                              		LogKyokuStart();                                                                        
		try{                                                                                          		try{                                                                                    
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S021)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                           ǉ 			InitKyoku();                                                                           
                                                                                           ǉ 			CallAllAI(MJMSG_KYOKUSTART);                                                           
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E021)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
			Kyoku();                                                                                     			Kyoku();                                                                               
		}                                                                                             		}                                                                                       
		catch(int Msg){                                                                               		catch(int Msg){                                                                         
			//オċǂIƂ̓Lb`B                                                   			//オċǂIƂ̓Lb`B                                             
			//G[͖                                                                               			//G[͖                                                                         
			Msg = 0;	//x߂̃_~[R[h                                                      			Msg = 0;	//x߂̃_~[R[h                                                
		}                                                                                             		}                                                                                       
		LogKyokuEnd();                                                                                		LogKyokuEnd();                                                                          
		CallAllAI(MJMSG_KYOKUEND);                                                                    		CallAllAI(MJMSG_KYOKUEND);                                                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S022)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_Game.Kyoku++;                                                                          ύX 		m_Taku.Kyoku++;                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E022)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		cout << ".";                                                                                  		cout << ".";                                                                            
	}                                                                                              	}                                                                                        
	CalcGameScore();                                                                               	CalcGameScore();                                                                         
	LogGameEnd();                                                                                  	LogGameEnd();                                                                            
	CallAllAI(MJMSG_GAMEEND);                                                                      	CallAllAI(MJMSG_GAMEEND);                                                                
}                                                                                               }                                                                                         
void CMJSim::InitKyoku()                                                                        void CMJSim::InitKyoku()                                                                  
{                                                                                               {                                                                                         
	m_Log.clear();                                                                                 	m_Log.clear();                                                                           
                                                                                                                                                                                          
	int score[4];                                                                                  	int score[4];                                                                            
	int i;                                                                                         	int i;                                                                                   
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S023)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		score[i] = m_Game.Player[i].Score;                                                       ύX 		score[i] = m_Taku.Player[i].Score;                                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E023)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S024)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	memset(&m_Game.Player, 0, sizeof(MJPLAYER) * 4);                                          ύX 	memset(&m_Taku.Player, 0, sizeof(MJPLAYER) * 4);                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E024)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S025)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_Game.Player[i].Score = score[i];                                                       ύX 		m_Taku.Player[i].Score = score[i];                                                      
		strcpy(m_Game.Player[i].Name, m_AI[i]->m_Name.c_str());                                  ύX 		strcpy(m_Taku.Player[i].Name, m_AI[i]->m_Name.c_str());                                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E025)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S026)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_Game.Turn = m_Game.Kyoku % 4;	//c͒N                                          ύX 	m_Taku.Turn = m_Taku.Kyoku % 4;	//c͒N                                         
	m_Game.Tsumo = &m_Game.Yama[14];	//cJnʒu                                           ύX 	m_Taku.Tsumo = &m_Taku.Yama[14];	//cJnʒu                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E026)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	//Rς                                                                                     	//Rς                                                                               
	int hai[] = {	1,2,3,4,5,6,7,8,9,                                                               	int hai[] = {	1,2,3,4,5,6,7,8,9,                                                         
					11,12,13,14,15,16,17,18,19,                                                                					11,12,13,14,15,16,17,18,19,                                                          
					21,22,23,24,25,26,27,28,29,                                                                					21,22,23,24,25,26,27,28,29,                                                          
					31,33,35,37,                                                                               					31,33,35,37,                                                                         
					41,43,45};                                                                                 					41,43,45};                                                                           
	for(i = 0; i < 4; i++){	//34̔v4Rs[                                                  	for(i = 0; i < 4; i++){	//34̔v4Rs[                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S027)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		memcpy(m_Game.Yama + i * 34, hai, sizeof(hai));                                          ύX 		memcpy(m_Taku.Yama + i * 34, hai, sizeof(hai));                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E027)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	//܂                                                                                       	//܂                                                                                 
	srand(GetSeed());                                                                              	srand(GetSeed());                                                                        
	for(i = 0; i < 136; i++){                                                                      	for(i = 0; i < 136; i++){                                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S028)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		swap(m_Game.Yama[i], m_Game.Yama[rand() % 136]);                                         ύX 		swap(m_Taku.Yama[i], m_Taku.Yama[rand() % 136]);                                        
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E028)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	//zv΂                                                                                 	//zv΂                                                                           
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
		for(int j = 0; j < 13; j++){                                                                  		for(int j = 0; j < 13; j++){                                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S029)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
			m_Game.Player[i].Tehai[*m_Game.Tsumo]++;                                                ύX 			m_Taku.Player[i].Tehai[*m_Taku.Tsumo]++;                                               
			m_Game.Tsumo++;                                                                         ύX 			m_Taku.Tsumo++;                                                                        
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E029)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::Kyoku()                                                                            void CMJSim::Kyoku()                                                                      
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S030)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	InitKyoku();                                                                              ύX 	//Ō̃c܂Ń[v                                                                   
	CallAllAI(MJMSG_KYOKUSTART);                                                              ύX 	while(*m_Taku.Tsumo != 0){                                                               
                                                                                           ύX 		MJPLAYER *Player = &m_Taku.Player[m_Taku.Turn];                                         
	//Ō̃c܂Ń[v                                                                    ύX 		//c                                                                                  
	while(*m_Game.Tsumo != 0){                                                                ύX 		LogHaifu(m_Taku.Turn, MJACTION_TSUMO, *m_Taku.Tsumo);                                   
		MJPLAYER *Player = &m_Game.Player[m_Game.Turn];                                          ύX 		Player->Tsumo = *m_Taku.Tsumo;                                                          
		//c                                                                                   ύX 		m_Taku.Tsumo++;                                                                         
		LogHaifu(m_Game.Turn, MJACTION_TSUMO, *m_Game.Tsumo);                                    ύX                                                                                           
		Player->Tsumo = *m_Game.Tsumo;                                                           ύX 		//R}hCɑ\                                                          
		m_Game.Tsumo++;                                                                          ύX 		//TakuDisp(MJMSG_TSUMO, m_Taku.Turn, &m_Taku);                                          
		//R}hCɑ\                                                           ύX 		                                                                                        
		//TakuDisp(MJMSG_TSUMO, m_Game.Turn, &m_Game);                                           ύX 		m_AI[m_Taku.Turn]->Action(MJMSG_TSUMO);	//ʒm                                          
		m_AI[m_Game.Turn]->Action(MJMSG_TSUMO);	//ʒm                                           ύX 		CheckActionForTsumo(m_Taku.Turn);	//ANV`FbN                                
		//[`΂łȂΈꔭ                                                 ύX 		Action(m_Taku.Turn);	//ANVs                                                 
		if(Player->Action.Type != MJACTION_RICHI){Player->Ippatsu = false;}                      ύX 		//[`΂łȂΈꔭ                                                
                                                                                           ύX 		if(Player->Action.Type != MJACTION_RICHI){Player->Ippatsu = false;}                     
		CheckActionForTsumo(m_Game.Turn);	//ANV`FbN                                 ύX 		                                                                                        
		Action(m_Game.Turn, Player->Action.Type);	//ANVs                             ύX 		Reaction();	//̂Ĕvɑ΂ẴANV                                              
		                                                                                         ύX 		m_Taku.Turn++; m_Taku.Turn %= 4;	//̃vC[ɉ                                 
		Reaction();	//̂Ĕvɑ΂ẴANV                                               폜                                                                                           
		m_Game.Turn++; m_Game.Turn %= 4;	//̃vC[ɉ                                  폜                                                                                           
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E030)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	//                                                                                         	//                                                                                   
	Ryukyoku();                                                                                    	Ryukyoku();                                                                              
}                                                                                               }                                                                                         
void CMJSim::Reaction()                                                                         void CMJSim::Reaction()                                                                   
{                                                                                               {                                                                                         
	CallAllAI(MJMSG_REACTION);	//Sɒʒm                                                        	CallAllAI(MJMSG_REACTION);	//Sɒʒm                                                  
	int i;                                                                                         	int i;                                                                                   
	//wꂽANV`FbN                                                               	//wꂽANV`FbN                                                         
	for(i = 0; i < 4; i++){CheckActionForReaction(i);}                                             	for(i = 0; i < 4; i++){CheckActionForReaction(i);}                                       
                                                                                                                                                                                          
	//v̂ĂvC[猩ċ߂ƂDɂ                                             	//v̂ĂvC[猩ċ߂ƂDɂ                                       
	int index[4];                                                                                  	int index[4];                                                                            
	//Turn̎index[0]ɂȂ悤ɂ                                                           	//Turn̎index[0]ɂȂ悤ɂ                                                     
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S031)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		index[i] = (m_Game.Turn + i + 1) % 4;                                                    ύX 		index[i] = (m_Taku.Turn + i + 1) % 4;                                                   
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E031)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	int r = index[0];	//̂Ĕvɑ΂ăANVNvC[                               	int r = index[0];	//̂Ĕvɑ΂ăANVNvC[                         
	//Dx̍ANV̗p                                                                 	//Dx̍ANV̗p                                                           
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S032)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		if(m_Game.Player[r].Action.Type < m_Game.Player[index[i]].Action.Type){                  ύX 		if(m_Taku.Player[r].Action.Type < m_Taku.Player[index[i]].Action.Type){                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E032)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
			r = index[r];                                                                                			r = index[r];                                                                          
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
	//NANVH                                                                   	//NANVH                                                             
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S033)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	if(m_Game.Player[r].Action.Type != MJACTION_NULL){                                        ύX 	if(m_Taku.Player[r].Action.Type != MJACTION_NULL){                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E033)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		//̗pANVs                                                                    		//̗pANVs                                                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S034)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		Action(r, m_Game.Player[r].Action.Type);                                                 ύX 		Action(r);                                                                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E034)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		//ꔭ                                                                                  		//ꔭ                                                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S035)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		for(i = 0; i < 4; i++){m_Game.Player[i].Ippatsu = false;}                                ύX 		for(i = 0; i < 4; i++){m_Taku.Player[i].Ippatsu = false;}                               
		m_Game.Turn = r;	//^[AvC[ɐݒ                                      ύX 		m_Taku.Turn = r;	//^[AvC[ɐݒ                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E035)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		Reaction();	//ċA                                                                        		Reaction();	//ċA                                                                  
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S036)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
void CMJSim::Action(int Index, int ActionType)                                             ύX void CMJSim::Action(int Index)                                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E036)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S037)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	switch(ActionType){                                                                       ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
                                                                                           ǉ 	switch(Player->Action.Type){                                                             
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E037)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	case MJACTION_NULL:	break;                                                                     	case MJACTION_NULL:	break;                                                               
	case MJACTION_TSUMOAGARI:	Agari(Index, false);break;                                           	case MJACTION_TSUMOAGARI:	Agari(Index, false);break;                                     
	case MJACTION_ANKAN:	Ankan(Index);break;                                                       	case MJACTION_ANKAN:	Ankan(Index);break;                                                 
	case MJACTION_KAKAN:	Kakan(Index);break;                                                       	case MJACTION_KAKAN:	Kakan(Index);break;                                                 
	case MJACTION_RICHI:	Richi(Index);break;                                                       	case MJACTION_RICHI:	Richi(Index);break;                                                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S038)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	case MJACTION_SUTEHAI:	Sutehai(m_Game.Turn);break;                                        ύX 	case MJACTION_SUTEHAI:	Sutehai(m_Taku.Turn);break;                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E038)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	case MJACTION_RON:	Agari(Index, true);break;                                                   	case MJACTION_RON:	Agari(Index, true);break;                                             
	case MJACTION_PON:	Pon(Index);break;                                                           	case MJACTION_PON:	Pon(Index);break;                                                     
	case MJACTION_CHI:	Chi(Index);break;                                                           	case MJACTION_CHI:	Chi(Index);break;                                                     
	case MJACTION_MINKAN:	Minkan(Index);break;                                                     	case MJACTION_MINKAN:	Minkan(Index);break;                                               
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::CheckActionForReaction(int Index)                                                  void CMJSim::CheckActionForReaction(int Index)                                            
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S039)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E039)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	switch(Player->Action.Type){                                                                   	switch(Player->Action.Type){                                                             
	case MJACTION_NULL:	break;                                                                     	case MJACTION_NULL:	break;                                                               
	case MJACTION_RON:	break;	//ȂBオĂȂƂ̓`{                           	case MJACTION_RON:	break;	//ȂBオĂȂƂ̓`{                     
	case MJACTION_MINKAN:	CheckMinkan(Index);break;                                                	case MJACTION_MINKAN:	CheckMinkan(Index);break;                                          
	case MJACTION_PON:	CheckPon(Index);break;                                                      	case MJACTION_PON:	CheckPon(Index);break;                                                
	case MJACTION_CHI:	CheckChi(Index);break;                                                      	case MJACTION_CHI:	CheckChi(Index);break;                                                
	default:                                                                                       	default:                                                                                 
		Player->Action.Type = MJACTION_NULL;                                                          		Player->Action.Type = MJACTION_NULL;                                                    
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::CheckChi(int Index)                                                                void CMJSim::CheckChi(int Index)                                                          
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S040)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = m_Game.Player[m_Game.Turn].Kawa[GetLastIndex(m_Game.Player[m_Game.Turn].Kawa) - ύX 	int hai = m_Taku.Player[m_Taku.Turn].Kawa[GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa) -
 1];                                                                                        --   1];                                                                                      
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E040)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	Player->Tehai[hai]++;	//vvɉ                                                 	Player->Tehai[hai]++;	//vvɉ                                           
	if(Player->Action.Hosoku < 1 ||                                                                	if(Player->Action.Hosoku < 1 ||                                                          
			Player->Action.Hosoku + 1 < 1 ||                                                             			Player->Action.Hosoku + 1 < 1 ||                                                       
			Player->Action.Hosoku + 2 < 1){                                                              			Player->Action.Hosoku + 2 < 1){                                                        
		//`[ɕKvȔvȂꍇAȂ                                                		//`[ɕKvȔvȂꍇAȂ                                          
		Player->Action.Type = MJACTION_NULL;                                                          		Player->Action.Type = MJACTION_NULL;                                                    
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::CheckPon(int Index)                                                                void CMJSim::CheckPon(int Index)                                                          
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S041)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = m_Game.Player[m_Game.Turn].Kawa[GetLastIndex(m_Game.Player[m_Game.Turn].Kawa) - ύX 	int hai = m_Taku.Player[m_Taku.Turn].Kawa[GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa) -
 1];                                                                                        --   1];                                                                                      
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E041)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	if(Player->Tehai[hai] < 2){                                                                    	if(Player->Tehai[hai] < 2){                                                              
		//|ɕKvȔvȂꍇAȂ                                                		//|ɕKvȔvȂꍇAȂ                                          
		Player->Action.Type = MJACTION_NULL;                                                          		Player->Action.Type = MJACTION_NULL;                                                    
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::CheckMinkan(int Index)                                                             void CMJSim::CheckMinkan(int Index)                                                       
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S042)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = m_Game.Player[m_Game.Turn].Kawa[GetLastIndex(m_Game.Player[m_Game.Turn].Kawa) - ύX 	int hai = m_Taku.Player[m_Taku.Turn].Kawa[GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa) -
 1];                                                                                        --   1];                                                                                      
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E042)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	if(Player->Tehai[hai] < 3){                                                                    	if(Player->Tehai[hai] < 3){                                                              
		//JɕKvȔvȂꍇAȂ                                              		//JɕKvȔvȂꍇAȂ                                        
		Player->Action.Type = MJACTION_NULL;                                                          		Player->Action.Type = MJACTION_NULL;                                                    
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::CheckActionForTsumo(int Index)                                                     void CMJSim::CheckActionForTsumo(int Index)                                               
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S043)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E043)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	switch(Player->Action.Type){                                                                   	switch(Player->Action.Type){                                                             
	case MJACTION_TSUMOAGARI:	break;	//ȂBオĂȂƂ̓`{                    	case MJACTION_TSUMOAGARI:	break;	//ȂBオĂȂƂ̓`{              
	case MJACTION_ANKAN:	CheckAnkan(Index);break;                                                  	case MJACTION_ANKAN:	CheckAnkan(Index);break;                                            
	case MJACTION_KAKAN:	CheckKakan(Index);break;                                                  	case MJACTION_KAKAN:	CheckKakan(Index);break;                                            
	case MJACTION_RICHI:	CheckSutehai(Index);break;	//epCǂ͊mFȂBm[e       	case MJACTION_RICHI:	CheckSutehai(Index);break;	//epCǂ͊mFȂBm[e 
	case MJACTION_SUTEHAI:	CheckSutehai(Index);break;                                              	case MJACTION_SUTEHAI:	CheckSutehai(Index);break;                                        
	default:                                                                                       	default:                                                                                 
		Player->Action.Type = MJACTION_SUTEHAI;                                                       		Player->Action.Type = MJACTION_SUTEHAI;                                                 
		Player->Action.Sutehai = 0;                                                                   		Player->Action.Sutehai = 0;                                                             
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::CheckAnkan(int Index)                                                              void CMJSim::CheckAnkan(int Index)                                                        
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S044)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E044)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = Player->Action.Hosoku;                                                               	int hai = Player->Action.Hosoku;                                                         
                                                                                                                                                                                          
	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                         	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                   
	if(Player->Tehai[hai] < 4){                                                                    	if(Player->Tehai[hai] < 4){                                                              
		//JłȂꍇAc؂ɂ                                                            		//JłȂꍇAc؂ɂ                                                      
		Player->Action.Type = MJACTION_SUTEHAI;                                                       		Player->Action.Type = MJACTION_SUTEHAI;                                                 
		Player->Action.Sutehai = 0;                                                                   		Player->Action.Sutehai = 0;                                                             
	}                                                                                              	}                                                                                        
	Player->Tehai[Player->Tsumo]--;                                                                	Player->Tehai[Player->Tsumo]--;                                                          
}                                                                                               }                                                                                         
void CMJSim::CheckKakan(int Index)                                                              void CMJSim::CheckKakan(int Index)                                                        
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S045)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E045)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = Player->Action.Hosoku;                                                               	int hai = Player->Action.Hosoku;                                                         
	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                         	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                   
                                                                                                                                                                                          
	//J|T                                                                       	//J|T                                                                 
	int FuroIndex = -1;                                                                            	int FuroIndex = -1;                                                                      
	for(int i = 0; i < 4; i++){                                                                    	for(int i = 0; i < 4; i++){                                                              
		if(Player->Furo[i].Type == MJFORO_PON && Player->Furo[i].Hai == hai){                         		if(Player->Furo[i].Type == MJFORO_PON && Player->Furo[i].Hai == hai){                   
			FuroIndex = i;break;                                                                         			FuroIndex = i;break;                                                                   
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
	if(FuroIndex == -1 || Player->Tehai[hai] < 1){                                                 	if(FuroIndex == -1 || Player->Tehai[hai] < 1){                                           
		//JłȂꍇAc؂ɂ                                                            		//JłȂꍇAc؂ɂ                                                      
		Player->Action.Type = MJACTION_SUTEHAI;                                                       		Player->Action.Type = MJACTION_SUTEHAI;                                                 
		Player->Action.Sutehai = 0;                                                                   		Player->Action.Sutehai = 0;                                                             
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::CheckSutehai(int Index)                                                            void CMJSim::CheckSutehai(int Index)                                                      
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S046)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E046)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	if(Player->Action.Sutehai != 0 && Player->Tehai[Player->Action.Sutehai] < 1){                  	if(Player->Action.Sutehai != 0 && Player->Tehai[Player->Action.Sutehai] < 1){            
		//c؂ȊOŁA̔vĂȂꍇAc؂                                          		//c؂ȊOŁA̔vĂȂꍇAc؂                                    
		Player->Action.Type = MJACTION_SUTEHAI;                                                       		Player->Action.Type = MJACTION_SUTEHAI;                                                 
		Player->Action.Sutehai = 0;                                                                   		Player->Action.Sutehai = 0;                                                             
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::Agari(int Index, bool IsRon)                                                       void CMJSim::Agari(int Index, bool IsRon)                                                 
{                                                                                               {                                                                                         
	if(IsRon){                                                                                     	if(IsRon){                                                                               
		//vvɉ                                                                        		//vvɉ                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S047)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		int hai = m_Game.Player[m_Game.Turn].Kawa[GetLastIndex(m_Game.Player[m_Game.Turn].Kawa)  ύX 		int hai = m_Taku.Player[m_Taku.Turn].Kawa[GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa) 
- 1];                                                                                       --  - 1];                                                                                     
		m_Game.Player[Index].Tsumo = hai;                                                        ύX 		m_Taku.Player[Index].Tsumo = hai;                                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E047)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		LogHaifu(Index, MJACTION_RON);                                                                		LogHaifu(Index, MJACTION_RON);                                                          
	}                                                                                              	}                                                                                        
	else{                                                                                          	else{                                                                                    
		LogHaifu(Index, MJACTION_TSUMOAGARI);                                                         		LogHaifu(Index, MJACTION_TSUMOAGARI);                                                   
	}                                                                                              	}                                                                                        
	//オ_vZ                                                                           	//オ_vZ                                                                     
	//KyokuScore͒PɑȂ                                                               	//KyokuScore͒PɑȂ                                                         
	//[`œ_Ăꍇ                                                           	//[`œ_Ăꍇ                                                     
	if(m_Agari.Calc(Index, IsRon)){                                                                	if(m_Agari.Calc(Index, IsRon)){                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S048)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_Game.AgariType = MJAGARI_AGARI;                                                        ύX 		m_Taku.AgariType = MJAGARI_AGARI;                                                       
		m_Game.Player[Index].KyokuScore += (m_Game.RichiboNum * 1000);	//[`_                ύX 		m_Taku.Player[Index].KyokuScore += (m_Taku.RichiboNum * 1000);	//[`_               
		m_Game.RichiboNum = 0;                                                                   ύX 		m_Taku.RichiboNum = 0;                                                                  
		m_Game.Player[Index].KyokuScore += (m_Game.TsumiboNum * 300);	//ςݖ_                   ύX 		m_Taku.Player[Index].KyokuScore += (m_Taku.TsumiboNum * 300);	//ςݖ_                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E048)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
		if(IsRon){	//                                                                             		if(IsRon){	//                                                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S049)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
			m_Game.Player[Index].KyokuScore += m_Agari.Score();                                     ύX 			m_Taku.Player[Index].KyokuScore += m_Agari.Score();                                    
			m_Game.Player[m_Game.Turn].KyokuScore -= m_Agari.Score();                               ύX 			m_Taku.Player[m_Taku.Turn].KyokuScore -= m_Agari.Score();                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E049)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		}                                                                                             		}                                                                                       
		else{	//debug c                                                                            		else{	//debug c                                                                      
			for(int i = 0; i < 4; i++){                                                                  			for(int i = 0; i < 4; i++){                                                            
				if(Index == i){	//オvC[                                                        				if(Index == i){	//オvC[                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S050)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
					m_Game.Player[i].KyokuScore += m_Agari.Score();                                       ύX 					m_Taku.Player[i].KyokuScore += m_Agari.Score();                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E050)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
				}                                                                                           				}                                                                                     
				else{                                                                                       				else{                                                                                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S051)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
					if(GetZikaze(Index, m_Game.Kyoku) == 0){//オvC[e                      ύX 					if(GetZikaze(Index, m_Taku.Kyoku) == 0){//オvC[e                     
						m_Game.Player[i].KyokuScore -= m_Agari.Score() / 3;                                  ύX 						m_Taku.Player[i].KyokuScore -= m_Agari.Score() / 3;                                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E051)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
					}                                                                                          					}                                                                                    
					else{	//q̏ꍇ                                                                           					else{	//q̏ꍇ                                                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S052)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
						if(GetZikaze(i, m_Game.Kyoku) == 0){	//ȅꍇ                                      ύX 						if(GetZikaze(i, m_Taku.Kyoku) == 0){	//ȅꍇ                                     
							m_Game.Player[i].KyokuScore -= m_Agari.Score() / 2;                                 ύX 							m_Taku.Player[i].KyokuScore -= m_Agari.Score() / 2;                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E052)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
						}                                                                                         						}                                                                                   
						else{                                                                                     						else{                                                                               
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S053)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
							m_Game.Player[i].KyokuScore -= m_Agari.Score() / 4;                                 ύX 							m_Taku.Player[i].KyokuScore -= m_Agari.Score() / 4;                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E053)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
						}                                                                                         						}                                                                                   
					}                                                                                          					}                                                                                    
				}                                                                                           				}                                                                                     
			}                                                                                            			}                                                                                      
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
	else{	//`{                                                                               	else{	//`{                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S054)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_Game.AgariType = MJAGARI_CHONBO;                                                       ύX 		m_Taku.AgariType = MJAGARI_CHONBO;                                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E054)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	//Z                                                                                         	//Z                                                                                   
	for(int i = 0; i < 4; i++){                                                                    	for(int i = 0; i < 4; i++){                                                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S055)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_Game.Player[i].Score += m_Game.Player[i].KyokuScore;                                   ύX 		m_Taku.Player[i].Score += m_Taku.Player[i].KyokuScore;                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E055)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	throw 1;	//オƂ͗O1𑗂                                                     	throw 1;	//オƂ͗O1𑗂                                               
}                                                                                               }                                                                                         
void CMJSim::Ryukyoku()                                                                         void CMJSim::Ryukyoku()                                                                   
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S056)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_Game.AgariType = MJAGARI_RYUKYOKU;                                                      ύX 	m_Taku.AgariType = MJAGARI_RYUKYOKU;                                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E056)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int table[5][2] = {                                                                            	int table[5][2] = {                                                                      
		{0,0},			//epC0l                                                                      		{0,0},			//epC0l                                                                
		{3000,-1000},	//1l                                                                           		{3000,-1000},	//1l                                                                     
		{1500,-1500},                                                                                 		{1500,-1500},                                                                           
		{1000,-3000},                                                                                 		{1000,-3000},                                                                           
		{0,0},                                                                                        		{0,0},                                                                                  
	};                                                                                             	};                                                                                       
	//epCĂlJEg                                                               	//epCĂlJEg                                                         
	int i, TenpaiNum = 0;                                                                          	int i, TenpaiNum = 0;                                                                    
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
		if(m_Agari.GetShanten(i) == 0){TenpaiNum++;}                                                  		if(m_Agari.GetShanten(i) == 0){TenpaiNum++;}                                            
	}                                                                                              	}                                                                                        
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
		int IsTenpai = m_Agari.GetShanten(i) == 0 ? 0 : 1;	//epCȂ0                            		int IsTenpai = m_Agari.GetShanten(i) == 0 ? 0 : 1;	//epCȂ0                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S057)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_Game.Player[i].KyokuScore += table[TenpaiNum][IsTenpai];                               ύX 		m_Taku.Player[i].KyokuScore += table[TenpaiNum][IsTenpai];                              
		m_Game.Player[i].Score += m_Game.Player[i].KyokuScore;                                   ύX 		m_Taku.Player[i].Score += m_Taku.Player[i].KyokuScore;                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E057)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
void CMJSim::Richi(int Index)                                                                   void CMJSim::Richi(int Index)                                                             
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S058)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
	Player->RichiIndex = GetLastIndex(m_Game.Player[m_Game.Turn].Kawa);                       ύX 	Player->RichiIndex = GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa);                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E058)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	Player->Ippatsu = true;                                                                        	Player->Ippatsu = true;                                                                  
	Player->KyokuScore -= 1000;	//ǃXRA1000_                                           	Player->KyokuScore -= 1000;	//ǃXRA1000_                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S059)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_Game.RichiboNum++;                                                                      ύX 	m_Taku.RichiboNum++;                                                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E059)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	LogHaifu(Index, MJACTION_RICHI);                                                               	LogHaifu(Index, MJACTION_RICHI);                                                         
                                                                                                                                                                                          
	Sutehai(Index);                                                                                	Sutehai(Index);                                                                          
}                                                                                               }                                                                                         
void CMJSim::Pon(int Index)                                                                     void CMJSim::Pon(int Index)                                                               
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S060)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = m_Game.Player[m_Game.Turn].Kawa[GetLastIndex(m_Game.Player[m_Game.Turn].Kawa) - ύX 	int hai = m_Taku.Player[m_Taku.Turn].Kawa[GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa) -
 1];                                                                                        --   1];                                                                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E060)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	LogHaifu(Index, MJACTION_PON);                                                                 	LogHaifu(Index, MJACTION_PON);                                                           
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S061)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E061)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	Player->Tehai[hai] -= 2;	//v폜                                                        	Player->Tehai[hai] -= 2;	//v폜                                                  
	int FuroIndex = GetFuroNum(Player->Furo);                                                      	int FuroIndex = GetFuroNum(Player->Furo);                                                
	Player->Furo[FuroIndex].Type = MJFORO_PON;                                                     	Player->Furo[FuroIndex].Type = MJFORO_PON;                                               
	Player->Furo[FuroIndex].Hai = hai;                                                             	Player->Furo[FuroIndex].Hai = hai;                                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S062)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	Player->Furo[FuroIndex].Hosoku = m_Game.Turn;	//ǂ                          ύX 	Player->Furo[FuroIndex].Hosoku = m_Taku.Turn;	//ǂ                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E062)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	Sutehai(Index);                                                                                	Sutehai(Index);                                                                          
}                                                                                               }                                                                                         
void CMJSim::Minkan(int Index)                                                                  void CMJSim::Minkan(int Index)                                                            
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S063)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = m_Game.Player[m_Game.Turn].Kawa[GetLastIndex(m_Game.Player[m_Game.Turn].Kawa) - ύX 	int hai = m_Taku.Player[m_Taku.Turn].Kawa[GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa) -
 1];                                                                                        --   1];                                                                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E063)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	LogHaifu(Index, MJACTION_MINKAN, hai);                                                         	LogHaifu(Index, MJACTION_MINKAN, hai);                                                   
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S064)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E064)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	Player->Tehai[hai] -= 3;	//v폜                                                        	Player->Tehai[hai] -= 3;	//v폜                                                  
	int FuroIndex = GetFuroNum(Player->Furo);                                                      	int FuroIndex = GetFuroNum(Player->Furo);                                                
	Player->Furo[FuroIndex].Type = MJFORO_MINKAN;                                                  	Player->Furo[FuroIndex].Type = MJFORO_MINKAN;                                            
	Player->Furo[FuroIndex].Hai = hai;                                                             	Player->Furo[FuroIndex].Hai = hai;                                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S065)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	Player->Furo[FuroIndex].Hosoku = m_Game.Turn;	//ǂ                          ύX 	Player->Furo[FuroIndex].Hosoku = m_Taku.Turn;	//ǂ                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E065)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S066)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	//V                                                                              ύX 	Rinsyan(Index);                                                                          
	Player->Tsumo = m_Game.Yama[GetKanNum(&m_Game)];                                          ύX }                                                                                         
	Player->Rinsyan = true;                                                                   ύX void CMJSim::Ankan(int Index)                                                             
                                                                                           ύX {                                                                                         
	m_Game.Turn = Index;                                                                      ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
	m_AI[m_Game.Turn]->Action(MJMSG_TSUMO);	//ʒm                                            폜                                                                                           
	//AIɎwꂽANVs                                                          폜                                                                                           
	Action(m_Game.Turn, m_Game.Player[m_Game.Turn].Action.Type);                              폜                                                                                           
	Player->Rinsyan = false;                                                                  폜                                                                                           
}                                                                                          폜                                                                                           
void CMJSim::Ankan(int Index)                                                              폜                                                                                           
{                                                                                          폜                                                                                           
	MJPLAYER *Player = &m_Game.Player[Index];                                                 폜                                                                                           
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E066)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = Player->Action.Hosoku;                                                               	int hai = Player->Action.Hosoku;                                                         
	LogHaifu(Index, MJACTION_ANKAN, hai);                                                          	LogHaifu(Index, MJACTION_ANKAN, hai);                                                    
                                                                                                                                                                                          
	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                         	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                   
	Player->Tehai[hai] -= 4;	//v폜                                                        	Player->Tehai[hai] -= 4;	//v폜                                                  
	if(hai != Player->Tsumo){	//Jvƃc֌WȂꍇAcv폜                       	if(hai != Player->Tsumo){	//Jvƃc֌WȂꍇAcv폜                 
		Player->Tehai[Player->Tsumo]--;                                                               		Player->Tehai[Player->Tsumo]--;                                                         
	}                                                                                              	}                                                                                        
	int FuroIndex = GetFuroNum(Player->Furo);                                                      	int FuroIndex = GetFuroNum(Player->Furo);                                                
	Player->Furo[FuroIndex].Type = MJFORO_ANKAN;                                                   	Player->Furo[FuroIndex].Type = MJFORO_ANKAN;                                             
	Player->Furo[FuroIndex].Hai = hai;                                                             	Player->Furo[FuroIndex].Hai = hai;                                                       
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S067)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	//V                                                                              ύX 	Rinsyan(Index);                                                                          
	Player->Tsumo = m_Game.Yama[GetKanNum(&m_Game)];                                          ύX }                                                                                         
	Player->Rinsyan = true;                                                                   ύX void CMJSim::Kakan(int Index)                                                             
                                                                                           ύX {                                                                                         
	m_AI[m_Game.Turn]->Action(MJMSG_TSUMO);	//ʒm                                            ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
	//AIɎwꂽANVs                                                          폜                                                                                           
	Action(m_Game.Turn, m_Game.Player[m_Game.Turn].Action.Type);                              폜                                                                                           
	Player->Rinsyan = false;                                                                  폜                                                                                           
}                                                                                          폜                                                                                           
void CMJSim::Kakan(int Index)                                                              폜                                                                                           
{                                                                                          폜                                                                                           
	MJPLAYER *Player = &m_Game.Player[Index];                                                 폜                                                                                           
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E067)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int hai = Player->Action.Hosoku;                                                               	int hai = Player->Action.Hosoku;                                                         
	LogHaifu(Index, MJACTION_KAKAN, hai);                                                          	LogHaifu(Index, MJACTION_KAKAN, hai);                                                    
	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                         	Player->Tehai[Player->Tsumo]++;	//cvvɉ                                   
                                                                                                                                                                                          
	//J|T                                                                       	//J|T                                                                 
	int FuroIndex = -1;                                                                            	int FuroIndex = -1;                                                                      
	for(int i = 0; i < 4; i++){                                                                    	for(int i = 0; i < 4; i++){                                                              
		if(Player->Furo[i].Type == MJFORO_PON && Player->Furo[i].Hai == hai){                         		if(Player->Furo[i].Type == MJFORO_PON && Player->Furo[i].Hai == hai){                   
			FuroIndex = i;break;                                                                         			FuroIndex = i;break;                                                                   
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
	Player->Furo[FuroIndex].Type = MJFORO_MINKAN;                                                  	Player->Furo[FuroIndex].Type = MJFORO_MINKAN;                                            
	Player->Furo[FuroIndex].Hai = hai;                                                             	Player->Furo[FuroIndex].Hai = hai;                                                       
                                                                                                                                                                                          
	Player->Tehai[hai]--;	//v폜                                                           	Player->Tehai[hai]--;	//v폜                                                     
	if(hai != Player->Tsumo){	//Jvƃc֌WȂꍇAcv폜                       	if(hai != Player->Tsumo){	//Jvƃc֌WȂꍇAcv폜                 
		Player->Tehai[Player->Tsumo]--;                                                               		Player->Tehai[Player->Tsumo]--;                                                         
	}                                                                                              	}                                                                                        
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S068)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                           ύX 	Rinsyan(Index);                                                                          
	//V                                                                              ύX }                                                                                         
	Player->Tsumo = m_Game.Yama[GetKanNum(&m_Game)];                                          ύX void CMJSim::Rinsyan(int Index)                                                           
	Player->Rinsyan = true;                                                                   ύX {                                                                                         
                                                                                           ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
	m_AI[m_Game.Turn]->Action(MJMSG_TSUMO);	//ʒm                                            ύX 	Player->Tsumo = m_Taku.Yama[GetKanNum(&m_Taku)];                                         
	//AIɎwꂽANVs                                                          ύX 	Player->Rinsyan = true;                                                                  
	Action(m_Game.Turn, m_Game.Player[m_Game.Turn].Action.Type);                              ύX 	m_Taku.Turn = Index;	//^[JvC[ɐݒ                                  
	Player->Rinsyan = false;                                                                  ύX                                                                                           
}                                                                                          ύX 	m_AI[m_Taku.Turn]->Action(MJMSG_TSUMO);	//ʒm                                           
void CMJSim::Chi(int Index)                                                                ύX 	CheckActionForTsumo(m_Taku.Turn);	//ANV`FbN                                 
{                                                                                          ύX 	Action(m_Taku.Turn);	//AIɎwꂽANVs                                    
	int hai = m_Game.Player[m_Game.Turn].Kawa[GetLastIndex(m_Game.Player[m_Game.Turn].Kawa) - ύX 	Player->Rinsyan = false;                                                                 
 1];                                                                                        --                                                                                            
                                                                                           ύX }                                                                                         
	//v폜                                                                            ύX void CMJSim::Chi(int Index)                                                               
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX {                                                                                         
                                                                                           ǉ 	int hai = m_Taku.Player[m_Taku.Turn].Kawa[GetLastIndex(m_Taku.Player[m_Taku.Turn].Kawa) -
                                                                                            --   1];                                                                                      
                                                                                           ǉ                                                                                           
                                                                                           ǉ 	//v폜                                                                           
                                                                                           ǉ 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E068)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int FuroIndex = GetFuroNum(Player->Furo);                                                      	int FuroIndex = GetFuroNum(Player->Furo);                                                
	for(int i = 0; i < 3; i++){                                                                    	for(int i = 0; i < 3; i++){                                                              
		if(hai != Player->Action.Hosoku + i){                                                         		if(hai != Player->Action.Hosoku + i){                                                   
			//vȊOv폜                                                             			//vȊOv폜                                                       
			Player->Tehai[Player->Action.Hosoku + i]--;                                                  			Player->Tehai[Player->Action.Hosoku + i]--;                                            
		}                                                                                             		}                                                                                       
		else{                                                                                         		else{                                                                                   
			//3̔v̓AԖڂvZbg                                                			//3̔v̓AԖڂvZbg                                          
			Player->Furo[FuroIndex].Hosoku = i;                                                          			Player->Furo[FuroIndex].Hosoku = i;                                                    
		}                                                                                             		}                                                                                       
                                                                                              
	switch(Player->Furo[FuroIndex].Hosoku){                                                        	switch(Player->Furo[FuroIndex].Hosoku){                                                  
	case 0:	LogHaifu(Index, MJACTION_CHI, Player->Action.Hosoku + 1, Player->Action.Hosoku +       	case 0:	LogHaifu(Index, MJACTION_CHI, Player->Action.Hosoku + 1, Player->Action.Hosoku + 
	case 1:	LogHaifu(Index, MJACTION_CHI, Player->Action.Hosoku + 0, Player->Action.Hosoku +       	case 1:	LogHaifu(Index, MJACTION_CHI, Player->Action.Hosoku + 0, Player->Action.Hosoku + 
	case 2:	LogHaifu(Index, MJACTION_CHI, Player->Action.Hosoku + 0, Player->Action.Hosoku +       	case 2:	LogHaifu(Index, MJACTION_CHI, Player->Action.Hosoku + 0, Player->Action.Hosoku + 
	}                                                                                              	}                                                                                        
                                                                                                                                                                                          
	Sutehai(Index);                                                                                	Sutehai(Index);                                                                          
}                                                                                               }                                                                                         
void CMJSim::Sutehai(int Index)                                                                 void CMJSim::Sutehai(int Index)                                                           
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S069)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	MJPLAYER *Player = &m_Game.Player[Index];                                                 ύX 	MJPLAYER *Player = &m_Taku.Player[Index];                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E069)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	                                                                                               	                                                                                         
	//c؂                                                                                     	//c؂                                                                               
	if(Player->Action.Sutehai == 0){                                                               	if(Player->Action.Sutehai == 0){                                                         
		LogHaifu(Index, MJACTION_SUTEHAI_TSUMOGIRI, Player->Tsumo);                                   		LogHaifu(Index, MJACTION_SUTEHAI_TSUMOGIRI, Player->Tsumo);                             
		Player->Kawa[GetLastIndex(Player->Kawa)] = Player->Tsumo;                                     		Player->Kawa[GetLastIndex(Player->Kawa)] = Player->Tsumo;                               
		Player->Tsumo = 0;                                                                            		Player->Tsumo = 0;                                                                      
	}                                                                                              	}                                                                                        
	else{                                                                                          	else{                                                                                    
		LogHaifu(Index, MJACTION_SUTEHAI, Player->Action.Sutehai);                                    		LogHaifu(Index, MJACTION_SUTEHAI, Player->Action.Sutehai);                              
		Player->Kawa[GetLastIndex(Player->Kawa)] = Player->Action.Sutehai;                            		Player->Kawa[GetLastIndex(Player->Kawa)] = Player->Action.Sutehai;                      
                                                                                              
	//p1,p2̓|C^ւ̃|C^                                                                  	//p1,p2̓|C^ւ̃|C^                                                            
	//~ɕׂ                                                                                 	//~ɕׂ                                                                           
	return (*(MJPLAYER**)p2)->Score - (*(MJPLAYER**)p1)->Score;                                    	return (*(MJPLAYER**)p2)->Score - (*(MJPLAYER**)p1)->Score;                              
}                                                                                               }                                                                                         
void CMJSim::CalcGameScore()                                                                    void CMJSim::CalcGameScore()                                                              
{                                                                                               {                                                                                         
	//\[g                                                                                   	//\[g                                                                             
	MJPLAYER *p[4];                                                                                	MJPLAYER *p[4];                                                                          
	int i;                                                                                         	int i;                                                                                   
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S070)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		p[i] = &m_Game.Player[i];                                                                ύX 		p[i] = &m_Taku.Player[i];                                                               
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E070)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	qsort((void*)p, 4, sizeof(MJPLAYER*), qsort_CalcGameScore);                                    	qsort((void*)p, 4, sizeof(MJPLAYER*), qsort_CalcGameScore);                              
                                                                                                                                                                                          
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
		//1000_Pʂ̓_߂                                                                    		//1000_Pʂ̓_߂                                                              
		int uma[] = {8,4,-4,-8};	//ʓ_                                                             		int uma[] = {8,4,-4,-8};	//ʓ_                                                       
		int score = (p[i]->Score - 30000) / 1000 + uma[i];                                            		int score = (p[i]->Score - 30000) / 1000 + uma[i];                                      
		if(i == 0){score += (3 * 4);}	//1ʂɃIJ𑫂Ă                                         		if(i == 0){score += (3 * 4);}	//1ʂɃIJ𑫂Ă                                   
                                                                                                                                                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S071)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_Game.GameScore[i].Player = p[i];                                                       ύX 		m_Taku.GameScore[i].Player = p[i];                                                      
		m_Game.GameScore[i].Score = score;                                                       ύX 		m_Taku.GameScore[i].Score = score;                                                      
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E071)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
}                                                                                               }                                                                                         
string CMJSim::GetTonpuHai(int Hai)                                                             string CMJSim::GetTonpuHai(int Hai)                                                       
{                                                                                               {                                                                                         
	char *t[] = {                                                                                  	char *t[] = {                                                                            
		"","1m","2m","3m","4m","5m","6m","7m","8m","9m",                                              		"","1m","2m","3m","4m","5m","6m","7m","8m","9m",                                        
		"","1p","2p","3p","4p","5p","6p","7p","8p","9p",                                              		"","1p","2p","3p","4p","5p","6p","7p","8p","9p",                                        
		"","1s","2s","3s","4s","5s","6s","7s","8s","9s",                                              		"","1s","2s","3s","4s","5s","6s","7s","8s","9s",                                        
		"","","",  "","",  "","",  "k",  "",  "",                                              		"","","",  "","",  "","",  "k",  "",  "",                                        
		"","","",  "","",  ""                                                                   		"","","",  "","",  ""                                                             
                                                                                              
	}                                                                                              	}                                                                                        
	m_File << endl;                                                                                	m_File << endl;                                                                          
}                                                                                               }                                                                                         
void CMJSim::LogKyokuStart()                                                                    void CMJSim::LogKyokuStart()                                                              
{                                                                                               {                                                                                         
	//Ȃ                                                                                   	//Ȃ                                                                             
}                                                                                               }                                                                                         
void CMJSim::LogKyokuEnd()                                                                      void CMJSim::LogKyokuEnd()                                                                
{                                                                                               {                                                                                         
	//ǂ̌                                                                                     	//ǂ̌                                                                               
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S072)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	m_File	<< endl << "  " << GetTonpuKaze(m_Game.Kyoku / 4) << m_Game.Kyoku % 4 + 1 << " " ύX 	m_File	<< endl << "  " << GetTonpuKaze(m_Taku.Kyoku / 4) << m_Taku.Kyoku % 4 + 1 << " "
			<< m_Game.TsumiboNum << "{([`" << m_Game.RichiboNum << ")";                      ύX 			<< m_Taku.TsumiboNum << "{([`" << m_Taku.RichiboNum << ")";                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E072)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	int i;                                                                                         	int i;                                                                                   
	for(i = 0; i < 4; i++){                                                                        	for(i = 0; i < 4; i++){                                                                  
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S073)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		if(m_Game.Player[i].KyokuScore != 0){                                                    ύX 		if(m_Taku.Player[i].KyokuScore != 0){                                                   
			m_File	<< " " << m_Game.Player[i].Name << " " << m_Game.Player[i].KyokuScore;           ύX 			m_File	<< " " << m_Taku.Player[i].Name << " " << m_Taku.Player[i].KyokuScore;          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E073)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		}                                                                                             		}                                                                                       
	}                                                                                              	}                                                                                        
	m_File << endl;                                                                                	m_File << endl;                                                                          
                                                                                                                                                                                          
	LogKyokuEndAgariInfo();                                                                        	LogKyokuEndAgariInfo();                                                                  
	LogKyokuEndHaifu();                                                                            	LogKyokuEndHaifu();                                                                      
}                                                                                               }                                                                                         
void CMJSim::LogKyokuEndHaifu()                                                                 void CMJSim::LogKyokuEndHaifu()                                                           
{                                                                                               {                                                                                         
	//zv                                                                                         	//zv                                                                                   
	int k = 0;                                                                                     	int k = 0;                                                                               
	for(int i = 0; i < 4; i++){                                                                    	for(int i = 0; i < 4; i++){                                                              
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S074)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		m_File << "    [" << i + 1 << GetTonpuKaze(GetZikaze(i, m_Game.Kyoku)) << "]";           ύX 		m_File << "    [" << i + 1 << GetTonpuKaze(GetZikaze(i, m_Taku.Kyoku)) << "]";          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E074)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		//\[gBqXgO֓                                                            		//\[gBqXgO֓                                                      
		int hist[46];                                                                                 		int hist[46];                                                                           
		memset(hist, 0, 46 * sizeof(int));                                                            		memset(hist, 0, 46 * sizeof(int));                                                      
		for(int j = 0; j < 13; j++){                                                                  		for(int j = 0; j < 13; j++){                                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S075)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
			hist[m_Game.Yama[(i * 13 + j) + 14]]++;                                                 ύX 			hist[m_Taku.Yama[(i * 13 + j) + 14]]++;                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E075)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
		}                                                                                             		}                                                                                       
		//O֏o                                                                              		//O֏o                                                                        
		for(j = 1; j < 46; j++){                                                                      		for(j = 1; j < 46; j++){                                                                
			for(int k = 0; k < hist[j]; k++){                                                            			for(int k = 0; k < hist[j]; k++){                                                      
				m_File << GetTonpuHai(j);                                                                   				m_File << GetTonpuHai(j);                                                             
			}                                                                                            			}                                                                                      
		}                                                                                             		}                                                                                       
		m_File << endl;                                                                               		m_File << endl;                                                                         
	}                                                                                              	}                                                                                        
	                                                                                               	                                                                                         
	//h                                                                                         	//h                                                                                   
    m_File << "    [\h]";                                                                       m_File << "    [\h]";                                                             
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S076)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	for(i = 0; i < GetKanNum(&m_Game) + 1; i++){	//ȂƂ1̓h                  ύX 	for(i = 0; i < GetKanNum(&m_Taku) + 1; i++){	//ȂƂ1̓h                 
		m_File << GetTonpuHai(GetDora(i, m_Game.Yama));                                          ύX 		m_File << GetTonpuHai(GetDora(i, m_Taku.Yama));                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E076)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
    m_File << " [h]";                                                                          m_File << " [h]";                                                                
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S077)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	for(i = 0; i < GetKanNum(&m_Game) + 1; i++){                                              ύX 	for(i = 0; i < GetKanNum(&m_Taku) + 1; i++){                                             
		m_File << GetTonpuHai(GetDora(i + 4, m_Game.Yama));                                      ύX 		m_File << GetTonpuHai(GetDora(i + 4, m_Taku.Yama));                                     
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E077)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	}                                                                                              	}                                                                                        
	m_File << endl;                                                                                	m_File << endl;                                                                          
                                                                                                                                                                                          
	//v                                                                                         	//v                                                                                   
    m_File << "    * ";                                                                             m_File << "    * ";                                                                   
	char *TompuAction[] = {"","R","d","D","C","N","K","A","A","K","K","G"};                        	char *TompuAction[] = {"","R","d","D","C","N","K","A","A","K","K","G"};                  
                                                                                                                                                                                          
	vector<int>::iterator it;                                                                      	vector<int>::iterator it;                                                                
	for(it = m_Log.begin(); it != m_Log.end();){                                                   	for(it = m_Log.begin(); it != m_Log.end();){                                             
		m_File << *it + 1;	//vC[ԍ                                                           		m_File << *it + 1;	//vC[ԍ                                                     
                                                                                              
			it++;it++;break;                                                                             			it++;it++;break;                                                                       
		}                                                                                             		}                                                                                       
		m_File << " ";                                                                                		m_File << " ";                                                                          
	}                                                                                              	}                                                                                        
	m_File	<< endl;                                                                                	m_File	<< endl;                                                                          
}                                                                                               }                                                                                         
void CMJSim::LogKyokuEndAgariInfo()                                                             void CMJSim::LogKyokuEndAgariInfo()                                                       
{                                                                                               {                                                                                         
	//オ                                                                                   	//オ                                                                             
	m_File << "    ";                                                                              	m_File << "    ";                                                                        
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S078)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	switch(m_Game.AgariType){	//オꍇ                                                  ύX 	switch(m_Taku.AgariType){	//オꍇ                                                 
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E078)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	case MJAGARI_AGARI:                                                                            	case MJAGARI_AGARI:                                                                      
		{                                                                                             		{                                                                                       
			char *agari[] = {"c",""};                                                             			char *agari[] = {"c",""};                                                       
			char *kansuji[] = {"","","","O","l"};                                                  			char *kansuji[] = {"","","","O","l"};                                            
			switch(m_Agari.Han()){                                                                       			switch(m_Agari.Han()){                                                                 
			case 5:                                                                                      			case 5:                                                                                
				m_File << "";break;                                                                     				m_File << "";break;                                                               
			case 6:case 7:                                                                               			case 6:case 7:                                                                         
				m_File << "";break;                                                                   				m_File << "";break;                                                             
			case 8:case 9:case 10:                                                                       			case 8:case 9:case 10:                                                                 
                                                                                              
	case MJAGARI_CHONBO:                                                                           	case MJAGARI_CHONBO:                                                                     
		m_File << "`{";break;                                                                   		m_File << "`{";break;                                                             
	}                                                                                              	}                                                                                        
	m_File << endl;                                                                                	m_File << endl;                                                                          
}                                                                                               }                                                                                         
void CMJSim::LogGameEnd()                                                                       void CMJSim::LogGameEnd()                                                                 
{                                                                                               {                                                                                         
	m_File	<< endl << "  ----  ----" << endl;                                              	m_File	<< endl << "  ----  ----" << endl;                                        
	for(int i = 0; i < 4; i++){                                                                    	for(int i = 0; i < 4; i++){                                                              
		m_File	<< "  " << i + 1 << " "                                                              		m_File	<< "  " << i + 1 << " "                                                        
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S079)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
				<< m_Game.GameScore[i].Player->Name << " "                                             ύX 				<< m_Taku.GameScore[i].Player->Name << " "                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E079)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
				<< showpos                                                                                  				<< showpos                                                                            
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S080)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
				<< m_Game.GameScore[i].Score                                                           ύX 				<< m_Taku.GameScore[i].Score                                                          
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E080)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
				<< noshowpos << endl;                                                                       				<< noshowpos << endl;                                                                 
	}                                                                                              	}                                                                                        
	m_File	<< "----- 300 I 2003/01/01 00:00 -----" << endl;                                   	m_File	<< "----- 300 I 2003/01/01 00:00 -----" << endl;                             
}                                                                                               }                                                                                         
void CMJSim::LogHaifu(int Index,int Action, int Hosoku1, int Hosoku2)                           void CMJSim::LogHaifu(int Index,int Action, int Hosoku1, int Hosoku2)                     
{                                                                                               {                                                                                         
	m_Log.push_back(Index);                                                                        	m_Log.push_back(Index);                                                                  
	m_Log.push_back(Action);                                                                       	m_Log.push_back(Action);                                                                 
	m_Log.push_back(Hosoku1);                                                                      	m_Log.push_back(Hosoku1);                                                                
	m_Log.push_back(Hosoku2);                                                                      	m_Log.push_back(Hosoku2);                                                                
}                                                                                               }                                                                                         
int main(int argc, char* argv[])                                                                int main(int argc, char* argv[])                                                          
{                                                                                               {                                                                                         
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(S081)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
	cout << "MJSim ver 0.1.1" << endl;                                                        ύX 	cout << "MJSim ver 0.3.0" << endl;                                                       
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9(E081)----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                                                                                                                                                                                          
	CMJSim Sim;                                                                                    	CMJSim Sim;                                                                              
	Sim.Run();                                                                                     	Sim.Run();                                                                               
                                                                                                                                                                                          
	return 0;                                                                                      	return 0;                                                                                
}                                                                                               }                                                                                         
//                                                                                              //                                                                                        
----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9      ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9
                      OLD    NEW                                                          
ύX   158ǉ     9폜    17v   184                         952 LINE    944   s     -8                                                        
                                                                                  
