Still plugging away. Looking at the possibility of creating an isometric world for Marshall to quest in.

Still plugging along with Marshall ideas. We're currently planning to use Phaser as our game engine, so the code monkeys have been learning and experimenting with the API.

We've been getting quite a few downloads of Yellow Dog Saves the World lately, which is good, but they are mostly coming from mainland China, so... Good news, or? You decide.

The issue with Node and Socket not working correctly was resolved, and the RTS finished. Not wonderful, but it contains all the basics for a two-player real-time strategy game, which was the goal.

Still working on the Marshall game. We're looking at making it an open-world 8-bit game, sort of like Zelda, although the original intent was a side-scroller. We've also been considering it as a platformer, but the current storyline would have to be tweaked to make it work. Likely, it will end up being a RPG, possibly with side-scrolling boss fights like some of the later Zelda games.

Progress, at least a bit. Still working on Javascript, currently on a small RTS. I'm having some trouble getting Node and Socket to mesh correctly.  The Marshall Mellow script is being polished, and level designs are being bruited about.

Been a long time - this is really no way to run a business. (Kick self in ass). New stuff - Yellow Dog was released earlier this year with double the encounters, and with some platforms/barriers added. We're waiting for feedback on this version. My own (don't let this influence how you feel! :-) ) opinion is that we need to add a smaller platform sprite so that ramps and tunnels wouldn't be so awkward. We'll keep working to improve the YD experience, even as we move on to new projects.

New(ish) project - Coding department is acquiring Javascript skills. We haven't abandoned our game starring our spokesman, Marshall Mellow, and hope to release it in late 2020 for multiple platforms, including iOS and Android. Don't give up!  Regular (I know, I know...) updates as progress occurs.

Graphics is waiting (over a month now...) for the local Mac repair center to finish replacing the GPU on his laptop. Thus, none of the actual sprites and backgrounds are ready for YDv2.0. The coding department is also trying to refine some elements, but we are still hoping to get it out prior to the December holidays. 

Work continues on the YD update. A working prototype is nearly ready, but we are using placeholder sprites. The graphics department is busy getting started with college courses, so our mid-October release is looking optimistic. We've decided to shoot for a pre-Christmas release in December, which would be a year from the original v1.0 release. If we're ready before then, awesome! Otherwise, crossed fingers for December.

We've decided to go back to a free version of Yellow Dog Saves the World. Tell all your friends and significant others! In the App Store now!

The game previously planned for a late summer/early release has been put on hold. When it is released, it will be more involved than the little side-scroller it was originally intended to be, probably a platformer, definitely a leveller, and may even contain a maze. Details are being hammered out among the creatives. 

Yellow Dog Saves the World is being upgraded with levels and new enemies. The version 2.0 release is set for mid-October. Watch for announcements!

First, a brief update. The game hinted at in the last post was intended to be something we could churn out in a couple of months, a simple side-scroller to provide the coding team with more and better experience using Swift and XCode. Then, the design team got involved. We are now projecting a release date of our level-based game sometime in late August or early September. A further hint: It involves chubby Boy Scouts and marshmallows. (At least we kept the graphics department out of it...what a bunch of buttholes.)

On to the code: One of the elements the design group insisted upon was a slider to control the speed and direction of the player. It quickly became apparent that a UISlider object wasn't going to be viable, for reasons that I won't go into here. Our best option was going to be a slider built as an SKNode. Apple, the source of all that is good in the world (some other world, in a galaxy far, far away) has provided the basic code for this, in the form of a slider class. It can be downloaded, as of this writing , at 

https://developer.apple.com/library/content/samplecode/scenekit-2017/Listings/Swift_Shared_UI_Slider_swift.html

It proved to be very simple to implement. Copy the code into a new Swift file (we called ours Slider.swift, same as Apple, though, of course, the name is entirely up to you and the needs of your app). Because we use the slider to vary our player's speed, we added a variable above the init() function:

var playerSpeed = 0

We changed the label position to fit our project (the default centers it in the screen), and cut the size of the circular slider from height to height/3. The slider fill color default is white, which we changed to blue, then moved the slider and background - the background is the thin line the round slider moves along -  to where we wanted them on the screen, based on where the label is located:

//Create background and slider
        background = SKSpriteNode(color: SKColor.white, size: CGSize(width: CGFloat(width),                       height: CGFloat(2)))
        slider = SKShapeNode(circleOfRadius: CGFloat(height/3))
        slider!.fillColor = SKColor.blue
        
        //Position slider and background
        background!.anchorPoint = CGPoint(x: CGFloat(0.0), y: CGFloat(0.5))
        slider!.position = CGPoint(x: CGFloat((label!.position.x + 1) + (background!.size.width / 2)), y:             CGFloat(-100.0))
        background!.position = CGPoint(x: CGFloat(label!.position.x + 1), y: CGFloat(-100.0))

The design people requested that the slider values range from -1000 to 0 to +1000. To get this, we added these lines to the iOS-specific code in the #if-#endif, in the touchesMoved function:

        let maxVal  = Int(1000)
        let userValue = Int(value * CGFloat(1000))
        playerSpeed = (2 * userValue) - maxVal

Prior to that, in the same function, we changed the y-value of the slider position to -100.0, to match the rest of our code for that value.

The last step to implementing the slider was to add a new function after touchesMoved, but still inside the #if-#endif. Our slider , once moved in either direction from the center, needs to snap back to the center and reset the slider value to 0. To do this, we override the touchesEnded function:

 override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
        slider!.position = CGPoint(x: background!.position.x + (background!.size.width / 2), y:                          CGFloat(-100.0))
        let curVal = slider!.position.x + 224.0 //This is an offset you will need to experiment with
        playerSpeed = Int(curVal)
        setBackGroundColor(SKColor.white)
    }

Notice that we set the background color to white in this function. The touchesMoved function sets it to gray, so we return it to the default color.

Lastly, in your GameScene class, instantiate your slider class, passing in values for the width, height, and text label. Add the slider to your GameScene, probably attaching it to the camera:

self.camera!.addChild(slider)

And that's it! You'll have to add your own code for the behavior you want, but this creates the basic slider.