The Amazing iOS9 Course - Over 84 hours of Content!

Learn to build an iOS 9 video player by adding the media player framework, importing UIKit, and configuring a movie player controller to play local mp4 files or online streams.

Learn how to add the media player framework and play a video in iOS 9, choosing between local and online videos, and understanding wireless download limits and updating online content.

Build a compound interest calculator in swift for ios9, from creating a new single view app to wiring text fields, labels, and a calculation flow with float math.

Create a compound interest calculator for iOS9, convert the rate to decimal, format results to two decimals, display and clear inputs, and customize the app’s UI while testing scenarios.

Learn to build a number divisor app for iOS9 in Swift, using a single view interface with text fields, a calculate button, and modulus checks for divisibility by another number.

Validate user input in the number divisor app for iOS 9 to prevent crashes by defaulting empty fields to 1. Avoid division by zero and present clear results during calculations.

Build a coffee decider app for iOS 9 in Swift with Xcode, wiring the UI, managing coffee and button arrays, and implementing randomization and outlets.

Learn to build a coffee decider in iOS9 by printing random coffee selections to a label, wiring a print button, and styling with fonts, colors, and layout considerations.

Create a tip calculator for OS X using a cocoa application in Xcode, wiring meal cost and tip percentage text fields to labels and buttons with Swift outlets and actions.

Learn to structure a tip calculator by breaking code into readable, modular functions, converting user input to floats, calculating the tip, and printing results for easy release.

Learn to build an OSX tip calculator that formats totals to two decimal places, tracks total tip and meal, clears the app, and explores design choices to improve user experience.

Learn to use arrays to build an OS X cocoa app that counts characters in a string, using Swift, Xcode, and interface elements like text fields, labels, and buttons.

Create a swift array of text characters to power a character counter on os x, enabling count, length, add, remove, and reverse operations, including retrieving the third character.

Learn to build a simple Cocoa app for OSX called word reverse, using Xcode and storyboards to wire outlets and actions, handle input, reverse the word, and display it.

Learn how to reset an OSX word reverser app, implement placeholder text, wire up reversing logic, test the app, and explore UI design with chalkboard fonts and font tweaks.

Create an inspirational quote app for OS X using Swift, arrays, and random selection, with outlets and actions to display quotes, update the button text, and handle user interactions.

Explore how to prevent quote repeats in an OSX inspirational quote app by using arrays, number checks, and nested if statements, while refining the fonts and layout.

Design and build an innovative OS X Cocoa calculator in Swift, wiring text fields and labels with outlets and actions for addition, subtraction, multiplication, and division.

Explore building an innovative OSX calculator in Swift, implementing addition, subtraction, multiplication, and division with float inputs and scoped variables.

Learn to build a stock price calculator app for OS X using Swift and Xcode, designing the interface, wiring outlets and actions, and calculating profit, percent increase, and total funds.

Design and implement a macOS stock price calculator that formats profits and total funds to two decimal places, updates strings, and refines the UI with Avenir Next font.

Learn to build a savings app for OS X with Swift and storyboard, design the interface, connect outlets and actions, and calculate weekly, monthly, and yearly savings and income.

Explore building a savings app for OSX, calculating hourly income to yearly income, monthly and weekly savings, and formatting outputs with currency and percentages while testing early.

Build a savings visualizer for osx using a cocoa app with sliders and labels to input yearly income and percent saved, then calculate weekly, monthly, yearly, and 25-year savings.

Build and refine a savings visualizer for OSX, formatting weekly, monthly, and yearly savings with two-decimal dollars and percent values, and debugging common ui formatting issues.

Build a simple osx score counter in swift using a cocoa app, with a large label and add, subtract, and reset buttons, zero-based integers, outlets, and actions.

Implement an if statement in the score counter button to prevent negative scores, design a retro user interface with Courier font, and cap the score at 100 while testing.

Build a simple quiz app for OSX using Swift and Cocoa, with labels, buttons, outlets, actions, and array-based questions and randomized answers.

Learn to build a simple kids' quiz app for OSX by implementing button logic for correct and incorrect answers with separate functions, and expand to ten questions.

Create an OSX addition game with Cocoa, Swift, and a storyboard interface that presents a random two-number question, shows total correct, and uses four answer buttons plus a reset.

Builds an OSX addition app by implementing randomized incorrect answers, robust correct and incorrect logic, modular functions, and thorough testing to ensure non-repeating numbers and reliable resets.

Learn to build a multiplication game for OS X using Cocoa and Swift, including UI labels, outlets, actions, and randomized questions.

Builds an OS X multiplication game interface by wiring button handlers for correct and incorrect answers, updating totals, and resetting with randomized numbers, while exploring difficulty levels for ages 3–10.

Learn to build an OSX subtraction game in Xcode using storyboard, labels, and buttons. Wire outlets and actions, implement random numbers, and display questions and results.

Improve the subtraction game for OSX by structuring logic with dedicated correct and incorrect functions, updating total correct, and preventing negative numbers through reset and validation.

Design and code an algebra addition game for OSX using Swift and Xcode, with labeled questions, interactive buttons, and random number logic to track correct and incorrect answers.

