warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Reorganizes Project (#41)

Browse source
This commit is contained in:
Kamron Batman 2019-08-02 18:13:40 -07:00 • committed by GitHub
parent 08bf44af9a
commit 3614a66aee
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3499 changed files with 79 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

51
Projects/Scripts/Items/Games/Backgammon.cs Normal file
View file

@ -0,0 +1,51 @@
namespace Server.Items
{
[Flippable(0xE1C, 0xFAD)]
public class Backgammon : BaseBoard
{
[Constructible]
public Backgammon() : base(0xE1C)
{
}
public Backgammon(Serial serial) : base(serial)
{
}
public override void CreatePieces()
{
for (int i = 0; i < 5; i++)
{
CreatePiece(new PieceWhiteChecker(this), 42, 17 * i + 6);
CreatePiece(new PieceBlackChecker(this), 42, 17 * i + 119);
CreatePiece(new PieceBlackChecker(this), 142, 17 * i + 6);
CreatePiece(new PieceWhiteChecker(this), 142, 17 * i + 119);
}
for (int i = 0; i < 3; i++)
{
CreatePiece(new PieceBlackChecker(this), 108, 17 * i + 6);
CreatePiece(new PieceWhiteChecker(this), 108, 17 * i + 153);
}
for (int i = 0; i < 2; i++)
{
CreatePiece(new PieceWhiteChecker(this), 223, 17 * i + 6);
CreatePiece(new PieceBlackChecker(this), 223, 17 * i + 170);
}
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

135
Projects/Scripts/Items/Games/BaseBoard.cs Normal file
View file

@ -0,0 +1,135 @@
using System;
using System.Collections.Generic;
using Server.ContextMenus;
using Server.Gumps;
using Server.Multis;
using Server.Network;
namespace Server.Items
{
public abstract class BaseBoard : Container, ISecurable
{
public BaseBoard(int itemID) : base(itemID)
{
CreatePieces();
Weight = 5.0;
}
public BaseBoard(Serial serial) : base(serial)
{
}
public override bool DisplaysContent => false; // Do not display (x items, y stones)
public override bool IsDecoContainer => false;
public override TimeSpan DecayTime => TimeSpan.FromDays(1.0);
[CommandProperty(AccessLevel.GameMaster)]
public SecureLevel Level{ get; set; }
public abstract void CreatePieces();
public void Reset()
{
for (int i = Items.Count - 1; i >= 0; --i)
if (i < Items.Count)
Items[i].Delete();
CreatePieces();
}
public void CreatePiece(BasePiece piece, int x, int y)
{
AddItem(piece);
piece.Location = new Point3D(x, y, 0);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(1); // version
writer.Write((int)Level);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
if (version == 1)
Level = (SecureLevel)reader.ReadInt();
if (Weight == 1.0)
Weight = 5.0;
}
public override bool OnDragDrop(Mobile from, Item dropped)
{
return dropped is BasePiece piece && piece.Board == this && base.OnDragDrop(from, dropped);
}
public override bool OnDragDropInto(Mobile from, Item dropped, Point3D point)
{
if (dropped is BasePiece piece && piece.Board == this && base.OnDragDropInto(from, dropped, point))
{
Packet p = new PlaySound(0x127, GetWorldLocation());
p.Acquire();
if (RootParent == from)
from.Send(p);
else
foreach (NetState state in GetClientsInRange(2))
state.Send(p);
p.Release();
return true;
}
return false;
}
public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
{
base.GetContextMenuEntries(from, list);
if (ValidateDefault(from, this))
list.Add(new DefaultEntry(from, this));
SetSecureLevelEntry.AddTo(from, this, list);
}
public static bool ValidateDefault(Mobile from, BaseBoard board)
{
// Fixed this because it implies you can use it from your bank, if you can access your bank
// while in your house. (!(board.RootParent is Mobile) || board.RootParent == from)
return !board.Deleted && (from.AccessLevel >= AccessLevel.GameMaster || from.Alive &&
(board.IsChildOf(from.Backpack) || !(board.RootParent is Mobile) &&
board.Map == from.Map && from.InRange(board.GetWorldLocation(), 1) &&
BaseHouse.FindHouseAt(board)?.IsOwner(from) == true));
}
public class DefaultEntry : ContextMenuEntry
{
private BaseBoard m_Board;
private Mobile m_From;
public DefaultEntry(Mobile from, BaseBoard board) : base(6162,
from.AccessLevel >= AccessLevel.GameMaster ? -1 : 1)
{
m_From = from;
m_Board = board;
}
public override void OnClick()
{
if (ValidateDefault(m_From, m_Board))
m_Board.Reset();
}
}
}
}

95
Projects/Scripts/Items/Games/BasePiece.cs Normal file
View file

@ -0,0 +1,95 @@
namespace Server.Items
{
public class BasePiece : Item
{
public BasePiece(int itemID, BaseBoard board) : base(itemID)
{
Board = board;
}
public BasePiece(Serial serial) : base(serial)
{
}
public BaseBoard Board{ get; set; }
public override bool IsVirtualItem => true;
public override bool CanTarget => false;
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
writer.Write(Board);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 0:
{
Board = (BaseBoard)reader.ReadItem();
if (Board == null || Parent == null)
Delete();
break;
}
}
}
public override void OnSingleClick(Mobile from)
{
if (Board?.Deleted != false)
Delete();
else if (!IsChildOf(Board))
Board.DropItem(this);
else
base.OnSingleClick(from);
}
public override bool OnDragLift(Mobile from)
{
if (Board?.Deleted != false)
{
Delete();
return false;
}
if (!IsChildOf(Board))
{
Board.DropItem(this);
return false;
}
return true;
}
public override bool DropToMobile(Mobile from, Mobile target, Point3D p)
{
return false;
}
public override bool DropToItem(Mobile from, Item target, Point3D p)
{
return target == Board && p.X != -1 && p.Y != -1 && base.DropToItem(from, target, p);
}
public override bool DropToWorld(Mobile from, Point3D p)
{
return false;
}
public override int GetLiftSound(Mobile from)
{
return -1;
}
}
}

41
Projects/Scripts/Items/Games/CheckerBoard.cs Normal file
View file

@ -0,0 +1,41 @@
namespace Server.Items
{
public class CheckerBoard : BaseBoard
{
[Constructible]
public CheckerBoard() : base(0xFA6)
{
}
public CheckerBoard(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1016449; // a checker board
public override void CreatePieces()
{
for (int i = 0; i < 4; i++)
{
CreatePiece(new PieceWhiteChecker(this), 50 * i + 45, 25);
CreatePiece(new PieceWhiteChecker(this), 50 * i + 70, 50);
CreatePiece(new PieceWhiteChecker(this), 50 * i + 45, 75);
CreatePiece(new PieceBlackChecker(this), 50 * i + 70, 150);
CreatePiece(new PieceBlackChecker(this), 50 * i + 45, 175);
CreatePiece(new PieceBlackChecker(this), 50 * i + 70, 200);
}
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

52
Projects/Scripts/Items/Games/CheckersPieces.cs Normal file
View file

@ -0,0 +1,52 @@
namespace Server.Items
{
public class PieceWhiteChecker : BasePiece
{
public PieceWhiteChecker(BaseBoard board) : base(0x3584, board)
{
}
public PieceWhiteChecker(Serial serial) : base(serial)
{
}
public override string DefaultName => "white checker";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceBlackChecker : BasePiece
{
public PieceBlackChecker(BaseBoard board) : base(0x358B, board)
{
}
public PieceBlackChecker(Serial serial) : base(serial)
{
}
public override string DefaultName => "black checker";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

302
Projects/Scripts/Items/Games/ChessPieces.cs Normal file
View file

@ -0,0 +1,302 @@
namespace Server.Items
{
public class PieceWhiteKing : BasePiece
{
public PieceWhiteKing(BaseBoard board) : base(0x3587, board)
{
}
public PieceWhiteKing(Serial serial) : base(serial)
{
}
public override string DefaultName => "white king";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceBlackKing : BasePiece
{
public PieceBlackKing(BaseBoard board) : base(0x358E, board)
{
}
public PieceBlackKing(Serial serial) : base(serial)
{
}
public override string DefaultName => "black king";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceWhiteQueen : BasePiece
{
public PieceWhiteQueen(BaseBoard board) : base(0x358A, board)
{
}
public PieceWhiteQueen(Serial serial) : base(serial)
{
}
public override string DefaultName => "white queen";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceBlackQueen : BasePiece
{
public PieceBlackQueen(BaseBoard board) : base(0x3591, board)
{
}
public PieceBlackQueen(Serial serial) : base(serial)
{
}
public override string DefaultName => "black queen";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceWhiteRook : BasePiece
{
public PieceWhiteRook(BaseBoard board) : base(0x3586, board)
{
}
public PieceWhiteRook(Serial serial) : base(serial)
{
}
public override string DefaultName => "white rook";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceBlackRook : BasePiece
{
public PieceBlackRook(BaseBoard board) : base(0x358D, board)
{
}
public PieceBlackRook(Serial serial) : base(serial)
{
}
public override string DefaultName => "black rook";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceWhiteBishop : BasePiece
{
public PieceWhiteBishop(BaseBoard board) : base(0x3585, board)
{
}
public PieceWhiteBishop(Serial serial) : base(serial)
{
}
public override string DefaultName => "white bishop";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceBlackBishop : BasePiece
{
public PieceBlackBishop(BaseBoard board) : base(0x358C, board)
{
}
public PieceBlackBishop(Serial serial) : base(serial)
{
}
public override string DefaultName => "black bishop";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceWhiteKnight : BasePiece
{
public PieceWhiteKnight(BaseBoard board) : base(0x3588, board)
{
}
public PieceWhiteKnight(Serial serial) : base(serial)
{
}
public override string DefaultName => "white knight";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceBlackKnight : BasePiece
{
public PieceBlackKnight(BaseBoard board) : base(0x358F, board)
{
}
public PieceBlackKnight(Serial serial) : base(serial)
{
}
public override string DefaultName => "black knight";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceWhitePawn : BasePiece
{
public PieceWhitePawn(BaseBoard board) : base(0x3589, board)
{
}
public PieceWhitePawn(Serial serial) : base(serial)
{
}
public override string DefaultName => "white pawn";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
public class PieceBlackPawn : BasePiece
{
public PieceBlackPawn(BaseBoard board) : base(0x3590, board)
{
}
public PieceBlackPawn(Serial serial) : base(serial)
{
}
public override string DefaultName => "black pawn";
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

66
Projects/Scripts/Items/Games/Chessboard.cs Normal file
View file

@ -0,0 +1,66 @@
namespace Server.Items
{
public class Chessboard : BaseBoard
{
[Constructible]
public Chessboard() : base(0xFA6)
{
}
public Chessboard(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1016450; // a chessboard
public override void CreatePieces()
{
for (int i = 0; i < 8; i++)
{
CreatePiece(new PieceBlackPawn(this), 67, 25 * i + 17);
CreatePiece(new PieceWhitePawn(this), 192, 25 * i + 17);
}
// Rook
CreatePiece(new PieceBlackRook(this), 42, 5);
CreatePiece(new PieceBlackRook(this), 42, 180);
CreatePiece(new PieceWhiteRook(this), 216, 5);
CreatePiece(new PieceWhiteRook(this), 216, 180);
// Knight
CreatePiece(new PieceBlackKnight(this), 42, 30);
CreatePiece(new PieceBlackKnight(this), 42, 155);
CreatePiece(new PieceWhiteKnight(this), 216, 30);
CreatePiece(new PieceWhiteKnight(this), 216, 155);
// Bishop
CreatePiece(new PieceBlackBishop(this), 42, 55);
CreatePiece(new PieceBlackBishop(this), 42, 130);
CreatePiece(new PieceWhiteBishop(this), 216, 55);
CreatePiece(new PieceWhiteBishop(this), 216, 130);
// Queen
CreatePiece(new PieceBlackQueen(this), 42, 105);
CreatePiece(new PieceWhiteQueen(this), 216, 105);
// King
CreatePiece(new PieceBlackKing(this), 42, 80);
CreatePiece(new PieceWhiteKing(this), 216, 80);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0); // version
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

51
Projects/Scripts/Items/Games/Dices.cs Normal file
View file

@ -0,0 +1,51 @@
using Server.Network;
namespace Server.Items
{
public class Dices : Item, ITelekinesisable
{
[Constructible]
public Dices() : base(0xFA7)
{
Weight = 1.0;
}
public Dices(Serial serial) : base(serial)
{
}
public void OnTelekinesis(Mobile from)
{
Effects.SendLocationParticles(EffectItem.Create(Location, Map, EffectItem.DefaultDuration), 0x376A, 9, 32, 5022);
Effects.PlaySound(Location, Map, 0x1F5);
Roll(from);
}
public override void OnDoubleClick(Mobile from)
{
if (!from.InRange(GetWorldLocation(), 2))
return;
Roll(from);
}
public void Roll(Mobile from)
{
PublicOverheadMessage(MessageType.Regular, 0, false,
$"*{from.Name} rolls {Utility.Random(1, 6)}, {Utility.Random(1, 6)}*");
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

64
Projects/Scripts/Items/Games/Mahjong/MahjongDealerIndicator.cs Normal file
View file

@ -0,0 +1,64 @@
namespace Server.Engines.Mahjong
{
public class MahjongDealerIndicator
{
public MahjongDealerIndicator(MahjongGame game, Point2D position, MahjongPieceDirection direction, MahjongWind wind)
{
Game = game;
Position = position;
Direction = direction;
Wind = wind;
}
public MahjongDealerIndicator(MahjongGame game, GenericReader reader)
{
Game = game;
int version = reader.ReadInt();
Position = reader.ReadPoint2D();
Direction = (MahjongPieceDirection)reader.ReadInt();
Wind = (MahjongWind)reader.ReadInt();
}
public MahjongGame Game{ get; }
public Point2D Position{ get; private set; }
public MahjongPieceDirection Direction{ get; private set; }
public MahjongWind Wind{ get; private set; }
public MahjongPieceDim Dimensions => GetDimensions(Position, Direction);
public static MahjongPieceDim GetDimensions(Point2D position, MahjongPieceDirection direction)
{
if (direction == MahjongPieceDirection.Up || direction == MahjongPieceDirection.Down)
return new MahjongPieceDim(position, 40, 20);
return new MahjongPieceDim(position, 20, 40);
}
public void Move(Point2D position, MahjongPieceDirection direction, MahjongWind wind)
{
MahjongPieceDim dim = GetDimensions(position, direction);
if (!dim.IsValid())
return;
Position = position;
Direction = direction;
Wind = wind;
Game.Players.SendGeneralPacket(true, true);
}
public void Save(GenericWriter writer)
{
writer.Write(0); // version
writer.Write(Position);
writer.Write((int)Direction);
writer.Write((int)Wind);
}
}
}

48
Projects/Scripts/Items/Games/Mahjong/MahjongDices.cs Normal file
View file

@ -0,0 +1,48 @@
namespace Server.Engines.Mahjong
{
public class MahjongDices
{
public MahjongDices(MahjongGame game)
{
Game = game;
First = Utility.Random(1, 6);
Second = Utility.Random(1, 6);
}
public MahjongDices(MahjongGame game, GenericReader reader)
{
Game = game;
int version = reader.ReadInt();
First = reader.ReadInt();
Second = reader.ReadInt();
}
public MahjongGame Game{ get; }
public int First{ get; private set; }
public int Second{ get; private set; }
public void RollDices(Mobile from)
{
First = Utility.Random(1, 6);
Second = Utility.Random(1, 6);
Game.Players.SendGeneralPacket(true, true);
if (from != null)
Game.Players.SendLocalizedMessage(1062695,
$"{from.Name}\t{First}\t{Second}"); // ~1_name~ rolls the dice and gets a ~2_number~ and a ~3_number~!
}
public void Save(GenericWriter writer)
{
writer.Write(0); // version
writer.Write(First);
writer.Write(Second);
}
}
}

56
Projects/Scripts/Items/Games/Mahjong/MahjongEnums.cs Normal file
View file

@ -0,0 +1,56 @@
namespace Server.Engines.Mahjong
{
public enum MahjongPieceDirection
{
Up,
Left,
Down,
Right
}
public enum MahjongWind
{
North,
East,
South,
West
}
public enum MahjongTileType
{
Dagger1 = 1,
Dagger2,
Dagger3,
Dagger4,
Dagger5,
Dagger6,
Dagger7,
Dagger8,
Dagger9,
Gem1,
Gem2,
Gem3,
Gem4,
Gem5,
Gem6,
Gem7,
Gem8,
Gem9,
Number1,
Number2,
Number3,
Number4,
Number5,
Number6,
Number7,
Number8,
Number9,
North,
East,
South,
West,
Green,
Red,
White
}
}

298
Projects/Scripts/Items/Games/Mahjong/MahjongGame.cs Normal file
View file

@ -0,0 +1,298 @@
using System;
using System.Collections.Generic;
using Server.ContextMenus;
using Server.Gumps;
using Server.Multis;
namespace Server.Engines.Mahjong
{
public class MahjongGame : Item, ISecurable
{
public const int MaxPlayers = 4;
public const int BaseScore = 30000;
private DateTime m_LastReset;
private bool m_ShowScores;
private bool m_SpectatorVision;
[Constructible]
public MahjongGame() : base(0xFAA)
{
Weight = 5.0;
BuildWalls();
DealerIndicator =
new MahjongDealerIndicator(this, new Point2D(300, 300), MahjongPieceDirection.Up, MahjongWind.North);
WallBreakIndicator = new MahjongWallBreakIndicator(this, new Point2D(335, 335));
Dices = new MahjongDices(this);
Players = new MahjongPlayers(this, MaxPlayers, BaseScore);
m_LastReset = DateTime.UtcNow;
Level = SecureLevel.CoOwners;
}
public MahjongGame(Serial serial) : base(serial)
{
}
public MahjongTile[] Tiles{ get; private set; }
public MahjongDealerIndicator DealerIndicator{ get; private set; }
public MahjongWallBreakIndicator WallBreakIndicator{ get; private set; }
public MahjongDices Dices{ get; private set; }
public MahjongPlayers Players{ get; private set; }
[CommandProperty(AccessLevel.GameMaster)]
public bool ShowScores
{
get => m_ShowScores;
set
{
if (m_ShowScores == value)
return;
m_ShowScores = value;
if (value)
Players.SendPlayersPacket(true, true);
Players.SendGeneralPacket(true, true);
Players.SendLocalizedMessage(value ? 1062777 : 1062778); // The dealer has enabled/disabled score display.
}
}
[CommandProperty(AccessLevel.GameMaster)]
public bool SpectatorVision
{
get => m_SpectatorVision;
set
{
if (m_SpectatorVision == value)
return;
m_SpectatorVision = value;
if (Players.IsInGamePlayer(Players.DealerPosition))
Players.Dealer.Send(new MahjongGeneralInfo(this));
Players.SendTilesPacket(false, true);
Players.SendLocalizedMessage(value ? 1062715 : 1062716); // The dealer has enabled/disabled Spectator Vision.
InvalidateProperties();
}
}
[CommandProperty(AccessLevel.GameMaster)]
public SecureLevel Level{ get; set; }
private void BuildHorizontalWall(ref int index, int x, int y, int stackLevel, MahjongPieceDirection direction,
MahjongTileTypeGenerator typeGenerator)
{
for (int i = 0; i < 17; i++)
{
Point2D position = new Point2D(x + i * 20, y);
Tiles[index + i] = new MahjongTile(this, index + i, typeGenerator.Next(), position, stackLevel, direction,
false);
}
index += 17;
}
private void BuildVerticalWall(ref int index, int x, int y, int stackLevel, MahjongPieceDirection direction,
MahjongTileTypeGenerator typeGenerator)
{
for (int i = 0; i < 17; i++)
{
Point2D position = new Point2D(x, y + i * 20);
Tiles[index + i] = new MahjongTile(this, index + i, typeGenerator.Next(), position, stackLevel, direction,
false);
}
index += 17;
}
private void BuildWalls()
{
Tiles = new MahjongTile[136];
MahjongTileTypeGenerator typeGenerator = new MahjongTileTypeGenerator();
int i = 0;
BuildHorizontalWall(ref i, 165, 110, 0, MahjongPieceDirection.Up, typeGenerator);
BuildHorizontalWall(ref i, 165, 115, 1, MahjongPieceDirection.Up, typeGenerator);
BuildVerticalWall(ref i, 530, 165, 0, MahjongPieceDirection.Left, typeGenerator);
BuildVerticalWall(ref i, 525, 165, 1, MahjongPieceDirection.Left, typeGenerator);
BuildHorizontalWall(ref i, 165, 530, 0, MahjongPieceDirection.Down, typeGenerator);
BuildHorizontalWall(ref i, 165, 525, 1, MahjongPieceDirection.Down, typeGenerator);
BuildVerticalWall(ref i, 110, 165, 0, MahjongPieceDirection.Right, typeGenerator);
BuildVerticalWall(ref i, 115, 165, 1, MahjongPieceDirection.Right, typeGenerator);
}
public override void GetProperties(ObjectPropertyList list)
{
base.GetProperties(list);
if (m_SpectatorVision)
list.Add(1062717); // Spectator Vision Enabled
else
list.Add(1062718); // Spectator Vision Disabled
}
public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
{
base.GetContextMenuEntries(from, list);
Players.CheckPlayers();
if (from.Alive && IsAccessibleTo(from) && Players.GetInGameMobiles(true, false).Count == 0)
list.Add(new ResetGameEntry(this));
SetSecureLevelEntry.AddTo(from, this, list);
}
public override void OnDoubleClick(Mobile from)
{
Players.CheckPlayers();
Players.Join(from);
}
public void ResetGame(Mobile from)
{
if (DateTime.UtcNow - m_LastReset < TimeSpan.FromSeconds(5.0))
return;
m_LastReset = DateTime.UtcNow;
if (from != null)
Players.SendLocalizedMessage(1062771, from.Name); // ~1_name~ has reset the game.
Players.SendRelievePacket(true, true);
BuildWalls();
DealerIndicator =
new MahjongDealerIndicator(this, new Point2D(300, 300), MahjongPieceDirection.Up, MahjongWind.North);
WallBreakIndicator = new MahjongWallBreakIndicator(this, new Point2D(335, 335));
Players = new MahjongPlayers(this, MaxPlayers, BaseScore);
}
public void ResetWalls(Mobile from)
{
if (DateTime.UtcNow - m_LastReset < TimeSpan.FromSeconds(5.0))
return;
m_LastReset = DateTime.UtcNow;
BuildWalls();
Players.SendTilesPacket(true, true);
if (from != null)
Players.SendLocalizedMessage(1062696); // The dealer rebuilds the wall.
}
public int GetStackLevel(MahjongPieceDim dim)
{
int level = -1;
foreach (MahjongTile tile in Tiles)
if (tile.StackLevel > level && dim.IsOverlapping(tile.Dimensions))
level = tile.StackLevel;
return level;
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(1); // version
writer.Write((int)Level);
writer.Write(Tiles.Length);
for (int i = 0; i < Tiles.Length; i++)
Tiles[i].Save(writer);
DealerIndicator.Save(writer);
WallBreakIndicator.Save(writer);
Dices.Save(writer);
Players.Save(writer);
writer.Write(m_ShowScores);
writer.Write(m_SpectatorVision);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 1:
{
Level = (SecureLevel)reader.ReadInt();
goto case 0;
}
case 0:
{
if (version < 1)
Level = SecureLevel.CoOwners;
int length = reader.ReadInt();
Tiles = new MahjongTile[length];
for (int i = 0; i < length; i++)
Tiles[i] = new MahjongTile(this, reader);
DealerIndicator = new MahjongDealerIndicator(this, reader);
WallBreakIndicator = new MahjongWallBreakIndicator(this, reader);
Dices = new MahjongDices(this, reader);
Players = new MahjongPlayers(this, reader);
m_ShowScores = reader.ReadBool();
m_SpectatorVision = reader.ReadBool();
m_LastReset = DateTime.UtcNow;
break;
}
}
}
private class ResetGameEntry : ContextMenuEntry
{
private MahjongGame m_Game;
public ResetGameEntry(MahjongGame game) : base(6162)
{
m_Game = game;
}
public override void OnClick()
{
Mobile from = Owner.From;
if (from.CheckAlive() && !m_Game.Deleted && m_Game.IsAccessibleTo(from) &&
m_Game.Players.GetInGameMobiles(true, false).Count == 0)
m_Game.ResetGame(from);
}
}
}
}

233
Projects/Scripts/Items/Games/Mahjong/MahjongPacketHandlers.cs Normal file
View file

@ -0,0 +1,233 @@
using Server.Network;
namespace Server.Engines.Mahjong
{
public delegate void OnMahjongPacketReceive(MahjongGame game, NetState state, PacketReader pvSrc);
public sealed class MahjongPacketHandlers
{
private static OnMahjongPacketReceive[] m_SubCommandDelegates = new OnMahjongPacketReceive[0x100];
public static void RegisterSubCommand(int subCmd, OnMahjongPacketReceive onReceive)
{
m_SubCommandDelegates[subCmd] = onReceive;
}
public static OnMahjongPacketReceive GetSubCommandDelegate(int cmd)
{
if (cmd >= 0 && cmd < 0x100) return m_SubCommandDelegates[cmd];
return null;
}
public static void Initialize()
{
PacketHandlers.Register(0xDA, 0, true, OnPacket);
RegisterSubCommand(0x6, ExitGame);
RegisterSubCommand(0xA, GivePoints);
RegisterSubCommand(0xB, RollDice);
RegisterSubCommand(0xC, BuildWalls);
RegisterSubCommand(0xD, ResetScores);
RegisterSubCommand(0xF, AssignDealer);
RegisterSubCommand(0x10, OpenSeat);
RegisterSubCommand(0x11, ChangeOption);
RegisterSubCommand(0x15, MoveWallBreakIndicator);
RegisterSubCommand(0x16, TogglePublicHand);
RegisterSubCommand(0x17, MoveTile);
RegisterSubCommand(0x18, MoveDealerIndicator);
}
public static void OnPacket(NetState state, PacketReader pvSrc)
{
MahjongGame game = World.FindItem(pvSrc.ReadUInt32()) as MahjongGame;
game?.Players.CheckPlayers();
pvSrc.ReadByte();
int cmd = pvSrc.ReadByte();
OnMahjongPacketReceive onReceive = GetSubCommandDelegate(cmd);
if (onReceive != null)
onReceive(game, state, pvSrc);
else
pvSrc.Trace(state);
}
private static MahjongPieceDirection GetDirection(int value)
{
switch (value)
{
case 0: return MahjongPieceDirection.Up;
case 1: return MahjongPieceDirection.Left;
case 2: return MahjongPieceDirection.Down;
default: return MahjongPieceDirection.Right;
}
}
private static MahjongWind GetWind(int value)
{
switch (value)
{
case 0: return MahjongWind.North;
case 1: return MahjongWind.East;
case 2: return MahjongWind.South;
default: return MahjongWind.West;
}
}
public static void ExitGame(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null)
return;
Mobile from = state.Mobile;
game.Players.LeaveGame(from);
}
public static void GivePoints(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGamePlayer(state.Mobile))
return;
int to = pvSrc.ReadByte();
int amount = pvSrc.ReadInt32();
game.Players.TransferScore(state.Mobile, to, amount);
}
public static void RollDice(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGamePlayer(state.Mobile))
return;
game.Dices.RollDices(state.Mobile);
}
public static void BuildWalls(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGameDealer(state.Mobile))
return;
game.ResetWalls(state.Mobile);
}
public static void ResetScores(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGameDealer(state.Mobile))
return;
game.Players.ResetScores(MahjongGame.BaseScore);
}
public static void AssignDealer(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGameDealer(state.Mobile))
return;
int position = pvSrc.ReadByte();
game.Players.AssignDealer(position);
}
public static void OpenSeat(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGameDealer(state.Mobile))
return;
int position = pvSrc.ReadByte();
if (game.Players.GetPlayer(position) == state.Mobile)
return;
game.Players.OpenSeat(position);
}
public static void ChangeOption(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGameDealer(state.Mobile))
return;
pvSrc.ReadInt16();
pvSrc.ReadByte();
int options = pvSrc.ReadByte();
game.ShowScores = (options & 0x1) != 0;
game.SpectatorVision = (options & 0x2) != 0;
}
public static void MoveWallBreakIndicator(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGameDealer(state.Mobile))
return;
int y = pvSrc.ReadInt16();
int x = pvSrc.ReadInt16();
game.WallBreakIndicator.Move(new Point2D(x, y));
}
public static void TogglePublicHand(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGamePlayer(state.Mobile))
return;
pvSrc.ReadInt16();
pvSrc.ReadByte();
bool publicHand = pvSrc.ReadBoolean();
game.Players.SetPublic(game.Players.GetPlayerIndex(state.Mobile), publicHand);
}
public static void MoveTile(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGamePlayer(state.Mobile))
return;
int number = pvSrc.ReadByte();
if (number < 0 || number >= game.Tiles.Length)
return;
pvSrc.ReadByte(); // Current direction
MahjongPieceDirection direction = GetDirection(pvSrc.ReadByte());
pvSrc.ReadByte();
bool flip = pvSrc.ReadBoolean();
pvSrc.ReadInt16(); // Current Y
pvSrc.ReadInt16(); // Current X
pvSrc.ReadByte();
int y = pvSrc.ReadInt16();
int x = pvSrc.ReadInt16();
pvSrc.ReadByte();
game.Tiles[number].Move(new Point2D(x, y), direction, flip, game.Players.GetPlayerIndex(state.Mobile));
}
public static void MoveDealerIndicator(MahjongGame game, NetState state, PacketReader pvSrc)
{
if (game == null || !game.Players.IsInGameDealer(state.Mobile))
return;
MahjongPieceDirection direction = GetDirection(pvSrc.ReadByte());
MahjongWind wind = GetWind(pvSrc.ReadByte());
int y = pvSrc.ReadInt16();
int x = pvSrc.ReadInt16();
game.DealerIndicator.Move(new Point2D(x, y), direction, wind);
}
}
}

46
Projects/Scripts/Items/Games/Mahjong/MahjongPieceDim.cs Normal file
View file

@ -0,0 +1,46 @@
namespace Server.Engines.Mahjong
{
public struct MahjongPieceDim
{
public Point2D Position{ get; }
public int Width{ get; }
public int Height{ get; }
public MahjongPieceDim(Point2D position, int width, int height)
{
Position = position;
Width = width;
Height = height;
}
public bool IsValid()
{
return Position.X >= 0 && Position.Y >= 0 && Position.X + Width <= 670 && Position.Y + Height <= 670;
}
public bool IsOverlapping(MahjongPieceDim dim)
{
return Position.X < dim.Position.X + dim.Width && Position.Y < dim.Position.Y + dim.Height &&
Position.X + Width > dim.Position.X && Position.Y + Height > dim.Position.Y;
}
public int GetHandArea()
{
if (Position.X + Width > 150 && Position.X < 520 && Position.Y < 35)
return 0;
if (Position.X + Width > 635 && Position.Y + Height > 150 && Position.Y < 520)
return 1;
if (Position.X + Width > 150 && Position.X < 520 && Position.Y + Height > 635)
return 2;
if (Position.X < 35 && Position.Y + Height > 150 && Position.Y < 520)
return 3;
return -1;
}
}
}

505
Projects/Scripts/Items/Games/Mahjong/MahjongPlayers.cs Normal file
View file

@ -0,0 +1,505 @@
using System.Collections.Generic;
namespace Server.Engines.Mahjong
{
public class MahjongPlayers
{
private bool[] m_InGame;
private Mobile[] m_Players;
private bool[] m_PublicHand;
private int[] m_Scores;
private List<Mobile> m_Spectators;
public MahjongPlayers(MahjongGame game, int maxPlayers, int baseScore)
{
Game = game;
m_Spectators = new List<Mobile>();
m_Players = new Mobile[maxPlayers];
m_InGame = new bool[maxPlayers];
m_PublicHand = new bool[maxPlayers];
m_Scores = new int[maxPlayers];
for (int i = 0; i < m_Scores.Length; i++)
m_Scores[i] = baseScore;
}
public MahjongPlayers(MahjongGame game, GenericReader reader)
{
Game = game;
m_Spectators = new List<Mobile>();
int version = reader.ReadInt();
int seats = reader.ReadInt();
m_Players = new Mobile[seats];
m_InGame = new bool[seats];
m_PublicHand = new bool[seats];
m_Scores = new int[seats];
for (int i = 0; i < seats; i++)
{
m_Players[i] = reader.ReadMobile();
m_PublicHand[i] = reader.ReadBool();
m_Scores[i] = reader.ReadInt();
}
DealerPosition = reader.ReadInt();
}
public MahjongGame Game{ get; }
public int Seats => m_Players.Length;
public Mobile Dealer => m_Players[DealerPosition];
public int DealerPosition{ get; private set; }
public Mobile GetPlayer(int index)
{
if (index < 0 || index >= m_Players.Length)
return null;
return m_Players[index];
}
public int GetPlayerIndex(Mobile mobile)
{
for (int i = 0; i < m_Players.Length; i++)
if (m_Players[i] == mobile)
return i;
return -1;
}
public bool IsInGameDealer(Mobile mobile)
{
if (Dealer != mobile)
return false;
return m_InGame[DealerPosition];
}
public bool IsInGamePlayer(int index)
{
if (index < 0 || index >= m_Players.Length || m_Players[index] == null)
return false;
return m_InGame[index];
}
public bool IsInGamePlayer(Mobile mobile)
{
int index = GetPlayerIndex(mobile);
return IsInGamePlayer(index);
}
public bool IsSpectator(Mobile mobile)
{
return m_Spectators.Contains(mobile);
}
public int GetScore(int index)
{
if (index < 0 || index >= m_Scores.Length)
return 0;
return m_Scores[index];
}
public bool IsPublic(int index)
{
if (index < 0 || index >= m_PublicHand.Length)
return false;
return m_PublicHand[index];
}
public void SetPublic(int index, bool value)
{
if (index < 0 || index >= m_PublicHand.Length || m_PublicHand[index] == value)
return;
m_PublicHand[index] = value;
SendTilesPacket(true, !Game.SpectatorVision);
if (IsInGamePlayer(index))
m_Players[index].SendLocalizedMessage(value ? 1062775 : 1062776); // Your hand is [not] publicly viewable.
}
public List<Mobile> GetInGameMobiles(bool players, bool spectators)
{
List<Mobile> list = new List<Mobile>();
if (players)
for (int i = 0; i < m_Players.Length; i++)
if (IsInGamePlayer(i))
list.Add(m_Players[i]);
if (spectators)
list.AddRange(m_Spectators);
return list;
}
public void CheckPlayers()
{
bool removed = false;
for (int i = 0; i < m_Players.Length; i++)
{
Mobile player = m_Players[i];
if (player == null)
continue;
if (player.Deleted)
{
m_Players[i] = null;
SendPlayerExitMessage(player);
UpdateDealer(true);
removed = true;
}
else if (m_InGame[i])
{
if (player.NetState == null)
{
m_InGame[i] = false;
SendPlayerExitMessage(player);
UpdateDealer(true);
removed = true;
}
else if (!Game.IsAccessibleTo(player) || player.Map != Game.Map ||
!player.InRange(Game.GetWorldLocation(), 5))
{
m_InGame[i] = false;
player.Send(new MahjongRelieve(Game));
SendPlayerExitMessage(player);
UpdateDealer(true);
removed = true;
}
}
}
for (int i = 0; i < m_Spectators.Count;)
{
Mobile mobile = m_Spectators[i];
if (mobile.NetState == null || mobile.Deleted)
{
m_Spectators.RemoveAt(i);
}
else if (!Game.IsAccessibleTo(mobile) || mobile.Map != Game.Map ||
!mobile.InRange(Game.GetWorldLocation(), 5))
{
m_Spectators.RemoveAt(i);
mobile.Send(new MahjongRelieve(Game));
}
else
{
i++;
}
}
if (removed && !UpdateSpectators())
SendPlayersPacket(true, true);
}
private void UpdateDealer(bool message)
{
if (IsInGamePlayer(DealerPosition))
return;
for (int i = DealerPosition + 1; i < m_Players.Length; i++)
if (IsInGamePlayer(i))
{
DealerPosition = i;
if (message)
SendDealerChangedMessage();
return;
}
for (int i = 0; i < DealerPosition; i++)
if (IsInGamePlayer(i))
{
DealerPosition = i;
if (message)
SendDealerChangedMessage();
return;
}
}
private int GetNextSeat()
{
for (int i = DealerPosition; i < m_Players.Length; i++)
if (m_Players[i] == null)
return i;
for (int i = 0; i < DealerPosition; i++)
if (m_Players[i] == null)
return i;
return -1;
}
private bool UpdateSpectators()
{
if (m_Spectators.Count == 0)
return false;
int nextSeat = GetNextSeat();
if (nextSeat >= 0)
{
Mobile newPlayer = m_Spectators[0];
m_Spectators.RemoveAt(0);
AddPlayer(newPlayer, nextSeat, false);
UpdateSpectators();
return true;
}
return false;
}
private void AddPlayer(Mobile player, int index, bool sendJoinGame)
{
m_Players[index] = player;
m_InGame[index] = true;
UpdateDealer(false);
if (sendJoinGame)
player.Send(new MahjongJoinGame(Game));
SendPlayersPacket(true, true);
player.Send(new MahjongGeneralInfo(Game));
player.Send(new MahjongTilesInfo(Game, player));
if (DealerPosition == index)
SendLocalizedMessage(1062773, player.Name); // ~1_name~ has entered the game as the dealer.
else
SendLocalizedMessage(1062772, player.Name); // ~1_name~ has entered the game as a player.
}
private void AddSpectator(Mobile mobile)
{
if (!IsSpectator(mobile)) m_Spectators.Add(mobile);
mobile.Send(new MahjongJoinGame(Game));
mobile.Send(new MahjongPlayersInfo(Game, mobile));
mobile.Send(new MahjongGeneralInfo(Game));
mobile.Send(new MahjongTilesInfo(Game, mobile));
}
public void Join(Mobile mobile)
{
int index = GetPlayerIndex(mobile);
if (index >= 0)
{
AddPlayer(mobile, index, true);
}
else
{
int nextSeat = GetNextSeat();
if (nextSeat >= 0)
AddPlayer(mobile, nextSeat, true);
else
AddSpectator(mobile);
}
}
public void LeaveGame(Mobile player)
{
int index = GetPlayerIndex(player);
if (index >= 0)
{
m_InGame[index] = false;
SendPlayerExitMessage(player);
UpdateDealer(true);
SendPlayersPacket(true, true);
}
else
{
m_Spectators.Remove(player);
}
}
public void ResetScores(int value)
{
for (int i = 0; i < m_Scores.Length; i++) m_Scores[i] = value;
SendPlayersPacket(true, Game.ShowScores);
SendLocalizedMessage(1062697); // The dealer redistributes the score sticks evenly.
}
public void TransferScore(Mobile from, int toPosition, int amount)
{
int fromPosition = GetPlayerIndex(from);
Mobile to = GetPlayer(toPosition);
if (fromPosition < 0 || to == null || m_Scores[fromPosition] < amount)
return;
m_Scores[fromPosition] -= amount;
m_Scores[toPosition] += amount;
if (Game.ShowScores)
{
SendPlayersPacket(true, true);
}
else
{
from.Send(new MahjongPlayersInfo(Game, from));
to.Send(new MahjongPlayersInfo(Game, to));
}
SendLocalizedMessage(1062774,
$"{from.Name}\t{to.Name}\t{amount}"); // ~1_giver~ gives ~2_receiver~ ~3_number~ points.
}
public void OpenSeat(int index)
{
Mobile player = GetPlayer(index);
if (player == null)
return;
if (m_InGame[index])
player.Send(new MahjongRelieve(Game));
m_Players[index] = null;
SendLocalizedMessage(1062699, player.Name); // ~1_name~ is relieved from the game by the dealer.
UpdateDealer(true);
if (!UpdateSpectators())
SendPlayersPacket(true, true);
}
public void AssignDealer(int index)
{
Mobile to = GetPlayer(index);
if (to == null || !m_InGame[index])
return;
int oldDealer = DealerPosition;
DealerPosition = index;
if (IsInGamePlayer(oldDealer))
m_Players[oldDealer].Send(new MahjongPlayersInfo(Game, m_Players[oldDealer]));
to.Send(new MahjongPlayersInfo(Game, to));
SendDealerChangedMessage();
}
private void SendDealerChangedMessage()
{
if (Dealer != null)
SendLocalizedMessage(1062698, Dealer.Name); // ~1_name~ is assigned the dealer.
}
private void SendPlayerExitMessage(Mobile who)
{
SendLocalizedMessage(1062762, who.Name); // ~1_name~ has left the game.
}
public void SendPlayersPacket(bool players, bool spectators)
{
foreach (Mobile mobile in GetInGameMobiles(players, spectators))
mobile.Send(new MahjongPlayersInfo(Game, mobile));
}
public void SendGeneralPacket(bool players, bool spectators)
{
List<Mobile> mobiles = GetInGameMobiles(players, spectators);
if (mobiles.Count == 0)
return;
MahjongGeneralInfo generalInfo = new MahjongGeneralInfo(Game);
generalInfo.Acquire();
foreach (Mobile mobile in mobiles)
mobile.Send(generalInfo);
generalInfo.Release();
}
public void SendTilesPacket(bool players, bool spectators)
{
foreach (Mobile mobile in GetInGameMobiles(players, spectators))
mobile.Send(new MahjongTilesInfo(Game, mobile));
}
public void SendTilePacket(MahjongTile tile, bool players, bool spectators)
{
foreach (Mobile mobile in GetInGameMobiles(players, spectators))
mobile.Send(new MahjongTileInfo(tile, mobile));
}
public void SendRelievePacket(bool players, bool spectators)
{
List<Mobile> mobiles = GetInGameMobiles(players, spectators);
if (mobiles.Count == 0)
return;
MahjongRelieve relieve = new MahjongRelieve(Game);
relieve.Acquire();
foreach (Mobile mobile in mobiles)
mobile.Send(relieve);
relieve.Release();
}
public void SendLocalizedMessage(int number)
{
foreach (Mobile mobile in GetInGameMobiles(true, true))
mobile.SendLocalizedMessage(number);
}
public void SendLocalizedMessage(int number, string args)
{
foreach (Mobile mobile in GetInGameMobiles(true, true))
mobile.SendLocalizedMessage(number, args);
}
public void Save(GenericWriter writer)
{
writer.Write(0); // version
writer.Write(Seats);
for (int i = 0; i < Seats; i++)
{
writer.Write(m_Players[i]);
writer.Write(m_PublicHand[i]);
writer.Write(m_Scores[i]);
}
writer.Write(DealerPosition);
}
}
}

88
Projects/Scripts/Items/Games/Mahjong/MahjongTile.cs Normal file
View file

@ -0,0 +1,88 @@
namespace Server.Engines.Mahjong
{
public class MahjongTile
{
protected Point2D m_Position;
public MahjongTile(MahjongGame game, int number, MahjongTileType value, Point2D position, int stackLevel,
MahjongPieceDirection direction, bool flipped)
{
Game = game;
Number = number;
Value = value;
m_Position = position;
StackLevel = stackLevel;
Direction = direction;
Flipped = flipped;
}
public MahjongTile(MahjongGame game, GenericReader reader)
{
Game = game;
int version = reader.ReadInt();
Number = reader.ReadInt();
Value = (MahjongTileType)reader.ReadInt();
m_Position = reader.ReadPoint2D();
StackLevel = reader.ReadInt();
Direction = (MahjongPieceDirection)reader.ReadInt();
Flipped = reader.ReadBool();
}
public MahjongGame Game{ get; }
public int Number{ get; }
public MahjongTileType Value{ get; }
public Point2D Position => m_Position;
public int StackLevel{ get; private set; }
public MahjongPieceDirection Direction{ get; private set; }
public bool Flipped{ get; private set; }
public MahjongPieceDim Dimensions => GetDimensions(m_Position, Direction);
public bool IsMovable => Game.GetStackLevel(Dimensions) <= StackLevel;
public static MahjongPieceDim GetDimensions(Point2D position, MahjongPieceDirection direction)
{
if (direction == MahjongPieceDirection.Up || direction == MahjongPieceDirection.Down)
return new MahjongPieceDim(position, 20, 30);
return new MahjongPieceDim(position, 30, 20);
}
public void Move(Point2D position, MahjongPieceDirection direction, bool flip, int validHandArea)
{
MahjongPieceDim dim = GetDimensions(position, direction);
int curHandArea = Dimensions.GetHandArea();
int newHandArea = dim.GetHandArea();
if (!IsMovable || !dim.IsValid() || validHandArea >= 0 &&
(curHandArea >= 0 && curHandArea != validHandArea || newHandArea >= 0 && newHandArea != validHandArea))
return;
m_Position = position;
Direction = direction;
StackLevel = -1; // Avoid self interference
StackLevel = Game.GetStackLevel(dim) + 1;
Flipped = flip;
Game.Players.SendTilePacket(this, true, true);
}
public void Save(GenericWriter writer)
{
writer.Write(0); // version
writer.Write(Number);
writer.Write((int)Value);
writer.Write(m_Position);
writer.Write(StackLevel);
writer.Write((int)Direction);
writer.Write(Flipped);
}
}
}

32
Projects/Scripts/Items/Games/Mahjong/MahjongTileTypeGenerator.cs Normal file
View file

@ -0,0 +1,32 @@
using System.Collections.Generic;
namespace Server.Engines.Mahjong
{
public class MahjongTileTypeGenerator
{
public MahjongTileTypeGenerator()
{
LeftTileTypes = new List<MahjongTileType>(136);
for (int i = 1; i <= 34; i++)
{
MahjongTileType tile = (MahjongTileType)i;
LeftTileTypes.Add(tile);
LeftTileTypes.Add(tile);
LeftTileTypes.Add(tile);
LeftTileTypes.Add(tile);
}
}
public List<MahjongTileType> LeftTileTypes{ get; }
public MahjongTileType Next()
{
int random = Utility.Random(LeftTileTypes.Count);
MahjongTileType next = LeftTileTypes[random];
LeftTileTypes.RemoveAt(random);
return next;
}
}
}

50
Projects/Scripts/Items/Games/Mahjong/MahjongWallBreakIndicator.cs Normal file
View file

@ -0,0 +1,50 @@
namespace Server.Engines.Mahjong
{
public class MahjongWallBreakIndicator
{
public MahjongWallBreakIndicator(MahjongGame game, Point2D position)
{
Game = game;
Position = position;
}
public MahjongWallBreakIndicator(MahjongGame game, GenericReader reader)
{
Game = game;
int version = reader.ReadInt();
Position = reader.ReadPoint2D();
}
public MahjongGame Game{ get; }
public Point2D Position{ get; private set; }
public MahjongPieceDim Dimensions => GetDimensions(Position);
public static MahjongPieceDim GetDimensions(Point2D position)
{
return new MahjongPieceDim(position, 20, 20);
}
public void Move(Point2D position)
{
MahjongPieceDim dim = GetDimensions(position);
if (!dim.IsValid())
return;
Position = position;
Game.Players.SendGeneralPacket(true, true);
}
public void Save(GenericWriter writer)
{
writer.Write(0); // version
writer.Write(Position);
}
}
}

209
Projects/Scripts/Items/Games/Mahjong/Packets.cs Normal file
View file

@ -0,0 +1,209 @@
using System.IO;
using Server.Network;
namespace Server.Engines.Mahjong
{
public sealed class MahjongJoinGame : Packet
{
public MahjongJoinGame(MahjongGame game) : base(0xDA)
{
EnsureCapacity(9);
m_Stream.Write(game.Serial);
m_Stream.Write((byte)0);
m_Stream.Write((byte)0x19);
}
}
public sealed class MahjongPlayersInfo : Packet
{
public MahjongPlayersInfo(MahjongGame game, Mobile to) : base(0xDA)
{
MahjongPlayers players = game.Players;
EnsureCapacity(11 + 45 * players.Seats);
m_Stream.Write(game.Serial);
m_Stream.Write((byte)0);
m_Stream.Write((byte)0x2);
m_Stream.Write((byte)0);
m_Stream.Write((byte)players.Seats);
int n = 0;
for (int i = 0; i < players.Seats; i++)
{
Mobile mobile = players.GetPlayer(i);
if (mobile != null)
{
m_Stream.Write(mobile.Serial);
m_Stream.Write(players.DealerPosition == i ? (byte)0x1 : (byte)0x2);
m_Stream.Write((byte)i);
if (game.ShowScores || mobile == to)
m_Stream.Write(players.GetScore(i));
else
m_Stream.Write(0);
m_Stream.Write((short)0);
m_Stream.Write((byte)0);
m_Stream.Write(players.IsPublic(i));
m_Stream.WriteAsciiFixed(mobile.Name, 30);
m_Stream.Write(!players.IsInGamePlayer(i));
n++;
}
else if (game.ShowScores)
{
m_Stream.Write(0);
m_Stream.Write((byte)0x2);
m_Stream.Write((byte)i);
m_Stream.Write(players.GetScore(i));
m_Stream.Write((short)0);
m_Stream.Write((byte)0);
m_Stream.Write(players.IsPublic(i));
m_Stream.WriteAsciiFixed("", 30);
m_Stream.Write(true);
n++;
}
}
if (n != players.Seats)
{
m_Stream.Seek(10, SeekOrigin.Begin);
m_Stream.Write((byte)n);
}
}
}
public sealed class MahjongGeneralInfo : Packet
{
public MahjongGeneralInfo(MahjongGame game) : base(0xDA)
{
EnsureCapacity(13);
m_Stream.Write(game.Serial);
m_Stream.Write((byte)0);
m_Stream.Write((byte)0x5);
m_Stream.Write((short)0);
m_Stream.Write((byte)0);
m_Stream.Write((byte)((game.ShowScores ? 0x1 : 0x0) | (game.SpectatorVision ? 0x2 : 0x0)));
m_Stream.Write((byte)game.Dices.First);
m_Stream.Write((byte)game.Dices.Second);
m_Stream.Write((byte)game.DealerIndicator.Wind);
m_Stream.Write((short)game.DealerIndicator.Position.Y);
m_Stream.Write((short)game.DealerIndicator.Position.X);
m_Stream.Write((byte)game.DealerIndicator.Direction);
m_Stream.Write((short)game.WallBreakIndicator.Position.Y);
m_Stream.Write((short)game.WallBreakIndicator.Position.X);
}
}
public sealed class MahjongTilesInfo : Packet
{
public MahjongTilesInfo(MahjongGame game, Mobile to) : base(0xDA)
{
MahjongTile[] tiles = game.Tiles;
MahjongPlayers players = game.Players;
EnsureCapacity(11 + 9 * tiles.Length);
m_Stream.Write(game.Serial);
m_Stream.Write((byte)0);
m_Stream.Write((byte)0x4);
m_Stream.Write((short)tiles.Length);
foreach (MahjongTile tile in tiles)
{
m_Stream.Write((byte)tile.Number);
if (tile.Flipped)
{
int hand = tile.Dimensions.GetHandArea();
if (hand < 0 || players.IsPublic(hand) || players.GetPlayer(hand) == to ||
game.SpectatorVision && players.IsSpectator(to))
m_Stream.Write((byte)tile.Value);
else
m_Stream.Write((byte)0);
}
else
{
m_Stream.Write((byte)0);
}
m_Stream.Write((short)tile.Position.Y);
m_Stream.Write((short)tile.Position.X);
m_Stream.Write((byte)tile.StackLevel);
m_Stream.Write((byte)tile.Direction);
m_Stream.Write(tile.Flipped ? (byte)0x10 : (byte)0x0);
}
}
}
public sealed class MahjongTileInfo : Packet
{
public MahjongTileInfo(MahjongTile tile, Mobile to) : base(0xDA)
{
MahjongGame game = tile.Game;
MahjongPlayers players = game.Players;
EnsureCapacity(18);
m_Stream.Write(tile.Game.Serial);
m_Stream.Write((byte)0);
m_Stream.Write((byte)0x3);
m_Stream.Write((byte)tile.Number);
if (tile.Flipped)
{
int hand = tile.Dimensions.GetHandArea();
if (hand < 0 || players.IsPublic(hand) || players.GetPlayer(hand) == to ||
game.SpectatorVision && players.IsSpectator(to))
m_Stream.Write((byte)tile.Value);
else
m_Stream.Write((byte)0);
}
else
{
m_Stream.Write((byte)0);
}
m_Stream.Write((short)tile.Position.Y);
m_Stream.Write((short)tile.Position.X);
m_Stream.Write((byte)tile.StackLevel);
m_Stream.Write((byte)tile.Direction);
m_Stream.Write(tile.Flipped ? (byte)0x10 : (byte)0x0);
}
}
public sealed class MahjongRelieve : Packet
{
public MahjongRelieve(MahjongGame game) : base(0xDA)
{
EnsureCapacity(9);
m_Stream.Write(game.Serial);
m_Stream.Write((byte)0);
m_Stream.Write((byte)0x1A);
}
}
}