AGM Notes

2016 rewrite of selected items - easier than cutting and pasting snippets and trying to get them to make sense...

May 1st 1993- AGM held in Derby.
Hardware Officer position removed from Committee. Publicity position vacant.
Chairman: Trevor Stephens. Vice Chairman: Mark Wills. Gen Sec: Richard Twyning.
Membership: Alasdair Bryce. Treasurer: Alan Rutherford Editor: Gary Smith.
Libraries: Disk: Stephen Shaw. Cassette:Mark Wills Modules:Francesco Lama

Retiring officers: Nicky Goddard (cassette),Phil Trotter (Modules and Publicity), Alan Bailey (Editor)

The meeting decided the group would ONLY support the TI99/4a (and a bit of Geneve). An offer would be made to East Anglia and West Midlands groups for a combination of groups, with West Midlands continuing to organise its workshop meetings. It was noted the East Anglia group was suffering following the departure from our shores of Scott and JoAnn.

[On p37 of this issue it was noted by Alasdair Bryce regarding members comments that "a couple made known their displeasure at Stephen Shaw's 'Rambles' being muzzled." ]

The Chairman

From the Chairmans Chair - T Stevens 1993

I have again been busy arranging things. You will see that I have again produced this issue as our Editor, Alan BAILEY has now had to give up the job through ill health. I on behalf of all the committee and members thank you for what you have done for the club in the past years. It is very much appreciated. We now have a new Editor for the next issue. He is Gary SMITH. So if you look at the committee list you will see his details. Can you now send all your submissions to him.

There has also been other changes in the committee, so if you see the report on the AGM you will see who's who. and what's what.

Now onto the continued saga of Sprites. Up till now we have discussed quite a few new programming tricks. Here are a few more for you to get your computer round.

You have all heard of multi tasking. This is where the computer is able to carry on with two programs at once. lf you remember last issue we looked at how once a sprite is set into motion it goes off on its own without further program control. This means with sprites you can infact Multi Task by getting the computer to do more than one thing without loss of any speed.

The following program shows how you can put a moving pattern on the screen with sprites and also display print statements. You can if you like use 'display at', instead of 'print'. Try and experiment with the routine and see what else you can do with it. Try putting music to the sprites, change the sprite colours or what ever. If you make up something really spectacular send it into me.

