Dan Jones

Emergency Batarang Case!

Let's say you have a photographic image that really should be a JPG or WebP, for the best file size and quality. But what if I need transparency too? Don't I need PNG for that? Won't that make for either huge file sizes (PNG-24) or weird quality (PNG-8)? Let's look at another way that ends up best-of-both-worlds.

The goal is to clip myself out of the image, removing the background. My technique for that is usually to use Photoshop and cut a clipping path manually with the Pen tool.

Now I can select the inverse of that clipping path to easily remove the background.

Attempting to save this as a 1200px wide image as PNG-24 out of Photoshop ends up as about a 1MB image!

We could cut that by 75% using PNG-8, but then we 1) get that weird Giffy look (less photographic) and 2) have to pick a matte color for the edges because we aren't getting nice alpha transparency here, just binary transparency.

Gosh what if we could just use JPG? The quality and file size is way better.

No transparency though.

But wait! Can't we just clip this thing out? We have clip-path now. Well... yeah. We do have clip-path. It can't take a path(), though, and what we've created for vector points in Photoshop is path data. It could take a polygon() though, if we made all the lines straight. That's probably not ideal (I'm curvy!). Or we could make a <clipPath> element in some inline SVG and use clip-path: url(#id_of_clipPath);, which does support a <path> inside.

There is masking as well, which is another possibility.

Let's look at a third possibility though: put everything into <svg>. That made some logical sense to me, so all this stays together and scales together.

The trick is to make two things:

1. The JPG
2. The clipping <path>

The JPG is easy enough. Output that right from Photoshop. Optimize.

Now we can set up the SVG. SVG is happy to take a raster graphic. SVG is known for vector graphics, but it's a very flexible image format.

<svg>
  <image xlink:href="/images/chris.jpg" x="0" y="0">
<svg>

To get the path, we export the path we created with the Pen tool over to Illustrator.

Now we have the path over there, and it's easy to export as SVG:

Now we have the path data we need:

Let's use that <path> within a <clipPath> in the SVG we've started. Then also apply that clip path to the <image>:

<svg viewBox="0 0 921.17 1409.71">
  <defs>
    <clipPath id="chris-clip">
      <path d=" ... " />
    </clipPath>
  </defs>
  <image xlink:href="/images/chris.jpg" clip-path="url(#chris-clip)" x="0" y="0" width="921" height="1409">
<svg>

Tada!

A transparent JPG, essentially.

Transparent JPG (With SVG) is a post from CSS-Tricks

If you have ever developed HTML5 games before, you might be familiar with a few game engines that can make game development a lot easier. They have all the code you need to detect collisions, spawn different entities, or add sound effects to your game. In this tutorial, you will learn about another such game engine called Crafty. It is very easy to use and supports all major browsers, including IE9. 

Once minified, the library is only 127kb in size, so it won't result in any major delay in loading your game. It supports sprite maps, so you can easily draw game entities on the screen. You can also create custom events that can be triggered whenever you want and on whatever object you want. 

There are also components for sounds, animation, and other effects. Overall, this game engine is a great choice if you want to develop some basic HTML5 games.

Initial Setup

The first thing that you need to do is include Crafty in your project. You can either download the file and load it in your projects or you can directly link to the minified version hosted on a CDN. Once the library has been loaded, you can use the following line to initialize Crafty:

Crafty.init([Number width, Number height, stage_elem]);

The first two arguments determine the width and height of our stage. The third argument is used to specify the element that we are going to use as our stage. If the third argument is not provided, Crafty will use a div with id cr-stage as its stage. Similarly, if the width and height arguments are missing, Crafty will set the width and height of our stage equal to the window width and height.

At this point, you should have the following code:

<html>
  <head></head>
  <body>
    <div id="crafty-game"></div>
    <script type="text/javascript" src="path/to/crafty.min.js"></script>
    <script>
      Crafty.init(600,400, document.getElementById('crafty-game'));
    </script>
  </body>
</html>

Creating Entities

Entities are building blocks of a Crafty game. Everything from the player to the enemies and obstacles is represented using entities. You can pass a list of components to an entity. Each of these components will add extra functionality to our entity by assigning properties and methods from that component to the entity. You can also chain other methods to an entity to set various properties like its width, height, location, and color. Here is a very basic example of adding components to an entity:

Crafty.e('2D, Canvas, Color');

Every entity that you want to display to the user will need both the 2D component and a rendering layer. The rendering layer can be DOM, Canvas, or WebGL. Please note that WebGL support was added in version 0.7.1. Currently, only the Sprite, Image, SpriteAnimation, and Color components support WebGL rendering. Text entities still need to use DOM or Canvas for now.

Now, you can use the attr() method to set the value of various properties including the width, height, and position of your entity. Most methods in Crafty will return the entity they are called on, and attr() is no exception. This means that you will be able to chain more methods to set other properties of your elements. Here is an example:

Crafty.e("2D, Canvas, Color")
      .attr({x:200, y:100, w:200, h:50})
      .color("orange");

This will create an orange rectangular entity on the stage.

Moving Entities Around

Now that you have created the entity, let's write some code to move it around using the keyboard. You can move an entity in four different directions, i.e. up, down, left, and right, by adding the Fourway component to it. 

The entity can then be moved by either using the arrow keys or W, A, S, and D. You can pass a number as an argument to the fourway constructor to set the speed of the entity. Here is what the code of the entity should look like now:

Crafty.e("2D, Canvas, Color, Fourway")
      .attr({x:200, y:100, w:200, h:50})
      .color("orange")
      .fourway(300);

You can restrict the movement of an entity to just two directions using the Twoway component. Replacing the Fourway component in the code above with Twoway will confine the movement of the box to just the horizontal direction. This is evident from the following demo:

You can also add your own components to different entities for identification or to group similar entities together. In this case, I am adding the Floor component to our orange box. You can use some other descriptive names to help you identify different entities.

Crafty.e("2D, Canvas, Color, Twoway, Floor")
  .attr({ x: 200, y: 340, w: 200, h: 50 })
  .color("orange")
  .twoway(300);

There is another very useful component that you can use to move elements around, and it is called the Gravity component. When added to an entity, it will make that entity fall down. You might want to stop the given entity from falling further, once it encounters some other entities. This can be achieved by passing an identifier component as an argument to the gravity function. Here is the code that makes the small black square fall on the floor or platform:

Crafty.e("2D, Canvas, Color, Gravity")
  .attr({ x: 200, y: 50, w: 50, h: 50 })
  .color("black")
  .gravity("Floor");

Final Thoughts

As you see in the tutorial, we were able to create the basic structure of a simple game using very little code. All we had to do was add components to our entities and specify the values of different properties like width, height, or movement speed.

This tutorial was meant give you a basic idea of entities and other concepts related to Crafty. In the next part, you will learn about entities in much more detail. If you have any questions about this tutorial, let me know in the comments.

While Google Home and the Amazon Echo are well-equipped with features already, the companies behind these smart speakers may soon add another major feature.

The Wall Street Journal offers a brief report suggesting that both Google and Amazon are working out ways to make the Home and Echo support phone call functionality. However, there are issues holding up both companies, including privacy, access to emergency service, and telecom regulations.

The report also adds that both companies are aware of the “inherent awkwardness” of having phone conversations on a speaker, which makes one wonder why they’d be going down that route at all if that’s the case.

Amazon is also working with a few more road blocks of its own, considering it does not own the operating systems that the Echo connects to to facilitate those phone calls. To get around these elements, Amazon may introduce a virtual number for the Echo speaker, or simply allow for call forwarding.

Do you think the Home or Echo should support phone calls?

Shaking My Head In Hopeless Disbelief As I Watch The World Fall To Pieces Before My Eyes

PS: Need some good vibes to get you through? I’m Kickstarting a book of life advice from turtles. Good for the soul. Check it out!

ʕ – ▃ – ʔ  NATURE: AS POWERFUL AS SHE IS MYSTERIOUS

PS: I just launched 2 new books on Kickstarter collecting my best comics from the past 3 years! They’ll bring you equal parts joy and maniacal laughter. Check it out!

This is the world we live in.

I do a lot of these.
So do other people.

Nearly one year after kicking off its Hands Free mobile payments trial, Google has revealed that its ending the test.

Google says that it’s shutting down the Hands Free app on February 8, almost one year after launching a pilot program in the San Francisco Bay Area. the company goes on to say that it’s using customer feedback to “bring the best of the Hands Free technology to even more people and stores,” and while Google won’t say what it’s got planned next, it does urge everyone to check out Android Pay in the mean time.

Google Hands Free was originally announced way back in May 2015. The goal of the service was to let you pay for things hands-free using the Bluetooth, Wi-Fi, and location services parts of your smartphone. After telling the cashier that you’d like to “pay with Google,” they would confirm your identity using the name and photo associated with your profile, and then you’d be good to go.

It’s kind of disappointing that the Hands Free trial only lasted a little less than a year and was only available in the Bay Area, because that means that many of us didn’t get to try the service. Here’s to hoping that when Google says that it’s working to bring Hands Free tech to more people and stores, that means that more of us will get to have a Hands Free-like experience in the future.

Did you ever try Hands Free?

The app management screen in the Google Play Store is pretty rudimentary. You get a list of installed apps and a list of all apps you’ve previously installed. That may change soon.

The images you see above reportedly show how the new app management screen will soon look. There is a separate tab for updates alongside the installed and library tabs and installed apps can be sorted via a drop down menu. You can also open apps with a single tap rather than opening the Google Play listing first, as well as see app size and when it was updated and last used.

There’s no news on when this will launch, but at least one person has gotten this new layout. Hopefully it’ll be a quick rollout!

Texts From Superheroes

Facebook | Twitter | Patreon

Texts From Superheroes

Facebook | Twitter | Patreon

Texts From Superheroes: Best Of Valentine’s Day

Read More of the Best of Valentine’s Day on Texts From Superheroes

Texts From Superheroes

Facebook | Twitter | Patreon