public Discard(Mahjong.Replay Replay, int Round, int Player)
{
R = Replay;
Rnd = R.Rounds[Round];
this.Player = Player;
Red = !Replay.LobbyType.HasFlag(LobbyType.NOAKA);
}
public void Loading()
{
_algorithm = Mahjong.GetAlgorithm(
"./Resources/TingTable.json",
"./Resources/LaiTable.json",
"./Resources/HuTable.json");
}
/// <summary>
/// 找到同桌其他玩家要删除的打出的手牌
/// </summary>
/// <param name="parent">要找的玩家的对应的父物体</param>
public Mahjong GetOtherPlayerHandCard(Transform parent, int index)
{
Mahjong mah = null;
if (parent == null)
{
return(null);
}
PlayerPlayingPanelData pppd = MahjongGame_AH.GameData.Instance.PlayerPlayingPanelData;
Mahjong[] maharray = parent.GetComponentsInChildren <Mahjong>();
string name = "";
if (index == 1 || index == 3)
{
name = PlayerPlayingPanelData.currentHCardPre;
}
else
{
name = PlayerPlayingPanelData.currentUCardPre;
}
//从最后一个寻找要删除的刚才摸得手牌
for (int i = maharray.Length - 1; i >= 0; i--)
{
if (maharray[i].name == name && maharray[i].enabled)
{
mah = maharray[i];
break;
}
}
return(mah);
}
bool Eat(Mahjong _mahjong)
{
List <Mahjong> list = GetSamaColorList(_mahjong);
list.Add(_mahjong);
string serializeList = SerializeList(list);
string[] eatSerialize = MahjongConst.eatSerialize;
int containsCount = 0;
for (int i = 0, length = eatSerialize.Length; i < length; i++)
{
char[] chars = eatSerialize[i].ToCharArray();
for (int j = 0, lengthJ = chars.Length; j < lengthJ; j++)
{
if (!serializeList.Contains(chars[i].ToString()))
{
break;
}
else
{
containsCount++;
if (containsCount == lengthJ)
{
return(true);
}
}
}
}
return(false);
}
private int GetPlayerIndex(Mahjong.Replay R, string NickName)
{
for (int i = 0; i < 4; i++)
{
if (R.Players[i].NickName.CompareTo(NickName) == 0) return i;
}
return -1;
}
public int ShowSex = 0; // show player's sex
public PaifuGenerator(Mahjong.Replay Replay, int Round)
{
R = Replay;
Rnd = R.Rounds[Round];
Red = !Replay.LobbyType.HasFlag(LobbyType.NOAKA);
// Replay only one game, if it need
if (Rnd.Hands[0].Count == 0) Rnd.ReplayGame();
for (int i = 0; i < R.PlayerCount; i++) DangerTiles[i] = null;
}
public void CheckNewMahjong(Mahjong newOne, PlayerInfo playerInfo = null)
{
if (playerInfo != null)
{
PlayerPosition playerPos = GetPlayerPosition(playerInfo);
CheckAbandonOne(newOne, playerPos);
}
else
{
CheckCatchOne(newOne);
}
}
List <Mahjong> GetSamaColorList(Mahjong _mahjong)
{
List <Mahjong> list = new List <Mahjong>();
for (int i = 0, length = ownMahjongList.Count; i < length; i++)
{
if (ownMahjongList[i].mahjongColor == _mahjong.mahjongColor)
{
list.Add(ownMahjongList[i]);
}
}
return(list);
}
/// <summary>
/// 获取刚摸的手牌
/// </summary>
/// <returns></returns>
public Mahjong GetDealCard()
{
Mahjong go = null;
Mahjong[] mah = GetSelfCard();
for (int i = 0; i < mah.Length; i++)
{
if (mah[i].isDealCard)
{
go = mah[i];
break;
}
}
return(go);
}
public Room(int index, Mahjong.ShuffleType shuffleType, MahjongRoomType roomType)
{
__index = index;
__type = shuffleType;
__mahjong = new Mahjong();
switch (roomType)
{
case MahjongRoomType.Normal:
__mahjong.rule = new Rule();
break;
case MahjongRoomType.Hand258:
__mahjong.rule = new Rule258();
break;
}
}
bool Bump(Mahjong _mahjong)
{
int type = _mahjong.type;
int haveCount = 0;
for (int i = 0, length = ownMahjongList.Count; i < length; i++)
{
if (ownMahjongList[i].type == type)
{
haveCount++;
if (haveCount == 2)
{
return(true);
}
}
}
return(false);
}
public void OnClick()
{
if (isDrag)
{
return;
}
if (MahjongManger.Instance.hasCardDarg)
{
return;
}
// Debug.LogError("点击Onclick");
if (iState == 1)
{
iState = 0;
PlayerPlayingPanelData pppd = GameData.Instance.PlayerPlayingPanelData;
if (pppd.isCanHandCard)
{
PutCard(1);
}
else
{
MoveDown(bMahjongValue);
}
}
else if (iState == 0)
{
iState = 1;
SystemMgr.Instance.AudioSystem.PlayManual(AudioSystem.AudioMenel.pick_card, false, false);
for (int i = 0; i < transform.parent.GetComponentsInChildren <Mahjong>(false).Length; i++)
{
Mahjong mj = transform.parent.GetComponentsInChildren <Mahjong>(false)[i];
if (mj != this)
{
if (mj.iState == 1)
{
// Debug.LogError("有牌上去了");
mj.iState = 0;
mj.MoveDown(mj.bMahjongValue);
}
}
}
MoveUp();
}
}
/// <summary>
/// 获取指定的手牌
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public Mahjong GetPointCard(byte value)
{
Mahjong mah = null;
//Debug.LogError("value:" + value);
Mahjong[] mahjong = GetSelfCard();
for (int i = 0; i < mahjong.Length; i++)
{
//Debug.LogError("mahjong:" + mahjong[i].bMahjongValue);
if (mahjong[i].bMahjongValue == value)
{
mah = mahjong[i];
// Debug.LogError(mah.name);
break;
}
}
return(mah);
}
protected void CheckCatchOne(Mahjong newOne)
{
}
protected void CheckAbandonOne(Mahjong newOne, PlayerPosition playerPos)
{
}
bool HasTempai(Mahjong.Round Rnd, int Player)
{
for (int j = 0; j < Rnd.Steps.Count; j++)
{
if (Rnd.Steps[j].Player != Player) continue;
if (Rnd.Steps[j].Shanten == 0) return true;
}
return false;
}
/// <summary>
/// 打出牌之后的操作
/// </summary>
/// <param name="status">1表示正常打出牌，2表示碰杠的处理</param>
public void PutCard(int status)
{
#region 关闭提示
showM[] show = transform.parent.parent.parent.GetComponentsInChildren <showM>();
//Debug.LogError("down" + show.Length);
for (int i = 0; i < show.Length; i++)
{
if (show[i].isOpen)
{
show[i].Stop();
for (int j = 0; j < show[i].m.Length; j++)
{
show[i].m[j].enabled = false;
}
show[i].isOpen = false;
}
}
#endregion 关闭提示
Vector3 firstPos = Vector3.zero; //第一张麻将的位置
PlayerPlayingPanelData pppd = GameData.Instance.PlayerPlayingPanelData;
pppd.isCanHandCard = false;
if (status == 1 && pppd.iPlayerHostStatus == 0)
{
//发送出牌请求
byte value = Convert.ToByte(bMahjongValue.ToString("x8"));
NetMsg.ClientDiscardTileReq msg = new NetMsg.ClientDiscardTileReq();
msg.iUserId = GameData.Instance.PlayerNodeDef.iUserId;
msg.byDrawSeaBottom = bMahjongValue;
MahjongManger.Instance.TingFirstValue = msg.byDrawSeaBottom;
NetworkMgr.Instance.GameServer.SendDiscardTileReq(msg);
MahjongManger.Instance.isEndPutAnimation = false;
UIMainView.Instance.PlayerPlayingPanel.TingShow.SetActive(false);
MahjongManger.Instance.HideTingLogo();
}
//隐藏该麻将
//transform.localScale = Vector3.one * 0.001f;
iState = 0;
//获取第一张麻将的位置
//firstPos = MahjongManger.Instance.GetFirstMahjongPos(0);
firstPos = MahjongManger.Instance.FirstPos;
//获取打出牌的下标
for (int i = 0; i < pppd.usersCardsInfo[0].listCurrentCards.Count; i++)
{
if (bMahjongValue == pppd.usersCardsInfo[0].listCurrentCards[i].cardNum && iMahId == pppd.usersCardsInfo[0].listCurrentCards[i].MahId)
{
pppd.usersCardsInfo[0].listCurrentCards.RemoveAt(i);
MahjongManger.Instance.iputCardIndex = i;
break;
}
}
int deadcardValue = -1;
int mahid = -1;
if (MahjongManger.Instance.PlayerDealHandCrad != null)
{
deadcardValue = MahjongManger.Instance.PlayerDealHandCrad.bMahjongValue;
mahid = MahjongManger.Instance.PlayerDealHandCrad.iMahId;
}
//判断打出的牌是不是摸到的手牌
if (isDealCard)
{
isDealCard = false;
}
else
{
//对list进行排序，获取手牌的下标
pppd.CurrentCradSort(0);
pppd.CurrentCradSort(0);
//处理玩家吃碰之后的打牌操作
if (deadcardValue == -1 && mahid == -1)
{
if (pppd.isSpwanSpecialCard)
{
pppd.isSpwanSpecialCard = false;
MahjongManger.Instance.insertCardIndex = pppd.usersCardsInfo[0].listCurrentCards.Count;
}
else
{
MahjongManger.Instance.insertCardIndex = -1;
MahjongManger.Instance.iputCardIndex -= 1;
}
}
else
{
for (int i = 0; i < pppd.usersCardsInfo[0].listCurrentCards.Count; i++)
{
if (deadcardValue == pppd.usersCardsInfo[0].listCurrentCards[i].cardNum && mahid == pppd.usersCardsInfo[0].listCurrentCards[i].MahId)
{
MahjongManger.Instance.insertCardIndex = i;
break;
}
}
}
Mahjong[] mah = new Mahjong[Mathf.Abs(MahjongManger.Instance.insertCardIndex - MahjongManger.Instance.iputCardIndex)];
if (Mathf.Abs(MahjongManger.Instance.insertCardIndex - MahjongManger.Instance.iputCardIndex) > 0)
{
mah = MahjongManger.Instance.GetWillMoveCard();
}
//调用移动方法插入手牌
if (mah.Length > 0)
{
for (int i = 0; i < mah.Length; i++)
{
mah[i].MoveSelf(MahjongManger.Instance.MoveStatus, 1);
}
}
//Debug.LogError("这张麻将的信息，deadcardValue:" + deadcardValue + ",mahid:" + mahid);
if (deadcardValue != -1 && mahid != -1)
{
MahjongManger.Instance.flyMahjongIndexPos(firstPos);
}
else
{
MahjongManger.Instance.GetFirstMahjongPos(0);
}
}
int index = pppd.GetOtherPlayerShowPos(pppd.bySeatNum + 1) - 1;
if (status == 1)
{
byte value = bMahjongValue;
//if (PlayerPrefs.HasKey("TingOneCard"))
//{
// if (PlayerPrefs.GetInt("TingOneCard") == 1 && pppd.playingMethodConf.byDiscardSeeReadHandTile == 0)
// {
// value = 255;
// }
//}
pppd.iSpwanCardNum--;
//先在同一个位置产生一个对应的预置体，然后移动
transform.localScale = Vector3.zero;
GameObject go = Instantiate(Resources.Load <GameObject>("Game/Ma/TabelBigCard"));
go.transform.SetParent(UIMainView.Instance.PlayerPlayingPanel._Cards[0].transform.Find("currentGroup"));
go.name = "TabelBigCard";
go.transform.localPosition = transform.localPosition;
go.transform.localScale = Vector3.one * 1.2f;
go.transform.localEulerAngles = Vector3.zero;
UIMainView.Instance.PlayerPlayingPanel.ChangeCardNum(go.transform.Find("Image/num").GetComponent <Image>(), value, index);
go.GetComponent <Mahjong>().bMahjongValue = value;
go.GetComponent <Mahjong>().PutCardAnimator(pppd.bySeatNum, value, 1);
PoolManager.Unspawn(gameObject);
}
else
{
}
isDealCard = false;
}
// filters
private bool CheckChiitoiHand(Mahjong.Hand H)
{
if(H.Shanten != 0) return false;
Mahjong.ShantenCalculator Sh = new Mahjong.ShantenCalculator(H);
Sh.GetShanten();
return (Sh.ShantenChiitoi == 0);
}
public void Loading()
{
_algorithm = Mahjong.GetAlgorithm();
}
// MM/DD | 牌譜 | type | link
// place位 A:nickname(result) B:
static void AddReplayInfoTenhou(Mahjong.Replay R, List<string> Output)
{
// Game type
{
string Link = String.Format("http://tenhou.net/0/?log={0:s}&tw={1:d}\t", R.Hash, 0);
string Info = String.Format("{0:00}/{1:00} | 牌譜 | {2:s} | {3:s}", R.Date.Month, R.Date.Day,
Tenhou.LobbyType.GetText(R.LobbyType),
Link);
Output.Add(Info);
}
// Players
{
string Players = "";
for (int p = 0; p < R.PlayerCount; p++)
{
Mahjong.Player P = R.Players[p];
string Position = "" + Convert.ToChar('A' + p);
string Result = (R.Result[p] > 0) ? "+" + R.Result[p].ToString() : R.Result[p].ToString();
string PlayerInfo = String.Format("{0:s}:{1:s}({2:s}.0) ", Position, P.NickName, Result);
Players += PlayerInfo;
}
Output.Add(Players);
}
}
static int TempaiCount(Mahjong.Replay R, int Player)
{
if (Player >= R.PlayerCount) return 0;
int Count = 0;
for (int i = 0; i < R.Rounds.Count; i++)
{
Mahjong.Round Rnd = R.Rounds[i];
if (Rnd.Tempai[Player]) Count++;
}
return Count;
}
static int AverageTableRating(Mahjong.Replay R)
{
int Rating = 0;
for (int p = 0; p < R.PlayerCount; p++)
{
Rating += R.Players[p].Rating;
}
return Rating / R.PlayerCount;
}
static int CountDangerous(Mahjong.Round Rnd, int Player)
{
int MaxCount = 0;
for (int j = 0; j < Rnd.Steps.Count; j++)
{
int[] D = Rnd.Steps[j].Danger;
if (D == null) continue;
if (Rnd.Steps[j].Player != Player) continue;
if (D.Length > MaxCount) MaxCount = D.Length;
}
return MaxCount;
}
private int GetDeadWaitCount(Mahjong.Round Rnd, int KanCount, int[] Waiting)
{
int Count = 0;
for (int i = KanCount; i < 14 + KanCount; i++)
{
Mahjong.Tile T = new Mahjong.Tile(Rnd.Wall.Tiles[i]);
if (Waiting.Contains(T.TileId)) Count++;
}
return Count;
}
// 0: non-colored,
// 1-3: m, p, s colored
private int IsColoredHand(Mahjong.Hand H)
{
int[] Suits = new int[3];
int NakiSuit = -1;
int ActiveTileCount = 0;
// Init
for (int i = 0; i < Suits.Length; i++) Suits[i] = 0;
// Check naki
for (int i = 0; i < H.Naki.Count; i++)
{
if ((H.Naki[i].Type == Mahjong.NakiType.NUKI) ||
(H.Naki[i].Type == Mahjong.NakiType.CHAKAN)) continue;
int CurrentNakiSuit = -1;
switch (new Mahjong.Tile(H.Naki[i].Tiles[0]).TileType)
{
case "m": CurrentNakiSuit = 0; break;
case "p": CurrentNakiSuit = 1; break;
case "s": CurrentNakiSuit = 2; break;
case "z":
// Jihai are accepted by any suit
continue;
}
// No nakies before
if (NakiSuit == -1)
NakiSuit = CurrentNakiSuit;
else if (NakiSuit != CurrentNakiSuit) return 0; // at least 2 sets of different suits - this is not colored hand
}
for (int i = 0; i < H.Tiles.Length; i++)
{
if (H.Tiles[i] == -1) continue;
switch (new Mahjong.Tile(H.Tiles[i]).TileType)
{
case "m": Suits[0]++; ActiveTileCount++; break;
case "p": Suits[1]++; ActiveTileCount++; break;
case "s": Suits[2]++; ActiveTileCount++; break;
case "z":
// Jihai are accepted by any suit
continue;
}
}
if (NakiSuit != -1) // Has opened sets of some suit
{
int AnotherSuitTiles = 0;
for (int i = 0; i < 3; i++)
{
if (i != NakiSuit) AnotherSuitTiles += Suits[i];
}
if (ColoredForced != -1)
{
return (AnotherSuitTiles == 0) ? NakiSuit : 0;
}
else
{
if (ActiveTileCount < 3)
return NakiSuit;
else
return (AnotherSuitTiles < 3) ? NakiSuit : 0;
}
}
else // no suit sets
{
int MaxTilesSuit = -1;
if ((Suits[0] >= Suits[1]) && (Suits[0] >= Suits[2]))
{
// Suit[0] max
MaxTilesSuit = 0;
}
else if ((Suits[1] >= Suits[0]) && (Suits[1] >= Suits[2]))
{
// Suit[2] max
MaxTilesSuit = 1;
}
else if ((Suits[2] >= Suits[0]) && (Suits[2] >= Suits[1]))
{
// Suit[0] max
MaxTilesSuit = 2;
}
else
return 0;
if (ColoredForced != -1)
{
return (ActiveTileCount == Suits[MaxTilesSuit]) ? MaxTilesSuit : 0;
}
else
{
if (ActiveTileCount > 0)
{
double SuitFraction = Convert.ToDouble(Suits[MaxTilesSuit]) / Convert.ToDouble(ActiveTileCount);
return (SuitFraction > 0.8f) ? MaxTilesSuit : 0;
}
else
return 4;
}
}
}
public void Initialize(Mahjong game)
{
this._game = game;
}
public override int Score(Mahjong.RuleType type, int playerIndex, int tileIndex, IEnumerable <Mahjong.Rule.WinFlag> winFlags)
{
MahjongServer host = instance == null ? null : instance.host as MahjongServer;
if (host == null)
{
return(0);
}
NetworkWriter writer = __instance.RpcStart();
if (writer != null)
{
writer.Write((byte)((int)type - (int)Mahjong.RuleType.Win));
writer.Write((byte)(((int)playerIndex + 4 - index) & 3));
writer.Write((byte)Mahjong.Tile.Get(tileIndex));
}
int score = 0, kongCount = base.kongCount;
score += __Write(MahjongScoreType.Flower, flowerCount + groupCount - kongCount, writer, host.scores);
score += __Write(MahjongScoreType.Kong, kongCount, writer, host.scores);
switch (type)
{
case Mahjong.RuleType.Win:
case Mahjong.RuleType.SelfDraw:
case Mahjong.RuleType.BreakKong:
case Mahjong.RuleType.OverKong:
if (type == Mahjong.RuleType.SelfDraw)
{
if (drawType == DrawType.Flower)
{
score += __Write(MahjongScoreType.FlowerDraw, 1, writer, host.scores);
}
}
if (type == Mahjong.RuleType.OverKong)
{
score += __Write(MahjongScoreType.KongDraw, 1, writer, host.scores);
if (drawType == DrawType.Flower)
{
score += __Write(MahjongScoreType.FlowerDraw, 1, writer, host.scores);
}
}
break;
default:
if (writer != null)
{
writer.Write((byte)255);
}
return(0);
}
IEnumerable <int> handTileIndices = base.handTileIndices;
if (winFlags != null)
{
foreach (Mahjong.Rule.WinFlag winFlag in winFlags)
{
switch (winFlag.index)
{
case 0:
score += __Write(MahjongScoreType.AllPongHand, 1, writer, host.scores);
if (Mahjong.Rule.IsGreatHand258(handTileIndices))
{
score += __Write(MahjongScoreType.GreatHand258, 1, writer, host.scores);
}
break;
case 1:
case 2:
case 3:
score += __Write(MahjongScoreType.Normal, 1, writer, host.scores);
break;
case 4:
break;
case 5:
score += __Write(MahjongScoreType.SevenPairsHand, 1, writer, host.scores);
break;
}
}
}
if (Mahjong.Rule.IsCleanHand(handTileIndices))
{
score += __Write(MahjongScoreType.CleanHand, 1, writer, host.scores);
}
if (Mahjong.Rule.IsPureHand(handTileIndices))
{
score += __Write(MahjongScoreType.PureHand, 1, writer, host.scores);
}
if (Mahjong.Rule.IsSimpleHand(handTileIndices))
{
score += __Write(MahjongScoreType.SimpleHand, 1, writer, host.scores);
}
if (count < 2)
{
score += __Write(MahjongScoreType.Single, 1, writer, host.scores);
}
Mahjong mahjong = base.mahjong;
if (mahjong != null)
{
if (poolTileIndexCount < 1)
{
score += __Write(index == mahjong.dealerIndex ? MahjongScoreType.HeavenlyHand : MahjongScoreType.EarthlyHand, 1, writer, host.scores);
}
}
if (writer != null)
{
writer.Write((byte)255);
}
instance.RpcEnd((short)MahjongNetworkRPCHandle.Score);
return(score);
}
private bool CheckFormInHand(Mahjong.Hand H)
{
int[] Tehai = new int[38];
for (int i = 0; i < Tehai.Length; i++) Tehai[i] = 0;
// Create tehai
for (int i = 0; i < H.Tiles.Length; i++)
{
if (H.Tiles[i] == -1) continue;
Mahjong.Tile T = new Mahjong.Tile(H.Tiles[i]);
Tehai[T.TileId]++;
}
// Check form in specified suits
for (int i = 0; i < 3; i++)
{
bool Mark = true;
if (Form[11 + i] != 0)
{
for (int j = 1; j < 10; j++)
{
if (Form[j] == -1) continue;
if (Form[j] != Tehai[i * 10 + j])
{
Mark = false;
break;
}
}
if (Mark) return true;
}
}
return false;
}
static bool HasFuriten(Mahjong.Round Rnd, int Player)
{
for (int j = 0; j < Rnd.Steps.Count; j++)
{
if (Rnd.Steps[j].Player != Player) continue;
if (Rnd.Steps[j].Furiten) return true;
}
return false;
}
private short __OnInit(NetworkWriter writer)
{
if (writer != null)
{
byte flag = 0;
Mahjong mahjong = base.mahjong;
bool isTurn = mahjong != null && mahjong.playerIndex == index;
if (isTurn)
{
flag |= 1 << (int)MahjongPlayerStatus.Turn;
}
if (__isShow)
{
flag |= 1 << (int)MahjongPlayerStatus.Show;
}
writer.Write(flag);
writer.Write((byte)groupCount);
IEnumerable <Group> groups = base.groups;
if (groups != null)
{
foreach (Group group in groups)
{
writer.Write((byte)group.type);
switch (group.type)
{
case Mahjong.RuleType.Chow:
case Mahjong.RuleType.Pong:
writer.Write(Mahjong.Tile.Get(group.x));
writer.Write(Mahjong.Tile.Get(group.y));
writer.Write(Mahjong.Tile.Get(group.z));
break;
case Mahjong.RuleType.Kong:
case Mahjong.RuleType.HiddenKong:
case Mahjong.RuleType.MeldedKong:
writer.Write(Mahjong.Tile.Get(group.x));
writer.Write(Mahjong.Tile.Get(group.y));
writer.Write(Mahjong.Tile.Get(group.z));
writer.Write(Mahjong.Tile.Get(group.w));
break;
default:
break;
}
}
}
writer.Write((byte)poolTileIndexCount);
IEnumerable <int> poolTileIndices = base.poolTileIndices;
if (poolTileIndices != null)
{
foreach (int poolTileIndex in poolTileIndices)
{
writer.Write(Mahjong.Tile.Get(poolTileIndex));
}
}
int count = __tileCodes == null ? 0 : base.count,
length = count > 0 ? __tileCodes.Length : 0,
handleTileIndex = base.handleTileIndex;
bool isHand = isTurn && Contains(handleTileIndex);
byte code;
writer.Write((byte)(count - (isHand ? 1 : 0)));
if (count > 0)
{
byte index;
foreach (KeyValuePair <int, int> pair in (IEnumerable <KeyValuePair <int, int> >) this)
{
index = (byte)pair.Key;
if (isTurn && index == handleTileIndex)
{
continue;
}
writer.Write(index);
code = Mahjong.Tile.Get(pair.Value);
code = code < length ? __tileCodes[code] : (byte)255;
writer.Write(code);
}
}
if (isHand)
{
writer.Write((byte)handleTileIndex);
code = Mahjong.Tile.Get(GetHandTileIndex(handleTileIndex));
code = code < length ? __tileCodes[code] : (byte)255;
writer.Write(code);
}
else
{
writer.Write((byte)255);
}
}
return((short)MahjongNetworkRPCHandle.Init);
}
static int TsumoCount(Mahjong.Replay R, int Player)
{
if(Player >= R.PlayerCount) return 0;
int Count = 0;
for (int i = 0; i < R.Rounds.Count; i++)
{
Mahjong.Round Rnd = R.Rounds[i];
if (Rnd.Winner[Player] && Rnd.Result == Mahjong.RoundResult.Tsumo) Count++;
}
return Count;
}
public IEnumerator Run()
{
__isRunning = true;
if (__mahjong == null)
{
__mahjong = new Mahjong();
__mahjong.rule = new Mahjong.Rule();
}
else if (__mahjong.rule == null)
{
__mahjong.rule = new Mahjong.Rule();
}
__mahjong.Shuffle(__type, out __point0, out __point1, out __point2, out __point3);
Player player;
IEnumerable <Mahjong.Player> players = __mahjong.players;
if (players != null)
{
foreach (Mahjong.Player instance in players)
{
player = instance as Player;
if (player != null)
{
player.Reset();
}
}
}
yield return(new WaitForSeconds(6.0f));
int i, index, ruleNodeIndex;
Mahjong.RuleType ruleType;
Player temp;
while (__mahjong.tileCount < 144)
{
index = __mahjong.playerIndex;
player = __mahjong.Get(index) as Player;
if (player != null)
{
while (true)
{
if (player.drawType == Mahjong.Player.DrawType.None)
{
if (!player.Draw())
{
break;
}
}
else
{
if (player.SendRuleMessage())
{
yield return(player.WaitToTry(5.0f));
for (i = 1; i < 4; ++i)
{
temp = __mahjong.Get((i + index) & 3) as Player;
if (temp != null)
{
if (temp.SendRuleMessage())
{
yield return(temp.WaitToTry(5.0f));
ruleType = __mahjong.ruleType;
if (ruleType == Mahjong.RuleType.BreakKong)
{
__Break();
if (__mahjong.rulePlayerIndex == temp.index)
{
temp.End(__mahjong.ruleNodeIndex);
}
break;
}
}
}
}
if (!__isRunning)
{
break;
}
ruleType = __mahjong.ruleType;
if (ruleType != Mahjong.RuleType.Unknown && index == __mahjong.rulePlayerIndex)
{
if (ruleType == Mahjong.RuleType.SelfDraw || ruleType == Mahjong.RuleType.OverKong)
{
__Break();
}
ruleNodeIndex = __mahjong.ruleNodeIndex;
if (!player.End(ruleNodeIndex))
{
continue;
}
if (!__isRunning)
{
break;
}
}
}
if (!player.isReady || !player.Discard(player.handleTileIndex))
{
if (player.SendReadyHand())
{
yield return(player.WaitToReady(5.0f));
}
if (!player.isReady)
{
yield return(player.WaitToThrow(6.0f));
}
}
for (i = 1; i < 4; ++i)
{
temp = __mahjong.Get((i + index) & 3) as Player;
if (temp != null && temp.SendRuleMessage())
{
yield return(temp.WaitToTry(5.0f));
ruleType = __mahjong.ruleType;
if (ruleType == Mahjong.RuleType.Win)
{
__Break();
break;
}
}
}
ruleType = __mahjong.ruleType;
if (ruleType != Mahjong.RuleType.Unknown)
{
player = __mahjong.Get(__mahjong.rulePlayerIndex) as Player;
if (player != null)
{
ruleNodeIndex = __mahjong.ruleNodeIndex;
player.End(ruleNodeIndex);
}
}
break;
}
}
}
if (!__isRunning)
{
break;
}
yield return(new WaitForSeconds(2.0f));
}
if (players != null)
{
int j, count;
Node node;
ZG.Network.Server host;
MahjongServerPlayer target;
ZG.Network.Lobby.Node result;
foreach (Mahjong.Player instance in players)
{
player = instance as Player;
target = player == null ? null : player.instance;
result = target == null ? null : target.node as ZG.Network.Lobby.Node;
if (result != null)
{
host = target.host;
if (host != null && host.GetNode(result.index, out node) && node.connectionId < 0)
{
host.Unregister(result.index, null);
}
else
{
count = result.count;
for (j = 0; j < count; ++j)
{
result.NotReady();
}
}
}
}
}
}
// NickName (Rank/Rating) ...
// Lobby
// Link
static void AddReplayInfoTournier(Mahjong.Replay R, List<string> Output)
{
int FirstPlaceIndex = -1;
for (int j = 0; j < R.PlayerCount; j++) if (R.Place[j] == 1) FirstPlaceIndex = j;
// Players
{
string Players = "";
for (int j = 0; j < R.PlayerCount; j++)
{
for (int p = 0; p < R.PlayerCount; p++)
{
if (R.Place[p] != j + 1) continue;
Mahjong.Player P = R.Players[p];
string PlayerInfo = String.Format("{0:s} ({1:s}/R{2:d}){3:s}", P.NickName, Tenhou.Rank.GetName(P.Rank), P.Rating,
(j != R.PlayerCount) ? ", " : "");
Players += PlayerInfo;
}
}
Output.Add(Players);
}
// Lobby
{
string Lobby = String.Format("Lobby {0:d}", R.Lobby);
Output.Add(Lobby);
}
// Link
{
string Link = String.Format("http://tenhou.net/0/?log={0:s}&tw={1:d}\t", R.Hash, FirstPlaceIndex);
Output.Add(Link);
}
// Delimiter
Output.Add("");
}
protected override EResponse OnHandle_SuteHai(EKaze fromPlayerKaze, Hai haiToHandle)
{
_action.Reset();
if (inTest)
{
//_action.MenuList.Add(EActionType.Nagashi);
//return DisplayMenuList();
}
Hai suteHai = haiToHandle;
// check Ron
int agariScore = MahjongAgent.getAgariScore(Tehai, suteHai, JiKaze);
if (agariScore > 0) // Ron
{
if (GameSettings.AllowFuriten || !isFuriten())
{
_action.IsValidRon = true;
_action.MenuList.Add(EActionType.Ron);
if (MahjongAgent.isReach(JiKaze))
{
//_action.MenuList.Add( EActionType.Nagashi );
return(DisplayMenuList());
}
else
{
_action.MenuList.Add(EActionType.Nagashi);
}
}
else
{
Utils.LogWarningFormat("Player {0} is enable to ron but furiten...", JiKaze.ToString());
}
}
if (MahjongAgent.getTsumoRemain() <= 0)
{
return(DoResponse(EResponse.Nagashi));
}
if (MahjongAgent.isReach(JiKaze))
{
return(DoResponse(EResponse.Nagashi));
}
// check menu Kan
if (MahjongAgent.getTotalKanCount() < GameSettings.KanCountMax)
{
if (Tehai.validDaiMinKan(suteHai))
{
_action.IsValidDaiMinKan = true;
_action.MenuList.Add(EActionType.Kan);
}
}
// check menu Pon
if (Tehai.validPon(suteHai))
{
_action.IsValidPon = true;
_action.MenuList.Add(EActionType.Pon);
}
// check menu Chii
int relation = Mahjong.getRelation(fromPlayerKaze, JiKaze);
if (relation == (int)ERelation.KaMiCha)
{
List <Hai> sarashiHaiRight = new List <Hai>();
if (Tehai.validChiiRight(suteHai, sarashiHaiRight))
{
_action.setValidChiiRight(true, sarashiHaiRight);
if (!_action.MenuList.Contains(EActionType.Chii))
{
_action.MenuList.Add(EActionType.Chii);
}
}
List <Hai> sarashiHaiCenter = new List <Hai>();
if (Tehai.validChiiCenter(suteHai, sarashiHaiCenter))
{
_action.setValidChiiCenter(true, sarashiHaiCenter);
if (!_action.MenuList.Contains(EActionType.Chii))
{
_action.MenuList.Add(EActionType.Chii);
}
}
List <Hai> sarashiHaiLeft = new List <Hai>();
if (Tehai.validChiiLeft(suteHai, sarashiHaiLeft))
{
_action.setValidChiiLeft(true, sarashiHaiLeft);
if (!_action.MenuList.Contains(EActionType.Chii))
{
_action.MenuList.Add(EActionType.Chii);
}
}
}
if (_action.MenuList.Count > 0)
{
_action.MenuList.Add(EActionType.Nagashi);
return(DisplayMenuList());
}
return(DoResponse(EResponse.Nagashi));
}
public static string GetText(Mahjong.LobbyType Flags)
{
string Temp = "";
int F = Convert.ToInt32(Flags);
int LobbyLevel = ((F & 0x0020) >> 4) | ((F & 0x0080) >> 7);
bool Aka = !Flags.HasFlag(Mahjong.LobbyType.NOAKA);
bool Kuitan = !Flags.HasFlag(Mahjong.LobbyType.NOKUI);
bool Nan = Flags.HasFlag(Mahjong.LobbyType.NAN);
bool Sanma = Flags.HasFlag(Mahjong.LobbyType.SANMA);
bool Saku = Flags.HasFlag(Mahjong.LobbyType.SAKU);
bool Gray = Flags.HasFlag(Mahjong.LobbyType.GRAY);
bool Chip = Flags.HasFlag(Mahjong.LobbyType.CHIP);
bool Jans = Flags.HasFlag(Mahjong.LobbyType.JANS);
bool Tech = Flags.HasFlag(Mahjong.LobbyType.TECH);
// Sanma
if (Sanma) Temp += "三";
// Lobby level
switch (LobbyLevel)
{
case 0: Temp += "般"; break; // 一般, ippan; general lobby
case 1: Temp += "上"; break; // 上級, uekyuu; 1dan+ lobby
case 2: Temp += "特"; break; // 特上, tokujou; 1800R 4dan+ lobby
}
if (Tech)
{
// Length
Temp += (Nan) ? "南" : "東";
}
// Open tanyao
Temp += (Kuitan) ? "喰" : "";
// Aka-dora
Temp += (Aka) ? "赤" : "";
if (Jans)
{
// Gray (wtf?)
Temp += (Gray) ? "速" : "";
if (!Chip)
{
Temp += "祝０";
}
else
{
Temp += (Jans) ? "祝５" : "祝２";
}
}
// Saku
Temp += (Saku) ? "速" : "";
// Chip
Temp += (Chip) ? "祝" : "";
return Temp;
}
public static int CompareMahjong(Mahjong mahjong1, Mahjong mahjong2)
{
if (mahjong1.type > mahjong2.type)
{
return(-1);
}
if (mahjong1.type > mahjong2.type)
{
return(1);
}
return(0);
}
