Building a game in SpriteKit, I used SKFieldNode.radialGravityField() with negative strength to simulate a positive charge's electric field. To visualize the fields and their interaction, I used SKView.showFields property and it was working fine.
Now, trying to implement a negative charge, I tried switching all fields to SKFieldNode.electricField(). The behavior of the fields and particles (attraction and repulsion) continued to work perfectly, but the visual representation created by showFields stopped working.
Investigating, the visual representation worked only for radialGravityField and did nothing for all other SKFieldNode options. I tried changing the fields' strength but couldn't reach anything. In addition to the fields physics working fine, I looked for the fields magnitude using SKPhysicsWorld.sampleFields(at:) and they were correct.
Example
Based on XCode's default project for iOS game, this GameScene below can reproduce the behavior. Changing from SKFieldNode.radialGravityField() to SKFieldNode.electricField() makes the fields not show up.
import SpriteKit
import GameplayKit
class GameScene: SKScene {
private var fieldNode : SKFieldNode?
override func didMove(to view: SKView) {
view.showsFields = true
self.fieldNode = SKFieldNode.radialGravityField() // Change field type here
if let fieldNode = self.fieldNode {
fieldNode.strength = 2
}
}
func touchDown(atPoint pos : CGPoint) {
if let n = self.fieldNode?.copy() as! SKFieldNode? {
n.position = pos
self.addChild(n)
}
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
for t in touches { self.touchDown(atPoint: t.location(in: self)) }
}
}
Related
I am pretty new to SpriteKit so I may be missing something quite obvious.
I am attempting to create an interactive map of the US. I have loaded PNG images for each state and placed a couple of them into the main SKScene using the scene editor.
My goal is wanting to detect when each state is tapped by the user. I initially wrote some code that would find the nodes within a touch location however, this meant that the user could tap the frame and it would be counted as a valid tap. I only want to register touches that happen within the state texture and not the frame. Reading online it was suggested to use SKPhysicsBody to register when a tap takes place. So I changed my code to the following.
class GameScene: SKScene {
override func didMove(to view: SKView) {}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
guard let touch = touches.first else { return }
let location: CGPoint = self.convertPoint(fromView: touch.location(in: self.view))
let body = self.physicsWorld.body(at: location)
if let state = body?.node, let name = state.name {
state.run(SKAction.run({
var sprite = self.childNode(withName: name) as! SKSpriteNode
sprite.color = UIColor.random()
sprite.colorBlendFactor = 1
}))
}
}
override func update(_ currentTime: TimeInterval) {
// Called before each frame is rendered
}
}
Now, if I choose the Bounding circle body type everything works as expected (shown above in the screenshot). When I click within the boudning circle it runs the SKAction otherwise it does nothing. However, when I change the body type to Alpha mask (the body type I want) it suddenly stops detecting the state. In fact, it returns the SKPhysicsBody for the MainScene entity.
Any advice on how to fix this would be greatly appreciated.
Thanks.
i can reproduce this behavior (bug?) when using the scene editor. however it goes away if you skip the sks file and initialize your sprites in code. (i acknowledge that setting locations for 50 states is more tedious this way.)
class GameScene: SKScene {
let ok = SKSpriteNode(imageNamed: "ok")
let nm = SKSpriteNode(imageNamed: "nm")
let tx = SKSpriteNode(imageNamed: "tx")
override func didMove(to view: SKView) {
tx.name = "Texas"
nm.name = "New Mexico"
ok.name = "Oklahoma"
//set up physics bodies w/ alpha mask
tx.physicsBody = SKPhysicsBody(texture: tx.texture!, size: tx.texture!.size())
tx.physicsBody?.affectedByGravity = false
nm.physicsBody = SKPhysicsBody(texture: nm.texture!, size: nm.texture!.size())
nm.physicsBody?.affectedByGravity = false
ok.physicsBody = SKPhysicsBody(texture: ok.texture!, size: ok.texture!.size())
ok.physicsBody?.affectedByGravity = false
//then position your sprites and add them as children
}
}
I'm attempting to create an overlay in SpriteKit which by using an SKSpriteNode. However, I want the touches to pass through the overlay, so I set isUserInteractionEnabled to false. However, when I do this, the SKSpriteNode still seems to absorb all the touches and does not allow the underlying nodes to do anything.
Here's an example of what I'm talking about:
class
TouchableSprite: SKShapeNode {
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
print("Touch began")
}
}
class GameScene: SKScene {
override func sceneDidLoad() {
// Creat touchable
let touchable = TouchableSprite(circleOfRadius: 100)
touchable.zPosition = -1
touchable.fillColor = SKColor.red
touchable.isUserInteractionEnabled = true
addChild(touchable)
// Create overlay
let overlayNode = SKSpriteNode(imageNamed: "Fade")
overlayNode.zPosition = 1
overlayNode.isUserInteractionEnabled = false
addChild(overlayNode)
}
}
I've tried subclassing SKSpriteNode and manually delegating the touch events to the appropriate nodes, but that results in a lot of weird behavior.
Any help would be much appreciated. Thanks!
Reading the actual sources you find:
/**
Controls whether or not the node receives touch events
*/
open var isUserInteractionEnabled: Bool
but this refers to internal node methods of touches.
By default isUserInteractionEnabled is false then the touch on a child like your overlay SKSpriteNode is, by default, a simple touch handled to the main (or parent) class (the object is here, exist but if you don't implement any action, you simply touch it)
To go through your overlay with the touch you could implement a code like this below to your GameScene.Remember also to not using -1 as zPosition because means it's below your scene.
P.S. :I've added a name to your sprites to recall it to touchesBegan but you can create global variables to your GameScene:
override func sceneDidLoad() {
// Creat touchable
let touchable = TouchableSprite(circleOfRadius: 100)
touchable.zPosition = 0
touchable.fillColor = SKColor.red
touchable.isUserInteractionEnabled = true
touchable.name = "touchable"
addChild(touchable)
// Create overlay
let overlayNode = SKSpriteNode(imageNamed: "fade")
overlayNode.zPosition = 1
overlayNode.name = "overlayNode"
overlayNode.isUserInteractionEnabled = false
addChild(overlayNode)
}
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
print("GameScene Touch began")
for t in touches {
let touchLocation = t.location(in: self)
if let overlay = self.childNode(withName: "//overlayNode") as? SKSpriteNode {
if overlay.contains(touchLocation) {
print("overlay touched")
if let touchable = self.childNode(withName: "//touchable") as? TouchableSprite {
if touchable.contains(touchLocation) {
touchable.touchesBegan(touches, with: event)
}
}
}
}
}
}
}
You need to be careful with zPosition. It is possible to go behind the scene, making things complicated.
What is worse is the order of touch events. I remember reading that it is based on the node tree, not the zPosition. Disable the scene touch and you should be seeing results.
This is what it says now:
The Hit-Testing Order Is the Reverse of Drawing Order In a scene, when
SpriteKit processes touch or mouse events, it walks the scene to find
the closest node that wants to accept the event. If that node doesn’t
want the event, SpriteKit checks the next closest node, and so on. The
order in which hit-testing is processed is essentially the reverse of
drawing order.
For a node to be considered during hit-testing, its
userInteractionEnabled property must be set to YES. The default value
is NO for any node except a scene node. A node that wants to receive
events needs to implement the appropriate responder methods from its
parent class (UIResponder on iOS and NSResponder on OS X). This is one
of the few places where you must implement platform-specific code in
SpriteKit.
But this may not have always been the case, so you will need to check between 8 , 9, and 10 for consistency
I'm trying to implement the "3d" audio Apple has added to SpriteKit, but the sounds really don't seem to be positioned at all, even with headphones on. Here's my relevant code.
Play Sound function:
func playTapSound(node: SKNode) {
let tapSound = SKAudioNode(fileNamed: "glassNote")
tapSound.positional = true
tapSound.autoplayLooped = false
node.addChild(tapSound)
tapSound.runAction(SKAction.play())
}
Game Scene:
let listenerNode = SKNode()
...
override func didMoveToView(view: SKView) {
listenerNode.position = view.center
listener = listenerNode
}
playTapSound gets called if the user taps a game piece node.
override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
let touchedNode = scene.nodeAtPoint(sceneTouchPoint)
playTapSound(touchedNode)
}
I've checked the positions of all the nodes including the listener node and they're all correct. Listener node is in the center of the screen and the game pieces are basically a checkerboard layout.
When I tap a piece, I really can't tell there's any sort of positioning on the audio. Is it just extremely subtle? Can't find much info out there about it except Apple saying it's part of SpriteKit..
Turns out my mistake was not adding my listenerNode to the scene before setting it to the listener.
From the docs on listener:
If a non-nil value is specified, it must be a node in the scene.
Game Scene updated and verified:
let listenerNode = SKNode()
...
override func didMoveToView(view: SKView) {
listenerNode.position = view.center
addChild(listenerNode)
listener = listenerNode
}
I'm creating a game for ios using swift. I've implemented the component entity system from Apples GameplayKit, very similar to how shown in this tutorial.
I have added a grid of squares which I want to respond differently to tap gestures. I will change a game state using state machine when a UI element is tapped, but I also want to then change how each square reacts to a tap gesture. From my current limited understanding, the best way to do this is change the tap gesture delegate. However, I've not been able to find any simple examples of how this can be done. The sqaures are SKSpriteNodes.
Code is available on request; however, I'm looking for an out of context example of how this could be done in the simplest way.
Does anyone know how this can be done or can suggest a "better" way. To avoid subjectivness, I'm defining better as structured better in terms of architecture. (Multiple if statements in a single gesture handler seems like the wrong way to do this, for example.)
I have found a working solution to my problem based on various bits of help and ideas I've had, however I'm still very much open to alternative solutions.
The main issue this probleme presnted, is how to reference back to the entity from the spritenode.
Through reading the documentation on SKSpriteNode, I discovered that it's parent class SKNode has a userData attribute, which allows you to store data in that node.
Attaching the entity instance to the node needed to happen in the SpriteComponent, as that is where the node is constructed, however it cannot happen in the constructor,so it had to be in a function in the SpriteComponent.
func addToNodeKey() {
self.node.userData = NSMutableDictionary()
self.node.userData?.setObject(self.entity!, forKey: "entity")
}
Then the function is called in the Enity class construction after adding the compoennt to itself.
addComponent(spriteComponent)
spriteComponent.addToNodeKey()
Now the Enity instance can be accessed from the touch event, I needed a way to perform a function on that instance, however you don't know if the instance will be a subclass of GKEntity or not, nor which type.
Therefore, I created another component, TouchableSpriteComponent. After some trying, the init function took a single function as its argument, which is then called from the scenes touch event, which allows the entity which created the TouchableSpriteComponent to define how it handles the event.
I created a gist for this solution, as there's probably too much code to place here. It is a permilink.
I'd really love to know if this is a "good" solution, or if there's a much clearer route which would have the same effect (without looping through all the entities or nodes).
If I understod well, you should have something like:
func entityTouched(touches: Set<UITouch>, withEvent event: UIEvent?)
in your GKEntity subclass.
I do this in my game:
class Square: MainEntity {
override func entityTouched(touches: Set<UITouch>, withEvent event: UIEvent?) {
//DO something
}
}
GameScene:
override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
super.touchesBegan(touches, withEvent: event)
let touch = touches.first!
let viewTouchLocation = touch.locationInView(self.view)
let sceneTouchPoint = self.convertPointFromView(viewTouchLocation)
let touchedNode = self.nodeAtPoint(sceneTouchPoint)
let touchedEntity = (touchedNode as? EntityNode)?.entity
if let myVC = touchedEntity as? MainEntity {
myVC.entityTouched(touches, withEvent: event)
}
where:
EntityNode:
class EntityNode: SKSpriteNode {
// MARK: Properties
weak var entity: GKEntity!
}
SpriteComponent:
class SpriteComponent: GKComponent {
let node : EntityNode
init(entity: GKEntity, texture: SKTexture, size: CGSize) {
node = EntityNode(texture: texture, color: SKColor.whiteColor(), size: size)
node.entity = entity
}
}
MainEntity:
class MainEntity: GKEntity {
var entityManager : EntityManager!
var node : SKSpriteNode!
//MARK: INITIALIZE
init(position:CGPoint, entityManager: EntityManager) {
super.init()
self.entityManager = entityManager
let texture = SKTexture(imageNamed: "some image")
let spriteComponent = SpriteComponent(entity: self, texture: texture, size: texture.size())
node = spriteComponent.node
addComponent(spriteComponent)
}
func entityTouched (touches: Set<UITouch>, withEvent event: UIEvent?) {}
}
Let me know if was what you are looking for.
I've two classes in separate files.
In the "main" file, where my scene is, I'm calling this function:
override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
/* Called when a touch begins */
for touch in touches {
character().spawnCharacter()
}
}
So, in my second file, character.swift I've this code:
import SpriteKit
public func spawnCharacter() -> SKSpriteNode{
let charNode = SKSpriteNode(imageNamed: "Hero")
charNode.name = "Hero"
charNode.postion = CGPointZero
charNode.zPosition = 3
addChild(charNode)
print("Node added")
return charNode
}
So, the print line is printed, but the node is never added.
I've been over my code a couple of times, but I can't crack it.
Any clues?
I am not entirely sure how your main file is organised, but I think the problem is here:
for touch in touches {
character().spawnCharacter() // <- SKSpriteNode is created but not added
}
You create sprite-node in spawnCharacter() but you do not use the returned object.
Potential fix would be:
for touch in touches {
let character = character().spawnCharacter()
scene.addChild(character)
}