Implement a Swift-based algebra addition game by adding correct and incorrect logic, button actions, and live UI updates for total correct and total incorrect, plus a random x placement challenge.

Build a Cocoa algebra multiplication game in Swift using a storyboard, with four answer buttons, outlets and actions, random number generation, and tracking of total correct for debugging.

Implement correct and incorrect logic for the multiplication game, manage button events, totals, resets, and number randomization, and note how to upload Mercker felt fonts on iOS versus OSX.

Finalize the OSX compound interest calculator by adding a clear function to reset inputs and outputs, and refine the app font with a label for total money earned.

Build a macOS divisor app in Xcode that converts inputs to integers, computes the modulus, and displays yes or no in a multi-line label.

Build an osx divisor app that checks divisibility and prints messages like 'first number is divisible by the division number' or 'not divisible', prioritizing minimal code and a clean ui.

Create a macOS Cocoa coffee decider app in Swift, using arrays, outlets, and actions to build a simple, fast UI and randomize coffee selections.

Choose a coffee option from the array and print items by index, using quotes for strings. Randomize selections and guard against out-of-bounds errors while adjusting labels and fonts.

Build an interactive iOS app in Swift that applies a circular distortion filter to an image, using sliders for radius and angle to update the live preview.

Learn to build and test a watch app in Xcode with the interface storyboard and watch kit, using simulators for iPhone and Apple Watch while noting Apple's vertical integration.

Learn to wire actions and outlets in watch kit interface, update button titles and labels, and use Swift functions and variables (strings and numbers) with type conversion.

Explore how if statements drive logic on Apple Watch apps, using comparisons, booleans, and else if structures, with hands-on examples like updating button titles and label colors.

Learn to build interactive watch app interfaces by changing button and label colors, using set background color and set text color, with IB action switches and sliders driving color functions.

Build a simple Apple Watch app in Xcode with Swift, using watchOS storyboard, outlets and actions, to flip a coin and display heads or tails.

Build a simple Apple Watch coin flip app in Swift, printing the coin state to a WatchKit label using strings and string interpolation, and organize code into modular, reusable functions.

Design a coffee decider app for watchOS 2 on the Apple Watch, with interface and label and button wired as outlets and actions, using Swift arrays to randomize a selection.

Master swift randomization and data type conversion using arc4random_uniform, convert between uint32 and int, then print a coffee array item to a label and button title for the ui.

learn to build a keyboardless tip calculator for the Apple Watch using Swift and interface builder, with outlets and actions, floats for totals, and a rough tip estimation.

Build a tip calculator that prints the meal total and tip total using meal cost and tip arrays, with zero-based counts and button indices on the watch interface.

Guide students through building a tip calculator app by formatting tip and meal totals to decimals, testing functionality, saving work, and balancing precision with rounded results for a watch app.

Learn to implement a watch timer in Xcode for Apple Watch with WatchKit, wiring a timer object to a start and stop button and a reset action, using Swift.

Explore building a timer in Xcode for Apple Watch: implement reset logic via a reset button, manage start/stop and date-based resets, and fix a bug where the timer starts automatically.

Design and code a watch kit dice app in Xcode using Swift, wire outlets and actions, and implement a dice type array to randomize results for display.

Extend the dice random number generator with a watch interface, address zero based counting, test with the simulator, fix zero results (set to one or re-roll), and discuss keyboard-free design.

Learn to build a random baby name generator for Apple Watch using Swift, with boy and girl name arrays, labels and buttons wired via outlets and actions, and basic randomization.

Generate random boy and random girl names by selecting indices from name arrays using random uniform and integer conversion, then display the chosen name in the UI.

Learn to build an emoji generator for Apple Watch using Swift, with an emoji array, outlets and actions, and a generate button that picks a random emoji.

Learn to randomize numbers from an emoji array in a Swift watch kit app, print a chosen emoji and button title, and handle array counting and type conversions.

Learn to build quote-of-the-day app for iOS by wiring a label and button, creating a quotes array, and implementing a random quote generator with outlets and actions.

Learn to implement a color-changing text feature in a quote of the day app using an integer color index, a change text color function, and preset UI colors in Swift.

Design a two-button Apple Watch pushup counter in Swift, using a max-reps array with outlets and actions to track, print, and reset reps when reaching the max.

Build a productivity timer for Apple Watch with a start button and reset, using a 20-minute focus interval and Swift timer logic with NSDate and time intervals.

Design a simple score counter app in Swift for watch kit, using three buttons, zero-based scoring, reset. Implement outlets and actions, update titles, test early and often in Xcode.

Build a roman numeral quiz app for Apple Watch using Xcode and storyboard; design the interface, hook outlets and actions, and implement random roman numeral generation and track score.

Implement a roman numeral watch app with nested if statements for button correct, update total correct, print score, and reset via an override function, randomize numbers, and color-changing roman numerals.

Design and build an Apple Watch app to learn Spanish, wiring outlets and actions, updating labels and buttons, and implementing random word selection with language switching.

Develop an Apple Watch Spanish learning app by implementing random number logic to avoid repeats, using English and Spanish word arrays, and updating correct/incorrect button states.

