private static void WriteUserValue(PacketWriter pWriter, GameEventUserValue userValue)
{
pWriter.Write(userValue.EventType);
pWriter.WriteInt(userValue.EventId);
pWriter.WriteUnicodeString(userValue.EventValue);
pWriter.WriteLong(userValue.ExpirationTimestamp);
}
public void Update(GameEventUserValue userValue)
{
QueryFactory.Query(TableName).Where("id", userValue.Id).Update(new
{
event_value = userValue.EventValue,
expiration_timestamp = userValue.ExpirationTimestamp
});
}
public static PacketWriter UpdateValue(GameEventUserValue userValue)
{
PacketWriter pWriter = PacketWriter.Of(SendOp.GameEventUserValue);
pWriter.Write(GameEventUserValuePacketMode.UpdateValue);
pWriter.WriteByte();
WriteUserValue(pWriter, userValue);
return(pWriter);
}
private static void HandleEarlyParticipation(GameSession session, PacketReader packet)
{
int eventId = packet.ReadInt();
AttendGift attendanceEvent = DatabaseManager.Events.FindAttendGiftEvent();
if (attendanceEvent is null || attendanceEvent.SkipDayCurrencyType == GameEventCurrencyType.None)
{
return;
}
GameEventUserValue skipDay = GameEventHelper.GetUserValue(session.Player, attendanceEvent.Id,
attendanceEvent.EndTimestamp, GameEventUserValueType.AttendanceEarlyParticipationRemaining);
int.TryParse(skipDay.EventValue, out int skipsTotal);
if (skipsTotal >= attendanceEvent.SkipDaysAllowed)
{
return;
}
// Charge player
CurrencyType currencyType = attendanceEvent.SkipDayCurrencyType switch
{
GameEventCurrencyType.Meso => CurrencyType.Meso,
GameEventCurrencyType.Meret => CurrencyType.Meret,
_ => CurrencyType.Meret
};
switch (currencyType)
{
case CurrencyType.Meso:
if (!session.Player.Wallet.Meso.Modify(-attendanceEvent.SkipDayCost))
{
return;
}
break;
case CurrencyType.Meret:
if (!session.Player.Account.Meret.Modify(-attendanceEvent.SkipDayCost))
{
return;
}
break;
default:
return;
}
skipsTotal++;
skipDay.UpdateValue(session, skipsTotal);
UpdateRewardsClaimed(session, attendanceEvent);
}
public long Insert(GameEventUserValue value)
{
return(QueryFactory.Query(TableName).InsertGetId <long>(new
{
character_id = value.CharacterId,
type = value.EventType,
event_value = value.EventValue,
event_id = value.EventId,
expiration_timestamp = value.ExpirationTimestamp,
}));
}
public static GameEventUserValue GetUserValue(Player player, int eventId, long expirationTimestamp, GameEventUserValueType type)
{
GameEventUserValue userValue = player.EventUserValues.FirstOrDefault(x => x.EventId == eventId && x.EventType == type);
if (userValue is null)
{
userValue = new(player.CharacterId, type, "", eventId, expirationTimestamp);
player.EventUserValues.Add(userValue);
}
return(userValue);
}
private static void UpdateRewardsClaimed(GameSession session, AttendGift attendanceEvent)
{
GameEventUserValue rewardsClaimValue = GameEventHelper.GetUserValue(session.Player, attendanceEvent.Id,
attendanceEvent.EndTimestamp, GameEventUserValueType.AttendanceRewardsClaimed);
int.TryParse(rewardsClaimValue.EventValue, out int convertedValue);
convertedValue++;
GiveAttendanceReward(session, attendanceEvent, convertedValue);
rewardsClaimValue.UpdateValue(session, convertedValue);
}
private static void HandleClaimReward(GameSession session, PacketReader packet)
{
int rewardTier = packet.ReadInt();
RPS rpsEvent = DatabaseManager.Events.FindRockPaperScissorsEvent();
if (rpsEvent is null)
{
return;
}
GameEventUserValue rewardsAccumulatedValue = GameEventHelper.GetUserValue(session.Player, rpsEvent.Id,
TimeInfo.Tomorrow(), GameEventUserValueType.RPSRewardsClaimed);
List <string> rewardsClaimedStrings = rewardsAccumulatedValue.EventValue.Split(",").ToList();
foreach (string rewardString in rewardsClaimedStrings)
{
// User has not claimed any rewards
if (rewardString == "")
{
break;
}
if (int.TryParse(rewardString, out int rewardInt) && rewardInt == rewardTier)
{
return;
}
}
RPSTier tier = rpsEvent.Tiers.ElementAtOrDefault(rewardTier);
if (tier is null)
{
return;
}
foreach (RPSReward reward in tier.Rewards)
{
Item item = new(reward.ItemId, reward.ItemAmount, reward.ItemRarity);
session.Player.Inventory.AddItem(session, item, true);
}
// update event value
rewardsClaimedStrings.Add(rewardTier.ToString());
rewardsAccumulatedValue.UpdateValue(session, string.Join(",", rewardsClaimedStrings));
}
private static void HandleProcessTile(GameSession session, GameEventUserValue totalTileValue, GameEventUserValue freeRollValue,
GameEventUserValue totalTripValue)
{
int.TryParse(freeRollValue.EventValue, out int freeRolls);
int.TryParse(totalTileValue.EventValue, out int totalTiles);
int currentTilePosition = totalTiles % MapleopolyTile.TILE_AMOUNT;
MapleopolyTile currentTile = DatabaseManager.Mapleopoly.FindTileByPosition(currentTilePosition + 1);
switch (currentTile.Type)
{
case MapleopolyTileType.Item:
case MapleopolyTileType.TreasureTrove:
Item item = new(currentTile.ItemId, currentTile.ItemAmount, currentTile.ItemRarity);
session.Player.Inventory.AddItem(session, item, true);
break;
case MapleopolyTileType.Backtrack:
totalTiles -= currentTile.TileParameter;
break;
case MapleopolyTileType.MoveForward:
totalTiles += currentTile.TileParameter;
break;
case MapleopolyTileType.RoundTrip:
totalTiles += MapleopolyTile.TILE_AMOUNT;
break;
case MapleopolyTileType.GoToStart:
int tileToStart = MapleopolyTile.TILE_AMOUNT - currentTilePosition;
totalTiles += tileToStart;
break;
case MapleopolyTileType.Start:
break;
default:
Logger.Warning("Unsupported tile");
break;
}
ProcessTrip(session, totalTripValue, totalTiles); // Check if player passed Start
totalTileValue.UpdateValue(session, totalTiles);
session.Send(MapleopolyPacket.ProcessTile(totalTiles, freeRolls, currentTile));
}
public List <GameEventUserValue> FindAllUserValuesByCharacterId(long characterId)
{
IEnumerable <dynamic> result = QueryFactory.Query(TableName).Where("character_id", characterId).Get();
List <GameEventUserValue> values = new();
foreach (dynamic entry in result)
{
// TODO: Move this to SQL task?
GameEventUserValue value = ReadGameEventUserValue(entry);
if (value.ExpirationTimestamp < TimeInfo.Now())
{
Delete(value);
continue;
}
values.Add(value);
}
return(values);
}
private static void HandleRoll(GameSession session, GameEventUserValue totalTileValue, GameEventUserValue freeRollValue)
{
// Check if player can roll
int tokenItemId = int.Parse(ConstantsMetadataStorage.GetConstant("MapleopolyTokenItemId"));
int tokenCost = int.Parse(ConstantsMetadataStorage.GetConstant("MapleopolyTokenCost"));
Item token = session.Player.Inventory.GetById(tokenItemId);
int.TryParse(freeRollValue.EventValue, out int freeRolls);
if (freeRolls > 0)
{
freeRolls--;
}
else if (token != null && token.Amount >= tokenCost)
{
session.Player.Inventory.ConsumeItem(session, token.Uid, tokenCost);
}
else
{
session.Send(MapleopolyPacket.Notice((byte)MapleopolyNotice.NotEnoughTokens));
return;
}
Random rnd = Random.Shared;
// roll two dice
int roll1 = rnd.Next(1, 6);
int roll2 = rnd.Next(1, 6);
int totalRoll = roll1 + roll2;
int.TryParse(totalTileValue.EventValue, out int totalTiles);
totalTiles += totalRoll;
if (roll1 == roll2)
{
freeRolls++;
}
// update user event values
freeRollValue.UpdateValue(session, freeRolls);
totalTileValue.UpdateValue(session, totalTiles);
session.Send(MapleopolyPacket.Roll(totalTiles, roll1, roll2));
}
private static void HandleBeginTimer(GameSession session)
{
AttendGift attendanceEvent = DatabaseManager.Events.FindAttendGiftEvent();
if (attendanceEvent is null)
{
return;
}
GameEventUserValue accumulatedTime = GameEventHelper.GetUserValue(session.Player, attendanceEvent.Id,
TimeInfo.Tomorrow(), GameEventUserValueType.AttendanceAccumulatedTime);
if (accumulatedTime.ExpirationTimestamp < TimeInfo.Now())
{
accumulatedTime.ExpirationTimestamp = TimeInfo.Tomorrow();
accumulatedTime.EventValue = "0";
DatabaseManager.GameEventUserValue.Update(accumulatedTime);
}
}
private static void HandleClaim(GameSession session)
{
AttendGift attendanceEvent = DatabaseManager.Events.FindAttendGiftEvent();
if (attendanceEvent is null || attendanceEvent.EndTimestamp < TimeInfo.Now())
{
session.Send(AttendancePacket.Notice((int)AttendanceNotice.EventNotFound));
return;
}
GameEventUserValue timeValue = GameEventHelper.GetUserValue(session.Player, attendanceEvent.Id,
TimeInfo.Tomorrow(), GameEventUserValueType.AttendanceAccumulatedTime);
long.TryParse(timeValue.EventValue, out long accumulatedTime);
if (TimeInfo.Now() - session.Player.LastLogTime + accumulatedTime <
attendanceEvent.TimeRequired)
{
return;
}
GameEventUserValue completeTimestampValue = GameEventHelper.GetUserValue(session.Player, attendanceEvent.Id,
attendanceEvent.EndTimestamp, GameEventUserValueType.AttendanceCompletedTimestamp);
long.TryParse(completeTimestampValue.EventValue, out long completedTimestamp);
DateTimeOffset savedTime = DateTimeOffset.FromUnixTimeSeconds(completedTimestamp);
if (DateTimeOffset.Now.UtcDateTime < savedTime.UtcDateTime && DateTimeOffset.Now.Date != savedTime.Date)
{
session.Send(AttendancePacket.Notice((int)AttendanceNotice.EventHasAlreadyBeenCompleted));
return;
}
// get current day value
UpdateRewardsClaimed(session, attendanceEvent);
// update completed timestamp
long convertedValue2 = TimeInfo.Now();
completeTimestampValue.UpdateValue(session, convertedValue2);
}
private static void ProcessTrip(GameSession session, GameEventUserValue totalTripValue, int totalTiles)
{
int.TryParse(totalTripValue.EventValue, out int totalTrips);
int newTotalTrips = totalTiles / MapleopolyTile.TILE_AMOUNT;
if (newTotalTrips <= totalTrips)
{
return;
}
int difference = newTotalTrips - totalTrips;
List <BlueMarbleReward> items = DatabaseManager.Events.FindMapleopolyEvent().Rewards;
for (int i = 0; i < difference; i++)
{
totalTrips++;
// Check if there's any item to give for every 1 trip
BlueMarbleReward mapleopolyItem1 = items.FirstOrDefault(x => x.TripAmount == 0);
if (mapleopolyItem1 != null)
{
Item item1 = new(mapleopolyItem1.ItemId, mapleopolyItem1.ItemAmount, mapleopolyItem1.ItemRarity);
session.Player.Inventory.AddItem(session, item1, true);
}
// Check if there's any other item to give for hitting a specific number of trips
BlueMarbleReward mapleopolyItem2 = items.FirstOrDefault(x => x.TripAmount == totalTrips);
if (mapleopolyItem2 == null)
{
continue;
}
Item item2 = new(mapleopolyItem2.ItemId, mapleopolyItem2.ItemAmount, mapleopolyItem2.ItemRarity);
session.Player.Inventory.AddItem(session, item2, true);
}
totalTripValue.UpdateValue(session, totalTrips);
}
private static void HandleOpen(GameSession session, GameEventUserValue totalTileValue, GameEventUserValue freeRollValue)
{
List <MapleopolyTile> tiles = DatabaseManager.Mapleopoly.FindAllTiles();
if (tiles.Count == 0)
{
return;
}
int tokenAmount = 0;
int tokenItemId = int.Parse(ConstantsMetadataStorage.GetConstant("MapleopolyTokenItemId"));
Item token = session.Player.Inventory.GetById(tokenItemId);
if (token != null)
{
tokenAmount = token.Amount;
}
int.TryParse(totalTileValue.EventValue, out int totalTiles);
int.TryParse(freeRollValue.EventValue, out int freeRolls);
session.Send(MapleopolyPacket.Open(totalTiles, freeRolls, tiles, tokenItemId, tokenAmount));
}
public override void Handle(GameSession session, PacketReader packet)
{
MapleopolyMode mode = (MapleopolyMode)packet.ReadByte();
BlueMarble mapleopolyEvent = DatabaseManager.Events.FindMapleopolyEvent();
if (mapleopolyEvent is null)
{
// TODO: Find an error packet to send if event is not active
return;
}
GameEventUserValue totalTileValue = GameEventHelper.GetUserValue(session.Player, mapleopolyEvent.Id, mapleopolyEvent.EndTimestamp,
GameEventUserValueType.MapleopolyTotalTileCount);
GameEventUserValue freeRollValue = GameEventHelper.GetUserValue(session.Player, mapleopolyEvent.Id, mapleopolyEvent.EndTimestamp,
GameEventUserValueType.MapleopolyFreeRollAmount);
GameEventUserValue totalTripValue = GameEventHelper.GetUserValue(session.Player, mapleopolyEvent.Id, mapleopolyEvent.EndTimestamp,
GameEventUserValueType.MapleopolyTotalTrips);
switch (mode)
{
case MapleopolyMode.Open:
HandleOpen(session, totalTileValue, freeRollValue);
break;
case MapleopolyMode.Roll:
HandleRoll(session, totalTileValue, freeRollValue);
break;
case MapleopolyMode.ProcessTile:
HandleProcessTile(session, totalTileValue, freeRollValue, totalTripValue);
break;
default:
LogUnknownMode(mode);
break;
}
}
private static void HandleSelectRpsChoice(GameSession session, PacketReader packet)
{
session.Player.RPSSelection = (RpsChoice)packet.ReadInt();
// delay for 1 sec for opponent to update their selection
Task.Run(async() =>
{
await Task.Delay(1000);
});
// confirm if opponent is still in the map
Player opponent = session.FieldManager.State.Players
.FirstOrDefault(x => x.Value.Value.CharacterId == session.Player.RPSOpponentId).Value?.Value;
if (opponent == null)
{
return;
}
// handle choices
RpsResult[,] resultMatrix =
{
{
RpsResult.Draw, RpsResult.Lose, RpsResult.Win
},
{
RpsResult.Win, RpsResult.Draw, RpsResult.Lose
},
{
RpsResult.Lose, RpsResult.Win, RpsResult.Draw
}
};
RpsResult result = resultMatrix[(int)session.Player.RPSSelection, (int)opponent.RPSSelection];
RPS rpsEvent = DatabaseManager.Events.FindRockPaperScissorsEvent();
if (rpsEvent is null)
{
return;
}
Item voucher = session.Player.Inventory.GetById(rpsEvent.VoucherId);
if (voucher is null)
{
return;
}
session.Player.Inventory.ConsumeItem(session, voucher.Uid, 1);
GameEventUserValue dailyMatches = GameEventHelper.GetUserValue(session.Player, rpsEvent.Id,
TimeInfo.Tomorrow(), GameEventUserValueType.RPSDailyMatches);
int.TryParse(dailyMatches.EventValue, out int dailyMatchCount);
dailyMatchCount++;
dailyMatches.UpdateValue(session, dailyMatchCount);
session.Send(RockPaperScissorsPacket.MatchResults(result, session.Player.RPSSelection, opponent.RPSSelection));
}
public bool Delete(GameEventUserValue userValue)
{
return(QueryFactory.Query(TableName).Where("id", userValue.Id).Delete() == 1);
}
