Ejemplo n.º 1
0
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;
}
Ejemplo n.º 3
0
void File::WriteByte (const char byte)
{
	std::vector<char> buffer;
	buffer.push_back(byte);
	CHECK(1 == Write(buffer), "Failed to write byte");
}
Ejemplo n.º 4
0
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 */
Ejemplo n.º 5
0
bool FileStore::Write(const char* b)
{
	return Write(b, strlen(b));
}
Ejemplo n.º 6
0
bool FileStore::Write(char b)
{
	return Write(&b, sizeof(char));
}
Ejemplo n.º 7
0
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;
        }
Ejemplo n.º 9
0
void CCharacterCore::Quantize()
{
	CNetObj_CharacterCore Core;
	Write(&Core);
	Read(&Core);
}