Help For The Clueless - Where To Start?

Question

Let's say, hypothetically, that I have no programming
experience beyond writing a random number generator in basic on my
Commodore 64 back in 1984. Let's pretend that I haven't the
slightest understanding of Javascript and only a handful of basic
HTML tags in my programming arsenal. Imagine that I have no real
idea of the method or syntax of any modern programming language.
Where would I even begin to learn how to apply ActionScript to my
Flash project?
I have plenty of animation and design experience, am
extremely familiar with AfterEffects, Carrara and other
timeline-based animation programs, and am fairly intelligent, but
almost every "basic" Flash ActionScript resource I find online
seems to assume that I have a basic understanding of computer
programming. I need something that tells me how to "speak" AS3 -
what a bracket means as opposed to a parenthesis, what a "string"
is and how it's used, what's an "event handler", etc.
Can anyone recommend the best way for a non-programmer to get
a grasp on the basics? If I could learn those, I'm pretty sure I
could figure out much for myself. My sincere thanks in advance for
any advice.
PS - What's got me skeered is that I went online to find out
how to make a text box populate one letter at a time as if it was
being typed. It would seem such an effect would be pretty popular
and thus have an easy mechanism built in to accomplish it. The
answer I got pointed to a huge page of code that was entirely
cryptic to me. Is this pretty much what I'm in for?

Answer 1

Doyle,
> Can anyone recommend the best way for a non-programmer
> to get a grasp on the basics [of ActionScript]? If I
could learn
> those, I'm pretty sure I could figure out much for
myself.
The big break-through for me was when I was able to wrap my
head around
the concept of objects. In short, everything of useful value
in
ActionScript is an object. Movie clip symbols, button
symbols, text fields
... those are objects. But even nontangible (or only vaguely
tangible)
things, like math functions, glow effects, today's date ...
those are
objects too.
They have characteristics, such as a movie clip's width and
height, its
x and y position on the stage. They have things they can do,
such as
play(), stop(), gotoAndPlay(someFrameHere). They have things
they can react
to, such as a mouse click.
Characteristics are called properties. Things an object can
do are
called methods. Things an object can react to are called
events. Generally
speaking, you'll find these three categories (as applicable)
in the class
entry for every object in the documentation.
Objects are defined by something called a class, which is
basically a
recipe or blueprint for the object in question. Movie clips
are defined by
the MovieClip class, text fields by the TextField class, and
so on. The
date/time is defined by the Date class. Arrays (lists of
things) are
defined by the Array class. There's a math class for math
methods, a String
class for strings (collections of characters), and countless
more. Some
classes work in groups (consider the Sound, SoundChannel, and
SoundTransform
classes).
So when you're considering how to accomplish a given goal,
consider
first what object you're dealing with. Is it a text field
(what you were
calling a text box)? Check out the TextField class. Your next
question is,
What aspect of this class am I intereted in: property
(characteristic),
method (thing it can do), or event (thing it can react to)?
Like us, classes take advantage of inheritance. I'm a human,
but I'm
also a mammal, and I'm also a vertibrate, etc. The closer you
get to the
branches of the family tree (i.e., the human side), the more
specific it
gets. For example, there's no reason for the Human class to
describe
spines, because that's already covered by the Vertibrate
class. That said,
humans *do have* spines, so when you look up the Property,
Method, and Event
headings of a given class entry, make sure to click the "Show
Inherited
Properties / Methods / Events" hyperlinks to see the full
functionality
available to that class.
The TextField class, for example, features an alpha property
(transparency) that it inherits from the DisplayObject class.
From that
same branch of the family tree, text fields also inherit
their x and y
properties, which makes sense: clearly, text fields can be
positioned at
any number of (x,y) coordinates on the Stage. TextField also
has a text
property, which indicates the text content displayed by that
text field
(that property isn't inherited).
If you look up the methods for that class, you'll find a
setTextFormat()
method, which is something an instance of this class can do:
it can set the
formatting (visual style) of the text it contains. As you dig
deeper,
you'll find a TextFormat class, and so on. Everything is an
object. :)
Events include mouseOver, mouseOut, keyDown, keyUp, and
more. If you
want something to happen when the user types into this text
field, you might
write an event handler (a custom function) and associate it
with the keyDown
event.
I'm giving you a high-level gloss, obviously ... but when I
finally
grasped the organization of the Help docs ... it made all the
difference.
If you're creating objects with code, you'll do what's
called
"instantiating and object," or "creating an instance" of that
object. Could
be like this:
var myTextField:TextField = new TextField();
At this point, the variable myTextField is an instance of
the TextField
class. You use that variable as a "nickname" or "handle" to
the object you
just created. If you want to add text to your new text field,
you reference
it by its instance name and set the TextField.text property
of that
instance:
myTextField.text = "Now I actually say something.";
If you want to positiion it somewhere in reference to the
timeline or
object in which it resides (might be the main timeline, for
example) ...
myTextField.x = 50;
myTextField.y = 100;
And to make it show up on the Stage, you have to add it to
the display
list. This is a new concept in ActionScript 3.0, but it's
easy to do. You
just invoke the DisplayObjectContainer.addChild() method on
whatever
DisplayObjectContainer instance you want -- on whatever
object should be the
container of, in this case the text field.
As it turns out, the main timeline is an instance of the
MovieClip
class, and MovieClip inherits from DisplayObjectContainer, so
it features
that method. Assuming this code appears in a keyframe of the
main timeline,
you can get your reference with the word "this" (sans
quotes):
this.addChild(myTextField);
or you can just drop the "this," because Flash understands
that your point
of view (your "scope") is currently the timeline in which the
code appears:
addChild(myTextField);
Obviously, you can also create some objects (like text
fields) with the
drawing tools (e.g., the Text tool). In that case, you don't
need to
instantiate the object, because it's already there. But you
*do* need to
give it an instance name, which you do by selecting that
object on the Stage
and giving it a name in the Property inspector. You'll
typically do this
with movie clips, text fields, and components.
Other classes are more abstract than that. There's a Tween
class, for
example, that allows you to programmatically create tweens.
There's a
String class for creating strings.
... I could go on, and so could many of the other regulars
on this forum
(and I hope they do). But I hope that at least gives you a
start. I've got
a fairly popular blog on various Flash topics (mostly AS2,
just by
historical happenstance), but that might help you out a bit.
http://www.quip.net/blog/
If you're a book learner (I am), you'll find a number of
book books on
the topic. Just make sure to read your Amazon reviews (even
if you buy
elsewhere) and make sure you're getting a book that talks
about ActionScript
in this sort of object-oriented approach.
David Stiller
Co-author, Foundation Flash CS3 for Designers
http://tinyurl.com/2k29mj
"Luck is the residue of good design."