50 RANDOMIZE :: CALL CLEAR
100 FOR N=1 TO 28 :: CALL SPR1TE(#N,42,2,N*6,N*2,0,N*4) :: NEXT N
110 PRINT "HELLO"
120 CALL DELAY(1000)
130 CALL CLEAR
140 PRINT "HELLO THERE!"
150 CALL DELAY(1000)
160 CALL CLEAR :: GOTO 110
170 SUB DELAY (D)
180 FOR A=l TO D
190 NEXT A
200 SUBEND

You will see from the example above how good your computer really is. It is in fact running, or multitasking 28 sprites and a display program all at once, with no loss of sprite positions which is important in this program for the effect.

We now move onto the problem of the Pacman syndrome Have you ever tried to program a sprite to pick up something and put it down? What we are going to do is bring together some of the programing tips that we have discussed into practice to show you what can be done. We will look at two bits of code. The first hot is issue is a simple version, the second which will be in next issue is a bit more complicated. So lets walk before we run.

In the first example your sprite will be set into motion according to an input from joystick 1. The program will check its position and place a block underneath it. You can if you wish put call key statements into the routine to replace that of the joysticks.

100 CALL CLEAR :: CALL SCREE
N(5) :: CALL CHAR(35, "F0F0F0F
0"') :: CALL SPRITE(#1,35,2,89
,121) :: CALL COLOR(1,1,11,2
7,7)
110 CALL JOYST(1,X,Y):: CALL
MOTION(#1,-Y*2,X*2) :: CALL
POSITION(#1,R,X):: IF R>188
THEN R=1-(Y>0)*187 :: CALL L
OCATE(#1,R,X)
120 CALL GCHAR(INT((R+7)/8),
INT((X+7)/8),Y):: IF Y=32 TH
EN CALL SOUND(-90,660,9) :: C
ALL HCHAR( INT( (R+7)/8),INT((
X+7)/8),40)
130 CALL KEY(1,X,Y):: IF Y T
HEN CALL CLEAR :: GOTO 110 E
LSE 110

NB If you have a Version 100 Extended Basic Cartridge change line 110 to CALL MOTION(#1,-Y,X)
To find your version of cartridge Type NEW then CALL VERSION(V) :: PRINT V

If we go through the program.
Line 100 clears the screen and then sets it to screen colour dark blue (5). The character 35 is then defined as a small block. Then the sprite #1 is defined as character 35 with the colour black. lt will be placed on the screen at dot row 89, dot column 121.

The color command then turns sets 1 and 2 so that set 1 is transparent on dark yellow and set 2 dark red foreground and the same on the background.

You will note that the space character is ascii 32. So when the set 1 is changed the space color turns dark yellow. So we have a yellow screen with a dark blue boarder.

After the set up in 100 we now go to 110. This commences a loop through 110 120 and 130. The line 110 sets the joystick routine in motion. (See previous artical for joysticks). Then the call position is called. This places in the variable R(Row) and X(col).

We can reuse the variable X but we must retain Y.

Return to page top

The if statement works like this:
IF R IS GREATER THAN 188 THEN IF Y IS GREATER THAN 0 (or stick pushed up), THEN R=188.

(The call locate relocates your sprite at the variables R and X, which now will be at the bottom of the screen.)
ELSE IF Y IS NOT GREATER THAN 0 (or stick pushed down), THEN R=1.
(The Relocate puts the sprite at the top of the screen).
ELSE IF R IS NOT GREATER THAN 188 THEN LEAVE R ALONE. Then do not relocate the sprite.

From Stephen Shaw

Hi everyone. Not much written by me this issue due to family illness, but a brief bit for you...

We will start with another graphics program, this time a RECURSIVE one. Our versions of Basic do not support recursion, but as long as there is enough memory we can stack up our subroutines, which is how this program operates.
Every time you GOSUB, the computer remembers where you left from UNTIL it returns, so lots of GOSUBS without any returns can end up with a MEMORY FULL error, but with a small program like this, we can stack up the GOSUBS far enough to produce a perfectly adequate recursive program:

--------> ------->
======

Return to page top

PROGRAMMING BASIC
Way back in TI*MES Issue 34, Autumn 1991, I gave a program that would add fractions, but not reduce the result (Listing One, below), and I asked 1f you could better it.
I also, in the same issue, gave a more complex program that would reduce the result (Listing Number Two, below).

These entries created the usual lack of response from the UK, but have stirred up quite a response from our overseas friends.
In MICROpendium March 1993 issue, Dean S Mah of Red Deer, Alberta gave some modifications to listing one- see listing three below, to be read in conjunction with list one.

Meanwhile one of our leading programmers has been attacking the problem from several angles- see listings four onwards.

Consider the problem. eg to add 11/13 to 17/32 etc and display the result as a fraction (some fractions cannot be displayed too well as a decimal!

Try to solve the problem.

Look at the various attempts below. Which program is the easiest to follow? Which program uses the least memory? And which program gives the fastest result? which of these three options would you prefer?

Now for the listings

==== ---->

========= -------> ------>


Return to page top

-----> ----->


---->


-----> ------->
========

LISTING SIX- modifications to listing 4 above
90 ON WARNING NEXT
290 REM 300 TN=N :: TL=L
310 FOR Y=2 T0 MIN(N,L)
320 IF N/Y>INT(N/Y)THEN 350
330 IF L/Y=INT(L/Y)THEN TN=N
/Y :: TL=L/Y
350 NEXT Y :: RETURN

=====

LISTING SEVEN
modifications to listing 4 above
90 ON WARNING NEXT
290 REM 300 FOR Y=2 TO MIN(N,L)
320 IF N/Y>INT(N/Y)THEN 350
330 IF L/Y=INT(L/Y) THEN N=N
/Y :: L=L/Y :: GOTO 300
350 NEXT Y :: RETURN

========
------->

There you have it. There are almost always MANY ways to tackle ANY programming problem. Some will be better than others because they are easier to follow OR use up less memory OR work faster. The programmer must decide his priorities and program accordingly.

So called programmers using macroassemblers with vast routine libraries already written tend to end up with programs which are hard to follow, hard to modify, are slow, and use up lots of memory, which is why PC users now tend to go for machines with 4MB of memory running at 32Mhz or more!

You don’t need all that if you know how to program.
And you can avoid using up 29k just to do a PRINT "HI"!
2016 update: A PC with 4MB of ram running at 32MHz - unimaginable today!

TIPS

Trevor Stevens:
TI WRITER
Have you ever tried to print out a multi document through the PF (print file) command, and suddenly realised that on page two of four there is a mistake. Or you want to print out only a paragraph, or perhaps save a line to disk without CR marks in them. Well you can. I have looked at the TI WRITER manual and can find no reference to the following command in it. I found it out by mistake when tried to save a file to disk.

What you do is take note of the line numbers (inclusive) that you want to print or save and then return to the E(dit) Mode, which is on the top line. Then type PF (Print file). You will then be presented with PI0 or RS232.300 or similar. In my Case I use PIO. You then back space over the PI0 to the begining of the entry field. Say you want to print line 20 through to 40, you will then type 20 40 PIO. Press return and the lines 20 to 40 are only transmitted to your printer and printed. For a single line type the single line number only. eg 20 PIO. Remember however to put the spaces between as given in the above examples. If you want it to disk, replace PIO with DSKN.FILE.

T I EXTENDED BASIC
Did you know that you can chain link cassette programs? What is chain link you may ask, well it is where you can write a basic program from which can load and run another program from your cassette recorder. When this happens the original is over written and the new one then replaces the old and then runs. You must however be at the begining of the program on the tape for this to happen. You do this with the RUN command. If you branch in your program to RUN "CS1" you will pe able to chain for as long as you like. This can increase memory storage. The only down side is that tape takes a long time to load.
DEMO to the above TIP
100 CALL CLEAR
110 PRINT "THIS IS PROGRAM 1"
120 FOR A=1 T0 1000 :: NEXT A
130 RUN "CS1"
Save this to tape first, then type NEW and enter the next program. Save this but DO NOT rewind the tape before you save. The second program should follow the first program on the tape.

100 CALL CLEAR
110 PRINT "THIS IS PROGRAM 2"
120 FOR A=1 TO 1000 :: NEXT A
130 PRINT "FINISHED"

Now rewind the tape to the start, OLD the first program, stop the tape and RUN the first program. When prompted DO NOT rewind the tape, pass on to the PLAY stage which should load the second program and run it.

c99 by Mark Wills

c99 for the slightly more initiated!

The IF command
Users of BASIC will be aware of the IF command which allows the computer to make a decision and execute a series of instructions according to the result of the decision. (Always either true or false).

In basic, the IF command takes the form :
IF expression THEN instruction(s)
ie IF A=4 THEN P=0
As you can see, P will equal zero when the expression evaluates to true. ie when A=4

c is very similar but its syntax is different:
if (expression) instruction;
or
if (expression) {
multiple instructions;
multiple instructions;
}

So taking the first c example above and replacing it with some actual c code:
if (a=4) p=0;
is the equivalent c way of saying the same as the BASIC statement above.

The second c example is as follows
if (a==4) {
p=0;
t=44;
z=(p+2)*t;
etc...;
}

The above example is called a "block if" because there is a "block" of code (the code between the curly brackets - or braces to give them their proper name) which is executed every time the condition inside the brackets evaluates to true.

There are a few rules and regulations we need to make clear when using if's relating to their syntax, just to clear up any confusion:

A single if
The expression to test must be enclosed inside brackets
The statement to execute in the event of the expression evaluating to true must terminate with a semicolon. (;)

Block if’s
Again, the expression to test must be enclosed within brackets.
The beginning of the code block must be indicated with an open brace ( { ). The end of the code block must be indicated with a closed brace ( } ). All statements inside the code block must be terminated with a semicolon (;) - as indeed all c statements must do.

Relational operators
This is probably a good time to discuss the difference between c's relational operators and BASIC’s, as they are different. A simple list will clarify the differences better than I can so.
Description:.......... c99 form: BASIC version
Is equal to ?............= = ...........=
Is not equal to ?........!= ...........<>
Is greater than ?.........> ............>
Is less than ? ...........< .........<
Is greater than or equal...>= ..........>=
Is less than or equal to...<= .........<=
Is not greater than ?......!> ...........note
Is not less than ? ........!< ........note
Comparative AND ............&& ..........none
Comparative OR..............|| ..........none

NOTE* Is not greater than, and is not less than is not really directly supported in TI-BASIC, so in order to express an equivalent expression in TI-BASIC you would say "is LESS than x" or "is GREATER than x" where x is the value you are testing, respectively.

Comparative AND and OR, which again is not DIRECTLY supported, allows you to mix multiple expressions in the same test. Example:
if(a= =4 && b= =2) p=41;
p will be set to 41 when a= =4 AND h= =2

if(a= =21 || z= =1) x=2;
x will be set to 2 when a= =21 OR z= =1
NOTE: For clarity above == is shown as = = but there should be no space between the two equals signs.
I guess thats if's more or less covered, except to say that you can call another part of your program (a function) with an if like this:
if(a= =4) game_over();

will call the game_over routine when a= =4. This of course can be done with code blocks:
if (a==4) {
score=score+1000;
game_over();
}

If's and if code blocks can also be nested:
if(a=2) {
if (b=2) game_over();
}

Also, you can use the ELSE clause, like in basic
IF A=1 THEN Z=2 ELSE Z=3
is
if (a=1) z=2; else z=3;


Return to page top

Note also c is case SENSITIVE. So a in this program:
main()
{
int a;
int A;
a=a+1;
A=A+1;
}
a and A are treated, unlike BASIC, as completely seperate variables in thier own right.

A quick aside here, the lines a=a+1 and A=A+1 can be re-written as
a++
A++
This in c says increment by one, and generates smaller code (and faster) than doing it the long way. You can also decrement by one:
a--;
A--;
Will decrement the two SEPERATE varaibles a and A by one each. Those of you who know machine code will spot that the compiler can use the INC and DEC instructions rather than A and S instructions which require operands and thus is larger and slower. Whenever you need to add or subtract one, you should use this method.

The while Loop
Another powerful and easy to use method of controlling program flow is the while loop. It looks like this:
while(expression) do something;
while(expression) {
do loads of things....;
}
In the while loop, a command or block of code can be executed for as long as a particular condition is true. Or, put another way, code can be made to execute WHILE the test condition is true, let's look at an example:
#include dsk1.conio
#asm
REF PRINTF
#endasm
main()
{
int a;
a=0;
while(a<100) printf("a is %d",a++);
}

Lets go through this program line by line and work out what the program does.
#include dsk1.conio
This line, tells the compiler to include the file conio when compiling. It contains certain defined variables that you may refer to in your programs - we’re not using any here but its good practice to get into the habit of including it all the file.

#asm
This line tells the compiler that all lines up until #endasm are "raw machine code" and not to alter them in any way, just to pass them straight on to the source file for assembling. In this case all we are passing is a REF to the assembler because we will be loading the PRINTF file at runtime because we are using the PRINTF command to display the contents of our variable a.

  REF PRINTF
As just mentioned, this line is passed un-modified through to the assembler source file in. Note that there is a space before the REF It is IMPORTANT!

#endasm
Tells the compiler that we have finished passing machine code through to the assembler source file.

main()
This indicates the beginning of the function called Main. Remember that all c programs start and end in main()

{
The open brace means that all code is intended for the function called main.

int a;
This line tells the compiler to reserve space for an integer variable called a.

a=0;
Sets the variable a to zero

while(a<100) printf("a is %d",a++);
This line looks at the value of a. If a is less than 100 (ie the expression is true) then the value of a is printed on the screen, and then increased by one for the next time round (the ++). The %d in the printf command means that the operand following the comma is to be treated as an integer, which we defined before (int a;)

Eventually, a will become 100 and the expression in the brackets (a<100) will evaluate to false. At this point control is passed to the next line of the code, which, in our case, is the end of the main() function, so the program simply stops.

}
Tells the compiler that we have finished our code for the main function, and, in this case, finished altogether!

The other technique worth a mention, and the final one for this issue is the do/while loop:
The do/while Loop:
Another very powerful way of controlling program flow/iteration, it looks like this:

do{
various things;
} while(expression);

You may wonder what the difference is, well, the difference is that the code inside the curly braces will ALWAYS be executed at least once. because the expression is tested at the END of the code block

This is a very handy method for implementing things like menus, where you put a number of options to select from, one of them being quit. If the user presses quit, the program flow will fall out of the bottom of the do/while loop because the test expression is testing for the quit key being pressed. Handy and efficient.