/* sava_data bin (C->S) */
EdpPacket* PacketSavedataBin(const char* dst_devid, cJSON* desc_obj, uint8* bin_data, uint32 bin_len)
{
EdpPacket* pkg;
uint32 remainlen;
/* check arguments */
char* desc_out = cJSON_Print(desc_obj);
uint32 desc_len = mystrlen(desc_out);
if (desc_len > (0x01 << 16) || bin_len > (3 * (0x01 << 20))
/* desc < 2^16 && bin_len < 3M*/
|| cJSON_GetObjectItem(desc_obj, "ds_id") == 0)
/* desc_obj MUST has ds_id */
{
hx_free(desc_out);
return 0;
}
pkg = NewBuffer();
/* msg type */
WriteByte(pkg, SAVEDATA);
if (dst_devid)
{
/* remain len */
remainlen = 1+(2+mystrlen(dst_devid))+1+(2+desc_len)+(4+bin_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x80);
/* dst devid */
WriteStr(pkg, dst_devid);
}
else
{
/* remain len */
remainlen = 1+1+(2+desc_len)+(4+bin_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x00);
}
/* bin flag */
WriteByte(pkg, 0x02);
/* desc */
WriteStr(pkg, desc_out);
hx_free(desc_out);
/* bin data */
WriteUint32(pkg, bin_len);
WriteBytes(pkg, bin_data, bin_len);
return pkg;
}
main()
{
bufferADT buffer;
buffer = NewBuffer();
while (TRUE) {
printf("*");
ExecuteCommand(buffer, GetLine());
DisplayBuffer(buffer);
}
FreeBuffer(buffer);
}
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cdm_v3_100_Denominate3Test_buildDenominate3(JNIEnv *env, jobject object) {
Denominate.usTellerID = 0;
Denominate.usMixNumber = WFS_CDM_INDIVIDUAL;
Denominate.lpDenomination = &Denomination;
strcpy(Denomination.cCurrencyID, "EUR");
Denomination.ulAmount = 1234;
Denomination.usCount = 3;
Denomination.lpulValues = Values;
Denomination.ulCashBox = 456;
return NewBuffer(env, &Denominate, sizeof(WFSCDMDENOMINATE));
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
if(msg > WM_USER) {
g_pEnv->CallVoidMethod(handlerObj, callbackMID, msg, NewBuffer(g_pEnv, &lParam, sizeof(lParam)));
return 0;
} else {
switch(msg) {
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
}
return DefWindowProc(hWnd, msg, wParam, lParam);
}
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cam_v320_CamStructV3_120Test_createCamStatusV3_120(JNIEnv *env, jobject obj) {
status.fwDevice = WFS_CAM_DEVONLINE;
for(int i = 0; i < WFS_CAM_CAMERAS_SIZE; i++) {
status.fwMedia[i] = WFS_CAM_MEDIANOTSUPP;
status.fwCameras[i] = WFS_CAM_CAMNOTSUPP;
status.usPictures[i] = 0;
}
status.fwMedia[WFS_CAM_PERSON] = WFS_CAM_MEDIAOK;
status.fwCameras[WFS_CAM_PERSON] = WFS_CAM_CAMOK;
status.usPictures[WFS_CAM_PERSON] = 1;
status.wAntiFraudModule = WFS_CAM_AFMOK;
status.lpszExtra = lpszExtra;
return NewBuffer(env, &status, sizeof(WFSCAMSTATUS));
}
BOOL CCircuitry::OnRingPacket(CRingPacket* pPacket)
{
int nChan = pPacket->GetLineId();
SsmSetRecMixer( nChan, FALSE, 0 );
SsmSetDTMFStopRecCharSet( nChan, "" );
SsmSetDtmfStopPlay( nChan, FALSE );
NewBuffer( nChan );
Start( nChan, TRUE );
return SendPacket( pPacket, TRUE );
}
/* Allocate alot of garbage */
static void PR_CALLBACK AllocStuff(void *unused) {
PRInt32 i;
void* danglingRefs[50];
PRIntervalTime start, end;
char msg[100];
start = PR_IntervalNow();
for (i = 0; i < loops; i++) {
void* p;
if (i & 1) {
Type1* t1 = NewType1();
t1->atwo = NewType2();
t1->next = NewType1();
t1->atwo->buf = NewBuffer(100);
p = t1;
} else {
Type2* t2 = NewType2();
t2->buf = NewBuffer(i & 16383);
p = t2;
}
if ((i % 10) == 0) {
memmove(&danglingRefs[0], &danglingRefs[1], 49*sizeof(void*));
danglingRefs[49] = p;
}
}
end = PR_IntervalNow();
if (debug_mode) PR_snprintf(msg, sizeof(msg), "Thread %p: %ld allocations took %ld ms",
PR_GetCurrentThread(), loops,
PR_IntervalToMilliseconds((PRIntervalTime) (end - start)));
PR_Lock(stderrLock);
#ifndef XP_MAC
fprintf(stderr, "%s\n", msg);
#else
if (debug_mode) printf("%s\n", msg);
#endif
PR_Unlock(stderrLock);
}
IFXString::IFXString(const IFXCHAR* operand)
: m_Buffer(NULL),
m_BufferLength(0)
{
if(!operand)
{
DeleteBuffer();
}
else
{
NewBuffer((U32)wcslen(operand)+1);
if (m_Buffer)
wcscpy(m_Buffer, operand);
}
}
/* ping (C->S) */
EdpPacket* PacketPing(void)
{
EdpPacket* pkg = NewBuffer();
if(!pkg->_data)
{
PrintLine("NewBuffer error");
return NULL;
}
/* msg type */
WriteByte(pkg, PINGREQ);
/* remain len */
WriteRemainlen(pkg, 0);
return pkg;
}
/* push_data (C->S) */
EdpPacket* PacketPushdata(const char* dst_devid, const char* data, uint32 data_len)
{
EdpPacket* pkg = NewBuffer();
uint32 remainlen;
/* msg type */
WriteByte(pkg, PUSHDATA);
/* remain len */
remainlen = (2+mystrlen(dst_devid))+data_len;
WriteRemainlen(pkg, remainlen);
/* dst devid */
WriteStr(pkg, dst_devid);
/* data */
WriteBytes(pkg, data, data_len);
return pkg;
}
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cam_v320_CamStructV3_120Test_createCamCapsV3_120(JNIEnv *env, jobject obj) {
caps.wClass = WFS_SERVICE_CLASS_CAM;
caps.fwType = WFS_CAM_TYPE_CAM;
for(int i = 0; i < WFS_CAM_CAMERAS_SIZE; i++) {
caps.fwCameras[i] = WFS_CAM_NOT_AVAILABLE;
}
caps.fwCameras[WFS_CAM_ROOM] = WFS_CAM_AVAILABLE;
caps.usMaxPictures = 100;
caps.fwCamData = WFS_CAM_AUTOADD | WFS_CAM_MANADD;
caps.usMaxDataLength = 64;
caps.fwCharSupport = WFS_CAM_ASCII | WFS_CAM_UNICODE;
caps.lpszExtra = lpszExtra;
caps.bPictureFile = TRUE;
caps.bAntiFraudModule = TRUE;
return NewBuffer(env, &caps, sizeof(WFSCAMCAPS));
}
JNIEXPORT jobject JNICALL Java_at_o2xfs_xfs_cdm_v3_130_Blacklist3_130Test_buildBlacklist3_130(JNIEnv *env, jobject obj) {
Blacklist.lpszVersion = Version;
Blacklist.usCount = 2;
Blacklist.lppBlacklistElements = lppBlacklistElements;
BlacklistElements[0].lpszSerialNumber = SerialNumber[0];
strcpy(BlacklistElements[0].cCurrencyID, "EUR");
BlacklistElements[0].ulValue = 10;
lppBlacklistElements[0] = &BlacklistElements[0];
BlacklistElements[1].lpszSerialNumber = SerialNumber[1];
strcpy(BlacklistElements[1].cCurrencyID, "EUR");
BlacklistElements[1].ulValue = 50;
lppBlacklistElements[1] = &BlacklistElements[1];
return NewBuffer(env, &Blacklist, sizeof(WFSCDMBLACKLIST));
}
HRESULT CLR_RT_HeapBlock_MemoryStream::Initialize( CLR_UINT8* buf, CLR_UINT32 len )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
m_buffers.DblLinkedList_Initialize(); // CLR_RT_DblLinkedList m_buffers; // EVENT HEAP - NO RELOCATION - list of CLR_RT_HeapBlock_MemoryStream::Buffer
CHECK_ALLOCATION(NewBuffer());
if(buf)
{
m_current->m_data = buf;
m_current->m_length = len;
}
TINYCLR_NOCLEANUP();
}
IFXString::IFXString(const IFXString* operand)
: m_Buffer(NULL),
m_BufferLength(0)
{
if(!operand)
{
DeleteBuffer();
}
else
{
if (operand->m_BufferLength > 0)
{
NewBuffer((U32)operand->m_BufferLength);
if (m_Buffer)
wcscpy(m_Buffer, operand->m_Buffer);
}
}
}
/* recv stream to a edp packet (S->C) */
EdpPacket* GetEdpPacket(RecvBuffer* buf)
{
EdpPacket* pkg = NULL;
int32_t flag = 0;
flag = IsPkgComplete(buf);
if (flag <= 0)
{
printf("%s flag<=0\n", __func__);
return pkg;
}
pkg = NewBuffer();
WriteBytes(pkg, buf->_data, flag);
/* shrink buffer */
memmove(buf->_data, buf->_data + flag, buf->_write_pos - flag);
buf->_write_pos -= flag;
return pkg;
}
EdpPacket* PacketSavedataBinStr(const int8_t* dst_devid,
const int8_t* desc_str, const uint8_t* bin_data, uint32_t bin_len)
{
EdpPacket* pkg = NULL;
uint32_t remainlen = 0;
uint32_t desc_len = 0;
/* check arguments */
desc_len = strlen((const char *)desc_str);
if (desc_len > (0x01 << 16) || bin_len > (3 * (0x01 << 20)))
{
/* desc < 2^16 && bin_len < 3M*/
return 0;
}
pkg = NewBuffer();
/* msg type */
WriteByte(pkg, SAVEDATA);
if (dst_devid)
{
/* remain len */
remainlen = 1 + (2 + strlen((const char *)dst_devid)) + 1 + (2 + desc_len) + (4 + bin_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x80);
/* dst devid */
WriteStr(pkg, dst_devid);
}
else
{
/* remain len */
remainlen = 1 + 1 + (2 + desc_len) + (4 + bin_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x00);
}
/* bin flag */
WriteByte(pkg, 0x02);
/* desc */
WriteStr(pkg, desc_str);
/* bin data */
WriteUint32(pkg, bin_len);
WriteBytes(pkg, bin_data, bin_len);
return pkg;
}
static void PPDialingHandler(SignalType * Signal)
{
switch (Signal->Event)
{
case IWU_PRIMITIVE:
{
switch (Signal->SubEvent)
{
case CC_CONNECT_prim:
{
SignalType * startAudio;
NewBuffer(sizeof(SignalType), (void**) &startAudio);
SendSignal((SignalType*) startAudio, DSP_PROCESS_ID, SETUPAUDIO_EVENT, 0);
connected = 1;
}
case CC_INFO_prim: /*do not break*/
{
if (connected == 1) {
SignalType* mySignal;
NewSignal(sizeof(SignalType) + 2 + strlen(numberToDial), (void **) &mySignal);
getSignalData(mySignal)[0] = 0x2c;
getSignalData(mySignal)[1] = strlen(numberToDial);
memcpy(getSignalData(mySignal) + 2, numberToDial, strlen(numberToDial));
InjectSignal(mySignal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_INFO_prim, Signal->SessionId);
}
}
break;
case CC_RELEASE_prim:
{
if (connected == 1) {
Signal->SignalLength = sizeof(CcReleaseComPrimType);
SendSignal(Signal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_RELEASE_COM_prim);
connected = 0;
setSignalHandler(APPLICATION_PROCESS_ID_PP, PPconnectionHandler, 0);
return;
}
}
break;
}
}
}
DeleteBuffer(Signal);
}
ApplicationInstanceType * getApplicationInstance(PMIDType PMID)
{
ApplicationInstanceType *applicationInstanceData;
applicationInstanceData = (ApplicationInstanceType *) GetNode(&applicationTree, PMID);
if (applicationInstanceData == NULL) {
NewBuffer(sizeof(ApplicationInstanceType), (void **) &applicationInstanceData);
memcpy(applicationInstanceData->pmid, PMID, sizeof(PMIDType));
applicationInstanceData->state = idle;
applicationInstanceData->msfState = msf_idle;
applicationInstanceData->timer = 0;
AddNode(&applicationTree, applicationInstanceData, applicationInstanceData->pmid);
created++;
PrintStatus(0, "created: ");
}
return applicationInstanceData;
}
VOID Queue<T,ElementTraits,ThreadingModel>::Enqueue( CONST T& Item )
{
if (m_Tail < m_Head)
{
if (m_Head < m_Buffer.Length())
m_Buffer[m_Head++] = Item;
else
{
if (m_Tail > 0)
m_Head = 0;
else
{
if (m_Buffer.Length() < 16)
m_Buffer.Resize( 16 );
else
m_Buffer.Resize( (SIZE_T)((FLOAT)(m_Buffer.Length()+1) * 1.5) );
}
m_Buffer[m_Head++] = Item;
}
}
else if (m_Tail > m_Head)
m_Buffer[m_Head++] = Item;
else if (m_Tail == m_Head)
{
if (m_Tail == 0)
{
if (m_Buffer.Length() < 16)
m_Buffer.Resize( 16 );
m_Buffer[m_Head++] = Item;
}
else
{
SIZE_T TailSize = m_Buffer.Length() - m_Tail;
Buffer<T> NewBuffer( (SIZE_T)((FLOAT)(m_Buffer.Length()+1) * 1.5) );
CopyObjects( &NewBuffer[0] , &m_Buffer[m_Tail], TailSize );
CopyObjects( &NewBuffer[TailSize] , &m_Buffer[0], m_Head );
m_Tail = 0;
m_Head = m_Buffer.Length();
m_Buffer = NewBuffer;
m_Buffer[m_Head++] = Item;
}
}
}
//---------------------------------------------------------------------------
// IFXString::Assign converter
//
// This method copies the source characters to the destination making any
// conversions that are necessary
//---------------------------------------------------------------------------
IFXRESULT IFXString::Assign(const IFXCHAR* pSource)
{
IFXRESULT result = IFX_OK;
if(!pSource)
{
DeleteBuffer();
}
else
{
NewBuffer((U32)wcslen(pSource)+1);
if (m_Buffer)
wcscpy(m_Buffer, pSource);
else
result = IFX_E_OUT_OF_MEMORY;
}
return result;
}
EdpPacket* PacketCmdResp(const int8_t* cmdid, uint16_t cmdid_len,
const int8_t* resp, uint32_t resp_len)
{
EdpPacket* send_pkg = NULL;
unsigned remainlen = 0;
send_pkg = NewBuffer();
/* 6 = 2 + 4 = len(cmdid_len) + len(resp_len) */
remainlen = cmdid_len + resp_len + (resp_len ? 6 : 2);
WriteByte(send_pkg, CMDRESP);
WriteRemainlen(send_pkg, remainlen);
WriteUint16(send_pkg, cmdid_len);
WriteBytes(send_pkg, cmdid, cmdid_len);
if (resp_len)
{
WriteUint32(send_pkg, resp_len);
WriteBytes(send_pkg, resp, resp_len);
}
return send_pkg;
}
/* recv stream to a edp packet (S->C) */
EdpPacket* GetEdpPacket(RecvBuffer* buf)
{
//assert(buf->_read_pos == 0);
EdpPacket* pkg = 0;
int32 flag = IsPkgComplete(buf);
if (flag <= 0)
{
return pkg;
}
pkg = NewBuffer();
WriteBytes(pkg, buf->_data, flag);
/* shrink buffer */
mymemmove(buf->_data, buf->_data + flag, buf->_write_pos - flag);
buf->_write_pos -= flag;
return pkg;
}
/* sava_data (C->S) */
EdpPacket* PacketSavedataJson(const char* dst_devid, cJSON* json_obj, int type)
{
EdpPacket* pkg = NewBuffer();
uint32 remainlen = 0;
char* json_out = cJSON_Print(json_obj);
uint32 json_len = mystrlen(json_out);
//printjson(json_obj);//_hx_printf("json type=%d,c=0x%X,p=0x%X n=0x%X",json_obj->type,json_obj->child,json_obj->prev,json_obj->next);
//return 0;
/* msg type */
WriteByte(pkg, SAVEDATA);
if (dst_devid)
{
/* remain len */
remainlen = 1+(2+mystrlen(dst_devid))+1+(2+json_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x80);
/* dst devid */
WriteStr(pkg, dst_devid);
}
else
{
/* remain len */
remainlen = 1+1+(2+json_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x00);
}
/* json flag */
WriteByte(pkg, type);
/* json */
WriteStr(pkg, json_out);
hx_free(json_out);
return pkg;
}
/* sava_data (C->S) */
EdpPacket* PacketSavedataJson(const int8_t* dst_devid, cJSON* json_obj, int32_t type)
{
EdpPacket* pkg = NULL;
uint32_t remainlen = 0;
int8_t* json_out = NULL;
uint32_t json_len = 0;
pkg = NewBuffer();
json_out =(int8_t *) cJSON_Print(json_obj);
json_len = strlen((const char *)json_out);
/* msg type */
WriteByte(pkg, SAVEDATA);
if (dst_devid)
{
/* remain len */
remainlen = 1 + (2 + strlen((const char *)dst_devid)) + 1 + (2 + json_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x80);
/* dst devid */
WriteStr(pkg, dst_devid);
}
else
{
/* remain len */
remainlen = 1 + 1 + (2 + json_len);
WriteRemainlen(pkg, remainlen);
/* translate address flag */
WriteByte(pkg, 0x00);
}
/* json flag */
WriteByte(pkg, type);
/* json */
WriteStr(pkg, json_out);
printf("%s \n", json_out);
free(json_out);
return pkg;
}
IFXString::IFXString(const char* operand)
: m_Buffer(NULL),
m_BufferLength(0)
{
if(!operand)
{
DeleteBuffer();
}
else
{
U32 size = 0;
IFXRESULT result = IFXOSGetWideCharStrSize( (const U8*)operand, &size );
size = size + 1; // null terminator
if( IFXSUCCESS(result) && (size > 0) )
{
NewBuffer(size);
if (m_Buffer)
IFXOSConvertUtf8StrToWideChar( (const U8*)operand, m_Buffer, size );
}
}
}
// &**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&
// Assignment Support
// &**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&**&
//---------------------------------------------------------------------------
// IFXString::Assign
//
// This method copies the source characters to the destination buffer
//---------------------------------------------------------------------------
IFXRESULT IFXString::Assign(const IFXString* pSource)
{
IFXRESULT result = IFX_OK;
if(!pSource)
{
DeleteBuffer();
}
else
{
if (pSource->m_BufferLength > 0)
{
NewBuffer(pSource->m_BufferLength);
if (m_Buffer)
wcscpy(m_Buffer, pSource->m_Buffer);
else
result = IFX_E_OUT_OF_MEMORY;
}
}
return result;
}
BOOL CCircuitry::OnDialPacket(CDialPacket* pPacket)
{
CSingleLock pLock( &Network.m_pSection, TRUE );
CHAR xRemoteId[MAX_PHONE + 1];
xRemoteId[ pPacket->GetRemoteId( xRemoteId ) ] = '\0';
CChannel* pChannel = Network.LookOutPhs( xRemoteId );
if ( ! pChannel ) return SendPacket( new CErrPacket( ECore_Busy ) );
int nChan = pChannel->m_nChan;
SsmSetRecMixer( nChan, FALSE, 0 );
SsmSetDTMFStopRecCharSet( nChan, "" );
SsmSetDtmfStopPlay( nChan, FALSE );
pChannel->OnDialPacket( pPacket );
NewBuffer( nChan );
Start( nChan );
return TRUE;
}
/* connect1 (C->S): devid + apikey */
EdpPacket* PacketConnect1(const char* devid, const char* auth_key)
{
EdpPacket* pkg = NewBuffer();
uint32 remainlen;
/* msg type */
WriteByte(pkg, CONNREQ);
/* remain len */
remainlen = (2+3)+1+1+2+(2+mystrlen(devid))+(2+mystrlen(auth_key));
WriteRemainlen(pkg, remainlen);
/* protocol desc */
WriteStr(pkg, PROTOCOL_NAME);
/* protocol version */
WriteByte(pkg, PROTOCOL_VERSION);
/* connect flag */
WriteByte(pkg, 0x40);
/* keep time */
WriteUint16(pkg, 0x0080);
/* DEVID */
WriteStr(pkg, devid);
/* auth key */
WriteStr(pkg, auth_key);
return pkg;
}
JNIEXPORT jobject JNICALL Java_com_aio4c_buffer_Buffer_allocate(JNIEnv* jvm, jclass clazz, jint capacity) {
Buffer* buffer = NULL;
jmethodID constructor = NULL;
jobject jBuffer = NULL;
jstring jmsg = NULL;
CheckJNICall(jvm, (*jvm)->GetMethodID(jvm, clazz, "<init>", "()V"), constructor);
CheckJNICall(jvm, (*jvm)->NewObject(jvm, clazz, constructor), jBuffer);
buffer = NewBuffer(capacity);
if (buffer == NULL) {
CheckJNICall(jvm, (*jvm)->NewStringUTF(jvm, "cannot allocate buffer"), jmsg);
RaiseJavaException(
jvm,
"java/lang/OutOfMemoryError",
"(Ljava/lang/String;)V",
jmsg);
} else {
SetPointer(jvm, jBuffer, buffer);
}
return jBuffer;
}
int gameloop(void)
{
struct Buffer *buffer;
int ticks;
int c = 0;
int cmd1, cmd2;
int done = NO;
time_t t;
struct tm *tp;
buffer = NewBuffer();
SetClip(0, 0, SCREEN_WIDTH - 1, SCREEN_HEIGHT - 1);
if (ModuleStatus() != MODULE_OK)
DisplayMessage(ModuleMessage());
gameIsPaused = NO;
missionTime = 0;
//screenShaking = 0;
while (!done) {
frames++;
Ticks_FrameBegin();
ticks = Ticks_Synchronize();
if (gOptions.displaySlices)
SetColorZero(32, 0, 0);
DrawScreen(buffer, gPlayer1, gPlayer2);
if (gOptions.displaySlices)
SetColorZero(0, 0, 0);
if (screenShaking) {
screenShaking -= ticks;
if (screenShaking < 0)
screenShaking = 0;
}
debug(D_VERBOSE, "frames... %d\n", frames);
if (Ticks_TimeElapsed(TICKS_PER_SEC)) {
fps = frames;
debug(D_NORMAL, "fps = %d\n", fps);
frames = 0;
t = time(NULL);
tp = localtime(&t);
timeHours = tp->tm_hour;
timeMinutes = tp->tm_min;
}
if (messageTicks > 0)
messageTicks -= ticks;
StatusDisplay();
if (!gameIsPaused) {
missionTime += ticks;
if ((gPlayer1 || gPlayer2) && MissionCompleted()) {
if (gMission.pickupTime == PICKUP_LIMIT)
PlaySound(SND_DONE, 0, 255);
gMission.pickupTime -= ticks;
if (gMission.pickupTime <= 0)
done = YES;
} else
gMission.pickupTime = PICKUP_LIMIT;
}
if (gOptions.displaySlices)
SetColorZero(0, 0, 32);
if (gOptions.displaySlices)
SetColorZero(0, 0, 0);
CopyToScreen();
if (!gameIsPaused) {
if (!gOptions.slowmotion || (frames & 1) == 0) {
UpdateAllActors(ticks);
UpdateMobileObjects();
GetPlayerInput(&cmd1, &cmd2);
if (gPlayer1 && !PlayerSpecialCommands(
gPlayer1, cmd1, &gPlayer1Data)) {
CommandActor(gPlayer1, cmd1);
}
if (gPlayer2 && !PlayerSpecialCommands(
gPlayer2, cmd2, &gPlayer2Data)) {
CommandActor(gPlayer2, cmd2);
}
if (gOptions.badGuys)
CommandBadGuys();
UpdateWatches();
}
} else {
GetPlayerInput(&cmd1, &cmd2);
}
if (!gPlayer1 && !gPlayer2) {
done = YES;
c = 0;
} else {
c = HandleKey(&done, cmd1 | cmd2);
}
Ticks_FrameEnd();
}
free(buffer);
return c != keyEsc;
}