Master modular SpriteKit coding by using scope and shared label nodes, and learn Swift type concepts like CG float versus float and alpha.

Prototype an iOS 9 8-ball decision app with Swift, using simple animations, a fade-in answer label, and a random answer array to engage users.

Build a color picker in iOS 9 using Swift, with red, green, blue sliders, outlets and actions, and a label that updates its background color.

Format color components to two decimal places and round values when printing red, green, and blue. Show app with full-screen color, adjust fonts and labels for a minimalist, readable UI.

Create a color filter app for iOS 9 using red, green, and blue sliders to overlay color on images. Build with a storyboard interface, update labels, and test in simulator.

Build an iOS 9 app that adjusts image opacity with a slider. Wire a label, image view, and slider, implement the change opacity action, and format the value for display.

learn to build an iOS 9 hsb color changer using sliders for hue, saturation, brightness, and opacity, wiring outlets and actions, updating background color in Swift.

Test and refine the hsb colour changer for ios9 by building in the simulator, adjusting saturation, brightness, and opacity, and iterating on label color logic and ui styling.

Design a color input interface using text fields for red, green, and blue, a number pad and calculate button; convert strings to cgfloat, clamp 0–255, and apply color to background.

Learn to validate text fields, set default color values when fields are empty, implement a clear function, and dynamically adjust background colors and fonts to enhance an iOS9 app.

Create a custom to-do checklist for iOS9, adding items with text fields, toggling completion via switches, and a clear reset function while managing the keyboard interactions.

Design an iOS9 to-do checklist interface by selecting fonts like Avenir Next ultralite and applying ocean blue theme. Configure background and text colors, add items, and manage switches with animation.

Explore core image filters in iOS 9 by building a simple Xcode project that applies CI filters to two images, background and logo, using mono and gaussian blur.

Learn to build a hue filter changer for iOS 9 by connecting a slider to a Core Image hue adjust filter, updating the image in real time with Swift.

Build a hue filter changer for iOS 9 using a UI image view and a slider, and test on iPhone to address lag, noting hue changes the whole image.

Learn to create a sketch-like image in Swift with a built-in filter in Xcode for iOS 9, using sliders for noise level, sharpness, edge intensity, threshold, and contrast.

Explore implementing a filter by printing and adjusting multiple inputs—noise level, sharpness, edge intensity, threshold, and contrast—formatting outputs and debugging, ensuring image variables are set before drawing.

Create a hexagon pixel generator for iOS 9 that uses a slider to control hexagon size, applying a hexagon pixelation filter to images in Swift and UIKit.

Turn your image into a pointillist image using a programmatic iOS 9 pointillism image generator, adjusting the dot radius with a slider and a start button.

Design a comic book image generator for iOS9 that uses a simple image view and button. Apply a comic effect filter to transform photos.

Create a glow effect for images by building a glowing image generator for iOS 9, using a bloom filter with adjustable radius and intensity.

Create a mosaic image generator for iOS 9 by applying the CI crystallize filter in Swift, with a draggable radius slider and real-time preview.

Build a kaleidoscope image generator for iOS 9 using Swift, with a slider, a generate button, and an image view to display the kaleidoscope via a CI kaleidoscope filter.

Invert an image on iOS 9 using a core image filter in a simple app, wiring an image view, label, and switch to toggle the effect.

Learn to apply a monochrome color filter in an iOS 9 app using a built-in filter, connect a slider to control intensity, and preview results in an image view.

Build a simple iOS9 app that applies a chrome photo filter to images, adjusting background color, text, and image assets to brighten and showcase the chrome effect.

Build a simple iOS 9 app that applies the chrome photo effect filter to images, wiring a button to generate the filtered, brightened image in the view.

Learn to build an iOS 9 app that applies a noir black-and-white filter to photos using Swift and Core Image, with interface builder setup and a filter button for testing.

Apply motion blur to images in an iOS 9 app by adjusting radius and angle with sliders, updating the image via a filter to preview the blur effect.

Learn to build a sepia tone image generator for iOS 9 by applying a filter to images, adjusting intensity, and wiring a change filter action in a Swift app.

Learn to apply the CI vibrance filter in iOS 9 using Swift, configure Core Image filters, and build an app that loads images, adjusts vibrance, and cycles through multiple pictures.

Learn to apply a circle crop and an effect fade filter to images in iOS 9 using Swift, via a storyboard-driven interface with image views and actions.

Discover how to implement a twirl distortion using the C filter in iOS 9 with Swift, wiring storyboard controls, sliders for radius and angle, and live image output.

Discover how to build an iOS9 image radius generator: round image corners with cornerRadius and clip bounds, then cycle the border color using a change color button in Swift.

Learn to display an image on touch in a Swift iOS 9 app, creating an image view, handling touches began, and sizing at 100x100, with notes on vector resolution.

Learn to build a pixelation app for iOS 9 in Swift that takes an image, applies a pixelation filter, and uses a slider to adjust the pixelization.

Learn to implement a programmatic noise reduction feature for images in iOS 9 with Swift, including setting up the interface and adjusting noise level and sharpness.

Learn to build an instagram-like filter switch in iOS 9 using Swift, Core Image filters, and a three-segment control to apply process, noir, and chrome effects.

