private static void HandleGetHelp(GameSession session, PacketReader packet)
{
int dungeonId = packet.ReadInt();
if (session.Player.DungeonHelperAccessTime > session.ClientTick)
{
session.Send(PartyPacket.DungeonHelperCooldown(session.Player.DungeonHelperAccessTime - session.ClientTick));
return;
}
Party party = session.Player.Party;
if (party is null)
{
party = new(session.Player);
GameServer.PartyManager.AddParty(party);
session.Send(PartyPacket.Create(party, false));
session.Send(PartyPacket.PartyHelp(dungeonId));
MapleServer.BroadcastPacketAll(DungeonHelperPacket.BroadcastAssist(party, dungeonId));
return;
}
session.Player.DungeonHelperAccessTime = session.ClientTick + 30000; // 30 second cooldown
party.BroadcastPacketParty(PartyPacket.PartyHelp(dungeonId));
MapleServer.BroadcastPacketAll(DungeonHelperPacket.BroadcastAssist(party, dungeonId));
}
private static void SetEnchantStats(GameSession session, ItemEnchant itemEnchantStats, Item item)
{
Dictionary <StatAttribute, ItemStat> statDiff = GetEnchantStatDiff(item.Stats.Enchants, itemEnchantStats.Stats);
foreach (ItemStat stat in itemEnchantStats.Stats.Values)
{
if (!item.Stats.Enchants.ContainsKey(stat.ItemAttribute))
{
item.Stats.Enchants[stat.ItemAttribute] = new BasicStat(stat.ItemAttribute, stat.Rate, StatAttributeType.Rate);
continue;
}
item.Stats.Enchants[stat.ItemAttribute].Flat = stat.Flat;
item.Stats.Enchants[stat.ItemAttribute].Rate = stat.Rate;
}
item.EnchantLevel++;
item.EnchantExp = 0;
item.Charges -= itemEnchantStats.Rates.ChargesAdded;
if (item.EnchantLevel > 11)
{
string message = $"3,{item.Uid},{ChatLinkType.Enchant},{session.Player.Name}"; //unk what 3 is
MapleServer.BroadcastPacketAll(ItemLinkPacket.SendLinkItem(new()
{
item
}));
MapleServer.BroadcastPacketAll(ChatPacket.Send(session.Player, message, ChatType.ItemEnchant));
}
session.Send(ItemEnchantPacket.EnchantSuccess(item, statDiff.Values.ToList()));
//TODO: If item is equipped, update stats
}
async Task Initialize()
{
Console.WriteLine("Initialize hardware...");
onboardLed = new RgbPwmLed(device: Device,
redPwmPin: Device.Pins.OnboardLedRed,
greenPwmPin: Device.Pins.OnboardLedGreen,
bluePwmPin: Device.Pins.OnboardLedBlue,
3.3f, 3.3f, 3.3f);
onboardLed.SetColor(Color.Red);
// initialize the wifi adpater
if (!Device.InitWiFiAdapter().Result)
{
throw new Exception("Could not initialize the WiFi adapter.");
}
// connnect to the wifi network.
Console.WriteLine($"Connecting to WiFi Network {Secrets.WIFI_NAME}");
var connectionResult = await Device.WiFiAdapter.Connect(Secrets.WIFI_NAME, Secrets.WIFI_PASSWORD);
if (connectionResult.ConnectionStatus != ConnectionStatus.Success)
{
throw new Exception($"Cannot connect to network: {connectionResult.ConnectionStatus}");
}
Console.WriteLine($"Connected. IP: {Device.WiFiAdapter.IpAddress}");
// create our maple web server
mapleServer = new MapleServer(Device.WiFiAdapter.IpAddress, 5417, true);
mapleServer.Start();
onboardLed.SetColor(Color.Green);
}
public override void Handle(LoginSession session, PacketReader packet)
{
LoginMode mode = (LoginMode)packet.ReadByte();
string username = packet.ReadUnicodeString();
string password = packet.ReadUnicodeString();
if (string.IsNullOrEmpty(username))
{
session.Send(LoginResultPacket.SendLoginMode(Packets.LoginMode.IncorrectId));
return;
}
Account account;
if (DatabaseManager.Accounts.AccountExists(username.ToLower()))
{
if (!DatabaseManager.Accounts.Authenticate(username, password, out account))
{
session.Send(LoginResultPacket.SendLoginMode(Packets.LoginMode.IncorrectPassword));
return;
}
Session loggedInAccount = MapleServer.GetSessions(MapleServer.GetLoginServer(), MapleServer.GetGameServer()).FirstOrDefault(p => p switch
{
LoginSession s => s.AccountId == account.Id,
GameSession s => s.Player?.AccountId == account.Id,
_ => false
});
public void Dispose()
{
if (Disposed)
{
return;
}
if (this is LoginSession loginSession)
{
MapleServer.GetLoginServer().RemoveSession(loginSession);
}
if (this is GameSession gameSession)
{
MapleServer.GetGameServer().RemoveSession(gameSession);
}
Disposed = true;
Complete();
Thread.Join(STOP_TIMEOUT);
CloseClient();
#if DEBUG
GC.SuppressFinalize(this);
#endif
}
public void Initialize()
{
bool goodToGo = false;
try
{
goodToGo = InitializeNetwork();
}
catch (Exception e)
{
Debug.Print(e.Message);
}
if (goodToGo)
{
Debug.Print("Network done.");
//Setup local time of the card
Utility.SetLocalTime(NTPTime(NTP_POOL_URL, NTP_OFFSET));
Debug.Print("Local time was set. Current local time is " + DateTime.Now);
//Setup initial time variables
MachineRunningSince = DateTime.Now;
MachineState = CoffeeMachineState.Standby;
TurnOffMode = TurnOffMode.Automatic;
// start web server
MapleServer server = new MapleServer();
server.Start();
}
}
public void Run()
{
this.IsRunning = true;
bool goodToGo = false;
try {
goodToGo = InitializeNetwork();
} catch (Exception e) {
Debug.Print(e.Message);
}
if (goodToGo)
{
MakeWebRequest("http://google.com");
//
Debug.Print("Network done.");
// set initial state
Ports.ONBOARD_LED.Write(false);
Ports.GPIO_PIN_D1.Write(false);
// start web server
MapleServer server = new MapleServer();
server.Start();
}
//this.IsRunning = false;
}
async Task Initialize()
{
Console.WriteLine("Initialize hardware...");
// initialize the wifi adpater
if (!Device.InitWiFiAdapter().Result)
{
throw new Exception("Could not initialize the WiFi adapter.");
}
// connnect to the wifi network.
Console.WriteLine($"Connecting to WiFi Network {Secrets.WIFI_NAME}");
var connectionResult = await Device.WiFiAdapter.Connect(Secrets.WIFI_NAME, Secrets.WIFI_PASSWORD);
if (connectionResult.ConnectionStatus != ConnectionStatus.Success)
{
throw new Exception($"Cannot connect to network: {connectionResult.ConnectionStatus}");
}
Console.WriteLine($"Connected. IP: {Device.WiFiAdapter.IpAddress}");
// create our maple web server
server = new MapleServer(
Device.WiFiAdapter.IpAddress,
advertise: true,
processMode: RequestProcessMode.Parallel
);
Console.WriteLine("Finished initialization.");
}
async Task Initialize()
{
var onboardLed = new RgbPwmLed(
device: Device,
redPwmPin: Device.Pins.OnboardLedRed,
greenPwmPin: Device.Pins.OnboardLedGreen,
bluePwmPin: Device.Pins.OnboardLedBlue);
onboardLed.SetColor(Color.Red);
DisplayController.Current.Initialize();
displayController = DisplayController.Current;
displayController.ShowSplashScreen();
var connectionResult = await Device.WiFiAdapter.Connect(Secrets.WIFI_NAME, Secrets.WIFI_PASSWORD);
if (connectionResult.ConnectionStatus != ConnectionStatus.Success)
{
throw new Exception($"Cannot connect to network: {connectionResult.ConnectionStatus}");
}
mapleServer = new MapleServer(
Device.WiFiAdapter.IpAddress, 5417, true
);
onboardLed.SetColor(Color.Green);
}
public static void Process(GameSession session, string command)
{
string[] args = command.ToLower().Split(" ", 2);
switch (args[0])
{
case "item":
ProcessItemCommand(session, args.Length > 1 ? args[1] : "");
break;
case "npc":
ProcessNpcCommand(session, args.Length > 1 ? args[1] : "");
break;
case "map":
ProcessMapCommand(session, args.Length > 1 ? args[1] : "");
break;
case "coord":
session.SendNotice(session.FieldPlayer.Coord.ToString());
break;
case "battleof":
session.Send(UserBattlePacket.UserBattle(session.FieldPlayer, false));
break;
case "notice":
if (args.Length <= 1)
{
break;
}
MapleServer.BroadcastPacketAll(NoticePacket.Notice(args[1]));
break;
}
}
private static void Initializer_NetworkConnected(object sender, EventArgs e)
{
var mapleServer = new MapleServer();
mapleServer.Start();
Debug.Print("Maple started");
}
protected void InitializeWebServer()
{
var handler = new RequestHandler();
handler.GetPlantHumidity += OnGetPlantHumidity;
_server = new MapleServer();
_server.AddHandler(handler);
}
public async Task Start()
{
MapleServer.BroadcastPacketAll(GlobalPortalPacket.Notice(this));
await Task.Delay(60000);
MapleServer.BroadcastPacketAll(GlobalPortalPacket.Clear(this));
GameServer.GlobalEventManager.RemoveEvent(this);
}
protected void InitializeWebServer()
{
var handler = new RequestHandler();
handler.RotateTo += (s, e) => { _servoController.RotateTo(((ServoEventArgs)e).Angle); };;
handler.StopSweep += (s, e) => { _servoController.StopSweep(); };
handler.StartSweep += (s, e) => { _servoController.StartSweep(); };
_server = new MapleServer();
_server.AddHandler(handler);
}
protected void InitializePowerServer()
{
var handler = new RequestHandler();
handler.TurnOn += (s, e) => { _receptacleController.TurnOn1(); };
handler.TurnOff += (s, e) => { _receptacleController.TurnOff1(); };
handler.StartRunningColors += (s, e) => { _receptacleController.StartRunningColors(); };
_server = new MapleServer();
_server.AddHandler(handler);
}
public static void Main()
{
MapleServer server = new MapleServer();
Initializer.NetworkConnected += (s, e) =>
{
// start maple server and send name broadcast address
server.Start("assimilate server", Initializer.CurrentNetworkInterface.IPAddress);
};
Initializer.InitializeNetwork();
Thread.Sleep(Timeout.Infinite);
}
public override void Handle(GameSession session, PacketReader packet)
{
ChatType type = (ChatType)packet.ReadInt();
string message = packet.ReadUnicodeString();
string recipient = packet.ReadUnicodeString();
packet.ReadLong();
GameCommandActions.Process(session, message);
switch (type)
{
case ChatType.Channel: //TODO: Send to all players on current channel
break;
case ChatType.Super:
case ChatType.World:
//Send to all players online
MapleServer.BroadcastPacketAll(ChatPacket.Send(session.Player, message, type));
break;
case ChatType.GuildNotice:
case ChatType.Guild:
//TODO: Send to all in guild
break;
case ChatType.Party:
Party party = GameServer.PartyManager.GetPartyById(session.Player.PartyId);
if (party != null)
{
party.BroadcastPacketParty(ChatPacket.Send(session.Player, message, type));
}
break;
case ChatType.WhisperTo:
Player recipientPlayer = GameServer.Storage.GetPlayerByName(recipient);
if (recipientPlayer != null)
{
recipientPlayer.Session.Send(ChatPacket.Send(session.Player, message, ChatType.WhisperFrom));
session.Send(ChatPacket.Send(recipientPlayer, message, ChatType.WhisperTo));
}
else
{
session.Send(ChatPacket.Send(session.Player, "Player not found or they are not online.", ChatType.WhisperFail));
}
break;
default:
session.FieldManager.SendChat(session.Player, message, type);
break;
}
}
protected void InitializeWebServer()
{
// configure our web server
RequestHandler handler = new RequestHandler();
handler.TurnOff += Handler_TurnOff;
handler.TurnOn += Handler_TurnOn;
handler.GetStatus += Handler_GetStatus;
_server = new MapleServer();
_server.AddHandler(handler);
}
void InitializeWebServer()
{
var handler = new RequestHandler();
handler.Stop += OnStop;
handler.TurnLeft += OnTurnLeft;
handler.TurnRight += OnTurnRight;
handler.MoveForward += OnMoveForward;
handler.MoveBackward += OnMoveBackward;
mapleServer = new MapleServer();
mapleServer.AddHandler(handler);
}
protected void InitializeWebServer()
{
var handler = new RequestHandler();
handler.TurnOn += (s, e) => { _rgbController.TurnOn(); };
handler.TurnOff += (s, e) => { _rgbController.TurnOff(); };
handler.StartBlink += (s, e) => { _rgbController.StartBlink(); };
handler.StartPulse += (s, e) => { _rgbController.StartPulse(); };
handler.StartRunningColors += (s, e) => { _rgbController.StartRunningColors(); };
_server = new MapleServer();
_server.AddHandler(handler);
}
public override void Execute(GameCommandTrigger trigger)
{
string[] args = trigger.Get <string[]>("message");
if (args == null || args.Length <= 1)
{
trigger.Session.SendNotice("No message provided.");
return;
}
string message = CommandHelpers.BuildString(args, trigger.Session.Player.Name);
MapleServer.BroadcastPacketAll(NoticePacket.Notice(message));
}
async Task Initialize()
{
LedController.Current.Initialize();
var connectionResult = await Device.WiFiAdapter.Connect(Secrets.WIFI_NAME, Secrets.WIFI_PASSWORD);
if (connectionResult.ConnectionStatus != ConnectionStatus.Success)
{
throw new Exception($"Cannot connect to network: {connectionResult.ConnectionStatus}");
}
mapleServer = new MapleServer(
Device.WiFiAdapter.IpAddress, 5417, true
);
}
protected void InitializeWebServer()
{
var handler = new RequestHandler();
handler.Connect += (s, e) =>
{
_playerTeamA.Salute();
_playerTeamB.Salute();
};
handler.KickA += (s, e) => { _playerTeamA.Kick(); };
handler.KickB += (s, e) => { _playerTeamB.Kick(); };
_server = new MapleServer();
_server.AddHandler(handler);
}
private static void HandleWorldChat(GameSession session, string message, ChatType type)
{
Item voucher = session.Player.Inventory.Items.Values.FirstOrDefault(x => x.Tag == "FreeWorldChatCoupon");
if (voucher != null)
{
session.Send(NoticePacket.Notice(SystemNotice.UsedWorldChatVoucher, NoticeType.ChatAndFastText));
InventoryController.Consume(session, voucher.Uid, 1);
}
else if (!session.Player.Wallet.RemoveMerets(30))
{
session.Send(ChatPacket.Error(session.Player, SystemNotice.InsufficientMerets, ChatType.NoticeAlert));
return;
}
MapleServer.BroadcastPacketAll(ChatPacket.Send(session.Player, message, type));
}
public static void Main()
{
// TODO: can't seem to get this example to work regardless of using directives/references - so going w/ this hack for now!
//while (!System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
while (Microsoft.SPOT.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()[0].IPAddress == "0.0.0.0")
{
Debug.Print("Waiting for network...");
Thread.Sleep(10);
}
;
Debug.Print("IP: " + Microsoft.SPOT.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()[0].IPAddress);
remoteController = new DS1803Controller();
var handler = new RequestHandler();
// TODO: sweepPot(byte pot, int from, int to)
//handler.SweepPot += (s, e) => { remoteController.sweepPot(); };
handler.SweepSteeringPotCenterToRight += (s, e) => { remoteController.sweepSteeringPotCenterToRight(); };
handler.SweepSteeringPotCenterToLeft += (s, e) => { remoteController.sweepSteeringPotCenterToLeft(); };
handler.SweepSteeringPotRightToLeft += (s, e) => { remoteController.sweepSteeringPotRightToLeft(); };
handler.SweepSteeringPotLeftToRight += (s, e) => { remoteController.sweepSteeringPotLeftToRight(); };
handler.SweepSteeringPotRightToCenter += (s, e) => { remoteController.sweepSteeringPotRightToCenter(); };
handler.SweepSteeringPotLeftToCenter += (s, e) => { remoteController.sweepSteeringPotLeftToCenter(); };
handler.SweepSteeringPotTest += (s, e) => { remoteController.sweepSteeringPotTest(); };
handler.SweepThrottlePotCenterToMaxForward += (s, e) => { remoteController.sweepThrottlePotCenterToMaxForward(); };
handler.SweepThrottlePotMaxForwardToCenter += (s, e) => { remoteController.sweepThrottlePotMaxForwardToCenter(); };
handler.SweepThrottlePotCenterToMaxReverse += (s, e) => { remoteController.sweepThrottlePotCenterToMaxReverse(); };
handler.SweepThrottlePotMaxReverseToCenter += (s, e) => { remoteController.sweepThrottlePotMaxReverseToCenter(); };
handler.SweepThrottlePotCenterToMidForward += (s, e) => { remoteController.sweepThrottlePotCenterToMidForward(); };
handler.SweepThrottlePotMidForwardToCenter += (s, e) => { remoteController.sweepThrottlePotMidForwardToCenter(); };
handler.SweepThrottlePotCenterToMidReverse += (s, e) => { remoteController.sweepThrottlePotCenterToMidReverse(); };
handler.SweepThrottlePotMidReverseToCenter += (s, e) => { remoteController.sweepThrottlePotMidReverseToCenter(); };
handler.CircleRight += (s, e) => { remoteController.circleRight(); };
handler.CircleLeft += (s, e) => { remoteController.circleLeft(); };
handler.Stop += (s, e) => { remoteController.stop(); };
maple = new MapleServer();
maple.AddHandler(handler);
maple.Start();
Debug.Print("Maple serving on http://" + Microsoft.SPOT.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()[0].IPAddress);
}
public static void Main(string[] args)
{
MapleServer server = new MapleServer(
IPAddress.Parse("127.0.0.1"),
// OR:
//GetLocalIP(),
advertise: true,
processMode: RequestProcessMode.Parallel
);
server.Start();
Console.WriteLine($"Server is listening on {server.IPAddress}");
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
server.Stop();
Console.WriteLine("Goodbye.");
}
async Task InitializeAsync()
{
ServoController.Instance.InitializeServo();
if (!Device.InitWiFiAdapter().Result)
{
throw new Exception("Could not initialize the WiFi adapter.");
}
var connectionResult = await Device.WiFiAdapter.Connect("SSID", "password");
if (connectionResult.ConnectionStatus != ConnectionStatus.Success)
{
throw new Exception($"Cannot connect to network: {connectionResult.ConnectionStatus}");
}
server = new MapleServer(
Device.WiFiAdapter.IpAddress, 5417
);
}
private static void HandleGetHelp(GameSession session, PacketReader packet)
{
int dungeonId = packet.ReadInt();
if (session.Player.Party == null)
{
Party newParty = new(session.Player);
GameServer.PartyManager.AddParty(newParty);
session.Send(PartyPacket.Create(newParty, false));
session.Send(PartyPacket.PartyHelp(dungeonId));
MapleServer.BroadcastPacketAll(DungeonHelperPacket.BroadcastAssist(newParty, dungeonId));
return;
}
Party party = session.Player.Party;
party.BroadcastPacketParty(PartyPacket.PartyHelp(dungeonId));
MapleServer.BroadcastPacketAll(DungeonHelperPacket.BroadcastAssist(party, dungeonId));
}
private static void HandleSuperChat(GameSession session, string message, ChatType type)
{
if (session.Player.SuperChat == 0)
{
return;
}
Item superChatItem = session.Player.Inventory.Items.Values.FirstOrDefault(x => x.Function.Id == session.Player.SuperChat);
if (superChatItem == null)
{
session.Player.SuperChat = 0;
session.Send(SuperChatPacket.Deselect(session.FieldPlayer));
session.Send(ChatPacket.Error(session.Player, SystemNotice.InsufficientSuperChatThemes, ChatType.NoticeAlert));
return;
}
MapleServer.BroadcastPacketAll(ChatPacket.Send(session.Player, message, type));
InventoryController.Consume(session, superChatItem.Uid, 1);
session.Send(SuperChatPacket.Deselect(session.FieldPlayer));
session.Player.SuperChat = 0;
}
/// <summary>
/// Get the app running
/// </summary>
internal void Run()
{
bool isConnected = false;
try
{
// attempt to connect
isConnected = InitNetwork();
}
catch (Exception ex)
{
Debug.Print(ex.Message);
}
// if it is connected, take the other initialize actions
if (isConnected)
{
// start REST API server
MapleServer server = new MapleServer();
server.AddHandler(new RequestHandler());
server.Start(ServerName, Initializer.CurrentNetworkInterface.IPAddress);
}
}
