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. 

   Later this month, we will be releasing a version of Yellow Dog Saves the World with no advertising. We are discontinuing the free banner ads version.
​
   We have a new app in the works! No early bean-spilling, but look for it in early May 2018.

   When it came time to monetize our app, Yellow Dog Saves the World, we (for various reasons which I won’t delve into here) decided to use Amazon’s SDK, specifically to add a banner ad.

   You would think that Amazon would have a lot of support for this sort of thing, right? Good instructions, concrete examples, etc., etc.? Well, you’d be wrong. For whatever reason, Amazon provides only bare-bones instructions for getting started (which is better than nothing, and which I encourage you to read and utilize to the best of your ability), but a lot is left unsaid when it comes to actually producing a working ad strategy in a production app. Also, as of this writing, mid-January of 2018, the SDK has not been updated for the current versions of Swift and Xcode.

   Additionally, there ain’t too many good examples out there on the InterWebs that use Amazon ads, just a bunch of queries to Stack Overflow with answers that range from partially useful to not at all.

WARNING - SUBVERSIVE CONTENT (i.e. Sage Advice) -> Compare this to Google’s AdMob (our current ad scheme), which is much easier to get started with, has fairly good instructions, and at least one very good concrete example on the web of connecting it to a real app. Before you go any further, I would recommend that you abandon Amazon in favor of AdMob. I haven’t tried to set up interstitial or rewarded videos in AdMob, but I have done some experimenting with Amazon interstitials, and I am pretty sure that AdMob will be the winner in that arena, as well.
​END - SUBVERSIVE CONTENT

   Okay, so my sage advice is wasted on you, and you persist in using Amazon. Here’s how the Code Ninjas  at Parhelyon integrated a Amazon Mobile Ads banner into Yellow Dog Saves the World:

   First, add a bridging to your project. Copy and rename the sample bridging header in the SimpleAdUniversalSample_Swift file. Change the name from SimpleAdUniversalSample_Swift-Bridging-Header.h  to Your_Project_Name-Bridging-Header.h, where “Your_Project_Name”, is, of course, the name of your project (in our case,Yellow_Dog_Saves_the_World-Bridging-Header.h). In Build Settings, find Swift Compiler - General, click the arrow on Objective-C Bridging Header, and add the name of your header under Debug and Release (If your header is in the project root, you should only need to add the name, if in a subfolder, you will need to include the folder in the path, i.e., FolderName/Your_Project_Name-Bridging-Header.h.)
   Second, add code to AppDelegate.swift, GameViewController.swift, MenuScene.swift, and GameScene.swift:

• In AppDelegate, in the application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?)  function, add 2 lines:

-> AmazonAdRegistration.shared().setAppKey(app key you received from Amazon goes here, in quotes)
->AmazonAdRegistration.shared().setLogging(true). You must change this value to “false” in the production code.

• In GameViewController (ViewController, if not a game app):

    -> Create a variable to connect to the banner view control in the storyboard. Although, in general, you should avoid using global variables as much as possible, we made this a global as it needs to be available to our MenuScene and GameScene classes. Example: var amazonBannerAd: AmazonAdView!

    -> In the viewWillLayoutSubviews function, ad this chunk of code:
let adFrame = CGRect(x: 0, y: 154, width: UIScreen.main.bounds.size.width,
height: 90)
           amazonBannerAd = AmazonAdView.init(frame: adFrame)
           amazonBannerAd.setHorizontalAlignment(.center)
          amazonBannerAd.setVerticalAlignment(.fitToContent)
   
           //Set ad loading options and load ad
           let adOptions = AmazonAdOptions()
           adOptions.isTestRequest = true //Set to false for production version
           amazonBannerAd.loadAd(adOptions)// This loads the ad
       
           //Ensure our delegate receives the callback messages
           amazonBannerAd.delegate = self
       
           //Add the Amazon Ad banner to our view
           self.view.addSubview(amazonBannerAd)
       
           //Hide the banner ad in MenuScene
           amazonBannerAd.isHidden = true
       
    This creates an ad frame that fits acceptably near the bottom center of an iPhone (tested on all simulator devices from iPhone 6 to iPhone X). It does not auto-place well on iPads at all. Ads on iPhones will be 320x50, which is Amazon’s preferred size for phones. This code causes it to auto-resize for iPads, but you can set a hardwired ad size in your code - sample code found on the Amazon forum shows how.

-> Still in GameViewController, right below the viewWillLayoutSubviews function, we added these three(3) functions:

//AMAZON
   func viewControllerForPresentingModalView() -> UIViewController! {
       return self
   }
   
    func adViewDidLoad(_ view: AmazonAdView!) -> Void {
       Swift.print("An ad loaded successfully.")
   }
   
   func adViewDidFail(toLoad view: AmazonAdView!, withError: AmazonAdError!)  -> Void {
       Swift.print("Ad failed to load. Error code \(withError.errorCode) \(withError.errorDescription)")
   }
   //AMAZON

• In our MenuScene class, we added code to reveal the hidden ad when the Start button is pressed: amazonBannerAd.isHidden = false

 

• In the GameScene class, in the code that checks our buttons that replay and restart the game, in the code for the restart (returnToMenu, in our case) button, which returns the game to the initial start menu screen, we need to hide the ad once more: amazonBannerAd.isHidden = true

   You may or may not want to hide the ad in the start menu, if this is the case, you can leave out the three calls (in GameViewController, MenuScene, and GameScene) to amazonBannerAd.isHidden altogether.

   And there you have it!

  Finally, go back and read the Subversive Content.