Learn to build a start-to-finish space shooter using SpriteKit on iPad, including drawing and sprites, setting up physics, collisions, and game state logic.

Set up score and main labels with fonts, colors, and positions, then implement spawns for projectiles and enemies using SpriteKit actions and physics bodies.

Extend the space shooter by implementing projectile and enemy timers, spawning logic, and touch-based player movement, plus basic collision handling with physics bodies.

Implement player–enemy and projectile collisions in a simple space shooter, handle game over, update the score, and move to the title screen. Spawn and manage sprite kit explosions on impact.

Create a title screen for the space shooter with a play button and game title label, then present the game scene with a crossfade transition.

Design and create vector sprites for a space shooter in Adobe Illustrator, defining 40x40 player, 30x30 enemy, and 10x10 projectile, tweaking shapes, testing, and exporting to Xcode.

Export 24-bit art for the player, enemy, and projectile, save for web, name assets exactly, import into Xcode, test the game, and adjust particles and visuals, royal purple.

Learn to build a simple iPad game that collects squares and avoids circles, using SpriteKit with particle emitters, retro green theming, and a starry background.

Spawn objects at the top with random positions, move them downward using actions, and destroy them on exit to create a simple avoid game for iPad.

Create a simple avoid game for iPad by adding random size and speed to stars, spawn timers for squares, circles, and stars, and touch-based player movement with an isAlive loop.

Create and configure hud labels (score and main) using courier font, size, and white color; position, spawn, and add them to the scene, then hide the main label at start.

Configure the sk physics contact delegate and implement did begin contact to manage collisions, update score, spawn explosion, and transition to the title scene.

Create a title scene with a spark explosion, a title label, and a play button in SpriteKit, then transition to the game scene while managing particle memory usage.

The lecture guides building a simple avoid game for iPad, adjusting visuals and physics, wiring an explosion emitter with SpriteKit, and spawning explosions.

Build an avoid game for iPad using SpriteKit, adding an SK sprite kit node for the player, a dark-green background, and a reset function to reinitialize isAlive and scores.

Export and optimize game art, set 30 by 30 sprites at high scale, integrate circle of void and square, tune colors, add explosions, and design new power-ups and themes.

Learn to build a minimalist avoid spikes game in spritekit, using a three-color scheme and simple art, with player spawning, spike spawning, and basic touch controls.

Set up the main and score label nodes with font and off-white color, position them, and spawn spikes on a timer using SpriteKit actions, with random x placement.

Hide the start screen by fading the label over three seconds with an SKAction sequence, then handle player–spike collisions via a physics contact delegate to update the score.

create a title scene for the avoid spikes game in SpriteKit, add a play button and game title, show game over text, and transition to the game scene.

Implement defeat flow by waiting, then transitioning to the title scene. Reset variables on start and add a score update loop, and prepare player and spike art in Illustrator.

See how to resize the player and spikes for consistent gameplay, craft a minimalist title screen, adjust backgrounds, and tune spike speed, then add a falling sprite for power-ups.

Explore chroma avoid in part 1 of the amazing iOS9 course, a program with over 84 hours of content.

Learn to implement chroma avoid gameplay in a SpriteKit app, with drag-based movement, dark and light color states, and timed background color changes, plus start label management and debugging.

Implement a countdown timer and color change counter in a chroma avoid game, spawn dark and light blocks at random x positions, and move them downward with SKAction sequences.

Add collision handling in SpriteKit by defining physics bodies, category masks, and didBeginContact; implement light and dark block collisions, update the score, and switch game scenes.

Create a title scene in SpriteKit with a play button and game title label, configure transitions to the game scene using crossfade, and handle scene resets and variable initialization.

Implement chroma avoid mechanics by configuring color blocks, collision logic, and score updates, and experiment with alpha, block speed, and a third color for engaging iOS game design.

Explore a color-based mini game where you touch the right color among four squares, using arrays and random colors in Swift SpriteKit with Bauhaus-inspired minimalism.

Create and style labels, set up a color array and random color choice, and display the correct color with several incorrect options to practice color matching in SwiftUI.

This lesson builds a color-matching game by wiring touch handling, defining correct and incorrect squares, updating a score, and managing a countdown timer with SpriteKit.

Implement game over logic by updating the label text to 'game over', showing 'try again', and resetting the game state, including spawning squares and transitioning scenes.

Tap a square as fast as you can to chase a high score. Use timers and touched nodes in Spryte kit to design a simple, appealing game for iPad Swift.

Learn to drive a timer-based game loop in sprite kit by using a timer counter, spawning a square, tracking touches to score, and implementing game over logic.

Implement reset logic and test scene transitions in spray kit, then apply divergent thinking to generate ten new game concepts.

Design a simple time-based collecting game in swift using SpriteKit for iPad, featuring item spawning, a score label, and touch-driven player movement.

Spawn collectibles at regular intervals with a timer and SKAction sequences, position and label them, and use physics categories for player and collectible collisions.

Builds collision handling in a square game using SK physics contact delegate, detects player–collectible collisions, updates score, and adds a countdown timer to increase challenge.

Master resetting a SpriteKit game scene, implementing game over logic, transitions, and variable resets, then add power-ups and a harder mode for collecting squares.

