void acceptmove(void) { int ta; int ma; char af; int moved = 0; int vma, dir; char prompt[60]; char buf[60], last = '\0'; char *p; if (!mc->crew3 || snagged(ms) || !windspeed) { Signal("Unable to move", NULL); return; } ta = maxturns(ms, &af); ma = maxmove(ms, mf->dir, 0); sprintf(prompt, "move (%d,%c%d): ", ma, af ? '\'' : ' ', ta); sgetstr(prompt, buf, sizeof buf); dir = mf->dir; vma = ma; for (p = buf; *p; p++) switch (*p) { case 'l': dir -= 2; case 'r': if (++dir == 0) dir = 8; else if (dir == 9) dir = 1; if (last == 't') { Signal("Ship can't turn that fast.", NULL); *p-- = '\0'; } last = 't'; ma--; ta--; vma = min(ma, maxmove(ms, dir, 0)); if ((ta < 0 && moved) || (vma < 0 && moved)) *p-- = '\0'; break; case 'b': ma--; vma--; last = 'b'; if ((ta < 0 && moved) || (vma < 0 && moved)) *p-- = '\0'; break; case '0': case 'd': *p-- = '\0'; break; case '\n': *p-- = '\0'; break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': if (last == '0') { Signal("Can't move that fast.", NULL); *p-- = '\0'; } last = '0'; moved = 1; ma -= *p - '0'; vma -= *p - '0'; if ((ta < 0 && moved) || (vma < 0 && moved)) *p-- = '\0'; break; default: if (!isspace(*p)) { Signal("Input error.", NULL); *p-- = '\0'; } } if ((ta < 0 && moved) || (vma < 0 && moved) || (af && turnfirst(buf) && moved)) { Signal("Movement error.", NULL); if (ta < 0 && moved) { if (mf->FS == 1) { Write(W_FS, ms, 0, 0, 0, 0); Signal("No hands to set full sails.", NULL); } } else if (ma >= 0) buf[1] = '\0'; } if (af && !moved) { if (mf->FS == 1) { Write(W_FS, ms, 0, 0, 0, 0); Signal("No hands to set full sails.", NULL); } } if (*buf) strcpy(movebuf, buf); else strcpy(movebuf, "d"); Writestr(W_MOVE, ms, movebuf); Signal("Helm: %s.", NULL, movebuf); }
int SocketConnection::Fill() { if(destFormat.Format == TypeRepresentation::ASCIIFORMAT) { std::string xmlString = ""; char tmp[1001]; //leave 1 for null termination// int amountRead = 0; do { #if defined(_WIN32) int amountRead = recv(descriptor, (char FAR *)tmp, 1000, 0); if(amountRead == SOCKET_ERROR) { LogWindowsSocketError("SocketConnection", "Fill"); if(WSAGetLastError() == WSAEWOULDBLOCK) return -1; } #else amountRead = recv(descriptor, (void *)tmp, 1000, 0); #endif if(amountRead > 0) { zeroesRead = 0; tmp[amountRead] = 0; xmlString += tmp; } ++zeroesRead; // If we have had a certain number of zero length reads in a row, // assume the connection died. if(zeroesRead > 100) { EXCEPTION0(LostConnectionException); } }while(amountRead == 1000); //if it gets entire list.. if(xmlString.size() > 0) { JSONNode node; node.Parse(xmlString); //std::cout << node.ToString() << std::endl; int guido = node["id"].GetInt(); JSONNode contents = node["contents"]; // JSONNode metadata = node["typeinfo"]; /// With the information I have I could probably /// just use JSONNode to convert completely.. /// but that would leave MapNode incomplete.. MapNode mapnode(contents,false); //std::cout << mapnode.ToXML(false) << std::endl; //std::cout << metadata["data"] << std::endl; buffer.clear(); return Write(guido,&mapnode); //,&metadata["data"] } return 0; } unsigned char tmp[1000]; #if defined(_WIN32) int amountRead = recv(descriptor, (char FAR *)tmp, 1000, 0); if(amountRead == SOCKET_ERROR) { LogWindowsSocketError("SocketConnection", "Fill"); if(WSAGetLastError() == WSAEWOULDBLOCK) return -1; } #else int amountRead = recv(descriptor, (void *)tmp, 1000, 0); #endif if(amountRead > 0) { zeroesRead = 0; // Add the new bytes to the buffer. for(int i = 0; i < amountRead; ++i) buffer.push_back(tmp[i]); } else ++zeroesRead; // If we have had a certain number of zero length reads in a row, // assume the connection died. if(zeroesRead > 100) { EXCEPTION0(LostConnectionException); } return amountRead; }
void File::WriteByte (const char byte) { std::vector<char> buffer; buffer.push_back(byte); CHECK(1 == Write(buffer), "Failed to write byte"); }
static void DevOperate( NetDCB * dcb, NetDevReq * req ) { NetInfoReq * ireq = (NetInfoReq *)req; NetInfo * info = &ireq->NetInfo; switch (req->DevReq.Request) { case FG_Read: /* Queue read requests for Reader process. The server */ /* currently sends us several of these when it starts. */ /* Note that we must lock the DCB against concurrent */ /* access. */ Wait( &dcb->lock ); AddTail( &dcb->readq, &req->DevReq.Node ); Signal( &dcb->nreq ); Signal( &dcb->lock ); return; case FG_Write: #ifdef DEBUG { int i; char * buf = (char *)req->Buf; IOdebug( "TX %d buf = %x [%", req->Size, buf ); for (i = 0;i < 24; i++) IOdebug( "%x %", buf[ i ] ); IOdebug( "]" ); } #endif /* Write data to /ether server inline */ req->Actual = Write( dcb->write, (char *) req->Buf, req->Size, -1 ); req->DevReq.Result = Result2( dcb->write ); break; case FG_SetInfo: #ifdef DEBUG IOdebug( "Net SetInfo %x %x %x [%", info->Mask, info->Mode, info->State ); { int i; for (i = 0; i < 5; i++ ) IOdebug( "%d.%", info->Addr[ i ] ); IOdebug( "%d]", info->Addr[ 5 ] ); } #endif /* Set options/address in ethernet device */ /* The tcpip server will attempt to set the ethernet */ /* address on startup. */ /* SetInfo does nothing in this driver. */ /* req->DevReq.Result = SetInfo(dcb->write,info,sizeof(NetInfo)); */ req->DevReq.Result = 0; break; case FG_GetInfo: /* Get options/address from /ether device. Only the */ /* ethernet address is used by tcpip server. */ info->Mask = 7; req->DevReq.Result = GetInfo( dcb->read, (byte *)info ); #ifdef DEBUG { int i; IOdebug( "Addr [%" ); for (i = 0; i < 6; i++ ) IOdebug( "%d %", info->Addr[ i ] ); IOdebug( "]" ); } #endif break; } #if 0 /* Unlock the DCB before returning request to server */ Signal( &dcb->lock ); #endif /* return request to server by calling the Action routine in */ /* the request. Note that the tcpip server will re-call */ /* DevOperate before returning from this routine when the */ /* request was a Read. */ (*req->DevReq.Action)( dcb, req ); return; } /* DevOperate */
bool FileStore::Write(const char* b) { return Write(b, strlen(b)); }
bool FileStore::Write(char b) { return Write(&b, sizeof(char)); }
void File::WriteHuge(const void* lpBuffer, unsigned long dwCount) { Write(lpBuffer, (UINT)dwCount); }
std::string dump(Mesh* mesh, int step, std::string fileName) const { auto _mesh = dynamic_cast<MeshType*>(mesh); assert_true(_mesh); LOG_DEBUG("Writing snapshot for mesh \"" << _mesh->getId() << "\" at step " << step << " to file " << fileName); auto grid = vtkSmartPointer<GridType>::New(); auto points = vtkSmartPointer<vtkPoints>::New(); auto contact = vtkSmartPointer<vtkIntArray>::New(); contact->SetName("contact"); auto border = vtkSmartPointer<vtkIntArray>::New(); border->SetName("border"); auto used = vtkSmartPointer<vtkIntArray>::New(); used->SetName("used"); auto norm = vtkSmartPointer<vtkDoubleArray>::New(); norm->SetName("norm"); norm->SetNumberOfComponents(3); auto vel = vtkSmartPointer<vtkDoubleArray>::New(); vel->SetName("velocity"); vel->SetNumberOfComponents(3); auto crack = vtkSmartPointer<vtkDoubleArray>::New(); crack->SetName("crack"); crack->SetNumberOfComponents(3); auto sxx = vtkSmartPointer<vtkDoubleArray>::New(); sxx->SetName("sxx"); auto sxy = vtkSmartPointer<vtkDoubleArray>::New(); sxy->SetName("sxy"); auto sxz = vtkSmartPointer<vtkDoubleArray>::New(); sxz->SetName("sxz"); auto syy = vtkSmartPointer<vtkDoubleArray>::New(); syy->SetName("syy"); auto syz = vtkSmartPointer<vtkDoubleArray>::New(); syz->SetName("syz"); auto szz = vtkSmartPointer<vtkDoubleArray>::New(); szz->SetName("szz"); auto compression = vtkSmartPointer<vtkDoubleArray>::New(); compression->SetName("compression"); auto tension = vtkSmartPointer<vtkDoubleArray>::New(); tension->SetName("tension"); auto shear = vtkSmartPointer<vtkDoubleArray>::New(); shear->SetName("shear"); auto deviator = vtkSmartPointer<vtkDoubleArray>::New(); deviator->SetName("deviator"); auto matId = vtkSmartPointer<vtkIntArray>::New(); matId->SetName("materialID"); auto rho = vtkSmartPointer<vtkDoubleArray>::New(); rho->SetName("rho"); auto mpiState = vtkSmartPointer<vtkIntArray>::New(); mpiState->SetName("mpiState"); auto nodePublicFlags = vtkSmartPointer<vtkIntArray>::New (); nodePublicFlags->SetName ("publicFlags"); auto nodePrivateFlags = vtkSmartPointer<vtkIntArray>::New (); nodePrivateFlags->SetName ("privateFlags"); auto nodeErrorFlags = vtkSmartPointer<vtkIntArray>::New (); nodeErrorFlags->SetName ("errorFlags"); auto nodeNumber = vtkSmartPointer<vtkIntArray>::New (); nodeNumber->SetName ("nodeNumber"); auto nodeBorderConditionId = vtkSmartPointer<vtkIntArray>::New (); nodeBorderConditionId->SetName ("borderConditionId"); auto nodeContactConditionId = vtkSmartPointer<vtkIntArray>::New(); nodeContactConditionId->SetName("contactState"); auto contactDestroyed = vtkSmartPointer<vtkIntArray>::New(); contactDestroyed->SetName("failedContacts"); auto nodeDestroyed = vtkSmartPointer<vtkIntArray>::New(); nodeDestroyed->SetName("failedNodes"); auto nodeFailureMeasure = vtkSmartPointer<vtkDoubleArray>::New(); nodeFailureMeasure->SetName("failureMeasure"); float _norm[3]; dumpMeshSpecificData(_mesh, grid, points); for (auto it = MeshNodeIterator<MeshType, snapshotterId>(_mesh); it.hasNext(); it++) { auto& node = *it; border->InsertNextValue(node.isBorder() ? 1 : 0); used->InsertNextValue(node.isUsed() ? 1 : 0); contact->InsertNextValue(node.isInContact() ? 1 : 0); if (node.isUsed() && node.isBorder()) _mesh->findBorderNodeNormal(node, _norm, _norm+1, _norm+2, false); else _norm[0] = _norm[1] = _norm[2] = 0.0; norm->InsertNextTuple(_norm); vel->InsertNextTuple(node.velocity); crack->InsertNextTuple(node.getCrackDirection().coords); sxx->InsertNextValue(node.sxx); sxy->InsertNextValue(node.sxy); sxz->InsertNextValue(node.sxz); syy->InsertNextValue(node.syy); syz->InsertNextValue(node.syz); szz->InsertNextValue(node.szz); compression->InsertNextValue(node.getCompression()); tension->InsertNextValue(node.getTension()); shear->InsertNextValue(node.getShear()); deviator->InsertNextValue(node.getDeviator()); matId->InsertNextValue(node.getMaterialId()); rho->InsertNextValue(node.getRho()); mpiState->InsertNextValue(node.isRemote() ? 1 : 0); nodePrivateFlags->InsertNextValue (node.getPrivateFlags()); nodePublicFlags->InsertNextValue (node.getPublicFlags()); nodeErrorFlags->InsertNextValue (node.getErrorFlags()); nodeBorderConditionId->InsertNextValue (node.getBorderConditionId()); nodeContactConditionId->InsertNextValue(node.getContactConditionId()); nodeNumber->InsertNextValue(node.number); contactDestroyed->InsertNextValue(node.isContactDestroyed() ? 1 : 0); nodeDestroyed->InsertNextValue(node.isDestroyed() ? 1 : 0); nodeFailureMeasure->InsertNextValue(node.getDamageMeasure()); } vtkFieldData* fd; if (useCells) fd = grid->GetCellData(); else fd = grid->GetPointData(); grid->SetPoints(points); fd->AddArray(contact); fd->AddArray(border); fd->AddArray(used); fd->AddArray(norm); fd->AddArray(crack); fd->AddArray(sxx); fd->AddArray(sxy); fd->AddArray(sxz); fd->AddArray(syy); fd->AddArray(syz); fd->AddArray(szz); fd->AddArray(compression); fd->AddArray(tension); fd->AddArray(shear); fd->AddArray(deviator); fd->AddArray(matId); fd->AddArray(rho); fd->AddArray(mpiState); fd->AddArray (nodePrivateFlags); fd->AddArray (nodePublicFlags); fd->AddArray (nodeErrorFlags); fd->AddArray (nodeBorderConditionId); fd->AddArray (nodeContactConditionId); fd->AddArray(vel); fd->AddArray(nodeNumber); fd->AddArray(contactDestroyed); fd->AddArray(nodeDestroyed); fd->AddArray(nodeFailureMeasure); // Write file auto writer = vtkSmartPointer<GridWriterType>::New(); writer->SetFileName(fileName.c_str()); #ifdef CONFIG_VTK_5 writer->SetInput(grid); #else writer->SetInputData(grid); #endif writer->Write(); return fileName; }
void CCharacterCore::Quantize() { CNetObj_CharacterCore Core; Write(&Core); Read(&Core); }