int decode_task() {
OutputBuffer * cb = &(getPlayerData()->buffer);
PlayerControl * pc = &(getPlayerData()->playerControl);
DecoderControl * dc = &(getPlayerData()->decoderControl);
unblockSignals();
mpm_enter(MPM_DECODE);
fprintf(stderr,"0 In the decode_task:\r\n");
/* CHILD TASK */
while(1) {
if(dc->cycleLogFiles) {
myfprintfCloseAndOpenLogFile();
dc->cycleLogFiles = 0;
}
else if(dc->start || dc->seek)
{
fprintf(stderr,"CAlling decodestart func :\r\n");
decodeStart(pc, cb, dc);
}
else if(dc->stop) {
dc->state = DECODE_STATE_STOP;
dc->stop = 0;
}
else{
my_usleep(10000);
// fprintf(stderr,"in the decode_task sleep:\r\n");
}
}
return EXIT_SUCCESS;
/* END OF CHILD TASK */
}
/* decode w/ buffering
* this will fork another process
* child process does decoding
* parent process does playing audio
*/
void decode() {
OutputBuffer * cb;
PlayerControl * pc;
DecoderControl * dc;
// fprintf(stderr,"In decode.c decode func :\r\n");
cb = &(getPlayerData()->buffer);
clearAllMetaChunkSets(cb);
cb->begin = 0;
cb->end = 0;
pc = &(getPlayerData()->playerControl);
dc = &(getPlayerData()->decoderControl);
dc->error = 0;
dc->seek = 0;
dc->stop = 0;
dc->start = 1;
if(mpm_get_id(MPM_DECODE)<=0) {
if(decoderInit(pc,cb,dc)<0) return;
}
decodeParent(pc, dc, cb);
// fprintf(stderr,"Exiting In decode.c decode func :\r\n");
}
//Commands
local void Cblink(const char *cmd, const char *params, Player *p, const Target *target)
{
if (target->type != T_ARENA)
return; //Ignore non-pub commands
PlayerData *pdata = getPlayerData(p);
if (!pdata->canBlink)
{
chat->SendMessage(p, "You do not have an item capable of blink on your ship.");
return;
}
if (TICK_DIFF(current_ticks(), pdata->lastBlink) < pdata->blinkDelay)
{
chat->SendMessage(p, "Blink is currently recharging.");
return;
}
pdata->blinkActivated = true;
if (!params || !*params)
pdata->blinkDirection = rand()%360;
else
pdata->blinkDirection = atoi(params);
}
local void updatePlayerData(Player *p, ShipHull *hull, bool lock)
{
PlayerData *pdata = getPlayerData(p);
if (!hull)
return;
if(hull->ship == SHIP_SPEC)
{
pdata->canBlink = false;
pdata->blinkActivated = false;
return;
}
pdata->blinkActivated = false;
if (lock == true)
db->lock();
//Blink variables
pdata->canBlink = (items->getPropertySumOnHull(p, hull, "blink", 0) > 0);
pdata->blinkDelay = items->getPropertySumOnHull(p, hull, "blinkdelay", 0);
pdata->blinkDistance = items->getPropertySumOnHull(p, hull, "blinkdistance", 0);
pdata->blinkMin = items->getPropertySumOnHull(p, hull, "blinkmin", 0);
pdata->blinkAWEffect = items->getPropertySumOnHull(p, hull, "blinkaweffect", 0);
pdata->blinkRadius = items->getPropertySumOnHull(p, hull, "blinkradius", 0);
pdata->blinkIgnoreWalls = (items->getPropertySumOnHull(p, hull, "blinkignorewalls", 0) > 0);
if (lock == true)
db->unlock();
}
local void shipFreqChangeCB(Player *p, int newship, int oldship, int newfreq, int oldfreq)
{
//Reset delays
PlayerData *pdata = getPlayerData(p);
pdata->lastBlink = current_ticks();
updatePlayerData(p, db->getPlayerShipHull(p, newship), true);
}
void Sky::applyDelta(const SkyDelta &delta) {
for (const auto &participation: delta.participations) {
if (const Player *player = arena.getPlayer(participation.first)) {
getPlayerData(*player).applyDelta(participation.second);
}
}
settings.applyDelta(delta.settings.get());
}
//Advisers
local void editPPK(Player *p, struct C2SPosition *pos)
{
if (!IS_STANDARD(p))
return;
if (pos->weapon.type == W_NULL)
{
Link *link;
Player *i;
PlayerData *pdata = getPlayerData(p);
PlayerData *idata;
long distance;
int highestAreaCloakMasking = 0;
FOR_EACH_PLAYER(i)
{
if (i->arena != p->arena)
continue;
if (i->p_freq != p->p_freq)
continue;
if (i->flags.is_dead)
continue;
if (i == p)
continue;
idata = getPlayerData(i);
if (!idata->ItemProperties.areaCloak) continue;
if (!idata->utilityState) continue;
if (idata->ItemProperties.areaCloakMasking <= highestAreaCloakMasking) continue;
distance = lhypot(abs(pos->x - i->position.x), abs(pos->y - i->position.y));
if (idata->ItemProperties.areaCloakRange > distance)
{
highestAreaCloakMasking = idata->ItemProperties.areaCloakMasking;
}
}
pdata->areaCloakedMasking = highestAreaCloakMasking;
}
//Callbacks
local void PPKCB(Player *p, struct C2SPosition *pos)
{
PlayerData *pdata = getPlayerData(p);
ArenaData *adata = getArenaData(p->arena);
if (p->flags.is_dead) //Reset dead players' blink and return
{
pdata->blinkActivated = false;
pdata->blinkDirection = 0;
return;
}
if (pdata->blinkActivated == true)
{
double theta;
theta = (((40 - (pos->rotation + 30) % 40) * 9) + pdata->blinkDirection) * (M_PI / 180);
//Reset variables
pdata->blinkActivated = false;
pdata->blinkDirection = 0;
int numAwers = getNumberOfAwers(p);
int dist = pdata->blinkDistance + numAwers * pdata->blinkAWEffect;
if (dist < pdata->blinkMin)
dist = pdata->blinkMin;
int x = pos->x + dist * cos(theta);
int y = pos->y + dist * -sin(theta);
if (pdata->blinkIgnoreWalls == false)
{
Coordinates pathEnd = isClearPath(p->arena, pos->x, pos->y, x, y, (adata->shipconfig[p->p_ship].radius + pdata->blinkRadius));
x = pathEnd.x;
y = pathEnd.y;
if (x == pos->x && y == pos->y) //Useless blink, don't do it.
{
chat->SendMessage(p, "Unable to blink. Try moving into open space.");
return;
}
}
//'restart' blink delay and warp player
pdata->lastBlink = current_ticks();
WarpPlayerWithFlash(p, x, y, pos->xspeed, pos->yspeed, pos->rotation, 0);
//Play LVZ at start location
Target t;
t.type = T_ARENA;
t.u.arena = p->arena;
objs->Move(&t, adata->currentID, pos->x + adata->lvzConfig.xOffset,
pos->y + adata->lvzConfig.yOffset, 0, 0);
objs->Toggle(&t,adata->currentID,1);
adata->currentID++;
if (adata->currentID > adata->lvzConfig.endID)
adata->currentID = adata->lvzConfig.startID;
//Play LVZ at end location
objs->Move(&t, adata->currentID, x + adata->lvzConfig.xOffset,
y + adata->lvzConfig.yOffset, 0, 0);
objs->Toggle(&t,adata->currentID,1);
adata->currentID++;
if (adata->currentID > adata->lvzConfig.endID)
adata->currentID = adata->lvzConfig.startID;
}
}
void Sky::onSpawn(Player &player,
const PlaneTuning &tuning,
const sf::Vector2f &pos,
const float rot) {
getPlayerData(player).spawn(tuning, pos, rot);
}
void Sky::onAction(Player &player, const Action action, const bool state) {
getPlayerData(player).doAction(action, state);
}
Participation &Sky::getParticipation(const Player &player) const {
return getPlayerData(player);
}
