/**
* Utility function for reading just the header from an ASIM msg
*
* @param buf The buffer to read the header into
* @param doBlocking Whether this function should continue attempting to read until
* data becomes available.
*
* @return An int containing the number of bytes actually read, -1 indicates
* an unresponsive ASIM. 0 indicates that the ASIM responded, but did
* not have any data available for reading. If doBlocking is true, -1
* can also signify a timeout.
*/
int Spa1Asim::readPacketHeader(unsigned char* buf, bool doBlocking)
{
int bytesRead = 0;
if (!doBlocking)
{
bytesRead = read(i2cFd, buf, SPA1_HEADER_SIZE);
if (bytesRead == -1)
{
return bytesRead;
}
if (buf[0] == 0xff && buf[1] == 0xff && buf[2] == 0xff)
{
bytesRead = 0;
}
}
else
{
bool dataReady = false;
double endTime = getCurTime() + ASIM_READ_TIMEOUT;
while (!dataReady)
{
bytesRead = read(i2cFd, buf, SPA1_HEADER_SIZE);
if (bytesRead == -1)
{
break;
}
if (buf[0] == 0xff && buf[1] == 0xff && buf[2] == 0xff)
{
dataReady = false;
usleep(1000);
}
else
{
dataReady = true;
}
if (getCurTime() > endTime)
{
bytesRead = -1;
break;
}
}
}
return bytesRead;
}
u2 Timer::getSince(const u2 time) {
const u2 t = getCurTime();
if (t > time)
return t - time;
return CountsPerClear + t - time;
}
void Networker::pingFunction(std::nullptr_t)
{
uint64_t diff;
while (!_finished) {
std::unique_lock<Lock> l(_lock);
for (auto& peer : _peers) {
diff = getCurTime() - std::get<peerInd::time>(peer.second);
if (diff > 1000000) {
// std::cout << "Timeout !" << std::endl;
ServerPingPacket pack;
pack.setStatus(true);
l.unlock();
send(&pack, peer.first);
l.lock();
}
if (diff > 8000000) {
_toErase.push_back(peer.first);
}
}
for (auto& elem : _toErase)
if (_peers.find(elem) != _peers.end()) {
_peers.erase(elem);
_PacketHandler->disconnectPlayer(elem);
}
_toErase.clear();
l.unlock();
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
void
AsdkDocReactor::documentToBeActivated(AcApDocument* pDoc)
{
if (pDoc == curDocGlobals.doc)
bumpCount(/*NOXLATE*/"#DOC_ACTIVATED(SAME)", Adesk::kTrue);
else {
// If switching documents, record the time spent on the
// current document's active command/lisp and reset the
// start time in the new document's active command/lisp.
int i;
if (curDocGlobals.doc != NULL) {
if ((i = curDocGlobals.cmdIndex - 1) >= 0)
recordElapsedCmdTime(curDocGlobals.cmdRcd[i],
curDocGlobals.cmdStartTime[i]);
if (curDocGlobals.lispRcd != NULL)
recordElapsedCmdTime(curDocGlobals.lispRcd,
curDocGlobals.lispStartTime);
docData[lookupDoc(curDocGlobals.doc)] = curDocGlobals;
}
if (pDoc == NULL) {
// This isn't supposed to happen...
assert(pDoc!=NULL);
// But in production, just log it and keep going...
bumpCount(/*NOXLATE*/"#NULL_DOC_ACTIVATED", Adesk::kTrue);
curDocGlobals.doc = NULL;
return;
}
curDocGlobals = (docData[lookupDoc(pDoc)]);
double currentTime = getCurTime();
if ((i = curDocGlobals.cmdIndex - 1) >= 0)
curDocGlobals.cmdStartTime[i] = currentTime;
curDocGlobals.lispStartTime = currentTime;
bumpCount(/*NOXLATE*/"#DOC_SWITCHED", Adesk::kTrue);
}
}
static void hcore(const char *file, int line, int level, int status, const char *fmt, va_list args)
{
//记录日志str
char str[LOG_MAX_STRING_LEN];
int strLen = 0;
char tmpStr[64];
int tmpStrLen = 0;
FILE *pf = NULL;
//初始化
memset(str, 0, LOG_MAX_STRING_LEN);
memset(tmpStr, 0, 64);
//加入Log时间
tmpStrLen = getCurTime(tmpStr);
tmpStrLen = sprintf(str, "[%s] ", tmpStr);
strLen += tmpStrLen;
//加入Log等级
tmpStrLen = sprintf(str+strLen, "[%s] ", LogLevelName[level]);
strLen += tmpStrLen;
//加入Log状态
if(status != 0)
{
tmpStrLen = sprintf(str+strLen, "[ERROR is %d] ", status);
}
else
{
tmpStrLen = sprintf(str+strLen, "[SUCCESS] ");
}
strLen += tmpStrLen;
//加入Log信息
tmpStrLen = vsprintf(str+strLen, fmt, args);
strLen += tmpStrLen;
//加入Log发生文件
tmpStrLen = sprintf(str+strLen, " [%s]", file);
strLen += tmpStrLen;
//加入Log发生行数
tmpStrLen = sprintf(str+strLen, " [%d]\n", line);
strLen += tmpStrLen;
//打开Log文件
int ret = openFile(&pf);
if(ret == -1)
{
printf("open file error \n");
return;
}
//写入Log文件
fwrite(str, strLen, 1, pf);
//fputs(str, pf);
fclose(pf);
return;
}
void recordCommandDuration()
{
if (curDocGlobals.doc == NULL)
return;
if (curDocGlobals.cmdIndex > 0 ) {
curDocGlobals.cmdIndex--;
// Record the time spent in the ended command
recordElapsedCmdTime(curDocGlobals.cmdRcd[curDocGlobals.cmdIndex],
curDocGlobals.cmdStartTime[curDocGlobals.cmdIndex]);
// restart the clock in the suspended command, if there is one.
if (curDocGlobals.cmdIndex > 0)
curDocGlobals.cmdStartTime[curDocGlobals.cmdIndex - 1] = getCurTime();
}
int i = lookupDoc(curDocGlobals.doc);
assert(i >= 0);
docData[i] = curDocGlobals;
// Active command stack has been fully popped and we have a pending
// statistics file update?
if (bStatsFileUpdatePending && ::updateCumulativeStats())
/* We have completed an operation such as SAVE or WBLOCK since
this lisp expression began, and this is a convenient time to
at least try to update the
stats file with the current counts. This must be marked pending
and done after command completion because cmdRcd[] points to a
CommandRecord object in *sessionStats which is deleted in
updateCumulativeStats()called below. updateCumulativeStats
will return kFalse if any documents have any active command
or LISP expressions, in which case, this will have to wait.
JMC, WCA 7/15/98 */
bStatsFileUpdatePending = Adesk::kFalse;
}
void CtpTraderSpi::OnRspOrderInsert(CThostFtdcInputOrderField *pInputOrder,
CThostFtdcRspInfoField *pRspInfo, int nRequestID, bool bIsLast)
{
CXTraderDlg* pDlg = (CXTraderDlg*)g_pCWnd;
if( IsErrorRspInfo(pRspInfo) || (pInputOrder==NULL) )
{
TCHAR szErr[MAX_PATH];
ansi2uni(CP_ACP,pRspInfo->ErrorMsg,szErr);
CThostFtdcOrderField* ErrOrd = new CThostFtdcOrderField();
ZeroMemory(ErrOrd, sizeof(CThostFtdcOrderField));
getCurTime(ErrOrd->InsertTime);
strcpy(ErrOrd->InstrumentID,pInputOrder->InstrumentID);
ErrOrd->Direction = pInputOrder->Direction;
strcpy(ErrOrd->CombOffsetFlag,pInputOrder->CombOffsetFlag);
ErrOrd->OrderStatus = THOST_FTDC_OST_ErrOrd;
ErrOrd->LimitPrice = pInputOrder->LimitPrice;
ErrOrd->VolumeTotalOriginal = pInputOrder->VolumeTotalOriginal;
ErrOrd->VolumeTotal = pInputOrder->VolumeTotalOriginal;
ErrOrd->VolumeTraded = 0;
m_orderVec.push_back(ErrOrd);
pDlg->InsertLstOrder(ErrOrd,INSERT_OP,szErr);
}
if(bIsLast) SetEvent(g_hEvent);
}
vector<float> Timeline::getPoints() const {
vector<float> result;
for_each(frames.begin(), frames.end(), [this, &result](pair<const float, frame_t> p) {
result.push_back(p.first / getCurTime());
});
return result;
}
void cglTimer::update()
{
float rCurTime = getCurTime();
m_rDelta = rCurTime - m_rPrevTime;
m_rTime += m_rDelta;
m_rPrevTime = rCurTime;
}
cglTimer::cglTimer()
: m_rTime(0.0f)
, m_rDelta(0.0f)
{
QueryPerformanceFrequency((LARGE_INTEGER*)&m_freq);
m_rPrevTime = getCurTime();
}
bool VideoHandler::saveFrame()
{
string fileName;
getCurTime(fileName);
fileName += ".jpg";
cout << "Saving key frame to '" << fileName << "'." << endl;
return imwrite(fileName, mFrame);
}
void countCommand(const char* cmdStr)
{
// If nesting a command, record the time spent in the pushed command, and
// stop counting it.
if (curDocGlobals.cmdIndex > 0)
recordElapsedCmdTime(curDocGlobals.cmdRcd[curDocGlobals.cmdIndex - 1],
curDocGlobals.cmdStartTime[curDocGlobals.cmdIndex - 1]);
curDocGlobals.cmdRcd[curDocGlobals.cmdIndex] = bumpCount(cmdStr, Adesk::kTrue);
curDocGlobals.cmdStartTime[curDocGlobals.cmdIndex++] = getCurTime();
}
void Clock::start()
{
if (m_lastStart != 0)
{
//already started
return;
}
//set last start to curtime
m_lastStart = getCurTime();
}
void AsdkCmdCountDocData::recordAndPop()
{
cmdIndex--;
// Record the time spent in the ended command
recordElapsedCmdTime(cmdRcd[cmdIndex],
cmdStartTime[cmdIndex]);
// restart the clock in the suspended command, if there is one.
if (cmdIndex > 0)
cmdStartTime[cmdIndex - 1] = getCurTime();
}
void ConsoleLog::warn(string fmt, ...)
{
stringstream ss;
char buf[MAX_LOG_LINE];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, MAX_LOG_LINE, fmt.c_str(), ap);
va_end(ap);
ss<<"["<<getCurTime()<<"]"<<"-"<<"|WARN|"<<":"<<buf;
cout<<ss.str()<<endl;
}
ClockStamp Clock::getElapsedSinceLastStart()
{
if (m_lastStart == 0)
{
//hasn't been started
return 0;
}
ClockStamp elapsed = getCurTime() - m_lastStart;
if (elapsed > 2000000000) // only time differences up to 23 days can be measured with this function
elapsed = 2000000000;
return elapsed;
}
int Timeline::findTempForPos(float pos, vector<float>& temps) {
auto curPos = pos * getCurTime();
auto to = frames.upper_bound(curPos);
if (to != frames.end() && to != frames.begin()) {
auto from = to;
--from;
auto frameFrom = from->second;
auto frameTo = to->second;
auto dydx = (curPos - from->first) / (to->first - from->first);
for (int i = 0; i < std::min(frameFrom.temps.size(), frameTo.temps.size()); ++i) {
float temp = frameFrom.temps[i] + dydx * (frameTo.temps[i] - frameFrom.temps[i]);
temps.push_back(temp);
//printf("%f, %f\n", frameFrom.temps[i], frameTo.temps[i]);
}
return 0;
}
return -1;
}
void riku::logger::newMess__(const char* _message, loggerMessageType _type, bool newString ){
// std::ofstream of;
// of.open(path2file.c_str(), std::ios_base::app );
// of.seekp (of.tellp());
char ctime[100];
getCurTime(ctime, sizeof(ctime));
/* if (_type<NUM_ERR_MESS_TYPE)
of<<typeMessCode[_type]<<" "<<ctime<<" "<<_message;
else
of<<typeMessCode[error]<<" "<<ctime<<" !ошибка поределения типа сообщения! "<<_message;
if (newString)
of<<std::endl;
of.close();
*/
if (_in_loggerGui )
_in_loggerGui->insertMess__(ctime, _message, _type, newString );
}
void td_printf(const char* fmt,...){
const int MAX_DBG_STR = 1024;
int written = 0;
char buffer[MAX_DBG_STR];
memset(buffer,0,MAX_DBG_STR);
va_list va;
va_start( va, fmt );
written = vsprintf( &buffer[0], fmt, va);
va_end(va);
FILE *myLog = NULL;
myLog = fopen("/mnt/sdcard/seraphim/seraphim.log","a+");
if (myLog != NULL)
{
char tmp[50] = {0};
getCurTime((char *)tmp);
int thepid = (int)getpid();
char buf[18];
memset( buf, 0x0, sizeof( buf ) );
snprintf(buf,sizeof(buf),"%d",thepid );
fputs("[PID:",myLog);
fputs(buf,myLog);
fputs("]",myLog);
pthread_t tid = pthread_self();
memset( buf, 0x0, sizeof( buf ) );
snprintf(buf,sizeof(buf),"%d", (unsigned int)tid);
fputs("[TID:",myLog);
fputs(buf,myLog);
fputs("]",myLog);
fputs(tmp,myLog);
fputs(" ",myLog);
fputs(buffer,myLog);
}else{
__android_log_write(1,"PORT","LOGError");
}
fclose(myLog);
}
//本地条件单和预埋单都通过OrderRef来定位
void ParkOrdDlg::GenCondLocal()
{
CXTraderDlg* pDlg = g_Dlg;
CtpTdSpi* td = gc_Td;
m_conType = CondTyTable[4*m_iSelPx+m_iSelCond];
PARKEDEX pkReq;
ZeroMemory(&pkReq,sizeof(pkReq));
strcpy(pkReq.park.InstrumentID, m_instId);
//这里需要在发送时从spi里自增
sprintf(pkReq.park.OrderRef, "%012d", ++pDlg->m_iRef_tj);
pkReq.park.Direction = m_cDir;
pkReq.park.CombOffsetFlag[0] = m_cKp;
pkReq.park.LimitPrice = (m_iLmt== LAST_DSJ)?LAST_DJ_ALIAS:m_dLmtPx; //价格
pkReq.park.VolumeTotalOriginal = m_iVol; ///数量
pkReq.park.OrderPriceType = m_cPxType;
pkReq.park.TimeCondition = m_cTmcType;
pkReq.park.VolumeCondition = THOST_FTDC_VC_AV;
pkReq.park.ContingentCondition = m_conType;
pkReq.park.StopPrice = m_dStopPx;
pkReq.park.CombHedgeFlag[0] = THOST_FTDC_HF_Speculation;
td->GetExhByInst(m_instId,pkReq.park.ExchangeID);
pkReq.park.ForceCloseReason = THOST_FTDC_FCC_NotForceClose;
pkReq.ordType = COND_LOCAL;
pkReq.park.Status = THOST_FTDC_OST_NotTouched;
getCurDate(pkReq.InsertDate);
getCurTime(pkReq.InsertTime);
td->m_pkExVec.push_back(pkReq);
pDlg->m_xLst[PKCON_IDX].SetItemCountEx(static_cast<int>(gv_Pk.size()));
pDlg->m_xLst[PKCON_IDX].Invalidate();
}
Networker::Networker(int port, NetManager* manager, IPacketHandler* handler)
: _sock(new UdpSocket(port, "", manager)), _finished(false)
{
_PacketHandler = handler;
_buffer.resize(APacket::kMaxPacketSize);
_handle = [this] (ISocket::returnCode, ssize_t sizeRec, std::string addr, int port) {
std::unique_lock<Lock> l(_lock);
APacket* pack;
bool found = false;
unsigned int id = 0;
if (sizeRec <= 0) {
std::cerr << "receive error" << std::endl;
return;
}
for (auto elem : _peers) {
if (std::get<peerInd::port>(elem.second) == port &&
inet_addr(std::get<peerInd::addr>(elem.second).c_str()) == inet_addr(addr.c_str())) {
found = true;
id = elem.first;
break;
}
++id;
}
#ifdef DEBUG_NETWORK
std::cout << "[RECEIVING FROM :"<< id <<"] ";
#endif
pack = _packHandlers[APacket::sGetType(_buffer)](_buffer);
if (!found) {
std::cout << "New peer ! : " << addr << ":" << port << std::endl;
_peers[id] = std::make_tuple(addr, port, getCurTime());
}
l.unlock();
_PacketHandler->handlePacket(pack, id);
delete pack;
_asyncRec(_sock, _buffer, _handle);
};
_asyncRec(_sock, _buffer, _handle);
}
bool VideoHandler::saveVideo()
{
if (mSaveVideoFile.empty()) {
getCurTime(mSaveVideoFile);
mSaveVideoFile += ".mov";
cout << "Saving video to '" << mSaveVideoFile << "'." << endl;
// in Mac OS X, only 'mp4v' is supported
int fourcc = CV_FOURCC('m', 'p', '4', 'v');
Size size = Size((int)mCapture.get(CV_CAP_PROP_FRAME_WIDTH),
(int)mCapture.get(CV_CAP_PROP_FRAME_HEIGHT));
mWriter.open(mSaveVideoFile, fourcc, mVideoFPS, size, true);
}
if (!mWriter.isOpened()) {
return false;
}
mWriter << mFrame;
return true;
}
int main(int argc, char **argv)
{
setupUUGear();
setShowLogs(1);
UUGearDevice dev = attachUUGearDevice ("UUGear-Arduino-7853-2668");
if (dev.fd != -1)
{
double begin, end;
begin = getCurTime();
int value = analogRead(&dev, 3);
end = getCurTime();
printf("Analog read on A3 takes %f ms, value=%d\n", end - begin, value);
begin = getCurTime();
setPinModeAsInput (&dev, 9);
end = getCurTime();
printf("Set pin mode on D9 takes %f ms\n", end - begin);
begin = getCurTime();
value = getPinStatus(&dev, 9);
end = getCurTime();
printf("Digital read on D9 takes %f ms, value=%d\n", end - begin, value);
detachUUGearDevice (&dev);
}
else
{
printf("Can not open UUGear device.\n");
}
cleanupUUGear();
return 0;
}
bool CCutScene::slice(PhysicsWorld &world, const PhysicsRayCastInfo& info, void *data)
{
log("slice called %f, %f, %lld", info.contact.x, info.contact.y, m_lLastSlice);
if (!m_bHasFood) return true;
if (info.shape->getBody()->getTag() != _sliceTag)
{
return true;
}
long long llLastSlice = 0;
PhysicsBody* pBody = info.shape->getBody();
if (pBody == NULL) return true;
CFoodCut* pFood = (CFoodCut*)info.shape->getBody()->getNode();
if (pFood == NULL) return true;
llLastSlice = pFood->getBirthTime();
if (getCurTime() - llLastSlice <= 200) return true;
m_v2Delta.normalize();
Vec2 v2Start = info.contact - m_v2Delta * 100;
Vec2 v2End = info.contact + m_v2Delta * 500;
if (!info.shape->containsPoint(v2Start) && !info.shape->containsPoint(v2End))
{
Vec2 normal = v2End - v2Start;
normal = normal.getPerp().getNormalized();
float dist = v2Start.dot(normal);
clipPoly(dynamic_cast<PhysicsShapePolygon*>(info.shape), normal, dist);
clipPoly(dynamic_cast<PhysicsShapePolygon*>(info.shape), -normal, -dist);
Vec2 v2Direct = (v2End - v2Start).getNormalized();
Vec2 v2Tmp = Vec2::ZERO;
for (int i = 0; i < PARTICLE_COUNT; i++)
{
v2Tmp = info.contact + v2Direct * 80 * (i - 1);
if (!info.shape->containsPoint(v2Tmp))
{
continue;
}
else
{
m_pEmitter[i]->setPosition(v2Tmp);
m_pEmitter[i]->resetSystem();
}
}
std::vector<CFoodCut*>::iterator it;
for (it = m_vCutFoods.begin(); it != m_vCutFoods.end(); it++)
{
CFoodCut* pTmp = *it;
if (pTmp == info.shape->getBody()->getNode())
{
m_vCutFoods.erase(it);
break;
}
}
m_nSliceCount--;
info.shape->getBody()->removeFromWorld();
info.shape->getBody()->getNode()->removeFromParent();
checkFoodSliced();
}
return true;
}
void ParkOrdDlg::GenTmOrder()
{
CXTraderDlg* pDlg = g_Dlg;
CtpTdSpi* td = gc_Td;
COleDateTime tm;
m_tmEdit.GetDateTime(tm);
if (COleDateTime::GetCurrentTime()>tm)
{
ShowErroTips(LoadStr(IDS_TMLESSNOW),LoadStr(IDS_MY_TIPS));
return;
}
PTMORDPARAM m_ptmPara = new TMORDPARAM;
ZeroMemory(m_ptmPara,sizeof(TMORDPARAM));
m_ptmPara->dt.nYear = tm.GetYear();
m_ptmPara->dt.nMonth = tm.GetMonth();
m_ptmPara->dt.nDay = tm.GetDay();
m_ptmPara->dt.nHour = tm.GetHour();
m_ptmPara->dt.nMin = tm.GetMinute();
m_ptmPara->dt.nSec = tm.GetSecond();
m_ptmPara->pDlg = pDlg;
PARKEDEX pkReq;
ZeroMemory(&pkReq,sizeof(pkReq));
//存tmordpara结构体的指针
pkReq.pTmOrd = m_ptmPara;
strcpy(pkReq.park.InstrumentID, m_instId);
//这里需要在发送时从spi里自增
sprintf(pkReq.park.OrderRef, "%012d", ++pDlg->m_iRef_tm);
pkReq.park.Direction = m_cDir;
pkReq.park.CombOffsetFlag[0] = m_cKp;
pkReq.park.LimitPrice = (m_iLmt== LAST_DSJ)?LAST_DJ_ALIAS:m_dLmtPx; //价格
pkReq.park.VolumeTotalOriginal = m_iVol; ///数量
pkReq.park.OrderPriceType = m_cPxType;
pkReq.park.TimeCondition = m_cTmcType;
pkReq.park.VolumeCondition = THOST_FTDC_VC_AV;
pkReq.park.ContingentCondition = THOST_FTDC_CC_Immediately;
pkReq.park.CombHedgeFlag[0] = THOST_FTDC_HF_Speculation;
td->GetExhByInst(m_instId,pkReq.park.ExchangeID);
pkReq.park.ForceCloseReason = THOST_FTDC_FCC_NotForceClose;
pkReq.ordType = TMORD_LOCAL;
pkReq.park.Status = THOST_FTDC_OST_NotTouched;
sprintf(pkReq.park.ErrorMsg,"%04d-%02d-%02d %d:%02d:%02d",tm.GetYear(),tm.GetMonth(),
tm.GetDay(),tm.GetHour(),tm.GetMinute(),tm.GetSecond());
getCurDate(pkReq.InsertDate);
getCurTime(pkReq.InsertTime);
memcpy(&m_ptmPara->pkReq,&pkReq,sizeof(PARKEDEX));
HANDLE hTmOrd = ::CreateThread(NULL,NULL,(LPTHREAD_START_ROUTINE)CXTraderDlg::SendTmOrd, m_ptmPara,CREATE_SUSPENDED,NULL);
if (hTmOrd != NULL)
{
pkReq.hThd = hTmOrd;
td->m_pkExVec.push_back(pkReq);
pDlg->m_xLst[PKCON_IDX].SetItemCountEx(static_cast<int>(gv_Pk.size()));
pDlg->m_xLst[PKCON_IDX].Invalidate();
::ResumeThread(hTmOrd);
}
}
void CCutScene::clipPoly(PhysicsShapePolygon* shape, Point normal, float distance)
{
PhysicsBody* body = shape->getBody();
int count = shape->getPointsCount();
int pointsCount = 0;
Point* points = new Point[count + 1];
Vector2dVector vcPoints;
vcPoints.clear();
Vector2d v2Point(0, 0);
for (int i=0, j=count-1; i<count; j=i, ++i)
{
Point a = body->local2World(shape->getPoint(j));
float aDist = a.dot(normal) - distance;
if (aDist < 0.0f)
{
points[pointsCount] = a;
++pointsCount;
}
Point b = body->local2World(shape->getPoint(i));
float bDist = b.dot(normal) - distance;
if (aDist*bDist < 0.0f)
{
float t = std::fabs(aDist)/(std::fabs(aDist) + std::fabs(bDist));
Vec2 v2Tmp = a.lerp(b, t);
points[pointsCount] = v2Tmp;
++pointsCount;
}
}
Point center = PhysicsShape::getPolyonCenter(points, pointsCount);
for (int i = 0; i < pointsCount; i++)
{
points[i] = body->world2Local(points[i]);
vcPoints.push_back(Vector2d(points[i].x, points[i].y));
}
PhysicsBody* polyon = PhysicsBody::createPolygon(points, pointsCount);
CFoodCut* pNode = (CFoodCut*)(body->getNode());
std::vector<int> vMaterials;
vMaterials.clear();
vMaterials = pNode->getMaterials();
MATERIAL_ID eId = MI_MAX;
if (vMaterials.size() != 0)
{
eId = (MATERIAL_ID)vMaterials[0];
}
CFoodCut *filledPolygon = CFoodCut::create(eId, vcPoints, pNode->getPanziIndex(), pNode->getTouchedIndex());
filledPolygon->setPhysicsBody(polyon);
int nTmp = rand() % 50 + 50;
int nTmpRotate = rand() % 30 - 60;
filledPolygon->setPosition(body->getPosition());
//filledPolygon->setRotation(filledPolygon->getRotation() + nTmpRotate);
filledPolygon->getPhysicsBody()->setTag(_sliceTag);
filledPolygon->getPhysicsBody()->setGravityEnable(false);
polyon->setVelocity(body->getVelocityAtWorldPoint(center));
//polyon->setAngularVelocity(body->getAngularVelocity());
polyon->setTag(_sliceTag);
float fMass = polyon->getMass();
float fV = 80;
float fImpulse = fMass * fV;
float fTmpX = (float)(Random() % 30) / 100.0f - 0.15f;
float fTmpY = (float)(rand() % 30) / 100.0f - 0.15f;
polyon->applyImpulse((normal + Vec2(fTmpX, fTmpY)) * -fImpulse);
polyon->setLinearDamping(0.8f);
addChild(filledPolygon, 80);
filledPolygon->setBirthTime(getCurTime());
m_vCutFoods.push_back(filledPolygon);
m_nSliceCount ++;
delete[] points;
}
int SyncVideoDecoder::getCurFrame() const
{
return int(getCurTime()*getStreamFPS()+0.49);
}
//主函数
int main(int argc, char* argv[])
{
//加载套接字库（必须）
WORD wVersionRequested;
WSADATA wsaData;
//套接字加载时错误提示
int err;
//版本 2.2
wVersionRequested = MAKEWORD(2, 2);
//加载 dll 文件 Scoket 库
err = WSAStartup(wVersionRequested, &wsaData);
if (err != 0){
//找不到 winsock.dll
printf("WSAStartup failed with error: %d\n", err);
return -1;
}
if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
{
printf("Could not find a usable version of Winsock.dll\n");
WSACleanup();
}
else{
printf("The Winsock 2.2 dll was found okay\n");
}
SOCKET sockServer = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
//设置套接字为非阻塞模式
int iMode = 1; //1：非阻塞， 0 阻塞：
ioctlsocket(sockServer, FIONBIO, (u_long FAR*) &iMode);//非阻塞设置
SOCKADDR_IN addrServer; //服务器地址
//addrServer.sin_addr.S_un.S_addr = inet_addr(SERVER_IP);
addrServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//两者均可
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
err = bind(sockServer, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
if (err){
err = GetLastError();
printf("Could not bind the port %d for socket.Error code is %d\n", SERVER_PORT, err);
WSACleanup();
return -1;
}
SOCKADDR_IN addrClient; //客户端地址
int length = sizeof(SOCKADDR);
char buffer[BUFFER_LENGTH]; //数据发送接收缓冲区
ZeroMemory(buffer, sizeof(buffer));
//将测试数据读入内存
std::ifstream icin;
icin.open("../test.txt");
char data[1024 * 113];
ZeroMemory(data, sizeof(data));
icin.read(data, 1024 * 113);
icin.close();
totalPacket = sizeof(data) / 1024;
int recvSize;
for (int i = 0; i < SEQ_SIZE; ++i){
ack[i] = TRUE;
}
while (true){
//非阻塞接收，若没有收到数据，返回值为-1
recvSize =
recvfrom(sockServer, buffer, BUFFER_LENGTH, 0, ((SOCKADDR*)&addrClient), &length);
if (recvSize < 0){
Sleep(200);
continue;
}
printf("recv from client: %s\n", buffer);
if (strcmp(buffer, "-time") == 0){
getCurTime(buffer);
}
else if (strcmp(buffer, "-quit") == 0){
strcpy_s(buffer, strlen("Good bye!") + 1, "Good bye!");
}
else if (strcmp(buffer, "-testgbn") == 0){
//进入 gbn 测试阶段
//首先 server（ server 处于 0 状态）向 client 发送 205 状态码（ server进入 1 状态）
//server 等待 client 回复 200 状态码，如果收到（ server 进入 2 状态），则开始传输文件，否则延时等待直至超时\
//在文件传输阶段， server 发送窗口大小设为
ZeroMemory(buffer, sizeof(buffer));
int recvSize;
int waitCount = 0;
printf("Begain to test GBN protocol,please don't abort the process\n");
//加入了一个握手阶段
//首先服务器向客户端发送一个 205 大小的状态码（我自己定义的）表示服务器准备好了，可以发送数据
//客户端收到 205 之后回复一个 200 大小的状态码，表示客户端准备好了，可以接收数据了
//服务器收到 200 状态码之后，就开始使用 GBN 发送数据了
printf("Shake hands stage\n");
int stage = 0;
bool runFlag = true;
while (runFlag){
switch (stage){
case 0://发送 205 阶段
buffer[0] = 205;
sendto(sockServer, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR));
Sleep(100);
stage = 1;
break;
case 1://等待接收 200 阶段，没有收到则计数器+1，超时则放弃此次“连接”，等待从第一步开始
recvSize =
recvfrom(sockServer, buffer, BUFFER_LENGTH, 0, ((SOCKADDR*)&addrClient), &length);
if (recvSize < 0){
++waitCount;
if (waitCount > 20){
runFlag = false;
printf("Timeout error\n");
break;
}
Sleep(500);
continue;
}
else{
if ((unsigned char)buffer[0] == 200){
printf("Begin a file transfer\n");
printf("File size is %dB, each packet is 1024B and packet total num is %d\n", sizeof(data), totalPacket);
curSeq = 0;
curAck = 0;
totalSeq = 0;
waitCount = 0;
stage = 2;
}
}
break;
case 2://数据传输阶段
if (seqIsAvailable()){
//发送给客户端的序列号从 1 开始
buffer[0] = curSeq + 1;
ack[curSeq] = FALSE;
//数据发送的过程中应该判断是否传输完成
//为简化过程此处并未实现
memcpy(&buffer[1], data + 1024 * totalSeq, 1024);
printf("send a packet with a seq of %d\n", curSeq);
sendto(sockServer, buffer, BUFFER_LENGTH, 0,
(SOCKADDR*)&addrClient, sizeof(SOCKADDR));
++curSeq;
curSeq %= SEQ_SIZE;
++totalSeq;
Sleep(500);
}
//等待 Ack，若没有收到，则返回值为-1，计数器+1
recvSize =
recvfrom(sockServer, buffer, BUFFER_LENGTH, 0, ((SOCKADDR*)&addrClient), &length);
if (recvSize < 0){
waitCount++;
//20 次等待 ack 则超时重传
if (waitCount > 20)
{
timeoutHandler();
waitCount = 0;
}
}
else{
//收到 ack
ackHandler(buffer[0]);
waitCount = 0;
}
Sleep(500);
break;
}
}
}
sendto(sockServer, buffer, strlen(buffer) + 1, 0, (SOCKADDR*)&addrClient,
sizeof(SOCKADDR));
Sleep(500);
}
//关闭套接字，卸载库
closesocket(sockServer);
WSACleanup();
return 0;
}
void AsdkCommandReactor::lispWillStart(const char* firstLine)
{
curDocGlobals.lispRcd = bumpCount(firstLine, Adesk::kTrue);
curDocGlobals.lispStartTime = getCurTime();
}
void recordElapsedCmdTime(AsdkCommandRecord*& commandRecord, double startTime)
{
commandRecord->elapsedTime += elapsedTimeInSeconds(getCurTime(),
startTime);
}