Design a minimal mobile game in swift SpriteKit where you collect color blocks, move the player with touches, and cycle block colors using simple color variables and data transfer.

Apply SpriteKit to spawn colored falling blocks with random x positions, use actions and timers to move blocks, and implement physics contact to detect collisions with the player.

Implements collision handling between player and falling blocks, assigns names and categories, updates score with on-screen labels, enforces color-matched destruction, and triggers game over logic.

Explore building a one-page iOS game where the player moves while alive, collisions remove blocks off-screen, and the game resets after a delay using SKAction sequences, transitions, and rotation constraints.

Tap the right square before the countdown ends in a two-square SpriteKit game. Avoid wrong taps to keep the game going; precise timing boosts score and tests perception and reaction.

Implement a color square and a randomize square function to choose left or right squares, set their colors, and increase the score when a square is tapped.

Add a 10-second countdown timer using SKAction and run blocks, updating the on-screen countdown and font size. Trigger game over and reset the game when the countdown reaches zero.

Create a two-state iOS game with placing and collecting phases using SpriteKit and Swift. Spawn blocks, enforce screen bounds, apply physics, and score by placement and collection.

This lecture shows adding a floor physics body in Swift with SpriteKit, preventing gravity, randomizing block colors, and spawning start and score labels for a block game.

Add a score variable that increases when a block spawns and update the on-screen score. Introduce a countdown timer to manage spawning and state changes between spawning and collecting.

Create and configure a title scene in SpriteKit, including a play button and game title label, and set up transitions to the main game scene.

Learn to control game flow with spawning and collecting states, set can complete, trigger game over, and transition to the title scene using SKAction sequences.

Design a whack-a-block game for iPad using SpriteKit, spawning green good blocks and red bad blocks on a timer. Score by hitting greens and avoid reds during the countdown.

Create a whack-a-mole style game by implementing a countdown timer, spawning green and bad blocks at configurable intervals, and updating the score through touch interactions and game over logic.

Implement game over logic by destroying blocks, naming blocks with exact names like block good name and block bad name, and updating score while resetting the game state.

Build a color blocks game with a ready set go timer and game states: placing and collecting blocks. Use orange, blue, and white colors to signal changes and spawn blocks.

Practice spawning labels for score and timer, set fonts and positions, and implement a start timer sequence in a SpriteKit-based iOS app to drive Ready, Set, Go gameplay.

Learn to create and position on-screen labels for a color blocks game, set fonts and colors, and implement a start timer with ready set go.

Build a timer-driven sequence that places and counts down timers, toggles collecting state, and updates orange and blue blocks to reflect game progress.

Implement touch-based gameplay by detecting touched blocks, validating the correct block, and updating the score; manage game states, game over, and reset transitions.

Learn to build a swift SpriteKit-based block-collector game using a for loop to spawn blocks, implement a day-night cycle, and adjust difficulty with timer color cues.

spawn multiple blocks with a for loop and configurable amount, then remove blocks on touch, update score, and add a countdown timer with game over and reset logic.

Remove extraneous blocks when the game ends by enumerating nodes and destroying block sprites; add a remove extra blocks function with a crossfade, and implement an easy/medium/hard game screen.

Create a memory-based color blocks game that flashes colors for memorization, asks players to select the correct blocks, and uses arrays, timers, and spawn loops in SpriteKit.

Build a memory color game by adding labeled blocks, setting fonts and colors, and implementing a random color display, timer, and score tracking to challenge recall.

learn to implement a memory color game by handling touches, updating scores, and managing a countdown timer with game over and reset logic to coordinate color blocks.

Learn to build a memory color game by refactoring nested if statements into reusable game-over logic, manage countdown timers, test gameplay, and add difficulty levels with varying block counts.

Build a mine-avoidance game with a near-exponential difficulty curve using sprite kit. Drag the player with touches moved, avoid randomly placed mines, and spawn more mines after each goal.

Configure the goal and player with the same color cue and specific positions, add physics bodies with category bit masks, and enable collision handling in SpriteKit.

Learn to control a two-location goal with a numeric location variable, implement goal position logic, spawn and destroy mines, and manage reset and game-over flow.

Implement game over logic and update the score display in real time. Fine-tune mine spawning to steadily increase difficulty and introduce a rare random power-up to ease gameplay.

Place and collect blocks across two game states to score points in a Swift SpriteKit iPad tutorial, featuring spawn blocks, timers, and live scoring.

Implement a countdown timer using SKAction sequences to place and collect blocks, update the score, and manage game over logic in a Swift SpriteKit game.

Implement and reset a SpriteKit action sequence with transitions and scene scale settings, then apply color themes to the UI and fonts for a polished game experience.

Design an educational color-matching game for kids, balancing challenge and simplicity across ages, using SpriteKit concepts such as color arrays, SKLabelNode, and SKSpriteNode, with touch interactions.

Create a kid-friendly color-matching game by assigning random button colors, implementing touch-based input, and tracking scores, while refining visuals with darker colors and simple animations.

discover how to create an endless gravity game that toggles gravity up or down, guiding a player between a floor and a ceiling using SpriteKit physics and collision handling.

