// Spawns a player at a particular spawn point
void _Server::SpawnPlayer(_Object *Player, NetworkIDType MapID, uint32_t EventType) {
if(!ValidatePeer(Player->Peer) || !Player->Peer->CharacterID || !MapID)
return;
// Get map
_Map *Map = MapManager->GetObject(MapID);
// Load map
if(!Map) {
Map = MapManager->CreateWithID(MapID);
Map->Clock = Clock;
Map->Server = this;
Map->Load(Stats->GetMap(MapID)->File);
}
// Get old map
_Map *OldMap = Player->Map;
// Place player in new map
if(Map != OldMap) {
if(OldMap) {
OldMap->RemoveObject(Player);
}
Player->Map = Map;
// Find spawn point in map
uint32_t SpawnPoint = Player->SpawnPoint;
if(EventType == _Map::EVENT_MAPENTRANCE)
SpawnPoint = OldMap->NetworkID;
// Default to mapchange event if entrance not found
if(!Map->FindEvent(_Event(EventType, SpawnPoint), Player->Position))
Map->FindEvent(_Event(_Map::EVENT_MAPCHANGE, SpawnPoint), Player->Position);
// Add player to map
Map->AddObject(Player);
// Send new map id
_Buffer Packet;
Packet.Write<PacketType>(PacketType::WORLD_CHANGEMAPS);
Packet.Write<uint32_t>(MapID);
Packet.Write<double>(Clock);
Network->SendPacket(Packet, Player->Peer);
// Set player object list
Map->SendObjectList(Player->Peer);
// Set full player data to peer
SendPlayerInfo(Player->Peer);
}
else {
Map->FindEvent(_Event(EventType, Player->SpawnPoint), Player->Position);
SendPlayerPosition(Player->Peer);
SendHUD(Player->Peer);
}
}
void CGame::Event (int ID, int iTyp, CPlayer * pPlayer)
{
if (pPlayer == NULL)
{
TRAP ();
return;
}
if ( ! pPlayer->IsMe () )
return;
_Event ( ID, iTyp, pPlayer->GetName (), 0 );
}
int kernel(void)
{
/* Vacuous terminate */;
if (_state_1) {
_s.fun = 0, strcpy(fun_v, "None");;;
_state_1 = 0;
} else {
_state_1 = 0;
if (_s.ev) {
_Event(&X, ev_v);
strcpy(f, do_lookup(X));
(strcpy(fun_v, f)), (_s.fun = 1);
}
}
if (_s.fun) { kernel_O_fun(fun_v); _s.fun = 0; }
_s.ev = 0;
return 1;
}
void CGame::Event (int ID, int iTyp, int iVal)
{
char const * psText;
switch (ID)
{
case EVENT_HPR_NOACCESS :
case EVENT_HPR_NOPICKUP : {
int iTyp = __minmax ( 0, CMaterialTypes::GetNumTypes (), iVal );
psText = CMaterialTypes::GetDesc ( iTyp );
break; }
case EVENT_CONST_CANT :
psText = theStructures.GetData (iVal)->GetDesc ();
break;
default:
psText = NULL;
break;
}
_Event ( ID, iTyp, psText, 0 );
}
void CGame::Event (int ID, int iTyp, CUnit *pUnit)
{
if (pUnit == NULL)
{
TRAP ();
return;
}
if ( ! pUnit->GetOwner()->IsMe () )
return;
char const * psText;
switch (ID)
{
case EVENT_CONST_CANT :
psText = theStructures.GetData (((CVehicle *)pUnit)->GetBldgType ())->GetDesc ();
break;
case EVENT_BUILD_HALTED :
case EVENT_BUILD_DONE :
psText = theTransports.GetData (((CVehicleBuilding*)pUnit)->GetBldUnt()->GetVehType ())->GetDesc ();
break;
case EVENT_ATK_TARGET :
case EVENT_ATK_DESTROYED : {
CUnit * pTarget = pUnit->GetTarget ();
if ((pTarget != NULL) && (pTarget->GetUnitType () == CUnit::building))
psText = theStructures.GetData (((CBuilding *)pTarget)->GetData()->GetType ())->GetDesc ();
else
psText = NULL;
break; }
default:
psText = pUnit->GetData()->GetDesc ();
break;
}
_Event ( ID, iTyp, psText, pUnit->GetVoice () );
}
// Update bot based on goals
void _Bot::EvaluateGoal() {
// Respawn
if(!Player->WaitForServer && !Player->IsAlive()) {
_Buffer Packet;
Packet.Write<PacketType>(PacketType::WORLD_RESPAWN);
Network->SendPacket(Packet);
Player->WaitForServer = true;
return;
}
// Evaluate goal
switch(GoalState) {
case GoalStateType::NONE:
DetermineNextGoal();
break;
case GoalStateType::FARMING:
if(Map->NetworkID != 11) {
if(Map->NetworkID != 10) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_MAPCHANGE, 10), Position))
MoveTo(Player->Position, Position);
}
else if(Map->NetworkID == 10) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_MAPCHANGE, 11), Position))
MoveTo(Player->Position, Position);
}
}
else if(Map->NetworkID == 11) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_SCRIPT, 3), Position))
MoveTo(Player->Position, Position);
}
else {
BotState = BotStateType::MOVE_RANDOM;
}
break;
case GoalStateType::HEALING:
if(Map->NetworkID != 1) {
if(!Player->WaitForServer && Player->CanTeleport()) {
_Buffer Packet;
Packet.Write<PacketType>(PacketType::PLAYER_STATUS);
Packet.Write<uint8_t>(_Object::STATUS_TELEPORT);
Network->SendPacket(Packet);
Player->WaitForServer = true;
}
}
else {
if(Player->GetHealthPercent() < 1.0f) {
glm::ivec2 Position;
if(FindEvent(_Event(_Map::EVENT_SCRIPT, 1), Position)) {
if(Player->Position == Position)
BotState = BotStateType::MOVE_HEAL;
else
MoveTo(Player->Position, Position);
}
}
else
DetermineNextGoal();
}
break;
}
}
// Check for events
void _Map::CheckEvents(_Object *Object) {
// Check for teleporting
if(Server && Object->TeleportTime == 0.0) {
Object->TeleportTime = -1.0;
Object->Status = _Object::STATUS_NONE;
Server->SpawnPlayer(Object, Object->SpawnMapID, _Map::EVENT_SPAWN);
return;
}
// Handle events
const _Tile *Tile = &Tiles[Object->Position.x][Object->Position.y];
switch(Tile->Event.Type) {
case _Map::EVENT_SPAWN:
Object->SpawnMapID = NetworkID;
Object->SpawnPoint = Tile->Event.Data;
break;
case _Map::EVENT_MAPENTRANCE:
case _Map::EVENT_MAPCHANGE:
if(Server)
Server->SpawnPlayer(Object, (NetworkIDType)Tile->Event.Data, _Map::EVENT_MAPENTRANCE);
else
Object->WaitForServer = true;
break;
case _Map::EVENT_VENDOR: {
if(Server) {
Object->Vendor = Server->Stats->GetVendor(Tile->Event.Data);
// Notify client
_Buffer Packet;
Packet.Write<PacketType>(PacketType::EVENT_START);
Packet.Write<uint32_t>(Tile->Event.Type);
Packet.Write<uint32_t>(Tile->Event.Data);
Packet.Write<glm::ivec2>(Object->Position);
Server->Network->SendPacket(Packet, Object->Peer);
}
else
Object->WaitForServer = true;
} break;
case _Map::EVENT_TRADER: {
if(Server) {
Object->Trader = Server->Stats->GetTrader(Tile->Event.Data);
// Notify client
_Buffer Packet;
Packet.Write<PacketType>(PacketType::EVENT_START);
Packet.Write<uint32_t>(Tile->Event.Type);
Packet.Write<uint32_t>(Tile->Event.Data);
Packet.Write<glm::ivec2>(Object->Position);
Server->Network->SendPacket(Packet, Object->Peer);
}
else
Object->WaitForServer = true;
} break;
case _Map::EVENT_SCRIPT: {
if(Server)
Server->RunEventScript(Tile->Event.Data, Object);
} break;
case _Map::EVENT_PORTAL: {
if(Server) {
// Find matching even/odd event
FindEvent(_Event(Tile->Event.Type, Tile->Event.Data ^ 1), Object->Position);
Server->SendPlayerPosition(Object->Peer);
}
else
Object->WaitForServer = true;
} break;
case _Map::EVENT_JUMP: {
if(Server) {
// Find next jump
FindEvent(_Event(Tile->Event.Type, Tile->Event.Data + 1), Object->Position);
Server->SendPlayerPosition(Object->Peer);
}
else
Object->WaitForServer = true;
} break;
default:
if(Server) {
Object->Vendor = nullptr;
Object->Trader = nullptr;
if(Object->NextBattle <= 0) {
Server->QueueBattle(Object, Tile->Zone, false);
}
}
break;
}
}
void CGame::Event (int ID, int iTyp)
{
_Event ( ID, iTyp, NULL, 0 );
}
