Jump to content
Site Stability Read more... ×
  • Advertisement
  • 10/04/17 04:00 PM

    Dr. Steamlove or: How I Learned To Stop Worrying And Love The Review Bomb

    GameDev Unboxed

    Jesse "Chime" Collins

    Bombs away! Take shelter!

    The biggest allies that a game developer can have is their community. The gamers themselves are what makes a successful game. A game can be great, well made, and incredibly deep, but if no one buys it, you can assume it’ll go under the radar and has the potential to fall into obscurity. In contrast, the biggest enemies that a game developer can have is also their community. This can be seen in the most heart-wrenching sense this past month.

    Let’s start early in September to explain what’s all gone on so far. Felix Kjellberg, known by millions of people by his YouTube alias PewDiePie, got himself dunked in hot water again for things he’s said. This is an internet sensation, with one of the highest subscribed channels in YouTube history at over 52 million followers. His fanbase is of all ages, but the demographic does get pretty young. To call him an “influencer” is an understatement.

    And yet, this isn’t the first time he’s gotten himself put in the news in the past year for pretty insidious things he’s said or done. His previous escapades landed him in the hot seat by both YouTube and Disney, where he lost both of his largest partnerships. That’s a heck of a way to have consequences to your actions.

    PewDiePie's Terrible, Horrible, No Good, Very Bad Day

    But, this time, he was live streaming a round of PlayerUnknown’s Battlegrounds stream (PUBG for short). As someone that curses like a sailor, myself, I can’t really judge him on the vulgar content that was surrounding the offending word. Unfortunately, in a “heat of the moment” call-out, he used a racial slur, the “N-word” more specifically, against a player he was shooting at, without remorse. Now, I’m not here to complain about his crude humor or be offended. I’m here to discuss the implications and consequences that have come due to his (now) third strike in under a year.

    Let’s cut to a few days later. Sean Vanaman, co-founder of Campo Santo, the developing studio of Firewatch, decided that they no longer wanted to be affiliated with PewDiePie. That’s fair. He has made multiple Nazi references in the past and is now live streaming himself yelling racial slurs. It’s a fair assessment and want to distance yourself. Therefore, they issued what is called a DMCA (Digital Millennium Copyright Act) Takedown of any Firewatch-related videos that PewDiePie has made, which has YouTube personally remove videos under the order.

    Let’s explain what a DMCA entails. Back in 1998, the DMCA law was put into effect to protect intellectual property and copyright thereof. This law was created to help deter theft or copying of images, writing, video, or any created materials. If someone duplicates a piece of art, the original creator has the right to a DMCA Takedown, which is enacted by the original owner and contacts the incriminated party either by governing or contingence body. In the case of video games, a game developer can send a DMCA Takedown to a Let’s Player or game reviewer, if they so choose.

    Camp Santo Taking Charge Of the Indie Dev Community

    In the case of Campo Santo, furthermore, they contacted YouTube directly. They requested the Takedown of any videos that PewDiePie may have done involving their game, Firewatch. The developer won the fight and the DMCA Takedown took effect, which is a success in the name of indie developers having power over offending content. PewDiePie even apologized, albeit after the fact.

    Now, why is this bad? The developer won. The guy using racial slurs didn’t. Little guy won over the big, bad guy. We all live happily ever after. It’s a classic story trope. We move on, now, right? Wrong. Very, very wrong. Unfortunately, there are consequences. This move has caused two major tremors in two different directions: Influencers and Indie Developers.

    On one hand, this act has now set precedent for indie developers to abuse the system, if they so choose. The main argument is that indie developers that don’t like a poor review score can now issue a DMCA to remove things they dislike.

    DMCA Leads To Anger. Anger Leads To Hate. Hate Leads To...

    So what? The influencer takes it down and they move on? Unfortunately, under YouTube policy, if a video creator gets three DMCA Takedowns, they are banned from YouTube. It does not matter if PewDiePie has over 50 million subscribers and made over $15 million in 2016. If he gets two more strikes, his channel will be completely gone and his bread and butter will be (sorry for this) toast.

    He’s just one example. Imagine an up and coming influencer gets into video creation and streaming, only to have three strikes. If they do three reviews and give three poor scores because a game may be bad, there’s a chance they might as well just need to pack it up. This will cause a rift on what game people will review, but it will also fundamentally change the way that reviewers look at their subjects. Developers now have the power to only have positive reviews of their games be seen by millions of people.

    Not only that, but many YouTubers do fun, funny, and idiotic videos to parody games or IPs. Where it is perfectly legal to parody something, Nintendo, for instance, is known to be very protective of their work and have been known to issue DMCA Takedowns for parodies or likenesses to their work on YouTube in the past.

    As The Bombs Drop...

    In a very strange twist, a large amount of gamers and/or PewDiePie fans went for the jugular. In an event known as “review bombing”, the community bans together in what can only be described as a “negative carpet bomb or reviews”. In this case, they took to the FireWatch Steam page, which had originally held a “Mostly Positive” score in their rating system. These community members, proceeded to down-vote the game and leave negative and sometimes nasty remarks. They left it vague in some cases, but the majority rule was that the developer had upset them, so they needed to make sure the game suffered.

    Let Off Some Steam

    Steam, generally ones to stay out of any and all drama and commotion, spoke up for once. The issue, this time, seemed to line up perfectly with something they had already been doting on: a way to solve for review bombing. They posted a blog to their website which detailed their solvent for this unfortunately common problem.

    “So why is review bombing a problem?” the blog reads. “On the one hand, the players doing the bombing are fulfilling the goal of User Reviews - they're voicing their opinion as to why other people shouldn't buy the game. But one thing we've noticed is that the issue players are concerned about can often be outside the game itself. It might be that they're unhappy with something the developer has said online, or about choices the developer has made in the Steam version of their game relative to other platforms, or simply that they don't like the developer's political convictions. Many of these out-of-game issues aren't very relevant when it comes to the value of the game itself, but some of them are real reasons why a player may be unhappy with their purchase.”

    Steam to the Rescue?

    Noticeably, they seemed very hesitant to get too involved actively, but in the long run, their solution made sense. After solitarily discussing what options they really have or don’t have, they went on to their vision for a better future. “In the end,” they continued, “we decided not to change the ways that players can review games, and instead focused on how potential purchasers can explore the review data. Starting today, each game page now contains a histogram of the positive to negative ratio of reviews over the entire lifetime of the game, and by clicking on any part of the histogram you're able to read a sample of the reviews from that time period. As a potential purchaser, it's easy to spot temporary distortions in the reviews, to investigate why that distortion occurred, and decide for yourself whether it's something you care about. This approach has the advantage of never preventing anyone from submitting a review, but does require slightly more effort on the part of potential purchasers.”

    Firewatch is a slightly older game, which they can value had higher marks among the excited fans that bought early after its release and ever slowly declined after nearly a year and a half but remain in the “Very Positive” realm ever since. The problem with the review bombs are that they rise to the forefront and become the “Recent” reviews, which currently sits at a “Mixed” rating due to the trouble. Valve’s fix would ensure that people see reviews as a timeline of sorts, giving a historical look at the reviews. The decline is shown, but people can click to see the differences between the higher remarks and the bombing run.

    This entire situation has been a cavalcade roller coaster and I fear it’s only the beginning. The real core of the situation is gamer toxicity, but that’s a problem for another day. Only time will tell how this will end, though.


      Report Column Entry

    User Feedback

    There are no comments to display.

    Create an account or sign in to comment

    You need to be a member in order to leave a comment

    Create an account

    Sign up for a new account in our community. It's easy!

    Register a new account

    Sign in

    Already have an account? Sign in here.

    Sign In Now

  • Advertisement
  • Similar Content

    • By vivek soni
      Hi guys,
      i am trying to implement a simple font renderer using bitmap font texture with a dynamic vertex buffer, i am  able to successfully display text with correct glyph from bitmap texture.
      right now i am trying to draw a dynamic string that changes at user input, i.e user able change the displayded text by typing the new one.
      The issue is that  length of string is exactly same as what it was initialized with even when updating string at every render frame. string gets updated every fram but is capped at length equal to what is was initialized with.
      i am suspecting that vertexBufferDesc.ByteWidth is not getting updated even when i update vertexbuffer by map and unmap it.
      bool GlyphClass::Initialize(ID3D11Device* device, HWND hwnd, int screenWidth, int screenHeight, WCHAR* path) { bool result; m_GlyphWidthData.open("Font/AgencyFBFont_64x64_width.txt"); while (1) { if (m_GlyphWidthData.eof()) { break; } int tmp = 0; m_GlyphWidthData >> tmp; if (tmp != 0) { m_GlyphWidth.push_back(tmp); } } m_GlyphWidthData.close(); m_GlyphCharacter = 'A'; m_StringToDraw = "TEXTTEST@xyz";//userInputString != "" ? userInputString : "VIVEK599 xyz"; m_fontTextureShader = new TextureShaderClass; if (!m_fontTextureShader) { return false; } result = m_fontTextureShader->Initialize(device, hwnd); if (!result) { MessageBox(hwnd, L"Could not initialize font texture shader object!", L"Error", MB_OK); return false; } m_ScreenWidth = screenWidth; m_ScreenHeight = screenHeight; result = InitializeBuffers(device); if (!result) { return false; } result = LoadTexture(device, path); if (!result) { return false; } return true; } updatebuffer
      bool GlyphClass::UpdateBuffers(ID3D11DeviceContext* context, int posX, int posY) { m_StringToDraw = userInputString != "" ? userInputString : "STRING 555@xyz0123456789"; VertexType* vertices; D3D11_MAPPED_SUBRESOURCE mappedResource; VertexType* vertexPtr; HRESULT hr; vertices = new VertexType[m_VertexCount * m_StringToDraw.length()]; if (!vertices) { return false; } // Initialize vertex array to zeros at first. memset(vertices, 0, sizeof(VertexType) * m_VertexCount * m_StringToDraw.length() ); float posXOffset = (float)posX; float posYOffset = (float)posY; for ( int i = 0; i < m_StringToDraw.length(); i++ ) { int cx = m_StringToDraw[i] % 16; int cy = m_StringToDraw[i] / 16; float tex_left = (float)cx * (1.f / 16.f); float tex_top = (float)cy * (1.f / 16.f); float tex_right = tex_left + (1.f / 16.f) * ((float)m_GlyphWidth[m_StringToDraw[i]] / 64.f); float tex_bottom = tex_top + (1.f / 16.f); int totalCharWidth = 64; float left = (float)((float)(m_ScreenWidth / 2.f) * -1) + posXOffset; float right = left + (float)m_GlyphWidth[m_StringToDraw[i]]; float top = (float)(m_ScreenHeight / 2.f) - posYOffset; float bottom = top - (float)totalCharWidth; //triangle 1 - clockwise vertices[0 + m_VertexCount * i].position = Vector3(left, top, 0.f); vertices[0 + m_VertexCount * i].texture = Vector2(tex_left, tex_top); vertices[1 + m_VertexCount * i].position = Vector3(right, bottom, 0.f); vertices[1 + m_VertexCount * i].texture = Vector2(tex_right, tex_bottom); vertices[2 + m_VertexCount * i].position = Vector3(left, bottom, 0.f); vertices[2 + m_VertexCount * i].texture = Vector2(tex_left, tex_bottom); //triangle + i 2 vertices[3 + m_VertexCount * i].position = Vector3(left, top, 0.f); vertices[3 + m_VertexCount * i].texture = Vector2(tex_left, tex_top); vertices[4 + m_VertexCount * i].position = Vector3(right, top, 0.f); vertices[4 + m_VertexCount * i].texture = Vector2(tex_right, tex_top); vertices[5 + m_VertexCount * i].position = Vector3(right, bottom, 0.f); vertices[5 + m_VertexCount * i].texture = Vector2(tex_right, tex_bottom); posXOffset += m_GlyphWidth[m_StringToDraw[i]]; } hr = context->Map(m_VertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(hr)) { return false; } vertexPtr = (VertexType*)mappedResource.pData; int bufferSize = sizeof(VertexType) * m_VertexCount * m_StringToDraw.length(); memcpy(vertexPtr, (void*)vertices, bufferSize); D3D11_BUFFER_DESC tmpDesc; m_VertexBuffer->GetDesc(&tmpDesc); context->Unmap(m_VertexBuffer, 0); delete[] vertices; vertices = 0; return true; }  
    • By RoKabium Games
      On Lelantos you can use Portals to quickly go from one side of the map to the other. Each Portal has a number that once discovered will show up on the mini-map to help you keep track of where you are. Just be careful when using these teleportation devices, you never know what waits on the other side of the gate!
    • By RoKabium Games
      Aura enemies – ”Heeble” is a spider-like creature that is closely related to the Creeble, Greeble and Beeble and it can crawl across any type of block. The ice-webs this one spins causes a lingering damage so stay clear and burn those webs from afar.
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!