Gob

Summary

A Gob is a sprite: an image drawn at x,y (exact position fx,fy, doubles, since V3.2), size width,height, depth z. It can follow a Spline (attach / detach), takes part in collisions (COLLIDE_AT_END Spline or the GOB_COLLISION_OUTLINE flag), orbits a parent and carries the flag words gobFlags, gobFlags2, gobEventFlags.

V3.23: rotation, physics and picking

• Rotation: setAngle(radians) / setAngleDegrees / rotateBy. The angle is in radians, positive = clockwise on the screen, about the centre of the drawn rectangle. Angle 0 is exactly the old drawImage path. Otherwise the Gob is drawn with a Graphics2D transform, ROTATE_BILINEAR (default, smooth alpha edges when the art has a transparent margin) or ROTATE_NEAREST (setRotateInterpolation). The collision outline turns with it and still scales with z (GobGeometry).
• Physics: setPhysics(mass,restitution,response) makes a Gob physical (mass > 0 and response RESPONSE_BOUNCE or RESPONSE_STOP). vx,vy are in pixels per physics step (one per display frame, or per real time with CollisionManager.realTimeStep). BOUNCE: impulse with restitution (momentum is conserved between moving Gobs; 1 = elastic, 0 = they go on together). STOP: “ball in sand”, the Gob halts where it touches and is immovable for the partner. No mass and no response = the old V3.22 flag-only behaviour, nothing changes.
• Hit points: setHitPoints(n); each impact costs 0.5 * reduced mass * closing speed^2 * damageScale * damageFactor; at 0 the Gob explodes (onExplode(from) may handle it, e.g. the Asteroids break-up into 5 to 12 pieces; otherwise a CollisionAnimGob plays and the Gob is removed).
• Spline and physics together: a Gob with a Spline is driven by the Spline until its first bounce or stop; its velocity is measured from the path so it hits with that momentum. Then the physics owns it (isPhysicsOwned()): the Spline stays attached but is not stepped. resumeSpline() gives control back (the Gob jumps to the Spline's current point); setVelocity() takes over at once; setPhysicsMotion(false) lets the application move the Gob while the pass still resolves contacts.
• Picking: containsPoint(x,y) (bounding rectangle of the turned sprite, polygon, alpha mask for outline-flag Gobs), setPickable, setPickAlpha, hooks onPick / onSelect / onDeselect, isSelected(). See HyperView.pickGob().

Source file: Gob.java

Hierarchy

Extends: Linkable

Implements: HyperConstants, TextConstants

Referenced HyperView classes

• Binary
• Gadget
• HyperConstants
• HyperView
• Linkable
• Scanline
• Spline
• SplineConstants
• TextConstants
• ViewMain

Media files used

• none referenced

Following a Spline (V3.2): attach / detach, floating point position

A Spline is added to a Gob with attachSpline(s) (setSpline is the same; addSpline is the old name and the two Spline constructors use it). It sets GOB_SPLINE_ENA, puts the Gob on the first point of the path, resets the Spline and, for SP_ZBUFFER_ENA, does gobZInit() and sets ZBUFFER_ENA. getSpline() returns it (null when none); detachSpline() clears GOB_SPLINE_ENA and lets go: the Gob stays exactly where it is (position, size, z-buffer state), the Spline is returned, not cleaned up, and can be attached again (it restarts). A Spline belongs to one Gob: attaching it to a second Gob throws IllegalStateException; attaching another Spline to a Gob replaces (releases) the first; attachSpline(null) detaches.

Movement comes from the Spline. HyperView.run() calls Spline.step(gob) once per display frame; the Spline advances its distance by speed pixels along the curve and the Gob’s exact position is written with setFloatPosition(fx,fy). fx,fy,fz are doubles (getFloatX, getFloatY, getFloatZ); the integer x,y,z used for drawing, bounds and collisions are those rounded (floor(v+0.5)) and x2,y2 follow. A speed of 0.35 px/frame therefore moves x only every third frame while fx changes every frame. move(int,int) sets both. When STOP_AT_END is reached the Spline releases the Gob (spline becomes null) on the end point.

Collision outline & flags (COLLIDE_AT_END, GOB_COLLISION_OUTLINE)

A Gob takes part in the collision pass that HyperView.collisionPass() runs once per display frame (CollisionManager.collide()) if takesPartInCollisions(): its Spline has COLLIDE_AT_END (collidesAtEnd()) or it has the flag GOB_COLLISION_OUTLINE (gobFlags2, 0x800; isImageOutlineEnabled()). The two are independent:

• COLLIDE_AT_END is a Spline end mode: what the Gob does at the end of its path (stay there, attached) and, as before, it makes the Gob a participant. It does not compute anything.
• GOB_COLLISION_OUTLINE is a Gob flag: “compute and use an outline from my image”. It also makes the Gob a participant, with or without a Spline (a stationary Gob will do). Set it with setImageOutlineEnabled(true). The image outline is computed only for Gobs with the flag, once, by OutlineTracer, the first time the pass sees the Gob with a loaded image (or at once with computeImageOutline()). While the image is still loading the flagged Gob is not tested (so it can not collide with the wrong shape). Gobs without the flag never cost anything: getOutlineComputeCount() does not move for them.

The outline used is, in this order: 1. a polygon set by hand with setOutline() (it wins; with the flag set the image is then not traced); 2. the traced image outline (alpha >= outlineAlphaMin 128, outer contour only, holes ignored, Douglas-Peucker outlineEpsilon 1.0, at most outlineMaxPoints 48 points; if the largest piece is too thin, its bounding box; several pieces: the largest); 3. the bounding box x,y .. x+width-1,y+height-1 (a fully transparent image keeps it; AnimGobs are not traced). The outline is in image pixels, moves with the Gob and is scaled by width/widthBase when the Gob is z-buffered; it is never rotated.

On contact both Gobs get GOB_COLLIDED (cleared in the first frame without contact), collisionX/Y; a new contact also bumps collisionCount, sets collidedWith and adds a CollisionAnimGob. Nothing is stopped or removed. Members: collidesAtEnd, takesPartInCollisions, setImageOutlineEnabled, isImageOutlineEnabled, computeImageOutline, hasImageOutline, invalidateImageOutline, getImageOutlineRawPoints, setOutline, clearOutline, hasOutline, getOutline, getWorldOutline, isCollided, getCollisionCount, getCollidedWith, clearCollision.

Declaration & members

public class Gob extends Linkable implements HyperConstants, TextConstants

Declared in src/com/multiversesocial/hyperview/Gob.java, lines 1–2248. 153 field(s), 15 constructor(s), 119 method(s). Every member has an anchor you can link to (e.g. Gob.html#<id>).

Fields (153)

Constructors (15)

Methods (119)

Inherited members

Non-private members inherited from HyperView superclasses and not overridden or hidden here.

From Linkable (7 fields, 2 methods)

Fields: attachment, index, linkFlags, name, next, parentList, prev

Methods: inList(), setName(String)

Examples

Real usage taken from elsewhere in the HyperView 3.2 source (file and line shown; source path src/com/multiversesocial/hyperview/).

instantiation — MegaMooV.java, line 87

   87  new Gob(curView,"ea2.gif",46,47,sp2,0);

subclass — AnimGob.java, line 6

    6  public class AnimGob extends Gob implements AnimationConstants, HyperConstants
    7  {

declaration — Abort.java, line 8

    8  Gob destroyGob;