Ejemplo n.º 1
0
void StateManager::Internals::addedToEntity()
{
    StateManager* man = &mState;

    requestMessage("Get.Input",    [man](Kunlaboro::Message& msg){ msg.payload = man->mInput; msg.handled = true;    });
    requestMessage("Get.Settings", [man](Kunlaboro::Message& msg){ msg.payload = man->mSettings; msg.handled = true; });
    requestMessage("Get.Sounds",   [man](Kunlaboro::Message& msg){ msg.payload = man->mSound; msg.handled = true;    });
    requestMessage("Get.Font",     [man](Kunlaboro::Message& msg){ msg.payload = &man->mGlobalFont; msg.handled = true; });
    requestMessage("Get.GameView", [man](Kunlaboro::Message& msg){ msg.payload = man->mGameView; msg.handled = true; });
    requestMessage("Get.UiView",   [man](Kunlaboro::Message& msg){ msg.payload = man->mUiView; msg.handled = true;   });

    requestMessage("Now Playing",  [this](const Kunlaboro::Message& msg)
    {
        mCurrentSong = boost::any_cast<std::string>(msg.payload);
        mSongPopout = 0;
        mSongTimeout = 2;
    });
    requestMessage("LD26.Update",  [this](const Kunlaboro::Message& msg)
    {
        float dt = boost::any_cast<float>(msg.payload);

        if (mSongTimeout > 0)
            mSongTimeout = std::max(0.f, mSongTimeout - dt);

        if (!mCurrentSong.empty() && mSongTimeout > 0 && mSongPopout < 1)
            mSongPopout = std::min(1.f, mSongPopout + dt);
        else if (mSongTimeout == 0 && mSongPopout > 0)
            mSongPopout = std::max(0.f, mSongPopout - dt);
        else if (mSongTimeout == 0 && mSongPopout == 0 && !mCurrentSong.empty())
            mCurrentSong.clear();
    });
    changeRequestPriority("LD26.Update", -11);
    requestMessage("LD26.DrawUi",  [this](const Kunlaboro::Message& msg)
    {
        sf::RenderTarget& target = *boost::any_cast<sf::RenderTarget*>(msg.payload);

        sf::RectangleShape rect;
        rect.setSize(sf::Vector2f(512, 96));
        rect.setOrigin(rect.getSize()/2.f);
        rect.setFillColor(sf::Color::Black);
        rect.setOutlineColor(sf::Color::White);
        rect.setOutlineThickness(6.f);

        rect.setPosition(target.getSize().x + 262 - (512 * mSongPopout), target.getSize().y - 100);

        target.draw(rect);

        sf::Text playing("Now Playing:", mState.mGlobalFont);
        sf::FloatRect bounds = playing.getLocalBounds();
        playing.setPosition(rect.getPosition() - sf::Vector2f(350, 72) + sf::Vector2f(bounds.left + bounds.width/2, bounds.top + bounds.height/2));

        target.draw(playing);
        playing.setString(mCurrentSong);
        playing.move(0, bounds.height + 16);
        playing.setCharacterSize(20U);

        target.draw(playing);
    });
}
Ejemplo n.º 2
0
void IState::addedToEntity()
{
    requestMessage("LD26.Update", &IState::update);
    requestMessage("LD26.Draw",   &IState::draw);
    requestMessage("LD26.DrawUi", &IState::drawUi);

    changeRequestPriority("LD26.Update", -10);
    changeRequestPriority("LD26.Draw",   -10);
    changeRequestPriority("LD26.DrawUi", -10);

    setup();
}
Ejemplo n.º 3
0
void PostedItem::loadMessage(const uint32_t &token)
{
	std::vector<RsPostedPost> posts;
	std::vector<RsGxsComment> cmts;
	if (!rsPosted->getPostData(token, posts, cmts))
	{
		std::cerr << "GxsChannelPostItem::loadMessage() ERROR getting data";
		std::cerr << std::endl;
		return;
	}

	if (posts.size() == 1)
	{
		setPost(posts[0]);
	}
	else if (cmts.size() == 1)
	{
		RsGxsComment cmt = cmts[0];

		ui->newCommentLabel->show();
		ui->commLabel->show();
		ui->commLabel->setText(QString::fromUtf8(cmt.mComment.c_str()));

		//Change this item to be uploaded with thread element.
		setMessageId(cmt.mMeta.mThreadId);
		requestMessage();
	}
	else
	{
		std::cerr << "GxsChannelPostItem::loadMessage() Wrong number of Items. Remove It.";
		std::cerr << std::endl;
		removeItem();
		return;
	}
}
Ejemplo n.º 4
0
PostedItem::PostedItem(FeedHolder *feedHolder, uint32_t feedId, const RsGxsGroupId &groupId, const RsGxsMessageId &messageId, bool isHome, bool autoUpdate) :
    GxsFeedItem(feedHolder, feedId, groupId, messageId, isHome, rsPosted, autoUpdate)
{
	setup();

	requestGroup();
	requestMessage();
}
void ProtoBufWebSocketRequestMessageTest::testConstructor()
{
    std::string testVerb("hfhfhfh");
    std::string testPath("feuhehefhd");
    std::string testBody("body body body");
    google::protobuf::uint64 testId(3745646212);

    textsecure::WebSocketRequestMessage tsRequestMessage;
    tsRequestMessage.set_verb(testVerb);
    tsRequestMessage.set_path(testPath);
    tsRequestMessage.set_body(testBody);
    tsRequestMessage.set_id(testId);

    ProtoBufWebSocketRequestMessage requestMessage(tsRequestMessage);
    QVERIFY2(requestMessage.verb() == QString::fromStdString(testVerb), "Verb wasn't set.");
    QVERIFY2(requestMessage.path() == QString::fromStdString(testPath), "Path wasn't set.");
    QVERIFY2(requestMessage.body() == QString::fromStdString(testBody), "Body wasn't set.");
    QVERIFY2(requestMessage.requestId() == testId, "Test id wasn't set.");
}
Ejemplo n.º 6
0
void GxsFeedItem::fillDisplay(RsGxsUpdateBroadcastBase *updateBroadcastBase, bool complete)
{
	GxsGroupFeedItem::fillDisplay(updateBroadcastBase, complete);

	std::map<RsGxsGroupId, std::vector<RsGxsMessageId> > msgs;
	updateBroadcastBase->getAllMsgIds(msgs);

	if (!msgs.empty())
	{
		std::map<RsGxsGroupId, std::vector<RsGxsMessageId> >::const_iterator mit = msgs.find(groupId());
		if (mit != msgs.end())
		{
			const std::vector<RsGxsMessageId> &msgIds = mit->second;
			if (std::find(msgIds.begin(), msgIds.end(), messageId()) != msgIds.end()) {
				requestMessage();
			}
		}
	}
}
Ejemplo n.º 7
0
      CommandByte
      parse(uint8_t byte)
      {
        int8_t msg_size = 0;

        switch (m_state)
        {
          // Test for synchronization
          case FSM_STATE_NONE:
            m_togo = m_done = 0;
            msg_size = getCommandDataSize(byte);
            if (msg_size > 0)
            {
              m_togo = msg_size - 1;
              m_done = 1;
              m_data[0] = byte;   // Store ID.
              m_state = FSM_STATE_MESSAGE;
            }
            break;

            // Parse message body.
          case FSM_STATE_MESSAGE:
            m_data[m_done] = byte;
            ++m_done;
            --m_togo;
            break;

            // Should never get here.
          default:
            debug("%s: 0x%02x", DTR("unexpected byte"), byte);
            break;
        }

        // Exit if we don't have a complete message.
        if (m_togo != 0 || m_state != FSM_STATE_MESSAGE)
          return MSG_NULL;

        m_state = FSM_STATE_NONE;

        if (!validateCheckSum(m_data, m_done))
        {
          err("%s", DTR(Status::getString(Status::CODE_INVALID_CHECKSUM)));
          return MSG_NULL;
        }

        double tstamp = Clock::getSinceEpoch();

        // Interpret parsed data.
        int16_t angle = 0;

        switch (m_data[0])
        {
          case MSG_CONTMODE:
            return MSG_CONTMODE;

          case MSG_EEPROM:
            ByteCopy::fromBE(m_eeprom, m_data + 1);
            return MSG_EEPROM;

          case MSG_GS_EULER:
            m_euler.time = updateTimerCount(m_data + 7);
            ByteCopy::fromBE(angle, m_data + 1);
            m_euler.phi = Angles::radians((fp64_t)angle * c_euler_factor);
            ByteCopy::fromBE(angle, m_data + 3);
            m_euler.theta = Angles::radians((fp64_t)angle * c_euler_factor);
            ByteCopy::fromBE(angle, m_data + 5);
            m_euler.psi = Angles::radians((fp64_t)angle * c_euler_factor);
            m_euler.psi_magnetic = m_euler.psi;
            m_euler.setTimeStamp(tstamp);
            dispatch(m_euler, DF_KEEP_TIME);
            requestMessage(m_args.raw_ivecs ? MSG_RAW_IVECS : MSG_IVECS);
            return MSG_GS_EULER;

          case MSG_IVECS:
            // Acceleration.
            m_accel.time = updateTimerCount(m_data + 19);
            ByteCopy::fromBE(angle, m_data + 7);
            m_accel.x = (fp64_t)angle / m_accel_scale;
            ByteCopy::fromBE(angle, m_data + 9);
            m_accel.y = (fp64_t)angle / m_accel_scale;
            ByteCopy::fromBE(angle, m_data + 11);
            m_accel.z = (fp64_t)angle / m_accel_scale;
            m_accel.setTimeStamp(tstamp);

            // Angular velocity.
            ByteCopy::fromBE(angle, m_data + 13);
            m_agvel.x = (fp64_t)angle / m_gyro_scale;
            ByteCopy::fromBE(angle, m_data + 15);
            m_agvel.y = (fp64_t)angle / m_gyro_scale;
            ByteCopy::fromBE(angle, m_data + 17);
            m_agvel.z = (fp64_t)angle / m_gyro_scale;
            m_agvel.setTimeStamp(tstamp);

            dispatch(m_accel, DF_KEEP_TIME);
            dispatch(m_agvel, DF_KEEP_TIME);
            return MSG_IVECS;

          case MSG_RAW_IVECS:
            // Acceleration.
            m_accel.time = updateTimerCount(m_data + 19);
            ByteCopy::fromBE(angle, m_data + 7);
            m_accel.x = (fp64_t)angle / m_accel_scale;
            ByteCopy::fromBE(angle, m_data + 9);
            m_accel.y = (fp64_t)angle / m_accel_scale;
            ByteCopy::fromBE(angle, m_data + 11);
            m_accel.z = (fp64_t)angle / m_accel_scale;
            m_accel.setTimeStamp(tstamp);

            // Angular velocity.
            ByteCopy::fromBE(angle, m_data + 13);
            m_agvel.x = (fp64_t)angle / m_gyro_scale;
            ByteCopy::fromBE(angle, m_data + 15);
            m_agvel.y = (fp64_t)angle / m_gyro_scale;
            ByteCopy::fromBE(angle, m_data + 17);
            m_agvel.z = (fp64_t)angle / m_gyro_scale;
            m_agvel.setTimeStamp(tstamp);

            dispatch(m_accel, DF_KEEP_TIME);
            dispatch(m_agvel, DF_KEEP_TIME);
            return MSG_RAW_IVECS;
        }

        return MSG_NULL;
      }