Implement a gravity switch in a 2d iOS game by toggling physics world gravity between down and up with touches began, and spawn ceiling and floor blocks using SKAction sequences.

Develop a collecting game by tracking collectible count, implementing game over logic, and resetting the game while spawning blocks of random sizes and managing scene transitions.

Learn to build a circle path arcade game where a rotating leader drops pellets for you to collect while avoiding hazards, using physics, sprites, and Swift-based path animation.

Spawn a collectible aligned to the leader’s position, enable player movement via touches, and spawn moving obstacle blocks with a timer for continuous gameplay.

learn to set up a sprite kit scene with a timer and spawn logic, and implement physics contacts between the player, leader, blocks, and collectibles using category bit masks.

Learn to set up UI labels and game elements in an iOS SpriteKit project, including font styling, positioning, score tracking, game over handling, and scene reset transitions.

Set up a gravity game by spawning floor and ceiling blocks at random intervals, adjusting positions, and enabling collision logic with physics categories for game over on player contact.

Implement collision handling in the gravity game, trigger game over when the player is hit, and manage is alive with reset and block spawning timers, plus a score label.

Learn to build a collecting game using physics in sprite kit, spawning blocks and collectibles, and guiding a player to push blocks to a top or bottom goal.

Learn to spawn multiple collectibles, display and update the score with a single label, and manage collisions between collectibles and top or bottom blocks using physics categories and contact handling.

Discover Swift fundamentals through an interactive playground, learn variables and data types (string, integer, double, float, boolean), and practice daily to build transferable coding logic across platforms.

Learn how to declare and use variables in swift, including strings, integers, doubles, and floats, perform type conversions, and work with arrays using zero-based indexing.

Explore the if statement in Swift, covering conditions, boolean logic, and comparison operators; learn to use else, else if, brackets, and logical and/or for game and app code.

Learn how functions in Swift divide up code to improve readability and debugging. Discover how to name and call functions, with examples like add double and print arrays.

Explore SpriteKit basics in Xcode using Swift, design games for mobile devices, and understand the game loop, scene setup, and touch handling.

Spawn a sprite in SpriteKit on app load using modular functions to spawn, move, and delete, set the spaceship image by a case-sensitive name, and center it.

Learn to handle touches began, moved, and ended in SpriteKit to track touch location and move sprites. Spawn labels with SKLabelNode, fonts, and colors for on-screen scores.

Demonstrate SpriteKit actions by composing SKAction sequences for a player and label, using wait, fade, rotate, scale, and remove, with a focus on simplicity.

Discover run blocks in SpriteKit actions, execute code, spawn a circle with a shape node vs sprite node, adjust color and alpha, and update its position to follow the player.

Build a space shooter using SpriteKit, learn about collisions, spawning, and particle effects, and create a ship art in Illustrator while setting up a title scene and basic physics.

spawn the player and game objects, configure sprite nodes and physics categories, enable collisions with a physics contact delegate, and implement touch-based movement for a space shooter.

Spawn projectiles, enemies, and stars with SpriteKit by configuring physics bodies, positions, and z-order, using randomization, and display live score and main labels on screen.

Add a fire projectile with a timer and SKAction sequences to spawn and move upward, while spawning enemies and moving them downward, handling collisions via didBeginContact and physics categories.

master collision handling in a shooter by comparing contact names to enemy and updating the score, removing objects, and triggering game over with a 'game over' label and explosion particles.

Wire a particle spark explosion emitter from a resource path for the space shooter, spawn explosions at enemy positions, and clean up with timed actions while spawning stars with timers.

Create a dynamic space shooter title screen using SpriteKit by building a title scene with a play button and game title, styling with colors, and transitioning to the game scene.

Build the space shooter reset flow with a game over sequence, transitioning from the game scene to the title scene after a three-second wait, and resetting game variables at start.

Design and implement a space shooter in SpriteKit with an orange ship and silver explosions, export assets from Illustrator, and test gameplay in Xcode's simulator.

Create a color-themed circle avoid and collect squares game in SpriteKit, using SK shape nodes, dynamic background colors, and a mobile title scene.

Randomly select a background color (red, green, or blue) and spawn the player, square, circle avoid, and star using SK sprite nodes, physics bodies, and category bit masks.

Spawn a circle and align it with the circle avoid area. Set node colors, spawn labels, and implement touch-based player movement.

Set up multiple timers and spawn actions to generate squares, circles, and stars, control their movement with SKAction sequences, and destroy them to manage memory.

Explore handling physics contacts in Spryte kit by implementing didBeginContact, differentiating player-square and player-circle collisions, updating the score, and triggering game over with scene changes.

Design and implement a title scene in a SpriteKit iOS game, adding a game title, play button, and styling, and transition smoothly to the game scene.

Learn to choose light blue, green, and red colors using RGB values and 0–255 scaling, then apply them to spawn node colors, fonts, and stars to achieve arcade-themed theming.

Spawn and arrange square and circle elements in a SpriteKit scene, customize colors and labels, and refine layout with offsets and background color tweaks.

Design spikes and tech circles with textured art, exploring cost effective rotation animation and programmatic menus to streamline asset tweaks for a high action, polished title scene.

