public void HandleNetMessage(NetMessage3 message)
{
switch (message.Signature.MessageType)
{
case NM3MessageType.message:
Log.Add(message.Get <string>("message"));
break;
case NM3MessageType.world_create:
World = new fbWorld(
this,
message.Get <int>("width"),
message.Get <int>("height")
);
break;
case NM3MessageType.world_playerstart:
int x = message.Get <int>("x");
int y = message.Get <int>("y");
if (!World.PlayerStarts
.Any(v2 => v2.X == x && v2.Y == y))
{
World.PlayerStarts.Add(new Vector2i(x, y));
}
break;
case NM3MessageType.station_create:
World.SpawnStation(
message.Get <int>("owner"),
message.Get <int>("id"),
message.Get <int>("x"),
message.Get <int>("y")
);
break;
case NM3MessageType.station_set_project:
Station s = World.Map.Stations
[message.Get <int>("station-id")];
ProjectType type =
(ProjectType)message.Get <int>("projecttype");
switch (type)
{
case ProjectType.UnitProject:
s.Project = new BuildingProject(
this,
message.Get <int>("owner"),
s,
message.Get <int>("length"),
UnitType.GetType(
(UnitTypes)
message.Get <int>("project")
)
);
break;
case ProjectType.TechProject:
s.Project = new TechProject(
this,
message.Get <int>("owner"),
s,
message.Get <int>("length"),
(TechID)message.Get <int>("project")
);
break;
default:
throw new ArgumentException();
}
break;
case NM3MessageType.player_add_tech:
World.Players[message.Get <int>("id")]
.Tech.Add((TechID)message.Get <int>("tech"));
break;
case NM3MessageType.planet_create:
World.SpawnPlanet(
message.Get <int>("x"),
message.Get <int>("y")
);
break;
case NM3MessageType.unit_create:
EventHandler.Push(
new CreateUnitEvent(
UnitType.GetType(
(UnitTypes)
message.Get <int>("type")
),
message.Get <int>("owner"),
message.Get <int>("id"),
message.Get <int>("x"),
message.Get <int>("y")
)
);
break;
case NM3MessageType.unit_move:
EventHandler.Push(
new UnitMoveEvent(
message.Get <int>("id"),
message.Get <int>("x"),
message.Get <int>("y"),
false
)
);
break;
case NM3MessageType.player_new:
World.AddPlayer(
new Player(
"Unnamed player",
message.Get <int>("id"),
Color.White
)
);
break;
case NM3MessageType.player_assign_id:
We = message.Get <int>("id");
break;
case NM3MessageType.player_name:
EventHandler.Push(
new NameEvent(
message.Get <int>("id"),
message.Get <string>("name"),
message.Get <string>("color")
)
);
break;
case NM3MessageType.player_current:
World.CurrentID = message.Get <int>("index");
//todo: event this?
Log.Add(
string.Format(
"It is now {0}'s turn.",
World.Players[World.CurrentID].Name
)
);
break;
case NM3MessageType.unit_status:
Unit u = World.Units[message.Get <int>("id")];
u.Moves = message.Get <int>("moves");
u.Attacks = message.Get <int>("attacks");
u.Strength = message.Get <int>("strength");
//todo: should probably be an event
if (u.Strength <= 0)
{
World.DespawnUnit(u);
}
break;
case NM3MessageType.player_status:
World.GetPlayer(message.Get <int>("id"))
.Money = message.Get <int>("money");
break;
case NM3MessageType.client_disconnect:
EventHandler.Push(
new PlayerDisconnectEvent(
message.Get <int>("id")
)
);
break;
case NM3MessageType.client_pass:
World.Pass();
break;
case NM3MessageType.client_ready:
Ready = true;
break;
case NM3MessageType.client_unready:
Ready = false;
break;
default:
throw new Exception();
}
}
public override void Handle(Event e)
{
Station s;
switch (e.GetEventType())
{
case EventType.NameEvent:
NameEvent ne = (NameEvent)e;
Game.World.GetPlayer(ne.ID).Name = ne.Name;
Game.World.GetPlayer(ne.ID).Color = ne.Color;
break;
case EventType.UnitMoveEvent:
UnitMoveEvent ume = (UnitMoveEvent)e;
Unit u = Game.World.Units[ume.ID];
u.GetAnimateable().AddAnimation(
new PositionAnimation(
150,
CurveType.EaseOut,
u.fPosition,
new Vector2(ume.x, ume.y)
)
);
u.MoveTo(ume.x, ume.y);
if (ume.Local)
{
engine.NetClient.Send(
new NetMessage3(
NM3MessageType.unit_move,
u.ID,
ume.x, ume.y
)
);
}
break;
case EventType.BuildStationEvent:
BuildStationEvent bse = (BuildStationEvent)e;
engine.NetClient.Send(
new NetMessage3(
NM3MessageType.station_create,
bse.Owner, //isn't this always us?
//oh, right, but since the same message
//is used server -> client,
//it provides owner as well.
-1, //client doesn't give id, handled serverside
bse.x,
bse.y
)
);
break;
case EventType.BuildUnitEvent:
BuildUnitEvent bue = (BuildUnitEvent)e;
engine.NetClient.Send(
new NetMessage3(
NM3MessageType.unit_build,
(int)bue.UnitType,
bue.x,
bue.y
)
);
break;
case EventType.CreateUnitEvent:
CreateUnitEvent cue = (CreateUnitEvent)e;
Game.World.SpawnUnit(
new Unit(
Game.World,
cue.UnitType,
cue.Owner,
cue.ID,
cue.x,
cue.y
)
);
break;
case EventType.PlayerDisconnect:
PlayerDisconnectEvent pde = (PlayerDisconnectEvent)e;
Game.Log.Add(
string.Format(
"{0} disconnected.",
Game.World.GetPlayer(pde.id).Name
)
);
Game.World.RemovePlayer(pde.id);
break;
case EventType.SetProjectEvent:
SetProjectEvent spe = (SetProjectEvent)e;
s = Game.World.Map.Stations[spe.Station];
int time;
switch (spe.ProjectType)
{
case ProjectType.UnitProject:
UnitType type = UnitType.GetType(
(UnitTypes)spe.Project
);
time = type.ConstructionTime;
break;
case ProjectType.TechProject:
Tech tech = Tech.Techs[(TechID)spe.Project];
time = tech.ResearchTime;
break;
default:
throw new ArgumentException();
}
engine.NetClient.Send(
new NetMessage3(
NM3MessageType.station_set_project,
spe.Owner,
s.ID,
time,
(int)spe.ProjectType,
spe.Project
)
);
break;
case EventType.ProjectFinishedEvent:
ProjectFinishedEvent pfe = (ProjectFinishedEvent)e;
Project p = pfe.Project;
switch (p.GetProjectType())
{
case ProjectType.UnitProject:
//this is a bit hacky, but we specifically only
//want to send this netmessage from the client
//*OWNING* the project, whereas with techprojects
//we can handle them just fine on our own side.
//this is because we need to keep our unit ids
//synchronized.
if (p.Station.Tile.Unit == null)
{
if (
Game.LocalPlayer != null && //not serverside
p.Owner == Game.LocalPlayer.ID //and our
)
{
Push(
new BuildUnitEvent(
(UnitTypes)p.GetProject(),
p.Owner,
p.Station.Position.X,
p.Station.Position.Y
)
);
}
p.SetFinished();
}
break;
case ProjectType.TechProject:
Game.World.Players[p.Owner].Tech.Add(
(TechID)p.GetProject()
);
p.SetFinished();
break;
default:
throw new ArgumentException();
}
break;
default:
throw new ArgumentException();
}
}