Ejemplo n.º 8
0
void GxsFeedItem::updateItemStatic()
{
	std::cerr << "GxsFeedItem::updateItemStatic()";
	std::cerr << std::endl;
        requestMessage();
}
Ejemplo n.º 9
0
/*
Configures server and loops, processing connections 1 by 1 until quit_signal is received
*/
void* server_thread(void* p){
//Server config implementation
      //get info regarding server config details from Main method
      server_info* info = (server_info*)p;
      int PORT_NUMBER = info->port_num;
      // structs to represent the server and client
      struct sockaddr_in server_addr,client_addr;
      int sock; // socket descriptor
      // 1. socket: creates a socket descriptor that you later use to make other system calls
      if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
      perror("Socket");
      exit(1);
      }
      int temp;
      if (setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&temp,sizeof(int)) == -1) {
      perror("Setsockopt");
      exit(1);
      }
      // configure the server
      server_addr.sin_port = htons(PORT_NUMBER); // specify port number
      server_addr.sin_family = AF_INET;
      server_addr.sin_addr.s_addr = INADDR_ANY;
      bzero(&(server_addr.sin_zero),8);
      // 2. bind: use the socket and associate it with the port number
      if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) {
      perror("Unable to bind");
      exit(1);
      }
      // 3. listen: indicates that we want to listen to the port to which we bound; second arg is number of allowed connections
      if (listen(sock, 1) == -1) {
      perror("Listen");
      exit(1);
      }
      // once you get here, the server is set up and about to start listening
      printf("\nServer configured to listen on port %d\n", PORT_NUMBER);
      fflush(stdout);