Add a game title label and a play button, configuring font, color, and positioning, then transition to the game scene using an SKTransition and present it.

Create a SpriteKit game with an orange background, player and spike sprites, a ground, score labels, and physics categories; spawn and move spikes using a timer, while supporting touch-to-move controls.

Learn spike-player collision handling in SpriteKit with didBegin contact and category bit masks. Explore game over logic, reset variables, spawn sprites at start, and transition back to the title scene.

Refine a swift game scene with SK actions, updating the score and animating sprites. Add a power-up that stops spikes for five seconds using collision and a timer.

Master a color-switching arcade concept by building a game where you collect your current color and avoid opposing colors, learning duality gameplay and basic art techniques in SpriteKit.

Spawn dark and light blocks with SpriteKit physics, using size, position, and category masks to handle collisions. Implement timers and move actions to drive chroma avoid gameplay.

Implement color change logic with SKAction sequences and timers, updating light/dark states and UI, wire up a countdown timer, and set a repeating action loop.

Implements dark and light block collisions and game over logic, updates the score, and transitions to the title scene using spray kit.

Launch the game from the title scene by configuring SKTransition.door with a 0.4 second duration, ensure file names match exactly, and reset game variables for export.

Export light and dark ship assets, swap textures in Swift, and animate color changes with SKAction to create an animated title and two-state chroma-avoid gameplay.

Explore building a gravity-driven iPhone SpriteKit game, implementing physics, wall collisions, block spawning and collecting, color-randomized blocks, and simple game states with scoring and a countdown timer.

Learn to implement block spawning in a SpriteKit game: create random pastel block colors, set physics bodies with gravity, spawn blocks on touch, and update a score with on-screen labels.

Learn to set up a SpriteKit scene, manage a countdown timer, spawn and collect blocks, track score, handle touches, and implement game over and title scene transitions.

Set up the title scene by configuring the game title label, play button, and text, apply background and title colors, and implement the transition to the game scene.

Learn to create an outline by spawning an offset label with adjusted z positions and a cg point offset, and sync its text and shadow with the main label.

Design and build a fast-click game using Swift SpriteKit for iPhone, handling touch nodes, a ready-set-go timer, color-driven feedback, and a single-page interface.

Learn to implement a game timer, touch logic, scoring, and game over transitions in SpriteKit using Swift, including spawning squares, updating scores, and color customization.

Design a simple color-collecting game in Swift using SpriteKit, featuring spawning colors, a rotating animation, and touch-based color selection that ends when you pick the wrong square.

Learn to implement a falling blocks game in SpriteKit by spawning labels and a player, configuring physics bodies, handling touches, and color-changing gameplay.

Develop falling blocks using SKAction sequences to move, rotate, and destroy them, while spawning blocks on a timer and keeping the player at a fixed y-position.

Introduce random color blocks and color matching with the player to earn points, while implementing SpriteKit physics contact and color-based collision logic, plus a restart flow.

Learn to build a quick reflex game in Swift SpriteKit for iPhone, featuring tapping the white square, rotation, timers, scoring, and an orange, simple art style.

Randomize square colors with a dedicated function, animate changes using fade and rotation, and implement touch logic to update scores and reset the game in this SpriteKit tutorial.

Implement a countdown timer using SKAction and wait durations, apply a three-second grace, condition on is alive, update countdown variables, and reset the game with a crossfade transition.

Build a stroop-like color and word matching game in SpriteKit for iPhone with Swift, using arrays, randomization, timers, and touch input to process color and word cues.

Configure four spawn squares in Spryte kit, position them, and assign color and label logic for a color-matching challenge. Spawn and style the score and timer labels, with randomized colors.

Implement touch-based gameplay by handling touches began, identifying touched nodes, and triggering score updates, game over logic, a count down timer, and scene transitions.

Build a place-then-collect game in Swift using SpriteKit, swapping on-screen graphics with textures and colors, spawning blocks, handling touches, and updating the score with labels.

Build a four-square grid in Spryte kit, spawn the main score and timer labels, and implement randomized color logic to highlight the correct square while labeling and tweaking positions.

Implement touch handling and touch node logic to score points, trigger game over, manage a countdown timer, reset the game, and randomize colors and background for an engaging iOS game.

Build a memory-based game inspired by Simon, where you place blocks and collect a color that changes between colors, and avoid the wrong color, ending the game.

Create and manage multiple timers using SKAction in Swift, wiring starter, countdown, and placing timers with sequences, while updating game state variables and UI properties.

Develop and test placement and collection logic by tuning the placing timer, spawning blocks at random positions, removing collected blocks, updating the score, and changing colors to indicate collection.

Develop the ability to place the correct block and trigger game over, reset global variables, and use SpriteKit actions to restart the game.

Practice animating by rotating circles with repeated actions, resizing for aesthetics, and removing extras; then implement click-to-place logic using a coin-flip color (blue or orange) with white as the default.

Move objects across the screen to collect items in a single-page iPhone game, with color-changing touch interactions, basic physics and timers, and art created in Photoshop and Illustrator.

Learn to test a player, spawn collectibles on a timer with random x/y positions, configure physics bodies and contact detection, and implement touch-based movement and rotation for responsive gameplay.

Build a collect-squares game by adding physics, collisions, and did begin contact between player and collectibles, then implement scoring, a countdown timer, game over logic, and restart with scene transitions.

Create and export tech circle and round collectible art using Illustrator and Photoshop, integrate them into Swift and Xcode as sprite nodes, and experiment with colors and sizing.

Explore for loops as a tool to repeat tasks, then apply them to a Swift SpriteKit game that spawns and collects blocks, tracks score and countdown timer.

Spawn and position the goal and player, move the player with touches, handle physics contact to end the game on mine hits, update score, destroy and regenerate mines.

Implements game over logic for a mine-dodging game, resets variables and scene, updates UI, and introduces a challenge to randomly destroy mines or add one using a game state variable.

Build a simple whack-a-mole game that spawns good and bad blocks, tracks score, and explores color schemes and custom art in Adobe Illustrator for a Swift SpriteKit app.

Learn how to implement timed spawning of good and bad blocks in a SpriteKit game, manage countdown timers, touch interactions, scoring, and game over resets using SKAction sequences.

Polish a whack-a-mole game by creating mossy green tech circles, layering art with brushes, exporting as tech circle 12/13, and integrating assets in Xcode with exact image names.

Design and build a math educational game tailored to specific age groups. Engage the target market with appropriate difficulty and a simple app store-ready implementation.

Spawn and arrange color buttons, randomize colors, implement correct and incorrect color logic, and update the score as players tap the right color.

Spawn game items, set up color logic, and implement correct versus incorrect button behavior in a math educational game. Randomize colors, handle touches, and update the score to reinforce learning.

Create an endless gravity flip game for iPhone by implementing up and down gravity, setting up player, floor, and ceiling sprites, and wiring physics with SpriteKit.

Learn to implement a gravity flip game level by spawning floor and ceiling blocks with physics bodies, collisions, and timed blocks, including player setup, movement, and block reuse.

Develop and wire up NSK physics contact delegate and physics world contact delegate, implement collision logic for floor and ceiling blocks, and toggle gravity to create a gravity flipping game.

Adjust gravity flip mechanics by updating ceiling and floor blocks, collision masks, and dynamic behavior to unlock responsive gameplay, then fine-tune game over visuals and complete a flip challenge.

Spawn random orange blocks at random positions, collect them by touch to increase score, spawn multiple blocks, and reset the game with cleanup of extra blocks.

Build a color memory game for iPhone using SpriteKit, showing and memorizing colored blocks within a tunable time limit, with touch input, scoring, and game over on mistakes.

Learn to implement a color memory game by adding background and random colors, spawning blocks with for loops, and integrating countdown timers and color state logic in Swift-like code.

Implement color memory game mechanics by setting true colors, adjusting the flash timer and block size, handling touches for score updates, and wiring reset and game over logic.

Learn to build a mine-avoidance game in Swift with SpriteKit for iPhone, using drag controls and dynamic difficulty by destroying and respawning mines after each goal.

Configure a SpriteKit scene by creating a player sprite with a physics body, spawn random mines and a goal with a for loop, and display a score label for feedback.

Build and test a move blocks to goal game in Swift using SpriteKit, creating a player, top and bottom blocks, collectibles, labels, physics bodies, and spawn logic.

Move blocks to the goal through touch input, spawn collectibles, and manage updates and physics contacts to detect collisions and advance the game.

Implement collision logic to detect when a contact matches a collectible, update the score, remove the collectible from the scene, decrement collectible count, and add game over and reset sequences.

Explore how game mechanics and metaphor shape a SpriteKit game called follow the leader, where the leader drops pellets for the player to collect while avoiding obstacles.

Develop and place a leader and collectibles using SK label and sprite nodes, configure fonts, colors, and positions, and set up physics bodies with category and contact masks for interactions.

Spawn the leader and player, configure their physics bodies, and enable touch-driven movement. Use a timer and actions to spawn collectibles and block avoids along a leader path.

Spawn collectibles with a timer-based SKAction that controls drop speed and repeats. Configure SpriteKit physics by enabling the contact delegate and handling player, leader, and collectible collisions.

Add game over and reset functions, handle player and collectible collisions to increase score, remove blocks and collectibles, update score text, and restart the game scene with a transition.

Create a prototype SceneKit game in Xcode by building a scene with geometry and textures, adding a camera and lights, and exploring normal maps, shaders, and color lighting.

Learn to animate scene kit objects with run actions, including scale, rotate, and fade, and add tap gestures to interact with the ship and scene properties.

Explore Phasor, an HTML5 game framework, using the online playground to preload assets, render a sprite, and implement a WASD-controlled ship with a game loop and modular player controls.

Learn to build a Phaser game by enforcing on-screen borders, handling keyboard input for movement and shooting, spawning bullets, and managing game state with arrays and timers.

Implement a restart routine that destroys and recreates ships and bullets, then spawns enemies on a timer with random positions using physics and tweens while handling bullets and game over.

Implement collision detection by looping bullets and enemies, checking rectangle intersections, and destroying collided items while updating the score. Display game over at center, enable restart, and reflect score.