//Request Processing
      //loops, waiting for requests until quit_signal is activated
      while (quit_signal == 0){
            // 4. accept: wait here until we get a connection on that port
            int sin_size = sizeof(struct sockaddr_in);
            int fd2 = accept(sock, (struct sockaddr *)&client_addr,(socklen_t *)&sin_size);
            printf("Server got a connection from (%s, %d)\n", inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));

            // buffer to read data into
            char request[1024];
            // 5. recv: read incoming request message into buffer
            int bytes_received = recv(fd2,request,1024,0);
            request[bytes_received] = '\0';
            printf("%s\n", request);
            //this is a request for the most recent temperature 
            switch (request[5]){
                  case 'a':
                        changeSign(fd2);
                        break;
                  case 'b':
                        mostRecentTemp(fd2);
                        break;
                  case 'd':
                        highLowAverage(fd2); 
                        break;
                  case 'm':
                        requestMessage(fd2);
                        break;
                  case 'r':
                        resetAlarm(fd2);
                        break;
                  case 's':
                        toggleStandby(fd2);
                        break;
                  case 't':
                        checkTripped(fd2);
                        printf("%s\n\n", "in t");
                        break;
            }  
            close(fd2);
      }
      // 7. close: close the socket connection
      close(sock);
      printf("Server closed connection\n");
      return 0;
}
Ejemplo n.º 10
0
Archivo: World.cpp Proyecto: ace13/LD28
void World::addedToEntity()
{
    {
        std::random_device dev;
        std::uniform_int_distribution<int> rand(0, 3);
        std::uniform_real_distribution<float> randAng(0, 360);

        sf::RenderTexture render;
        auto size = std::min(sf::Texture::getMaximumSize(), 1024U);
        render.create(size, size);

        sf::Sprite sprite(Resources::Texture_Ground);
        sprite.setTextureRect(mSheet.getRect(0, 0));
        sprite.setOrigin(sprite.getTextureRect().width / 2, sprite.getTextureRect().height / 2);
        sprite.setPosition(sprite.getTextureRect().width / 2, sprite.getTextureRect().height / 2);

        sprite.rotate(90);

        for (int x = 0; x <= size;)
        {
            for (int y = 0; y <= size;)
            {
                sprite.setTextureRect(mSheet.getRect(rand(dev)%2, rand(dev) % 2));
                sprite.setRotation(rand(dev) * 90);

                render.draw(sprite);

                if (randAng(dev) > 300)
                {
                    sprite.setTextureRect(mSheet.getRect(2 + rand(dev) % 2, rand(dev) % 2));
                    sprite.setRotation(randAng(dev));
                    render.draw(sprite);
                }

                sprite.move(0, sprite.getTextureRect().height);
                y += sprite.getTextureRect().height;
            }
            
            sprite.setPosition(sprite.getPosition().x, 0);
            sprite.move(sprite.getTextureRect().width, 0);
            x += sprite.getTextureRect().width;
        }

        render.display();
        mBigOne = render.getTexture();
    }

    requestMessage("Event.Update", [this](const Kunlaboro::Message& msg)
    {
        static float timer = 0;
        float dt = boost::any_cast<float>(msg.payload);

        timer += dt;

        if (timer > 1)
        {
            timer = 0;
            std::list<Enemy*> list;

            sendGlobalMessage("Would the real slim shady please stand up?", &list);

            if (list.size() < 15)
            {
                auto& sys = *getEntitySystem();
                auto ent = sys.createEntity();
                sys.addComponent(ent, "Game.Enemy");
                sys.addComponent(ent, "Game.Weapon");
            }
        }
    });

    requestMessage("Event.Draw", [this](const Kunlaboro::Message& msg)
    {
        auto& target = *std::get<0>(boost::any_cast<std::tuple<sf::RenderTarget*,float>>(msg.payload));

        sf::Vector2f vC = target.getView().getCenter(), vS = (sf::Vector2f)mBigOne.getSize(), vS2 = target.getView().getSize();
        //vC += vS/2.f;

        sf::Vector2i centerPos = sf::Vector2i(vC.x / vS.x, vC.y / vS.x);

        sf::Sprite sprite(mBigOne);
        sprite.setOrigin((sf::Vector2f)mBigOne.getSize() / 2.f);
        sprite.setPosition(centerPos.x * vS.x, centerPos.y * vS.y);

        int xRes = vS2.x / vS.x + 1;
        int yRes = vS2.y / vS.y + 1;

        for (int x = -xRes; x <= xRes; ++x)
        {
            for (int y = -yRes; y <= yRes; ++y)
            {
                sprite.setPosition((centerPos.x + x) * vS.x, (centerPos.y + y) * vS.y);
                target.draw(sprite);
            }
        }

    });
    changeRequestPriority("Event.Draw", -9001);

    requestMessage("I'm ending this!", [this](const Kunlaboro::Message& msg) { getEntitySystem()->destroyEntity(getOwnerId()); });
    requestMessage("Did I accidentally all the stats?", [this](Kunlaboro::Message& msg) { msg.handled = true; msg.payload = mStats; }); ///< No, no you didn't.

    requestMessage("I am bullet!", [this](const Kunlaboro::Message&) { mStats.ShotsFired++; });
    requestMessage("I am bullethole!", [this](const Kunlaboro::Message&) { mStats.ShotsHit++; });
    requestMessage("Is dead now", [this](const Kunlaboro::Message& msg) { if (boost::any_cast<bool>(msg.payload)) mStats.EnemiesDeadByPlayer++; else mStats.EnemiesDead++; });
    requestMessage("Demon Speeding", [this](const Kunlaboro::Message& msg) { float s = boost::any_cast<float>(msg.payload); mStats.MaxSpeed = std::max(mStats.MaxSpeed, s); });
    requestMessage("Road to Rouen", [this](const Kunlaboro::Message& msg) { float s = boost::any_cast<float>(msg.payload); mStats.DistanceTraveled += s; });
}