SparrowOSTS_121127.ISO
This commit is contained in:
Terry A. Davis authored and minexew committed
1 parent
0e9364ff4c
commit
e57428affb
1218 files changed
+247142
-165507
No files matched your search
@@ -0,0 +1,9 @@
|
||||
#include "/SparrowOS/Accts/Adam3bPkgs"
|
||||
|
||||
#include "/SparrowOS/Apps/TimeClock/Load.CPP.Z"
|
||||
#include "/SparrowOS/Apps/MusicOrgan/Load.CPP.Z"
|
||||
Cd("HOME");;
|
||||
#include "/SparrowOS/Accts/TS/TSAdam"
|
||||
#include "/SparrowOS/Accts/TS/TSDistribute"
|
||||
#include "/SparrowOS/Demo/WebLogExample/WebLogRep.CPP.Z"
|
||||
Cd("HOME");;
|
||||
@@ -0,0 +1,266 @@
|
||||
//Change anything you want in this
|
||||
//acct file or others.
|
||||
|
||||
U0 FillInTime()
|
||||
{
|
||||
CDate ltdt;
|
||||
ltdt=GetCurTimeCDate;
|
||||
"$$IV,1$$----%D %T----$$IV,0$$\n",ltdt,ltdt;
|
||||
}
|
||||
|
||||
U0 RandQuote(I64 num)
|
||||
{ //$LK,"::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z","FI:::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z"$
|
||||
I64 i,size,l=512;
|
||||
U8 *bible_filename=Define("ST_BIBLE_FILE"),
|
||||
*buf=FileRead(bible_filename,&size);
|
||||
if (buf) {
|
||||
i=num%(size-l);
|
||||
buf[i+l]=0;
|
||||
"" buf+i;
|
||||
Free(buf);
|
||||
}
|
||||
}
|
||||
|
||||
U0 BadCodeJump(I64 num)
|
||||
{ //$LK,"::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z","FI:::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z"$
|
||||
CDirEntry *root=FilesFind("/SparrowOS/*",FUF_JUST_FILES|FUF_RECURSE|FUF_FLATTEN_TREE|FUF_JUST_SRC_FILES),
|
||||
*tempm=root;
|
||||
I64 cnt=0;
|
||||
CDoc *doc;
|
||||
U8 *st;
|
||||
while (tempm) {
|
||||
doc=DocRead(tempm->full_name);
|
||||
tempm->user_data=doc->root.y;
|
||||
cnt+=doc->root.y;
|
||||
DocDel(doc);
|
||||
tempm=tempm->next;
|
||||
}
|
||||
num=num%cnt;
|
||||
tempm=root;
|
||||
while (tempm) {
|
||||
num-=tempm->user_data;
|
||||
if (num<0) {
|
||||
st=MSPrintF("FL:%s,%d",tempm->full_name,-num);
|
||||
break;
|
||||
}
|
||||
tempm=tempm->next;
|
||||
}
|
||||
CDirListDel(root);
|
||||
Ed(st);
|
||||
Free(st);
|
||||
}
|
||||
|
||||
Bool MyPutKey(I64 ch,I64 sc)
|
||||
{ //ch=ASCII; sc=scancode
|
||||
|
||||
//See $LK,"Char","HI:Char"$ for definition of scan codes.
|
||||
//See $LK,"Keyboard Handling","FI:::/SparrowOS/Doc/KeyBoard.TXT.Z"$
|
||||
|
||||
//You can customize keys. This routine
|
||||
//is called before the main editor
|
||||
//key handler $LK,"DocPutKey","MN:DocPutKey"$().
|
||||
//You can intercept any key.
|
||||
|
||||
//Return TRUE if you completely
|
||||
//handled the key.
|
||||
|
||||
I64 i,sc2=sc.u8[0];
|
||||
|
||||
if (SC_F1<=sc2<=SC_F10 &&
|
||||
sc&SCF_ALT &&
|
||||
!(sc & SCF_CTRL)) {
|
||||
switch (sc2) {
|
||||
case SC_F1:
|
||||
if (sc&SCF_KEY_DESC) {
|
||||
if (sc & SCF_SHIFT)
|
||||
SetKeyDesc("Dollar/LTPURPLE");
|
||||
else
|
||||
SetKeyDesc("Dollar/PURPLE");
|
||||
} else {
|
||||
if (sc & SCF_SHIFT)
|
||||
"$$FG,LTPURPLE$$";
|
||||
else
|
||||
"$$FG,PURPLE$$";
|
||||
}
|
||||
break;
|
||||
case SC_F2:
|
||||
if (sc&SCF_KEY_DESC) {
|
||||
if (sc & SCF_SHIFT)
|
||||
SetKeyDesc("Dollar/LTRED");
|
||||
else
|
||||
SetKeyDesc("Dollar/RED");
|
||||
} else {
|
||||
if (sc & SCF_SHIFT)
|
||||
"$$FG,LTRED$$";
|
||||
else
|
||||
"$$FG,RED$$";
|
||||
}
|
||||
break;
|
||||
case SC_F3:
|
||||
if (sc&SCF_KEY_DESC) {
|
||||
if (sc & SCF_SHIFT)
|
||||
SetKeyDesc("Dollar/LTGREEN");
|
||||
else
|
||||
SetKeyDesc("Dollar/GREEN");
|
||||
} else {
|
||||
if (sc & SCF_SHIFT)
|
||||
"$$FG,LTGREEN$$";
|
||||
else
|
||||
"$$FG,GREEN$$";
|
||||
}
|
||||
break;
|
||||
case SC_F4:
|
||||
if (sc&SCF_KEY_DESC) {
|
||||
if (sc & SCF_SHIFT)
|
||||
SetKeyDesc("Dollar/LTBLUE");
|
||||
else
|
||||
SetKeyDesc("Dollar/Default Color");
|
||||
} else {
|
||||
if (sc & SCF_SHIFT)
|
||||
"$$FG,LTBLUE$$";
|
||||
else
|
||||
"$$FG$$";
|
||||
}
|
||||
break;
|
||||
case SC_F5:
|
||||
if (sc&SCF_KEY_DESC) {
|
||||
if (sc & SCF_SHIFT)
|
||||
SetKeyDesc("God Passage");
|
||||
else
|
||||
SetKeyDesc("God Word");
|
||||
} else {
|
||||
//$LK,"::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z","FI:::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z"$
|
||||
if (sc & SCF_SHIFT)
|
||||
RandQuote(KbdMouseEvtTime>>4);
|
||||
else
|
||||
"%s ",ws_sorted_words[KbdMouseEvtTime>>4%ws_num_words]->str;
|
||||
}
|
||||
break;
|
||||
case SC_F6:
|
||||
if (sc&SCF_KEY_DESC) {
|
||||
if (sc & SCF_SHIFT)
|
||||
SetKeyDesc("Cmd/Init WordStat Text");
|
||||
else
|
||||
SetKeyDesc("Cmd/Init WordStat LT");
|
||||
} else {
|
||||
if (sc & SCF_SHIFT)
|
||||
PopUp("WSInit(\"::/SparrowOS/Misc/Bible.TXT.Z\");");
|
||||
else
|
||||
PopUp("WSInit(\"::/SparrowOS/\" TEXT_FILE_MASK \";~*Bible.TXT.Z\");");
|
||||
}
|
||||
break;
|
||||
case SC_F7:
|
||||
if (sc&SCF_KEY_DESC) {
|
||||
if (sc & SCF_SHIFT)
|
||||
SetKeyDesc("Dollar/Insert Hidden Widget");
|
||||
else
|
||||
SetKeyDesc("Misc/Insert Datetime");
|
||||
} else {
|
||||
if (sc & SCF_SHIFT)
|
||||
DocInsSafe(DocCur,
|
||||
"$$HS+C$$$$FG$$$$HE$$");
|
||||
else
|
||||
FillInTime();
|
||||
}
|
||||
break;
|
||||
}
|
||||
return TRUE;
|
||||
} else {
|
||||
if (!(sc & SCF_CTRL)) {
|
||||
if (sc & SCF_ALT) {
|
||||
switch (ch) {
|
||||
case 'h':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Win/Tile Horizontally");
|
||||
else
|
||||
WinTileHorz;
|
||||
return TRUE;
|
||||
case 'm':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Win/Maximize");
|
||||
else {
|
||||
WinMax;
|
||||
WinBorder;
|
||||
}
|
||||
return TRUE;
|
||||
case 'v':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Win/Tile Vertically");
|
||||
else
|
||||
WinTileVert;
|
||||
return TRUE;
|
||||
case 'V':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Sys/Frame Grabber Toggle");
|
||||
else
|
||||
FrameGrabberToggle;
|
||||
return TRUE;
|
||||
|
||||
case 'l':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Edit/Put Link to Cur Pos on Clipboard");
|
||||
else {
|
||||
ClipBoardDel;
|
||||
DocPrintF(sys_clipboard_doc,"$$LK-A,\"FL:%s,%d\"$$",
|
||||
DocCur->filename.name,DocCur->cur_entry->y+1);
|
||||
}
|
||||
return TRUE;
|
||||
case 'L':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Edit/Place Anchor, Put Link to Clipboard");
|
||||
else {
|
||||
i=RandU32;
|
||||
ClipBoardDel;
|
||||
DocPrintF(sys_clipboard_doc,"$$LK,\"<TODO>\",\"FA:%s,ANC%d\"$$",
|
||||
DocCur->filename.name,i);
|
||||
"$$AN,\"<TODO>\",\"ANC%d\"$$",i;
|
||||
}
|
||||
return TRUE;
|
||||
|
||||
case 'w':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Win/WordStat(ON);");
|
||||
else
|
||||
WordStat(ON);
|
||||
return TRUE;
|
||||
case 'W':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Win/WordStat;");
|
||||
else
|
||||
WordStat;
|
||||
return TRUE;
|
||||
|
||||
//Ins your own ALT-key plug-ins
|
||||
case 'b':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("Cmd/Jump to Bad Code");
|
||||
else //$LK,"::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z","FI:::/SparrowOS/Apps/AfterEgypt/AENotes.TXT.Z"$
|
||||
BadCodeJump(KbdMouseEvtTime>>4);
|
||||
return TRUE;
|
||||
|
||||
case 'p':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("JukeBox(TAD)");
|
||||
else
|
||||
JukeBox("::/SparrowOS/Accts/TS/TAD/MusicOrgan");
|
||||
return TRUE;
|
||||
case 'P':
|
||||
if (sc&SCF_KEY_DESC)
|
||||
SetKeyDesc("JukeBox(Examples)");
|
||||
else
|
||||
JukeBox("::/SparrowOS/Apps/MusicOrgan/Examples");
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
Bool MyPutS(U8 *st)
|
||||
{
|
||||
nounusedwarn st;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
KeyDevAdd(&MyPutKey,&MyPutS,0x20000000,TRUE);
|
||||
@@ -0,0 +1,9 @@
|
||||
#include "/SparrowOS/Accts/Adam3eWrappers"
|
||||
|
||||
#help_index "Utils;Cmd Line (Typically)"
|
||||
public U0 M(U8 *src1,U8 *src2,U8 *fu_flags=NULL)
|
||||
{
|
||||
MergeChk(src1,src2,fu_flags);
|
||||
}
|
||||
#help_index ""
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
U0 UserStartUp()
|
||||
{ //Run each time a user a spawned
|
||||
UseTermDoc;
|
||||
DocCurAttr(WHITE<<4+BLUE);
|
||||
Type("::/SparrowOS/Doc/Start.TXT.Z");
|
||||
LBts(&Fs->display_flags,DISPLAYf_SHOW);
|
||||
WinZBufUpdate;
|
||||
if (!IsSysDeterministic)
|
||||
Preempt(ON);
|
||||
Dir;
|
||||
CPURep;
|
||||
}
|
||||
|
||||
U0 ServantStartUp()
|
||||
{ //Run each time a servant task is spawned.
|
||||
UseTermDoc;
|
||||
LBts(&Fs->display_flags,DISPLAYf_SHOW);
|
||||
WinZBufUpdate;
|
||||
if (!IsSysDeterministic)
|
||||
Preempt(ON);
|
||||
}
|
||||
|
||||
CTask *user1,*user2;
|
||||
|
||||
U0 StartUpTasks()
|
||||
{
|
||||
user1=SpawnUser;
|
||||
user2=SpawnUser;
|
||||
WinToTop(user1);
|
||||
WinTileVert;
|
||||
if (!IsSysDeterministic)
|
||||
PopUp("#include \"::/SparrowOS/Adam/Start.CPP.Z\";");
|
||||
AdamLog("Boot Time:%7.3fs\n",tS);
|
||||
XTalk(user1,"#include \"DoItOnce.CPP.Z\";\n");
|
||||
Silent(ON);
|
||||
if (!IsSysDeterministic)
|
||||
WSInit("/SparrowOS/" TEXT_FILE_MASK ";~*Bible.TXT.Z");
|
||||
Silent(OFF);
|
||||
AdamLog("WordStat Time:%7.3fs\n",tS);
|
||||
if (ts_has_win_drv)
|
||||
DrvEnable(TS_WIN_DRV_LET,OFF);
|
||||
}
|
||||
|
||||
DelTree("::/Temp/ScreenShots");
|
||||
MkDir("::/Temp/ScreenShots");
|
||||
|
||||
StartUpTasks;
|
||||
|
||||
"\nOS Compile Time:%D %T\n",sys_compile_time,sys_compile_time;
|
||||
@@ -0,0 +1,12 @@
|
||||
//This file is executed by the
|
||||
//first terminal window upon start-up.
|
||||
//See $LK,"DoItOnce","FF:HOME/Adam3fSys.CPP.Z,DoItOnce"$.
|
||||
|
||||
//It goes in your HOME directory and
|
||||
//you can customize it.
|
||||
|
||||
//Delete this to get rid of
|
||||
//default start-up msg.
|
||||
|
||||
//Type("::/SparrowOS/Doc/Customize.TXT.Z");
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,20 @@
|
||||
//Change anything you want in this
|
||||
//acct file or others.
|
||||
|
||||
//This makes your keyboard fast
|
||||
SetTypeMatic(0);
|
||||
|
||||
//Set Time Zone
|
||||
local_time_offset=-7*60*60*CDATE_FREQ; //Pacific
|
||||
|
||||
snd_vol=0.1;
|
||||
|
||||
//$AN,"","mouse_move_scale"$adjust these to set mouse move scale
|
||||
mxx_scale=0.5;
|
||||
myy_scale=0.5;
|
||||
mzz_scale=1.0; //wheel
|
||||
|
||||
//don't change these
|
||||
mxx_prescale=mxx/mxx_scale;
|
||||
myy_prescale=myy/myy_scale;
|
||||
mzz_prescale=mzz/mzz_scale;
|
||||
@@ -0,0 +1,488 @@
|
||||
//ISO1 is ISO9660
|
||||
//ISO2 is ISO13490
|
||||
//ISO3 is ISO13346
|
||||
|
||||
//ISO13346 tag id types
|
||||
#define ISO3T_PRI_VOL_DESC 1
|
||||
#define ISO3T_ANCHOR_VOL_DESC_PTR 2
|
||||
#define ISO3T_VOL_DESC_PTR 3
|
||||
#define ISO3T_IMPLEMENTATION_VOL_DESC 4
|
||||
#define ISO3T_PRT_DESC 5
|
||||
#define ISO3T_LOG_VOL_DESC 6
|
||||
#define ISO3T_UNALLOCATED_SPACE_DESC 7
|
||||
#define ISO3T_TERMINATOR_DESC 8
|
||||
#define ISO3T_LOG_VOL_INTEGRITY_DESC 9
|
||||
#define ISO3T_FILE_SET_DESC 256
|
||||
#define ISO3T_FILE_ID_DESC 257
|
||||
#define ISO3T_ALLOC_EXTENT_DESC 258
|
||||
#define ISO3T_INDIRECT_ENTRY 259
|
||||
#define ISO3T_TERMINAL_ENTRY 260
|
||||
#define ISO3T_FILE_ENTRY 261
|
||||
#define ISO3T_EXT_ATTR_HEADER_DESC 262
|
||||
#define ISO3T_UNALLOC_SPACE_ENTRY 263
|
||||
#define ISO3T_SPACE_BITMAP_DESC 264
|
||||
#define ISO3T_PRT_INTEGRITY_ENTRY 265
|
||||
#define ISO3T_EXT_FILE_ENTRY 266
|
||||
|
||||
class CISO3Tag
|
||||
{
|
||||
U16 id;
|
||||
U16 version;
|
||||
U8 xsum;
|
||||
U8 reserved;
|
||||
U16 serial_num;
|
||||
U16 desc_crc;
|
||||
U16 desc_crc_len;
|
||||
U32 loc;
|
||||
};
|
||||
|
||||
class CISO3Date
|
||||
{
|
||||
U16 time_zone;
|
||||
I16 year;
|
||||
U8 mon;
|
||||
U8 day;
|
||||
U8 hour;
|
||||
U8 min;
|
||||
U8 sec;
|
||||
U8 sec100;
|
||||
U8 sec10000;
|
||||
U8 sec1000000;
|
||||
};
|
||||
|
||||
|
||||
class CISO3DString32
|
||||
{
|
||||
U8 body[31];
|
||||
U8 len;
|
||||
};
|
||||
|
||||
class CISO3DString128
|
||||
{
|
||||
U8 body[127];
|
||||
U8 len;
|
||||
};
|
||||
|
||||
class CISO3CharSpec
|
||||
{
|
||||
U8 type;
|
||||
U8 body[63];
|
||||
};
|
||||
|
||||
class CISO3RegId
|
||||
{
|
||||
U8 flags;
|
||||
U8 id[23];
|
||||
U8 id_suffix[8];
|
||||
};
|
||||
|
||||
class CISO3ExtentAD
|
||||
{
|
||||
U32 len;
|
||||
U32 loc;
|
||||
};
|
||||
|
||||
class CISO3LBAdd
|
||||
{
|
||||
U32 log_blk_num;
|
||||
U16 prt_ref_num;
|
||||
};
|
||||
|
||||
class CISO3LongAD
|
||||
{
|
||||
U32 len;
|
||||
CISO3LBAdd loc;
|
||||
U8 implementation_use[6];
|
||||
};
|
||||
|
||||
class CISO3ICBTag
|
||||
{
|
||||
U32 prior_record_direct_entries;
|
||||
U16 strategy_type;
|
||||
U16 strategy_param;
|
||||
U16 max_entries;
|
||||
U8 reserved;
|
||||
U8 file_type;
|
||||
CISO3LBAdd parent_icb_loc;
|
||||
U16 flags;
|
||||
};
|
||||
|
||||
class CISO3PriDesc
|
||||
{
|
||||
CISO3Tag tag;
|
||||
U32 vol_desc_seq_num;
|
||||
U32 pri_vol_desc_num;
|
||||
CISO3DString32 vol_id;
|
||||
U16 vol_seq_num;
|
||||
U16 max_vol_seq_num;
|
||||
U16 interchg_level;
|
||||
U16 max_interchg_level;
|
||||
U32 char_set_list;
|
||||
U32 max_char_set_list;
|
||||
CISO3DString128 vol_set_id;
|
||||
CISO3CharSpec desc_char_set;
|
||||
CISO3CharSpec explanatory_char_set;
|
||||
CISO3ExtentAD vol_abstract;
|
||||
CISO3ExtentAD vol_copyright_notice;
|
||||
CISO3RegId app_id;
|
||||
CISO3Date recording_date_time;
|
||||
CISO3RegId implementation_id[32];
|
||||
U8 implementation_use[64];
|
||||
U32 pred_vol_desc_seq_loc;
|
||||
U16 flags;
|
||||
U8 reserved[22];
|
||||
};
|
||||
|
||||
class CISO3PrtMap
|
||||
{
|
||||
U8 type;
|
||||
U8 len;
|
||||
U0 mapping;
|
||||
};
|
||||
|
||||
class CISO3PrtMap1
|
||||
{
|
||||
U8 type;
|
||||
U8 len;
|
||||
U16 vol_seq_num;
|
||||
U16 prt_num;
|
||||
};
|
||||
|
||||
class CISO3PrtMap2
|
||||
{
|
||||
U8 type;
|
||||
U8 len;
|
||||
U8 prt_id[62];
|
||||
};
|
||||
|
||||
class CISO3LogVolDesc
|
||||
{
|
||||
CISO3Tag tag;
|
||||
U32 vol_desc_seq_num;
|
||||
CISO3CharSpec desc_char_set;
|
||||
CISO3DString128 log_vol_id;
|
||||
U32 blk_size;
|
||||
CISO3RegId domain_id;
|
||||
U8 log_vol_contents_use[16];
|
||||
U32 map_table_len;
|
||||
U32 num_prt_maps;
|
||||
CISO3RegId implementation_id;
|
||||
U8 implementation_use[128];
|
||||
CISO3ExtentAD integrity_seq_extent;
|
||||
U0 prt_maps;
|
||||
};
|
||||
|
||||
class CISO3Prt
|
||||
{
|
||||
CISO3Tag tag;
|
||||
U32 vol_desc_seq_num;
|
||||
U16 flags;
|
||||
U16 num;
|
||||
CISO3RegId contents;
|
||||
U8 contents_use[128];
|
||||
U32 access_type;
|
||||
U32 starting_loc;
|
||||
U32 len;
|
||||
CISO3RegId implementation_id;
|
||||
U8 implementation_use[128];
|
||||
U8 reserved[156];
|
||||
};
|
||||
|
||||
class CISO3FileSetDesc
|
||||
{
|
||||
CISO3Tag tag;
|
||||
CISO3Date recording_date_time;
|
||||
U16 interchg_level;
|
||||
U16 max_interchg_level;
|
||||
U32 char_set_list;
|
||||
U32 max_char_set_list;
|
||||
U32 file_set_num;
|
||||
U32 file_set_desc_num;
|
||||
CISO3CharSpec log_vol_id_char_set;
|
||||
CISO3DString128 log_vol_id;
|
||||
CISO3CharSpec file_set_char_set;
|
||||
CISO3DString32 file_set_id;
|
||||
CISO3DString32 copyright_file_id;
|
||||
CISO3DString32 abstract_file_id;
|
||||
CISO3LongAD root_dir_icb;
|
||||
CISO3RegId domain_id;
|
||||
CISO3LongAD next_extent;
|
||||
CISO3LongAD sys_stream_dir_icb;
|
||||
U8 reserved[32];
|
||||
};
|
||||
|
||||
class CISO3FileIdDesc
|
||||
{
|
||||
CISO3Tag tag;
|
||||
U16 version;
|
||||
U8 characteristics;
|
||||
U8 len_of_file_id;
|
||||
CISO3LongAD icb;
|
||||
U16 len_of_implementation_use;
|
||||
U0 implementation_use;
|
||||
U0 file_id;
|
||||
};
|
||||
|
||||
class CISO3File
|
||||
{
|
||||
CISO3Tag tag;
|
||||
CISO3ICBTag icb_tag;
|
||||
U32 uid;
|
||||
U32 gid;
|
||||
U32 permissions;
|
||||
U16 file_link_cnt;
|
||||
U8 record_fmt;
|
||||
U8 record_display_attr;
|
||||
U32 record_len;
|
||||
I64 info_len;
|
||||
I64 log_blks_recorded;
|
||||
CISO3Date access_date_time;
|
||||
CISO3Date modification_date_time;
|
||||
CISO3Date attr_date_time;
|
||||
U32 chk_pt;
|
||||
CISO3LongAD ext_attr_icb;
|
||||
CISO3RegId implementation_id;
|
||||
I64 unique_id;
|
||||
U32 ext_attr_len;
|
||||
U32 alloc_desc_len;
|
||||
U0 ext_attr;
|
||||
U0 alloc_desc;
|
||||
};
|
||||
|
||||
class CISO3FileExt
|
||||
{
|
||||
CISO3Tag tag;
|
||||
CISO3ICBTag icb_tag;
|
||||
U32 uid;
|
||||
U32 gid;
|
||||
U32 permissions;
|
||||
U16 file_link_cnt;
|
||||
U8 record_fmt;
|
||||
U8 record_display_attr;
|
||||
U32 record_len;
|
||||
I64 info_len;
|
||||
I64 object_size;
|
||||
I64 log_blks_recorded;
|
||||
CISO3Date access_date_time;
|
||||
CISO3Date modification_date_time;
|
||||
CISO3Date creation_date_time;
|
||||
CISO3Date attr_date_time;
|
||||
U32 chk_pt;
|
||||
U32 reserved;
|
||||
CISO3LongAD ext_attr_icb;
|
||||
CISO3LongAD stream_dir_icb;
|
||||
CISO3RegId implementation_id;
|
||||
I64 unique_id;
|
||||
U32 ext_attr_len;
|
||||
U32 alloc_desc_len;
|
||||
U0 ext_attr;
|
||||
U0 alloc_desc;
|
||||
};
|
||||
|
||||
import U0 ClassRep(U8 *class_name,U8 *d,I64 max_depth=2,Bool fun=FALSE,I64 offset=0);
|
||||
|
||||
Bool ISO3PrtInitPrt(CPrt *p,I64 blk)
|
||||
{
|
||||
CBlkDev *bdev=p->bdev;
|
||||
I64 spc=bdev->blk_size>>BLK_SIZE_BITS,i=blk/spc;
|
||||
CISO3FileSetDesc *iso=MAlloc(bdev->blk_size);
|
||||
Bool unlock,result=FALSE;
|
||||
try {
|
||||
unlock=PrtLock(p);
|
||||
while (TRUE) {
|
||||
p->size=MaxI64(p->size,(i+1)*spc);
|
||||
RBlks(p,iso,i*spc,spc);
|
||||
"%X:%X\n",i,iso->tag.id;
|
||||
switch (iso->tag.id) {
|
||||
case ISO3T_FILE_SET_DESC:
|
||||
ClassRep("CISO3FileSetDesc",iso,3);
|
||||
// p->offset=blk;
|
||||
// p->root_cluster=iso->root_dir_icb.loc.log_blk_num+p->offset/spc;
|
||||
result=TRUE;
|
||||
break;
|
||||
case ISO3T_EXT_FILE_ENTRY:
|
||||
ClassRep("CISO3FileExt",iso,3);
|
||||
break;
|
||||
case ISO3T_FILE_ENTRY:
|
||||
ClassRep("CISO3File",iso,3);
|
||||
break;
|
||||
case ISO3T_FILE_ID_DESC:
|
||||
ClassRep("CISO3FileIdDesc",iso,3);
|
||||
break;
|
||||
case ISO3T_ALLOC_EXTENT_DESC:
|
||||
case ISO3T_INDIRECT_ENTRY:
|
||||
case ISO3T_TERMINAL_ENTRY:
|
||||
case ISO3T_EXT_ATTR_HEADER_DESC:
|
||||
case ISO3T_UNALLOC_SPACE_ENTRY:
|
||||
case ISO3T_SPACE_BITMAP_DESC:
|
||||
case ISO3T_PRT_INTEGRITY_ENTRY:
|
||||
break;
|
||||
default
|
||||
goto i3pip_done;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
i3pip_done:
|
||||
Free(iso);
|
||||
if (unlock)
|
||||
PrtUnlock(p);
|
||||
} catch {
|
||||
Free(iso);
|
||||
if (unlock)
|
||||
PrtUnlock(p);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Bool ISO3PrtInit(CPrt *p,I64 blk)
|
||||
{
|
||||
CBlkDev *bdev=p->bdev;
|
||||
I64 spc=bdev->blk_size>>BLK_SIZE_BITS,i=blk/spc,offset=0;
|
||||
CISO3Prt *iso=MAlloc(bdev->blk_size);
|
||||
Bool unlock,result=FALSE;
|
||||
|
||||
try {
|
||||
unlock=PrtLock(p);
|
||||
while (TRUE) {
|
||||
p->size=MaxI64(p->size,(i+1)*spc);
|
||||
RBlks(p,iso,i*spc,spc);
|
||||
"%X:%X\n",i,iso->tag.id;
|
||||
switch (iso->tag.id) {
|
||||
case ISO3T_PRT_DESC:
|
||||
ClassRep("CISO3Prt",iso,3);
|
||||
offset=iso->starting_loc*spc; //one partition for now
|
||||
break;
|
||||
case ISO3T_PRI_VOL_DESC:
|
||||
ClassRep("CISO3PriDesc",iso,3);
|
||||
break;
|
||||
case ISO3T_LOG_VOL_DESC:
|
||||
ClassRep("CISO3LogVolDesc",iso,3);
|
||||
D(&iso(CISO3LogVolDesc *)->prt_maps);
|
||||
break;
|
||||
case ISO3T_ANCHOR_VOL_DESC_PTR:
|
||||
case ISO3T_VOL_DESC_PTR:
|
||||
case ISO3T_IMPLEMENTATION_VOL_DESC:
|
||||
case ISO3T_UNALLOCATED_SPACE_DESC:
|
||||
case ISO3T_LOG_VOL_INTEGRITY_DESC:
|
||||
break;
|
||||
case ISO3T_TERMINATOR_DESC:
|
||||
goto i3pi_done;
|
||||
default:
|
||||
PutDefineErr("ST_UNSUPPORTED_FILE_SYSTEM");
|
||||
throw(EXCEPT_PRT,8);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
i3pi_done:
|
||||
if (offset)
|
||||
result=ISO3PrtInitPrt(p,offset);
|
||||
Free(iso);
|
||||
if (unlock)
|
||||
PrtUnlock(p);
|
||||
} catch {
|
||||
Free(iso);
|
||||
if (unlock)
|
||||
PrtUnlock(p);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/****
|
||||
U0 CDate2ISO3(CISO3Date *dst,CDate ltdt)
|
||||
{
|
||||
CDateStruct ds;
|
||||
CDate2CDateStruct(&ds,ltdt);
|
||||
MemSet(dst,0,sizeof(CISO3Date));
|
||||
dst->year=ds.year;
|
||||
dst->mon=ds.mon;
|
||||
dst->day=ds.day_of_mon;
|
||||
dst->hour=ds.hour;
|
||||
dst->min=ds.min;
|
||||
dst->sec=ds.sec;
|
||||
dst->sec100=ds.sec100;
|
||||
}
|
||||
|
||||
CDate ISO3Date2CDate(CISO3Date *dt)
|
||||
{
|
||||
CDateStruct ds;
|
||||
MemSet(&ds,0,sizeof(CDateStruct));
|
||||
ds.day_of_mon=dt->day;
|
||||
ds.mon=dt->mon;
|
||||
ds.year=dt->year;
|
||||
ds.sec100=dt->sec100;
|
||||
ds.sec=dt->sec;
|
||||
ds.min=dt->min;
|
||||
ds.hour=dt->hour;
|
||||
return CDateStruct2CDate(&ds);
|
||||
}
|
||||
****/
|
||||
|
||||
|
||||
Bool ISOPrtInit(CPrt *p,I64 blk)
|
||||
{
|
||||
CBlkDev *bdev=p->bdev;
|
||||
I64 spc=bdev->blk_size>>BLK_SIZE_BITS,i=blk/spc;
|
||||
CISO1PriDesc *iso=MAlloc(bdev->blk_size);
|
||||
CISO1DirEntry *de;
|
||||
Bool unlock,result=FALSE;
|
||||
U8 buf[8];
|
||||
|
||||
try {
|
||||
unlock=PrtLock(p);
|
||||
p->type=PT_ISO9660; //default
|
||||
p->spc=spc;
|
||||
p->offset=p->data=p->root_cluster=p->size=0;
|
||||
while (TRUE) {
|
||||
p->size=MaxI64(p->size,(i+1)*spc);
|
||||
RBlks(p,iso,i*spc,spc);
|
||||
buf[0](U32)=iso->id[0](U32);
|
||||
buf[4](U16)=iso->id[4](U8);
|
||||
switch (ListEntryMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",LEF_EXACT)) {
|
||||
case 0:
|
||||
p->type=PT_ISO9660;
|
||||
switch (iso->type) {
|
||||
case ISO1T_SUPPLEMENTARY_DESC:
|
||||
p->data=0;
|
||||
de=&iso->root_dir_record;
|
||||
p->root_cluster=de->loc.little;
|
||||
p->size=iso->vol_space_size.little*bdev->blk_size>>BLK_SIZE_BITS;
|
||||
result=TRUE;
|
||||
goto ipi_done;
|
||||
case ISO1T_TERMINATOR:
|
||||
throw(EXCEPT_PRT,9);
|
||||
}
|
||||
break;
|
||||
case 2...6:
|
||||
p->type=PT_ISO13346;
|
||||
break;
|
||||
case 1: //PT_ISO13490 (Not supported)
|
||||
default: //Its normal for ISO13346 to read NULL blk as terminator
|
||||
switch (p->type) {
|
||||
case PT_ISO13346:
|
||||
i++; //Terminator is blk after last valid. Advance to next blk
|
||||
if (ISO3PrtInit(p,i*spc)) {
|
||||
result=TRUE;
|
||||
goto ipi_done;
|
||||
}
|
||||
break;
|
||||
}
|
||||
PutDefineErr("ST_UNSUPPORTED_FILE_SYSTEM");
|
||||
throw(EXCEPT_PRT,10);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
ipi_done:
|
||||
Free(iso);
|
||||
if (unlock)
|
||||
PrtUnlock(p);
|
||||
} catch {
|
||||
p->type=PT_ISO9660;
|
||||
p->spc=spc;
|
||||
p->offset=p->data=p->root_cluster=0;
|
||||
Free(iso);
|
||||
if (unlock)
|
||||
PrtUnlock(p);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
Binary file not shown.
@@ -0,0 +1,217 @@
|
||||
/*
|
||||
You can play with this if you are
|
||||
interested in USB. I'm not planning
|
||||
on doing USB unless the legacy PS2
|
||||
keyboard/mouse mode disappears.
|
||||
There EHCI UHCI in various ICH chips and
|
||||
others and God knows how many custom packet
|
||||
formats for different keyboards and mice. Okay,
|
||||
I suppose if BIOS can make a universal
|
||||
packet, it is done just one way for
|
||||
different mice. PS2 is more compatible.
|
||||
|
||||
*/
|
||||
#help_index "USB"
|
||||
extern I64 sys_num_usb;
|
||||
extern CUSB sys_usb_devs[MAX_USB];
|
||||
extern CUSBTD *USBAllocTD();
|
||||
extern U0 USBFreeTD(CUSBTD *temptd);
|
||||
extern U0 USBEndAll();
|
||||
extern U0 USBInitAll();
|
||||
extern U32 *USBAllocFrameList(I64 usb_num,I64 size);
|
||||
|
||||
U8 *StatCB(CDoc *,CDocEntry *doc_e,CTask *mem_task)
|
||||
{ //This routine shows the stat of the USB ports
|
||||
U8 *st=MAlloc(128,mem_task);
|
||||
U16 w1,w2,w3,w4;
|
||||
U32 d1;
|
||||
CUSB *u=doc_e->user_data;
|
||||
I64 d=u->ports;
|
||||
w3=InU16(d+USBP_STS);
|
||||
w1=InU16(d+USBP_PORTSC0); w2=InU16(d+USBP_PORTSC1);
|
||||
w4=InU16(d+USBP_FRNUM);
|
||||
d1=InU32(d+USBP_FRBASEADD);
|
||||
SPrintF(st,"%X:Stat:%04X P0:%04X P1:%04X FRAME:%04X",d1,w3,w1,w2,w4);
|
||||
return st;
|
||||
}
|
||||
|
||||
U0 PutStat()
|
||||
{
|
||||
I64 i;
|
||||
Bool old_preempt=Preempt(OFF);
|
||||
CDocEntry *doc_e;
|
||||
CUSB *u;
|
||||
WinMax;
|
||||
|
||||
"$$FG,GREEN$$Dev Stat Bits\n$$FG$$"
|
||||
" 0:IRQ\n"
|
||||
" 1:IRQ err\n"
|
||||
" 2:Resume\n"
|
||||
" 3:Host Sys Err\n"
|
||||
" 4:Host Process Err\n"
|
||||
" 5:Halted\n"
|
||||
"$$FG,GREEN$$Port Stat Bits\n$$FG$$"
|
||||
" 0:Connection Stat\n"
|
||||
" 1:Connection Stat Change\n"
|
||||
" 2:Port Enabled\n"
|
||||
" 3:Port Enabled Change\n"
|
||||
"4-5:Line Stat\n"
|
||||
" 6:Resume Detect\n"
|
||||
" 8:Low Speed\n"
|
||||
" 9:Port Rst\n"
|
||||
" 10:Overcurrent Active\n"
|
||||
" 11:Overcurrent Indicator\n"
|
||||
" 12:Suspend\n\n";
|
||||
|
||||
for (i=0;i<sys_num_usb;i++) {
|
||||
u=&sys_usb_devs[i];
|
||||
"$$FG,LTRED$$Dev%d:%X:",i,u->ports;
|
||||
doc_e=DocPutS(DocCur,"$$TX+TC,\" \"$$");
|
||||
doc_e->user_data=&sys_usb_devs[i];
|
||||
doc_e->tag_cb=&StatCB;
|
||||
"$$FG$$\n";
|
||||
}
|
||||
|
||||
Preempt(old_preempt);
|
||||
NewLine;
|
||||
}
|
||||
|
||||
|
||||
extern U0 PutQH(U32 h);
|
||||
|
||||
U32 *P(U32 d)
|
||||
{
|
||||
return d&~3;
|
||||
}
|
||||
|
||||
|
||||
U0 PutTD(U32 t)
|
||||
{
|
||||
"TD:$$FG,GREEN$$%08X$$FG$$\n",t;
|
||||
"%08X\n",*P(t);
|
||||
DocDm(t+4,8);
|
||||
if (*P(t+12))
|
||||
DocDm(*P(t+12),16);
|
||||
// DocDm(*P(t+12),*P(t+4)>>21&0x7FF);
|
||||
if (!(*P(t)&1)) {
|
||||
if (*P(t)&2)
|
||||
PutQH(*P(t));
|
||||
else
|
||||
PutTD(*P(t));
|
||||
}
|
||||
}
|
||||
|
||||
U0 PutQH(U32 h)
|
||||
{
|
||||
"QH:$$FG,RED$$%08X$$FG$$\n",h;
|
||||
"%08X\n",*P(h);
|
||||
"%08X\n",*P(h+4);
|
||||
|
||||
if (!(*P(h)&1)) {
|
||||
if (*P(h)&2)
|
||||
PutQH(*P(h));
|
||||
else
|
||||
PutTD(*P(h));
|
||||
}
|
||||
|
||||
if (!(*P(h+4)&1)) {
|
||||
if (*P(h+4)&2)
|
||||
PutQH(*P(h+4));
|
||||
else
|
||||
PutTD(*P(h+4));
|
||||
}
|
||||
}
|
||||
|
||||
U0 PutFrame(U32 f)
|
||||
{
|
||||
PutQH(f);
|
||||
}
|
||||
|
||||
U0 PutFrames()
|
||||
{
|
||||
I64 i,d,f,w1,w2;
|
||||
CUSB *u;
|
||||
for (i=0;i<sys_num_usb;i++) {
|
||||
u=&sys_usb_devs[i];
|
||||
d=u->ports;
|
||||
w1=InU16(d+USBP_PORTSC0); w2=InU16(d+USBP_PORTSC1);
|
||||
if (w1&1 || w2&1) {
|
||||
f=InU32(d+USBP_FRBASEADD);
|
||||
PutFrame(f);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
U0 Main()
|
||||
{
|
||||
USBInitAll;
|
||||
PutStat;
|
||||
PutFrames;
|
||||
"$$FG,RED$$The BIOS sets-up the USB in PS/2 legacy mode.$$FG$$\n";
|
||||
}
|
||||
|
||||
Main;
|
||||
|
||||
|
||||
/* Not Finished
|
||||
#define PORT 5
|
||||
|
||||
#define DEV_ADD_INIT 1
|
||||
#define DEV_ADD 1
|
||||
#define END_PT0 0
|
||||
#define END_PT1 1
|
||||
#define END_PT2 2
|
||||
#define MAX_LEN 8
|
||||
#define TERMINATE 1
|
||||
|
||||
U0 SetUpTD()
|
||||
{
|
||||
CUSB *u=&sys_usb_devs[PORT];
|
||||
I64 i,d=u->ports;
|
||||
U32 *frm=CAllocAligned(0x1000,0x1000,Fs->code_heap),
|
||||
*tds=CAllocAligned(256,16,Fs->code_heap),
|
||||
*buf=CAlloc(128,Fs->code_heap);
|
||||
DocD(buf,128);
|
||||
|
||||
"<0>\n"; Sleep(100);
|
||||
OutU16(d+USBP_CMD,2); //Reset
|
||||
"<1>\n"; Sleep(100);
|
||||
OutU16(d+USBP_CMD,0);
|
||||
"<2>\n"; Sleep(100);
|
||||
OutU16(d+USBP_PORTSC0,4); //Enable
|
||||
OutU16(d+USBP_PORTSC1,4);
|
||||
"<3>\n"; Sleep(100);
|
||||
|
||||
tds[0]=&tds[4](U8 *);
|
||||
tds[1]=0;
|
||||
tds[2]=PID_SETUP+DEV_ADD_INIT<<8+END_PT0<<15+MAX_LEN<<21;
|
||||
tds[3]=buf;
|
||||
buf[0]=0+RQ_SET_ADDR<<8+DEV_ADD<<16;
|
||||
buf[1]=0+0<<16;
|
||||
|
||||
|
||||
tds[4]=TERMINATE;
|
||||
tds[5]=0;
|
||||
tds[6]=PID_SETUP+DEV_ADD_INIT<<8+END_PT0<<15+MAX_LEN<<21;
|
||||
tds[7]=buf(U8 *)+8;
|
||||
buf[2]=0+RQ_SET_ADDR<<8+DEV_ADD<<16;
|
||||
buf[3]=0+0<<16;
|
||||
|
||||
frm[0]=&tds[0](U8 *);
|
||||
for (i=1;i<0x1000/4;i++)
|
||||
frm[i]=TERMINATE;
|
||||
|
||||
OutU16(d+USBP_FRNUM,frm);
|
||||
OutU32(d+USBP_FRBASEADD,frm);
|
||||
"<4>\n"; Sleep(200);
|
||||
OutU16(d+USBP_CMD,1);
|
||||
"<5>\n"; Sleep(1000);
|
||||
OutU16(d+USBP_CMD,0);
|
||||
"<6>\n"; Sleep(200);
|
||||
}
|
||||
|
||||
SetUpTD;
|
||||
|
||||
*/
|
||||
|
||||
@@ -0,0 +1,114 @@
|
||||
#define USBP_CMD 0x00
|
||||
#define USBP_STS 0x02
|
||||
#define USBP_INTR 0x04
|
||||
#define USBP_FRNUM 0x06
|
||||
#define USBP_FRBASEADD 0x08
|
||||
#define USBP_SOFMOD 0x0C
|
||||
#define USBP_PORTSC0 0x10
|
||||
#define USBP_PORTSC1 0x12
|
||||
#define MAX_USB 16
|
||||
|
||||
class CUSBTD //Not implemented
|
||||
{
|
||||
U32 td[4];
|
||||
};
|
||||
|
||||
class CUSB //Not implemented
|
||||
{
|
||||
U8 num, //USB dev num
|
||||
bus,dev,fun;
|
||||
U16 ports,pad;
|
||||
U32 *frame_list;
|
||||
};
|
||||
|
||||
//USB Pkt ID's
|
||||
#define PID_OUT 0xE1
|
||||
#define PID_IN 0x69
|
||||
#define PID_SOF 0xA5
|
||||
#define PID_SETUP 0x2D
|
||||
#define PID_DATA0 0xC3
|
||||
#define PID_DATA1 0x4B
|
||||
#define PID_DATA2 0x87
|
||||
#define PID_MDATA 0x0F
|
||||
#define PID_ACK 0xD2
|
||||
#define PID_NAK 0x5A
|
||||
#define PID_STALL 0x1E
|
||||
#define PID_NYET 0x96
|
||||
#define PID_PRE 0x3C
|
||||
#define PID_ERR 0x3C
|
||||
#define PID_SPLIT 0x78
|
||||
#define PID_PING 0xB4
|
||||
|
||||
//USB Std Rqsts
|
||||
#define RQ_GET_STAT 0x0
|
||||
#define RQ_CLR_FEAT 0x1
|
||||
#define RQ_SET_FEAT 0x3
|
||||
#define RQ_SET_ADDR 0x5
|
||||
#define RQ_SET_DESC 0x7
|
||||
#define RQ_GET_CFG 0x8
|
||||
#define RQ_SET_CFG 0x9
|
||||
#define RQ_GET_INTERFACE 0xA
|
||||
#define RQ_SET_INTERFACE 0xB
|
||||
#define RQ_SYNC_FRAME 0xC
|
||||
|
||||
I64 sys_num_usb=0;
|
||||
CUSB sys_usb_devs[MAX_USB];
|
||||
MemSet(sys_usb_devs,0,MAX_USB*sizeof(CUSB));
|
||||
|
||||
|
||||
U0 USBInitOne(I64 b,I64 d,I64 f)
|
||||
{
|
||||
CUSB *u;
|
||||
if (sys_num_usb<MAX_USB &&
|
||||
PCIReadU16(b,d,f,0)==0x8086) {
|
||||
u=&sys_usb_devs[sys_num_usb++];
|
||||
u->num=sys_num_usb;
|
||||
u->bus=b;
|
||||
u->dev=d;
|
||||
u->fun=f;
|
||||
u->ports=PCIReadU32(b,d,f,0x20)&~0x1F;
|
||||
}
|
||||
}
|
||||
|
||||
U0 USBEndAll()
|
||||
{
|
||||
sys_num_usb=0;
|
||||
}
|
||||
|
||||
U0 USBInitAll() //This is only valid for my ICH10 dev
|
||||
{
|
||||
if (sys_num_usb)
|
||||
USBEndAll;
|
||||
USBInitOne(0,29,0);
|
||||
USBInitOne(0,29,1);
|
||||
USBInitOne(0,29,2);
|
||||
USBInitOne(0,29,3);
|
||||
USBInitOne(0,26,0);
|
||||
USBInitOne(0,26,1);
|
||||
USBInitOne(0,26,2);
|
||||
}
|
||||
|
||||
CUSBTD *USBAllocTD()
|
||||
{
|
||||
return MAllocAligned(sizeof(CUSBTD),0x10,sys_uncached_heap);
|
||||
}
|
||||
|
||||
U0 USBFreeTD(CUSBTD *temptd)
|
||||
{
|
||||
Free(temptd);
|
||||
}
|
||||
|
||||
U32 *USBAllocFrameList(I64 usb_num,I64 size)
|
||||
{ //aligned to 0x1000
|
||||
CUSB *u;
|
||||
if (0<=usb_num<sys_num_usb) {
|
||||
u=&sys_usb_devs[usb_num];
|
||||
Free(u->frame_list);
|
||||
u->frame_list=MAllocAligned(size*sizeof(U32),0x1000,sys_uncached_heap);
|
||||
OutU16(u->ports+USBP_CMD,0); //Stop
|
||||
OutU16(u->ports+USBP_FRNUM,0);
|
||||
OutU32(u->ports+USBP_FRBASEADD,u->frame_list);
|
||||
return u->frame_list;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
* Preempt-->cli
|
||||
|
||||
* Why is bitmap different from vector in $LK,"Logo","FI:::/SparrowOS/Accts/TS/TAD/Archive/Logo.TXT.Z"$?
|
||||
|
||||
* Hangs after pressing Compile MAIN in menu.
|
||||
* Crashes after back-up-script. Went away maybe after spurious IRQ fix.
|
||||
* Might be same as last one. Back-up-script cause jumps back and forth in ToHtml
|
||||
* Music organ hangs when cursoring around.
|
||||
|
||||
* $LK,"DocUpdateTaskDocs","MN:DocUpdateTaskDocs"$() skips locked docs. $LK,"WinMgrSync","MN:WinMgrSync"$() needs to check.
|
||||
|
||||
* Why is wordstat so slow on "OldMasterBootWrite" for example.
|
||||
|
||||
* $LK,"Plain","MN:Plain"$() might be better not saving $LK,"CH_CURSOR","MN:CH_CURSOR"$.
|
||||
|
||||
* TRANSPARENT might not work with line ROPF_DITHER
|
||||
|
||||
* It would be nice if $LK,"U","MN:U"$() NOP were better.
|
||||
|
||||
* Autoindent is very bad.
|
||||
|
||||
* Make native file system expanded size set in Copy.
|
||||
|
||||
* unhandled exception on MP message gets overwritten by WinMgr
|
||||
|
||||
* Cmd to enable/disable compiler warnings
|
||||
|
||||
* make aware of ctrl-r side bar
|
||||
|
||||
* fix problem -- remembering 0 terminator in str or not for $$DA
|
||||
* GetS, crazy putkey code
|
||||
* editor page formatting
|
||||
|
||||
* $LK,"gr_screen_image","MN:gr_screen_image"$
|
||||
>Might want to do ZOOM in U8 graphics and convert screen capture to U8
|
||||
>Might want to reverse bit order
|
||||
|
||||
* wenceslas crashes in testsuite, sometimes
|
||||
|
||||
* CGrVectMap sucks
|
||||
* return vals for grrect, grblot, grputchar?
|
||||
* collisions for grrect, grblot, grputchar?
|
||||
|
||||
* 32-bit devices should be in free spot address space of E820.
|
||||
|
||||
* RAM drive too small for SparrowOSCD.ISO
|
||||
$WW,1$
|
||||
* Race condition in Navy.CPP.Z torpedo
|
||||
|
||||
* Logrep throw for out-of-mem?
|
||||
* {Lock|Rep}{Seg|2E=NotBr|3E=Br}{OP}{ADD}{REX}
|
||||
* Virtual Box MP reboot
|
||||
* Std local var names
|
||||
* EIE_ABS_ADDR 64
|
||||
|
||||
//After Egypt possible future ideas
|
||||
//$LK,"Numbers,13:33","BF:Numbers,13:33"$ scouts
|
||||
//$LK,"Numbers,21:8","BF:Numbers,21:8"$ snakes
|
||||
|
||||
GrEdit: Move sidebar selected elems.
|
||||
- Be careful of multipt elems.
|
||||
GrEdit: Strip origin shift cmds.
|
||||
|
||||
GrEditBitMap, grabscroll?
|
||||
GrEditBitMap, cut/paste boxes.
|
||||
|
||||
extern of fun with dft arg of str?
|
||||
|
||||
* We kinda need a routine to return how much free memory, so that applications can plan a big alloc.
|
||||
|
||||
* FileMgr bad with lots of files.
|
||||
|
||||
* This $LK,"Fs->catch_except=TRUE","FF:::/SparrowOS/OSMain/TaskCmd.CPP.Z,Fs->catch_except=TRUE"$ causes problems because it catches divide and out-of-mem. Not sure what to do, yet.
|
||||
* $LK,"MPStart","MN:MPStart"$() free old task memory. (Prolly never gonna do anything about this.)
|
||||
* $LK,"sys_var_init_flag","MN:sys_var_init_flag"$ local vars.
|
||||
* sprite shift pts, ctrl pt for ellipse/polygon w,h is off when rotated.
|
||||
|
||||
* Window mgr needs to do DOC operations on posted messages from mouse. Works for $LK,"SetIP","MN:SetIP"$(), though.
|
||||
|
||||
* Add local vars to sym table in $LK,"Dbg","MN:Dbg"$()? (maybe)
|
||||
|
||||
This shit:
|
||||
$HC,"<object width=\"750\" height=\"520\"><param name=\"movie\" value=\"http://www.youtube.com/v/WAr-xYtBFbY?hl=en&fs=1\"></param><param name=\"allowFullScreen\" value=\"true\"></param><param name=\"allowscriptaccess\" value=\"always\"></param><embed src=\"http://www.youtube.com/v/WAr-xYtBFbY?hl=en&fs=1\" type=\"application/x-shockwave-flash\" allowscriptaccess=\"always\" allowfullscreen=\"true\" width=\"750\" height=\"520\"></embed></object>"$
|
||||
|
||||
|
||||
* $LK,"Bible sized nodes","FF:::/SparrowOS/Adam/Doc/DocRecalc.CPP.Z,->tag+i"$
|
||||
* Mouseinstall throws exceptions, doesn't work, investigate Mouse $LK,"0x9FC30","FF:::/SparrowOS/OSMain/KbdMouse/Mouse.CPP.Z,9FC"$
|
||||
* get kbd lights working.
|
||||
* figure-out hyperthread vs nonhyperthread CPU's
|
||||
* Might have issue with compiler exceptions and restoring lex.hash tables.
|
||||
* Generates two compiler error messages for expressions in statements.
|
||||
* release semaphores or break lock sema,usb_td
|
||||
* Fix Mom's secondary CD-ROM, dad's primary
|
||||
* pmtstr in install didn't like focus change
|
||||
|
||||
*$FG,2$U0 Main()
|
||||
{
|
||||
U0 (*fp_old_draw_input_ptr)(CDC *dc,I64 x,I64 y)=fp_draw_input_ptr;
|
||||
}$FG$
|
||||
|
||||
* Syncronize VGA memory update with the hardware refresh cycle.
|
||||
|
||||
* Demo $LK,"ToHtml","MN:ToHtml"$().
|
||||
|
||||
* Del short name in FAT32--currently I do not check to see if I have generated a unique short name and one can delete multiple files accidentally. Generating unique short names is a pain in the ass because you have to scan the whole directory. I think I just truncate the name instead of "Program~1" or whatever. S081130-0001.BMP crashed windows--two identical short names.
|
||||
|
||||
* OVERSTRIKE at cmd line with menu macro.
|
||||
|
||||
* $FG,2$lock{}$FG$ warning on invalid modes.
|
||||
* Local array vars-->reg.
|
||||
* $LK,"DCF_SYMMETRY","MN:DCF_SYMMETRY"$, before transformation? (Currently it's after)
|
||||
* all graphics clipping -- screen y+top<0 for top<0
|
||||
* Maybe convert graphics to float
|
||||
* compiler F32
|
||||
* preempt(OFF) during graphic clipping?
|
||||
* compiler optimization heap_glbls with added offset
|
||||
* static_compile extern glblvar references.
|
||||
* extern glbl var in static module on data heap.
|
||||
* Might make FAT32 read in contiguous chunks.
|
||||
* make Limit(),Min(),Max() asm routines.
|
||||
* Might make CSprite flood fill operate on a separate bitmap and blotted at the end.
|
||||
* autofile popup of popup
|
||||
* <CTRL-R> delete subsprite in menu near others
|
||||
* consider changing domenu so a real <ESC> on menu item doesn't select (<SPACE BAR> sends <ESC> followed by <SPACE BAR> or something)
|
||||
* puts3 with depth buf? might not do this
|
||||
* make task queins and querem safe for multicore cycling through tasks (fwd).
|
||||
* make better heapwalk, do something with _CFG_HEAP_DBG.
|
||||
* log to file--would be inefficient--load-in whole file, modify and write out. Useful, but not very efficient (SparrowOS file system has no grow-file ability. Created when FAT patent was an issue and wanted absly nothing people could sue me for.)
|
||||
* APIC2
|
||||
* import intel datasheets, somehow?
|
||||
* Might make DskView show drive colors.
|
||||
* Might do utility to set drive colors, making a tree entry in Adam 3 using registry-like routines... or registry I guess.
|
||||
|
||||
* New Editor widgets
|
||||
|
||||
* Make use of flag potential in SysFilesFind and possibly CFileAccess
|
||||
* implement fixed pos files
|
||||
|
||||
* new C+ language features
|
||||
* better debugging
|
||||
|
||||
* Change hardcoded stuff to Define
|
||||
* Too much preemption turned off?
|
||||
* Look for mem leaks.
|
||||
* Move stuff out of OSmain.
|
||||
|
||||
* $LK,"ROP_XOR","MN:ROP_XOR"$ with pen_width>1 is broken.
|
||||
|
||||
* use width and height in line clipping for pen_width>1 or blot.
|
||||
* SIMD transformation
|
||||
* test removable media id (critical for resident files)
|
||||
|
||||
* add field overflow U8 "t='*'"
|
||||
* Implement fmt codes into GetF
|
||||
* GetF date codes and maybe $FG,2$h$FG$ fmts for nums
|
||||
* Date Input
|
||||
* Default date fmt
|
||||
|
||||
* 16 bit Unassembly is bad--very low priority
|
||||
* more signed int disassembly
|
||||
* support r4u8 by adding 0x40 byte
|
||||
* static var off of data heap.
|
||||
* Might want to use U32*U32 multiplication.
|
||||
* could add "const" to not set LF_NOT_CONSTANT flag for trig, etc.
|
||||
* do r,rm ICCmp like ICBrCmp
|
||||
* could make glblvar imports use TY_RIP_DISP32.
|
||||
* PUSH_CMP allocs reg R9 or whatever
|
||||
* Might be problem with NOP in OPT pass1 for NO_PUSH in expressions besides assignments. Is ShiftNoPush fully implemented?
|
||||
* NOP1 might need to have diff ic_data's
|
||||
* in divequal, it assumes about ebx
|
||||
* error/warning line nums
|
||||
* ASM branch out warning of range off by 1 line--use lx->last_line_num
|
||||
|
||||
* Switch statement with sparse cases (low priority)
|
||||
* maybe inline functions?
|
||||
* Use of more floating-point stk?
|
||||
|
||||
* More aggressive in this routine $LK,"CmpF2PushPop","MN:CmpF2PushPop"$() with types besides MOV and F64.
|
||||
* !dbl ~dbl
|
||||
* &=, |= can overflow with Bts Btr on small data types
|
||||
|
||||
* num lock comes on with break key
|
||||
* sort options for findfiles
|
||||
* recalc_start could be more accurate before recalculating?
|
||||
* Maybe, get rid of $LK,"0x20000","FF:::/SparrowOS/Compiler/CmpMain.CPP.Z,0x20000"$ in compiler.
|
||||
* get rid of "$FG,2$$$PI$FG$" alias.
|
||||
@@ -0,0 +1,8 @@
|
||||
$TR,"Adam"$
|
||||
$ID,2$$TR,"SparrowOS"$
|
||||
$ID,2$$TR,"SysMsgFlags"$
|
||||
$ID,2$sys_msg_flags[0]=0x255;
|
||||
$ID,-2$$TR,"SysRegVer"$
|
||||
$ID,2$registry_version=1.020;
|
||||
$ID,-2$$ID,-2$$ID,-2$$TR,"SparrowOS"$
|
||||
$ID,2$$ID,-2$
|
||||
@@ -0,0 +1,413 @@
|
||||
#define CID_DFT 0
|
||||
#define CID_TAD8 1
|
||||
|
||||
I64 ts_cid=CID_DFT;
|
||||
|
||||
#include "::/SparrowOS/Accts/TS/TSIDComputer"
|
||||
|
||||
U0 VMDrvs(CATARep *root,CATARep **_ata_drv,CATARep **_atapi_drv)
|
||||
{
|
||||
CBlkDev *bd=Drv2BlkDev(dft_drv);
|
||||
CATARep *tempha=root,*ata_drv=NULL,*atapi_drv=NULL;
|
||||
Bool found_atapi=FALSE;
|
||||
while (tempha) {
|
||||
if (tempha->type==BDT_ATA) {
|
||||
if (!ata_drv || tempha->unit<ata_drv->unit ||
|
||||
tempha->unit==ata_drv->unit && tempha->num<ata_drv->num)
|
||||
ata_drv=tempha;
|
||||
} else if (tempha->type==BDT_ATAPI) {
|
||||
if (!found_atapi) {
|
||||
if (bd && tempha->base0==bd->base0 && tempha->unit==bd->unit) {
|
||||
atapi_drv=tempha;
|
||||
found_atapi=TRUE;
|
||||
} else if (!atapi_drv || tempha->unit<atapi_drv->unit ||
|
||||
tempha->unit==atapi_drv->unit && tempha->num<atapi_drv->num)
|
||||
atapi_drv=tempha;
|
||||
}
|
||||
}
|
||||
tempha=tempha->next;
|
||||
}
|
||||
if (_ata_drv) *_ata_drv =ata_drv;
|
||||
if (_atapi_drv) *_atapi_drv=atapi_drv;
|
||||
}
|
||||
|
||||
U0 TSInit()
|
||||
{
|
||||
//TS_TRA_DRV is for transfering files to dual booted OS's
|
||||
//TS_IMG_DRV is for the holding area for burning CDROMs
|
||||
CATARep *root=NULL,*ata_drv=NULL,*atapi_drv=NULL;
|
||||
CBlkDev *bd;
|
||||
switch (ts_cid) {
|
||||
case CID_TAD8:
|
||||
DefinePrintF("CFG_ACCT","\"\nTS/TAD\n\"");
|
||||
DefinePrintF("CFG_HARD_DRVS","\"h2s0xbc00\n0xb880\n1d2s0xbc00\n0xb880\n0\"");
|
||||
DefinePrintF("CFG_RAM_DRVS","\"b1Scale2Mem(2048,0x40000)\nz1Scale2Mem(2048,0x40000)\n\"");
|
||||
DefinePrintF("CFG_CDROM_DRVS","\"t3s0xb800\n0\"");
|
||||
DefinePrintF("CFG_DSK_CACHE","\"Scale2Mem(0x80000,0x8000000)\n\"");
|
||||
DefinePrintF("TS_HDS","\"DEI\"");
|
||||
DefinePrintF("TS_MASTER_BOOT_DRVS","\"I\"");
|
||||
DefinePrintF("TS_MAIN_DRV","\"D\"");
|
||||
DefinePrintF("TS_BAK_DRV","\"E\"");
|
||||
DefinePrintF("TS_RAM_DRV","\"B\"");
|
||||
DefinePrintF("TS_TRA_DRV","\"I\"");
|
||||
DefinePrintF("TS_WIN_DRV","\"H\"");
|
||||
DefinePrintF("TS_IMG_DRV","\"Z\"");
|
||||
DefinePrintF("TS_CDROM_DRV","\"T\"");
|
||||
break;
|
||||
default:
|
||||
DefinePrintF("CFG_ACCT","\"\nTS/TAD\n\"");
|
||||
DefinePrintF("CFG_HARD_DRVS","\"d2s0x1F0\n0x3F4\n0\"");
|
||||
DefinePrintF("CFG_RAM_DRVS","\"b1Scale2Mem(2048,0x40000)\nz1Scale2Mem(2048,0x40000)\n\"");
|
||||
DefinePrintF("CFG_CDROM_DRVS","\"t3s0x170\n0\"");
|
||||
bd=Drv2BlkDev(dft_drv);
|
||||
if (bd->type==BDT_ATAPI) {
|
||||
ATARep(FALSE,&root);
|
||||
VMDrvs(root,&ata_drv,&atapi_drv);
|
||||
if (ata_drv)
|
||||
DefinePrintF("CFG_HARD_DRVS","\"d2p%d\n\"",ata_drv->num);
|
||||
if (atapi_drv)
|
||||
DefinePrintF("CFG_CDROM_DRVS","\"t3p%d\n\"",atapi_drv->num);
|
||||
} else {
|
||||
bd=Drv2BlkDev('D');
|
||||
DefinePrintF("CFG_HARD_DRVS","\"d2s0x%X\n0x%X\n%d\"",
|
||||
bd->base0,bd->base1,bd->unit);
|
||||
bd=Drv2BlkDev('T');
|
||||
DefinePrintF("CFG_CDROM_DRVS","\"t3s0x%X\n%d\"",bd->base0,bd->unit);
|
||||
}
|
||||
DefinePrintF("CFG_DSK_CACHE","\"Scale2Mem(0x80000,0x8000000)\n\"");
|
||||
DefinePrintF("TS_HDS","\"DEF\"");
|
||||
DefinePrintF("TS_MASTER_BOOT_DRVS","\"D\"");
|
||||
DefinePrintF("TS_MAIN_DRV","\"D\"");
|
||||
DefinePrintF("TS_BAK_DRV","\"E\"");
|
||||
DefinePrintF("TS_RAM_DRV","\"B\"");
|
||||
DefinePrintF("TS_TRA_DRV","\"F\"");
|
||||
DefinePrintF("TS_WIN_DRV","\"\"");
|
||||
DefinePrintF("TS_IMG_DRV","\"Z\"");
|
||||
DefinePrintF("TS_CDROM_DRV","\"T\"");
|
||||
}
|
||||
} TSInit;
|
||||
|
||||
Bool ts_has_main_drv =ToBool(StrLen(TS_MAIN_DRV)),
|
||||
ts_has_bak_drv =ToBool(StrLen(TS_BAK_DRV)),
|
||||
ts_has_ram_drv =ToBool(StrLen(TS_BAK_DRV)),
|
||||
ts_has_tra_drv =ToBool(StrLen(TS_TRA_DRV)),
|
||||
ts_has_win_drv =ToBool(StrLen(TS_WIN_DRV)),
|
||||
ts_has_img_drv =ToBool(StrLen(TS_IMG_DRV)),
|
||||
ts_has_cdrom_drv=ToBool(StrLen(TS_CDROM_DRV));
|
||||
|
||||
U0 TSInit2()
|
||||
{
|
||||
DefinePrintF("TS_MAIN_DRV_LET","'%s'",TS_MAIN_DRV);
|
||||
DefinePrintF("TS_BAK_DRV_LET","'%s'",TS_BAK_DRV);
|
||||
DefinePrintF("TS_RAM_DRV_LET","'%s'",TS_RAM_DRV);
|
||||
DefinePrintF("TS_TRA_DRV_LET","'%s'",TS_TRA_DRV);
|
||||
DefinePrintF("TS_WIN_DRV_LET","'%s'",TS_WIN_DRV);
|
||||
DefinePrintF("TS_IMG_DRV_LET","'%s'",TS_IMG_DRV);
|
||||
DefinePrintF("TS_CDROM_DRV_LET","'%s'",TS_CDROM_DRV);
|
||||
} TSInit2;
|
||||
|
||||
if (ts_has_main_drv)
|
||||
SetDrvTextAttr(TS_MAIN_DRV_LET, WHITE <<4|BLUE);
|
||||
if (ts_has_bak_drv)
|
||||
SetDrvTextAttr(TS_BAK_DRV_LET, WHITE <<4|RED);
|
||||
if (ts_has_ram_drv)
|
||||
SetDrvTextAttr(TS_RAM_DRV_LET, BLUE <<4|YELLOW);
|
||||
if (ts_has_tra_drv)
|
||||
SetDrvTextAttr(TS_TRA_DRV_LET, WHITE <<4|BROWN);
|
||||
if (ts_has_win_drv)
|
||||
SetDrvTextAttr(TS_WIN_DRV_LET, LTRED <<4|BLACK);
|
||||
if (ts_has_img_drv)
|
||||
SetDrvTextAttr(TS_IMG_DRV_LET, BLUE <<4|LTRED);
|
||||
if (ts_has_cdrom_drv)
|
||||
SetDrvTextAttr(TS_CDROM_DRV_LET,LTGRAY<<4|BLUE);
|
||||
|
||||
#define TS_ISO_NAME TS_RAM_DRV ":/SparrowOSCD.ISO"
|
||||
|
||||
#define CFG_OPTS "ProtectLow\n\n"
|
||||
#define CFG_DBG_OPTS "ProtectLow\nDet\nHeapInit\n130\nMemInit\n131\nVarInit\n132\n\n"
|
||||
#define CFG_DBGZ_OPTS "ProtectLow\nDet\nHeapInit\n0\nMemInit\n0\nVarInit\n0\n\n"
|
||||
|
||||
#define TS_CFG CFG_RAM_DRVS CFG_CDROM_DRVS CFG_HARD_DRVS CFG_ACCT CFG_DSK_CACHE CFG_OPTS
|
||||
#define TS_MENU_CFG CFG_RAM_DRVS CFG_CDROM_DRVS CFG_HARD_DRVS "\n\n" CFG_DSK_CACHE CFG_OPTS
|
||||
#define TS_CDROM_CFG "b10x20000\nt3 \n\nTS\n\n\n"
|
||||
|
||||
//$BK,1$Change these, too...$BK,0$
|
||||
//$MA+A-X+PU,"PROD_CDROM_CFG","F(\"PROD_CDROM_CFG\");View;"$
|
||||
//$LK,"Install Acct","FF:::/SparrowOS/Accts/Install/DoItOnce.CPP.Z,InstallBoot"$
|
||||
|
||||
|
||||
U0 CtrlAltR(I64)
|
||||
{
|
||||
snd_record=!snd_record;
|
||||
}
|
||||
SetCtrlAltLetCB('R',&CtrlAltR,"Toggle snd_record");
|
||||
|
||||
Bool frame_grabber_paused=FALSE,
|
||||
frame_grabber_on=FALSE;
|
||||
|
||||
public U0 MyScreenShot(I64 bits=4)
|
||||
{
|
||||
U8 *st;
|
||||
CDirEntry *tempm;
|
||||
I64 cnt=0;
|
||||
tempm=FilesFind("::/Temp/ScreenShots/*.BMP");
|
||||
while (tempm) {
|
||||
cnt++;
|
||||
tempm=tempm->next;
|
||||
}
|
||||
st=MSPrintF("::/Temp/ScreenShots/SCRN%04d.BMP",cnt);
|
||||
BMPFileCaptureScreen(st,bits);
|
||||
Free(st);
|
||||
Beep;
|
||||
}
|
||||
|
||||
//This is the max rate for Windows Movie Maker.
|
||||
#define VIDEO_FRAME_RATE 8
|
||||
|
||||
#exe {
|
||||
if (ts_cid==CID_TAD8)
|
||||
StreamPutS("#define FRAME_DIR_CNT 600\n");
|
||||
else
|
||||
StreamPutS("#define FRAME_DIR_CNT 200\n");
|
||||
};
|
||||
|
||||
U0 FrameGrabberTask(I64)
|
||||
{
|
||||
I64 frame_num=0;
|
||||
I64 buf[136],buf2[136],buf3[136];
|
||||
F64 end_time=tNP,f;
|
||||
TaskInitExt;
|
||||
Silent(ON); //no output to screen
|
||||
while (frame_grabber_on) {
|
||||
SPrintF(buf2,"::/Temp/ScreenShots/V%03d",frame_num/FRAME_DIR_CNT);
|
||||
MkDir(buf2);
|
||||
SPrintF(buf,"%s/VID%05d.BMP.Z",buf2,frame_num%FRAME_DIR_CNT);
|
||||
frame_num++;
|
||||
Suspend(sys_winmgr_task,FALSE);
|
||||
BMPFileCaptureScreen(buf);
|
||||
Suspend(sys_winmgr_task);
|
||||
StrCpy(buf3,buf);
|
||||
|
||||
f=tNP;
|
||||
while (end_time<f) {
|
||||
end_time+=1.0/VIDEO_FRAME_RATE;
|
||||
if (end_time<f) {
|
||||
SPrintF(buf2,"::/Temp/ScreenShots/V%03d",frame_num/FRAME_DIR_CNT);
|
||||
MkDir(buf2);
|
||||
SPrintF(buf,"%s/VID%05d.BMP.Z",buf2,frame_num%FRAME_DIR_CNT);
|
||||
frame_num++;
|
||||
Copy(buf3,buf);
|
||||
}
|
||||
}
|
||||
LBts(&Fs->task_flags,TASKf_IDLE);
|
||||
while (sys_cur_scan_code&SCF_NUM) {
|
||||
Suspend(sys_winmgr_task,FALSE);
|
||||
Yield;
|
||||
end_time=tNP;
|
||||
}
|
||||
while (end_time>tNP) {
|
||||
Suspend(sys_winmgr_task,FALSE);
|
||||
Yield;
|
||||
}
|
||||
LBtr(&Fs->task_flags,TASKf_IDLE);
|
||||
}
|
||||
Suspend(sys_winmgr_task,FALSE);
|
||||
}
|
||||
|
||||
public U0 FrameGrabberToggle()
|
||||
{
|
||||
if (frame_grabber_on) {
|
||||
IOSnd(ON);
|
||||
frame_grabber_on=FALSE;
|
||||
Snd(0);
|
||||
snd_record=FALSE;
|
||||
} else {
|
||||
IOSnd(OFF); //You don't want to hear screen capture file writes
|
||||
frame_grabber_on=TRUE;
|
||||
Spawn(&FrameGrabberTask,NULL,"Frame Grabber");
|
||||
snd_record=TRUE;
|
||||
Snd(0);
|
||||
}
|
||||
}
|
||||
|
||||
U0 ScreenShotTask(I64)
|
||||
{
|
||||
TaskInitExt;
|
||||
MyScreenShot;
|
||||
}
|
||||
|
||||
U0 CtrlAltS(I64)
|
||||
{
|
||||
Spawn(&ScreenShotTask);
|
||||
}
|
||||
SetCtrlAltLetCB('S',&CtrlAltS,"Cmd/Screen Shot");
|
||||
|
||||
public U0 MBRRep(U8 drv_let='C')
|
||||
{
|
||||
CBlkDev *bdev=Drv2BlkDev(drv_let);
|
||||
I64 type,i,j,ext_base;
|
||||
I64 offset;
|
||||
CMasterBoot mbr;
|
||||
|
||||
if (bdev->type!=BDT_ATA)
|
||||
return;
|
||||
drv_let=bdev->drv_let_base;
|
||||
offset=0;
|
||||
ext_base=INVALID_CLUSTER;
|
||||
while (TRUE) {
|
||||
ATAReadBlks(bdev,&mbr,offset,1);
|
||||
"$$FG,PURPLE$$Blk:%08X$$FG$$\n",offset;
|
||||
ClassRep("CMasterBoot",&mbr);
|
||||
if (mbr.signature!=0xAA55)
|
||||
break;
|
||||
j=-1;
|
||||
for (i=0;i<4;i++) {
|
||||
"$$FG,CYAN$$ Entry #%d$$FG$$\n",i;
|
||||
if (mbr.p[i].active||mbr.p[i].type)
|
||||
ClassRep("CMBRPrt",&mbr.p[i]);
|
||||
if (mbr.p[i].type) {
|
||||
type=mbr.p[i].type;
|
||||
"$$FG,RED$$%C Offset:%08X Size:%08X Type:%X$$FG$$\n",
|
||||
drv_let,mbr.p[i].offset+offset,
|
||||
mbr.p[i].size,type;
|
||||
if (type==5 || type==0xF)
|
||||
j=i;
|
||||
else
|
||||
drv_let++;
|
||||
}
|
||||
}
|
||||
if (j<0)
|
||||
break;
|
||||
if (!mbr.p[j].offset)
|
||||
break;
|
||||
if (ext_base==INVALID_CLUSTER) {
|
||||
offset=mbr.p[j].offset;
|
||||
ext_base=offset;
|
||||
} else
|
||||
offset=mbr.p[j].offset+ext_base;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public U0 Abbr(U8 *word,U8 *abbr)
|
||||
{
|
||||
U8 buf1[136],buf2[136];
|
||||
StrCpy(buf1,word);
|
||||
StrCpy(buf2,abbr);
|
||||
|
||||
StrUtil(buf1,SUF_TO_LOWER);
|
||||
StrUtil(buf2,SUF_TO_LOWER);
|
||||
Grep(buf1,"/SparrowOS/"TEXT_FILE_MASK,"-l-i",buf2);
|
||||
|
||||
*buf1=ToUpper(*buf1);
|
||||
*buf2=ToUpper(*buf2);
|
||||
Grep(buf1,"/SparrowOS/"TEXT_FILE_MASK,"-l-i",buf2);
|
||||
|
||||
StrUtil(buf1,SUF_TO_UPPER);
|
||||
StrUtil(buf2,SUF_TO_UPPER);
|
||||
Grep(buf1,"/SparrowOS/"TEXT_FILE_MASK,"-l-i",buf2);
|
||||
}
|
||||
|
||||
public U0 ChkAll()
|
||||
{
|
||||
U8 *ptr=TS_HDS;
|
||||
while (*ptr)
|
||||
ChkDsk(*ptr++);
|
||||
}
|
||||
|
||||
public U0 MyHAllRep(U8 *flags="-p",U8 *index=NULL)
|
||||
{
|
||||
HashRep(Fs->hash_table,HTG_SRC_SYM-HTT_DEFINE_STR-HTT_CLASS,NULL,flags,0,index);
|
||||
}
|
||||
|
||||
public CDoc *DC2Doc(CDC *dc,I64 dx=0,I64 dy=0,I64 *_total_score=NULL)
|
||||
{
|
||||
I64 *ptr;
|
||||
U8 byte_bit_cnts[256],st[2];
|
||||
I64 i,j,row,col,ch,best_ch,score,best_score,cur_char_image,diff_image,total_score=0;
|
||||
CDoc *doc=DocNew;
|
||||
|
||||
MemSet(st,0,sizeof(st));
|
||||
MemSet(byte_bit_cnts,0,sizeof(byte_bit_cnts));
|
||||
for (i=0;i<256;i++)
|
||||
for (j=0;j<7;j++)
|
||||
if (Bt(&i,j))
|
||||
byte_bit_cnts[i]++;
|
||||
|
||||
for (row=0;row<dc->height/FONT_HEIGHT;row++) {
|
||||
for (col=0;col<dc->width/FONT_WIDTH;col++) {
|
||||
|
||||
cur_char_image=0;
|
||||
for (i=0;i<FONT_HEIGHT;i++)
|
||||
for (j=0;j<FONT_WIDTH;j++)
|
||||
if (GrPeek(dc,col*FONT_WIDTH+j+dx,row*FONT_HEIGHT+i+dy)!=WHITE)
|
||||
LBts(&cur_char_image,i*8+j);
|
||||
|
||||
best_score=MAX_I64;
|
||||
best_ch=0;
|
||||
ptr=&gr_font[32*FONT_HEIGHT];
|
||||
for (ch=32;ch<127;ch++) {
|
||||
diff_image=*ptr++ ^ cur_char_image;
|
||||
score=0;
|
||||
for (i=0;i<8;i++)
|
||||
score+=byte_bit_cnts[diff_image.u8[i]];
|
||||
if (score<best_score) {
|
||||
best_score=score;
|
||||
best_ch=ch;
|
||||
}
|
||||
}
|
||||
if (best_ch=='$$')
|
||||
DocPutS(doc,"$$$$");
|
||||
else {
|
||||
*st=best_ch;
|
||||
DocPutS(doc,st);
|
||||
}
|
||||
total_score+=best_score;
|
||||
}
|
||||
DocPutS(doc,"\n");
|
||||
}
|
||||
if (_total_score) *_total_score=total_score;
|
||||
return doc;
|
||||
}
|
||||
|
||||
public U0 BMP2TXT(U8 *_in_name,U8 *_out_name=NULL)
|
||||
{
|
||||
U8 *in_name,*out_name;
|
||||
I64 dx,dy,score,best_score=MAX_I64;
|
||||
CDC *dc;
|
||||
CDoc *doc;
|
||||
in_name=DftExt(_in_name,"BMP"),
|
||||
if (_out_name)
|
||||
out_name=DftExt(_out_name,"TXT.Z");
|
||||
else
|
||||
out_name=ChgExt(_in_name,"TXT.Z");
|
||||
if (dc=BMPFileRead(in_name)) {
|
||||
for (dy=-3;dy<=4;dy++)
|
||||
for (dx=-3;dx<=4;dx++) {
|
||||
doc=DC2Doc(dc,dx,dy,&score);
|
||||
if (score<best_score) {
|
||||
best_score=score;
|
||||
StrCpy(&doc->filename.name,out_name);
|
||||
DocWrite(doc);
|
||||
}
|
||||
DocDel(doc);
|
||||
}
|
||||
}
|
||||
Free(in_name);
|
||||
Free(out_name);
|
||||
}
|
||||
|
||||
|
||||
U0 CopyVideo()
|
||||
{
|
||||
U8 *st;
|
||||
if (ts_has_tra_drv) {
|
||||
Del(TS_TRA_DRV ":/Temp/*.SND");
|
||||
st=MSPrintF("#include \"::/SparrowOS/Apps/MusicOrgan/Load\";"
|
||||
"SndFileCreate(\"" TS_TRA_DRV ":/Temp/Audio\",0.23,0.0,WF_NULL,0.45,0.35);");
|
||||
PopUp(st);
|
||||
Free(st);
|
||||
DelTree(TS_TRA_DRV ":/Temp/ScreenShots");
|
||||
CopyTree("::/Temp/ScreenShots",TS_TRA_DRV ":/Temp/ScreenShots");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,543 @@
|
||||
//The CFG defines are $LK,"Here","FI:::/SparrowOS/Demo/AcctExample/TSAdam.CPP.Z"$.
|
||||
|
||||
U0 ShowBootFileDate(U8 drv_let)
|
||||
{
|
||||
CDirEntry de;
|
||||
U8 *name=MSPrintF("%c:/OSMain.BIN.C",drv_let);
|
||||
if (FileFind(name,&de))
|
||||
"%s %D %T\n",name,de.datetime,de.datetime;
|
||||
else
|
||||
"%s\n",name;
|
||||
Free(name);
|
||||
}
|
||||
|
||||
U0 ShowBootFiles()
|
||||
{
|
||||
U8 *ptr=TS_HDS;
|
||||
while (*ptr)
|
||||
ShowBootFileDate(*ptr++);
|
||||
}
|
||||
|
||||
U8 DrvMySelect()
|
||||
{
|
||||
I64 result;
|
||||
ShowBootFiles;
|
||||
"Drive:";
|
||||
result=ToUpper(GetChar);
|
||||
NewLine;
|
||||
return result;
|
||||
}
|
||||
|
||||
U0 CmpDrv(U8 drv_let)
|
||||
{
|
||||
drv_let=ToUpper(drv_let);
|
||||
Auto(TS_CFG);
|
||||
InstallBoot(drv_let);
|
||||
if (StrOcc(TS_MASTER_BOOT_DRVS,drv_let))
|
||||
InstallMasterBoot(drv_let);
|
||||
}
|
||||
|
||||
U0 QMenuBoot(U8 drv_let=0)
|
||||
{
|
||||
if (!drv_let)
|
||||
drv_let=Prt2Drv(Fs->cur_prt);
|
||||
Drv(drv_let);
|
||||
Cd("/SparrowOS/OSMain");
|
||||
Auto(TS_MENU_CFG);
|
||||
if (!Cmp("OSMain","OSMain",NULL,':'))
|
||||
Boot("OSMain.BIN.Z");
|
||||
}
|
||||
|
||||
U0 UpdateAndCompile(U8 src,U8 dst)
|
||||
{
|
||||
U8 buf_s[128],buf_d[128];
|
||||
if (src==dst) return;
|
||||
|
||||
SPrintF(buf_s,"%c:/SparrowOS",src);
|
||||
SPrintF(buf_d,"%c:/SparrowOS",dst);
|
||||
CopyTree(buf_s,buf_d);
|
||||
CmpDrv(dst);
|
||||
}
|
||||
|
||||
U0 PromptUpdateDrv()
|
||||
{
|
||||
U8 src,dst;
|
||||
"\nSrc Drive:\n";
|
||||
src=DrvMySelect;
|
||||
"\nDst Drive:\n";
|
||||
dst=DrvMySelect;
|
||||
UpdateAndCompile(src,dst);
|
||||
ShowBootFiles;
|
||||
Drv(src);
|
||||
}
|
||||
|
||||
U0 MyMerge()
|
||||
{
|
||||
U8 src,dst,buf_s[128],buf_d[128];
|
||||
"\nMerge Src Drive:\n";
|
||||
src=DrvMySelect;
|
||||
"\nMerge Dst Drive:\n";
|
||||
dst=DrvMySelect;
|
||||
SPrintF(buf_s,"%c:/SparrowOS/*",src);
|
||||
SPrintF(buf_d,"%c:/SparrowOS/*",dst);
|
||||
MergeChk(buf_d,buf_s,"+r+d");
|
||||
Drv(dst);
|
||||
}
|
||||
|
||||
U0 MyCopyDrv(U8 src,U8 dst)
|
||||
{
|
||||
U8 buf_s[128],buf_d[128];
|
||||
src=ToUpper(src);
|
||||
dst=ToUpper(dst);
|
||||
|
||||
Fmt(dst,TRUE,FALSE,PT_FAT32);
|
||||
|
||||
SPrintF(buf_s,"%c:/SparrowOS",src);
|
||||
SPrintF(buf_d,"%c:/SparrowOS",dst);
|
||||
CopyTree(buf_s,buf_d);
|
||||
|
||||
SPrintF(buf_s,"%c:/Windows",src);
|
||||
SPrintF(buf_d,"%c:/Windows",dst);
|
||||
CopyTree(buf_s,buf_d);
|
||||
|
||||
SPrintF(buf_s,"%c:/Linux",src);
|
||||
SPrintF(buf_d,"%c:/Linux",dst);
|
||||
CopyTree(buf_s,buf_d);
|
||||
|
||||
SPrintF(buf_s,"%c:/0000Boot",src);
|
||||
SPrintF(buf_d,"%c:/0000Boot",dst);
|
||||
CopyTree(buf_s,buf_d);
|
||||
|
||||
SPrintF(buf_d,"%c:/Temp",dst);
|
||||
MkDir(buf_d);
|
||||
|
||||
SPrintF(buf_d,"%c:/Temp/ScreenShots",dst);
|
||||
MkDir(buf_d);
|
||||
|
||||
if (ts_has_tra_drv && dst==TS_TRA_DRV_LET) {
|
||||
SPrintF(buf_d,"%c:/Logs",dst);
|
||||
MkDir(buf_d);
|
||||
SPrintF(buf_d,"%c:/Logs/SPARROWOSLogs",dst);
|
||||
MkDir(buf_d);
|
||||
}
|
||||
DocClear;
|
||||
Drv(dst);
|
||||
CmpDrv(dst);
|
||||
}
|
||||
|
||||
U0 PmtMyCopyDrv()
|
||||
{
|
||||
U8 src,dst;
|
||||
"$$FG,RED$$\nCopy Src Drive:\n$$FG$$";
|
||||
src=DrvMySelect;
|
||||
"$$FG,RED$$\nCopy Dst Drive:\n$$FG$$";
|
||||
dst=DrvMySelect;
|
||||
MyCopyDrv(src,dst);
|
||||
}
|
||||
|
||||
public U0 FileCursorRem(U8 *filename)
|
||||
{
|
||||
CDoc *doc;
|
||||
doc=DocRead(filename,DOCF_PLAIN_TEXT|DOCF_NO_CURSOR);
|
||||
DocWrite(doc);
|
||||
DocDel(doc);
|
||||
}
|
||||
|
||||
public U0 FileCursorTop(U8 *filename)
|
||||
{
|
||||
CDoc *doc;
|
||||
doc=DocRead(filename,DOCF_PLAIN_TEXT);
|
||||
doc->cur_entry=doc->root.next;
|
||||
DocWrite(doc);
|
||||
DocDel(doc);
|
||||
}
|
||||
|
||||
public U0 FilesCursorRem(U8 *mask="*")
|
||||
{
|
||||
I64 fuf_flags=0;
|
||||
GetFFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r+t+f+F");
|
||||
CDirEntry *tempm=FilesFind(mask,fuf_flags),*tempm1;
|
||||
while (tempm) {
|
||||
tempm1=tempm->next;
|
||||
FileCursorRem(tempm->full_name);
|
||||
Touch(tempm->full_name,"","",tempm->datetime);
|
||||
CDirEntryDel(tempm);
|
||||
tempm=tempm1;
|
||||
}
|
||||
}
|
||||
|
||||
public U0 FilesCursorTop(U8 *mask="*")
|
||||
{
|
||||
I64 fuf_flags=0;
|
||||
GetFFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r+t+f+F");
|
||||
CDirEntry *tempm=FilesFind(mask,fuf_flags),*tempm1;
|
||||
while (tempm) {
|
||||
tempm1=tempm->next;
|
||||
FileCursorTop(tempm->full_name);
|
||||
Touch(tempm->full_name,"","",tempm->datetime);
|
||||
CDirEntryDel(tempm);
|
||||
tempm=tempm1;
|
||||
}
|
||||
}
|
||||
|
||||
U0 UncollapseFile(U8 *filename,I64 *)
|
||||
{
|
||||
CDoc *doc=DocRead(filename,DOCF_NO_CURSOR);
|
||||
DocCollapse(FALSE,doc);
|
||||
DocWrite(doc);
|
||||
DocDel(doc);
|
||||
}
|
||||
|
||||
U0 UncollapseList(CDirEntry *tempm1,I64 *flags)
|
||||
{
|
||||
CDirEntry *tempm2;
|
||||
while (tempm1 && !Bt(flags,FUf_CANCEL)) {
|
||||
tempm2=tempm1->next;
|
||||
if (tempm1->attr & _ATTR_DIR) {
|
||||
if (tempm1->sub) {
|
||||
"%S %s\n","ST_SCANNING_DIR",tempm1->full_name;
|
||||
UncollapseList(tempm1->sub,flags);
|
||||
}
|
||||
} else
|
||||
UncollapseFile(tempm1->full_name,flags);
|
||||
CDirEntryDel(tempm1);
|
||||
tempm1=tempm2;
|
||||
}
|
||||
}
|
||||
|
||||
U0 Uncollapse(U8 *files_find_mask=TEXT_FILE_MASK,U8 *fu_flags=NULL)
|
||||
{
|
||||
I64 f=0;
|
||||
GetFFlags(&f,Define("ST_FILE_UTIL_FLAGS"),"+r");
|
||||
GetFFlags(&f,Define("ST_FILE_UTIL_FLAGS"),fu_flags);
|
||||
UncollapseList(FilesFind(files_find_mask,f),&f);
|
||||
}
|
||||
|
||||
U0 CopySongDir(U8 *files_find_mask,U8 threshold)
|
||||
{
|
||||
CDoc *s;
|
||||
CDocEntry *doc_e;
|
||||
CDirEntry *tempm,*tempm1;
|
||||
tempm1=tempm=FilesFind(files_find_mask);
|
||||
while (tempm1) {
|
||||
s=DocRead(tempm1->full_name);
|
||||
doc_e=s->root.next;
|
||||
if (doc_e->type_u8==DOCT_TEXT && doc_e->tag[2]>=threshold)
|
||||
Copy(tempm1->full_name,"/SparrowOS/Apps/MusicOrgan/Examples");
|
||||
tempm1=tempm1->next;
|
||||
}
|
||||
CDirListDel(tempm);
|
||||
}
|
||||
|
||||
public U0 CopySongs(U8 threshold='7')
|
||||
{
|
||||
DelTree("/SparrowOS/Apps/MusicOrgan/Examples");
|
||||
MkDir("/SparrowOS/Apps/MusicOrgan/Examples");
|
||||
CopySongDir("/SparrowOS/Accts/TS/TAD/MusicOrgan/*.CPP.Z",threshold);
|
||||
}
|
||||
|
||||
U0 PrepForDistribution()
|
||||
{
|
||||
Del("/SparrowOS/Demo/WebLogExample/WebLog.TXT.Z");
|
||||
Del("/SparrowOS/Demo/GameStarters/EagleDive.BIN.Z");
|
||||
DelTree("/SparrowOS/Accts/*Temp.TXT.Z");
|
||||
CopySongs;
|
||||
|
||||
//User
|
||||
Del("/SparrowOS/Accts/User/Registry.CPP.Z");
|
||||
|
||||
//Install
|
||||
Del("/SparrowOS/Accts/Install/Registry.CPP.Z");
|
||||
|
||||
//SafeMode
|
||||
Del("/SparrowOS/Accts/SafeMode/Registry.CPP.Z");
|
||||
|
||||
Touch("/SparrowOS/Accts/PersonalMenu.TXT.Z","+T");
|
||||
//TS
|
||||
Touch("/SparrowOS/Accts/TS/PersonalMenu.TXT.Z","+T");
|
||||
|
||||
DelTree("/SparrowOS/Demo/AcctExample");
|
||||
CopyTree("/SparrowOS/Accts/TS","/SparrowOS/Demo/AcctExample");
|
||||
DelTree("/SparrowOS/Demo/AcctExample/TAD/MusicOrgan");
|
||||
DelTree("/SparrowOS/Demo/AcctExample/Wb2");
|
||||
Del("/SparrowOS/Demo/AcctExample/TAD/Test*");
|
||||
|
||||
Cd("/SparrowOS");
|
||||
FilesCursorTop;
|
||||
|
||||
DelTree("/SparrowOS/Demo/*.BI?");
|
||||
|
||||
Cd("/SparrowOS");
|
||||
S2T(SRC_FILE_MASK,"+r");
|
||||
Move(WSD_DEF_FILENAME,WSD_DEF_FILENAME_Z);
|
||||
}
|
||||
|
||||
U0 PrepForInHouse()
|
||||
{
|
||||
Drv(TS_MAIN_DRV_LET);
|
||||
PrepForDistribution;
|
||||
Auto(TS_CDROM_CFG);
|
||||
InstallBoot(TS_MAIN_DRV_LET,TS_CDROM_DRV_LET);
|
||||
Fmt(TS_IMG_DRV_LET,TRUE,FALSE,PT_NATIVE);
|
||||
Drv(TS_IMG_DRV_LET);
|
||||
CopyTree(TS_MAIN_DRV ":/SparrowOS","/SparrowOS");
|
||||
CopyTree(TS_MAIN_DRV ":/Windows","/Windows");
|
||||
CopyTree(TS_MAIN_DRV ":/Linux","/Linux");
|
||||
MkDir("/Temp");
|
||||
MkDir("/Temp/ScreenShots");
|
||||
CopyTree(TS_MAIN_DRV ":/0000Boot","/0000Boot");
|
||||
}
|
||||
|
||||
U0 MakeSymbolFiles()
|
||||
{
|
||||
CDoc *doc;
|
||||
U8 *st;
|
||||
if (ts_has_tra_drv) {
|
||||
DocClear;
|
||||
DocMax;
|
||||
HashRep(Fs->hash_table,HTG_ALL,NULL,"-p",0,NULL);
|
||||
if (doc=DocCur) {
|
||||
st=StrNew(doc->filename.name);
|
||||
StrCpy(doc->filename.name,TS_TRA_DRV ":/Wb/Accts/TS/Wb2/SymbolsAlpha.TXT.Z");
|
||||
DocWrite(doc);
|
||||
StrCpy(doc->filename.name,st);
|
||||
Free(st);
|
||||
}
|
||||
DocClear;
|
||||
DocMax;
|
||||
HashRep(Fs->hash_table,HTG_ALL,NULL,"-p+m",0,NULL);
|
||||
if (doc=DocCur) {
|
||||
st=StrNew(doc->filename.name);
|
||||
StrCpy(doc->filename.name,TS_TRA_DRV ":/Wb/Accts/TS/Wb2/SymbolsAddress.TXT.Z");
|
||||
DocWrite(doc);
|
||||
StrCpy(doc->filename.name,st);
|
||||
Free(st);
|
||||
}
|
||||
DocClear;
|
||||
}
|
||||
}
|
||||
|
||||
I64 MakeLineCntFile()
|
||||
{
|
||||
U8 *st;
|
||||
CDoc *doc;
|
||||
I64 result;
|
||||
CDocEntry *tree_branch,*start_indent,*end_indent;
|
||||
|
||||
DocClear;
|
||||
Drv(TS_MAIN_DRV_LET);
|
||||
PrepForDistribution;
|
||||
|
||||
DocMax;
|
||||
DocClear;
|
||||
Cd(TS_MAIN_DRV ":/SparrowOS");
|
||||
result=LineCntRep;
|
||||
if (doc=DocCur) {
|
||||
st=StrNew(doc->filename.name);
|
||||
StrCpy(doc->filename.name,TS_MAIN_DRV ":/SparrowOS/Accts/TS/Wb2/LineCnt.TXT.Z");
|
||||
DocWrite(doc);
|
||||
StrCpy(doc->filename.name,st);
|
||||
Free(st);
|
||||
}
|
||||
DocClear;
|
||||
|
||||
doc=DocRead(TS_MAIN_DRV ":/SparrowOS/Adam/DocDefines.CPP.Z");
|
||||
DocTreeFind(doc,"LineCnt",&tree_branch,&start_indent,&end_indent);
|
||||
DocCut(doc,start_indent->next,end_indent->last);
|
||||
doc->cur_entry=start_indent->next;
|
||||
doc->cur_data_col=0;
|
||||
DocPrintF(doc,"DefinePrintF(\"DD_SPARROWOS_LOC\",\"%,d\");\n",result);
|
||||
|
||||
st=MSPrintF("%,d",result);
|
||||
DefineLoad("DD_SPARROWOS_LOC",st);
|
||||
Free(st);
|
||||
|
||||
DocWrite(doc);
|
||||
DocDel(doc);
|
||||
|
||||
"Total LOC:%12,d\n\n",result;
|
||||
return result;
|
||||
}
|
||||
|
||||
U0 PrepForProduction(U8 *auto_cfg)
|
||||
{
|
||||
Drv(TS_MAIN_DRV_LET);
|
||||
PrepForDistribution;
|
||||
Auto(auto_cfg);
|
||||
InstallBoot(TS_MAIN_DRV_LET,TS_CDROM_DRV_LET);
|
||||
Fmt(TS_IMG_DRV_LET,TRUE,FALSE,PT_NATIVE);
|
||||
Drv(TS_IMG_DRV_LET);
|
||||
CopyTree(TS_MAIN_DRV ":/SparrowOS","/SparrowOS");
|
||||
CopyTree(TS_MAIN_DRV ":/Windows","/Windows");
|
||||
CopyTree(TS_MAIN_DRV ":/Linux","/Linux");
|
||||
MkDir("/Temp");
|
||||
DelTree("/SparrowOS/Accts/TS");
|
||||
CopyTree(TS_MAIN_DRV ":/0000Boot","/0000Boot");
|
||||
Del("/0000Boot/OldMBR.BIN.C");
|
||||
Del("/0000Boot/BootMHD2.BIN.C");
|
||||
}
|
||||
|
||||
U0 MakeInHouseCDImage()
|
||||
{
|
||||
PrepForInHouse;
|
||||
CDFileCreate(TS_ISO_NAME,TS_IMG_DRV ":/*",NULL,BOOTCD_BIN_Z);
|
||||
Drv(TS_MAIN_DRV_LET);
|
||||
}
|
||||
|
||||
U0 MakeProductionCDImage()
|
||||
{
|
||||
PrepForProduction(PROD_CDROM_CFG);
|
||||
CDFileCreate(TS_ISO_NAME,TS_IMG_DRV ":/*",NULL,BOOTCD_BIN_Z);
|
||||
Drv(TS_MAIN_DRV_LET);
|
||||
}
|
||||
|
||||
U0 TSWebFile(U8 *name)
|
||||
{
|
||||
U8 *name2;
|
||||
CDirEntry de;
|
||||
if (FileFind(name,&de)) {
|
||||
"File:%s\n",name;
|
||||
UncollapseFile(name,NULL);
|
||||
Touch(name,"",NULL,de.datetime);
|
||||
name2=ChgExt(name,"html");
|
||||
ToHtml(name,name2,
|
||||
"<title>The Sparrow Operating System</title>\n"
|
||||
"<meta name=\"keywords\" content=\"Operating System,64-Bit,64 Bit,Sparrow,OS,SparrowOS,Free,Open Source,Public Domain,x86_64\">\n"
|
||||
);
|
||||
Touch(name2,"",NULL,de.datetime);
|
||||
Free(name2);
|
||||
}
|
||||
}
|
||||
|
||||
U0 MakeWebSite()
|
||||
{
|
||||
CDirEntry *tempm,*tempm2;
|
||||
if (ts_has_tra_drv) {
|
||||
DocClear;
|
||||
Cd(TS_TRA_DRV ":/Wb");
|
||||
tempm=tempm2=FilesFind(TEXT_FILE_MASK,FUF_RECURSE|FUF_FLATTEN_TREE|FUF_JUST_FILES);
|
||||
while (tempm) {
|
||||
TSWebFile(tempm->full_name);
|
||||
tempm=tempm->next;
|
||||
}
|
||||
CDirListDel(tempm2);
|
||||
Drv(TS_MAIN_DRV_LET);
|
||||
}
|
||||
}
|
||||
|
||||
U0 ToWeb(U8 *name)
|
||||
{
|
||||
U8 *st,*st2;
|
||||
if (ts_has_tra_drv) {
|
||||
st=FileNameAbs(name);
|
||||
if (!StrNCmp(st+1,":/SparrowOS/",12)) {
|
||||
st2=MSPrintF(TS_TRA_DRV":/Wb/%s",st+13);
|
||||
"%s\n",st2;
|
||||
Copy(name,st2);
|
||||
TSWebFile(st2);
|
||||
Free(st2);
|
||||
}
|
||||
Free(st);
|
||||
}
|
||||
}
|
||||
|
||||
U0 TSUncompress()
|
||||
{
|
||||
U8 *st;
|
||||
CDirEntry *tempm,*tempm1;
|
||||
if (ts_has_tra_drv) {
|
||||
DelTree(TS_TRA_DRV ":/Uncompressed");
|
||||
CopyTree(TS_MAIN_DRV ":/SparrowOS",TS_TRA_DRV ":/Uncompressed");
|
||||
tempm=FilesFind(TS_TRA_DRV ":/Uncompressed/*.Z",FUF_RECURSE|FUF_FLATTEN_TREE|FUF_JUST_FILES);
|
||||
while (tempm) {
|
||||
tempm1=tempm->next;
|
||||
st=StrNew(tempm->full_name);
|
||||
StrLastRem(st,".");
|
||||
Move(tempm->full_name,st);
|
||||
Free(st);
|
||||
CDirEntryDel(tempm);
|
||||
tempm=tempm1;
|
||||
}
|
||||
FilesCursorRem(TS_TRA_DRV ":/Uncompressed/" TEXT_FILE_MASK);
|
||||
}
|
||||
}
|
||||
|
||||
U0 MakeBack()
|
||||
{
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
WordStat;
|
||||
WinMax;
|
||||
WinBorder;
|
||||
ChkAll;
|
||||
MyCopyDrv(TS_MAIN_DRV_LET,TS_BAK_DRV_LET);
|
||||
if (ts_has_tra_drv) {
|
||||
MakeLineCntFile;
|
||||
MyCopyDrv(TS_MAIN_DRV_LET,TS_TRA_DRV_LET);
|
||||
DelTree (TS_TRA_DRV ":/Wb");
|
||||
CopyTree(TS_MAIN_DRV ":/SparrowOS",TS_TRA_DRV ":/Wb");
|
||||
DocClear;
|
||||
MakeInHouseCDImage;
|
||||
DocClear;
|
||||
Copy(TS_ISO_NAME,TS_TRA_DRV ":/Wb/SparrowOSTS.ISO");
|
||||
MakeProductionCDImage;
|
||||
DocClear;
|
||||
Copy(TS_ISO_NAME,TS_TRA_DRV ":/Wb/SparrowOSCD.ISO");
|
||||
Cd(TS_MAIN_DRV ":/SparrowOS");
|
||||
if (LinkChk)
|
||||
throw;
|
||||
MakeSymbolFiles;
|
||||
MakeWebSite;
|
||||
TSUncompress;
|
||||
}
|
||||
ChkAll;
|
||||
SettingsPop;
|
||||
}
|
||||
|
||||
public U0 TSMount()
|
||||
{
|
||||
Auto(CFG_HARD_DRVS "\n");
|
||||
Mount;
|
||||
}
|
||||
|
||||
U0 TSCopy()
|
||||
{
|
||||
DelTree(TS_MAIN_DRV ":/SparrowOS");
|
||||
CopyTree(TS_CDROM_DRV ":/",TS_MAIN_DRV ":/");
|
||||
CmpDrv(TS_MAIN_DRV_LET);
|
||||
DelTree(TS_BAK_DRV ":/SparrowOS");
|
||||
CopyTree(TS_CDROM_DRV ":/",TS_BAK_DRV ":/");
|
||||
CmpDrv(TS_BAK_DRV_LET);
|
||||
if (ts_has_tra_drv) {
|
||||
DelTree(TS_TRA_DRV ":/SparrowOS");
|
||||
CopyTree(TS_CDROM_DRV ":/",TS_TRA_DRV ":/");
|
||||
CmpDrv(TS_TRA_DRV_LET);
|
||||
}
|
||||
Reboot;
|
||||
}
|
||||
|
||||
U0 TSPrtDsk()
|
||||
{
|
||||
CTask *task=SpawnUser;
|
||||
CATARep *root=NULL,*ata_drv=NULL,*atapi_drv=NULL;
|
||||
ATARep(FALSE,&root);
|
||||
VMDrvs(root,&ata_drv,&atapi_drv);
|
||||
if (ata_drv) {
|
||||
XTalkWait(task,"PrtDsk;\nY%C2p%d\nYYY",TS_MAIN_DRV_LET,ata_drv->num);
|
||||
XTalkWait(task,"%d\nY%d\nY\nY\n",(prt_dsk_dsk_size-PRT_HEADER)/3,(prt_dsk_dsk_size-PRT_HEADER)/3);
|
||||
}
|
||||
Kill(task);
|
||||
}
|
||||
|
||||
|
||||
public U0 TSUpdate()
|
||||
{
|
||||
TSMount;
|
||||
TSCopy;
|
||||
}
|
||||
|
||||
public U0 TSInstall()
|
||||
{
|
||||
TSPrtDsk;
|
||||
TSCopy;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
U0 TSIDComputer()
|
||||
{
|
||||
CMemE820 *m20=SYS_MEM_E820;
|
||||
if (m20[11].base==0x100000000 &&
|
||||
m20[11].base(I64)+m20[11].len-1==0x33FFFFFFF)
|
||||
ts_cid=CID_TAD8;
|
||||
} TSIDComputer;
|
||||
@@ -0,0 +1,7 @@
|
||||
U0 TSIDComputer()
|
||||
{
|
||||
CMemE820 *m20=SYS_MEM_E820;
|
||||
if (m20[11].base==0x100000000 &&
|
||||
m20[11].base(I64)+m20[11].len-1==0x33FFFFFFF)
|
||||
ts_cid=CID_TAD8;
|
||||
} TSIDComputer;
|
||||
@@ -0,0 +1,83 @@
|
||||
/*
|
||||
This is a JIT file, not static.
|
||||
|
||||
Asm labels can only be defined once
|
||||
in a task. Hit F5 to spawn a new task
|
||||
and run it.
|
||||
*/
|
||||
|
||||
asm {
|
||||
//Opcodes are slightly different to make writing my x86_64 assembler easier.
|
||||
//See $LK,"::/SparrowOS/Compiler/OpCodes.TXT.Z","FI:::/SparrowOS/Compiler/OpCodes.TXT.Z"$.
|
||||
USE64 //Defaults to 64, but this is a good habit.
|
||||
IMPORT Beep;
|
||||
|
||||
_BEEPS::
|
||||
//You can clobber RAX,RBX,RCX,RDX,R8,R9 in a pure asm subroutine.
|
||||
ENTER 0
|
||||
MOV RCX,U64 SF_ARG1[RBP] //$LK,"SF_ARG1","FF:::/SparrowOS/OSMain/Adam1a.HPP.Z,SF_ARG1"$
|
||||
|
||||
@@05: PUSH RCX
|
||||
//U0 Beep(I64 freq=500,Bool busy=FALSE)
|
||||
PUSH FALSE //Do not busy (spin) wait
|
||||
PUSH 500 //Hz
|
||||
CALL Beep
|
||||
POP RCX
|
||||
LOOP @@05
|
||||
|
||||
LEAVE
|
||||
//Return vals are in RAX if you have one.
|
||||
RET1 8
|
||||
}
|
||||
|
||||
|
||||
//_extern binds a asm sym to a function.
|
||||
//My convention is to put an underscore
|
||||
//on C callable routines.
|
||||
_extern _BEEPS U0 Beeps(I64 cnt);
|
||||
|
||||
I64 AsmAndC()
|
||||
{
|
||||
I64 noreg i; //Normally this would be stored in a reg
|
||||
//Check with $LK,"Uf","MN:Uf"$("AsmAndC").
|
||||
|
||||
i=PmtI64("Num of beeps 1-5 (%d):",3,1,5);
|
||||
Beeps(i);
|
||||
|
||||
asm {
|
||||
//You can clobber RAX,RBX,RCX,RDX, but preserve the rest for code in a C+ routine.
|
||||
USE64 //Defaults to 64, but this is a good habit.
|
||||
IMPORT Snd;
|
||||
MOV RCX,&i[RBP] //You can clobber RAX,RBX,RCX,RDX.
|
||||
//You better preserve the rest.
|
||||
|
||||
@@05: PUSH RCX
|
||||
//U0 Snd(F64 freq,I64 waveform=WF_SQUARE,F64 amp=1.0);
|
||||
MOV RAX,1.0 //amplitude
|
||||
PUSH RAX
|
||||
PUSH WF_SQUARE
|
||||
|
||||
MOV RAX,RCX //freq=loop*100.0+100.0
|
||||
IMUL2 RAX,100 //SparrowOS uses nonstandard opcodes
|
||||
//to avoid multiple form of the same one.
|
||||
//See $LK,"::/SparrowOS/Compiler/OpCodes.TXT.Z","FI:::/SparrowOS/Compiler/OpCodes.TXT.Z"$.
|
||||
//$BK,1$Asm is kind-of a bonus -- there's no reason$BK,0$
|
||||
//$BK,1$to use it, but I need it for the kernel.$BK,0$
|
||||
ADD RAX,100
|
||||
PUSH RAX
|
||||
FILD U64 [RSP] //Convert from int to floating
|
||||
FSTP U64 [RSP]
|
||||
|
||||
CALL Snd
|
||||
|
||||
MOV RCX,0x20000000 //Simple delay loop
|
||||
@@10: LOOP @@10
|
||||
|
||||
POP RCX
|
||||
LOOP @@05
|
||||
}
|
||||
Snd(0);
|
||||
return i;
|
||||
}
|
||||
|
||||
"Beeps:%d\n",AsmAndC;
|
||||
@@ -0,0 +1,98 @@
|
||||
/*
|
||||
This is a JIT file, not static.
|
||||
|
||||
Asm labels can only be defined once
|
||||
in a task. Hit F5 to spawn a new task
|
||||
and run it.
|
||||
*/
|
||||
|
||||
//This is to demo glbl var access.
|
||||
//Glbs defined elsewhere can accessed too, like sys_jiffies.
|
||||
I64 glbl_hz=400,glbl_hz_step=100,glbl_hz_base=100;
|
||||
|
||||
asm {
|
||||
//Opcodes are slightly different to make writing my x86_64 assembler easier.
|
||||
//See $LK,"::/SparrowOS/Compiler/OpCodes.TXT.Z","FI:::/SparrowOS/Compiler/OpCodes.TXT.Z"$.
|
||||
USE64 //Defaults to 64, but this is a good habit.
|
||||
|
||||
|
||||
//See $LK,"::/SparrowOS/OSMain/Str1a.CPP.Z","FL:::/SparrowOS/OSMain/Str1a.CPP.Z,1"$ and $LK,"::/SparrowOS/OSMain/Utils1a.CPP.Z","FI:::/SparrowOS/OSMain/Utils1a.CPP.Z"$.
|
||||
//These are asm syms and must be imported to work properly.
|
||||
//When in doubt, import syms.
|
||||
IMPORT PUT_STR,PUT_CHAR,PUT_HEX_U64;
|
||||
|
||||
JIFFIES_MSG: DU8 "Jiffies:",0;
|
||||
|
||||
_BEEPS2::
|
||||
//You can clobber RAX,RBX,RCX,RDX,R8,R9 in a pure asm subroutine.
|
||||
ENTER 0
|
||||
MOV RCX,U64 SF_ARG1[RBP] //$LK,"SF_ARG1","FF:::/SparrowOS/OSMain/Adam1a.HPP.Z,SF_ARG1"$
|
||||
|
||||
PUSH U64 [&sys_jiffies]
|
||||
|
||||
@@05: PUSH RCX
|
||||
//U0 Beep(I64 freq=500,Bool busy=FALSE)
|
||||
PUSH FALSE //Do not busy (spin) wait
|
||||
PUSH U64 [&glbl_hz] //evaluated at run time
|
||||
CALL &Beep
|
||||
POP RCX
|
||||
LOOP @@05
|
||||
|
||||
PUSH RSI //we must preserve this register.
|
||||
MOV RSI,JIFFIES_MSG
|
||||
CALL PUT_STR
|
||||
POP RSI
|
||||
|
||||
POP RAX
|
||||
SUB RAX,U64 [&sys_jiffies]
|
||||
NEG RAX
|
||||
CALL PUT_HEX_U64
|
||||
MOV RAX,CH_NEW_LINE
|
||||
CALL PUT_CHAR
|
||||
|
||||
LEAVE
|
||||
RET1 8
|
||||
}
|
||||
|
||||
//My convention is to put an underscore
|
||||
//on C callable routines.
|
||||
_extern _BEEPS2 U0 Beeps2(I64 cnt);
|
||||
|
||||
U0 AsmAndC2()
|
||||
{
|
||||
I64 reg R15 i;
|
||||
|
||||
i=PmtI64("$$FG,PURPLE$$\n\nNum of beeps 1-5 (%d):$$FG$$",3,1,5);
|
||||
Beeps2(i);
|
||||
|
||||
asm {
|
||||
LIST
|
||||
//You can clobber RAX,RBX,RCX,RDX, but preserve the rest for code in a C+ routine.
|
||||
USE64 //Defaults to 64, but this is a good habit.
|
||||
MOV RCX,R15 //You can clobber RAX,RBX,RCX,RDX.
|
||||
//You better preserve the rest.
|
||||
@@05: PUSH RCX
|
||||
//U0 Snd(F64 freq,I64 waveform=WF_SQUARE,F64 amp=1.0);
|
||||
MOV RAX,1.0 //amplitude
|
||||
PUSH RAX
|
||||
PUSH WF_SQUARE
|
||||
|
||||
MOV RAX,RCX //freq=loop*100.0+100.0
|
||||
IMUL2 RAX,glbl_hz_step //evaluated at compile ttime
|
||||
ADD RAX,U64 [&glbl_hz_base] //evaluated at run time
|
||||
PUSH RAX
|
||||
FILD U64 [RSP] //Convert from int to floating
|
||||
FSTP U64 [RSP]
|
||||
|
||||
CALL &Snd //We can skip IMPORT for this symbol if JIT.
|
||||
|
||||
MOV RCX,0x20000000 //Simple delay loop
|
||||
@@10: LOOP @@10
|
||||
|
||||
POP RCX
|
||||
LOOP @@05
|
||||
}
|
||||
Snd(0);
|
||||
}
|
||||
|
||||
AsmAndC2;
|
||||
@@ -0,0 +1,52 @@
|
||||
/*
|
||||
This is a JIT file, not static.
|
||||
|
||||
Asm labels can only be defined once
|
||||
in a task. Hit F5 to spawn a new task
|
||||
and run it.
|
||||
|
||||
These are many useful kernel
|
||||
routines $LK,"::/SparrowOS/OSMain/Str1a.CPP.Z","FF:::/SparrowOS/OSMain/Str1a.CPP.Z,PUT_CHAR"$
|
||||
intended to be called from
|
||||
asm. Generally, they preserve
|
||||
regs.
|
||||
|
||||
You can call any routine you
|
||||
like, C or asm, if you import it.
|
||||
Be aware that C routines do not
|
||||
preserve RAX,RBX,RCX,RDX,R8,R9.
|
||||
When calling from the shell or
|
||||
from C, preserve all other regs.
|
||||
|
||||
*/
|
||||
|
||||
asm {
|
||||
//Opcodes are slightly different to make writing my x86_64 assembler easier.
|
||||
//See $LK,"::/SparrowOS/Compiler/OpCodes.TXT.Z","FI:::/SparrowOS/Compiler/OpCodes.TXT.Z"$.
|
||||
|
||||
USE64 //Defaults to 64, but this is a good habit.
|
||||
|
||||
IMPORT PUT_HEX_U8,PUT_CHAR;
|
||||
|
||||
MY_MSG:
|
||||
//Define U8 does not put terminating zeros
|
||||
//on strings.
|
||||
DU8 "Hello World\n",0;
|
||||
|
||||
//My convention is to put an underscore
|
||||
//on C callable routines.
|
||||
_HELLO_WORLD::
|
||||
MOV RCX,10
|
||||
@@05: MOV RAX,RCX
|
||||
CALL PUT_HEX_U8
|
||||
MOV RAX,CH_SPACE
|
||||
CALL PUT_CHAR
|
||||
MOV RSI,MY_MSG
|
||||
//Alternatively, if you use an '&', you don't need
|
||||
//to import a SYS_SYM. This only works for JIT asm.
|
||||
CALL &PUT_STR
|
||||
LOOP @@05
|
||||
RET
|
||||
};
|
||||
|
||||
Call(_HELLO_WORLD);
|
||||
@@ -0,0 +1,48 @@
|
||||
#define RANGE_START 1
|
||||
#define RANGE_END 100
|
||||
|
||||
#define FIZZ_SPAN 6
|
||||
#define BUZZ_SPAN 7
|
||||
|
||||
asm {
|
||||
MSG_BUZZ: DU8 "BUZZ\n\0";
|
||||
MSG_FIZZ: DU8 "FIZZ\n\0";
|
||||
MSG_BUZZ_FIZZ: DU8 "BUZZ_FIZZ\n\0";
|
||||
MSG_NEW_LINE: DU8 "\n\0";
|
||||
|
||||
_BUZZ_FIZZ::
|
||||
ENTER 0 //Always use Enter/Leave
|
||||
PUSH ESI //RSI must be preserved. This instruction is 64-bit.
|
||||
MOV RAX,RANGE_START
|
||||
MOV DX,(FIZZ_SPAN-RANGE_START%FIZZ_SPAN+1)<<8+
|
||||
(BUZZ_SPAN-RANGE_START%BUZZ_SPAN+1)
|
||||
|
||||
@@05: DEC DH
|
||||
JNZ @@10
|
||||
MOV DH,FIZZ_SPAN
|
||||
MOV ESI,MSG_FIZZ
|
||||
DEC DL
|
||||
JNZ @@20
|
||||
MOV DL,BUZZ_SPAN
|
||||
MOV ESI,MSG_BUZZ_FIZZ
|
||||
JMP @@20
|
||||
|
||||
@@10: DEC DL
|
||||
JNZ @@15
|
||||
MOV DL,BUZZ_SPAN
|
||||
MOV ESI,MSG_BUZZ
|
||||
JMP @@20
|
||||
|
||||
@@15: CALL &PUT_HEX_U64
|
||||
MOV ESI,MSG_NEW_LINE
|
||||
@@20: CALL &PUT_STR
|
||||
|
||||
INC RAX
|
||||
CMP RAX,RANGE_END //Actually only a 32-bit instruction.
|
||||
JBE @@05
|
||||
POP ESI
|
||||
LEAVE
|
||||
RET
|
||||
}
|
||||
|
||||
Call(_BUZZ_FIZZ);
|
||||
@@ -0,0 +1,23 @@
|
||||
|
||||
|
||||
asm {
|
||||
DIV_U64_BY_U64::
|
||||
ENTER 0
|
||||
XOR RDX,RDX
|
||||
MOV RCX,64
|
||||
MOV RAX,SF_ARG1[RBP]
|
||||
MOV RBX,SF_ARG2[RBP]
|
||||
@@1: SHL1 RAX
|
||||
RCL1 RDX
|
||||
CMP RBX,RDX
|
||||
JA @@2
|
||||
INC RAX
|
||||
SUB RDX,RBX
|
||||
@@2: LOOP @@1
|
||||
LEAVE
|
||||
RET1 16
|
||||
}
|
||||
|
||||
_extern DIV_U64_BY_U64 I64 DivU64ByU64(I64 dividend,I64 divisor);
|
||||
|
||||
"123456/10=%d\n",DivU64ByU64(123456,10);
|
||||
@@ -0,0 +1,70 @@
|
||||
/*
|
||||
When I was a kid with a Commodore 64,
|
||||
the 6502 chip had no multiply instruction
|
||||
and this is how we had to do it, except,
|
||||
I used more regs in this example.
|
||||
*/
|
||||
asm {
|
||||
//Opcodes are slightly different to make writing my x86_64 assembler easier.
|
||||
//See $LK,"::/SparrowOS/Compiler/OpCodes.TXT.Z","FI:::/SparrowOS/Compiler/OpCodes.TXT.Z"$.
|
||||
|
||||
USE64 //Defaults to 64, but this is a good habit.
|
||||
|
||||
//You can clobber RAX,RBX,RCX,RDX,R8,R9
|
||||
|
||||
MUL_BY_HAND_U8_U8_TO_U16: //This is only for fun.
|
||||
//8bit * 8bit-->16bit
|
||||
//AL*BL-->AX
|
||||
MOV CL,8
|
||||
SHL AX,8
|
||||
@@05: SHL1 AX
|
||||
JNC @@10
|
||||
ADD AL,BL
|
||||
@@10: DEC CL
|
||||
JNZ @@05
|
||||
RET
|
||||
|
||||
_MUL_BY_HAND_U8_U8_TO_U16:: //C callable
|
||||
ENTER 0
|
||||
MOV AL,U8 SF_ARG1[RBP] //$LK,"SF_ARG1","FF:::/SparrowOS/OSMain/Adam1a.HPP.Z,SF_ARG1"$
|
||||
MOV BL,U8 SF_ARG2[RBP]
|
||||
CALL MUL_BY_HAND_U8_U8_TO_U16
|
||||
MOVZX RAX,AX
|
||||
LEAVE
|
||||
RET1 16
|
||||
|
||||
_MUL_U64_U64_TO_U128::
|
||||
//64bit * 64bit-->128bit
|
||||
ENTER 0
|
||||
MOV RBX,U64 SF_ARG3[RBP]
|
||||
MOV RAX,U64 SF_ARG1[RBP] //$LK,"SF_ARG1","FF:::/SparrowOS/OSMain/Adam1a.HPP.Z,SF_ARG1"$
|
||||
MUL U64 SF_ARG2[RBP] //Result RDX:RAX 128bit
|
||||
MOV U64 [RBX],RAX
|
||||
MOV U64 8[RBX],RDX
|
||||
LEAVE
|
||||
RET1 24
|
||||
};
|
||||
|
||||
//My convention is to put an underscore
|
||||
//on C callable routines.
|
||||
_extern _MUL_BY_HAND_U8_U8_TO_U16 U16 MulU8(U8 n1,U8 n2);
|
||||
|
||||
class U128
|
||||
{
|
||||
U64 lo,hi;
|
||||
};
|
||||
|
||||
_extern _MUL_U64_U64_TO_U128 U0 MulU64(I64 n1,I64 n2,U128 *_prod);
|
||||
|
||||
U0 MulByHand()
|
||||
{
|
||||
U128 p;
|
||||
"2*7 =0x%X\n",MulU8(2,7);
|
||||
"100*10=0x%X\n",MulU8(100,10);
|
||||
|
||||
MulU64(0x0123456789ABCDEF,0x1000001,&p);
|
||||
"0x0123466789ABCDEF*0x1000001=0x%016X%016X\n",p.hi,p.lo;
|
||||
}
|
||||
|
||||
MulByHand;
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
asm {
|
||||
PUT_DEC_U64::
|
||||
//RAX is number to print in decimal.
|
||||
//Preserves all regs.
|
||||
ENTER 24 //24 char buffer on stack
|
||||
PUSH_C_REGS //$LK,"Save regs","FF:::/SparrowOS/OSMain/Adam1a.HPP.Z,PUSH_C_REGS"$ which C code is free to clobber
|
||||
PUSH RSI //This reg is not saved.
|
||||
LEA RSI,-1[RBP] //Load addr of end of buffer.
|
||||
//We picked RSI because of PUT_STR
|
||||
//We'll move backward
|
||||
MOV U8 [RSI],0 //Terminator
|
||||
|
||||
OR RAX,RAX //Special case -- zero
|
||||
JNZ @@05
|
||||
DEC RSI
|
||||
MOV U8 [RSI],'0'
|
||||
JMP @@15
|
||||
|
||||
@@05: MOV RBX,10 //Divides by 10
|
||||
|
||||
@@10: XOR RDX,RDX
|
||||
DIV RBX //RAX=(RDX:RAX)/RBX with remainder in RDX
|
||||
ADD RDX,'0'
|
||||
DEC RSI
|
||||
MOV U8 [RSI],DL
|
||||
OR RAX,RAX
|
||||
JNZ @@10
|
||||
|
||||
@@15: CALL &PUT_STR
|
||||
POP RSI
|
||||
POP_C_REGS
|
||||
LEAVE
|
||||
RET
|
||||
|
||||
_DO_IT:: //The convention is C-callable routines have underscores.
|
||||
MOV RAX,122333221
|
||||
CALL PUT_DEC_U64
|
||||
PUSH 1
|
||||
CALL &NewLine //Print one carriage return
|
||||
RET
|
||||
}
|
||||
|
||||
Call(_DO_IT);
|
||||
@@ -0,0 +1,15 @@
|
||||
/* To run this, do a directory, right click on
|
||||
this file's name and select "AutoFile".
|
||||
Or, type $LK,"AutoFile","MN:AutoFile"$(filename);
|
||||
See $LK,"AutoFile","FF:::/SparrowOS/Doc/Glossary.TXT.Z,AutoFile"$ in the glossary for more info.
|
||||
*/
|
||||
|
||||
|
||||
I64 i;
|
||||
for (i=0;i<3;i++)
|
||||
"Dir;\n";
|
||||
|
||||
"$$FG,RED$$//Press a letter to complete the mask$$FG$$\n";
|
||||
"Dir(\"*.";
|
||||
I64 ch=GetChar(NULL,FALSE); //Prompt for first digit of mask
|
||||
"%c*\");\n",ch;
|
||||
@@ -0,0 +1,28 @@
|
||||
/* To run this, do a directory, right click on
|
||||
this file's name and select "AutoFile".
|
||||
Or, type $LK,"AutoFile","MN:AutoFile"$(filename);
|
||||
See $LK,"AutoFile","FF:::/SparrowOS/Doc/Glossary.TXT.Z,AutoFile"$ in the glossary for more info.
|
||||
|
||||
This autofile will renum the defines in
|
||||
AFEd.TXT.Z. Test it by numbering a few wrong
|
||||
and running this demo.
|
||||
|
||||
*/
|
||||
|
||||
U8 i;
|
||||
|
||||
"Ed(\"AFEd.TXT.Z\");\n";
|
||||
//Go to start of file
|
||||
Msg(MSG_KEY_DOWN,0,SC_CURSOR_UP|SCF_CTRL);
|
||||
for (i=0;i<=0xC3;i++) {
|
||||
if (i)
|
||||
Msg(MSG_KEY_DOWN_UP,0,SC_F3);
|
||||
else
|
||||
"%c0x%c",CH_CTRLF,CH_ESC;
|
||||
Msg(MSG_KEY_DOWN,0,SC_CURSOR_RIGHT);
|
||||
Msg(MSG_KEY_DOWN,0,SC_CURSOR_RIGHT);
|
||||
"%02X",i;
|
||||
Msg(MSG_KEY_DOWN,0,SC_CURSOR_RIGHT);
|
||||
Msg(MSG_KEY_DOWN,0,SC_CURSOR_RIGHT);
|
||||
"%c%c",CH_BACKSPACE,CH_BACKSPACE;
|
||||
}
|
||||
@@ -0,0 +1,230 @@
|
||||
//Intermediate compiler codes
|
||||
#define IC_END 0x00
|
||||
#define IC_START 0x01
|
||||
#define IC_NOP 0x02
|
||||
#define IC_END_EXP 0x03
|
||||
#define IC_NOP1 0x04
|
||||
#define IC_LABEL 0x05
|
||||
#define IC_CALL_START 0x06
|
||||
#define IC_CALL_END 0x07
|
||||
#define IC_CALL_END2 0x08
|
||||
#define IC_RETURN_VAL 0x09
|
||||
#define IC_RETURN_VAL2 0x0A
|
||||
#define IC_IMM 0x0B
|
||||
#define IC_F64 0x0C
|
||||
#define IC_STR_CONST 0x0D
|
||||
#define IC_ABS_ADDR 0x0E
|
||||
#define IC_ADDR_IMPORT 0x0F
|
||||
#define IC_HEAP_GLBL 0x10
|
||||
#define IC_SIZEOF 0x11
|
||||
#define IC_TYPE 0x12
|
||||
#define IC_GET_LABEL 0x13
|
||||
#define IC_RBP 0x14
|
||||
#define IC_REG 0x15
|
||||
#define IC_FS 0x16
|
||||
#define IC_GS 0x17
|
||||
|
||||
#define IC_LEA 0x18
|
||||
#define IC_MOV 0x19
|
||||
|
||||
#define IC_TO_I64 0x1A
|
||||
#define IC_TO_F64 0x1B
|
||||
#define IC_TO_BOOL 0x1C
|
||||
#define IC_TOUPPER 0x1D
|
||||
#define IC_NATIVE_TYPECAST 0x1E
|
||||
|
||||
#define IC_ADDR 0x1F
|
||||
#define IC_COM 0x20
|
||||
#define IC_NOT 0x21
|
||||
#define IC_UNARY_MINUS 0x22
|
||||
|
||||
#define IC_DEREF 0x23
|
||||
#define IC_DEREF_PP 0x24
|
||||
#define IC_DEREF_MM 0x25
|
||||
#define IC__PP 0x26
|
||||
#define IC__MM 0x27
|
||||
#define IC_PP_ 0x28
|
||||
#define IC_MM_ 0x29
|
||||
|
||||
#define IC_SHL 0x2A
|
||||
#define IC_SHR 0x2B
|
||||
#define IC_SHL_CONST 0x2C
|
||||
#define IC_SHR_CONST 0x2D
|
||||
#define IC_POWER 0x2E
|
||||
|
||||
#define IC_MUL 0x2F
|
||||
#define IC_DIV 0x30
|
||||
#define IC_MOD 0x31
|
||||
|
||||
#define IC_AND 0x32
|
||||
|
||||
#define IC_OR 0x33
|
||||
#define IC_XOR 0x34
|
||||
|
||||
#define IC_ADD 0x35
|
||||
#define IC_SUB 0x36
|
||||
#define IC_ADD_CONST 0x37
|
||||
#define IC_SUB_CONST 0x38
|
||||
|
||||
#define IC_EQUAL_EQUAL 0x39
|
||||
#define IC_NOT_EQUAL 0x3A
|
||||
#define IC_LESS 0x3B
|
||||
#define IC_GREATER 0x3C
|
||||
#define IC_LESS_EQUAL 0x3D
|
||||
#define IC_GREATER_EQUAL 0x3E
|
||||
#define IC_PUSH_CMP 0x3F
|
||||
|
||||
#define IC_AND_AND 0x40
|
||||
|
||||
#define IC_OR_OR 0x41
|
||||
#define IC_XOR_XOR 0x42
|
||||
|
||||
#define IC_COLON 0x43
|
||||
#define IC_QUESTION 0x44
|
||||
|
||||
#define IC_ASSIGN 0x45
|
||||
#define IC_ASSIGN_PP 0x46
|
||||
#define IC_ASSIGN_MM 0x47
|
||||
|
||||
#define IC_SHL_EQUAL 0x48
|
||||
#define IC_SHR_EQUAL 0x49
|
||||
#define IC_MUL_EQUAL 0x4A
|
||||
#define IC_DIV_EQUAL 0x4B
|
||||
#define IC_MOD_EQUAL 0x4C
|
||||
#define IC_AND_EQUAL 0x4D
|
||||
#define IC_OR_EQUAL 0x4E
|
||||
#define IC_XOR_EQUAL 0x4F
|
||||
#define IC_ADD_EQUAL 0x50
|
||||
#define IC_SUB_EQUAL 0x51
|
||||
|
||||
#define IC_JMP 0x52
|
||||
#define IC_SWITCH 0x53
|
||||
#define IC_NOBOUND_SWITCH 0x54
|
||||
|
||||
#define IC_ADD_RSP 0x55
|
||||
#define IC_ADD_RSP1 0xC1
|
||||
#define IC_ENTER 0x56
|
||||
#define IC_PUSH_REGS 0x57
|
||||
#define IC_POP_REGS 0x58
|
||||
#define IC_LEAVE 0x59
|
||||
#define IC_RET 0x5A
|
||||
|
||||
#define IC_CALL 0x5B
|
||||
#define IC_CALL_INDIRECT 0x5C
|
||||
#define IC_CALL_INDIRECT2 0x5D
|
||||
#define IC_CALL_IMPORT 0x5E
|
||||
#define IC_CALL_EXTERN 0x5F
|
||||
#define IC_IRQ 0x60
|
||||
|
||||
#define IC_ASM 0x61
|
||||
#define IC_CLI 0x62
|
||||
#define IC_STI 0x63
|
||||
#define IC_PREEMPT 0x64
|
||||
#define IC_CLD 0x65
|
||||
#define IC_STD 0x66
|
||||
#define IC_HLT 0x67
|
||||
#define IC_PUSHFD 0x68
|
||||
#define IC_POPFD 0x69
|
||||
#define IC_PAUSE 0x6A
|
||||
|
||||
#define IC_CLFLUSH 0x6B
|
||||
#define IC_INVLPG 0x6C
|
||||
#define IC_WBINVD 0x6F
|
||||
#define IC_INVD 0x70
|
||||
|
||||
#define IC_INU8 0x71
|
||||
#define IC_INU16 0x72
|
||||
#define IC_INU32 0x73
|
||||
#define IC_OUTU8 0x74
|
||||
#define IC_OUTU16 0x75
|
||||
#define IC_OUTU32 0x76
|
||||
|
||||
#define IC_GET_FLAGS 0x77
|
||||
#define IC_SET_FLAGS 0x78
|
||||
#define IC_GET_RAX 0x79
|
||||
#define IC_SET_RAX 0x7A
|
||||
#define IC_GET_BASE_PTR 0x7B
|
||||
#define IC_SET_BASE_PTR 0x7C
|
||||
#define IC_GET_STK_PTR 0x7D
|
||||
#define IC_SET_STK_PTR 0x7E
|
||||
#define IC_RIP 0x7F
|
||||
|
||||
#define IC_RDTSC 0x80
|
||||
#define IC_HPET 0x81
|
||||
|
||||
#define IC_BT 0x82
|
||||
#define IC_BTS 0x83
|
||||
#define IC_BTR 0x84
|
||||
#define IC_BTC 0x85
|
||||
#define IC_BEQU 0x86
|
||||
#define IC_LBTS 0x87
|
||||
#define IC_LBTR 0x88
|
||||
#define IC_LBTC 0x89
|
||||
#define IC_LBEQU 0x8A
|
||||
#define IC_BSF 0x8B
|
||||
#define IC_BSR 0x8C
|
||||
|
||||
#define IC_QUE_INS 0x8D
|
||||
#define IC_QUE_INS_REV 0x8E
|
||||
#define IC_QUE_REM 0x8F
|
||||
|
||||
#define IC_STRLEN 0x90
|
||||
#define IC_MEMCPY 0x91
|
||||
|
||||
#define IC_MEMSET 0x92
|
||||
#define IC_MEMSET_U16 0xC2
|
||||
#define IC_MEMSET_U32 0xC3
|
||||
#define IC_MEMSET_U64 0xC4
|
||||
|
||||
#define IC_BR_ZERO 0x93
|
||||
#define IC_BR_NOT_ZERO 0x94
|
||||
|
||||
#define IC_BR_NOT_EQUAL 0x95
|
||||
#define IC_BR_EQUAL_EQUAL 0x96
|
||||
#define IC_BR_GREATER_EQUAL 0x97
|
||||
#define IC_BR_LESS_EQUAL 0x98
|
||||
#define IC_BR_GREATER 0x99
|
||||
#define IC_BR_LESS 0x9A
|
||||
#define IC_BR_NOT_EQUAL2 0x9B
|
||||
#define IC_BR_EQUAL_EQUAL2 0x9C
|
||||
#define IC_BR_GREATER_EQUAL2 0x9D
|
||||
#define IC_BR_LESS_EQUAL2 0x9E
|
||||
#define IC_BR_GREATER2 0x9F
|
||||
#define IC_BR_LESS2 0xA0
|
||||
#define IC_BR_AND_ZERO 0xA1
|
||||
#define IC_BR_AND_NOT_ZERO 0xA2
|
||||
#define IC_BR_AND_AND_ZERO 0xA3
|
||||
#define IC_BR_AND_AND_NOT_ZERO 0xA4
|
||||
#define IC_BR_OR_OR_ZERO 0xA5
|
||||
#define IC_BR_OR_OR_NOT_ZERO 0xA6
|
||||
|
||||
#define IC_BR_BT 0xA7
|
||||
#define IC_BR_BTS 0xA8
|
||||
#define IC_BR_BTR 0xA9
|
||||
#define IC_BR_BTC 0xAA
|
||||
#define IC_BR_LBTS 0xAB
|
||||
#define IC_BR_LBTR 0xAC
|
||||
#define IC_BR_LBTC 0xAD
|
||||
#define IC_BR_NOT_BT 0xAE
|
||||
#define IC_BR_NOT_BTS 0xAF
|
||||
#define IC_BR_NOT_BTR 0xB0
|
||||
#define IC_BR_NOT_BTC 0xB1
|
||||
#define IC_BR_NOT_LBTS 0xB2
|
||||
#define IC_BR_NOT_LBTR 0xB3
|
||||
#define IC_BR_NOT_LBTC 0xB4
|
||||
|
||||
#define IC_SWAP_U8 0xB5
|
||||
#define IC_SWAP_U16 0xB6
|
||||
#define IC_SWAP_U32 0xB7
|
||||
#define IC_SWAP_U64 0xB8
|
||||
|
||||
#define IC_ABS_I64 0xB9
|
||||
#define IC_SIGN_I64 0xBA
|
||||
#define IC_MIN_I64 0xBB
|
||||
#define IC_MIN_U64 0xBC
|
||||
#define IC_MAX_I64 0xBD
|
||||
#define IC_MAX_U64 0xBE
|
||||
#define IC_LIMIT_I64 0xBF
|
||||
#define IC_LIMIT_U64 0xC0
|
||||
|
||||
#define IC_NUM_ENTRIES 0xC5
|
||||
@@ -0,0 +1,12 @@
|
||||
/* This is not an AutoFile. It uses $LK,"AutoStr","MN:AutoStr"$
|
||||
to run text as though from an AutoFile.
|
||||
|
||||
This example shows how you can drive pop-up
|
||||
windows.
|
||||
*/
|
||||
|
||||
Auto(" ");
|
||||
"PopUp #1:%X\n",PopUpNoYes;
|
||||
|
||||
AutoStr("Msg(MSG_KEY_DOWN,0,SC_CURSOR_RIGHT);'' CH_SPACE;");
|
||||
"PopUp #2:%X\n",PopUpNoYes;
|
||||
@@ -0,0 +1,26 @@
|
||||
U0 DoWait()
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<3;i++) {
|
||||
"PopUpNoYes;\n ";
|
||||
|
||||
//Necessary after a $LK,"DocEntryRun","MN:DocEntryRun"$()
|
||||
//which occurs when PopUp's close.
|
||||
TaskWait;
|
||||
|
||||
"\"%d\\n\\n\";\n",i;
|
||||
}
|
||||
}
|
||||
|
||||
U0 DoNoWait()
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<3;i++)
|
||||
"PopUpNoYes;\n \"%d\\n\\n\";\n",i;
|
||||
}
|
||||
|
||||
"//With Wait ";PressAKey;
|
||||
DoWait;
|
||||
"//With No Wait ";PressAKey;
|
||||
DoNoWait;
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
/* To run this, do a directory, right click on
|
||||
this file's name and select "AutoFile".
|
||||
Or, type $LK,"AutoFile","MN:AutoFile"$(filename);
|
||||
See $LK,"AutoFile","FF:::/SparrowOS/Doc/Glossary.TXT.Z,AutoFile"$ in the glossary for more info.
|
||||
|
||||
Profiling does not $UL,1$require$UL,0$ autofiles.
|
||||
*/
|
||||
"$$FG,RED$$ProfAll;$$FG$$\n";
|
||||
"$$FG,RED$$//Collecting Data$$FG$$";
|
||||
PressAKey;
|
||||
"\n$$FG,RED$$ProfRep;$$FG$$\n";
|
||||
@@ -0,0 +1,13 @@
|
||||
U0 AFSetIPDemo()
|
||||
{
|
||||
I64 t,l;
|
||||
WinBorder(ON);
|
||||
l=Fs->win_pixel_left+Fs->win_scroll_x;
|
||||
t=Fs->win_pixel_top+Fs->win_scroll_y;
|
||||
SetIP(,,,FALSE,FALSE,FALSE); //Mouse unclicked
|
||||
AFSetIP(,l-4,t-4);
|
||||
AFSetIP(20,l+20,t+20,,TRUE);
|
||||
SetIP(,,,FALSE,FALSE,FALSE);
|
||||
}
|
||||
|
||||
AFSetIPDemo;
|
||||
@@ -0,0 +1,81 @@
|
||||
//This demonstrates class meta data.
|
||||
//Basically, we make use of the compiler's
|
||||
//data about a class. We can add to the
|
||||
//compilers data arbitrary items, either string or
|
||||
//or int or F64 (if you typecast).
|
||||
|
||||
//This stuff is not high performance.
|
||||
//Don't get carried away -- it might be slow.
|
||||
|
||||
|
||||
U0 RankOut(I64 i)
|
||||
{
|
||||
" %z",i,"Cadet\0Ensign\0Captain\0Admiral\0President\0";
|
||||
}
|
||||
|
||||
class Test1Struct
|
||||
{
|
||||
I64 age printf_str "%2d" dft_val 38;
|
||||
I64 color dft_val RED; //Accepts expressions
|
||||
I64 rank printf_str "%1d" dft_val 6/2 output_fun &RankOut;
|
||||
};
|
||||
|
||||
class Test2Struct
|
||||
{
|
||||
I64 age printf_str "%2d" dft_val 38 percentile 54.20;
|
||||
I64 rank printf_str "%1d" dft_val 5;
|
||||
I64 serial_num printf_str "%6d" dft_val 123456;
|
||||
};
|
||||
|
||||
|
||||
U0 DumpStruct(U8 *class_name,U8 *data)
|
||||
{
|
||||
CHashClass *tempc=HashFind(class_name,Fs->hash_table,HTT_CLASS);
|
||||
U8 *printf_str;
|
||||
I64 *q,dft_val;
|
||||
U0 (* fp_output_fun)(I64 i);
|
||||
F64 percentile;
|
||||
if (!tempc) return;
|
||||
CMemberList *ml;
|
||||
ml=tempc->member_list;
|
||||
while (ml) {
|
||||
"%s:",ml->str;
|
||||
|
||||
//All our items are I64's. If you want, you can check
|
||||
//the data type of the member var. See $LK,"ClassRep","MN:ClassRep"$().
|
||||
q=data+ml->offset;
|
||||
|
||||
if (printf_str=MemberMetaData("printf_str",ml))
|
||||
"" printf_str,*q;
|
||||
|
||||
//This is slightly ambiguous -- if no meta is present it will return zero.
|
||||
if (dft_val=MemberMetaData("dft_val",ml))
|
||||
" default:%d",dft_val;
|
||||
|
||||
//This corrects for the ambiguity, allowing zero percentile.
|
||||
if (MemberMetaFind("percentile",ml)) { //check if it exists
|
||||
//We could use the $LK,"CMemberListMeta","MN:CMemberListMeta"$ structure returned by
|
||||
//$LK,"MemberMetaFind","MN:MemberMetaFind"$() and save a search.
|
||||
percentile=MemberMetaData("percentile",ml)(F64);
|
||||
" percentile: %5.2f",percentile;
|
||||
}
|
||||
|
||||
if (fp_output_fun=MemberMetaData("output_fun",ml))
|
||||
(*fp_output_fun)(*q);
|
||||
NewLine;
|
||||
ml=ml->next;
|
||||
}
|
||||
}
|
||||
|
||||
Test1Struct t1;
|
||||
t1.age=44;
|
||||
t1.rank=3;
|
||||
|
||||
DumpStruct("Test1Struct",&t1);
|
||||
|
||||
Test2Struct t2;
|
||||
t2.age=22;
|
||||
t2.rank=2;
|
||||
t2.serial_num=55555;
|
||||
|
||||
DumpStruct("Test2Struct",&t2);
|
||||
@@ -0,0 +1,37 @@
|
||||
F64 glbl;
|
||||
|
||||
F64 CompileDemo(U8 *st)
|
||||
{
|
||||
I64 type;
|
||||
U8 *code;
|
||||
CLex *lx=LexNew(st,LF_DONT_FREE_BUF);
|
||||
F64 result=0;
|
||||
Lex(lx); //Gotta get it started
|
||||
"Compile \"%s\"\n",st;
|
||||
do {
|
||||
if (code=CmpExpression(lx,&type)) {
|
||||
if (type!=IT_F64)
|
||||
result=ToF64(Call(code));
|
||||
else
|
||||
result=Call(code)(F64);
|
||||
ExpressionDel(code);
|
||||
}
|
||||
"result=%9.4f\n",result;
|
||||
if (lx->token==';')
|
||||
Lex(lx);
|
||||
} while (lx->token!=TK_EOF); //end of file?
|
||||
LexDel(lx);
|
||||
return result;
|
||||
}
|
||||
|
||||
CompileDemo("2+Cos(ã)");
|
||||
CompileDemo("1;2+4");
|
||||
CompileDemo("glbl=1;glbl*2;glbl/3;Sin(glbl)");
|
||||
|
||||
//This is just like you typed-it on
|
||||
//the cmd line.
|
||||
ExePutS(
|
||||
"I64 i;"
|
||||
"for (i=0;i<10;i++) "
|
||||
" \"%d\n\",i;"
|
||||
);
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
An $LK,"CDate","MN:CDate"$ is a signed 64-bit date/time num
|
||||
representing how many 49710ths of a second
|
||||
since Christ. The reason it is this crazy
|
||||
num is so that 32bits is exactly one day.
|
||||
|
||||
These nums can be subtracted to get time
|
||||
differences.
|
||||
|
||||
The time of day to the nearest 49710ths of a second
|
||||
is stored in the lower 32-bits. The upper
|
||||
32-bits hold the num of days since Christ.
|
||||
|
||||
$LK,"PrintF","MN:PrintF"$() and the file datetimes use
|
||||
this format, otherwise you might want to
|
||||
use $LK,"GetTimeStamp","MN:GetTimeStamp"$() for a higher frequency
|
||||
timing, divide by $LK,"time_stamp_freq","MN:time_stamp_freq"$,
|
||||
but this num is tied to your CPU's
|
||||
clock frequency which is inexact when
|
||||
converted to real-time.
|
||||
*/
|
||||
|
||||
|
||||
CDate ltdt=GetCurTimeCDate;
|
||||
|
||||
I64 i;
|
||||
for (i=0;i<NUM_DATE_FMTS;i++)
|
||||
"%%h%dD: %h*D\n",i,i,ltdt;
|
||||
NewLine;
|
||||
|
||||
for (i=0;i<NUM_TIME_FMTS;i++)
|
||||
"%%h%dT: %h*T\n",i,i,ltdt;
|
||||
|
||||
"$$FG,PURPLE$$CDate freq:%12.6f$$FG$$\n",0x100000000/24.0/60.0/60.0;
|
||||
|
||||
/*
|
||||
You can customize to your locality
|
||||
with $LK,"date_fmt_map","MN:date_fmt_map"$[] and $LK,"time_fmt_map","MN:time_fmt_map"$[].
|
||||
$LK,"DateTimeFmtMapsRst","MN:DateTimeFmtMapsRst"$() will rst
|
||||
them.
|
||||
*/
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
/*
|
||||
Press <CTRL-ALT-C> to break.
|
||||
|
||||
Rerun Program
|
||||
|
||||
Press <CTRL-ALT-D> to enter Dbg.
|
||||
> $LK,"Dr","MN:Dr"$; //Dump Registers
|
||||
> $LK,"BptsR","MN:BptsR"$; //Clear break-points.
|
||||
> $LK,"Go2","MN:Go2"$; //Cont program
|
||||
|
||||
|
||||
Press <CTRL-ALT-D> to enter Dbg.
|
||||
> $LK,"Uf","MN:Uf"$("DbgDemo");
|
||||
> $LK,"U","MN:U"$(RIP);
|
||||
|
||||
See $LK,"Debugging","HI:Debugging"$
|
||||
|
||||
*/
|
||||
|
||||
U0 DbgDemo()
|
||||
{
|
||||
I64 i=0;
|
||||
while (TRUE)
|
||||
if (!(i++%2000000))
|
||||
".";
|
||||
}
|
||||
|
||||
DbgDemo;
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
/*
|
||||
See $LK,"Define","HI:Char/Define"$.
|
||||
*/
|
||||
|
||||
//These might be in the Adam task.
|
||||
DefineLoad("ST_YES_NO","(Yes or No)");
|
||||
DefineLoad("ST_EXIT","Exit");
|
||||
DefineListLoad("ST_NO_YES_LIST","No\0Yes\0");
|
||||
|
||||
|
||||
//New strings might be loaded for each user
|
||||
//to override.
|
||||
|
||||
"Spanish";
|
||||
if (YorN) {
|
||||
DefineLoad("ST_YES_NO","(Si or No)");
|
||||
DefineLoad("ST_EXIT","Salida");
|
||||
DefineListLoad("ST_NO_YES_LIST","No\0Si\0");
|
||||
}
|
||||
|
||||
|
||||
Bool Quit()
|
||||
{
|
||||
Bool result;
|
||||
U8 *st;
|
||||
I64 i;
|
||||
while (TRUE) {
|
||||
"%S %S?","ST_EXIT","ST_YES_NO";
|
||||
st=MGetS;
|
||||
i=DefineMatch(st,"ST_NO_YES_LIST",LEF_IGNORE_CASE);
|
||||
if (i>=0) {
|
||||
result=i;
|
||||
break;
|
||||
}
|
||||
Free(st);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Quit;
|
||||
@@ -0,0 +1,77 @@
|
||||
//This loads a list of zero terminated
|
||||
//strings into the sym table and
|
||||
//gives a name to it. Strings like
|
||||
//this are known as Define entries.
|
||||
|
||||
//See $LK,"ST_RAINBOW_10","FF:::/SparrowOS/Adam/Gr/GrScreen.CPP.Z,ST_RAINBOW_10"$
|
||||
|
||||
U0 ShowDigit(U8 ch)
|
||||
{
|
||||
//The %Z code displays a Define subentry
|
||||
"$$FG,%Z$$%d$$FG$$",ch-'0',"ST_RAINBOW_10",ch-'0';
|
||||
}
|
||||
|
||||
U0 ShowPattern(U8 *st)
|
||||
{
|
||||
U8 ch;
|
||||
while (ch=*st++)
|
||||
ShowDigit(ch);
|
||||
NewLine;
|
||||
}
|
||||
|
||||
U0 Digits()
|
||||
{
|
||||
I64 num,ch,i;
|
||||
U8 answer[1024];
|
||||
|
||||
DocClear;
|
||||
//Set default background and foreground
|
||||
"$$WW,1$$$$BD,DKGRAY$$$$FD,WHITE$$"
|
||||
"\nThis is a mem game. "
|
||||
"Try to remember the digits and enter them. "
|
||||
"They are colored based on electrical "
|
||||
"engineering color codes.\n";
|
||||
for (i=0;i<10;i++) {
|
||||
"$$FG,%Z$$%d: %Z\n",i,"ST_RAINBOW_10",i,i,"ST_RAINBOW_10";
|
||||
}
|
||||
"$$FG$$\n"; //set to default background
|
||||
if (!PressAKey) goto dg_done;
|
||||
|
||||
while (TRUE) {
|
||||
restart:
|
||||
num=0;
|
||||
//Set to zeros so we have terminators
|
||||
MemSet(answer,0,sizeof(answer));
|
||||
while (TRUE) {
|
||||
DocClear;
|
||||
"$$WW,1$$$$BD,DKGRAY$$$$FD,WHITE$$\n";
|
||||
"Pattern\nLength:%d\n\n",num+1;
|
||||
answer[num++]=RandU32%10+'0';
|
||||
ShowPattern(answer);
|
||||
if (!PressAKey) goto dg_done;
|
||||
|
||||
DocClear;
|
||||
"$$WW,1$$$$BD,DKGRAY$$$$FD,WHITE$$\n";
|
||||
"Guess\nLength:%d\n\n",num;
|
||||
for (i=0;i<num;i++) {
|
||||
ch=GetChar(NULL,FALSE);
|
||||
if (ch==CH_SHIFT_ESC || ch==CH_ESC)
|
||||
return;
|
||||
ShowDigit(ch);
|
||||
if (ch!=answer[i]) {
|
||||
Snd(0);
|
||||
"\nScore:%d\n",num;
|
||||
ShowPattern(answer);
|
||||
Beep;
|
||||
Beep;
|
||||
if (!PressAKey) goto dg_done;
|
||||
goto restart;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
dg_done:
|
||||
"$$CL$$\n";
|
||||
}
|
||||
|
||||
Digits;
|
||||
@@ -0,0 +1,93 @@
|
||||
U8 *tSCB(CDoc *,CDocEntry *,CTask *mem_task)
|
||||
{
|
||||
//This routine is called by the window
|
||||
//mgr things would get corrupted
|
||||
//if the window mgr used it's own
|
||||
//heap, so we use the owning task's heap.
|
||||
U8 *st=MAlloc(64,mem_task);
|
||||
CDate ltdt=tS*CDATE_FREQ;
|
||||
//Doesn't have to be fixed width!!
|
||||
SPrintF(st,"%d=%h11T",ltdt,ltdt);
|
||||
return st;
|
||||
}
|
||||
|
||||
U8 *CurTimeCB(CDoc *,CDocEntry *,CTask *mem_task)
|
||||
{
|
||||
U8 *st=MAlloc(64,mem_task);
|
||||
CDate ltdt=GetCurTimeCDate;
|
||||
SPrintF(st,"%h0D %h0T",ltdt,ltdt);
|
||||
return st;
|
||||
}
|
||||
|
||||
U0 DoIt()
|
||||
{
|
||||
/* The main window is kept at Fs->last_doc.
|
||||
A second framework is kept at Fs->next_doc.
|
||||
Normally, the next_doc is used for updating
|
||||
the border, primarily.
|
||||
|
||||
See $LK,"UseTermDoc","MN:UseTermDoc"$().
|
||||
See $LK,"DocUpdateTaskDocs","MN:DocUpdateTaskDocs"$().
|
||||
|
||||
Note: the next_doc is not to be confused
|
||||
with the aux_str, a member of the $LK,"CDocEntry","MN:CDocEntry"$.
|
||||
|
||||
*/
|
||||
CDoc *aux=DocAux, //Fetches Fs->next_doc basically.
|
||||
*cur=DocCur; //Fetches Fs->last_doc basically.
|
||||
CDocEntry *doc_e;
|
||||
|
||||
// We don't want an update between
|
||||
// creating the CDocEntry and defining the
|
||||
// callback, so we turn-off preemption.
|
||||
|
||||
Bool old_preempt=Preempt(OFF);
|
||||
|
||||
DocBottom(aux); //Ins at the bottom
|
||||
DocPutS(aux,"$$FG,RED$$$$CM+BY+LX,5,-3$$");
|
||||
|
||||
// The $LK,"DocPutS","MN:DocPutS"$() routine returns the addr of the last entry.
|
||||
doc_e=DocPutS(aux,"$$TX+TC,\" \"$$");
|
||||
// The TC flag is "has tag callback".
|
||||
|
||||
// Flags are explained here:
|
||||
// $LK,"::/SparrowOS/Doc/CtrlL.TXT.Z","FI:::/SparrowOS/Doc/CtrlL.TXT.Z"$
|
||||
// $LK,"::/SparrowOS/Doc/Dollar.TXT.Z","FI:::/SparrowOS/Doc/Dollar.TXT.Z"$
|
||||
// $LK,"Dollar Flags","MN:DOCEf1_AUX_STR"$
|
||||
// $LK,"ST_DOC_FLAGS","FF:::/SparrowOS/Adam/Doc/Doc.CPP.Z,ST_DOC_FLAGS"$
|
||||
|
||||
doc_e->tag_cb=&tSCB;
|
||||
DocPutS(aux,"$$FG$$");
|
||||
|
||||
//$BK,1$WARNING:$BK,0$ If you use the last_doc you
|
||||
//run the risk of the user pressing
|
||||
//<CTRL-T> or using the clipboard, both
|
||||
//of which will crash. So, you might want
|
||||
//to use the next_doc.
|
||||
|
||||
DocPutS(cur,"$$FG,LTRED$$");
|
||||
doc_e=DocPutS(cur,"$$TX+TC,\" \"$$");
|
||||
doc_e->tag_cb=&CurTimeCB;
|
||||
DocPutS(cur,"$$FG$$");
|
||||
|
||||
Preempt(old_preempt);
|
||||
|
||||
//Send carriage return, new line, so
|
||||
//that the timer string is not part
|
||||
//of the next cmd on the cmd line.
|
||||
NewLine;
|
||||
}
|
||||
|
||||
|
||||
|
||||
U0 UndoIt()
|
||||
{
|
||||
//Clear-out entries without a +H hold flag.
|
||||
DocBottom(Fs->next_doc);
|
||||
DocPutS(Fs->next_doc,"$$CL$$");
|
||||
}
|
||||
|
||||
|
||||
DoIt;
|
||||
|
||||
// See $LK,"::/SparrowOS/Demo/Doc/CallBackAux2.CPP.Z","FI:::/SparrowOS/Demo/Doc/CallBackAux2.CPP.Z"$ for another way.
|
||||
@@ -0,0 +1,35 @@
|
||||
//See $LK,"::/SparrowOS/Demo/Doc/CallBack.CPP.Z","FI:::/SparrowOS/Demo/Doc/CallBack.CPP.Z"$ first.
|
||||
|
||||
U8 *tSCB(CDoc *,CDocEntry *,CTask *mem_task)
|
||||
{
|
||||
U8 *st=MAlloc(64,mem_task);
|
||||
CDate ltdt=tS*CDATE_FREQ;
|
||||
SPrintF(st,"%d=%h11T",ltdt,ltdt);
|
||||
return st;
|
||||
}
|
||||
|
||||
U0 DoIt()
|
||||
{
|
||||
CDocEntry *doc_e;
|
||||
CDoc *aux2=DocNew;
|
||||
|
||||
aux2->flags|=DOCF_AUX_DOC;
|
||||
|
||||
DocPutS(aux2,"$$FG,RED$$$$CM+BY+LX,5,-3$$");
|
||||
doc_e=DocPutS(aux2,"$$TX+TC,\" \"$$");
|
||||
doc_e->tag_cb=&tSCB;
|
||||
DocPutS(aux2,"$$FG$$");
|
||||
|
||||
DocQueInsRev(aux2,DocAux);
|
||||
|
||||
NewLine;
|
||||
}
|
||||
|
||||
U0 UndoIt()
|
||||
{
|
||||
CDoc *aux2=DocAux;
|
||||
DocQueRem(aux2);
|
||||
DocDel(aux2);
|
||||
}
|
||||
|
||||
DoIt;
|
||||
@@ -0,0 +1,38 @@
|
||||
U0 CursorMovementDemo()
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<100;i++) {
|
||||
"%03d ",i;
|
||||
"$$CM,-4,1$$";
|
||||
if (i%10==9)
|
||||
"$$CM,4,-10$$";
|
||||
}
|
||||
|
||||
//+LX is relative to left side.
|
||||
//See <CTRL-L> with cursor-movement for all the flags.
|
||||
//Check "Quote" to set-up a cmd for in quotes.
|
||||
"$$CM+LX,0,+10$$\n";
|
||||
}
|
||||
|
||||
CursorMovementDemo;
|
||||
|
||||
//The word-wrap Off and On cmds are
|
||||
//$$WW,0$$ and $$WW,1$$.
|
||||
|
||||
//You might need $LK,"DocMax","MN:DocMax"$() to adjust
|
||||
//the cmd line window buf size.
|
||||
//It counts cmds, not lines.
|
||||
|
||||
//The +H flag will hold-onto an entry
|
||||
//so it doesn't get pushed-out of the document.
|
||||
//This is useful for a $$WW+H,1$$ cmd.
|
||||
|
||||
//See $LK,"::/SparrowOS/Doc/Dollar.TXT.Z","FI:::/SparrowOS/Doc/Dollar.TXT.Z"$ for documentation on
|
||||
//all flags and cmds.
|
||||
|
||||
|
||||
//Note: the default page length is 66 lines
|
||||
//and branching back more than the page length
|
||||
//will rst the column to 1. So, set page
|
||||
//length to a large number if you want to
|
||||
//branch back a long distance.
|
||||
@@ -0,0 +1,64 @@
|
||||
/*
|
||||
$$DA is the data widget.
|
||||
-T flag is for var
|
||||
width fields with a terminator
|
||||
character.
|
||||
+RD refreshes the data.
|
||||
+UD updates the val when you edit it.
|
||||
+U32 means the val is 4 bytes.
|
||||
-I64 I64 is the default so we might
|
||||
want to turn-it-off. Strings
|
||||
use I64.
|
||||
,32 sets the tag string width.
|
||||
See $LK,"Data Tag Width","FA:::/SparrowOS/Adam/Doc/DocPlain.CPP.Z,DataTagWidth"$.
|
||||
-P Means it is a string var, basically.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
I32 i;
|
||||
U8 buf[8];
|
||||
|
||||
U0 UpdateGlblTask(I64)
|
||||
{
|
||||
while (TRUE) {
|
||||
i++;
|
||||
Sleep(1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
U0 DataDemo()
|
||||
{
|
||||
CDocEntry *doc_e;
|
||||
|
||||
//This is the command line document.
|
||||
CDoc *doc=DocCur;
|
||||
|
||||
//We do this to prevent access to
|
||||
//doc_e->data before it is set.
|
||||
Bool unlock=DocLock(doc);
|
||||
|
||||
//You might set the $LK,"DOCF_FORM","MN:DOCF_FORM"$ flag.
|
||||
// doc->flags|=DOCF_FORM
|
||||
//if you wish.
|
||||
|
||||
Spawn(&UpdateGlblTask,NULL,"Update Glbl",Fs);
|
||||
|
||||
"Enter editor overstrike mode\n"
|
||||
"and you can modify the val.\n"
|
||||
"However, changes happen immediately,\n"
|
||||
"so it's tricky.\n\n";
|
||||
//Use <CTRL-L> for the $$DA,$$ format.
|
||||
doc_e=DocPutS(doc,"$$DA-T+RD+UD-I64+U32,32,\"%12d\"$$\n");
|
||||
doc_e->data=&i;
|
||||
|
||||
StrCpy(buf,"Terry");
|
||||
doc_e=DocPutS(doc,"$$DA-P+RD+UD,7,\"Str:%s\"$$\n");
|
||||
doc_e->data=buf;
|
||||
|
||||
if (unlock)
|
||||
DocUnlock(doc);
|
||||
}
|
||||
|
||||
DataDemo;
|
||||
@@ -0,0 +1,24 @@
|
||||
/*
|
||||
The +D flag causes a define-string
|
||||
look-up and substitution.
|
||||
|
||||
It is available in the <CTRL-L> menu
|
||||
under text entries for use in
|
||||
documentation.
|
||||
|
||||
*/
|
||||
|
||||
|
||||
DefineLoad("COMPANY","Trivial Solutions");
|
||||
"Company: $$TX+D,\"\",\"COMPANY\"$$\n";
|
||||
|
||||
DefinePrintF("COMPANY_TIME","%T",GetCurTimeCDate);
|
||||
|
||||
#exe {
|
||||
StreamPrintF(
|
||||
"#define COMPANY_AGE %h56D\n",GetCurTimeCDate-A2CDate("8/1/2003"));
|
||||
};
|
||||
|
||||
|
||||
"Age : $$TX+D,\"\",\"COMPANY_AGE\"$$ years\n";
|
||||
"Time: $$TX+D,\"\",\"COMPANY_TIME\"$$\n";
|
||||
Binary file not shown.
@@ -0,0 +1,68 @@
|
||||
public U0 DocProfile(U8 *filename,I64 flags)
|
||||
{
|
||||
I64 i,*cmd_stats=CAlloc(sizeof(I64)*DOCT_NUM_TYPES),
|
||||
*flags_stats=CAlloc(sizeof(I64)*64),
|
||||
*type_flags_stats=CAlloc(sizeof(I64)*64);
|
||||
//Note, word wrap is determined by
|
||||
//doc->win_task when a $LK,"CDoc","MN:CDoc"$ is recalculated
|
||||
//use $LK,"DocRecalc","MN:DocRecalc"$().
|
||||
CDoc *doc=DocRead(filename,flags);
|
||||
|
||||
//doc->root which is equal to doc is the
|
||||
//header of the CQue and represents the end-of-file marker.
|
||||
CDocEntry *doc_e=doc->root.next;
|
||||
while (doc_e!=doc) {
|
||||
cmd_stats[doc_e->type_u8]++;
|
||||
for (i=0;i<64;i++)
|
||||
if (Bt(&doc_e->flags1,i))
|
||||
flags_stats[i]++;
|
||||
for (i=16;i<32;i++)
|
||||
if (Bt(&doc_e->type,i))
|
||||
type_flags_stats[i]++;
|
||||
doc_e=doc_e->next;
|
||||
}
|
||||
DocDel(doc);
|
||||
|
||||
"$$FG,PURPLE$$-------%s-------\n",filename;
|
||||
"$$FG,GREEN$$The lowest byte of the 32-bit 'doc_e->type', '$$FG,PURPLE$$doc_e->type.u8[0]$$FG,GREEN$$', is cmd and accessed with the union '$$FG,PURPLE$$doc_e->type_u8$$FG,GREEN$$'. "
|
||||
"See $$LK,\"CDocEntry\",\"MN:CDocEntry\"$$, "
|
||||
"$$LK,\"Doc Type Defines\",\"MN:DOCT_TEXT\"$$ and $$LK,\"Doc Type Codes\",\"FF:::/SparrowOS/Adam/Doc/Doc.CPP.Z,ST_DOC_CMDS\"$$.\n$$FG$$";
|
||||
for (i=0;i<DOCT_NUM_TYPES;i++)
|
||||
if (cmd_stats[i])
|
||||
"%4Z:%d\n",i,"ST_DOC_CMDS",cmd_stats[i];
|
||||
|
||||
"\n$$FG,GREEN$$'$$FG,PURPLE$$doc_e->type.u8[1]$$FG,GREEN$$' is the screen color attr of the entry. "
|
||||
"'$$FG,PURPLE$$doc_e->type.u16[1]$$FG,GREEN$$' is some flags for blinking and stuff. "
|
||||
"See $$LK,\"Doc Type Flag Defines\",\"MN:DOCET_BLINK\"$$.\n$$FG$$";
|
||||
|
||||
for (i=16;i<32;i++)
|
||||
if (type_flags_stats[i])
|
||||
"%4d:%d\n",i,type_flags_stats[i];
|
||||
|
||||
"$$FG,GREEN$$\n'$$FG,PURPLE$$doc_e->flags1$$FG,GREEN$$' is 64-bit. "
|
||||
"See $$LK,\"Doc Flag Defines\",\"MN:DOCEf1_AUX_STR\"$$ and $$LK,\"Doc Flag Codes\",\"FF:::/SparrowOS/Adam/Doc/Doc.CPP.Z,ST_DOC_FLAGS\"$$.\n$$FG$$";
|
||||
for (i=0;i<64;i++)
|
||||
if (flags_stats[i])
|
||||
"%4Z:%d\n",i,"ST_DOC_FLAGS",flags_stats[i];
|
||||
|
||||
Free(cmd_stats);
|
||||
Free(flags_stats);
|
||||
PressAKey;
|
||||
NewLine;
|
||||
}
|
||||
|
||||
|
||||
//See $LK,"TipOfDay","MN:TipOfDay"$.
|
||||
|
||||
//Note: Not all $LK,"CDocEntry","MN:CDocEntry"$'s are full-sized nodes.
|
||||
//Some are $LK,"MAlloc","MN:MAlloc"$ed with a smaller size to save
|
||||
//mem. They all have at least the size $LK,"CDocEntryBase","MN:CDocEntryBase"$.
|
||||
|
||||
//Note: $LK,"CDocEntry","MN:CDocEntry"$'s should be allocated from the
|
||||
//heap of the owning task, doc->mem_task.
|
||||
|
||||
//The flag arrays $LK,"doc_tag_types","MN:doc_tag_types"$, $LK,"doc_form_types","MN:doc_form_types"$, etc
|
||||
//are useful.
|
||||
|
||||
DocProfile("::/SparrowOS/Doc/ChangeLog.TXT.Z",0);
|
||||
DocProfile("::/SparrowOS/Doc/ChangeLog.TXT.Z",DOCF_PLAIN_TEXT);
|
||||
@@ -0,0 +1,44 @@
|
||||
class DStruct
|
||||
{
|
||||
//Use <CTRL-L> and select "Data" to generate the fmtstrs
|
||||
|
||||
//The number is the field from after the ':' to the end.
|
||||
// See $LK,"Data Tag Width","FA:::/SparrowOS/Adam/Doc/DocPlain.CPP.Z,DataTagWidth"$.
|
||||
|
||||
F64 num1 fmtstr "$$DA-T,32,\"F64 1:%12.8f\"$$\n";
|
||||
F64 num2 fmtstr "$$DA-T,32,\"F64 2:%12e\"$$\n";
|
||||
I64 num3 fmtstr "$$DA-T,32,\"I64 1:0x%016X\"$$\n";
|
||||
I64 num4 fmtstr "$$DA-T,32,\"I64 2:%12d\"$$\n";
|
||||
U8 name[32] fmtstr "$$DA-P,31,\"Name :%s\"$$\n";
|
||||
CDate datetime fmtstr "$$DA-T,32,\"Date :%8D\"$$\n";
|
||||
};
|
||||
|
||||
U0 FormDemo()
|
||||
{
|
||||
DStruct gtl;
|
||||
CDate ltdt;
|
||||
|
||||
gtl.num1=12.3e-4; //Set defaults
|
||||
gtl.num2=4.5e3;
|
||||
gtl.num3=0x1234;
|
||||
gtl.num4=-567;
|
||||
StrCpy(>l.name,"John");
|
||||
ltdt=GetCurTimeCDate;
|
||||
gtl.datetime=ltdt;
|
||||
if (DocFormDo(>l,"DStruct")) {
|
||||
"#1=%e\n",gtl.num1;
|
||||
"#2=%e\n",gtl.num2;
|
||||
"#3=%d\n",gtl.num3;
|
||||
"#4=%d\n",gtl.num4;
|
||||
"Name=%s\n",gtl.name;
|
||||
"Date=%D\n",gtl.datetime;
|
||||
} else
|
||||
"Cancel\n";
|
||||
|
||||
"\n\nClassRep Example\n";
|
||||
ClassRep("DStruct",>l);
|
||||
|
||||
//See also $LK,"ClassRepD","MN:ClassRepD"$().
|
||||
}
|
||||
|
||||
FormDemo;
|
||||
@@ -0,0 +1,76 @@
|
||||
//This example shows buttons. Buttons return a menu val
|
||||
//unless you rig them to send macros. Menu entries are
|
||||
//about the same as buttons, but don't have a border.
|
||||
|
||||
|
||||
I64 PopUpFreq()
|
||||
{ //See also $LK,"PopUpRangeI64","MN:PopUpRangeI64"$()
|
||||
I64 i;
|
||||
CDoc *doc=DocNew;
|
||||
DocPutS(doc,"$$TX+CX,\"Set Freq\"$$\n" //Centered text
|
||||
"$$CM+LX,2,4$$$$BT,\"100 Hz\",100$$"
|
||||
"$$CM+LX,18,0$$$$BT,\"200 Hz\",200$$"
|
||||
"$$CM+LX,2,4$$$$BT,\"400 Hz\",400$$"
|
||||
"$$CM+LX,18,0$$$$BT,\"800 Hz\",800$$\n");
|
||||
i=PopUpMenu(doc);
|
||||
if (i<0) i=0; // <SHIFT-ESC>
|
||||
DocDel(doc);
|
||||
return i;
|
||||
}
|
||||
|
||||
#define MU_NOTHING 0
|
||||
#define MU_SET_FREQ 1
|
||||
#define MU_SND_ON 2
|
||||
#define MU_SND_OFF 3
|
||||
|
||||
U0 MenuButton()
|
||||
{
|
||||
Bool done=FALSE;
|
||||
I64 i,j=0,freq=100;
|
||||
I64 old_flags=DocCur->flags;
|
||||
//This allows keyboard navigation to skip nonselectible entries.
|
||||
DocCur->flags|=DOCF_FORM;
|
||||
do {
|
||||
DocClear;
|
||||
//Use <CTRL-L> to generate cursor movement expressions and check "Quote".
|
||||
"$$CM+CX-RE,-4$$Menu Demo\n\n";
|
||||
"$$LM,8$$"; //Set left margin
|
||||
//These are buttons that return a val from a menu selection.
|
||||
if (!j)
|
||||
"\n$$BT,\"Snd On\",MU_SND_ON$$\n\n\n";
|
||||
else
|
||||
"\n$$BT,\"Snd Off\",MU_SND_OFF$$\n\n\n";
|
||||
"\n$$BT,\"Set Freq\",MU_SET_FREQ$$\n\n\n"
|
||||
"\n$$BT,\"Nothing\",MU_NOTHING$$\n\n\n"
|
||||
"\n$$BT,\"Done\",DOCM_CANCEL$$\n\n\n";
|
||||
i=DocMenuDo(DocCur);
|
||||
DocBottom;
|
||||
switch (i) {
|
||||
case MU_NOTHING:
|
||||
break;
|
||||
case MU_SND_ON:
|
||||
j=freq;
|
||||
Snd(j);
|
||||
break;
|
||||
case MU_SND_OFF:
|
||||
j=0;
|
||||
Snd(j);
|
||||
break;
|
||||
case MU_SET_FREQ:
|
||||
freq=PopUpFreq;
|
||||
if (j) {
|
||||
j=freq;
|
||||
Snd(j);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
done=TRUE;
|
||||
}
|
||||
} while (!done);
|
||||
DocCur->flags=DocCur->flags&~DOCF_FORM |
|
||||
old_flags & DOCF_FORM;
|
||||
DocClear;
|
||||
Snd(0);
|
||||
}
|
||||
|
||||
MenuButton;
|
||||
Binary file not shown.
@@ -0,0 +1,24 @@
|
||||
"\nSuper : 3$$SY,-3$$2$$SY,0$$=9\n\n"
|
||||
"Sub : H$$SY,3$$2$$SY,0$$O\n\n"
|
||||
"Color : $$FG,RED$$Test$$FG$$\n\n"
|
||||
"Blink : $$BK,1$$Test$$BK,0$$\n\n"
|
||||
"Invert : $$IV,1$$Test$$IV,0$$\n\n"
|
||||
"UnderLine: $$UL,1$$Test$$UL,0$$\n\n"
|
||||
"Link : $$LK,\"Genesis,1:1\",\"BF:Genesis,1:1\"$$\n\n\n"
|
||||
|
||||
|
||||
"Button : $$BT-X,\"OKAY\",1$$\n\n\n\n";
|
||||
|
||||
//You can do it this way if you like.
|
||||
"\nSuper : 3$SY,-3$2$SY,0$=9\n\n"
|
||||
"Sub : H$SY,3$2$SY,0$O\n\n"
|
||||
//Can't see color because of syntax highlighting. Press <CTRL-T>
|
||||
"Color : $FG,4$Test$FG$\n\n"
|
||||
"Blink : $BK,1$Test$BK,0$\n\n"
|
||||
"Invert : $IV,1$Test$IV,0$\n\n"
|
||||
"UnderLine: $UL,1$Test$UL,0$\n\n"
|
||||
//<CTRL-SHIFT-T> on this link to toggle individual commands.
|
||||
"Link : $LK,"Genesis,1:1","BF:Genesis,1:1"$\n\n\n"
|
||||
|
||||
|
||||
"Button : $BT,"OKAY",1$\n\n\n\n";
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
This uses DocPutS/DocPrintF because updates
|
||||
to within a tree while a tree is collapsed get
|
||||
messed-up if "live"(like using ordinary PrintF/PutS.)
|
||||
The insert point is confused by hiding of
|
||||
data in collapsed trees. Therefore, the window main
|
||||
Doc is taken off-line by disabling preemption so there
|
||||
are no screen updates until all data has been inserted.
|
||||
|
||||
There is a special Doc function which is also
|
||||
available to take an Doc off-line. See $LK,"DocInsSafe","MN:DocInsSafe"$.
|
||||
For this example, however, I wanted to use DocPrintF
|
||||
and disabled Preemption myself.
|
||||
*/
|
||||
|
||||
#include "/SparrowOS/Demo/Shared/TreeDemoJoin"
|
||||
|
||||
U0 TreeDemo()
|
||||
{
|
||||
I64 fuf_flags=0;
|
||||
CDoc *doc=DocNew;
|
||||
GetFFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r");
|
||||
DocPutS(doc,"$$TR-C+AL,\"\"$$\n");
|
||||
DocPutS(doc,"$$ID,+2$$");
|
||||
TreeSub(doc,FilesFind("/SparrowOS/*",fuf_flags));
|
||||
DocPutS(doc,"$$ID,-2$$");
|
||||
DocInsDoc(DocCur,doc);
|
||||
DocDel(doc);
|
||||
}
|
||||
|
||||
TreeDemo;
|
||||
@@ -0,0 +1,84 @@
|
||||
/*
|
||||
This scans the sym table and checks
|
||||
each $LK,"HTT_DEFINE_STR","MN:HTT_DEFINE_STR"$ entry to see if
|
||||
it only occurs once in files.
|
||||
|
||||
It's a brute force solution, but
|
||||
gets the job done... slowly.
|
||||
|
||||
$LK,"Grep","MN:Grep"$() returns a count of matches.
|
||||
|
||||
$LK,"FileOcc","MN:FileOcc"$() is $LK,"Grep","MN:Grep"$() with
|
||||
output $LK,"Silent","MN:Silent"$().
|
||||
|
||||
*/
|
||||
|
||||
U0 UnusedDefineScan()
|
||||
{
|
||||
CDoc *old_doc=DocCur,*doc;
|
||||
I64 cnt=0;
|
||||
CHashTable *tempht;
|
||||
CHash *temph;
|
||||
CDocEntry *doc_e,*doc_e2;
|
||||
Bool old_silent=IsSilent;
|
||||
|
||||
//Technically, we might want to
|
||||
//turn-off preemption in case the
|
||||
//table was modified.
|
||||
|
||||
try {
|
||||
tempht=Fs->hash_table;
|
||||
while (tempht) {
|
||||
temph=tempht->next_added;
|
||||
while (temph!=tempht) {
|
||||
if (temph->type&HTT_DEFINE_STR)
|
||||
cnt++;
|
||||
temph=temph->next_added;
|
||||
}
|
||||
tempht=tempht->next;
|
||||
}
|
||||
|
||||
progress1=0;
|
||||
progress1_max=cnt;
|
||||
StrCpy(progress1_desc,"Define Scan");
|
||||
|
||||
tempht=Fs->hash_table;
|
||||
while (tempht) {
|
||||
temph=tempht->next_added;
|
||||
while (temph!=tempht) {
|
||||
if (temph->type&HTT_DEFINE_STR) {
|
||||
progress1++;
|
||||
if (FileOcc(temph->str,"/SparrowOS/"TEXT_FILE_MASK,"+l-i")==1) {
|
||||
doc=DocNew;
|
||||
DocQueRem(old_doc);
|
||||
DocQueIns(doc,Fs->last_doc);
|
||||
Grep(temph->str,"/SparrowOS/"TEXT_FILE_MASK,"+l-i");
|
||||
DocQueRem(doc);
|
||||
DocQueIns(old_doc,Fs->last_doc);
|
||||
doc_e=doc->root.next;
|
||||
while (doc_e!=doc) {
|
||||
if (doc_e->type_u8==DOCT_LINK) {
|
||||
NewLine;
|
||||
"" temph->str;
|
||||
doc_e2=DocEntryCopy(doc,doc_e);
|
||||
DocIns(old_doc,doc_e2);
|
||||
NewLine;
|
||||
}
|
||||
doc_e=doc_e->next;
|
||||
}
|
||||
DocDel(doc);
|
||||
}
|
||||
}
|
||||
temph=temph->next_added;
|
||||
}
|
||||
tempht=tempht->next;
|
||||
}
|
||||
} catch
|
||||
CatchAll;
|
||||
|
||||
Silent(old_silent);
|
||||
NewLine;
|
||||
ProgressBarsRst;
|
||||
}
|
||||
|
||||
UnusedDefineScan;
|
||||
@@ -0,0 +1,68 @@
|
||||
#define DB_FILENAME "HOME/DataBaseDemo.BIN"
|
||||
#define DB_MAX_ACCT 100
|
||||
#define DB_ACCT_BLKS 1
|
||||
|
||||
class Acct
|
||||
{ //Use <CTRL-L> to help generate fmtstrs.
|
||||
U8 name[32] fmtstr "$$DA-P,32,\"Name:%s\"$$\n";
|
||||
U8 addr[64] fmtstr "$$DA-P,64,\"Addr:%s\"$$\n";
|
||||
U8 pad[DB_ACCT_BLKS*BLK_SIZE-64-32];
|
||||
};
|
||||
|
||||
|
||||
U0 InitDatabase()
|
||||
{
|
||||
CFile *f;
|
||||
//Write new contiguous file
|
||||
f=FOpen(DB_FILENAME,"w",DB_MAX_ACCT*DB_ACCT_BLKS);
|
||||
FClose(f);
|
||||
}
|
||||
|
||||
|
||||
U0 WriteAcct()
|
||||
{
|
||||
CFile *f;
|
||||
Acct a;
|
||||
I64 acctnum;
|
||||
|
||||
acctnum=PmtI64("Acct #",-1);
|
||||
if (0<=acctnum<DB_MAX_ACCT) {
|
||||
MemSet(&a,0,BLK_SIZE);
|
||||
if (DocFormDo(&a,"Acct")) {
|
||||
f=FOpen(DB_FILENAME,"w+");
|
||||
FWBlks(f,&a,acctnum*DB_ACCT_BLKS,DB_ACCT_BLKS);
|
||||
FClose(f);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
U0 ReadAcct()
|
||||
{
|
||||
CFile *f;
|
||||
Acct a;
|
||||
I64 acctnum;
|
||||
|
||||
acctnum=PmtI64("Acct #",-1);
|
||||
if (0<=acctnum<DB_MAX_ACCT) {
|
||||
f=FOpen(DB_FILENAME,"r");
|
||||
FRBlks(f,&a,acctnum*DB_ACCT_BLKS,DB_ACCT_BLKS);
|
||||
FClose(f);
|
||||
ClassRep("Acct",&a);
|
||||
}
|
||||
}
|
||||
|
||||
U0 DatabaseDemo()
|
||||
{
|
||||
I64 ch;
|
||||
if (!FileFind(DB_FILENAME))
|
||||
InitDatabase;
|
||||
do {
|
||||
"$$FG,GREEN$$R$$FG$$ead acct, $$FG,GREEN$$W$$FG$$rite acct or $$FG,GREEN$$<SHIFT-ESC>$$FG$$:";
|
||||
ch=ToUpper(GetChar);
|
||||
NewLine;
|
||||
if (ch=='R') ReadAcct;
|
||||
if (ch=='W') WriteAcct;
|
||||
} while (ch!=CH_SHIFT_ESC && ch!=CH_ESC);
|
||||
}
|
||||
|
||||
DatabaseDemo;
|
||||
@@ -0,0 +1,27 @@
|
||||
/* There is no FPrintF type function and no
|
||||
way to grow files. Therefore, use mem to
|
||||
hold the file until you are done. The $LK,"CDoc","MN:CDoc"$
|
||||
framework is convenient for this.
|
||||
*/
|
||||
|
||||
#include "/SparrowOS/Demo/Shared/TreeDemoJoin"
|
||||
|
||||
U0 FPrintFDemo(U8 *output_filename=NULL)
|
||||
{
|
||||
I64 fuf_flags=0;
|
||||
CDoc *doc=DocNew;
|
||||
GetFFlags(&fuf_flags,Define("ST_FILE_UTIL_FLAGS"),"+r");
|
||||
DocPutS(doc,"$$TR-C+AL,\"\"$$\n");
|
||||
DocPutS(doc,"$$ID,+2$$");
|
||||
TreeSub(doc,FilesFind("/SparrowOS/*",fuf_flags));
|
||||
DocPutS(doc,"$$ID,-2$$");
|
||||
DocRecalc(doc);
|
||||
if (output_filename) {
|
||||
StrCpy(doc->filename.name,output_filename);
|
||||
DocWrite(doc,FALSE);
|
||||
} else
|
||||
DocWrite(doc,TRUE);
|
||||
DocDel(doc);
|
||||
}
|
||||
|
||||
FPrintFDemo;
|
||||
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
$WW,1$This gets a list of files, flattens the list from a tree into an array and sorts them by cluster num, to speed-up access time by avoiding moving the disk head around.
|
||||
$WW,0$*/
|
||||
|
||||
U0 Main()
|
||||
{
|
||||
I64 i,cnt=0;
|
||||
CDirEntry *tempm=FilesFind("::/SparrowOS/*",1<<FUf_RECURSE),
|
||||
**a=FilesOrder(tempm,&cnt);
|
||||
for (i=0;i<cnt;i++) {
|
||||
"%08X %s\n",a[i]->cluster,a[i]->full_name;
|
||||
CDirEntryDel(a[i]);
|
||||
}
|
||||
Free(a);
|
||||
}
|
||||
|
||||
Main;
|
||||
@@ -0,0 +1,41 @@
|
||||
U0 RawAccess(I64 drv_let=0)
|
||||
{
|
||||
CPrt *p=Drv2Prt(drv_let);
|
||||
CBlkDev *bdev=Drv2BlkDev(drv_let);
|
||||
I64 blk,old_offset,old_size;
|
||||
U8 *buf=MAlloc(BLK_SIZE);
|
||||
|
||||
PrtRep;
|
||||
PressAKey;
|
||||
|
||||
ClassRep("CPrt",p);
|
||||
PressAKey;
|
||||
|
||||
ClassRep("CBlkDev",bdev);
|
||||
PressAKey;
|
||||
|
||||
//Temporarily change partition range to full device.
|
||||
//Normally, you are limited to just your partition.
|
||||
//This is obviously $BK,1$dangerous$BK,0$!
|
||||
old_offset=p->offset;
|
||||
old_size =p->size;
|
||||
p->offset=bdev->min_blk;
|
||||
p->size=bdev->max_blk-bdev->min_blk+1;
|
||||
|
||||
try {
|
||||
blk=PmtI64("Blk to Read: ",old_offset,bdev->min_blk,bdev->max_blk);
|
||||
RBlks(p,buf,blk,1);
|
||||
D(buf,BLK_SIZE);
|
||||
} catch
|
||||
CatchAll;
|
||||
|
||||
p->offset=old_offset;
|
||||
p->size =old_size;
|
||||
|
||||
Free(buf);
|
||||
}
|
||||
|
||||
RawAccess;
|
||||
|
||||
//See $LK,"RBlks","MN:RBlks"$(), $LK,"WBlks","MN:WBlks"$(), $LK,"PrtLock","MN:PrtLock"$(), $LK,"PrtUnlock","MN:PrtUnlock"$()
|
||||
//$LK,"DBlk","MN:DBlk"$(), $LK,"DCluster","MN:DCluster"$(), $LK,"BlkDevLock","MN:BlkDevLock"$() and $LK,"BlkDevUnlock","MN:BlkDevUnlock"$().
|
||||
@@ -0,0 +1,16 @@
|
||||
U0 UnusedSpaceRep()
|
||||
{
|
||||
I64 i;
|
||||
CPrt *p;
|
||||
for (i=0;i<26;i++) {
|
||||
try {
|
||||
p=Drv2Prt(i+'A');
|
||||
if (p->type==PT_FAT32 || p->type==PT_NATIVE)
|
||||
"%C: %7.3f%% Free\n",
|
||||
Prt2Drv(p),UnusedDrvSpace(Prt2Drv(p))*100.0/(p->size*BLK_SIZE);
|
||||
} catch
|
||||
Fs->catch_except=TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
UnusedSpaceRep;
|
||||
@@ -0,0 +1,71 @@
|
||||
//$BK,1$WARNING:$BK,0$ Don't return out of a catch{}. This
|
||||
//might get fixed.
|
||||
|
||||
//You can use $LK,"CatchAll","MN:CatchAll"$() in a catch statement
|
||||
//and it will report args.
|
||||
|
||||
#define EXCEPT_1 1
|
||||
#define EXCEPT_2 2
|
||||
#define EXCEPT_3 3
|
||||
#define EXCEPT_4 4
|
||||
|
||||
U0 Show()
|
||||
{
|
||||
I64 i;
|
||||
"Fs->except_argc=%X\n",Fs->except_argc;
|
||||
for (i=0;i<Fs->except_argc;i++)
|
||||
"Fs->except_argv[%d]=%08X\n",i,Fs->except_argv[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
Bool Pmt(I64 i)
|
||||
{
|
||||
"%d ",i;
|
||||
return YorN;
|
||||
}
|
||||
|
||||
U0 D1()
|
||||
{
|
||||
"D1\n";
|
||||
if (Pmt(1)) throw(EXCEPT_1);
|
||||
if (Pmt(2)) throw(EXCEPT_2,33,55,66);
|
||||
if (Pmt(5)) throw;
|
||||
}
|
||||
|
||||
U0 D2()
|
||||
{
|
||||
"D2\n";
|
||||
try {
|
||||
D1;
|
||||
if (Pmt(4)) throw(EXCEPT_4);
|
||||
} catch {
|
||||
"D2 handler\n";
|
||||
Show;
|
||||
if (Fs->except_argc>0) {
|
||||
if (Fs->except_argv[0]==EXCEPT_1) {
|
||||
"Caught in D2\n";
|
||||
Fs->catch_except=TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
U0 Demo()
|
||||
{
|
||||
try {
|
||||
D2;
|
||||
if (Pmt(3)) throw;
|
||||
} catch {
|
||||
"Demo handler\n";
|
||||
Show;
|
||||
"Ignore Except";
|
||||
if (YorN)
|
||||
Fs->ignore_except=TRUE;
|
||||
else
|
||||
Fs->catch_except=TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Demo;
|
||||
@@ -0,0 +1,36 @@
|
||||
U0 Install()
|
||||
{
|
||||
gr_font[8*255+0]=0b00111100;
|
||||
gr_font[8*255+1]=0b01000010;
|
||||
gr_font[8*255+2]=0b10100101;
|
||||
gr_font[8*255+3]=0b10000001;
|
||||
gr_font[8*255+4]=0b11000011;
|
||||
gr_font[8*255+5]=0b10111101;
|
||||
gr_font[8*255+6]=0b01000010;
|
||||
gr_font[8*255+7]=0b00111100;
|
||||
}
|
||||
|
||||
Install;
|
||||
|
||||
"Face:ÿ\n";
|
||||
|
||||
//Chars 128-255 are treated as letters
|
||||
//by the compiler and everything else.
|
||||
//Enter them by holding ALT and
|
||||
//pressing a 3 digit decimal number or
|
||||
//press <CTRL-ALT-A>.
|
||||
|
||||
U0 SrcExample()
|
||||
{
|
||||
I64 fÿÿ=12345;
|
||||
"fÿÿ=%d\n",fÿÿ;
|
||||
}
|
||||
|
||||
SrcExample;
|
||||
//See $LK,"::/SparrowOS/Demo/ScreenCodes.CPP.Z","FI:::/SparrowOS/Demo/ScreenCodes.CPP.Z"$
|
||||
//$LK,"::/SparrowOS/Demo/Graphics/CharGraphics.CPP.Z","FI:::/SparrowOS/Demo/Graphics/CharGraphics.CPP.Z"$,
|
||||
//and $LK,"::/SparrowOS/Demo/Graphics/FontEd.CPP.Z","FI:::/SparrowOS/Demo/Graphics/FontEd.CPP.Z"$.
|
||||
|
||||
//See $LK,"alpha_bitmap","MN:alpha_bitmap"$, and
|
||||
//$LK,"alpha_numeric_bitmap","MN:alpha_numeric_bitmap"$.
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
File diff suppressed because it is too large.
Load diff
Binary file not shown.
@@ -0,0 +1,124 @@
|
||||
//Practice tracing circles
|
||||
|
||||
AcctRegSetDftEntry("SparrowOS/CircleTrace","F64 best_score=999;\n");
|
||||
AcctRegExecuteBranch("SparrowOS/CircleTrace");
|
||||
|
||||
I64 cx,cy;
|
||||
F64 avg_error=0,elapsed_time=0,total_error=0,score=999;
|
||||
|
||||
U0 SongTask(I64)
|
||||
{
|
||||
Fs->task_end_cb=&SndTaskEndCB;
|
||||
MusicSettingsRst;
|
||||
while (TRUE)
|
||||
Play("hEDCARCDECR");
|
||||
}
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *)
|
||||
{
|
||||
U8 buf[128];
|
||||
SPrintF(buf,"Error:%6.3f Time:%6.3f Score:%6.3f Best:%8.3f",avg_error,elapsed_time,score,best_score);
|
||||
PlotWinStr(task,buf,BLACK<<4+WHITE,0,0);
|
||||
}
|
||||
|
||||
#define CIRCLE_RADIUS 100
|
||||
#define CIRCUMFERENCE (2*ã*CIRCLE_RADIUS)
|
||||
|
||||
Bool CTPlot(CDC *dc,I64 x,I64 y,I64)
|
||||
{
|
||||
F64 rad=Sqrt(Sqr(x-cx)+Sqr(y-cy));
|
||||
GrPlot(dc,x,y);
|
||||
total_error+=Abs(rad-CIRCLE_RADIUS);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
U0 CircleTrace()
|
||||
{
|
||||
I64 msg_code,p1,p2,x1,y1;
|
||||
F64 rad,t0,total_distance;
|
||||
CDC *dc=DCAlias;
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
Fs->song_task=Spawn(&SongTask,NULL,"Song",Fs);
|
||||
WordStat;
|
||||
|
||||
cx=Fs->win_pixel_width/2;
|
||||
cy=Fs->win_pixel_height/2;
|
||||
|
||||
Fs->win_inhibit=WIF_ALL-WIF_BORDER;
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
|
||||
DCFill;
|
||||
dc->color=ROP_XOR+BLACK^COLOR_TRANSPARENT;
|
||||
GrCircle(dc,cx,cy,CIRCLE_RADIUS);
|
||||
do {
|
||||
msg_code=GetMsg(&p1,&p2,
|
||||
1<<MSG_KEY_DOWN+1<<MSG_IP_L_DOWN);
|
||||
switch (msg_code) {
|
||||
case MSG_KEY_UP:
|
||||
break;
|
||||
case MSG_IP_L_DOWN:
|
||||
DCFill;
|
||||
dc->color=ROP_XOR+BLACK^COLOR_TRANSPARENT;
|
||||
GrCircle(dc,cx,cy,CIRCLE_RADIUS);
|
||||
dc->color=ROP_XOR+RED^COLOR_TRANSPARENT;
|
||||
t0=tP;
|
||||
total_distance=0.001;
|
||||
total_error=0;
|
||||
x1=p1; y1=p2;
|
||||
do {
|
||||
msg_code=ScanMsg(&p1,&p2,
|
||||
1<<MSG_IP_L_UP+1<<MSG_IP_MOVE);
|
||||
switch (msg_code) {
|
||||
case MSG_IP_L_UP:
|
||||
break;
|
||||
case MSG_IP_MOVE:
|
||||
if (x1!=p1 || y1!=p2) {
|
||||
total_distance+=Sqrt(Sqr(x1-p1)+Sqr(y1-p2));
|
||||
Line(dc,x1,y1,0,p1,p2,0,&CTPlot);
|
||||
x1=p1;y1=p2;
|
||||
//undo overlapping pixels on segments
|
||||
GrPlot(dc,x1,y1);
|
||||
rad=Sqrt(Sqr(x1-cx)+Sqr(y1-cy));
|
||||
total_error-=Abs(rad-CIRCLE_RADIUS);
|
||||
}
|
||||
break;
|
||||
}
|
||||
elapsed_time=tP-t0;
|
||||
avg_error=total_error/total_distance;
|
||||
score=elapsed_time*avg_error;
|
||||
|
||||
//This $LK,"Sleep","MN:Sleep"$()s until the next time the
|
||||
//window mgr task runs. The
|
||||
//window mgr calls the UpdateWin() routine
|
||||
//and places msgs in the que, so there's
|
||||
//no need to do anything until the window mgr runs.
|
||||
WinMgrSync;
|
||||
|
||||
} while (msg_code!=MSG_IP_L_UP);
|
||||
music_mute=TRUE; Sleep(200);
|
||||
if (total_distance>0.95*CIRCUMFERENCE) {
|
||||
if (score<best_score) {
|
||||
Snd(2000);Sleep(50);Snd(0);Sleep(50);
|
||||
Snd(2000);Sleep(50);Snd(0);Sleep(50);
|
||||
Snd(2000);Sleep(50);
|
||||
best_score=score;
|
||||
} else {
|
||||
Snd(500);Sleep(50);
|
||||
}
|
||||
} else {
|
||||
Snd(100);Sleep(1000);
|
||||
}
|
||||
Snd(0); Sleep(200); music_mute=FALSE;
|
||||
break;
|
||||
}
|
||||
} while (msg_code!=MSG_KEY_DOWN || p1!=CH_SHIFT_ESC && p1!=CH_ESC);
|
||||
SettingsPop;
|
||||
DCFill;
|
||||
DCDel(dc);
|
||||
AcctRegWriteBranch("SparrowOS/CircleTrace","F64 best_score=%5.4f;\n",best_score);
|
||||
}
|
||||
|
||||
CircleTrace; //Execute when #included
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,509 @@
|
||||
//Set snap to 4 and width to 4
|
||||
//if you edit this map.
|
||||
|
||||
//Don't forget to change the
|
||||
//starting pos.
|
||||
$BG,0$
|
||||
|
||||
$SP,"map",1$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"hero",2$
|
||||
|
||||
|
||||
|
||||
$SP,"hero_attack",3$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"template",4$ //This is a template you can copy and use to make a tile.
|
||||
//WHITE is the transparent color.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"tree",5$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"path",6$
|
||||
|
||||
|
||||
|
||||
$SP,"water1",7$
|
||||
|
||||
|
||||
|
||||
$SP,"water2",8$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"goblin",9$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"wall1",10$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"wall2",11$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$BG$
|
||||
|
||||
//These are indexed by color #.
|
||||
//See $LK,"COLORS","MN:RED"$.
|
||||
|
||||
U8 *tiles1[16]=
|
||||
{NULL,$IB,"<7>",7$ ,$IB,"<5>",5$ ,NULL,
|
||||
$IB,"<6>",6$ ,NULL,NULL,NULL,
|
||||
NULL,NULL,NULL,NULL,
|
||||
NULL,NULL,NULL,NULL};
|
||||
|
||||
U8 *tiles2[16]=
|
||||
{NULL,$IB,"<8>",8$ ,$IB,"<5>",5$ ,NULL,
|
||||
$IB,"<6>",6$ ,NULL,NULL,NULL,
|
||||
NULL,NULL,NULL,NULL,
|
||||
NULL,NULL,NULL,NULL};
|
||||
|
||||
|
||||
|
||||
#define SCREEN_SCALE 24
|
||||
#define SCREEN_WIDTH 24
|
||||
#define SCREEN_HEIGHT 24
|
||||
I64 screen_x,screen_y;
|
||||
|
||||
#define MAP_SCALE 4
|
||||
I64 map_width,map_height;
|
||||
U8 *map=NULL;
|
||||
|
||||
I64 man_x,man_y,man_dx,man_dy;
|
||||
Bool man_attack;
|
||||
F64 man_attack_t0;
|
||||
|
||||
#define NUM_MONSTERS 16
|
||||
class Monster
|
||||
{
|
||||
I64 x,y,dx,dy;
|
||||
Bool dead,pad[7];
|
||||
} monsters[NUM_MONSTERS];
|
||||
|
||||
#define LOS_SCALE 4
|
||||
|
||||
Bool LOSPlot(U8 *,I64 x,I64 y,I64)
|
||||
{
|
||||
if (!map[(y/LOS_SCALE)*map_width+(x/LOS_SCALE)])
|
||||
return FALSE;
|
||||
else
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
Bool LOS(I64 x1,I64 y1,I64 x2,I64 y2)
|
||||
{ //Line of sight
|
||||
return Line(NULL,x1*LOS_SCALE+LOS_SCALE/2,y1*LOS_SCALE+LOS_SCALE/2,0,
|
||||
x2*LOS_SCALE+LOS_SCALE/2,y2*LOS_SCALE+LOS_SCALE/2,0,&LOSPlot);
|
||||
}
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
CDC *dc_t=DCAlias(gr_dc,task);
|
||||
I64 i,x,y,xx,yy,x1,y1,z1,color;
|
||||
CD3I32 poly[4];
|
||||
U8 **_tiles;
|
||||
|
||||
task->text_attr=BLACK<<4;
|
||||
if (Blink(5,tP(task)))
|
||||
_tiles=tiles1;
|
||||
else
|
||||
_tiles=tiles2;
|
||||
|
||||
GrRotXEqu(dc_t->r,60*2*ã/360);
|
||||
GrRotZEqu(dc_t->r,15*2*ã/360);
|
||||
GrSetRotMat(dc_t,dc_t->r);
|
||||
dc_t->x=task->win_pixel_width/2;
|
||||
dc_t->y=task->win_pixel_height/2;
|
||||
dc_t->flags|=DCF_TRANSFORMATION;
|
||||
|
||||
//You could make it much more efficient
|
||||
//if you did it like $LK,"::/SparrowOS/Demo/GameStarters/BigGuns.CPP.Z","FI:::/SparrowOS/Demo/GameStarters/BigGuns.CPP.Z"$
|
||||
//with a $LK,"CDC","MN:CDC"$.
|
||||
|
||||
for (y=-SCREEN_HEIGHT/2;y<SCREEN_HEIGHT/2;y++) {
|
||||
yy=y+screen_y;
|
||||
if (0<=yy<map_height)
|
||||
for (x=-SCREEN_WIDTH/2;x<SCREEN_WIDTH/2;x++) {
|
||||
xx=x+screen_x;
|
||||
if (0<=xx<map_width) {
|
||||
if ((color=map[yy*map_width+xx]) &&
|
||||
LOS(xx,yy,man_x,man_y)) {
|
||||
if (_tiles[color]) {
|
||||
x1=x*SCREEN_SCALE;
|
||||
y1=y*SCREEN_SCALE;
|
||||
z1=0;
|
||||
GrTransform(dc_t,&x1,&y1,&z1);
|
||||
CSpritePlot3(dc,x1,y1,z1,_tiles[color]);
|
||||
} else { //If no tile defined, do solid color.
|
||||
poly[0].x=x*SCREEN_SCALE;
|
||||
poly[0].y=y*SCREEN_SCALE;
|
||||
poly[0].z=0;
|
||||
poly[1].x=(x+1)*SCREEN_SCALE-1;
|
||||
poly[1].y=y*SCREEN_SCALE;
|
||||
poly[1].z=0;
|
||||
poly[2].x=(x+1)*SCREEN_SCALE;
|
||||
poly[2].y=(y+1)*SCREEN_SCALE-1;
|
||||
poly[2].z=0;
|
||||
poly[3].x=x*SCREEN_SCALE-1;
|
||||
poly[3].y=(y+1)*SCREEN_SCALE-1;
|
||||
poly[3].z=0;
|
||||
dc_t->color=color;
|
||||
GrFillPoly3(dc_t,4,poly);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dc_t->color=LTGRAY;
|
||||
for (x=-SCREEN_WIDTH/2;x<=SCREEN_WIDTH/2;x++)
|
||||
GrLine3(dc_t,x*SCREEN_SCALE,-SCREEN_HEIGHT/2*SCREEN_SCALE,0,x*SCREEN_SCALE,SCREEN_HEIGHT/2*SCREEN_SCALE-1,0);
|
||||
for (y=-SCREEN_HEIGHT/2;y<=SCREEN_HEIGHT/2;y++)
|
||||
GrLine3(dc_t,-SCREEN_WIDTH/2*SCREEN_SCALE,y*SCREEN_SCALE,0,SCREEN_WIDTH/2*SCREEN_SCALE,y*SCREEN_SCALE-1,0);
|
||||
|
||||
for (y=-SCREEN_HEIGHT/2;y<SCREEN_HEIGHT/2;y++) {
|
||||
yy=y+screen_y;
|
||||
if (0<=yy<map_height)
|
||||
for (x=-SCREEN_WIDTH/2;x<SCREEN_WIDTH/2;x++) {
|
||||
xx=x+screen_x;
|
||||
if (0<=xx<map_width) {
|
||||
if (!map[yy*map_width+xx]) {
|
||||
if (yy+1<map_height && LOS(xx,yy+1,man_x,man_y)) {
|
||||
x1=x*SCREEN_SCALE;
|
||||
y1=y*SCREEN_SCALE;
|
||||
z1=0;
|
||||
GrTransform(dc_t,&x1,&y1,&z1);
|
||||
CSpritePlot3(dc,x1,y1,z1,$IB,"<10>",10$);
|
||||
}
|
||||
if (xx+1<map_width && LOS(xx+1,yy,man_x,man_y)) {
|
||||
x1=x*SCREEN_SCALE;
|
||||
y1=y*SCREEN_SCALE;
|
||||
z1=0;
|
||||
GrTransform(dc_t,&x1,&y1,&z1);
|
||||
CSpritePlot3(dc,x1,y1,z1,$IB,"<11>",11$);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<NUM_MONSTERS;i++)
|
||||
if (!monsters[i].dead && LOS(monsters[i].x,monsters[i].y,man_x,man_y)) {
|
||||
x1=(monsters[i].x-screen_x)*SCREEN_SCALE+SCREEN_SCALE/2;
|
||||
y1=(monsters[i].y-screen_y)*SCREEN_SCALE+SCREEN_SCALE/2;
|
||||
z1=0;
|
||||
GrTransform(dc_t,&x1,&y1,&z1);
|
||||
if (monsters[i].dx<0) {
|
||||
dc->flags|=DCF_SYMMETRY|DCF_JUST_MIRROR;
|
||||
GrSetSymmetry(dc,x1,y1,x1,y1+1);
|
||||
} else
|
||||
dc->flags&=~(DCF_SYMMETRY|DCF_JUST_MIRROR);
|
||||
CSpritePlot3(dc,x1,y1,z1,$IB,"<9>",9$);
|
||||
}
|
||||
|
||||
x1=(man_x-screen_x)*SCREEN_SCALE+SCREEN_SCALE/2;
|
||||
y1=(man_y-screen_y)*SCREEN_SCALE+SCREEN_SCALE/2;
|
||||
z1=0;
|
||||
if (tP(task)-man_attack_t0<0.2) {
|
||||
x1+=Tri(tP(task)-man_attack_t0,0.2)*SCREEN_SCALE*man_dx;
|
||||
y1+=Tri(tP(task)-man_attack_t0,0.2)*SCREEN_SCALE*man_dy;
|
||||
}
|
||||
GrTransform(dc_t,&x1,&y1,&z1);
|
||||
if (man_dx<0) {
|
||||
dc->flags|=DCF_SYMMETRY|DCF_JUST_MIRROR;
|
||||
GrSetSymmetry(dc,x1,y1,x1,y1+1);
|
||||
} else
|
||||
dc->flags&=~(DCF_SYMMETRY|DCF_JUST_MIRROR);
|
||||
|
||||
if (tP(task)-man_attack_t0<0.2)
|
||||
CSpritePlot3(dc,x1,y1,z1,$IB,"<3>",3$);
|
||||
else
|
||||
CSpritePlot3(dc,x1,y1,z1,$IB,"<2>",2$);
|
||||
|
||||
DCDel(dc_t);
|
||||
}
|
||||
|
||||
|
||||
U0 Attack()
|
||||
{
|
||||
I64 i;
|
||||
man_attack_t0=tP;
|
||||
Noise(100,300,1000);
|
||||
for (i=0;i<NUM_MONSTERS;i++) {
|
||||
if (!monsters[i].dead &&
|
||||
man_x+man_dx==monsters[i].x && man_y+man_dy==monsters[i].y)
|
||||
monsters[i].dead=TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i,x,y,minx,maxx,miny,maxy;
|
||||
CDC *dc;
|
||||
CSpriteExtents($IB,"<1>",1$,&minx,&maxx,&miny,&maxy);
|
||||
map_width =(maxx-minx+1)/MAP_SCALE;
|
||||
map_height=(maxy-miny+1)/MAP_SCALE;
|
||||
Free(map);
|
||||
map=MAlloc(map_width*map_height*sizeof(U8));
|
||||
dc=DCNew(DCT_COLOR8,map_width*MAP_SCALE,map_height*MAP_SCALE);
|
||||
CSpritePlot3(dc,-minx,-miny,0,$IB,"<1>",1$);
|
||||
for (y=0;y<map_height;y++)
|
||||
for (x=0;x<map_width;x++)
|
||||
map[y*map_width+x]=GrPeek(dc,x*MAP_SCALE,y*MAP_SCALE);
|
||||
DCDel(dc);
|
||||
|
||||
for (i=0;i<NUM_MONSTERS;i++) {
|
||||
monsters[i].dead=FALSE;
|
||||
monsters[i].dx=0;
|
||||
monsters[i].dy=0;
|
||||
do {
|
||||
monsters[i].x=RandU64%(map_width-2)+1;
|
||||
monsters[i].y=RandU64%(map_height-2)+1;
|
||||
} while (!map[(monsters[i].y)*map_width+monsters[i].x]);
|
||||
}
|
||||
man_attack_t0=tP;
|
||||
man_attack=FALSE;
|
||||
man_x=0;
|
||||
man_y=4;
|
||||
man_dx=0;
|
||||
man_dy=0;
|
||||
screen_x=0;
|
||||
screen_y=0;
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
Free(map);
|
||||
map=NULL;
|
||||
}
|
||||
|
||||
U0 AnimateTask(I64)
|
||||
{
|
||||
I64 i,x,y,dx,dy;
|
||||
while (TRUE) {
|
||||
for (i=0;i<NUM_MONSTERS;i++)
|
||||
if (!monsters[i].dead) {
|
||||
dx=RandU16%3-1;
|
||||
dy=RandU16%3-1;
|
||||
x=monsters[i].x+dx;
|
||||
y=monsters[i].y+dy;
|
||||
if (0<=x<=map_width && 0<=y<=map_height &&
|
||||
map[y*map_width+x]) {
|
||||
monsters[i].x=x;
|
||||
monsters[i].y=y;
|
||||
monsters[i].dx=dx;
|
||||
monsters[i].dy=dy;
|
||||
}
|
||||
}
|
||||
Sleep(1000);
|
||||
}
|
||||
}
|
||||
|
||||
U0 DunGen()
|
||||
{
|
||||
I64 ch,sc;
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" Up(,,SC_CURSOR_UP);"
|
||||
" Down(,,SC_CURSOR_DOWN);"
|
||||
" Left(,,SC_CURSOR_LEFT);"
|
||||
" Right(,,SC_CURSOR_RIGHT);"
|
||||
" Attack(,CH_SPACE);"
|
||||
"}"
|
||||
);
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
Preempt(OFF);
|
||||
WinMax;
|
||||
WordStat;
|
||||
Init;
|
||||
Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",Fs);
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
|
||||
try {
|
||||
while (TRUE) {
|
||||
switch (GetMsg(&ch,&sc,1<<MSG_KEY_DOWN|1<<MSG_KEY_UP)) {
|
||||
case MSG_KEY_DOWN:
|
||||
switch (ch) {
|
||||
case CH_NEW_LINE:
|
||||
Init;
|
||||
break;
|
||||
case CH_SPACE:
|
||||
man_attack=TRUE;
|
||||
break;
|
||||
case CH_ESC:
|
||||
case CH_SHIFT_ESC:
|
||||
goto dg_done;
|
||||
case 0:
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_RIGHT:
|
||||
if (man_attack) {
|
||||
man_dx=1;
|
||||
man_dy=0;
|
||||
Attack;
|
||||
} else
|
||||
if (man_x+1<map_width && map[man_y*map_width+(man_x+1)]==RED) {
|
||||
man_x++;
|
||||
if (man_x-screen_x>SCREEN_WIDTH/2-3) {
|
||||
screen_x+=SCREEN_WIDTH/2;
|
||||
if (screen_x+SCREEN_WIDTH/2>map_width)
|
||||
screen_x=map_width-SCREEN_WIDTH/2;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SC_CURSOR_LEFT:
|
||||
if (man_attack) {
|
||||
man_dx=-1;
|
||||
man_dy=0;
|
||||
Attack;
|
||||
} else
|
||||
if (man_x-1>=0 && map[man_y*map_width+(man_x-1)]==RED) {
|
||||
man_x--;
|
||||
if (man_x-screen_x<-SCREEN_WIDTH/2+3) {
|
||||
screen_x-=SCREEN_WIDTH/2;
|
||||
if (screen_x-SCREEN_WIDTH/2<0)
|
||||
screen_x=SCREEN_WIDTH/2;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SC_CURSOR_UP:
|
||||
if (man_attack) {
|
||||
man_dx=0;
|
||||
man_dy=-1;
|
||||
Attack;
|
||||
} else
|
||||
if (man_y-1>=0 && map[(man_y-1)*map_width+man_x]==RED) {
|
||||
man_y--;
|
||||
if (man_y-screen_y<-SCREEN_HEIGHT/2+3) {
|
||||
screen_y-=SCREEN_HEIGHT/2;
|
||||
if (screen_y-SCREEN_HEIGHT/2<0)
|
||||
screen_y=SCREEN_HEIGHT/2;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case SC_CURSOR_DOWN:
|
||||
if (man_attack) {
|
||||
man_dx=0;
|
||||
man_dy=1;
|
||||
Attack;
|
||||
} else
|
||||
if (man_y+1<map_height && map[(man_y+1)*map_width+man_x]==RED) {
|
||||
man_y++;
|
||||
if (man_y-screen_y>SCREEN_HEIGHT/2-3) {
|
||||
screen_y+=SCREEN_HEIGHT/2;
|
||||
if (screen_y+SCREEN_HEIGHT/2>map_height)
|
||||
screen_y=map_height-SCREEN_HEIGHT/2;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case MSG_KEY_UP:
|
||||
if (ch==CH_SPACE)
|
||||
man_attack=FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
dg_done:
|
||||
GetMsg(,,1<<MSG_KEY_UP);
|
||||
} catch
|
||||
CatchAll;
|
||||
SettingsPop;
|
||||
MenuPop;
|
||||
CleanUp;
|
||||
}
|
||||
|
||||
DunGen;
|
||||
£ | ˜ ˜ øÿÿÿ˜ ˜ ´ ´ ´ øÿÿÿ´ øÿÿÿ˜ øÿÿÿ¤ ¤ œ ° ° ° üÿÿÿ° üÿÿÿœ üÿÿÿœ üÿÿÿœ œ ¬ ¬ ¬ ¬ ¨ ¤ $ Ì $ Ì $ Ì @ Ì @ ¤ @ ¤ @ ¤ ( ¨ ( È ( È ( È < È < ¨ < ¨ < ¨ , ¨ , Ä , Ä , Ä 8 Ä 8 ¬ 8 ¬ 8 ¬ 0 ¬ 0 À 0 À 0 À 4 À 4 ° 4 Ì 4 ä 4 ä ( ä @ ä @ @ @ ø ø ø $ ø $ ä $ è ( ü ( ü ü < ø < è < è 8 è , è , ø , ø , ø 8 ø 8 ì < ì 8 ì 0 ì 0 ô 0 ð 4 ô 4 ô 8 ð 8 ü ü ü ì è øÿÿÿè è Ô Ô Ô øÿÿÿÔ øÿÿÿä øÿÿÿä øÿÿÿà ä ä üÿÿÿä üÿÿÿØ üÿÿÿØ üÿÿÿØ Ø Ü Ü Ü à à Ð Ì È üÿÿÿÈ È Ä Ä Ä üÿÿÿ 4 � 4 Œ , Œ < Œ < € < € < € , € , ˆ , ˆ , ˆ 8 ˆ 8 „ 8 „ 8 „ 0 ˜ 4 ˜ L ” L œ L œ L œ X œ X ” X ” X ” P ˜ P ˜ T ¼ ôÿÿÿ¼ 0 ¼ 8 ¼ P ¼ P ¼ X ° Ä , Ä 8 R ýÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ² % þÿÿÿëÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿ ÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿ ÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿ ÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿ ÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿ ÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿ ÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿ ÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ
|
||||
|
||||
ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿÿ ÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿ ÿÿ
|
||||
ÿÿÿÿÿ ÿ
|
||||
ÿ ÿ ÿÿ ÿÿ ÿ ÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ J $ ýÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ 2 ýÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿ ÿ ÿÿ ÿ ÿ ÿ ÿÿ ÿ ÿÿ ÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ 2 ýÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿ ÿ ÿÿ ÿ ÿ ÿ ÿÿ ÿ ÿÿ ÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ' ìÿÿÿéÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
ÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
ò þÿÿÿüÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿ ÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ¢ ␍ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ² ' $ ìÿÿÿäÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ² öÿÿÿèÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿ ÿ ÿÿÿÿ ÿÿ ÿ ÿÿÿÿ ÿÿÿ ÿÿ ÿÿÿ ÿÿÿÿ ÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
@@ -0,0 +1,990 @@
|
||||
//This uses $LK,"fixed-point","FI:::/SparrowOS/Demo/Lectures/FixedPoint.CPP.Z"$.
|
||||
|
||||
//This program can be static compiled to a .BIN.Z or JIT.
|
||||
//If static compiling, override the finename extention warning.
|
||||
#ifstatic
|
||||
#include "::/SparrowOS/OSMain/StaticAdam.HPP.Z"
|
||||
I64 best_score=0; //Doesn't work yet for statics
|
||||
#else
|
||||
AcctRegSetDftEntry("SparrowOS/EagleDive","I64 best_score=0;\n");
|
||||
AcctRegExecuteBranch("SparrowOS/EagleDive");
|
||||
#endif
|
||||
|
||||
|
||||
//Keep these power of two so shift is used instead of multiply
|
||||
//to index arrays.
|
||||
#define MAP_WIDTH 1024
|
||||
#define MAP_HEIGHT 1024
|
||||
|
||||
#define MAP_SCALE 150
|
||||
#define DISPLAY_SCALE 100
|
||||
#define CTRLS_SCALE 0.05
|
||||
|
||||
//I think I did these so the heads-up showed intelligable numbers.
|
||||
//Scaling is a mess.
|
||||
#define COORDINATE_SCALE 256
|
||||
#define COORDINATE_BITS 8
|
||||
|
||||
#define WATER_ELEVATION 15
|
||||
#define ROCK_ELEVATION 45
|
||||
#define SNOW_ELEVATION 55
|
||||
|
||||
//Too big makes off-screen draws take place.
|
||||
#define MAX_PANEL_SIZE 16
|
||||
|
||||
class Panel
|
||||
{
|
||||
Panel *next;
|
||||
I32 n, //num polygon sides
|
||||
num; //panel number
|
||||
CD3I32 *pts;
|
||||
I64 color,cnt;
|
||||
};
|
||||
|
||||
class Fish
|
||||
{
|
||||
Fish *next,*last;
|
||||
I64 x,y,z;
|
||||
} fish_root;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<1>",1$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
I64 critical_section_flag;
|
||||
U0 CriticalSectionStart()
|
||||
{
|
||||
while (LBts(&critical_section_flag,0))
|
||||
Yield;
|
||||
}
|
||||
U0 CriticalSectionEnd()
|
||||
{
|
||||
LBtr(&critical_section_flag,0);
|
||||
}
|
||||
|
||||
//These are $BK,1$NOT$BK,0$ deallocated after the program ends,
|
||||
//but I did them this way for your benefit
|
||||
//so 2D array indexing is not done by hand.
|
||||
//You can type "EagleDive;" at the command line
|
||||
//to rerun without new allocations.
|
||||
//Normally, just spawn a popup task,
|
||||
//run it and kill it using an icon.
|
||||
#ifstatic
|
||||
#exe {OptOn(OPTf_GLBLS_ON_DATA_HEAP);};
|
||||
#endif
|
||||
I16 elevations[MAP_HEIGHT][MAP_WIDTH];
|
||||
I32 normals[MAP_HEIGHT][MAP_WIDTH*2];
|
||||
Panel *panels[MAP_HEIGHT][MAP_WIDTH*2];
|
||||
#ifstatic
|
||||
#exe {OptOff(OPTf_GLBLS_ON_DATA_HEAP);};
|
||||
#endif
|
||||
|
||||
I64 num_panels;
|
||||
Panel *panel_root;
|
||||
U8 *panels_processed_bitmap;
|
||||
|
||||
F64 game_t0,v_grid_size,span_factor,è,é1,é2,speed;
|
||||
|
||||
I64 x,y,z,game_score;
|
||||
|
||||
Bool game_over;
|
||||
|
||||
class MPCtrl {
|
||||
I64 mp_cnt;
|
||||
I64 doc_update;
|
||||
F64 update_done_t[MP_MAX_PROCESSORS];
|
||||
I64 done_flags;
|
||||
Bool app_done;
|
||||
} mp;
|
||||
|
||||
U0 FSTransform(CDC *dc,I64 *x,I64 *y,I64 *z)
|
||||
{
|
||||
I64 zz;
|
||||
//I accidentally made the Z coordinate sign backward
|
||||
//from the fill-poly depth buf scheme, so it is negated at the end.
|
||||
//Negative Z coordinates are the ones we want plotted.
|
||||
GrRot(dc->r,x,y,z);
|
||||
|
||||
//We don't want divide by zero or make too monstrous foreground objects.
|
||||
//The foreground object boundary is kinda crappy looking when
|
||||
//you point toward the ground.
|
||||
*z=-*z;
|
||||
zz=*z+50;
|
||||
if (zz>0) {
|
||||
//The divide causes "foreshortening" which makes the distance go to a vanishing point.
|
||||
*x = *x * DISPLAY_SCALE/ zz;
|
||||
*y = *y * DISPLAY_SCALE/ zz;
|
||||
}
|
||||
*x+=dc->x;
|
||||
*y =dc->y-*y;
|
||||
}
|
||||
|
||||
|
||||
|
||||
U0 CalcNormals()
|
||||
{
|
||||
/*The idea is that there are two triangles
|
||||
forming every grid square and we find the normal
|
||||
vect with a curl.
|
||||
|
||||
i j k
|
||||
0 1 dz2
|
||||
1 0 dz1
|
||||
|
||||
Normal:
|
||||
dz1*i + dz2*j - k
|
||||
|
||||
i j k
|
||||
-1 0 -dz3
|
||||
0 -1 -dz4
|
||||
|
||||
Normal:
|
||||
-dz3*i - dz4*j + k
|
||||
|
||||
|
||||
Basically, we want to combine grid
|
||||
locations with the same normals. These
|
||||
are not unit vects for one thing.
|
||||
|
||||
What I came-up with is dz1/dz2 and dz3/dz4.
|
||||
|
||||
It works pretty well. It combines
|
||||
more than it should, but that's good
|
||||
because it would result in too many
|
||||
panels.
|
||||
|
||||
*/
|
||||
I64 i,j,k,dz1,dz2;
|
||||
for (j=0;j<MAP_HEIGHT-1;j++) {
|
||||
k=0;
|
||||
for (i=0;i<MAP_WIDTH-1;i++) {
|
||||
dz1=elevations[j][i+1]-elevations[j][i];
|
||||
dz2=elevations[j+1][i]-elevations[j][i];
|
||||
if (dz2)
|
||||
normals[j][k++]=dz1<<16/dz2;
|
||||
else {
|
||||
if (!dz1)
|
||||
normals[j][k++]=0;
|
||||
else if (dz1>0)
|
||||
normals[j][k++]=MAX_I32;
|
||||
else
|
||||
normals[j][k++]=MIN_I32;
|
||||
}
|
||||
|
||||
dz1=elevations[j+1][i+1]-elevations[j][i+1];
|
||||
dz2=elevations[j+1][i+1]-elevations[j+1][i];
|
||||
if (dz2)
|
||||
normals[j][k++]=dz1<<16/dz2;
|
||||
else {
|
||||
if (!dz1)
|
||||
normals[j][k++]=0;
|
||||
else if (dz1>0)
|
||||
normals[j][k++]=MAX_I32;
|
||||
else
|
||||
normals[j][k++]=MIN_I32;
|
||||
}
|
||||
}
|
||||
normals[j][k++]=0;
|
||||
normals[j][k++]=0;
|
||||
}
|
||||
k=0;
|
||||
for (i=0;i<MAP_WIDTH-1;i++) {
|
||||
normals[j][k++]=0;
|
||||
normals[j][k++]=0;
|
||||
}
|
||||
}
|
||||
|
||||
Bool TestSameSlope(I64 x,I64 y,I64 w,I64 h)
|
||||
{
|
||||
I64 k1,k2,xx,yy,s;
|
||||
if (!(0<=x && x+w<MAP_WIDTH && 0<=y && y+h<MAP_HEIGHT))
|
||||
return FALSE;
|
||||
//Works well averaging the two slopes of two triangles.
|
||||
//If it is too picky, we get too many panels.
|
||||
s=normals[y][x*2]+normals[y][x*2+1];
|
||||
for (k2=0;k2<h;k2++)
|
||||
for (k1=0;k1<w;k1++) {
|
||||
xx=(x+k1)*2;
|
||||
yy=y+k2;
|
||||
if (normals[yy][xx]+normals[yy][xx+1]!=s)
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
U0 MPDoPanels(CTask *task)
|
||||
{
|
||||
I64 i,j,k,l,k1,k2,w,h,threshold,lo,hi;
|
||||
Bool cont;
|
||||
Panel *tempp,*start_ptr=NULL,*end_ptr=NULL;
|
||||
CD3I32 *poly;
|
||||
Fish *tempf;
|
||||
lo=Gs->num*(MAP_HEIGHT-1)/mp.mp_cnt;
|
||||
hi=(Gs->num+1)*(MAP_HEIGHT-1)/mp.mp_cnt;
|
||||
for (threshold=8;threshold>=1;threshold--)
|
||||
for (j=lo;j<hi;j++) {
|
||||
k=0;
|
||||
for (i=0;i<MAP_WIDTH-1;i++) {
|
||||
if (!panels[j][k]) {
|
||||
w=1;
|
||||
h=1;
|
||||
do {
|
||||
cont=FALSE;
|
||||
if (w<MAX_PANEL_SIZE && TestSameSlope(i,j,w+1,h)) {
|
||||
w++;
|
||||
cont=TRUE;
|
||||
}
|
||||
if (h<MAX_PANEL_SIZE && TestSameSlope(i,j,w,h+1)) {
|
||||
h++;
|
||||
cont=TRUE;
|
||||
}
|
||||
} while (cont);
|
||||
if (w>=threshold || h>=threshold) {
|
||||
tempp=CAlloc(sizeof(Panel),task);
|
||||
lock {tempp->num=num_panels++;}
|
||||
l=elevations[j][i];
|
||||
if (l<=WATER_ELEVATION*MAP_SCALE &&
|
||||
elevations[j][i+w-1]<=WATER_ELEVATION*MAP_SCALE &&
|
||||
elevations[j+h-1][i]<=WATER_ELEVATION*MAP_SCALE &&
|
||||
elevations[j+h-1][i+w-1]<=WATER_ELEVATION*MAP_SCALE) {
|
||||
tempp->color=BLUE;
|
||||
if (Rand<0.05) {
|
||||
tempf=MAlloc(sizeof(Fish),task);
|
||||
tempf->x=(i+w/2)*MAP_SCALE;
|
||||
tempf->y=(j+h/2)*MAP_SCALE;
|
||||
tempf->z=l;
|
||||
CriticalSectionStart;
|
||||
QueIns(tempf,fish_root.last);
|
||||
CriticalSectionEnd;
|
||||
}
|
||||
} else {
|
||||
if (RandI16&1) {
|
||||
if (l<ROCK_ELEVATION*MAP_SCALE)
|
||||
tempp->color=LTGREEN;
|
||||
else if (l<SNOW_ELEVATION*MAP_SCALE) {
|
||||
if (!(RandU16&3))
|
||||
tempp->color=LTGRAY;
|
||||
else
|
||||
tempp->color=LTGREEN;
|
||||
} else {
|
||||
if (!(RandU16&3))
|
||||
tempp->color=WHITE;
|
||||
else
|
||||
tempp->color=LTGRAY;
|
||||
}
|
||||
} else {
|
||||
if (l<ROCK_ELEVATION*MAP_SCALE)
|
||||
tempp->color=GREEN+LTGREEN<<16+ROPF_DITHER;
|
||||
else if (l<SNOW_ELEVATION*MAP_SCALE) {
|
||||
if (!(RandU16&3))
|
||||
tempp->color=DKGRAY+LTGRAY<<16+ROPF_DITHER;
|
||||
else
|
||||
tempp->color=GREEN+LTGREEN<<16+ROPF_DITHER;
|
||||
} else {
|
||||
if (!(RandU16&3))
|
||||
tempp->color=LTGRAY+WHITE<<16+ROPF_DITHER;
|
||||
else
|
||||
tempp->color=DKGRAY+LTGRAY<<16+ROPF_DITHER;
|
||||
}
|
||||
}
|
||||
}
|
||||
tempp->n=4;
|
||||
poly=tempp->pts=MAlloc(sizeof(CD3I32)*tempp->n,task);
|
||||
poly[0].x=MAP_SCALE*i;
|
||||
poly[0].y=MAP_SCALE*j;
|
||||
poly[0].z=elevations[j][i];
|
||||
poly[1].x=MAP_SCALE*(i+w);
|
||||
poly[1].y=MAP_SCALE*j;
|
||||
poly[1].z=elevations[j][i+w];
|
||||
poly[2].x=MAP_SCALE*(i+w);
|
||||
poly[2].y=MAP_SCALE*(j+h);
|
||||
poly[2].z=elevations[j+h][i+w];
|
||||
poly[3].x=MAP_SCALE*i;
|
||||
poly[3].y=MAP_SCALE*(j+h);
|
||||
poly[3].z=elevations[j+h][i];
|
||||
tempp->next=start_ptr;
|
||||
start_ptr=tempp;
|
||||
if (!end_ptr)
|
||||
end_ptr=tempp;
|
||||
for (k2=0;k2<h;k2++)
|
||||
for (k1=0;k1<w;k1++) {
|
||||
panels[j+k2][(i+k1)*2]=tempp;
|
||||
panels[j+k2][(i+k1)*2+1]=tempp;
|
||||
}
|
||||
}
|
||||
}
|
||||
k+=2;
|
||||
}
|
||||
}
|
||||
if (end_ptr) {
|
||||
CriticalSectionStart;
|
||||
if (end_ptr)
|
||||
end_ptr->next=panel_root;
|
||||
panel_root=start_ptr;
|
||||
CriticalSectionEnd;
|
||||
}
|
||||
LBts(&mp.done_flags,Gs->num);
|
||||
}
|
||||
|
||||
|
||||
U0 InitMap()
|
||||
{
|
||||
//We make a topographic data structure "elevations[][]"
|
||||
//and convert it to panels. The conversion to panels leaves
|
||||
//gaps the way I did it, but it looks good, except for sky leaking through
|
||||
//There is no wrong way to pick colors if it looks good, unless
|
||||
//you wanted to do lighting.
|
||||
|
||||
//"panels[][]" holds the flat and sloped panels for each spot, while
|
||||
//"hstep_panels[][]" holds side panels in cases of step-like formations.
|
||||
//They require a separate array because a single "elevation[][]" spot can
|
||||
//have a panel on top and a panel on the side like stairs.
|
||||
|
||||
I64 i,j,l,k1,k2,x,y,xx,yy;
|
||||
MemSet(elevations,0,sizeof(elevations));
|
||||
MemSet(panels,0,sizeof(panels));
|
||||
for (i=0;i<MAP_WIDTH*MAP_HEIGHT/128;i++) {
|
||||
x=RandU32%MAP_WIDTH;
|
||||
y=RandU32%MAP_HEIGHT;
|
||||
j=1<<(RandU32%6);
|
||||
l=0;
|
||||
while (j--) {
|
||||
if (!l && RandU16<MAX_U16/4)
|
||||
l=RandU16%(j+1);
|
||||
if (l) {
|
||||
for (k1=-j;k1<=j;k1++)
|
||||
for (k2=-j;k2<=j;k2++) {
|
||||
xx=x+k2; yy=y+k1;
|
||||
if (0<=xx<MAP_WIDTH &&
|
||||
0<=yy<MAP_HEIGHT)
|
||||
elevations[yy][xx]+=MAP_SCALE/2;
|
||||
}
|
||||
l--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
xx=x/(MAP_SCALE*COORDINATE_SCALE);
|
||||
yy=y/(MAP_SCALE*COORDINATE_SCALE);
|
||||
z+=elevations[yy][xx]*COORDINATE_SCALE;
|
||||
|
||||
for (j=0;j<MAP_HEIGHT;j++)
|
||||
for (i=0;i<MAP_WIDTH;i++)
|
||||
if (elevations[j][i]<WATER_ELEVATION*MAP_SCALE)
|
||||
elevations[j][i]=WATER_ELEVATION*MAP_SCALE;
|
||||
|
||||
|
||||
CalcNormals;
|
||||
|
||||
panel_root=NULL;
|
||||
num_panels=0;
|
||||
|
||||
mp.done_flags=0;
|
||||
for (i=1;i<mp.mp_cnt;i++)
|
||||
MPSpawn(&MPDoPanels,Fs,"Do Panels",i);
|
||||
MPDoPanels(Fs);
|
||||
while (mp.done_flags!=1<<mp.mp_cnt-1)
|
||||
Yield;
|
||||
panels_processed_bitmap=MAlloc((num_panels+7)>>3);
|
||||
}
|
||||
|
||||
|
||||
CDC *main_dc;
|
||||
|
||||
U0 DrawIt(CTask *,CDC *dc)
|
||||
{
|
||||
main_dc->flags|=DCF_NO_TRANSPARENTS;
|
||||
GrBlot(dc,0,0,main_dc);
|
||||
}
|
||||
|
||||
|
||||
/*$SP,"",2$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Cores render strips. The strips are wider toward the horizon by span_factor
|
||||
and overlap +/- 15%. The cores check the panel map array
|
||||
and render the panel for each square and mark-it done.
|
||||
|
||||
The depth buf is not locked in the graphic routines
|
||||
so we get some glitches.
|
||||
|
||||
*/
|
||||
|
||||
U0 MPDrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
//This is identical to the previous routine but is run by core#1
|
||||
I64 i,j,ww,hh,*s2w,x1,y1,z1, xx,yy,
|
||||
xh,yh,zh, yh2,xh2, reg x1w, reg y1w, x1h,y1h,
|
||||
x3,y3,z3,
|
||||
cx=task->win_pixel_width>>1,
|
||||
cy=task->win_pixel_height>>1;
|
||||
F64 h_grid_size,t0=tNP;
|
||||
Panel reg *tempp;
|
||||
|
||||
xx=x/(MAP_SCALE*COORDINATE_SCALE);
|
||||
yy=y/(MAP_SCALE*COORDINATE_SCALE);
|
||||
|
||||
//World to screen coordinates
|
||||
GrIdentEqu(dc->r);
|
||||
GrRotZEqu(dc->r,é2);
|
||||
GrRotXEqu(dc->r,è);
|
||||
GrRotZEqu(dc->r,é1);
|
||||
GrSetRotMat(dc,dc->r);
|
||||
|
||||
//Screen to world coordinates
|
||||
|
||||
//This gives us the vects for stepping through the grid in
|
||||
//the direction the plane is facing. we step horizontally and vertically
|
||||
//and use the reciprocal slope principle y=mx+b and y=(-1/m)x+b are perpendicular.
|
||||
|
||||
s2w=GrIdent;
|
||||
GrRotZEqu(s2w,-é1);
|
||||
GrRotXEqu(s2w,-è);
|
||||
GrRotZEqu(s2w,-é2);
|
||||
xh=0;
|
||||
yh=0;
|
||||
zh=-256;
|
||||
GrRot(s2w,&xh,&yh,&zh);
|
||||
|
||||
//The layer for core#1 is not cleared automatically
|
||||
//it is persistent. I have carefully syncronized to the update
|
||||
//cycle initiated by core#0 to prevent flicker.
|
||||
|
||||
dc->flags|=DCF_TRANSFORMATION;
|
||||
dc->transform=&FSTransform;
|
||||
dc->x=cx;
|
||||
dc->y=cy;
|
||||
|
||||
//dc->x and the translation part of dc->r are identical in effect,
|
||||
//but we use both to show-off. We could add offsets together and use one or the other.
|
||||
|
||||
x1=-x>>COORDINATE_BITS;
|
||||
y1=-y>>COORDINATE_BITS;
|
||||
z1=-z>>COORDINATE_BITS;
|
||||
GrRot(dc->r,&x1,&y1,&z1);
|
||||
GrSetTranslation(dc->r,x1,y1,z1);
|
||||
|
||||
//This is a refinement.
|
||||
if (Abs(è*180/ã)>90) {
|
||||
x3=0;
|
||||
y3=-cy;
|
||||
z3=0;
|
||||
GrRot(s2w,&x3,&y3,&z3);
|
||||
xx+=x3;
|
||||
yy+=y3;
|
||||
}
|
||||
|
||||
h_grid_size=4.0*v_grid_size*(Gs->num+span_factor)/span_factor;
|
||||
if (Gs->num&1) { //alternate left-right,right-left
|
||||
yh2=-yh;
|
||||
xh2=-xh;
|
||||
} else {
|
||||
yh2=yh;
|
||||
xh2=xh;
|
||||
}
|
||||
|
||||
ww=h_grid_size;
|
||||
hh=1.30*v_grid_size; //Cores overlap 15% on each side of strip.
|
||||
//Calc starting point.
|
||||
x1h=xx<<8+0.5*yh2*h_grid_size+xh*v_grid_size*(Gs->num+1.15);
|
||||
y1h=yy<<8-0.5*xh2*h_grid_size+yh*v_grid_size*(Gs->num+1.15);
|
||||
|
||||
xh=-xh; //Back to front to help with depth.
|
||||
yh=-yh;
|
||||
|
||||
//Take half steps to cover whole grid.
|
||||
xh>>=1; yh>>=1;
|
||||
xh2>>=1; yh2>>=1;
|
||||
ww<<=1;
|
||||
hh<<=1;
|
||||
|
||||
for (j=0;j<hh;j++) {
|
||||
x1w=x1h;
|
||||
y1w=y1h;
|
||||
for (i=0;i<ww;i++) {
|
||||
x1=x1w>>8; y1=y1w>>8;
|
||||
if (0<=x1<MAP_WIDTH && 0<=y1<MAP_HEIGHT) {
|
||||
if ((tempp=panels[y1][x1*2]) && !LBts(panels_processed_bitmap,tempp->num)) {
|
||||
if (tempp->cnt>8*(1.1-Gs->idle_factor)) {
|
||||
dc->color=tempp->color;
|
||||
tempp->cnt=GrFillPoly3(dc,tempp->n,tempp->pts);
|
||||
} else
|
||||
tempp->cnt++;
|
||||
}
|
||||
}
|
||||
x1w-=yh2;
|
||||
y1w+=xh2;
|
||||
}
|
||||
x1h+=xh;
|
||||
y1h+=yh;
|
||||
}
|
||||
Free(s2w);
|
||||
mp.update_done_t[Gs->num]=tNP-t0;
|
||||
}
|
||||
|
||||
U0 APEagleDiveTask(CTask *master_task)
|
||||
{
|
||||
CDC *dc=DCAlias(main_dc,master_task);
|
||||
if (!IsSysDeterministic)
|
||||
Preempt(ON);
|
||||
while (!mp.app_done) {
|
||||
LBts(&Fs->task_flags,TASKf_IDLE);
|
||||
while (!LBtr(&mp.doc_update,Gs->num) && !mp.app_done)
|
||||
Yield;
|
||||
LBtr(&Fs->task_flags,TASKf_IDLE);
|
||||
if (!mp.app_done)
|
||||
MPDrawIt(master_task,dc);
|
||||
}
|
||||
|
||||
//We made an alias of this we don't want freed.
|
||||
dc->depth_buf=NULL;
|
||||
|
||||
DCDel(dc);
|
||||
LBts(&mp.done_flags,Gs->num);
|
||||
}
|
||||
|
||||
U0 DrawHorizon(CDC *dc)
|
||||
{
|
||||
I64 x1,y1,z1,x2,y2,z2,xh,yh,zh,*s2w=GrIdent,
|
||||
cx=Fs->win_pixel_width>>1,
|
||||
cy=Fs->win_pixel_height>>1;
|
||||
CD3I32 p[4];
|
||||
I32 *old_db=dc->depth_buf;
|
||||
dc->depth_buf=NULL;
|
||||
|
||||
GrIdentEqu(dc->r);
|
||||
GrRotZEqu(dc->r,é2);
|
||||
GrRotXEqu(dc->r,è);
|
||||
GrRotZEqu(dc->r,é1);
|
||||
GrSetRotMat(dc,dc->r);
|
||||
dc->flags&=~DCF_TRANSFORMATION;
|
||||
dc->transform=&FSTransform;
|
||||
dc->x=cx;
|
||||
dc->y=cy;
|
||||
|
||||
GrRotZEqu(s2w,-é1);
|
||||
GrRotXEqu(s2w,-è);
|
||||
GrRotZEqu(s2w,-é2);
|
||||
xh=0;
|
||||
yh=0;
|
||||
zh=-256;
|
||||
GrRot(s2w,&xh,&yh,&zh);
|
||||
Free(s2w);
|
||||
|
||||
x1=xh+yh*32; y1=yh-xh*32; z1=0;
|
||||
(*dc->transform)(dc,&x1,&y1,&z1);
|
||||
x2=xh-yh*32; y2=yh+xh*32; z2=0;
|
||||
(*dc->transform)(dc,&x2,&y2,&z2);
|
||||
DCClipLine(dc,&x1,&y1,&x2,&y2);
|
||||
|
||||
MemSet(p,0,sizeof(p));
|
||||
if (x2<x1) {
|
||||
SwapU64(&x1,&x2);
|
||||
SwapU64(&y1,&y2);
|
||||
}
|
||||
if (!x1 && x2==dc->width-1) {
|
||||
p[0].x=0;
|
||||
p[0].y=0;
|
||||
p[1].x=dc->width-1;
|
||||
p[1].y=0;
|
||||
p[2].x=dc->width-1;
|
||||
p[2].y=y2;
|
||||
p[3].x=0;
|
||||
p[3].y=y1;
|
||||
if (-ã/2<=é1<ã/2 ^^ -ã/2<=Wrap(è-ã/2)<ã/2)
|
||||
dc->color=LTCYAN;
|
||||
else
|
||||
dc->color=LTGREEN;
|
||||
GrFillPoly3(dc,4,p);
|
||||
p[0].y=dc->height-1;
|
||||
p[1].y=dc->height-1;
|
||||
if (-ã/2<=é1<ã/2 ^^ -ã/2<=Wrap(è-ã/2)<ã/2)
|
||||
dc->color=LTGREEN;
|
||||
else
|
||||
dc->color=LTCYAN;
|
||||
GrFillPoly3(dc,4,p);
|
||||
} else {
|
||||
if (y2<y1) {
|
||||
SwapU64(&x1,&x2);
|
||||
SwapU64(&y1,&y2);
|
||||
}
|
||||
if (!y1 && y2==dc->height-1) {
|
||||
p[0].x=0;
|
||||
p[0].y=0;
|
||||
p[1].x=0;
|
||||
p[1].y=dc->height-1;
|
||||
p[2].x=x2;
|
||||
p[2].y=dc->height-1;
|
||||
p[3].x=x1;
|
||||
p[3].y=0;
|
||||
if (x1<x2 ^^ -ã/2<=é1<ã/2 ^^ -ã/2<=Wrap(è-ã/2)<ã/2)
|
||||
dc->color=LTCYAN;
|
||||
else
|
||||
dc->color=LTGREEN;
|
||||
GrFillPoly3(dc,4,p);
|
||||
p[0].x=dc->width-1;
|
||||
p[1].x=dc->width-1;
|
||||
if (x1<x2 ^^ -ã/2<=é1<ã/2 ^^ -ã/2<=Wrap(è-ã/2)<ã/2)
|
||||
dc->color=LTGREEN;
|
||||
else
|
||||
dc->color=LTCYAN;
|
||||
GrFillPoly3(dc,4,p);
|
||||
}
|
||||
}
|
||||
dc->depth_buf=old_db;
|
||||
}
|
||||
|
||||
|
||||
U0 BSPEagleDive()
|
||||
{
|
||||
CDC *dc=DCAlias(main_dc,Fs);
|
||||
F64 last_t;
|
||||
I64 i,xx,yy,height,bkcolor,
|
||||
cx=Fs->win_pixel_width>>1,
|
||||
cy=Fs->win_pixel_height>>1;
|
||||
Fish *tempf;
|
||||
|
||||
MemSet(panels_processed_bitmap,0,(num_panels+7)>>3);
|
||||
MemSet(mp.update_done_t,0,sizeof(F64)*MP_MAX_PROCESSORS);
|
||||
|
||||
xx=x/(MAP_SCALE*COORDINATE_SCALE);
|
||||
yy=y/(MAP_SCALE*COORDINATE_SCALE);
|
||||
height=z/COORDINATE_SCALE-elevations[yy][xx];
|
||||
if (height<0) {
|
||||
if (elevations[yy][xx]>WATER_ELEVATION*MAP_SCALE) {
|
||||
dc->color=bkcolor=BLACK;
|
||||
if (!game_over) {
|
||||
GrRect(dc,0,0,dc->width,dc->height);
|
||||
music_mute=TRUE;
|
||||
Beep;
|
||||
game_over=TRUE;
|
||||
music_mute=FALSE;
|
||||
}
|
||||
} else
|
||||
bkcolor=BLUE;
|
||||
} else
|
||||
bkcolor=LTCYAN;
|
||||
|
||||
if (height>=0 && !(-ã/4<=Wrap(è-ã)<ã/4)) {
|
||||
DrawHorizon(dc);
|
||||
DCDepthBufRst(dc);
|
||||
|
||||
//Signal all cores to start update
|
||||
mp.doc_update=1<<mp.mp_cnt-1-1;
|
||||
|
||||
//Wait for all cores to start
|
||||
while (mp.doc_update)
|
||||
Yield;
|
||||
|
||||
MPDrawIt(Fs,dc);
|
||||
|
||||
xx=x/COORDINATE_SCALE;
|
||||
yy=y/COORDINATE_SCALE;
|
||||
tempf=fish_root.next;
|
||||
while (tempf!=&fish_root) {
|
||||
if (SqrI64(tempf->x-xx)+SqrI64(tempf->y-yy)<MAP_SCALE*MAP_SCALE*20*20)
|
||||
CSpritePlot3(dc,tempf->x,tempf->y,tempf->z,$IB,"<1>",1$);
|
||||
tempf=tempf->next;
|
||||
}
|
||||
|
||||
//Wait for all cores to complete.
|
||||
LBts(&Fs->task_flags,TASKf_IDLE);
|
||||
for (i=1;i<mp.mp_cnt;i++)
|
||||
while (!mp.update_done_t[i])
|
||||
Yield;
|
||||
LBtr(&Fs->task_flags,TASKf_IDLE);
|
||||
|
||||
last_t=mp.update_done_t[0];
|
||||
for (i=1;i<mp.mp_cnt;i++)
|
||||
last_t=Max(last_t,mp.update_done_t[i]);
|
||||
|
||||
//Adjust size of updated grid.
|
||||
v_grid_size *=0.90+0.10*(0.65/Fs->win_max_refresh)/last_t;
|
||||
v_grid_size=Limit(v_grid_size,20,200);
|
||||
//Regulate how much grid expands in the distance.
|
||||
if (mp.mp_cnt>1)
|
||||
span_factor*=0.90+0.10*mp.update_done_t[mp.mp_cnt-1]/mp.update_done_t[0];
|
||||
span_factor=Limit(span_factor,.30,3.0);
|
||||
|
||||
} else {
|
||||
dc->color=bkcolor;
|
||||
GrRect(dc,0,0,dc->width,dc->height);
|
||||
}
|
||||
dc->pen_width=2;
|
||||
if (bkcolor==BLUE)
|
||||
dc->color=WHITE;
|
||||
else
|
||||
dc->color=BLACK;
|
||||
dc->flags&=~DCF_TRANSFORMATION;
|
||||
GrLine3(dc,cx+5,cy,0,cx-5,cy,0);
|
||||
GrLine3(dc,cx,cy+5,0,cx,cy-5,0);
|
||||
GrPrintF(dc,0,0,"é1:%5.1f è:%5.1f é2:%5.1f Box:%5.1f",
|
||||
é1*180/ã,è*180/ã,é2*180/ã,v_grid_size);
|
||||
GrPrintF(dc,0,FONT_HEIGHT,"x:%5.1f y:%5.1f z:%5.1f height:%3d score:%d high:%d",
|
||||
ToF64(x)/COORDINATE_SCALE,ToF64(y)/COORDINATE_SCALE,ToF64(z)/COORDINATE_SCALE,
|
||||
height,game_score,best_score);
|
||||
|
||||
if (game_over && Blink(,tP)) {
|
||||
dc->color=RED;
|
||||
GrPutS(dc,(Fs->win_pixel_width-9*FONT_WIDTH)/2,
|
||||
(Fs->win_pixel_height-FONT_HEIGHT)/2,"Game Over");
|
||||
} else if (tP-game_t0<5.0 && Blink(,tP)) {
|
||||
dc->color=WHITE;
|
||||
GrPutS(dc,(Fs->win_pixel_width-10*FONT_WIDTH)/2,
|
||||
(Fs->win_pixel_height-FONT_HEIGHT)/2,"Catch Fish");
|
||||
}
|
||||
//We made an alias of this we don't want freed.
|
||||
dc->depth_buf=NULL;
|
||||
DCDel(dc);
|
||||
WinMgrSync;
|
||||
}
|
||||
|
||||
#define ANIMATE_MS 10
|
||||
|
||||
U0 AnimateTask(I64)
|
||||
{
|
||||
//This just steadily moves the airplane fwd.
|
||||
I64 *s2w,x1,y1,z1;
|
||||
F64 t0=tP(Fs->parent_task),mS;
|
||||
Fish *tempf,*tempf1;
|
||||
while (TRUE) {
|
||||
mS=1000*(tP(Fs->parent_task)-t0);
|
||||
t0=tP(Fs->parent_task);
|
||||
if (!game_over) {
|
||||
//Screen to world coordinates
|
||||
s2w=GrIdent;
|
||||
GrRotZEqu(s2w,-é1);
|
||||
GrRotXEqu(s2w,-è);
|
||||
GrRotZEqu(s2w,-é2);
|
||||
x1=0;y1=0;z1=-speed*mS*COORDINATE_SCALE;
|
||||
GrRot(s2w,&x1,&y1,&z1);
|
||||
x+=x1;
|
||||
y+=y1;
|
||||
z+=z1;
|
||||
Free(s2w);
|
||||
x1=x/COORDINATE_SCALE; y1=y/COORDINATE_SCALE; z1=z/COORDINATE_SCALE;
|
||||
if (z1<WATER_ELEVATION*MAP_SCALE) {
|
||||
speed=0.5;
|
||||
tempf=fish_root.next;
|
||||
while (tempf!=&fish_root) {
|
||||
tempf1=tempf->next;
|
||||
if (SqrI64(tempf->x-x1)+SqrI64(tempf->y-y1)<MAP_SCALE*MAP_SCALE*5*5) {
|
||||
game_score++;
|
||||
if (game_score>best_score)
|
||||
best_score=game_score;
|
||||
QueRem(tempf);
|
||||
Free(tempf);
|
||||
music_mute=TRUE;
|
||||
Snd(1000); Sleep(200); Snd(0);
|
||||
music_mute=FALSE;
|
||||
}
|
||||
tempf=tempf1;
|
||||
}
|
||||
} else {
|
||||
if (-ã/4<=è<=ã/4)
|
||||
speed+=0.0005;
|
||||
else if (-3*ã/4<=è<=3*ã/4)
|
||||
speed+=0.0001;
|
||||
else
|
||||
speed-=0.0001;
|
||||
speed=Limit(speed+(0.0005-0.0002*Abs(è)/(ã/4)),0.1,5.0);
|
||||
}
|
||||
}
|
||||
WinMgrSync;
|
||||
}
|
||||
}
|
||||
|
||||
U0 MPEnd()
|
||||
{
|
||||
mp.done_flags=0;
|
||||
mp.app_done=TRUE;
|
||||
//Wait for all cores to exit
|
||||
while (mp.done_flags!=1<<mp.mp_cnt-1-1)
|
||||
Yield;
|
||||
}
|
||||
|
||||
U0 TaskEndCB()
|
||||
{
|
||||
MPEnd;
|
||||
Exit;
|
||||
}
|
||||
|
||||
U0 SongTask(I64)
|
||||
{ //Song by Terry A. Davis
|
||||
#ifstatic
|
||||
Fs->task_end_cb=ExtFind("SndTaskEndCB");//(Can't take addr of an extern function.)
|
||||
#else
|
||||
Fs->task_end_cb=&SndTaskEndCB;
|
||||
#endif
|
||||
MusicSettingsRst;
|
||||
music_stacatto_factor=0.2;
|
||||
while (TRUE) {
|
||||
Play("W13eBDEDBDEDFEEDFEED");
|
||||
Play("BDEDBDEDFEEDFEED");
|
||||
}
|
||||
}
|
||||
|
||||
U0 Init(I64 _mp_cnt)
|
||||
{
|
||||
I64 i;
|
||||
main_dc=DCNew(DCT_COLOR8,GR_WIDTH,GR_HEIGHT);
|
||||
critical_section_flag=0;
|
||||
game_over=FALSE;
|
||||
game_score=0;
|
||||
MemSet(&mp,0,sizeof(MPCtrl));
|
||||
if (_mp_cnt<=mp_cnt)
|
||||
mp.mp_cnt=_mp_cnt;
|
||||
else
|
||||
mp.mp_cnt=mp_cnt;
|
||||
QueInit(&fish_root);
|
||||
InitMap;
|
||||
DCAllocDepthBuf(main_dc);
|
||||
|
||||
Fs->win_max_refresh=30.0;
|
||||
|
||||
v_grid_size=64.0;
|
||||
span_factor=1.0;
|
||||
è =-90.0*ã/180.0;
|
||||
é1= 0.0*ã/180.0;
|
||||
é2= 0.0*ã/180.0;
|
||||
speed = 2.5;
|
||||
|
||||
x=MAP_WIDTH>>1 *COORDINATE_SCALE*MAP_SCALE;
|
||||
y=MAP_HEIGHT>>1*COORDINATE_SCALE*MAP_SCALE;
|
||||
z=64 *COORDINATE_SCALE*MAP_SCALE;
|
||||
|
||||
for (i=1;i<mp.mp_cnt;i++)
|
||||
MPSpawn(&APEagleDiveTask,Fs,"AP EagleDive",i);
|
||||
Fs->task_end_cb=&TaskEndCB;
|
||||
game_t0=tP;
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
Fish *tempf=fish_root.next,*tempf1;
|
||||
Panel *tempp=panel_root,*tempp1;
|
||||
|
||||
MPEnd;
|
||||
|
||||
while (tempf!=&fish_root) {
|
||||
tempf1=tempf->next;
|
||||
QueRem(tempf);
|
||||
Free(tempf);
|
||||
tempf=tempf1;
|
||||
}
|
||||
while (tempp) {
|
||||
tempp1=tempp->next;
|
||||
Free(tempp->pts);
|
||||
Free(tempp);
|
||||
tempp=tempp1;
|
||||
}
|
||||
Free(panels_processed_bitmap);
|
||||
DCDel(main_dc);
|
||||
}
|
||||
|
||||
U0 EagleDive(I64 _mp_cnt=MP_MAX_PROCESSORS)
|
||||
{
|
||||
I64 ch,sc;
|
||||
F64 pp,tt1,tt2;
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
//We really can't afford to run at 60Hz. This is how often VGA
|
||||
//memory is updated, not related to actual hardware refresh rates.
|
||||
|
||||
WordStat;
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" Down(,,SC_CURSOR_UP);"
|
||||
" Up(,,SC_CURSOR_DOWN);"
|
||||
" Left(,,SC_CURSOR_LEFT);"
|
||||
" Right(,,SC_CURSOR_RIGHT);"
|
||||
"}"
|
||||
);
|
||||
WinMax;
|
||||
WinBorder;
|
||||
"Initializing...\n";
|
||||
Fs->song_task=Spawn(&SongTask,NULL,"Song",Fs);
|
||||
Init(_mp_cnt);
|
||||
Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",Fs);
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
try //in case <CTRL-ALT-C> is pressed.
|
||||
do {
|
||||
if (ScanKey(&ch,&sc)) {
|
||||
pp=è; tt1=é1; tt2=é2;
|
||||
switch (ch) {
|
||||
case 0:
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_DOWN:
|
||||
è +=-CTRLS_SCALE*Cos(tt1);
|
||||
é2+=-CTRLS_SCALE*Sin(tt1)*Sin(è);
|
||||
break;
|
||||
case SC_CURSOR_UP:
|
||||
è -=-CTRLS_SCALE*Cos(tt1);
|
||||
é2-=-CTRLS_SCALE*Sin(tt1)*Sin(è);
|
||||
break;
|
||||
case SC_CURSOR_RIGHT:
|
||||
é1+=CTRLS_SCALE;
|
||||
break;
|
||||
case SC_CURSOR_LEFT:
|
||||
é1-=CTRLS_SCALE;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case CH_NEW_LINE:
|
||||
Fs->draw_it=NULL;
|
||||
CleanUp;
|
||||
WinMgrSync;
|
||||
Init(_mp_cnt);
|
||||
Fs->draw_it=&DrawIt;
|
||||
break;
|
||||
}
|
||||
é1=Wrap(é1);
|
||||
è =Wrap(è);
|
||||
é2=Wrap(é2);
|
||||
} else
|
||||
BSPEagleDive;
|
||||
} while (ch!=CH_SHIFT_ESC && ch!=CH_ESC);
|
||||
catch
|
||||
CatchAll;
|
||||
SettingsPop;
|
||||
CleanUp;
|
||||
#ifnstatic
|
||||
AcctRegWriteBranch("SparrowOS/EagleDive","I64 best_score=%d;\n",best_score);
|
||||
#endif
|
||||
MenuPop;
|
||||
}
|
||||
|
||||
EagleDive;
|
||||
. ¨ ¢ ¢ ¨ ¢ ¨ ¢ ¨ ˜ ˜ ¢ ˆ ¢ ˆ x x ¢ h ¢ h X X ¢ H ¢ H 8 8 ¢ ( ¢ ( ¢ ¨ ¨ " " 2 ¨ 2 ¨ B B R ¨ R ¨ b b r ¨ r ¨ ‚ ‚ ’ ¨ ’ !r 8 P " !t 2 R !v , T !N * p @ !L . l D !L 4 h H !T x & !X z !\ | !Z D t L âÿÿÿ % ãÿÿÿ #
|
||||
@@ -0,0 +1,659 @@
|
||||
//This uses $LK,"fixed-point","FI:::/SparrowOS/Demo/Lectures/FixedPoint.CPP.Z"$.
|
||||
|
||||
|
||||
AcctRegSetDftEntry("SparrowOS/FPS","F64 best_score=9999;\n");
|
||||
AcctRegExecuteBranch("SparrowOS/FPS");
|
||||
|
||||
//Set snap to 4 and width to 4
|
||||
//if you edit this map.
|
||||
|
||||
//Don't forget to change the
|
||||
//starting pos.
|
||||
#define MAN_START_X 0
|
||||
#define MAN_START_Y 4.5
|
||||
|
||||
$SP,"<1>",1$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define MONSTER_SCALE 2.0
|
||||
|
||||
|
||||
$SP,"<2>",2$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<3>",3$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<4>",4$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define PLANT_SCALE 2.0
|
||||
|
||||
|
||||
|
||||
$SP,"<5>",5$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define SCREEN_SCALE 512
|
||||
#define PLOT_GRID_WIDTH 24
|
||||
#define PLOT_GRID_HEIGHT 24
|
||||
#define MAN_HEIGHT 125
|
||||
|
||||
#define MAP_SCALE 4
|
||||
I64 map_width,map_height;
|
||||
U8 *map=NULL,
|
||||
*panels_processed_bitmap=NULL;
|
||||
|
||||
I64 man_xx,man_yy;
|
||||
F64 man_é;
|
||||
|
||||
F64 t0,tf;
|
||||
|
||||
#define NUM_MONSTERS 16
|
||||
I64 monsters_left;
|
||||
class Monster
|
||||
{
|
||||
I64 x,y;
|
||||
Bool dead,pad[7];
|
||||
} monsters[NUM_MONSTERS];
|
||||
|
||||
U0 FPSTransform(CDC *dc,I64 *x,I64 *y,I64 *z)
|
||||
{
|
||||
I64 zz;
|
||||
GrRot(dc->r,x,y,z);
|
||||
zz=SCREEN_SCALE/3+*z;
|
||||
if (zz<1) zz=1;
|
||||
*x=SCREEN_SCALE/2* *x/zz;
|
||||
*y=SCREEN_SCALE/2* (*y+MAN_HEIGHT)/zz;
|
||||
*x+=dc->x;
|
||||
*y+=dc->y;
|
||||
*z+=dc->z;
|
||||
}
|
||||
|
||||
#define LOS_SCALE 4
|
||||
|
||||
Bool LOSPlot(U8 *,I64 x,I64 y,I64)
|
||||
{
|
||||
if (!map[(y/LOS_SCALE)*map_width+(x/LOS_SCALE)])
|
||||
return FALSE;
|
||||
else
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
Bool LOS(I64 x1,I64 y1,I64 x2,I64 y2)
|
||||
{ //Line of sight
|
||||
return Line(NULL,x1*LOS_SCALE/SCREEN_SCALE,y1*LOS_SCALE/SCREEN_SCALE,0,
|
||||
x2*LOS_SCALE/SCREEN_SCALE,y2*LOS_SCALE/SCREEN_SCALE,0,&LOSPlot);
|
||||
}
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
I64 i,j,*r1,*r2,*r3,*s2w,xx,yy,zz,x,y,x1,y1,z1,
|
||||
x1w,y1w,x1h,y1h,xh,yh,zh,
|
||||
cx=task->win_pixel_width/2,
|
||||
cy=task->win_pixel_height/2,
|
||||
_man_xx=man_xx,_man_yy=man_yy;
|
||||
U8 *inter;
|
||||
F64 tt,_man_é=man_é;
|
||||
CD3I32 poly[4];
|
||||
|
||||
task->text_attr=BLACK<<4;
|
||||
DCAllocDepthBuf(dc);
|
||||
MemSet(panels_processed_bitmap,0,(map_width*map_height+7)>>3);
|
||||
|
||||
//World to screen
|
||||
GrRotZEqu(dc->r,_man_é+ã/2);
|
||||
GrRotXEqu(dc->r,ã/2);
|
||||
GrSetRotMat(dc,dc->r);
|
||||
|
||||
xh=-_man_xx/SCREEN_SCALE; yh=-_man_yy/SCREEN_SCALE; zh=0;
|
||||
GrRot(dc->r,&xh,&yh,&zh);
|
||||
GrSetTranslation(dc->r,xh,yh,zh);
|
||||
|
||||
//Screen to world
|
||||
s2w=GrRotX(-ã/2,task);
|
||||
GrRotZEqu(s2w,-_man_é-ã/2);
|
||||
xh=0; yh=0; zh=SCREEN_SCALE;
|
||||
GrRot(s2w,&xh,&yh,&zh);
|
||||
|
||||
//Rotate light source
|
||||
xx=dc->ls.x; yy=dc->ls.y; zz=-dc->ls.z;
|
||||
(*dc->transform)(dc,&xx,&yy,&zz);
|
||||
dc->ls.x=xx; dc->ls.y=yy; dc->ls.z=zz;
|
||||
|
||||
dc->flags|=DCF_TRANSFORMATION;
|
||||
dc->transform=&FPSTransform;
|
||||
dc->x=cx;
|
||||
dc->y=cy;
|
||||
r1=GrRotX(-ã/2,task);
|
||||
GrRotZEqu(r1,tP(task));
|
||||
GrScaleMatEqu(r1,MONSTER_SCALE);
|
||||
|
||||
r2=GrIdent(task);
|
||||
GrScaleMatEqu(r2,MONSTER_SCALE);
|
||||
|
||||
r3=GrRotX(-ã/2,task);
|
||||
GrScaleMatEqu(r3,PLANT_SCALE);
|
||||
|
||||
x1h=_man_xx+yh*PLOT_GRID_WIDTH/2+xh*(PLOT_GRID_HEIGHT-1);
|
||||
y1h=_man_yy-xh*PLOT_GRID_WIDTH/2+yh*(PLOT_GRID_HEIGHT-1);
|
||||
xh>>=1; yh>>=1;
|
||||
for (j=0;j<PLOT_GRID_HEIGHT*2;j++) {
|
||||
x1w=x1h;
|
||||
y1w=y1h;
|
||||
for (i=0;i<PLOT_GRID_WIDTH*4;i++) {
|
||||
xx=x1w/SCREEN_SCALE; yy=y1w/SCREEN_SCALE;
|
||||
x=xx*SCREEN_SCALE-_man_xx; y=yy*SCREEN_SCALE-_man_yy;
|
||||
if (1<=xx<map_width-1 && 1<=yy<map_height-1 &&
|
||||
!LBts(panels_processed_bitmap,yy*map_width+xx)) {
|
||||
if ((dc->color=map[yy*map_width+xx]) &&
|
||||
LOS(xx*SCREEN_SCALE+SCREEN_SCALE/2,yy*SCREEN_SCALE+SCREEN_SCALE/2,
|
||||
_man_xx,_man_yy)) {
|
||||
poly[0].x=x;
|
||||
poly[0].y=y;
|
||||
poly[0].z=0;
|
||||
poly[1].x=x+SCREEN_SCALE;
|
||||
poly[1].y=y;
|
||||
poly[1].z=0;
|
||||
poly[2].x=x+SCREEN_SCALE;
|
||||
poly[2].y=y+SCREEN_SCALE;
|
||||
poly[2].z=0;
|
||||
poly[3].x=x;
|
||||
poly[3].y=y+SCREEN_SCALE;
|
||||
poly[3].z=0;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
if (dc->color==GREEN) {
|
||||
x1=x+SCREEN_SCALE/2;
|
||||
y1=y+SCREEN_SCALE/2;
|
||||
z1=0;
|
||||
GrTransform(dc,&x1,&y1,&z1);
|
||||
if (z1>0)
|
||||
CSpritePlotRotMat3b(dc,x+SCREEN_SCALE/2,y+SCREEN_SCALE/2,0,$IB,"<5>",5$,r3);
|
||||
}
|
||||
|
||||
if (!map[(yy+1)*map_width+xx]) {
|
||||
dc->color=LTGRAY;
|
||||
poly[0].x=x;
|
||||
poly[0].y=y+SCREEN_SCALE;
|
||||
poly[0].z=0;
|
||||
poly[1].x=x+SCREEN_SCALE;
|
||||
poly[1].y=y+SCREEN_SCALE;
|
||||
poly[1].z=0;
|
||||
poly[2].x=x+SCREEN_SCALE;
|
||||
poly[2].y=y+SCREEN_SCALE;
|
||||
poly[2].z=SCREEN_SCALE;
|
||||
poly[3].x=x;
|
||||
poly[3].y=y+SCREEN_SCALE;
|
||||
poly[3].z=SCREEN_SCALE;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
}
|
||||
if (!map[yy*map_width+xx+1]) {
|
||||
dc->color=DKGRAY;
|
||||
poly[0].x=x+SCREEN_SCALE;
|
||||
poly[0].y=y;
|
||||
poly[0].z=0;
|
||||
poly[1].x=x+SCREEN_SCALE;
|
||||
poly[1].y=y+SCREEN_SCALE;
|
||||
poly[1].z=0;
|
||||
poly[2].x=x+SCREEN_SCALE;
|
||||
poly[2].y=y+SCREEN_SCALE;
|
||||
poly[2].z=SCREEN_SCALE;
|
||||
poly[3].x=x+SCREEN_SCALE;
|
||||
poly[3].y=y;
|
||||
poly[3].z=SCREEN_SCALE;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
}
|
||||
if (!map[(yy-1)*map_width+xx]) {
|
||||
dc->color=LTGRAY;
|
||||
poly[0].x=x;
|
||||
poly[0].y=y;
|
||||
poly[0].z=0;
|
||||
poly[1].x=x+SCREEN_SCALE;
|
||||
poly[1].y=y;
|
||||
poly[1].z=0;
|
||||
poly[2].x=x+SCREEN_SCALE;
|
||||
poly[2].y=y;
|
||||
poly[2].z=SCREEN_SCALE;
|
||||
poly[3].x=x;
|
||||
poly[3].y=y;
|
||||
poly[3].z=SCREEN_SCALE;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
}
|
||||
if (!map[yy*map_width+xx-1]) {
|
||||
dc->color=DKGRAY;
|
||||
poly[0].x=x;
|
||||
poly[0].y=y;
|
||||
poly[0].z=0;
|
||||
poly[1].x=x;
|
||||
poly[1].y=y+SCREEN_SCALE;
|
||||
poly[1].z=0;
|
||||
poly[2].x=x;
|
||||
poly[2].y=y+SCREEN_SCALE;
|
||||
poly[2].z=SCREEN_SCALE;
|
||||
poly[3].x=x;
|
||||
poly[3].y=y;
|
||||
poly[3].z=SCREEN_SCALE;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
}
|
||||
}
|
||||
}
|
||||
x1w-=yh;
|
||||
y1w+=xh;
|
||||
}
|
||||
x1h-=xh;
|
||||
y1h-=yh;
|
||||
}
|
||||
|
||||
//Draw Monsters
|
||||
for (i=0;i<NUM_MONSTERS;i++) {
|
||||
x=monsters[i].x;
|
||||
y=monsters[i].y;
|
||||
if (LOS(x,y,_man_xx,_man_yy)) {
|
||||
x-=_man_xx;
|
||||
y-=_man_yy;
|
||||
xx=x;
|
||||
yy=y;
|
||||
zz=0;
|
||||
GrTransform(dc,&xx,&yy,&zz);
|
||||
if (zz>0) {
|
||||
if (monsters[i].dead)
|
||||
CSpritePlotRotMat3b(dc,x,y,0,$IB,"<2>",2$,r2);
|
||||
else {
|
||||
tt=Tri(tP(task),1.0);
|
||||
inter=CSpriteInterpolate($IB,"<3>",3$,$IB,"<4>",4$,tt);
|
||||
CSpritePlotRotMat3b(dc,x,y,0,inter,r1);
|
||||
Free(inter);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Free(r1);
|
||||
Free(r2);
|
||||
Free(r3);
|
||||
|
||||
//Draw Map heads-up display, scaled 2 pixels
|
||||
Free(dc->r);
|
||||
GrSetRotMat(dc,GrIdent(task));
|
||||
dc->x=task->win_pixel_width -2*map_width;
|
||||
dc->y=task->win_pixel_height-2*map_height;
|
||||
dc->z=0;
|
||||
dc->transform=&GrTransform;
|
||||
dc->pen_width=2;
|
||||
for (i=0;i<map_height;i++)
|
||||
for (j=0;j<map_width;j++) {
|
||||
dc->color=map[(map_height-1-i)*map_width+j];
|
||||
GrPlot3(dc,2*j,2*i,0);
|
||||
}
|
||||
|
||||
//Draw Things on heads-up Map
|
||||
dc->color=LTPURPLE;
|
||||
for (i=0;i<NUM_MONSTERS;i++)
|
||||
if (!monsters[i].dead)
|
||||
GrPlot3(dc,2*(monsters[i].x/SCREEN_SCALE),2*(map_height-1-monsters[i].y/SCREEN_SCALE),0);
|
||||
dc->color=LTCYAN;
|
||||
GrPlot3(dc,2*(_man_xx/SCREEN_SCALE),2*(map_height-1-_man_yy/SCREEN_SCALE),0);
|
||||
|
||||
|
||||
if (tf) {
|
||||
dc->color=LTRED;
|
||||
if (Blink(,tP(task)))
|
||||
GrPutS(dc,cx-(FONT_WIDTH*14)/2,cy-FONT_HEIGHT/2,"Game Completed");
|
||||
tt=tf;
|
||||
} else {
|
||||
dc->color=LTGREEN;
|
||||
GrLine(dc,cx-5,cy,cx+5,cy);
|
||||
GrLine(dc,cx,cy-5,cx,cy+5);
|
||||
tt=tP(task);
|
||||
}
|
||||
GrPrintF(dc,0,0,"Enemy:%d Time:%3.2f Best:%3.2f",monsters_left,tt-t0,best_score);
|
||||
Free(s2w);
|
||||
}
|
||||
|
||||
U0 Fire()
|
||||
{
|
||||
I64 i,x,y;
|
||||
F64 d,dx,dy,xx=Cos(man_é),yy=Sin(man_é);
|
||||
Noise(100,300,1000);
|
||||
for (i=0;i<NUM_MONSTERS;i++) {
|
||||
x=monsters[i].x;
|
||||
y=monsters[i].y;
|
||||
if (!monsters[i].dead &&
|
||||
LOS(x,y,man_xx,man_yy)) {
|
||||
dx=x-man_xx;
|
||||
dy=man_yy-y;
|
||||
if (d=Sqrt(dx*dx+dy*dy)) {
|
||||
dx/=d;
|
||||
dy/=d;
|
||||
if (dx*xx+dy*yy>0.995) {
|
||||
monsters[i].dead=TRUE;
|
||||
if (!--monsters_left) {
|
||||
tf=tP;
|
||||
if (tf-t0<best_score)
|
||||
best_score=tf-t0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i,x,y;
|
||||
I64 min_map_x,max_map_x,min_map_y,max_map_y;
|
||||
CDC *dc;
|
||||
CSpriteExtents($IB,"<1>",1$,&min_map_x,&max_map_x,&min_map_y,&max_map_y);
|
||||
map_width =(max_map_x-min_map_x+1)/MAP_SCALE+2;
|
||||
map_height=(max_map_y-min_map_y+1)/MAP_SCALE+2;
|
||||
Free(map);
|
||||
Free(panels_processed_bitmap);
|
||||
map=CAlloc(map_width*map_height*sizeof(U8));
|
||||
panels_processed_bitmap=MAlloc((map_width*map_height+7)>>3);
|
||||
dc=DCNew(DCT_COLOR8,map_width*MAP_SCALE,map_height*MAP_SCALE);
|
||||
CSpritePlot3(dc,-min_map_x+MAP_SCALE,-min_map_y+MAP_SCALE,0,$IB,"<1>",1$);
|
||||
for (y=1;y<map_height-1;y++)
|
||||
for (x=1;x<map_width-1;x++)
|
||||
map[(map_height-1-y)*map_width+x]=GrPeek(dc,x*MAP_SCALE,y*MAP_SCALE);
|
||||
DCDel(dc);
|
||||
man_xx=(1+MAN_START_X)*SCREEN_SCALE;
|
||||
man_yy=(map_height-1-MAN_START_Y)*SCREEN_SCALE;
|
||||
man_é=0;
|
||||
|
||||
for (i=0;i<NUM_MONSTERS;i++) {
|
||||
monsters[i].dead=FALSE;
|
||||
do {
|
||||
monsters[i].x=RandU64%((map_width-2)*SCREEN_SCALE)+SCREEN_SCALE;
|
||||
monsters[i].y=RandU64%((map_height-2)*SCREEN_SCALE)+SCREEN_SCALE;
|
||||
} while (!map[(monsters[i].y/SCREEN_SCALE)*map_width+monsters[i].x/SCREEN_SCALE]);
|
||||
}
|
||||
monsters_left=NUM_MONSTERS;
|
||||
tf=0;
|
||||
t0=tP;
|
||||
}
|
||||
|
||||
U0 AnimateTask(I64)
|
||||
{
|
||||
I64 i,x,y,dd;
|
||||
while (TRUE) {
|
||||
dd=0.25*SCREEN_SCALE*Sin(tP(Fs->parent_task)/2);
|
||||
for (i=0;i<NUM_MONSTERS;i++)
|
||||
if (!monsters[i].dead) {
|
||||
x=monsters[i].x;
|
||||
y=monsters[i].y;
|
||||
if (i&1)
|
||||
x+=dd;
|
||||
else
|
||||
y+=dd;
|
||||
if (0<=x<=map_width*SCREEN_SCALE &&
|
||||
0<=y<=map_height*SCREEN_SCALE &&
|
||||
map[(y/SCREEN_SCALE)*map_width+x/SCREEN_SCALE]) {
|
||||
if (!map[(y/SCREEN_SCALE)*map_width+x/SCREEN_SCALE+1] &&
|
||||
x-RoundI64(x,SCREEN_SCALE)>SCREEN_SCALE/2 ||
|
||||
!map[(y/SCREEN_SCALE)*map_width+x/SCREEN_SCALE-1] &&
|
||||
x-RoundI64(x,SCREEN_SCALE)<SCREEN_SCALE/2)
|
||||
x=RoundI64(x,SCREEN_SCALE)+SCREEN_SCALE/2;
|
||||
if (!map[(y/SCREEN_SCALE+1)*map_width+x/SCREEN_SCALE] &&
|
||||
y-RoundI64(y,SCREEN_SCALE)>SCREEN_SCALE/2 ||
|
||||
!map[(y/SCREEN_SCALE-1)*map_width+x/SCREEN_SCALE] &&
|
||||
y-RoundI64(y,SCREEN_SCALE)<SCREEN_SCALE/2)
|
||||
y=RoundI64(y,SCREEN_SCALE)+SCREEN_SCALE/2;
|
||||
monsters[i].x=x;
|
||||
monsters[i].y=y;
|
||||
}
|
||||
}
|
||||
Sleep(20);
|
||||
}
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
Free(map);
|
||||
Free(panels_processed_bitmap);
|
||||
map=NULL;
|
||||
panels_processed_bitmap=NULL;
|
||||
}
|
||||
|
||||
U0 SongTask(I64)
|
||||
{ //Song by Terry A. Davis
|
||||
Fs->task_end_cb=&SndTaskEndCB;
|
||||
MusicSettingsRst;
|
||||
while (TRUE) {
|
||||
Play("W12q.A#1eG2AeA#qAq.A#1eG2eAeA#qA");
|
||||
Play("q.A#1eG2A#A1qG2q.A#1eG2A#A1qG");
|
||||
Play("3eA#A2qG3eA#A2qG3eA#A2G3AA#A2qG");
|
||||
}
|
||||
}
|
||||
|
||||
U0 MoveMan(F64 é)
|
||||
{
|
||||
I64 x,y,color,step=SCREEN_SCALE/2;
|
||||
do {
|
||||
x=man_xx+step*Cos(é);
|
||||
y=man_yy-step*Sin(é);
|
||||
x=Limit(x,0,map_width*SCREEN_SCALE);
|
||||
y=Limit(y,0,map_height*SCREEN_SCALE);
|
||||
color=map[y/SCREEN_SCALE*map_width+x/SCREEN_SCALE];
|
||||
if (color==RED || color==GREEN) {
|
||||
man_xx=x;
|
||||
man_yy=y;
|
||||
break;
|
||||
} else
|
||||
step>>=1;
|
||||
} while (step);
|
||||
}
|
||||
|
||||
#define MICRO_STEPS 4
|
||||
U0 RotateMan(F64 d)
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<MICRO_STEPS;i++) {
|
||||
man_é+=d/MICRO_STEPS;
|
||||
Sleep(15);
|
||||
}
|
||||
}
|
||||
|
||||
U0 FPS()
|
||||
{
|
||||
I64 sc;
|
||||
|
||||
PopUpOk(
|
||||
"I refuse to rip-off the original\n"
|
||||
"so this is intentionally crappy\n"
|
||||
"and included for demonstration\n"
|
||||
"purposes.\n\n"
|
||||
"Write games, don't play them.\n");
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" Fwd(,,SC_CURSOR_UP);"
|
||||
" Backward(,,SC_CURSOR_DOWN);"
|
||||
" Left(,,SC_CURSOR_LEFT);"
|
||||
" Right(,,SC_CURSOR_RIGHT);"
|
||||
" Fire(,CH_SPACE);"
|
||||
"}"
|
||||
);
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
Preempt(OFF);
|
||||
WinMax;
|
||||
WordStat;
|
||||
Init;
|
||||
Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",Fs);
|
||||
Fs->song_task=Spawn(&SongTask,NULL,"Song",Fs);
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
|
||||
try {
|
||||
while (TRUE) {
|
||||
switch (GetKey(&sc)) {
|
||||
case CH_SPACE:
|
||||
Fire;
|
||||
break;
|
||||
case CH_NEW_LINE:
|
||||
Init;
|
||||
break;
|
||||
case CH_ESC:
|
||||
case CH_SHIFT_ESC:
|
||||
goto fs_done;
|
||||
case 0:
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_RIGHT:
|
||||
Spawn(&RotateMan,(ã/32)(I64));
|
||||
break;
|
||||
case SC_CURSOR_LEFT:
|
||||
Spawn(&RotateMan,(-ã/32)(I64));
|
||||
break;
|
||||
case SC_CURSOR_UP:
|
||||
MoveMan(man_é);
|
||||
break;
|
||||
case SC_CURSOR_DOWN:
|
||||
MoveMan(man_é+ã);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
fs_done:
|
||||
} catch
|
||||
CatchAll;
|
||||
SettingsPop;
|
||||
CleanUp;
|
||||
MenuPop;
|
||||
AcctRegWriteBranch("SparrowOS/FPS","F64 best_score=%5.4f;\n",best_score);
|
||||
}
|
||||
|
||||
FPS;
|
||||
Æ < < < < , , , $ 8 8 8 8 $ $ $ $ 4 4 4 4 ( ( ( ( 0 , 0 T 0 T 0 T L T L , L , L , 4 0 4 P 4 P 4 P H P H 0 H 0 H 0 8 0 8 L 8 L 8 L D L D 4 D 4 D 4 < 4 < H < H < H @ H @ 8 @ T @ l @ l 4 l L l L ˆ L ˆ L ˆ $ ˆ $ € $ € $ € 0 € 0 l 0 p 4 „ 4 „ ( „ H € H p H p D p 8 p 8 € 8 € 8 € D € D t H t D t < t < | < x @ | @ | D x D „ „ „ t p p p \ \ \ \ l l h l l l ` ` ` ` d d d h h X T P P P L L L ( @ @ 8 H H H H 8 8 8 8 D D D D < Z , u @ Z D D < D D D \ D \ D d T 0 T 8 T H L 0 L L d d h h 8 8 x 8 | 8 | 4 x 4 Z < H ñÿÿÿ ñÿÿÿØÿÿÿ ìÿÿÿØÿÿÿ ûÿÿÿ¿ÿÿÿ ¿ÿÿÿ Øÿÿÿ Øÿÿÿ ìÿÿÿ ƒÿÿÿ çÿÿÿƒÿÿÿ ûÿÿÿƒÿÿÿ ƒÿÿÿ
|
||||
tÿÿÿ öÿÿÿtÿÿÿ
|
||||
¿ÿÿÿ öÿÿÿ¿ÿÿÿ ƒÿÿÿ
|
||||
|
||||
tÿÿÿ
|
||||
ƒÿÿÿ
|
||||
ûÿÿÿƒÿÿÿ
|
||||
çÿÿÿƒÿÿÿ
|
||||
|
||||
¿ÿÿÿ
|
||||
¿ÿÿÿ
|
||||
ûÿÿÿ¿ÿÿÿ
|
||||
öÿÿÿ¿ÿÿÿ
|
||||
ìÿÿÿØÿÿÿ
|
||||
ñÿÿÿØÿÿÿ
|
||||
Øÿÿÿ
|
||||
Øÿÿÿ
|
||||
ûÿÿÿ
|
||||
ûÿÿÿ
|
||||
ñÿÿÿûÿÿÿ
|
||||
ìÿÿÿûÿÿÿ
|
||||
ƒÿÿÿ
|
||||
ìÿÿÿƒÿÿÿ
|
||||
çÿÿÿ«ÿÿÿ- ìÿÿÿ«ÿÿÿ- «ÿÿÿ- «ÿÿÿ- °ÿÿÿ- °ÿÿÿ- ìÿÿÿ°ÿÿÿ- çÿÿÿ°ÿÿÿ- øÿÿÿxÿÿÿ ýÿÿÿ|ÿÿÿ xÿÿÿ xÿÿÿ |ÿÿÿ öÿÿÿtÿÿÿ
|
||||
ÿÿÿÿxÿÿÿ ìÿÿÿûÿÿÿ ñÿÿÿûÿÿÿ ñÿÿÿ ûÿÿÿ ûÿÿÿ ìÿÿÿ
|
||||
␍ ! ! & ' ' " # % $ $ # ␍ ␍ !
|
||||
|
||||
|
||||
$ % * $ * + ' & ( ' ( ) & ( ( $ + +
|
||||
0 / . 1 1 2 - , 7 7 6 5 3 4 3 ! 3 4 5 8 3 3 ! 8 3 9 ; : 7 ; 7 6 6 ; ; 1 ␍ Z < H ñÿÿÿ öÿÿÿñÿÿÿØÿÿÿ ìÿÿÿØÿÿÿ ûÿÿÿ¿ÿÿÿ ¿ÿÿÿ Øÿÿÿ Øÿÿÿ ìÿÿÿ öÿÿÿ ƒÿÿÿ çÿÿÿƒÿÿÿ ûÿÿÿƒÿÿÿ ƒÿÿÿ
|
||||
tÿÿÿ öÿÿÿtÿÿÿ
|
||||
¿ÿÿÿ öÿÿÿ¿ÿÿÿ ƒÿÿÿ
|
||||
|
||||
tÿÿÿ
|
||||
ƒÿÿÿ
|
||||
ûÿÿÿƒÿÿÿ
|
||||
çÿÿÿƒÿÿÿ
|
||||
|
||||
¿ÿÿÿ
|
||||
¿ÿÿÿ
|
||||
ûÿÿÿ¿ÿÿÿ
|
||||
öÿÿÿ¿ÿÿÿ
|
||||
ìÿÿÿØÿÿÿ
|
||||
ñÿÿÿØÿÿÿ
|
||||
Øÿÿÿ
|
||||
Øÿÿÿ
|
||||
ûÿÿÿ ûÿÿÿ ñÿÿÿûÿÿÿ ìÿÿÿûÿÿÿ ƒÿÿÿ
|
||||
ìÿÿÿƒÿÿÿ
|
||||
çÿÿÿ«ÿÿÿ- ìÿÿÿ«ÿÿÿ- «ÿÿÿÓÿÿÿ «ÿÿÿÓÿÿÿ °ÿÿÿÓÿÿÿ °ÿÿÿÓÿÿÿìÿÿÿ°ÿÿÿ- çÿÿÿ°ÿÿÿ- øÿÿÿxÿÿÿ ýÿÿÿ|ÿÿÿ xÿÿÿ xÿÿÿ |ÿÿÿ öÿÿÿtÿÿÿ
|
||||
ÿÿÿÿxÿÿÿ ìÿÿÿûÿÿÿ ñÿÿÿûÿÿÿ ñÿÿÿ ûÿÿÿ- ûÿÿÿ- ìÿÿÿ - -
|
||||
␍ ! ! & ' ' " # % $ $ # ␍ ␍ !
|
||||
|
||||
|
||||
$ % * $ * + ' & ( ' ( ) & ( ( $ + +
|
||||
0 / . 1 1 2 - , 7 7 6 5 3 4 3 ! 3 4 5 8 3 3 ! 8 3 9 ; : 7 ; 7 6 6 ; ; 1 ␍ Z < H ñÿÿÿ ñÿÿÿØÿÿÿ ìÿÿÿØÿÿÿ ûÿÿÿ¿ÿÿÿ ¿ÿÿÿ Øÿÿÿ Øÿÿÿ ìÿÿÿ öÿÿÿ ƒÿÿÿ çÿÿÿƒÿÿÿ ûÿÿÿƒÿÿÿ ƒÿÿÿ
|
||||
tÿÿÿ öÿÿÿtÿÿÿ
|
||||
¿ÿÿÿ öÿÿÿ¿ÿÿÿ ƒÿÿÿ
|
||||
|
||||
tÿÿÿ
|
||||
ƒÿÿÿ
|
||||
ûÿÿÿƒÿÿÿ
|
||||
çÿÿÿƒÿÿÿ
|
||||
|
||||
¿ÿÿÿ
|
||||
¿ÿÿÿ
|
||||
ûÿÿÿ¿ÿÿÿ
|
||||
öÿÿÿ¿ÿÿÿ
|
||||
ìÿÿÿØÿÿÿ
|
||||
ñÿÿÿØÿÿÿ
|
||||
Øÿÿÿ
|
||||
Øÿÿÿ
|
||||
ûÿÿÿ ûÿÿÿ ñÿÿÿûÿÿÿ ìÿÿÿûÿÿÿ ƒÿÿÿ
|
||||
ìÿÿÿƒÿÿÿ
|
||||
çÿÿÿ«ÿÿÿÓÿÿÿìÿÿÿ«ÿÿÿÓÿÿÿ «ÿÿÿ- «ÿÿÿ- °ÿÿÿ- °ÿÿÿ- ìÿÿÿ°ÿÿÿÓÿÿÿçÿÿÿ°ÿÿÿÓÿÿÿøÿÿÿxÿÿÿ ýÿÿÿ|ÿÿÿ xÿÿÿ xÿÿÿ |ÿÿÿ öÿÿÿtÿÿÿ
|
||||
ÿÿÿÿxÿÿÿ ìÿÿÿûÿÿÿ# ñÿÿÿûÿÿÿ# ñÿÿÿ # ûÿÿÿ ûÿÿÿ ìÿÿÿ # öÿÿÿ
|
||||
␍ ! ! & ' ' " # % $ $ # ␍ ␍ !
|
||||
|
||||
|
||||
$ % * $ * + ' & ( ' ( ) & ( ( $ + +
|
||||
0 / . 1 1 2 - , 7 7 6 5 3 4 3 ! 3 4 5 8 3 3 ! 8 3 9 ; : 7 ; 7 6 6 ; ; 1 ␍ , Îÿÿÿ Îÿÿÿûÿÿÿ çÿÿÿûÿÿÿ çÿÿÿ µÿÿÿ �ÿÿÿ ƒÿÿÿ �ÿÿÿâÿÿÿ µÿÿÿâÿÿÿûÿÿÿÎÿÿÿ ûÿÿÿÎÿÿÿûÿÿÿûÿÿÿçÿÿÿûÿÿÿûÿÿÿçÿÿÿ ûÿÿÿµÿÿÿ ûÿÿÿ�ÿÿÿ ûÿÿÿ�ÿÿÿâÿÿÿûÿÿÿµÿÿÿâÿÿÿ �ÿÿÿ µÿÿÿ âÿÿÿµÿÿÿ âÿÿÿ�ÿÿÿ �ÿÿÿûÿÿÿ µÿÿÿûÿÿÿâÿÿÿµÿÿÿûÿÿÿâÿÿÿ�ÿÿÿûÿÿÿ
|
||||
|
||||
|
||||
␍ ␍ ␍
|
||||
|
||||
|
||||
␍
|
||||
␍ ÷ÿÿÿ ÷ÿÿÿñÿÿÿ ÷ÿÿÿ ôÿÿÿ ÷ÿÿÿ øÿÿÿçÿÿÿ ìÿÿÿçÿÿÿ ìÿÿÿçÿÿÿøÿÿÿøÿÿÿçÿÿÿðÿÿÿ çÿÿÿðÿÿÿ çÿÿÿøÿÿÿ çÿÿÿ çÿÿÿ ␍ ␍
|
||||
|
||||
|
||||
|
||||
␍ ␍ ␍
|
||||
@@ -0,0 +1,163 @@
|
||||
#define NUM_ROAD 512
|
||||
#define ROAD_WIDTH_BY_2 200
|
||||
#define CAR_WIDTH_BY_2 100
|
||||
|
||||
I64 road_x[NUM_ROAD],road_trend;
|
||||
F64 speed,distance;
|
||||
I64 road_ptr=0,car_x;
|
||||
F64 t_last;
|
||||
Bool crash;
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
I64 h=task->win_pixel_width,v=task->win_pixel_height;
|
||||
I64 i,x,y,xx;
|
||||
Bool old_preempt=Preempt(OFF);
|
||||
xx=h>>1-car_x+road_x[road_ptr&(NUM_ROAD-1)];
|
||||
|
||||
task->text_attr=BLACK+BLACK<<4;
|
||||
dc->color=LTGRAY;
|
||||
for (i=0;i<NUM_ROAD;i++) {
|
||||
x=h>>1-car_x+road_x[(i+road_ptr)&(NUM_ROAD-1)];
|
||||
y=v-0.5*i;
|
||||
if (y<v/2) break;
|
||||
GrPlot(dc,x+ROAD_WIDTH_BY_2-0.4*i,y);
|
||||
GrPlot(dc,x-ROAD_WIDTH_BY_2+0.4*i,y);
|
||||
}
|
||||
dc->color=WHITE;
|
||||
|
||||
x=h>>1-CAR_WIDTH_BY_2;
|
||||
if (x<xx-ROAD_WIDTH_BY_2)
|
||||
crash=TRUE;
|
||||
GrLine(dc,x-10,v,x-40,v-100);
|
||||
GrLine(dc,x+10,v,x+40,v-100);
|
||||
|
||||
x=h>>1+CAR_WIDTH_BY_2;
|
||||
if (x>xx+ROAD_WIDTH_BY_2)
|
||||
crash=TRUE;
|
||||
GrLine(dc,x-10,v,x-40,v-100);
|
||||
GrLine(dc,x+10,v,x+40,v-100);
|
||||
|
||||
dc->color=YELLOW;
|
||||
if (crash)
|
||||
GrPutS(dc,h>>1-FONT_WIDTH*4,(v-FONT_HEIGHT)>>1,"Game Over");
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
U0 UpdateRoad()
|
||||
{
|
||||
F64 t0=tP;
|
||||
distance+=speed*(t0-t_last);
|
||||
t_last=t0;
|
||||
while (distance>1.0) {
|
||||
road_trend=LimitI64(road_trend+SignI64(RandU16%3-1),-5,5);
|
||||
road_x[road_ptr&(NUM_ROAD-1)]=
|
||||
road_x[(road_ptr-1)&(NUM_ROAD-1)]+=road_trend/3;
|
||||
road_ptr++;
|
||||
distance-=1.0;
|
||||
}
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i,x=0;
|
||||
speed=0;
|
||||
distance=0;
|
||||
road_trend=0;
|
||||
road_ptr=0;
|
||||
car_x=0;
|
||||
for (i=0;i<NUM_ROAD;i++) {
|
||||
road_x[i]=x;
|
||||
road_trend=LimitI64(road_trend+SignI64(RandU16%3-1),-5,5);
|
||||
x+=road_trend/3;
|
||||
}
|
||||
t_last=tP;
|
||||
crash=FALSE;
|
||||
}
|
||||
|
||||
|
||||
U0 Halogen()
|
||||
{
|
||||
I64 p1,p2,ch=0,sc=0;
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" Accelerate(,,SC_CURSOR_UP);"
|
||||
" Deccellerate(,,SC_CURSOR_DOWN);"
|
||||
" Left(,,SC_CURSOR_LEFT);"
|
||||
" Right(,,SC_CURSOR_RIGHT);"
|
||||
"}"
|
||||
);
|
||||
Preempt(OFF);
|
||||
WordStat;
|
||||
WinMax;
|
||||
Init;
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
try {
|
||||
while (TRUE) {
|
||||
switch (ScanMsg(&p1,&p2,1<<MSG_KEY_DOWN|1<<MSG_KEY_UP)) {
|
||||
case MSG_KEY_DOWN:
|
||||
ch=p1;sc=p2;
|
||||
switch (ch) {
|
||||
case CH_NEW_LINE:
|
||||
Init;
|
||||
break;
|
||||
case CH_ESC:
|
||||
case CH_SHIFT_ESC:
|
||||
goto ha_done;
|
||||
}
|
||||
break;
|
||||
case MSG_KEY_UP:
|
||||
ch=p1;sc=p2;
|
||||
if (!ch)
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_RIGHT:
|
||||
case SC_CURSOR_LEFT:
|
||||
case SC_CURSOR_UP:
|
||||
case SC_CURSOR_DOWN:
|
||||
sc=0;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_RIGHT:
|
||||
car_x++;
|
||||
break;
|
||||
case SC_CURSOR_LEFT:
|
||||
car_x--;
|
||||
break;
|
||||
case SC_CURSOR_UP:
|
||||
if (++speed>200) speed=200;
|
||||
break;
|
||||
case SC_CURSOR_DOWN:
|
||||
if (--speed<0) speed=0;
|
||||
break;
|
||||
}
|
||||
if (crash)
|
||||
Snd(0);
|
||||
else {
|
||||
if (speed)
|
||||
Snd(speed+10);
|
||||
else
|
||||
Snd(0);
|
||||
UpdateRoad;
|
||||
}
|
||||
Sleep(10);
|
||||
}
|
||||
ha_done:
|
||||
GetMsg(,,1<<MSG_KEY_UP);
|
||||
} catch
|
||||
CatchAll;
|
||||
MenuPop;
|
||||
SettingsPop;
|
||||
}
|
||||
|
||||
Halogen;
|
||||
@@ -0,0 +1,189 @@
|
||||
class MyMass:CMass
|
||||
{
|
||||
F64 radius;
|
||||
};
|
||||
|
||||
class MySpring:CSpring
|
||||
{
|
||||
};
|
||||
|
||||
CMathODE *ode=NULL;
|
||||
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
Bool old_suspend;
|
||||
MyMass *tempm;
|
||||
MySpring *temps;
|
||||
|
||||
old_suspend=Suspend(task);
|
||||
dc->color=RED;
|
||||
temps=ode->next_spring;
|
||||
while (temps!=&ode->next_spring) {
|
||||
GrLine(dc,temps->end1->x,temps->end1->y,
|
||||
temps->end2->x,temps->end2->y);
|
||||
temps=temps->next;
|
||||
}
|
||||
|
||||
dc->color=BLACK;
|
||||
tempm=ode->next_mass;
|
||||
while (tempm!=&ode->next_mass) {
|
||||
GrCircle(dc,tempm->x,tempm->y,tempm->radius);
|
||||
tempm=tempm->next;
|
||||
}
|
||||
Suspend(task,old_suspend);
|
||||
}
|
||||
|
||||
|
||||
U0 MyDerivative(CMathODE *ode,F64,COrder2D3 *,COrder2D3 *)
|
||||
{
|
||||
//The forces due to springs and drag are
|
||||
//automatically handled by the
|
||||
//ode code. We can add new forces
|
||||
//here.
|
||||
F64 d,dd;
|
||||
CD3 p;
|
||||
MyMass *tempm1,*tempm2;
|
||||
|
||||
tempm1=ode->next_mass;
|
||||
while (tempm1!=&ode->next_mass) {
|
||||
tempm2=tempm1->next;
|
||||
while (tempm2!=&ode->next_mass) {
|
||||
D3Sub(&tempm2->state->x,&tempm1->state->x,&p);
|
||||
dd=D3SqrNorm(&p);
|
||||
if (dd<=Sqr(tempm1->radius+tempm2->radius)) {
|
||||
d=Sqrt(dd)+0.0001;
|
||||
dd=10.0*Sqr(Sqr(Sqr(tempm1->radius+tempm2->radius)-dd));
|
||||
D3MulEqu(&p,dd/d);
|
||||
D3AddEqu(&tempm2->DstateDt->DxDt,&p);
|
||||
D3SubEqu(&tempm1->DstateDt->DxDt,&p);
|
||||
}
|
||||
tempm2=tempm2->next;
|
||||
}
|
||||
tempm1=tempm1->next;
|
||||
}
|
||||
}
|
||||
|
||||
U0 PlaceMass(I64 x, I64 y)
|
||||
{
|
||||
MyMass *tempm=CAlloc(sizeof(MyMass));
|
||||
tempm->mass=1.0;
|
||||
tempm->drag_profile_factor=100.0;
|
||||
tempm->x=x;
|
||||
tempm->y=y;
|
||||
tempm->radius=10*(Rand+0.25);
|
||||
QueIns(tempm,ode->last_mass);
|
||||
}
|
||||
|
||||
U0 PlaceSpring(MyMass *tempm1,MyMass *tempm2)
|
||||
{
|
||||
MySpring *temps=CAlloc(sizeof(MySpring));
|
||||
temps->end1=tempm1;
|
||||
temps->end2=tempm2;
|
||||
temps->constant=10000;
|
||||
temps->rest_len=100;
|
||||
QueIns(temps,ode->last_spring);
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
ode=ODENew(0,1e-4,ODEF_HAS_MASSES);
|
||||
ode->derivative=&MyDerivative;
|
||||
ode->drag_v2=0.002;
|
||||
ode->drag_v3=0.00001;
|
||||
ode->acceleration_limit=5e3;
|
||||
|
||||
QueIns(ode,Fs->last_ode);
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
QueRem(ode);
|
||||
QueDel(&ode->next_mass,TRUE);
|
||||
QueDel(&ode->next_spring,TRUE);
|
||||
ODEDel(ode);
|
||||
}
|
||||
|
||||
U0 MassSpringDemo()
|
||||
{
|
||||
I64 msg_code,p1,p2;
|
||||
MyMass *tempm1=NULL,*tempm2=NULL;
|
||||
|
||||
PopUpOk("Left-Click to place mas\n"
|
||||
"Right-Click and drag to\n"
|
||||
"connect with spring.\n\n"
|
||||
"Springs are 100 pixels long.\n");
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
WinMax;
|
||||
|
||||
//This Preempt() eliminates a lot of hassles.
|
||||
//The concern is about changing
|
||||
//que links while the winmgr task
|
||||
//is updating the ode or screen.
|
||||
|
||||
//The Window mgr suspends this
|
||||
//task while updating the ode. It
|
||||
//will not be interrupted and with this
|
||||
//preempt, we will not be interrupted.
|
||||
//There is little downside to Preempt()
|
||||
//since we will yield during GetMsg().
|
||||
Preempt(OFF);
|
||||
|
||||
|
||||
Fs->win_inhibit|=WIF_DBL_CLICK;
|
||||
WordStat;
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
"}"
|
||||
);
|
||||
|
||||
Init;
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
|
||||
try {
|
||||
while (TRUE) {
|
||||
msg_code=GetMsg(&p1,&p2,1<<MSG_IP_L_DOWN|1<<MSG_IP_R_DOWN|1<<MSG_IP_R_UP|1<<MSG_KEY_DOWN);
|
||||
switch (msg_code) {
|
||||
case MSG_IP_L_DOWN:
|
||||
PlaceMass(p1,p2);
|
||||
break;
|
||||
case MSG_IP_R_DOWN:
|
||||
tempm1=MassFind(ode,p1,p2);
|
||||
tempm2=NULL;
|
||||
break;
|
||||
case MSG_IP_R_UP:
|
||||
if (tempm1 && (tempm2=MassFind(ode,p1,p2)) && tempm1!=tempm2)
|
||||
PlaceSpring(tempm1,tempm2);
|
||||
tempm1=tempm2=NULL;
|
||||
break;
|
||||
case MSG_KEY_DOWN:
|
||||
switch (p1) {
|
||||
case CH_NEW_LINE:
|
||||
CleanUp;
|
||||
Init;
|
||||
break;
|
||||
case CH_SHIFT_ESC:
|
||||
case CH_ESC:
|
||||
goto ms_done;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
ms_done: //Don't goto out of try
|
||||
GetMsg(,,1<<MSG_KEY_UP);
|
||||
} catch
|
||||
CatchAll;
|
||||
SettingsPop;
|
||||
CleanUp;
|
||||
MenuPop;
|
||||
}
|
||||
|
||||
MassSpringDemo;
|
||||
Binary file not shown.
@@ -0,0 +1,770 @@
|
||||
#define GAME_SPEED_SCALE 0.1
|
||||
|
||||
F64 game_speed,
|
||||
launch_unit_x1,launch_unit_y1,launch_unit_x2,launch_unit_y2,launch_t,
|
||||
return_unit_x1,return_unit_y1,return_unit_x2,return_unit_y2,return_t,
|
||||
set_é_unit_x1,set_é_unit_y1,set_é_unit_x2,set_é_unit_y2,set_é_t;
|
||||
CTask *main_task;
|
||||
|
||||
#define OT_CARRIER 0
|
||||
#define OT_CRUISER 1
|
||||
#define OT_FIGHTER 2
|
||||
#define OT_NUM_TYPES 3
|
||||
|
||||
#define OF_SHIP 1
|
||||
#define OF_ACTIVE 2
|
||||
#define OF_RETURNING 4
|
||||
#define OF_SHOOTING 8
|
||||
|
||||
class Obj
|
||||
{
|
||||
Obj *next,*last;
|
||||
Obj *next_in_squadron,*last_in_squadron;
|
||||
Obj *host;
|
||||
U8 player,type;
|
||||
U16 flags;
|
||||
I16 squadron,member_num;
|
||||
F64 x,y,é,dé,
|
||||
speed,turn_rate,
|
||||
life_percent,
|
||||
target_x,target_y,
|
||||
ship_guns,ship_guns_range,
|
||||
air_guns,air_guns_range,
|
||||
fuel,max_fuel,fuel_burn_rate,
|
||||
death_time,next_action_time;
|
||||
I32 torpedos,max_torpedos;
|
||||
F64 torpedos_range;
|
||||
} obj_root;
|
||||
|
||||
class Torpedo
|
||||
{
|
||||
Torpedo *next,*last;
|
||||
Obj *target;
|
||||
F64 x,y,é,speed,timeout;
|
||||
} torpedo_root;
|
||||
|
||||
#define SA_PARKED 0
|
||||
#define SA_LAUNCHING 1
|
||||
#define SA_FLYING 2
|
||||
#define SA_SET_é 3
|
||||
#define SA_RETURNING 4
|
||||
#define SA_DEAD 5
|
||||
|
||||
class Squadron : Obj
|
||||
{
|
||||
I64 action,dead_mask,total_mask;
|
||||
} *squadrons;
|
||||
|
||||
|
||||
U0 SquadronIns(Obj *o,Obj *pred)
|
||||
{
|
||||
Obj *succ=pred->next_in_squadron;
|
||||
o->next_in_squadron=succ;
|
||||
o->last_in_squadron=pred;
|
||||
pred->next_in_squadron=o;
|
||||
succ->last_in_squadron=o;
|
||||
}
|
||||
|
||||
U0 SquadronRem(Obj *o)
|
||||
{
|
||||
Obj *pred=o->last_in_squadron,*succ=o->next_in_squadron;
|
||||
pred->next_in_squadron=succ;
|
||||
succ->last_in_squadron=pred;
|
||||
}
|
||||
|
||||
#define NUM_PLAYERS 2
|
||||
|
||||
I64 num_carriers[NUM_PLAYERS]={2,3},
|
||||
num_cruisers[NUM_PLAYERS]={2,3},
|
||||
num_planes_per_squadron[NUM_PLAYERS]={6,5},
|
||||
num_squadrons_per_carrier[NUM_PLAYERS]={2,3},
|
||||
num_alive[NUM_PLAYERS],
|
||||
num_squadrons;
|
||||
|
||||
Obj *ObjFind(F64 x,F64 y,
|
||||
I64 flag_mask=OF_ACTIVE|OF_RETURNING,I64 flag_val=OF_ACTIVE,
|
||||
I64 type_mask=-1,I64 player_mask=-1,F64 *_d=NULL)
|
||||
{
|
||||
Obj *tempo=obj_root.next,*best=NULL;
|
||||
F64 dd,best_dd=MAX_F64;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->flags&flag_mask==flag_val &&
|
||||
Bt(&type_mask,tempo->type)&&Bt(&player_mask,tempo->player)) {
|
||||
dd=Sqr(tempo->x-x)+Sqr(tempo->y-y);
|
||||
if (dd<best_dd) {
|
||||
best=tempo;
|
||||
best_dd=dd;
|
||||
}
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
if (_d) *_d=Sqrt(best_dd);
|
||||
return best;
|
||||
}
|
||||
|
||||
U0 ObjDel(Obj *tempo)
|
||||
{
|
||||
if (tempo) {
|
||||
if (tP(main_task)<tempo->death_time)
|
||||
tempo->flags&=~OF_ACTIVE;
|
||||
else {
|
||||
if (tempo->squadron>=0)
|
||||
SquadronRem(tempo);
|
||||
QueRem(tempo);
|
||||
if (tempo->squadron>=0)
|
||||
LBts(&squadrons[tempo->squadron].dead_mask,tempo->member_num);
|
||||
num_alive[tempo->player]--;
|
||||
Free(tempo);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
$BG,1$
|
||||
|
||||
|
||||
$SP,"<1>",1$
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<2>",2$
|
||||
|
||||
|
||||
$SP,"<3>",3$
|
||||
|
||||
|
||||
|
||||
$SP,"<4>",4$
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<5>",5$
|
||||
|
||||
|
||||
$SP,"<6>",6$
|
||||
$BG$
|
||||
U8 *imgs[NUM_PLAYERS][OT_NUM_TYPES]={{$IB,"<1>",1$,$IB,"<2>",2$,$IB,"<3>",3$},{$IB,"<4>",4$,$IB,"<5>",5$,$IB,"<6>",6$}};
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
F64 d,cur_time=tP(task);
|
||||
Obj *tempo;
|
||||
Torpedo *tempt;
|
||||
Bool old_preempt=Preempt(OFF);
|
||||
task->text_attr=BLUE<<4+WHITE;
|
||||
|
||||
|
||||
tempt=torpedo_root.next;
|
||||
while (tempt!=&torpedo_root) {
|
||||
dc->color=WHITE;
|
||||
GrPlot(dc,tempt->x,tempt->y);
|
||||
tempt=tempt->next;
|
||||
}
|
||||
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->flags&OF_ACTIVE && tempo->flags&OF_SHIP) {
|
||||
CSpritePlotRotZ3b(dc,tempo->x,tempo->y,0,imgs[tempo->player][tempo->type],tempo->é+ã/2);
|
||||
if (Blink(,cur_time)) {
|
||||
dc->color=BLACK;
|
||||
GrLine(dc,tempo->x+5,tempo->y,tempo->x+5+10,tempo->y);
|
||||
|
||||
if (tempo->life_percent>0) {
|
||||
if (tempo->life_percent<33)
|
||||
dc->color=RED;
|
||||
else if (tempo->life_percent<66)
|
||||
dc->color=YELLOW;
|
||||
else
|
||||
dc->color=GREEN;
|
||||
GrLine(dc,tempo->x+5,tempo->y,tempo->x+5+10*tempo->life_percent/100,tempo->y);
|
||||
}
|
||||
|
||||
dc->color=BLACK;
|
||||
GrLine(dc,tempo->x+5,tempo->y+2,tempo->x+5+10,tempo->y+2);
|
||||
d=tempo->fuel*100/tempo->max_fuel;
|
||||
if (d>0) {
|
||||
if (d<33)
|
||||
dc->color=RED;
|
||||
else if (d<66)
|
||||
dc->color=YELLOW;
|
||||
else
|
||||
dc->color=GREEN;
|
||||
GrLine(dc,tempo->x+5,tempo->y+2,tempo->x+5+10*d/100,tempo->y+2);
|
||||
}
|
||||
}
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->flags&OF_ACTIVE && !(tempo->flags&OF_SHIP))
|
||||
CSpritePlotRotZ3b(dc,tempo->x,tempo->y,0,imgs[tempo->player][tempo->type],tempo->é+ã/2);
|
||||
if (tempo->flags&OF_SHOOTING) {
|
||||
dc->color=LTRED;
|
||||
GrLine(dc,tempo->x,tempo->y,tempo->target_x,tempo->target_y,3);
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
|
||||
dc->flags|=DCF_TRANSFORMATION;
|
||||
if (cur_time<launch_t) {
|
||||
dc->color=LTGREEN;
|
||||
GrArrow3(dc,launch_unit_x1,launch_unit_y1,0,launch_unit_x2,launch_unit_y2,0);
|
||||
}
|
||||
if (cur_time<return_t) {
|
||||
dc->color=LTRED;
|
||||
GrArrow3(dc,return_unit_x1,return_unit_y1,0,return_unit_x2,return_unit_y2,0);
|
||||
}
|
||||
if (cur_time<set_é_t) {
|
||||
dc->color=YELLOW;
|
||||
GrArrow3(dc,set_é_unit_x1,set_é_unit_y1,0,set_é_unit_x2,set_é_unit_y2,0);
|
||||
}
|
||||
|
||||
dc->color=YELLOW;
|
||||
GrPrintF(dc,-task->win_scroll_x,-task->win_scroll_y,"Game Speed: %5.2f",game_speed);
|
||||
dc->color=LTCYAN;
|
||||
GrPrintF(dc,-task->win_scroll_x,-task->win_scroll_y+ FONT_HEIGHT,"Player 1: %d",num_alive[0]);
|
||||
dc->color=LTPURPLE;
|
||||
GrPrintF(dc,-task->win_scroll_x,-task->win_scroll_y+2*FONT_HEIGHT,"Player 2: %d",num_alive[1]);
|
||||
|
||||
if ((!num_alive[0]||!num_alive[1]) && Blink(,cur_time)) {
|
||||
if (!num_alive[1]) {
|
||||
dc->color=LTGREEN;
|
||||
GrPutS(dc,task->win_pixel_width>>1 -(FONT_WIDTH*14)/2-task->win_scroll_x,
|
||||
task->win_pixel_height>>1-FONT_HEIGHT/2-task->win_scroll_y,"Game Completed");
|
||||
} else {
|
||||
dc->color=LTRED;
|
||||
GrPutS(dc,task->win_pixel_width>>1 -(FONT_WIDTH*9)/2-task->win_scroll_x,
|
||||
task->win_pixel_height>>1-FONT_HEIGHT/2-task->win_scroll_y,"Game Over");
|
||||
}
|
||||
}
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i,fighter,ship,player,squadron,
|
||||
w=Fs->win_pixel_width,h=Fs->win_pixel_height;
|
||||
Squadron *temps;
|
||||
Obj *tempo,*tempo1;
|
||||
QueInit(&obj_root);
|
||||
QueInit(&torpedo_root);
|
||||
|
||||
Fs->win_scroll_x=0;
|
||||
Fs->win_scroll_y=0;
|
||||
game_speed=1.0;
|
||||
launch_t=return_t=set_é_t=0;
|
||||
main_task=Fs;
|
||||
num_squadrons=0;
|
||||
for (player=0;player<NUM_PLAYERS;player++) {
|
||||
num_alive[player]=0;
|
||||
for (ship=0;ship<num_cruisers[player];ship++) {
|
||||
tempo1=CAlloc(sizeof(Obj));
|
||||
num_alive[player]++;
|
||||
tempo1->type=OT_CRUISER; tempo1->player=player;
|
||||
tempo1->squadron=-1; tempo1->member_num=ship;
|
||||
tempo1->flags=OF_ACTIVE|OF_SHIP;
|
||||
tempo1->x=0.8*w*(Rand-0.5)+w>>1; tempo1->y=0.8*h*(Rand-0.5)+h>>1;
|
||||
tempo1->host=NULL;
|
||||
tempo1->speed=35.0; tempo1->turn_rate=2.5;
|
||||
tempo1->é=2*ã*(Rand-0.5); tempo1->dé=0;
|
||||
tempo1->life_percent=100.0;
|
||||
tempo1->fuel=tempo1->max_fuel=100000;
|
||||
tempo1->fuel_burn_rate=100.0;
|
||||
tempo1->air_guns =5000; tempo1->air_guns_range =30.0;
|
||||
tempo1->ship_guns=10000; tempo1->ship_guns_range=30.0;
|
||||
tempo1->torpedos =tempo1->max_torpedos=0;
|
||||
tempo1->torpedos_range =0.0;
|
||||
tempo1->next_action_time=0;
|
||||
QueIns(tempo1,obj_root.last);
|
||||
}
|
||||
|
||||
for (ship=0;ship<num_carriers[player];ship++) {
|
||||
tempo1=CAlloc(sizeof(Obj));
|
||||
num_alive[player]++;
|
||||
tempo1->type=OT_CARRIER; tempo1->player=player;
|
||||
tempo1->squadron=-1; tempo1->member_num=ship;
|
||||
tempo1->flags=OF_ACTIVE|OF_SHIP;
|
||||
tempo1->x=0.8*w*(Rand-0.5)+w>>1; tempo1->y=0.8*h*(Rand-0.5)+h>>1;
|
||||
tempo1->host=NULL;
|
||||
tempo1->speed=28.0; tempo1->turn_rate=1.0;
|
||||
tempo1->é=2*ã*(Rand-0.5); tempo1->dé=0;
|
||||
tempo1->life_percent=100.0;
|
||||
tempo1->fuel=tempo1->max_fuel=750000;
|
||||
tempo1->fuel_burn_rate=500.0;
|
||||
tempo1->air_guns =5000; tempo1->air_guns_range =20.0;
|
||||
tempo1->ship_guns=2000; tempo1->ship_guns_range=30.0;
|
||||
tempo1->torpedos =tempo1->max_torpedos=0;
|
||||
tempo1->torpedos_range =0.0;
|
||||
tempo1->next_action_time=0;
|
||||
QueIns(tempo1,obj_root.last);
|
||||
|
||||
for (squadron=0;squadron<num_squadrons_per_carrier[player];squadron++,num_squadrons++) {
|
||||
for (fighter=0;fighter<num_planes_per_squadron[player];fighter++) {
|
||||
tempo=CAlloc(sizeof(Obj));
|
||||
num_alive[player]++;
|
||||
tempo->type=OT_FIGHTER; tempo->player=player;
|
||||
tempo->squadron=num_squadrons; tempo->member_num=fighter;
|
||||
tempo->flags=0;
|
||||
tempo->host=tempo1;
|
||||
tempo->speed=300.0; tempo->turn_rate=25.0;
|
||||
tempo->life_percent=100.0;
|
||||
tempo->fuel=tempo->max_fuel=1000;
|
||||
tempo->fuel_burn_rate=1.0;
|
||||
tempo->air_guns =35000; tempo->air_guns_range =8.0;
|
||||
tempo->ship_guns=0; tempo->ship_guns_range=0.0;
|
||||
tempo->torpedos =tempo->max_torpedos=1;
|
||||
tempo->torpedos_range =20.0;
|
||||
QueIns(tempo,obj_root.last);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
squadrons=CAlloc(num_squadrons*sizeof(Squadron));
|
||||
for (i=0,temps=squadrons;i<num_squadrons;i++,temps++) {
|
||||
temps->next_in_squadron=temps->last_in_squadron=temps;
|
||||
temps->squadron=i;
|
||||
}
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->squadron>=0) {
|
||||
temps=&squadrons[tempo->squadron];
|
||||
temps->host =tempo->host;
|
||||
temps->player=tempo->player;
|
||||
temps->total_mask=1<<num_planes_per_squadron[tempo->player]-1;
|
||||
SquadronIns(tempo,temps->last_in_squadron);
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
QueDel(&obj_root,TRUE);
|
||||
QueDel(&torpedo_root,TRUE);
|
||||
Free(squadrons);
|
||||
}
|
||||
|
||||
Obj *ObjLaunch(I64 player,I64 squadron=-1,Obj *host=NULL,F64 x=MAX_F64,F64 y=MAX_F64,F64 é=MAX_F64)
|
||||
{
|
||||
Obj *tempo;
|
||||
F64 cur_time=tP(main_task);
|
||||
if (!host)
|
||||
host=ObjFind(x,y,,,1<<OT_CARRIER,1<<player);
|
||||
if (host && cur_time>host->next_action_time) {
|
||||
if (é==MAX_F64)
|
||||
é=Arg(x-host->x,y-host->y);
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->host==host && (squadron<0||tempo->squadron==squadron) && !(tempo->flags&OF_ACTIVE) &&
|
||||
(tempo->squadron<0||squadrons[tempo->squadron].action==SA_PARKED||squadrons[tempo->squadron].action==SA_LAUNCHING)) {
|
||||
if (tempo->fuel<=0.0) //When low on fuel, not zero, gets launched and captured.
|
||||
LBts(&squadrons[tempo->squadron].dead_mask,tempo->member_num);
|
||||
else {
|
||||
tempo->flags=tempo->flags&~OF_RETURNING|OF_ACTIVE;
|
||||
tempo->é=host->é;
|
||||
if (x==MAX_F64 || y==MAX_F64 || Sqr(x-host->x)+Sqr(y-host->y)>3*3)
|
||||
tempo->dé=Wrap(é-tempo->é,-ã);
|
||||
else
|
||||
tempo->dé=0;
|
||||
tempo->x=host->x;
|
||||
tempo->y=host->y;
|
||||
host->next_action_time=cur_time+0.25/game_speed;
|
||||
return tempo;
|
||||
}
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Squadron *SquadronLaunch(I64 player,F64 x=MAX_F64,F64 y=MAX_F64)
|
||||
{
|
||||
Squadron *temps;
|
||||
Obj *tempo;
|
||||
if (tempo=ObjLaunch(player,,,x,y)) {
|
||||
if (player==0) {
|
||||
launch_unit_x1=tempo->x;
|
||||
launch_unit_y1=tempo->y;
|
||||
launch_unit_x2=ipx-main_task->win_pixel_left-main_task->win_scroll_x;
|
||||
launch_unit_y2=ipy-main_task->win_pixel_top -main_task->win_scroll_y;
|
||||
launch_t=tP(main_task)+0.5;
|
||||
}
|
||||
if (tempo->squadron>=0) {
|
||||
temps=&squadrons[tempo->squadron];
|
||||
if (temps->action==SA_PARKED) {
|
||||
temps->action=SA_LAUNCHING;
|
||||
temps->é=tempo->é+tempo->dé;
|
||||
}
|
||||
return temps;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
Obj *ObjReturn(I64 player,F64 x,F64 y)
|
||||
{
|
||||
Obj *tempo;
|
||||
if (tempo=ObjFind(x,y,OF_ACTIVE,OF_ACTIVE,1<<OT_FIGHTER,1<<player))
|
||||
tempo->flags|=OF_RETURNING;
|
||||
return tempo;
|
||||
}
|
||||
|
||||
Squadron *SquadronReturn(I64 player,F64 x,F64 y)
|
||||
{
|
||||
Squadron *temps;
|
||||
Obj *tempo;
|
||||
if (tempo=ObjReturn(player,x,y)) {
|
||||
if (player==0) {
|
||||
return_unit_x1=tempo->x;
|
||||
return_unit_y1=tempo->y;
|
||||
if (tempo->host) {
|
||||
return_unit_x2=tempo->host->x;
|
||||
return_unit_y2=tempo->host->y;
|
||||
return_t=tP(main_task)+0.5;
|
||||
}
|
||||
}
|
||||
if (tempo->squadron>=0) {
|
||||
temps=&squadrons[tempo->squadron];
|
||||
if (temps->action==SA_FLYING)
|
||||
temps->action=SA_RETURNING;
|
||||
return temps;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Obj *ObjSeté(I64 player,F64 x=MAX_F64,F64 y=MAX_F64,F64 é=MAX_F64)
|
||||
{
|
||||
Obj *tempo;
|
||||
if ((tempo=ObjFind(x,y,,,,1<<player)) && tempo->flags&OF_ACTIVE && !(tempo->flags&OF_RETURNING)) {
|
||||
if (é==MAX_F64)
|
||||
é=Arg(x-tempo->x,y-tempo->y);
|
||||
tempo->dé+=Wrap(é-(tempo->é+tempo->dé),-ã);
|
||||
return tempo;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Squadron *SquadronSeté(I64 player,F64 x=MAX_F64,F64 y=MAX_F64,F64 é=MAX_F64)
|
||||
{
|
||||
Squadron *temps;
|
||||
Obj *tempo;
|
||||
if (tempo=ObjSeté(player,x,y,é)) {
|
||||
if (player==0) {
|
||||
set_é_unit_x1=tempo->x;
|
||||
set_é_unit_y1=tempo->y;
|
||||
set_é_unit_x2=ipx-main_task->win_pixel_left-main_task->win_scroll_x;
|
||||
set_é_unit_y2=ipy-main_task->win_pixel_top -main_task->win_scroll_y;
|
||||
set_é_t=tP(main_task)+0.5;
|
||||
}
|
||||
if (tempo->squadron>=0) {
|
||||
temps=&squadrons[tempo->squadron];
|
||||
if (temps->action==SA_FLYING) {
|
||||
temps->action=SA_SET_é;
|
||||
temps->é=tempo->é+tempo->dé;
|
||||
}
|
||||
return temps;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
U0 SquadronActions()
|
||||
{
|
||||
I64 i,completed_mask;
|
||||
Obj *tempo;
|
||||
Squadron *temps;
|
||||
for (i=0,temps=squadrons;i<num_squadrons;i++,temps++) {
|
||||
completed_mask=0;
|
||||
switch (temps->action) {
|
||||
case SA_LAUNCHING:
|
||||
ObjLaunch(temps->player,i,temps->host,,,temps->é);
|
||||
tempo=temps->next_in_squadron;
|
||||
while (tempo!=temps) {
|
||||
LBEqu(&completed_mask,tempo->member_num,tempo->flags&OF_ACTIVE);
|
||||
tempo=tempo->next_in_squadron;
|
||||
}
|
||||
if (completed_mask|temps->dead_mask==temps->total_mask)
|
||||
temps->action=SA_FLYING;
|
||||
break;
|
||||
case SA_FLYING:
|
||||
tempo=temps->next_in_squadron;
|
||||
while (tempo!=temps) {
|
||||
LBEqu(&completed_mask,tempo->member_num,!(tempo->flags&OF_ACTIVE));
|
||||
tempo=tempo->next_in_squadron;
|
||||
}
|
||||
if (completed_mask|temps->dead_mask==temps->total_mask)
|
||||
temps->action=SA_PARKED;
|
||||
break;
|
||||
case SA_SET_é:
|
||||
tempo=temps->next_in_squadron;
|
||||
while (tempo!=temps) {
|
||||
tempo->dé+=Wrap(temps->é-(tempo->é+tempo->dé),-ã);
|
||||
tempo=tempo->next_in_squadron;
|
||||
}
|
||||
temps->action=SA_FLYING;
|
||||
break;
|
||||
case SA_RETURNING:
|
||||
tempo=temps->next_in_squadron;
|
||||
while (tempo!=temps) {
|
||||
tempo->flags|=OF_RETURNING;
|
||||
LBEqu(&completed_mask,tempo->member_num,!(tempo->flags&OF_ACTIVE));
|
||||
tempo=tempo->next_in_squadron;
|
||||
}
|
||||
if (completed_mask|temps->dead_mask==temps->total_mask)
|
||||
temps->action=SA_PARKED;
|
||||
break;
|
||||
}
|
||||
if (temps->dead_mask==temps->total_mask)
|
||||
temps->action=SA_DEAD;
|
||||
}
|
||||
}
|
||||
|
||||
U0 AI(I64 player,F64 period)
|
||||
{
|
||||
Obj *tempo;
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->player==player) {
|
||||
if (tempo->type==OT_CARRIER && Rand<5*period)
|
||||
SquadronLaunch(player,tempo->x,tempo->y);
|
||||
if (tempo->flags&OF_ACTIVE && !(tempo->flags&OF_RETURNING) && Rand<10.0*period)
|
||||
SquadronSeté(player,tempo->x,tempo->y,tempo->é+pi/2*(Rand-0.5));
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
}
|
||||
|
||||
U0 Combat(F64 period)
|
||||
{
|
||||
F64 d;
|
||||
Obj *tempo,*tempo1;
|
||||
Torpedo *tempt;
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
tempo->flags&=~OF_SHOOTING;
|
||||
if (tempo->flags&OF_ACTIVE &&
|
||||
(tempo1=ObjFind(tempo->x,tempo->y,OF_ACTIVE,OF_ACTIVE,,1<<(tempo->player^1),&d))) {
|
||||
tempo->target_x=tempo1->x;
|
||||
tempo->target_y=tempo1->y;
|
||||
if (tempo1->flags&OF_SHIP) {
|
||||
if (tempo->torpedos && d<tempo->torpedos_range && Rand<125*period) {
|
||||
tempo->torpedos--;
|
||||
tempt=CAlloc(sizeof(Torpedo));
|
||||
tempt->x=tempo->x;
|
||||
tempt->y=tempo->y;
|
||||
tempt->speed=100;
|
||||
d/=tempt->speed*(GAME_SPEED_SCALE*game_speed);
|
||||
tempo1->death_time=tempt->timeout=tP(main_task)+d;
|
||||
tempt->target=tempo1;
|
||||
tempt->é=Arg(tempo1->x-tempo->x,tempo1->y-tempo->y);
|
||||
QueIns(tempt,torpedo_root.last);
|
||||
Sweep(2000,2000,300);
|
||||
} else if (tempo->ship_guns>0 && d<tempo->ship_guns_range) {
|
||||
tempo->flags|=OF_SHOOTING;
|
||||
if (Rand<125.0*period) {
|
||||
tempo1->life_percent-=tempo->ship_guns*Rand*period;
|
||||
if (Rand<10.0*period)
|
||||
tempo1->fuel*=0.75*Rand+0.25;
|
||||
}
|
||||
Noise(100,75,200);
|
||||
}
|
||||
} else {
|
||||
if (tempo->air_guns>0 && d<tempo->air_guns_range) {
|
||||
tempo->flags|=OF_SHOOTING;
|
||||
if (Rand<125.0*period) {
|
||||
tempo1->life_percent-=tempo->air_guns*Rand*period;
|
||||
if (Rand<10.0*period)
|
||||
tempo1->fuel*=0.75*Rand+0.25;
|
||||
}
|
||||
Noise(25,500,2000);
|
||||
}
|
||||
}
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
tempo1=tempo->next;
|
||||
if (tempo->type==OT_FIGHTER &&
|
||||
(tempo->life_percent<=0.0 || tempo->flags&OF_ACTIVE && tempo->fuel<=0.0 ||
|
||||
tempo->host && !(tempo->flags&OF_ACTIVE) && tempo->host->life_percent<=0.0))
|
||||
ObjDel(tempo);
|
||||
tempo=tempo1;
|
||||
}
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
tempo1=tempo->next;
|
||||
if (tempo->life_percent<=0.0)
|
||||
ObjDel(tempo);
|
||||
tempo=tempo1;
|
||||
}
|
||||
}
|
||||
|
||||
#define ANIMATE_FREQ 50
|
||||
U0 AnimateTask(I64)
|
||||
{ //Preemption is off after Spawn
|
||||
Obj *tempo;
|
||||
Torpedo *tempt,*tempt1;
|
||||
F64 d,period;
|
||||
|
||||
while (TRUE) {
|
||||
period=GAME_SPEED_SCALE*game_speed/ANIMATE_FREQ;
|
||||
SquadronActions;
|
||||
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->flags&OF_ACTIVE && tempo->fuel>0) {
|
||||
if (tempo->dé) {
|
||||
d=tempo->dé;
|
||||
if (d> tempo->turn_rate*period) d= tempo->turn_rate*period;
|
||||
if (d<-tempo->turn_rate*period) d=-tempo->turn_rate*period;
|
||||
tempo->é +=d;
|
||||
tempo->dé-=d;
|
||||
}
|
||||
tempo->x+=tempo->speed*Cos(tempo->é)*period*tempo->life_percent/100.0;
|
||||
tempo->y+=tempo->speed*Sin(tempo->é)*period*tempo->life_percent/100.0;
|
||||
tempo->fuel-=tempo->speed*tempo->fuel_burn_rate*period;
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
|
||||
tempt=torpedo_root.next;
|
||||
while (tempt!=&torpedo_root) {
|
||||
tempt1=tempt->next;
|
||||
if (tP(main_task)>tempt->timeout) {
|
||||
tempo=tempt->target;
|
||||
if (Rand<0.333333) {
|
||||
tempo->life_percent-=150*Rand*Rand;
|
||||
if (Rand<0.333333)
|
||||
tempo->fuel*=0.75*Rand+0.25;
|
||||
}
|
||||
QueRem(tempt);
|
||||
Free(tempt);
|
||||
} else {
|
||||
tempt->x+=tempt->speed*Cos(tempt->é)*period;
|
||||
tempt->y+=tempt->speed*Sin(tempt->é)*period;
|
||||
}
|
||||
tempt=tempt1;
|
||||
}
|
||||
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->host && !(tempo->flags&OF_ACTIVE)) {
|
||||
tempo->x=tempo->host->x;
|
||||
tempo->y=tempo->host->y;
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
|
||||
tempo=obj_root.next;
|
||||
while (tempo!=&obj_root) {
|
||||
if (tempo->flags&OF_ACTIVE) {
|
||||
if (tempo->host) {
|
||||
d=Sqrt(Sqr(tempo->x-tempo->host->x)+Sqr(tempo->y-tempo->host->y));
|
||||
if (d<8 && tempo->max_fuel-tempo->fuel>30) {
|
||||
tempo->life_percent=100.0;
|
||||
if (tempo->host->fuel>0) {
|
||||
d=tempo->max_fuel-tempo->fuel;
|
||||
if (d>tempo->host->fuel) d=tempo->host->fuel;
|
||||
tempo->host->fuel-=d;
|
||||
tempo->fuel+=d;
|
||||
}
|
||||
tempo->torpedos=tempo->max_torpedos;
|
||||
tempo->x=tempo->host->x;
|
||||
tempo->y=tempo->host->y;
|
||||
tempo->flags&=~OF_ACTIVE;
|
||||
} else if (d>tempo->fuel-250)
|
||||
tempo->flags|=OF_RETURNING;
|
||||
if (tempo->flags&OF_RETURNING)
|
||||
tempo->dé+=Wrap(Arg(tempo->host->x-tempo->x,tempo->host->y-tempo->y)-(tempo->é+tempo->dé),-ã);
|
||||
} else if (tempo->type==OT_CARRIER)
|
||||
tempo->life_percent=Min(100.0,tempo->life_percent+2.5*period);
|
||||
}
|
||||
tempo=tempo->next;
|
||||
}
|
||||
|
||||
AI(1,period);
|
||||
Combat(period);
|
||||
Sleep(1000/ANIMATE_FREQ);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
U0 Navy()
|
||||
{
|
||||
I64 p1,p2;
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
PopUpOk("$$FG,GREEN$${Left-Mouse}$$FG$$\t\tChange Course\n"
|
||||
"$$FG,GREEN$${Right-Mouse}$$FG$$\t\tLaunch Squadron\n"
|
||||
"$$FG,GREEN$${Right-Double-Mouse}$$FG$$\tReturn Squadron\n"
|
||||
"$$FG,GREEN$${Ctrl-Left Grab}$$FG$$\tScroll Screen\n");
|
||||
Preempt(OFF),
|
||||
WinBorder;
|
||||
WordStat;
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" Faster(,'+');"
|
||||
" Slower(,'-');"
|
||||
"}"
|
||||
);
|
||||
WinMax;
|
||||
Fs->win_inhibit|=WIF_IP_L|WIF_IP_R;
|
||||
Init;
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",Fs);
|
||||
try {
|
||||
while (TRUE)
|
||||
switch(GetMsg(&p1,&p2,1<<MSG_KEY_DOWN|1<<MSG_IP_L_UP|1<<MSG_IP_R_UP|1<<MSG_IP_R_D_UP)) {
|
||||
case MSG_KEY_DOWN:
|
||||
switch (p1) {
|
||||
case CH_NEW_LINE:
|
||||
CleanUp;
|
||||
Init;
|
||||
break;
|
||||
case CH_ESC:
|
||||
case CH_SHIFT_ESC:
|
||||
goto nv_done;
|
||||
case '+':
|
||||
game_speed*=1.5;
|
||||
break;
|
||||
case '-':
|
||||
game_speed/=1.5;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case MSG_IP_L_UP:
|
||||
SquadronSeté(0,p1,p2);
|
||||
break;
|
||||
case MSG_IP_R_UP:
|
||||
SquadronLaunch(0,p1,p2);
|
||||
break;
|
||||
case MSG_IP_R_D_UP:
|
||||
SquadronReturn(0,p1,p2);
|
||||
break;
|
||||
}
|
||||
nv_done:
|
||||
GetMsg(,,1<<MSG_KEY_UP);
|
||||
} catch
|
||||
CatchAll;
|
||||
MenuPop;
|
||||
SettingsPop;
|
||||
CleanUp;
|
||||
}
|
||||
|
||||
Navy;
|
||||
r & úÿÿÿéÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿ ÿÿÿ ÿÿ ÿ ÿ ÿ ÿ ÿ ÿ ÿÿ ÿÿ ÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿ r & úÿÿÿéÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿ ÿÿÿ ÿÿ␍ ␍␍ÿ ␍␍ÿ ␍␍ÿ ␍␍ÿ ␍␍ÿ ␍ÿ ␍ÿÿ ÿÿ ÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿ b % üÿÿÿìÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿ ÿÿÿ ÿ ÿÿ ÿ ÿÿ ÿÿ ÿ ÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ b % üÿÿÿìÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿ ÿÿÿ ÿ␍␍ÿÿ ÿ␍␍ÿÿ ÿÿ ␍␍ ␍␍ÿ ÿÿ ÿÿÿ ÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ 0 þÿÿÿ ÿÿÿÿ 0 þÿÿÿ ÿÿÿÿ ␍
|
||||
@@ -0,0 +1,192 @@
|
||||
I64 sc_1,sc_2;
|
||||
|
||||
#define NUM_DROPS 0x2000
|
||||
|
||||
class Drop
|
||||
{
|
||||
I32 x,y;
|
||||
} drops[NUM_DROPS];
|
||||
|
||||
|
||||
CDC *cur_dc;
|
||||
|
||||
U0 DrawFrame(CTask *task,CDC *dc)
|
||||
{
|
||||
I64 w=task->win_pixel_width,h=task->win_pixel_height,
|
||||
cx=w>>1,cy=h>>1;
|
||||
|
||||
dc->color=LTRED;
|
||||
GrLine(dc,cx-20,cy-50,cx,cy-150);
|
||||
GrLine(dc,cx+20,cy-50,cx,cy-150);
|
||||
|
||||
dc->color=LTRED;
|
||||
GrLine(dc,cx-100,cy-100,cx,cy);
|
||||
GrLine(dc,cx+100,cy-100,cx,cy);
|
||||
if (Bt(key_down_bitmap,sc_1)) {
|
||||
dc->color=WHITE;
|
||||
GrRect(dc,cx-2,cy-2,5,5);
|
||||
}
|
||||
dc->color=BLACK;
|
||||
GrPutS(dc,cx+10,cy,"Press '1'");
|
||||
|
||||
dc->color=LTRED;
|
||||
GrRect(dc,cx-20,cy+60,41,21);
|
||||
|
||||
dc->color=LTRED;
|
||||
GrLine(dc,cx-200,cy,cx,cy+100);
|
||||
GrLine(dc,cx+200,cy,cx,cy+100);
|
||||
if (Bt(key_down_bitmap,sc_2)) {
|
||||
dc->color=WHITE;
|
||||
GrRect(dc,cx-2,cy+100-2,5,5);
|
||||
}
|
||||
dc->color=BLACK;
|
||||
GrPutS(dc,cx+10,cy+100,"Press '2'");
|
||||
|
||||
dc->color=LTRED;
|
||||
GrLine(dc,cx+400,cy+100,cx-250,cy+200);
|
||||
}
|
||||
|
||||
U0 DrawDrops(CTask *,CDC *dc)
|
||||
{
|
||||
I64 i;
|
||||
dc->color=BLUE;
|
||||
for (i=0;i<NUM_DROPS;i++)
|
||||
if (drops[i].y>=0 && GrPeek(dc,drops[i].x,drops[i].y)==WHITE)
|
||||
GrPlot(dc,drops[i].x,drops[i].y);
|
||||
}
|
||||
|
||||
U0 UpdateCurBase(CTask *task,CDC *dc)
|
||||
{
|
||||
Bool old_preempt=Preempt(OFF);
|
||||
cur_dc->color=ROP_EQU;
|
||||
dc->flags|=DCF_NO_TRANSPARENTS;
|
||||
GrBlot(cur_dc,-task->win_pixel_left-task->win_scroll_x,-task->win_pixel_top-task->win_scroll_y,dc);
|
||||
dc->flags&=~DCF_NO_TRANSPARENTS;
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
DrawFrame(task,dc);
|
||||
DrawDrops(task,dc);
|
||||
UpdateCurBase(task,dc);
|
||||
}
|
||||
|
||||
|
||||
U0 AnimateTask(I64)
|
||||
{
|
||||
I64 i,j,cur_drop=0,c1,c2,x0,y0,x1,y1,w,h;
|
||||
while (TRUE) {
|
||||
w=Fs->parent_task->win_pixel_width;
|
||||
h=Fs->parent_task->win_pixel_height;
|
||||
|
||||
for (i=0;i<2;i++) {
|
||||
j=0;
|
||||
do {
|
||||
if (++cur_drop>=NUM_DROPS)
|
||||
cur_drop=0;
|
||||
if (drops[cur_drop].y<0)
|
||||
break;
|
||||
j++;
|
||||
} while (j<=NUM_DROPS);
|
||||
|
||||
drops[cur_drop].x=RandU32%w;
|
||||
drops[cur_drop].y=0;
|
||||
}
|
||||
|
||||
for (i=0;i<NUM_DROPS;i++) {
|
||||
if (drops[i].y>=0) {
|
||||
if (drops[i].y>=h-1)
|
||||
drops[i].y=-MAX_I32;
|
||||
else {
|
||||
x0=x1=drops[i].x;
|
||||
y0=y1=drops[i].y;
|
||||
if (GrPeek(cur_dc,x0,y0+1)==WHITE)
|
||||
y1++;
|
||||
else {
|
||||
c1=GrPeek(cur_dc,x0+1,y0);
|
||||
c2=GrPeek(cur_dc,x0-1,y0);
|
||||
if (c1==WHITE && c2!=WHITE)
|
||||
x1++;
|
||||
else if (c2==WHITE && c1!=WHITE)
|
||||
x1--;
|
||||
else if (c1==WHITE && c2==WHITE) {
|
||||
c1=GrPeek(cur_dc,x0+1,y0+1);
|
||||
c2=GrPeek(cur_dc,x0-1,y0+1);
|
||||
if (c1==WHITE && c2!=WHITE)
|
||||
x1++;
|
||||
else if (c2==WHITE && c1!=WHITE)
|
||||
x1--;
|
||||
else if (RandI16>=0)
|
||||
x1++;
|
||||
else
|
||||
x1--;
|
||||
}
|
||||
if (GrPeek(cur_dc,x1,y1+1)==WHITE)
|
||||
y1++;
|
||||
}
|
||||
if (GrPeek(cur_dc,x0,y0)==BLUE) {
|
||||
cur_dc->color=WHITE;
|
||||
GrPlot(cur_dc,x0,y0);
|
||||
}
|
||||
cur_dc->color=BLUE;
|
||||
GrPlot(cur_dc,x1,y1);
|
||||
drops[i].x=x1;
|
||||
drops[i].y=y1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Sleep(10);
|
||||
}
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i;
|
||||
MemSet(drops,0,sizeof(drops));
|
||||
for (i=0;i<NUM_DROPS;i++)
|
||||
drops[i].y=-MAX_I32;
|
||||
}
|
||||
|
||||
U0 RainDrops()
|
||||
{
|
||||
I64 ch,sc;
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" OpenUpper(,'1');"
|
||||
" OpenLower(,'2');"
|
||||
"}"
|
||||
);
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
WinMax;
|
||||
cur_dc=DCNew(DCT_COLOR8,GR_WIDTH,GR_HEIGHT);
|
||||
sc_1=A2ScanCode('1');
|
||||
sc_2=A2ScanCode('2');
|
||||
Init;
|
||||
Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",Fs);
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
WordStat;
|
||||
try {
|
||||
do {
|
||||
ch=GetKey(&sc);
|
||||
switch (ch) {
|
||||
case CH_NEW_LINE:
|
||||
Init;
|
||||
break;
|
||||
}
|
||||
} while (ch!=CH_ESC && ch!=CH_SHIFT_ESC);
|
||||
} catch
|
||||
CatchAll;
|
||||
SettingsPop;
|
||||
MenuPop;
|
||||
DCDel(cur_dc);
|
||||
}
|
||||
|
||||
RainDrops;
|
||||
@@ -0,0 +1,522 @@
|
||||
//This uses $LK,"fixed-point","FI:::/SparrowOS/Demo/Lectures/FixedPoint.CPP.Z"$.
|
||||
|
||||
AcctRegSetDftEntry("SparrowOS/RawHide","F64 best_score=9999;\n");
|
||||
AcctRegExecuteBranch("SparrowOS/RawHide");
|
||||
|
||||
F64 t0,tf;
|
||||
|
||||
#define MAP_WIDTH 1500
|
||||
#define MAP_HEIGHT 1500
|
||||
#define MAP_BORDER 3
|
||||
CDC *dc2;
|
||||
|
||||
$BG,10$
|
||||
#define GE_COW 0
|
||||
|
||||
|
||||
$SP,"<1>",1$
|
||||
#define GE_BULL 1
|
||||
|
||||
|
||||
$SP,"<2>",2$
|
||||
#define GE_HORSE 2
|
||||
|
||||
|
||||
$SP,"<3>",3$
|
||||
#define GE_NUM 3
|
||||
$BG$
|
||||
|
||||
|
||||
class RHCSprite
|
||||
{
|
||||
U8 *img;
|
||||
I64 min_x,max_x,min_y,max_y;
|
||||
} rh_sprite[GE_NUM];
|
||||
|
||||
|
||||
|
||||
#define NUM_ANIMALS 128
|
||||
|
||||
class Animal
|
||||
{
|
||||
I64 num,x,y,dx,dy;
|
||||
RHCSprite *ge;
|
||||
U32 buddy;
|
||||
U8 type;
|
||||
Bool dead,pad[2];
|
||||
} *a;
|
||||
|
||||
|
||||
// ************************************
|
||||
#define COURSE_LEN (MAP_HEIGHT*2)
|
||||
I32 *rx,*ry,*rw;
|
||||
I64 river_lo,river_hi;
|
||||
U0 RiverNew()
|
||||
{
|
||||
rx=MAlloc(COURSE_LEN*sizeof(I32));
|
||||
ry=MAlloc(COURSE_LEN*sizeof(I32));
|
||||
rw=MAlloc(COURSE_LEN*sizeof(I32));
|
||||
river_lo=river_hi=COURSE_LEN/2;
|
||||
}
|
||||
|
||||
U0 RiverMake()
|
||||
{
|
||||
I64 i,x,y,dx,dy,w,old_x,old_y;
|
||||
//Plan lower course of river
|
||||
old_x=-1;old_y=-1;
|
||||
x=MAP_WIDTH<<32/2; y=MAP_HEIGHT<<32/2;
|
||||
dx=0; dy=1<<32;
|
||||
w=20<<32;
|
||||
i=COURSE_LEN/2;
|
||||
while (y.i32[1]<MAP_HEIGHT-MAP_BORDER && i<COURSE_LEN) {
|
||||
if (old_x.i32[1]!=x.i32[1]||old_y.i32[1]!=y.i32[1]) {
|
||||
rx[i]=x.i32[1]; ry[i]=y.i32[1]; rw[i]=w.i32[1];
|
||||
river_hi=i++;
|
||||
old_x=x; old_y=y;
|
||||
}
|
||||
dx=LimitI64(dx+RandI32/64,-MAX_I32,MAX_I32);
|
||||
dy=LimitI64(dy+RandI32/64,0,MAX_I32);
|
||||
x+=dx; y+=dy;
|
||||
w=LimitI64(w+RandI32*2,10*MAX_U32,150*MAX_U32);
|
||||
}
|
||||
//Plan upper course of river
|
||||
old_x=-1;old_y=-1;
|
||||
x=MAP_WIDTH<<32/2; y=MAP_HEIGHT<<32/2;
|
||||
dx=0; dy=-1<<32;
|
||||
w=20<<32;
|
||||
i=COURSE_LEN/2-1;
|
||||
while (y.i32[1]>=MAP_BORDER && i>=0) {
|
||||
if (old_x.i32[1]!=x.i32[1]||old_y.i32[1]!=y.i32[1]) {
|
||||
rx[i]=x.i32[1]; ry[i]=y.i32[1]; rw[i]=w.i32[1];
|
||||
river_lo=i--;
|
||||
old_x=x; old_y=y;
|
||||
}
|
||||
dx=LimitI64(dx+RandI32/64,-MAX_I32,MAX_I32);
|
||||
dy=LimitI64(dy+RandI32/64,-MAX_I32,0);
|
||||
x+=dx; y+=dy;
|
||||
w=LimitI64(w+RandI32*2,10*MAX_U32,150*MAX_U32);
|
||||
}
|
||||
|
||||
//Plot sand bar
|
||||
x=0; y=0;
|
||||
for (i=river_lo;i<=river_hi;i++) {
|
||||
dc2->color=YELLOW;
|
||||
dc2->pen_width=rw[i]+5;
|
||||
GrPlot3(dc2,rx[i]+x.i32[1],ry[i]+y.i32[1],0);
|
||||
|
||||
x=LimitI64(x+RandI32,-6*MAX_U32,6*MAX_U32);
|
||||
y=LimitI64(y+RandI32,-6*MAX_U32,6*MAX_U32);
|
||||
}
|
||||
|
||||
//Plot water
|
||||
for (i=river_lo;i<=river_hi;i++) {
|
||||
dc2->color=BLUE;
|
||||
dc2->pen_width=rw[i];
|
||||
GrPlot3(dc2,rx[i],ry[i],0);
|
||||
}
|
||||
}
|
||||
|
||||
U0 RiverDel()
|
||||
{
|
||||
Free(rx);
|
||||
Free(ry);
|
||||
Free(rw);
|
||||
}
|
||||
|
||||
|
||||
// ************************************
|
||||
class RiverDrop
|
||||
{
|
||||
RiverDrop *next,*last;
|
||||
I64 index,dx,dy;
|
||||
} rd_root;
|
||||
Bool rd_lock;
|
||||
|
||||
U0 RiverDropsDel()
|
||||
{
|
||||
while (LBts(&rd_lock,0))
|
||||
Yield;
|
||||
QueDel(&rd_root,TRUE);
|
||||
QueInit(&rd_root);
|
||||
LBtr(&rd_lock,0);
|
||||
}
|
||||
|
||||
U0 RiverDropsNext(CTask *mem_task)
|
||||
{
|
||||
RiverDrop *tempr,*tempr1;
|
||||
while (LBts(&rd_lock,0))
|
||||
Yield;
|
||||
tempr=rd_root.next;
|
||||
while (tempr!=&rd_root) {
|
||||
tempr1=tempr->next;
|
||||
if (++tempr->index>river_hi) {
|
||||
QueRem(tempr);
|
||||
Free(tempr);
|
||||
} else {
|
||||
do {
|
||||
if (RandU16&1 &&
|
||||
GrPeek(dc2,rx[tempr->index]+tempr->dx,ry[tempr->index]+tempr->dy)==BLUE)
|
||||
break;
|
||||
tempr->dx=LimitI64(tempr->dx+RandU16%3-1,-rw[tempr->index]/2,rw[tempr->index]/2);
|
||||
tempr->dy=LimitI64(tempr->dy+RandU16%3-1,-rw[tempr->index]/2,rw[tempr->index]/2);
|
||||
} while (GrPeek(dc2,rx[tempr->index]+tempr->dx,ry[tempr->index]+tempr->dy)!=BLUE &&
|
||||
GrPeek(dc2,rx[tempr->index] ,ry[tempr->index]) ==BLUE); //Might be reinitializing
|
||||
}
|
||||
tempr=tempr1;
|
||||
}
|
||||
tempr=MAlloc(sizeof(RiverDrop),mem_task);
|
||||
tempr->index=river_lo;
|
||||
tempr->dx=0;
|
||||
tempr->dy=0;
|
||||
QueIns(tempr,rd_root.last);
|
||||
LBtr(&rd_lock,0);
|
||||
}
|
||||
|
||||
U0 RiverDropsDraw(CDC *dc,I64 cx,I64 cy)
|
||||
{
|
||||
RiverDrop *tempr;
|
||||
dc->color=LTBLUE;
|
||||
while (LBts(&rd_lock,0))
|
||||
Yield;
|
||||
tempr=rd_root.next;
|
||||
while (tempr!=&rd_root) {
|
||||
GrPlot(dc,rx[tempr->index]+tempr->dx-cx,ry[tempr->index]+tempr->dy-cy);
|
||||
tempr=tempr->next;
|
||||
}
|
||||
LBtr(&rd_lock,0);
|
||||
}
|
||||
|
||||
// ************************************
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
static I64 last_ipx=0;
|
||||
static Bool left=TRUE;
|
||||
F64 t;
|
||||
I64 i,
|
||||
cx=(MAP_WIDTH -task->win_pixel_width)/2,
|
||||
cy=(MAP_HEIGHT-task->win_pixel_height)/2;
|
||||
if (task->win_scroll_x+cx<0)
|
||||
task->win_scroll_x=-cx;
|
||||
if (task->win_scroll_x+cx>MAP_WIDTH-task->win_pixel_width)
|
||||
task->win_scroll_x=MAP_WIDTH-task->win_pixel_width-cx;
|
||||
if (task->win_scroll_y+cy<0)
|
||||
task->win_scroll_y=-cy;
|
||||
if (task->win_scroll_y+cy>MAP_HEIGHT-task->win_pixel_height)
|
||||
task->win_scroll_y=MAP_HEIGHT-task->win_pixel_height-cy;
|
||||
|
||||
dc2->flags|=DCF_NO_TRANSPARENTS;
|
||||
GrBlot(dc,-cx,-cy,dc2);
|
||||
|
||||
RiverDropsDraw(dc,cx,cy);
|
||||
|
||||
for (i=0;i<NUM_ANIMALS;i++)
|
||||
if (!a[i].dead) {
|
||||
if (a[i].dx<0) {
|
||||
dc->flags|=DCF_JUST_MIRROR|DCF_SYMMETRY;
|
||||
GrSetSymmetry(dc,a[i].x.i32[1]-cx,0,a[i].x.i32[1]-cx,1);
|
||||
}
|
||||
CSpritePlot3(dc,a[i].x.i32[1]-cx,a[i].y.i32[1]-cy,0,a[i].ge->img);
|
||||
dc->flags&=~(DCF_JUST_MIRROR|DCF_SYMMETRY);
|
||||
}
|
||||
|
||||
|
||||
if (ipx-last_ipx>0)
|
||||
left=FALSE;
|
||||
else if (ipx-last_ipx<0)
|
||||
left=TRUE;
|
||||
if (left) {
|
||||
dc->flags|=DCF_JUST_MIRROR|DCF_SYMMETRY;
|
||||
GrSetSymmetry(dc,ipx-task->win_pixel_left-task->win_scroll_x,0,ipx-task->win_pixel_left-task->win_scroll_x,1);
|
||||
}
|
||||
CSpritePlot3(dc,
|
||||
ipx-task->win_pixel_left-task->win_scroll_x,
|
||||
ipy-task->win_pixel_top -task->win_scroll_y,0,rh_sprite[GE_HORSE].img);
|
||||
dc->flags&=~(DCF_JUST_MIRROR|DCF_SYMMETRY);
|
||||
last_ipx=ipx;
|
||||
|
||||
if (tf) {
|
||||
dc->color=RED;
|
||||
t=tf-t0;
|
||||
if (Blink(,tP(task)))
|
||||
GrPutS(dc,(task->win_pixel_width-FONT_WIDTH*9)>>1-task->win_scroll_x,
|
||||
(task->win_pixel_height-FONT_HEIGHT)>>1-task->win_scroll_y,
|
||||
"Game Over");
|
||||
} else {
|
||||
dc->color=BLACK;
|
||||
t=tP(task)-t0;
|
||||
}
|
||||
GrPrintF(dc,-task->win_scroll_x,-task->win_scroll_y,"Time:%7.2fs Best:%7.2fs",t,best_score);
|
||||
}
|
||||
|
||||
|
||||
U0 BuddySelect(I64 i)
|
||||
{
|
||||
I64 b,best_b=i,score,best_score=MAX_I64;
|
||||
for (b=0;b<NUM_ANIMALS;b++) {
|
||||
if (b!=i && !a[b].dead) {
|
||||
score=RandU32%(512*512)+
|
||||
SqrI64(a[b].x.i32[1]-a[i].x.i32[1])+
|
||||
SqrI64(a[b].y.i32[1]-a[i].y.i32[1]);
|
||||
if (score<best_score) {
|
||||
best_score=score;
|
||||
best_b=b;
|
||||
}
|
||||
}
|
||||
}
|
||||
a[i].buddy=best_b;
|
||||
}
|
||||
|
||||
U0 AnimateTask(CTask *parent)
|
||||
{
|
||||
I64 i,cx,cy,cursor_x,cursor_y,dd,ddx,ddy,cnt,max_speed=MAX_I64,
|
||||
min_x,max_x,min_y,max_y,updates=0;
|
||||
F64 f,d,dx,dy,s,stress;
|
||||
Animal *tempa,*tempa1;
|
||||
while (TRUE) {
|
||||
max_speed=LimitU64(max_speed,MAX_U32/3,200*MAX_U32);
|
||||
cx=(MAP_WIDTH -parent->win_pixel_width)/2,
|
||||
cy=(MAP_HEIGHT-parent->win_pixel_height)/2;
|
||||
cursor_x=ipx+cx-parent->win_pixel_left-parent->win_scroll_x;
|
||||
cursor_y=ipy+cy-parent->win_pixel_top -parent->win_scroll_y;
|
||||
min_x=max_x=min_y=max_y=cnt=0;
|
||||
stress=0;
|
||||
for (i=0;i<NUM_ANIMALS;i++) {
|
||||
tempa=&a[i];
|
||||
if (!tempa->dead) {
|
||||
//Move away from horse
|
||||
ddx=tempa->x.i32[1]-cursor_x;
|
||||
ddy=tempa->y.i32[1]-cursor_y;
|
||||
if (dd=SqrI64(ddx)+SqrI64(ddy)) {
|
||||
d=Sqrt(dd);
|
||||
dx=ddx/d;
|
||||
dy=ddy/d;
|
||||
f=2.0e2*MAX_U32/dd;
|
||||
tempa->dx+=f*dx;
|
||||
tempa->dy+=f*dy;
|
||||
}
|
||||
|
||||
//Reselect buddy about every NUM_ANIMALS*10ms=5.12 seconds
|
||||
tempa1=&a[tempa->buddy];
|
||||
if (tempa1->dead || i==updates%NUM_ANIMALS) {
|
||||
BuddySelect(i);
|
||||
tempa1=&a[tempa->buddy];
|
||||
}
|
||||
|
||||
//Move toward buddy
|
||||
ddx=tempa->x.i32[1]-tempa1->x.i32[1];
|
||||
ddy=tempa->y.i32[1]-tempa1->y.i32[1];
|
||||
if (dd=SqrI64(ddx)+SqrI64(ddy)) {
|
||||
d=Sqrt(dd);
|
||||
s=d`1.25-80;
|
||||
stress+=Abs(s);
|
||||
dx=ddx/d;
|
||||
dy=ddy/d;
|
||||
f=-0.001*s*MAX_U32;
|
||||
tempa->dx+=f*dx;
|
||||
tempa->dy+=f*dy;
|
||||
}
|
||||
|
||||
//Make velocity similar to buddy
|
||||
tempa->dx+=0.1*(tempa1->dx-tempa->dx);
|
||||
tempa->dy+=0.1*(tempa1->dy-tempa->dy);
|
||||
|
||||
|
||||
//Add random movement, limit speed and dampen speed
|
||||
tempa->dx=0.995*LimitI64(tempa->dx+RandI32/32,-max_speed,max_speed);
|
||||
tempa->dy=0.995*LimitI64(tempa->dy+RandI32/32,-max_speed,max_speed);
|
||||
|
||||
//Slow in river
|
||||
if (GrPeek(dc2,tempa->x.i32[1],tempa->y.i32[1])!=LTGREEN) {
|
||||
tempa->dx/=4;
|
||||
tempa->dy/=4;
|
||||
}
|
||||
|
||||
tempa->x+=tempa->dx;
|
||||
tempa->y+=tempa->dy;
|
||||
|
||||
//Keep on map
|
||||
if (!(MAP_BORDER-tempa->ge->min_x<=tempa->x.i32[1]<MAP_WIDTH-MAP_BORDER-tempa->ge->max_x)) {
|
||||
tempa->x -=tempa->dx;
|
||||
tempa->dx=-tempa->dx;
|
||||
}
|
||||
if (!(MAP_BORDER-tempa->ge->min_y<=tempa->y.i32[1]<MAP_HEIGHT-MAP_BORDER-tempa->ge->max_y)) {
|
||||
tempa->y -=tempa->dy;
|
||||
tempa->dy=-tempa->dy;
|
||||
}
|
||||
|
||||
if (cnt) {
|
||||
min_x=MinI64(min_x,tempa->x);
|
||||
max_x=MaxI64(max_x,tempa->x);
|
||||
min_y=MinI64(min_y,tempa->y);
|
||||
max_y=MaxI64(max_y,tempa->y);
|
||||
} else {
|
||||
min_x=max_x=tempa->x;
|
||||
min_y=max_y=tempa->y;
|
||||
}
|
||||
|
||||
cnt++;
|
||||
}
|
||||
}
|
||||
if (!(updates&15))
|
||||
RiverDropsNext(parent);
|
||||
|
||||
if (!tf && (max_x-min_x)>>32<GR_WIDTH && (max_y-min_y)>>32<GR_HEIGHT) {
|
||||
tf=tP(parent);
|
||||
music_mute=TRUE;
|
||||
Snd(2000);Sleep(200);Snd(0);Sleep(100);
|
||||
if (tf-t0<best_score) {
|
||||
best_score=tf-t0;
|
||||
Snd(2000);Sleep(200);Snd(0);Sleep(100);
|
||||
}
|
||||
music_mute=FALSE;
|
||||
}
|
||||
|
||||
updates++;
|
||||
|
||||
if (cnt)
|
||||
stress/=cnt;
|
||||
else
|
||||
stress=0;
|
||||
if (stress>100.0) {
|
||||
Yield;
|
||||
max_speed=stress/5.0*MAX_U32; //Converge faster at start-up
|
||||
} else {
|
||||
Sleep(10);
|
||||
max_speed=0; //Will be set to normal max speed
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
U0 SongTask(I64)
|
||||
{ //Randomly generated (by God :-)
|
||||
Fs->task_end_cb=&SndTaskEndCB;
|
||||
MusicSettingsRst;
|
||||
while (TRUE) {
|
||||
Play("W13qC2etG!3DCBDC!!ECFqFC!sADAD!qB");
|
||||
Play("C2etG!3DCBDC!!ECFqFC!sADAD!qB");
|
||||
Play("!2sG3A!2G3A!qG2etG3GDeBBqBFeBAqE");
|
||||
Play("!2sG3A!2G3A!qG2etG3GDeBBqBFeBAqE");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
U0 ReInit()
|
||||
{
|
||||
I64 i;
|
||||
|
||||
RiverDropsDel;
|
||||
dc2->color=LTGREEN;
|
||||
GrRect(dc2,2,2,MAP_WIDTH-4,MAP_HEIGHT-4);
|
||||
|
||||
RiverMake;
|
||||
|
||||
dc2->pen_width=MAP_BORDER;
|
||||
dc2->color=RED;
|
||||
GrLineRect4(dc2,MAP_BORDER/2,MAP_BORDER/2,MAP_WIDTH-(MAP_BORDER+1)/2,MAP_HEIGHT-(MAP_BORDER+1)/2);
|
||||
|
||||
for (i=river_lo;i<=river_hi;i++)
|
||||
RiverDropsNext(Fs);
|
||||
|
||||
MemSet(a,0,NUM_ANIMALS*sizeof(Animal));
|
||||
for (i=0;i<NUM_ANIMALS;i++) {
|
||||
a[i].num=i;
|
||||
a[i].x=(64+RandU32%(MAP_WIDTH-128))<<32;
|
||||
a[i].y=(64+RandU32%(MAP_WIDTH-128))<<32;
|
||||
if (i&1)
|
||||
a[i].ge=&rh_sprite[GE_COW];
|
||||
else
|
||||
a[i].ge=&rh_sprite[GE_BULL];
|
||||
BuddySelect(i);
|
||||
}
|
||||
t0=tP;
|
||||
tf=0;
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i;
|
||||
RHCSprite *ge;
|
||||
|
||||
rh_sprite[0].img=$IB,"<1>",1$;
|
||||
rh_sprite[1].img=$IB,"<2>",2$;
|
||||
rh_sprite[2].img=$IB,"<3>",3$;
|
||||
for (i=0;i<GE_NUM;i++) {
|
||||
ge=&rh_sprite[i];
|
||||
CSpriteExtents(ge->img,&ge->min_x,&ge->max_x,&ge->min_y,&ge->max_y);
|
||||
}
|
||||
|
||||
RiverNew;
|
||||
rd_lock=0;
|
||||
QueInit(&rd_root);
|
||||
dc2=DCNew(DCT_COLOR8,MAP_WIDTH,MAP_HEIGHT);
|
||||
a=MAlloc(NUM_ANIMALS*sizeof(Animal));
|
||||
ReInit;
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
DCDel(dc2);
|
||||
Free(a);
|
||||
RiverDropsDel;
|
||||
RiverDel;
|
||||
}
|
||||
|
||||
U0 RawHide()
|
||||
{
|
||||
I64 msg_code,p1,p2;
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
PopUpOk(
|
||||
"Coral the cattle into an area\n"
|
||||
"the size of a screen.\n\n"
|
||||
"Scroll with {CTRL-Left Grab}.\n"
|
||||
"Center with {CTRL-Right}.");
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
"}"
|
||||
);
|
||||
Fs->song_task=Spawn(&SongTask,NULL,"Song",Fs);
|
||||
Fs->win_inhibit=WIF_ALL-WIF_BORDER-WIF_GRAB_SCROLL-WIF_MENU;
|
||||
WinMax;
|
||||
WordStat;
|
||||
Preempt(OFF);
|
||||
Init;
|
||||
Fs->animate_task=Spawn(&AnimateTask,Fs,"Animate",Fs);
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
try {
|
||||
while (TRUE) {
|
||||
msg_code=GetMsg(&p1,&p2,1<<MSG_KEY_DOWN+1<<MSG_IP_L_DOWN+1<<MSG_IP_R_DOWN);
|
||||
switch (msg_code) {
|
||||
case MSG_IP_L_DOWN: //Doesn't do anything, yet.
|
||||
break;
|
||||
case MSG_IP_R_DOWN: //Doesn't do anything, yet.
|
||||
break;
|
||||
case MSG_KEY_DOWN:
|
||||
switch (p1) {
|
||||
case CH_NEW_LINE:
|
||||
ReInit;
|
||||
break;
|
||||
case CH_SHIFT_ESC:
|
||||
case CH_ESC:
|
||||
goto rh_done;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
rh_done:
|
||||
} catch
|
||||
CatchAll;
|
||||
MenuPop;
|
||||
SettingsPop;
|
||||
CleanUp;
|
||||
AcctRegWriteBranch("SparrowOS/RawHide","F64 best_score=%5.4f;\n",best_score);
|
||||
}
|
||||
|
||||
RawHide;
|
||||
ò öÿÿÿðÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿ ÿÿÿÿÿ ÿÿ ÿ ÿÿ ÿÿÿÿ ÿ ÿÿÿ ÿÿ ÿÿ ÿ ÿ ÿÿÿÿÿÿÿ ÿÿ ÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ b öÿÿÿôÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿ ÿÿ ÿÿ ÿ ÿ ÿÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿÿÿÿÿ ÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ Â öÿÿÿðÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿ ÿÿ ÿÿ ÿ ÿ ÿÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿ ÿ ÿ ÿÿÿÿ ÿÿ ÿÿÿÿÿ ÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,708 @@
|
||||
$BG,0$
|
||||
$SP,"<ship_null>",1$
|
||||
|
||||
|
||||
$SP,"<ship_thrust>",2$
|
||||
|
||||
|
||||
|
||||
$SP,"<ship_null2>",3$
|
||||
|
||||
|
||||
$SP,"<ship_thrust2>",4$
|
||||
|
||||
|
||||
|
||||
$SP,"<tiny_rock>",5$
|
||||
|
||||
|
||||
$SP,"<tiny_rock2>",6$
|
||||
|
||||
|
||||
$SP,"<small_rock>",7$
|
||||
|
||||
|
||||
$SP,"<small_rock2>",8$
|
||||
|
||||
|
||||
|
||||
$SP,"<medium_rock>",9$
|
||||
|
||||
|
||||
$SP,"<medium_rock2>",10$
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<large_rock>",11$
|
||||
|
||||
|
||||
$SP,"<large_rock2>",12$
|
||||
|
||||
|
||||
$SP,"<Bullet>",13$
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<Cargo>",14$
|
||||
|
||||
|
||||
$BG$
|
||||
|
||||
|
||||
#define CMD_NULL 0
|
||||
#define CMD_SPIN_LEFT 1
|
||||
#define CMD_SPIN_RIGHT 2
|
||||
#define CMD_THRUST 3
|
||||
#define CMD_FIRE 4
|
||||
#define CMD_GAME_OVER 5
|
||||
I64 cmd_code=CMD_NULL;
|
||||
|
||||
#define NUM_STARS 100
|
||||
I64 stars_x[NUM_STARS],stars_y[NUM_STARS];
|
||||
|
||||
Bool bounce;
|
||||
|
||||
#define OT_SHIP 1
|
||||
#define OT_CARGO 2
|
||||
#define OT_BULLET 3
|
||||
#define OT_TINY_ROCK 4
|
||||
#define OT_SMALL_ROCK 5
|
||||
#define OT_MEDIUM_ROCK 6
|
||||
#define OT_LARGE_ROCK 7
|
||||
|
||||
#define A_TRANSITION -1
|
||||
#define A_INACTIVE 0
|
||||
#define A_ACTIVE 1
|
||||
|
||||
class Order2D2é
|
||||
{
|
||||
F64 x,y,é;
|
||||
F64 DxDt,DyDt,DéDt;
|
||||
};
|
||||
|
||||
class Obj
|
||||
{
|
||||
I32 active;
|
||||
I32 type;
|
||||
U8 *img;
|
||||
F64 mass,radius;
|
||||
F64 timeout;
|
||||
};
|
||||
|
||||
#define NUM_OBJECTS 256
|
||||
|
||||
CMathODE *ode;
|
||||
Order2D2é *o_state;
|
||||
Obj *objs;
|
||||
|
||||
U0 ObjInit(I64 i, I64 type)
|
||||
{
|
||||
objs[i].active=A_ACTIVE;
|
||||
objs[i].timeout=0;
|
||||
objs[i].type=type;
|
||||
switch (type) {
|
||||
case OT_SHIP:
|
||||
if (bounce)
|
||||
objs[i].img=$IB,"<ship_null>",1$;
|
||||
else
|
||||
objs[i].img=$IB,"<ship_null>",3$;
|
||||
objs[i].radius=15;
|
||||
break;
|
||||
case OT_CARGO:
|
||||
objs[i].img=$IB,"<cargo>",14$;
|
||||
objs[i].radius=30;
|
||||
break;
|
||||
case OT_BULLET:
|
||||
objs[i].img=$IB,"<bullet>",15$;
|
||||
objs[i].radius=7;
|
||||
break;
|
||||
case OT_TINY_ROCK:
|
||||
if (i&1)
|
||||
objs[i].img=$IB,"<tiny_rock>",5$;
|
||||
else
|
||||
objs[i].img=$IB,"<tiny_rock2>",6$;
|
||||
objs[i].radius=5;
|
||||
break;
|
||||
case OT_SMALL_ROCK:
|
||||
if (i&1)
|
||||
objs[i].img=$IB,"<small_rock>",16$;
|
||||
else
|
||||
objs[i].img=$IB,"<small_rock2>",8$;
|
||||
objs[i].radius=11;
|
||||
break;
|
||||
case OT_MEDIUM_ROCK:
|
||||
if (i&1)
|
||||
objs[i].img=$IB,"<medium_rock>",17$;
|
||||
else
|
||||
objs[i].img=$IB,"<medium_rock2>",10$;
|
||||
objs[i].radius=20;
|
||||
break;
|
||||
case OT_LARGE_ROCK:
|
||||
if (i&1)
|
||||
objs[i].img=$IB,"<large_rock>",18$;
|
||||
else
|
||||
objs[i].img=$IB,"<large_rock2>",12$;
|
||||
objs[i].radius=26;
|
||||
break;
|
||||
}
|
||||
objs[i].mass=objs[i].radius*objs[i].radius*objs[i].radius;
|
||||
}
|
||||
|
||||
I64 ObjAlloc(I64 type)
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<NUM_OBJECTS-1;i++)
|
||||
if (objs[i].active==A_INACTIVE)
|
||||
break;
|
||||
ObjInit(i,type);
|
||||
return i;
|
||||
}
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
I64 i,x,y;
|
||||
|
||||
task->text_attr=BLACK<<4+WHITE;
|
||||
|
||||
dc->color=WHITE;
|
||||
for (i=0;i<NUM_STARS;i++)
|
||||
GrPlot(dc,stars_x[i],stars_y[i]);
|
||||
|
||||
for (i=0;i<NUM_OBJECTS;i++) {
|
||||
if (objs[i].active==A_ACTIVE) {
|
||||
if (objs[i].timeout && objs[i].timeout<tP(task))
|
||||
objs[i].active=A_INACTIVE;
|
||||
else {
|
||||
x=o_state[i].x;
|
||||
y=o_state[i].y;
|
||||
|
||||
if (x<0) {
|
||||
x=GR_WIDTH-AbsI64(x)%GR_WIDTH;
|
||||
o_state[i].x=x;
|
||||
} else if (x>GR_WIDTH) {
|
||||
x%=GR_WIDTH;
|
||||
o_state[i].x=x;
|
||||
}
|
||||
if (y<0) {
|
||||
y=GR_HEIGHT-AbsI64(y)%GR_HEIGHT;
|
||||
o_state[i].y=y;
|
||||
} else if (y>GR_HEIGHT) {
|
||||
y%=GR_HEIGHT;
|
||||
o_state[i].y=y;
|
||||
}
|
||||
switch (objs[i].type) {
|
||||
case OT_SHIP:
|
||||
if (bounce) {
|
||||
if (cmd_code==CMD_THRUST && RandU16&0x8000)
|
||||
CSpritePlotRotZ3b(dc,x,y,0,$IB,"<ship_thrust>",2$,o_state[i].é);
|
||||
else
|
||||
CSpritePlotRotZ3b(dc,x,y,0,$IB,"<ship_null>",1$,o_state[i].é);
|
||||
} else {
|
||||
if (cmd_code==CMD_THRUST && RandU16&0x8000)
|
||||
CSpritePlotRotZ3b(dc,x,y,0,$IB,"<ship_thrust>",4$,o_state[i].é);
|
||||
else
|
||||
CSpritePlotRotZ3b(dc,x,y,0,$IB,"<ship_null>",3$,o_state[i].é);
|
||||
}
|
||||
break;
|
||||
case OT_BULLET:
|
||||
case OT_TINY_ROCK:
|
||||
case OT_SMALL_ROCK:
|
||||
case OT_MEDIUM_ROCK:
|
||||
case OT_LARGE_ROCK:
|
||||
case OT_CARGO:
|
||||
CSpritePlotRotZ3b(dc,x,y,0,objs[i].img,o_state[i].é);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
dc->color=WHITE;
|
||||
GrPutS(dc,0,0,"Escort the cargo ship.");
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i,j;
|
||||
|
||||
cmd_code=CMD_NULL;
|
||||
|
||||
for (i=0;i<NUM_STARS;i++) {
|
||||
stars_x[i]=RandU16%GR_WIDTH;
|
||||
stars_y[i]=RandU16%GR_HEIGHT;
|
||||
}
|
||||
|
||||
MemSet(objs,0,sizeof(Obj)*NUM_OBJECTS);
|
||||
MemSet(o_state,0,sizeof(Order2D2é)*NUM_OBJECTS);
|
||||
|
||||
i=ObjAlloc(OT_SHIP); //always #0
|
||||
objs[i].mass=2.0*objs[i].radius*objs[i].radius*objs[i].radius;
|
||||
o_state[i].x=GR_WIDTH/2;
|
||||
o_state[i].y=GR_HEIGHT/2;
|
||||
|
||||
i=ObjAlloc(OT_CARGO); //always #1
|
||||
objs[i].mass=0.5*objs[i].radius*objs[i].radius*objs[i].radius;
|
||||
o_state[i].x=0;
|
||||
o_state[i].DxDt=16.0;
|
||||
o_state[i].y=GR_HEIGHT/2;
|
||||
o_state[i].é=ã/2;
|
||||
|
||||
for (j=0;j<4;j++) {
|
||||
i=ObjAlloc(OT_LARGE_ROCK);
|
||||
o_state[i].x=RandU32%GR_WIDTH;
|
||||
o_state[i].y=RandU32%GR_HEIGHT;
|
||||
o_state[i].DxDt=RandI16/2000.0;
|
||||
o_state[i].DyDt=RandI16/2000.0;
|
||||
o_state[i].DéDt=RandI16/25000.0;
|
||||
o_state[i].é=2*ã*RandI16/16384.0;
|
||||
}
|
||||
}
|
||||
|
||||
U0 MyDerivative(CMathODE *,F64,Order2D2é *state,Order2D2é *DstateDt)
|
||||
{
|
||||
I64 i,j;
|
||||
F64 f,d,d1,dd,dx,dy;
|
||||
|
||||
MemSet(DstateDt,0,sizeof(Order2D2é)*NUM_OBJECTS);
|
||||
for (i=0;i<NUM_OBJECTS;i++) {
|
||||
if (objs[i].active==A_ACTIVE) {
|
||||
DstateDt[i].x=state[i].DxDt;
|
||||
DstateDt[i].y=state[i].DyDt;
|
||||
DstateDt[i].é=state[i].DéDt;
|
||||
for (j=0;j<NUM_OBJECTS;j++) {
|
||||
if (i!=j && objs[j].active==A_ACTIVE) {
|
||||
dx=state[i].x-state[j].x;
|
||||
dy=state[i].y-state[j].y;
|
||||
dd=Sqr(dx)+Sqr(dy);
|
||||
d=Sqrt(dd);
|
||||
|
||||
if (d) {
|
||||
dx/=d;
|
||||
dy/=d;
|
||||
} else {
|
||||
dx=0;
|
||||
dy=0;
|
||||
}
|
||||
|
||||
d1=objs[i].radius+objs[j].radius;
|
||||
f=0;
|
||||
if (dd<Sqr(d1)) {
|
||||
if (bounce && objs[i].type!=OT_CARGO && objs[j].type!=OT_CARGO) {
|
||||
f=Sqr(Sqr(Sqr(d1-Abs(d)+0.1))); //spring force
|
||||
if (f>1000000.0) f=1000000.0;
|
||||
}
|
||||
} else
|
||||
f=-2.5*objs[i].mass*objs[j].mass/(dd+1.0);
|
||||
|
||||
DstateDt[i].DxDt+=f*dx/objs[i].mass;
|
||||
DstateDt[i].DyDt+=f*dy/objs[i].mass;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
switch (cmd_code) {
|
||||
case CMD_SPIN_LEFT:
|
||||
DstateDt[0].DéDt-=10.0;
|
||||
break;
|
||||
case CMD_SPIN_RIGHT:
|
||||
DstateDt[0].DéDt+=10.0;
|
||||
break;
|
||||
case CMD_THRUST:
|
||||
DstateDt[0].DxDt+=100.0*Cos(state[0].é-ã/2.0);
|
||||
DstateDt[0].DyDt+=100.0*Sin(state[0].é-ã/2.0);
|
||||
break;
|
||||
}
|
||||
|
||||
DstateDt[1].DxDt+=2.0*Cos(state[1].é-ã/2.0);
|
||||
DstateDt[1].DyDt+=2.0*Sin(state[1].é-ã/2.0);
|
||||
}
|
||||
|
||||
U0 Collision(I64 i,I64 j)
|
||||
{
|
||||
I64 i2;
|
||||
switch (objs[i].type) {
|
||||
case OT_SHIP:
|
||||
if (!bounce) {
|
||||
cmd_code=CMD_GAME_OVER;
|
||||
objs[i].active=A_INACTIVE;
|
||||
}
|
||||
break;
|
||||
case OT_CARGO:
|
||||
cmd_code=CMD_GAME_OVER;
|
||||
objs[i].active=A_INACTIVE;
|
||||
break;
|
||||
case OT_TINY_ROCK:
|
||||
if (objs[j].type==OT_BULLET && !bounce)
|
||||
objs[i].active=A_INACTIVE;
|
||||
break;
|
||||
case OT_BULLET:
|
||||
if (!bounce)
|
||||
objs[i].active=A_INACTIVE;
|
||||
break;
|
||||
case OT_SMALL_ROCK:
|
||||
case OT_MEDIUM_ROCK:
|
||||
i2=ObjAlloc(objs[i].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[i].x+objs[i2].radius+2.0;
|
||||
o_state[i2].y=o_state[i].y;
|
||||
o_state[i2].é=o_state[i].é;
|
||||
o_state[i2].DxDt=o_state[i].DxDt;
|
||||
o_state[i2].DyDt=o_state[i].DyDt;
|
||||
o_state[i2].DéDt=o_state[i].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[i].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[i].x-objs[i2].radius-2.0;
|
||||
o_state[i2].y=o_state[i].y;
|
||||
o_state[i2].é=o_state[i].é;
|
||||
o_state[i2].DxDt=o_state[i].DxDt;
|
||||
o_state[i2].DyDt=o_state[i].DyDt;
|
||||
o_state[i2].DéDt=o_state[i].DéDt;
|
||||
|
||||
objs[i].active=A_INACTIVE;
|
||||
break;
|
||||
case OT_LARGE_ROCK:
|
||||
i2=ObjAlloc(objs[i].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[i].x+objs[i2].radius+4.0;
|
||||
o_state[i2].y=o_state[i].y+objs[i2].radius+4.0;
|
||||
o_state[i2].é=o_state[i].é;
|
||||
o_state[i2].DxDt=o_state[i].DxDt;
|
||||
o_state[i2].DyDt=o_state[i].DyDt;
|
||||
o_state[i2].DéDt=o_state[i].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[i].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[i].x-objs[i2].radius-4.0;
|
||||
o_state[i2].y=o_state[i].y-objs[i2].radius-4.0;
|
||||
o_state[i2].é=o_state[i].é;
|
||||
o_state[i2].DxDt=o_state[i].DxDt;
|
||||
o_state[i2].DyDt=o_state[i].DyDt;
|
||||
o_state[i2].DéDt=o_state[i].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[i].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[i].x-objs[i2].radius-4.0;
|
||||
o_state[i2].y=o_state[i].y+objs[i2].radius+4.0;
|
||||
o_state[i2].é=o_state[i].é;
|
||||
o_state[i2].DxDt=o_state[i].DxDt;
|
||||
o_state[i2].DyDt=o_state[i].DyDt;
|
||||
o_state[i2].DéDt=o_state[i].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[i].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[i].x+objs[i2].radius+4.0;
|
||||
o_state[i2].y=o_state[i].y-objs[i2].radius-4.0;
|
||||
o_state[i2].é=o_state[i].é;
|
||||
o_state[i2].DxDt=o_state[i].DxDt;
|
||||
o_state[i2].DyDt=o_state[i].DyDt;
|
||||
o_state[i2].DéDt=o_state[i].DéDt;
|
||||
|
||||
objs[i].active=A_INACTIVE;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (objs[j].type) {
|
||||
case OT_SHIP:
|
||||
if (!bounce) {
|
||||
cmd_code=CMD_GAME_OVER;
|
||||
objs[j].active=A_INACTIVE;
|
||||
}
|
||||
break;
|
||||
case OT_CARGO:
|
||||
cmd_code=CMD_GAME_OVER;
|
||||
objs[j].active=A_INACTIVE;
|
||||
break;
|
||||
case OT_TINY_ROCK:
|
||||
if (objs[i].type==OT_BULLET && !bounce)
|
||||
objs[j].active=A_INACTIVE;
|
||||
break;
|
||||
case OT_BULLET:
|
||||
if (!bounce)
|
||||
objs[j].active=A_INACTIVE;
|
||||
break;
|
||||
case OT_SMALL_ROCK:
|
||||
case OT_MEDIUM_ROCK:
|
||||
i2=ObjAlloc(objs[j].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[j].x+objs[i2].radius+2.0;
|
||||
o_state[i2].y=o_state[j].y;
|
||||
o_state[i2].é=o_state[j].é;
|
||||
o_state[i2].DxDt=o_state[j].DxDt;
|
||||
o_state[i2].DyDt=o_state[j].DyDt;
|
||||
o_state[i2].DéDt=o_state[j].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[j].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[j].x-objs[i2].radius-2.0;
|
||||
o_state[i2].y=o_state[j].y;
|
||||
o_state[i2].é=o_state[j].é;
|
||||
o_state[i2].DxDt=o_state[j].DxDt;
|
||||
o_state[i2].DyDt=o_state[j].DyDt;
|
||||
o_state[i2].DéDt=o_state[j].DéDt;
|
||||
|
||||
objs[j].active=A_INACTIVE;
|
||||
break;
|
||||
|
||||
case OT_LARGE_ROCK:
|
||||
i2=ObjAlloc(objs[j].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[j].x+objs[i2].radius+4.0;
|
||||
o_state[i2].y=o_state[j].y+objs[i2].radius+4.0;
|
||||
o_state[i2].é=o_state[j].é;
|
||||
o_state[i2].DxDt=o_state[j].DxDt;
|
||||
o_state[i2].DyDt=o_state[j].DyDt;
|
||||
o_state[i2].DéDt=o_state[j].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[j].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[j].x-objs[i2].radius-4.0;
|
||||
o_state[i2].y=o_state[j].y-objs[i2].radius-4.0;
|
||||
o_state[i2].é=o_state[j].é;
|
||||
o_state[i2].DxDt=o_state[j].DxDt;
|
||||
o_state[i2].DyDt=o_state[j].DyDt;
|
||||
o_state[i2].DéDt=o_state[j].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[j].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[j].x-objs[i2].radius-4.0;
|
||||
o_state[i2].y=o_state[j].y+objs[i2].radius+4.0;
|
||||
o_state[i2].é=o_state[j].é;
|
||||
o_state[i2].DxDt=o_state[j].DxDt;
|
||||
o_state[i2].DyDt=o_state[j].DyDt;
|
||||
o_state[i2].DéDt=o_state[j].DéDt;
|
||||
|
||||
i2=ObjAlloc(objs[j].type-1);
|
||||
objs[i2].active=A_TRANSITION;
|
||||
o_state[i2].x=o_state[j].x+objs[i2].radius+4.0;
|
||||
o_state[i2].y=o_state[j].y-objs[i2].radius-4.0;
|
||||
o_state[i2].é=o_state[j].é;
|
||||
o_state[i2].DxDt=o_state[j].DxDt;
|
||||
o_state[i2].DyDt=o_state[j].DyDt;
|
||||
o_state[i2].DéDt=o_state[j].DéDt;
|
||||
|
||||
objs[j].active=A_INACTIVE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
U0 CheckCollisions()
|
||||
{
|
||||
I64 i,j;
|
||||
F64 d,d1,dd,dx,dy;
|
||||
CDC *dc;
|
||||
for (i=0;i<NUM_OBJECTS;i++) {
|
||||
if (objs[i].active==A_ACTIVE) {
|
||||
for (j=i+1;j<NUM_OBJECTS;j++) {
|
||||
if (objs[j].active==A_ACTIVE) {
|
||||
dx=o_state[i].x-o_state[j].x;
|
||||
dy=o_state[i].y-o_state[j].y;
|
||||
dd=Sqr(dx)+Sqr(dy);
|
||||
d=Sqrt(dd);
|
||||
|
||||
if (d) {
|
||||
dx/=d;
|
||||
dy/=d;
|
||||
} else {
|
||||
dx=0;
|
||||
dy=0;
|
||||
}
|
||||
|
||||
d1=objs[i].radius+objs[j].radius;
|
||||
if (dd<Sqr(d1)) {
|
||||
dc=DCNew(DCT_COLOR8,64,64,Fs);
|
||||
CSpritePlotRotZ3b(dc,32,32,0,objs[i].img,o_state[i].é);
|
||||
dc->color=ROP_COLLISION;
|
||||
dc->bkcolor=BLACK;
|
||||
CSpritePlotRotZ3b(dc,o_state[j].x-o_state[i].x+32,
|
||||
o_state[j].y-o_state[i].y+32,0,
|
||||
objs[j].img,o_state[j].é);
|
||||
if (dc->collision_cnt>0)
|
||||
Collision(i,j);
|
||||
DCDel(dc);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (i=0;i<NUM_OBJECTS;i++)
|
||||
if (objs[i].active==A_TRANSITION)
|
||||
objs[i].active=A_ACTIVE;
|
||||
}
|
||||
|
||||
#define MUZZLE_VELOCITY 500.0
|
||||
|
||||
U0 Fire()
|
||||
{
|
||||
F64 é=o_state[0].é;
|
||||
I64 i=ObjAlloc(OT_BULLET);
|
||||
objs[i].timeout=tP+0.5;
|
||||
objs[i].mass*=10.0;
|
||||
o_state[i].x=o_state[0].x+(objs[0].radius+objs[i].radius+1.0)*Cos(é-ã/2.0);
|
||||
o_state[i].y=o_state[0].y+(objs[0].radius+objs[i].radius+1.0)*Sin(é-ã/2.0);
|
||||
o_state[i].DxDt=o_state[0].DxDt+MUZZLE_VELOCITY*Cos(é-ã/2.0);
|
||||
o_state[i].DyDt=o_state[0].DyDt+MUZZLE_VELOCITY*Sin(é-ã/2.0);
|
||||
o_state[i].DéDt=RandI16/3000.0;
|
||||
|
||||
//not real physics with the 0.005 factor
|
||||
o_state[0].DxDt-=0.005*MUZZLE_VELOCITY*Cos(é-ã/2.0)*objs[i].mass/objs[0].mass;
|
||||
o_state[0].DyDt-=0.005*MUZZLE_VELOCITY*Sin(é-ã/2.0)*objs[i].mass/objs[0].mass;
|
||||
}
|
||||
|
||||
U0 CheckCrazy()
|
||||
{
|
||||
I64 i;
|
||||
F64 d;
|
||||
for (i=0;i<NUM_OBJECTS;i++)
|
||||
if (objs[i].active==A_ACTIVE) {
|
||||
d=Sqrt(Sqr(o_state[i].DxDt)+Sqr(o_state[i].DyDt));
|
||||
if (d>MUZZLE_VELOCITY*5.0)
|
||||
Auto(" ");
|
||||
}
|
||||
}
|
||||
|
||||
U0 SongTask(I64)
|
||||
{ //Song by Terry A. Davis
|
||||
Fs->task_end_cb=&SndTaskEndCB;
|
||||
MusicSettingsRst;
|
||||
while (TRUE) {
|
||||
Play("W13eGGsGGeGGGe.GeCDsEDeCBAe.AeG");
|
||||
Play("GsGGeGGGe.GeFEsDEeDCBe.AeFD");
|
||||
Play("EDFDEDECDCECDCsGGeG");
|
||||
Play("GG2hG3sGGeGGG2hG");
|
||||
}
|
||||
}
|
||||
|
||||
U0 Rocks()
|
||||
{
|
||||
I64 ch,sc,msg_code;
|
||||
CMenuEntry *tempse;
|
||||
|
||||
PopUpOk(
|
||||
"I refuse to rip-off the original\n"
|
||||
"so this is intentionally unplayable\n"
|
||||
"and included for demonstration\n"
|
||||
"purposes.\n\n"
|
||||
"Write games, don't play them.\n");
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
Fs->song_task=Spawn(&SongTask,NULL,"Song",Fs);
|
||||
Preempt(OFF),
|
||||
WinBorder;
|
||||
WordStat;
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" Fire(,CH_SPACE);"
|
||||
" Fwd(,,SC_CURSOR_UP);"
|
||||
" Left(,,SC_CURSOR_LEFT);"
|
||||
" Right(,,SC_CURSOR_RIGHT);"
|
||||
" ToggleBounce(,'b');"
|
||||
"}"
|
||||
);
|
||||
tempse=MenuEntryFind(Fs->cur_menu,"Play/ToggleBounce");
|
||||
tempse->checked=bounce=TRUE;
|
||||
|
||||
ode=ODENew(NUM_OBJECTS*6,0.01);
|
||||
ode->derivative=&MyDerivative;
|
||||
ode->min_tolerance=0.001*ode->max_tolerance;
|
||||
o_state=ode->state;
|
||||
objs=MAlloc(NUM_OBJECTS*sizeof(Obj));
|
||||
|
||||
WinMax;
|
||||
|
||||
Init;
|
||||
QueIns(ode,Fs->last_ode);
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
|
||||
try {
|
||||
while (TRUE) {
|
||||
while (msg_code=ScanMsg(&ch,&sc,1<<MSG_KEY_DOWN|1<<MSG_KEY_UP)) {
|
||||
if (msg_code==MSG_KEY_DOWN)
|
||||
switch (ch) {
|
||||
case 0:
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_RIGHT:
|
||||
cmd_code=CMD_SPIN_RIGHT;
|
||||
break;
|
||||
case SC_CURSOR_LEFT:
|
||||
cmd_code=CMD_SPIN_LEFT;
|
||||
break;
|
||||
case SC_CURSOR_UP:
|
||||
cmd_code=CMD_THRUST;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case CH_SPACE:
|
||||
Fire;
|
||||
break;
|
||||
case CH_NEW_LINE:
|
||||
Init;
|
||||
break;
|
||||
case CH_ESC:
|
||||
case CH_SHIFT_ESC:
|
||||
goto rk_done;
|
||||
case 'b':
|
||||
tempse=MenuEntryFind(Fs->cur_menu,"Play/ToggleBounce");
|
||||
tempse->checked=bounce=!bounce;
|
||||
break;
|
||||
}
|
||||
else //MSG_KEY_UP
|
||||
cmd_code=CMD_NULL;
|
||||
}
|
||||
CheckCollisions;
|
||||
CheckCrazy;
|
||||
if (cmd_code==CMD_GAME_OVER) {
|
||||
Sleep(1000);
|
||||
Init;
|
||||
}
|
||||
WinMgrSync; //msgs are only qued by winmngr
|
||||
}
|
||||
rk_done:
|
||||
GetMsg(,,1<<MSG_KEY_UP);
|
||||
} catch
|
||||
CatchAll;
|
||||
|
||||
QueRem(ode);
|
||||
ODEDel(ode);
|
||||
Free(objs);
|
||||
MenuPop;
|
||||
|
||||
SettingsPop;
|
||||
}
|
||||
|
||||
Rocks;
|
||||
® ùÿÿÿüÿÿÿ üÿÿÿ úÿÿÿÿÿÿÿ þÿÿÿ þÿÿÿ ÿÿÿÿ ýÿÿÿ ýÿÿÿ ÷ÿÿÿ ÷ÿÿÿûÿÿÿ ûÿÿÿ ÿÿÿÿ øÿÿÿ øÿÿÿ
|
||||
|
||||
ôÿÿÿ ôÿÿÿ ôÿÿÿ ôÿÿÿùÿÿÿ ùÿÿÿ ùÿÿÿ ùÿÿÿ þÿÿÿ þÿÿÿ ùÿÿÿüÿÿÿ üÿÿÿ úÿÿÿÿÿÿÿ þÿÿÿ þÿÿÿ ÿÿÿÿ ýÿÿÿ ýÿÿÿ ÷ÿÿÿ ÷ÿÿÿûÿÿÿ ûÿÿÿ ÿÿÿÿ øÿÿÿ øÿÿÿ ÿÿÿÿ þÿÿÿ
|
||||
þÿÿÿ
|
||||
|
||||
|
||||
␍ ýÿÿÿ
|
||||
|
||||
|
||||
|
||||
|
||||
óÿÿÿ óÿÿÿøÿÿÿ øÿÿÿ ûÿÿÿ ûÿÿÿ 3 þÿÿÿýÿÿÿólß$† n[½ þÿÿÿ d¨ Š g þÿÿÿûÿÿÿn[϶m’$C’$É$Q¶eÛ¼„ar–ͳíÙžW’"Cš¶½mÛ² úÿÿÿ¶m’6MÛ+ üÿÿÿ ¤m
|
||||
þÿÿÿþÿÿÿ¤iÛ
|
||||
I² G r üÿÿÿôÿÿÿóæy^ÝÚ³m“$íÛ¶mÛ³g’¡F CQŒ¢d["‰©( ³lÁ°lž×n $I’T¤$à ÷ÿÿÿ ž=Û$Í úÿÿÿ«]»¶m“¦IFI’$I’„IrY–ms×zõÖm¶kÛ&MÛ¶m“¤%‘’l¶e[’$‰HÒ·m›<I“$I’$I’ ³mÛ¶mÛ¶m[DŠŒ üÿÿÿøÿÿÿ¶Mߧm{ þÿÿÿI�ɶm›·yÛ ùÿÿÿ v]×£’,K€$ÉW $¥�Q‘ IŠK°Ù2Û´MoK’dɶm›=Ï3O“¦=␍ øÿÿÿúÿÿÿ«ëu¦ ␍ ó ÿÿÿÿþÿÿÿ þÿÿÿþÿÿÿýÿÿÿþÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿþÿÿÿÿÿÿÿ þÿÿÿþÿÿÿþÿÿÿÿÿÿÿÿÿÿÿ þÿÿÿ þÿÿÿÿÿÿÿ ýÿÿÿ ÿÿÿÿÿÿÿÿ ýÿÿÿþÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿýÿÿÿ
|
||||
þÿÿÿýÿÿÿþÿÿÿ ó ÿÿÿÿþÿÿÿ þÿÿÿþÿÿÿýÿÿÿþÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿþÿÿÿÿÿÿÿ þÿÿÿþÿÿÿþÿÿÿÿÿÿÿÿÿÿÿ þÿÿÿ þÿÿÿÿÿÿÿ ýÿÿÿ ÿÿÿÿÿÿÿÿ ýÿÿÿþÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿýÿÿÿ
|
||||
þÿÿÿýÿÿÿþÿÿÿ 3 þÿÿÿýÿÿÿólß$† n[½ þÿÿÿ d¨ Š g þÿÿÿûÿÿÿn[϶m’$C’$É$Q¶eÛ¼„ar–ͳíÙžW’"Cš¶½mÛ² úÿÿÿ¶m’6MÛ+ üÿÿÿ ¤m
|
||||
þÿÿÿþÿÿÿ¤iÛ
|
||||
I² G r üÿÿÿôÿÿÿóæy^ÝÚ³m“$íÛ¶mÛ³g’¡F CQŒ¢d["‰©( ³lÁ°lž×n $I’T¤$à ÷ÿÿÿ ž=Û$Í úÿÿÿ«]»¶m“¦IFI’$I’„IrY–ms×zõÖm¶kÛ&MÛ¶m“¤%‘’l¶e[’$‰HÒ·m›<I“$I’$I’ ³mÛ¶mÛ¶m[DŠŒ üÿÿÿøÿÿÿ¶Mߧm{ þÿÿÿI�ɶm›·yÛ ùÿÿÿ v]×£’,K€$ÉW $¥�Q‘ IŠK°Ù2Û´MoK’dɶm›=Ï3O“¦=␍ øÿÿÿúÿÿÿ«ëu¦ 6 ( ÿÿÿÿûÿÿÿÛlÛ¤m“dÂ�$·m ²d þÿÿÿþÿÿÿöiÚ
|
||||
k M øÿÿÿض¶µkۦϓ$Û$‰$ ’ A’$$m»Þ6ÏófG ÿÿÿÿûÿÿÿuëÚöH† EQdlÛö¶-Q$Æë Á²l¶m ýÿÿÿúÿÿÿ Ù öÿÿÿsÛÖmëÖÏŸ¶mû$¥$”"mY�%‰¢( #I’ÚömÛ®k»@’,˶mö¼$a…‰Â�$mÛ¾i’¾ùÛÁ¶mÛ¶m›çºvm[I¤„‰ÂDG øÿÿÿ®ëÚöì%›mÛ¶Iš´ízÛšˆÜþoI&IG A’$I’$II”m“¤ïmÛ¶Õž·$
|
||||
’!É␍+ øÿÿÿþÿÿÿ¶k»¶éÿ´mÓ$™0L�e[ ýÿÿÿI– É úÿÿÿ ¶]Û" ýÿÿÿ›·Í¶m& ¥�¦í ¾ ðÿÿÿ þÿÿÿ ÿÿÿÿ ␍ ûÿÿÿúÿÿÿ ûÿÿÿ úÿÿÿùÿÿÿ öÿÿÿ öÿÿÿ úÿÿÿ þÿÿÿ üÿÿÿ üÿÿÿ ýÿÿÿ ýÿÿÿ␍ ␍ ␍ ýÿÿÿ
|
||||
|
||||
þÿÿÿûÿÿÿþÿÿÿ ûÿÿÿ ␍ ÿÿÿÿ úÿÿÿüÿÿÿ ûÿÿÿ þÿÿÿ ùÿÿÿüÿÿÿ üÿÿÿ úÿÿÿÿÿÿÿ þÿÿÿ þÿÿÿ ÿÿÿÿ ýÿÿÿ ýÿÿÿ ÷ÿÿÿ ÷ÿÿÿûÿÿÿ ûÿÿÿ ÿÿÿÿ øÿÿÿ øÿÿÿ Ÿ ùÿÿÿüÿÿÿ üÿÿÿ úÿÿÿÿÿÿÿ þÿÿÿ þÿÿÿ ÿÿÿÿ ýÿÿÿ ýÿÿÿ ÷ÿÿÿ ÷ÿÿÿûÿÿÿ ûÿÿÿ ÿÿÿÿ øÿÿÿ øÿÿÿ ÿÿÿÿ þÿÿÿ
|
||||
þÿÿÿ
|
||||
|
||||
|
||||
␍ ' þÿÿÿþÿÿÿ4In]Kj ÿÿÿÿ ( þÿÿÿ 6™%If ýÿÿÿ $I
|
||||
Binary file not shown.
@@ -0,0 +1,408 @@
|
||||
#define MT_HOSE 1
|
||||
#define MT_DROPLET 2
|
||||
class MyMass:CMass
|
||||
{
|
||||
I64 type;
|
||||
F64 radius;
|
||||
};
|
||||
|
||||
#define ST_HOSE 1
|
||||
class MySpring:CSpring
|
||||
{
|
||||
I64 type;
|
||||
};
|
||||
|
||||
$BG,11$
|
||||
|
||||
|
||||
$SP,"<1>",1$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<2>",2$
|
||||
|
||||
|
||||
|
||||
$SP,"<3>",3$
|
||||
|
||||
$BG$
|
||||
|
||||
#define HOSE_RADIUS 3
|
||||
#define LINK_SIZE 6
|
||||
#define NOZZLE_START_Y (GR_HEIGHT-15*FONT_HEIGHT)
|
||||
#define NOZZLE_LEN 18
|
||||
#define FAUCET_X (5*HOSE_RADIUS)
|
||||
#define FAUCET_Y (GR_HEIGHT-12*FONT_HEIGHT)
|
||||
#define GROUND_Y (GR_HEIGHT-3*FONT_HEIGHT)
|
||||
MyMass *faucet,*nozzle;
|
||||
F64 nozzle_é;
|
||||
|
||||
CMathODE *ode=NULL;
|
||||
F64 start_up_timeout;
|
||||
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
Bool old_suspend,first;
|
||||
F64 dx,dy,d;
|
||||
I64 x1b,y1b,x2b,y2b,
|
||||
x1a,y1a,x2a,y2a;
|
||||
MyMass *tempm,*tempm1;
|
||||
MySpring *temps;
|
||||
CD3I32 poly[4];
|
||||
|
||||
if (start_up_timeout>tNP) {
|
||||
ode->drag_v2=0.01; //Let hose settle during start-up
|
||||
ode->drag_v3=0.0001;
|
||||
dc->color=RED;
|
||||
GrPutS(dc,(GR_WIDTH-FONT_WIDTH*6)>>1,GR_HEIGHT>>1,"Squirt");
|
||||
return;
|
||||
} else {
|
||||
ode->drag_v2=0.0005;
|
||||
ode->drag_v3=0.0000025;
|
||||
}
|
||||
|
||||
old_suspend=Suspend(task);
|
||||
tempm=faucet;
|
||||
dc->color=BLACK;
|
||||
GrRect(dc,tempm->x+8,tempm->y,8,GROUND_Y-FAUCET_Y);
|
||||
CSpritePlot3(dc,tempm->x,tempm->y,0,$IB,"<1>",1$);
|
||||
dc->color=BLACK;
|
||||
GrCircle(dc,tempm->x,tempm->y,tempm->radius);
|
||||
dc->color=GREEN;
|
||||
GrFloodFill(dc,tempm->x,tempm->y);
|
||||
|
||||
tempm=nozzle;
|
||||
tempm1=nozzle->last;
|
||||
dx=tempm->x-tempm1->x;
|
||||
dy=tempm->y-tempm1->y;
|
||||
nozzle_é=Wrap(Arg(dx,dy));
|
||||
CSpritePlotRotZ3b(dc,tempm->x,tempm->y,0,$IB,"<2>",2$,nozzle_é);
|
||||
dc->color=BLACK;
|
||||
GrCircle(dc,tempm->x,tempm->y,tempm->radius);
|
||||
dc->color=GREEN;
|
||||
GrFloodFill(dc,tempm->x,tempm->y);
|
||||
|
||||
first=TRUE;
|
||||
tempm=ode->next_mass;
|
||||
while (tempm!=&ode->next_mass) {
|
||||
if (tempm->type==MT_HOSE) {
|
||||
tempm1=tempm->last;
|
||||
dx=tempm->x-tempm1->x;
|
||||
dy=tempm->y-tempm1->y;
|
||||
d=HOSE_RADIUS/Max(Sqrt(dx*dx+dy*dy),0.001);
|
||||
dx*=d;
|
||||
dy*=d;
|
||||
x2a=tempm->x-dy;
|
||||
y2a=tempm->y+dx;
|
||||
x2b=tempm->x+dy;
|
||||
y2b=tempm->y-dx;
|
||||
|
||||
if (first)
|
||||
first=FALSE;
|
||||
else {
|
||||
dc->color=GREEN;
|
||||
poly[0].x=x1a;
|
||||
poly[0].y=y1a;
|
||||
poly[0].z=0;
|
||||
poly[1].x=x2a;
|
||||
poly[1].y=y2a;
|
||||
poly[1].z=0;
|
||||
poly[2].x=x2b;
|
||||
poly[2].y=y2b;
|
||||
poly[2].z=0;
|
||||
poly[3].x=x1b;
|
||||
poly[3].y=y1b;
|
||||
poly[3].z=0;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
}
|
||||
|
||||
//Fill gaps
|
||||
GrLine(dc,x2a,y2a,x2b,y2b);
|
||||
|
||||
x1a=x2a;
|
||||
y1a=y2a;
|
||||
x1b=x2b;
|
||||
y1b=y2b;
|
||||
} else if (tempm->type==MT_DROPLET)
|
||||
CSpritePlot3(dc,tempm->x,tempm->y,0,$IB,"<3>",3$);
|
||||
tempm=tempm->next;
|
||||
}
|
||||
|
||||
temps=ode->next_spring;
|
||||
while (temps!=&ode->next_spring) {
|
||||
if (temps->type==ST_HOSE) {
|
||||
dx=temps->end1->x-temps->end2->x;
|
||||
dy=temps->end1->y-temps->end2->y;
|
||||
d=HOSE_RADIUS/Max(Sqrt(dx*dx+dy*dy),0.001);
|
||||
dx*=d;
|
||||
dy*=d;
|
||||
dc->color=BLACK;
|
||||
GrLine(dc,temps->end1->x-dy,temps->end1->y+dx,
|
||||
temps->end2->x-dy,temps->end2->y+dx);
|
||||
GrLine(dc,temps->end1->x+dy,temps->end1->y-dx,
|
||||
temps->end2->x+dy,temps->end2->y-dx);
|
||||
}
|
||||
temps=temps->next;
|
||||
}
|
||||
Suspend(task,old_suspend);
|
||||
}
|
||||
|
||||
|
||||
U0 MyDerivative(CMathODE *ode,F64 t,COrder2D3 *state,COrder2D3 *DstateDt)
|
||||
{
|
||||
//The forces due to springs and drag are
|
||||
//automatically handled by the
|
||||
//ode code. We can add new forces
|
||||
//here.
|
||||
nounusedwarn t,state,DstateDt;
|
||||
// F64 d,dd;
|
||||
// CD3 p;
|
||||
MyMass *tempm1,*tempm2;
|
||||
nounusedwarn tempm2;
|
||||
|
||||
tempm1=ode->next_mass;
|
||||
while (tempm1!=&ode->next_mass) {
|
||||
if (tempm1->type==MT_HOSE) {
|
||||
if (tempm1->state->y+tempm1->radius>GROUND_Y)
|
||||
tempm1->DstateDt->DyDt-=Sqr(Sqr(tempm1->state->y+tempm1->radius-GROUND_Y))*tempm1->mass;
|
||||
else
|
||||
tempm1->DstateDt->DyDt+=500*tempm1->mass;
|
||||
if (tempm1==nozzle || tempm1==faucet) {
|
||||
tempm1->DstateDt->DxDt=0;
|
||||
tempm1->DstateDt->DyDt=0;
|
||||
}
|
||||
} else if (tempm1->type==MT_DROPLET)
|
||||
tempm1->DstateDt->DyDt=500*tempm1->mass;
|
||||
tempm1=tempm1->next;
|
||||
}
|
||||
}
|
||||
|
||||
MyMass *PlaceMass(I64 type,I64 x, I64 y,F64 r,F64 dx,F64 dy,F64 mass,CTask *mem_task)
|
||||
{
|
||||
MyMass *tempm=CAlloc(sizeof(MyMass),mem_task);
|
||||
tempm->type=type;
|
||||
tempm->mass=mass;
|
||||
tempm->drag_profile_factor=250.0;
|
||||
tempm->x=x;
|
||||
tempm->y=y;
|
||||
tempm->DxDt=dx;
|
||||
tempm->DyDt=dy;
|
||||
tempm->radius=r;
|
||||
QueIns(tempm,ode->last_mass);
|
||||
return tempm;
|
||||
}
|
||||
|
||||
MySpring PlaceSpring(MyMass *tempm1,MyMass *tempm2)
|
||||
{
|
||||
MySpring *temps=CAlloc(sizeof(MySpring));
|
||||
temps->end1=tempm1;
|
||||
temps->end2=tempm2;
|
||||
temps->constant=20000;
|
||||
QueIns(temps,ode->last_spring);
|
||||
return temps;
|
||||
}
|
||||
|
||||
U0 HoseNew()
|
||||
{
|
||||
I64 i;
|
||||
MyMass *tempm1=NULL,*tempm;
|
||||
MySpring *temps;
|
||||
for (i=FAUCET_X;i<GR_WIDTH;i+=LINK_SIZE) {
|
||||
tempm=PlaceMass(MT_HOSE,i/2,GROUND_Y-HOSE_RADIUS,HOSE_RADIUS,0,0,1.0,Fs);
|
||||
if (tempm1) {
|
||||
temps=PlaceSpring(tempm,tempm1);
|
||||
temps->rest_len=LINK_SIZE;
|
||||
temps->type=ST_HOSE;
|
||||
nozzle=tempm;
|
||||
} else
|
||||
faucet=tempm;
|
||||
tempm1=tempm;
|
||||
}
|
||||
faucet->y=FAUCET_Y;
|
||||
nozzle->y=NOZZLE_START_Y;
|
||||
nozzle_é=0;
|
||||
}
|
||||
|
||||
U0 AnimateTask(I64)
|
||||
{
|
||||
//Preempt is off by default for new task
|
||||
MyMass *tempm,*tempm1;
|
||||
F64 dx,dy;
|
||||
while (TRUE) {
|
||||
|
||||
//The WinMgr task suspends our parent when it
|
||||
//updates the ODE's. We use this to know when
|
||||
//the ODE's are being updated.
|
||||
if (!IsSuspended(Fs->parent_task)) {
|
||||
dx=Cos(nozzle_é),
|
||||
dy=Sin(nozzle_é),
|
||||
PlaceMass(MT_DROPLET,
|
||||
nozzle->x+NOZZLE_LEN*dx,nozzle->y+NOZZLE_LEN*dy,
|
||||
HOSE_RADIUS,
|
||||
500*dx,500*dy,
|
||||
100.0,Fs->parent_task);
|
||||
if (Rand<0.05) //faucet drip
|
||||
PlaceMass(MT_DROPLET,
|
||||
faucet->x,faucet->y,
|
||||
HOSE_RADIUS,
|
||||
0,0,
|
||||
100.0,Fs->parent_task);
|
||||
|
||||
tempm=ode->next_mass;
|
||||
while (tempm!=&ode->next_mass) {
|
||||
tempm1=tempm->next;
|
||||
if (tempm->type==MT_DROPLET &&
|
||||
tempm->y+tempm->radius>GROUND_Y) {
|
||||
QueRem(tempm);
|
||||
Free(tempm);
|
||||
}
|
||||
tempm=tempm1;
|
||||
}
|
||||
}
|
||||
WinMgrSync;
|
||||
}
|
||||
}
|
||||
|
||||
#define NOZZLE_MOVE_STEPS 5
|
||||
#define NOZZLE_MOVE 15.0
|
||||
U0 MoveNozzleTaskX(I64 sign)
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<NOZZLE_MOVE_STEPS;i++) {
|
||||
nozzle->x=Limit(nozzle->x+
|
||||
sign*NOZZLE_MOVE/NOZZLE_MOVE_STEPS,
|
||||
HOSE_RADIUS*3,GR_WIDTH-HOSE_RADIUS*3);
|
||||
WinMgrSync;
|
||||
}
|
||||
}
|
||||
|
||||
U0 MoveNozzleTaskY(I64 sign)
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<NOZZLE_MOVE_STEPS;i++) {
|
||||
nozzle->y=Limit(nozzle->y+
|
||||
sign*NOZZLE_MOVE/NOZZLE_MOVE_STEPS,
|
||||
HOSE_RADIUS*3,GROUND_Y);
|
||||
WinMgrSync;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
U0 DrawBackGroundTextLayer()
|
||||
{
|
||||
DocClear;
|
||||
"$$BG,LTCYAN$$";
|
||||
NewLine(GROUND_Y/FONT_HEIGHT);
|
||||
"$$BG,YELLOW$$";
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
DrawBackGroundTextLayer;
|
||||
|
||||
//Allow hose to settle.
|
||||
start_up_timeout=tNP+0.5;
|
||||
|
||||
ode=ODENew(0,5e-2,ODEF_HAS_MASSES);
|
||||
ode->derivative=&MyDerivative;
|
||||
ode->acceleration_limit=5e3;
|
||||
|
||||
HoseNew;
|
||||
QueIns(ode,Fs->last_ode);
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
WinMgrSync(NOZZLE_MOVE_STEPS); //Let nozzle move tasks die
|
||||
QueRem(ode);
|
||||
QueDel(&ode->next_mass,TRUE);
|
||||
QueDel(&ode->next_spring,TRUE);
|
||||
ODEDel(ode);
|
||||
DocClear;
|
||||
"$$BG$$";
|
||||
}
|
||||
|
||||
U0 SongTask(I64)
|
||||
{
|
||||
Fs->task_end_cb=&SndTaskEndCB;
|
||||
MusicSettingsRst;
|
||||
while (TRUE) {
|
||||
Play("W13eAM4/4");
|
||||
Play("2qGeGqG3eAq.BqBeBqA2eG3qA");
|
||||
Play("eB2hG3q.BqBeCq.DD");
|
||||
Play("qCeBqCeDhB");
|
||||
}
|
||||
}
|
||||
|
||||
U0 Squirt()
|
||||
{
|
||||
I64 sc;
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
Fs->song_task=Spawn(&SongTask,NULL,"Song",Fs);
|
||||
WinMax;
|
||||
WinBorder;
|
||||
Preempt(OFF);
|
||||
DocCursor;
|
||||
|
||||
Fs->win_inhibit|=WIF_DBL_CLICK;
|
||||
WordStat;
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" Left(,,SC_CURSOR_LEFT);"
|
||||
" Right(,,SC_CURSOR_RIGHT);"
|
||||
" Up(,,SC_CURSOR_UP);"
|
||||
" Down(,,SC_CURSOR_DOWN);"
|
||||
"}"
|
||||
);
|
||||
|
||||
Init;
|
||||
Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",Fs);
|
||||
Fs->draw_it=&DrawIt;
|
||||
|
||||
try {
|
||||
while (TRUE) {
|
||||
switch (GetKey(&sc)) {
|
||||
case 0:
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_LEFT:
|
||||
Spawn(&MoveNozzleTaskX,-1,"Move Nozzle",Fs);
|
||||
break;
|
||||
case SC_CURSOR_RIGHT:
|
||||
Spawn(&MoveNozzleTaskX,1,"Move Nozzle",Fs);
|
||||
break;
|
||||
case SC_CURSOR_UP:
|
||||
Spawn(&MoveNozzleTaskY,-1,"Move Nozzle",Fs);
|
||||
break;
|
||||
case SC_CURSOR_DOWN:
|
||||
Spawn(&MoveNozzleTaskY,1,"Move Nozzle",Fs);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case CH_NEW_LINE:
|
||||
CleanUp;
|
||||
Init;
|
||||
break;
|
||||
case CH_SHIFT_ESC:
|
||||
case CH_ESC:
|
||||
goto sq_done;
|
||||
}
|
||||
}
|
||||
sq_done: //Don't goto out of try
|
||||
} catch
|
||||
CatchAll;
|
||||
SettingsPop;
|
||||
CleanUp;
|
||||
MenuPop;
|
||||
}
|
||||
|
||||
Squirt;
|
||||
R ÷ÿÿÿìÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿ ÿÿ ÿÿÿ ÿ ÿÿ ÿÿÿ ÿ ÿ ÿÿÿÿÿ ÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿ ÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ 2 ÿÿÿÿûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ ÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿ ÿÿÿÿÿ ÿÿ ÿÿÿÿ ÿ ÿÿ ÿÿ ÿÿ ÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ J ýÿÿÿýÿÿÿÿÿÿ ÿÿ ÿ ÿÿ ÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,30 @@
|
||||
//Generate "Stadium.GRA.Z" from "Stadium.TXT.Z"
|
||||
|
||||
|
||||
U0 StadiumGen()
|
||||
{
|
||||
U0 (*fp_old_update)(CDC *dc);
|
||||
CDC *dc;
|
||||
|
||||
WinMax;
|
||||
WinBorder;
|
||||
DocClear;
|
||||
Type("::/SparrowOS/Demo/GameStarters/Stadium/Stadium.TXT.Z");
|
||||
"$$CM,0,%d$$",TEXT_ROWS-2;
|
||||
DocCursor(OFF);
|
||||
fp_old_update=fp_final_screen_update; //hide mouse cursor
|
||||
fp_final_screen_update=NULL;
|
||||
|
||||
WinMgrSync(2,TRUE);
|
||||
dc=DCExtract(gr_screen_image,0,FONT_HEIGHT,GR_WIDTH,GR_HEIGHT);
|
||||
|
||||
GRAWrite("::/SparrowOS/Demo/GameStarters/Stadium/Stadium",dc);
|
||||
DCDel(dc);
|
||||
|
||||
DocCursor(ON);
|
||||
fp_final_screen_update=fp_old_update;
|
||||
DocClear;
|
||||
}
|
||||
|
||||
StadiumGen;
|
||||
|
||||
Binary file not shown.
@@ -0,0 +1,124 @@
|
||||
I8 board [9];
|
||||
I64 board_x[9]={150,250,350,150,250,350,150,250,350};
|
||||
I64 board_y[9]={150,150,150,250,250,250,350,350,350};
|
||||
|
||||
U0 DrawX(CDC *dc,I64 x,I64 y)
|
||||
{
|
||||
dc->pen_width=5;
|
||||
GrLine3(dc,x-20,y-20,0,x+20,y+20,0);
|
||||
GrLine3(dc,x+20,y-20,0,x-20,y+20,0);
|
||||
}
|
||||
|
||||
U0 DrawO(CDC *dc,I64 x,I64 y)
|
||||
{
|
||||
dc->pen_width=5;
|
||||
GrCircle3(dc,x,y,0,25);
|
||||
}
|
||||
|
||||
U0 DrawBoard(I64 player)
|
||||
{
|
||||
I64 i;
|
||||
CDC *dc=DCAlias;
|
||||
DCFill;
|
||||
dc->pen_width=5;
|
||||
GrLine3(dc,200,100,0,200,400,0);
|
||||
GrLine3(dc,300,100,0,300,400,0);
|
||||
GrLine3(dc,100,200,0,400,200,0);
|
||||
GrLine3(dc,100,300,0,400,300,0);
|
||||
for (i=0;i<9;i++)
|
||||
switch (board[i]) {
|
||||
case 1:
|
||||
DrawX(dc,board_x[i],board_y[i]);
|
||||
break;
|
||||
case 2:
|
||||
DrawO(dc,board_x[i],board_y[i]);
|
||||
break;
|
||||
|
||||
}
|
||||
if (player==1)
|
||||
DrawX(dc,ipx-Fs->win_pixel_left,ipy-Fs->win_pixel_top);
|
||||
else
|
||||
DrawO(dc,ipx-Fs->win_pixel_left,ipy-Fs->win_pixel_top);
|
||||
DCDel(dc);
|
||||
}
|
||||
|
||||
|
||||
U0 TakeTurn(I64 player)
|
||||
{
|
||||
I64 i,x=0,y=0;
|
||||
while (!(100<=x<400) || !(100<=y<400) || board[i]) {
|
||||
if (player==1)
|
||||
Beep(500);
|
||||
else
|
||||
Beep(1000);
|
||||
while (!ip_lb) {
|
||||
DrawBoard(player);
|
||||
WinMgrSync;
|
||||
}
|
||||
while (ip_lb) {
|
||||
DrawBoard(player);
|
||||
WinMgrSync;
|
||||
}
|
||||
x=ipx-Fs->win_pixel_left;
|
||||
y=ipy-Fs->win_pixel_top;
|
||||
i=(x-100)/100+(y-100)/100*3;
|
||||
}
|
||||
board[i]=player;
|
||||
}
|
||||
|
||||
Bool CheckWinner(I64 player)
|
||||
{
|
||||
if ( player==board[0]==board[1]==board[2] ||
|
||||
player==board[3]==board[4]==board[5] ||
|
||||
player==board[6]==board[7]==board[8] ||
|
||||
|
||||
player==board[0]==board[3]==board[6] ||
|
||||
player==board[1]==board[4]==board[7] ||
|
||||
player==board[2]==board[5]==board[8] ||
|
||||
|
||||
player==board[0]==board[4]==board[8] ||
|
||||
player==board[2]==board[4]==board[6] )
|
||||
return TRUE;
|
||||
else
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
U0 DoGame()
|
||||
{
|
||||
I64 moves=0;
|
||||
MemSet(board,0,sizeof(board));
|
||||
while (TRUE) {
|
||||
TakeTurn(1);
|
||||
if (CheckWinner(1)) {
|
||||
Beep(500);
|
||||
Beep(500);
|
||||
Beep(500);
|
||||
break;
|
||||
}
|
||||
if (++moves==9) break;
|
||||
|
||||
TakeTurn(2);
|
||||
if (CheckWinner(2)) {
|
||||
Beep(1000);
|
||||
Beep(1000);
|
||||
Beep(1000);
|
||||
break;
|
||||
}
|
||||
if (++moves==9) break;
|
||||
}
|
||||
}
|
||||
|
||||
U0 TicTacToe()
|
||||
{
|
||||
WinMax; //Maximize window
|
||||
DocClear; //Clear window text.
|
||||
"$$FG,GREEN$$CTRL-ALT-C$$FG$$ to exit.\n";
|
||||
try
|
||||
while (TRUE)
|
||||
DoGame;
|
||||
catch
|
||||
CatchAll;
|
||||
DCFill;
|
||||
}
|
||||
|
||||
TicTacToe;
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,540 @@
|
||||
AcctRegSetDftEntry("SparrowOS/Wenceslas","F64 best_score=9999;\n");
|
||||
AcctRegExecuteBranch("SparrowOS/Wenceslas");
|
||||
|
||||
#define BORDER 5
|
||||
#define KING_STEP 4
|
||||
|
||||
|
||||
|
||||
$SP,"<1>",1$
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<2>",2$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<3>",3$
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<4>",4$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<5>",5$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<6>",6$
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
$SP,"<7>",7$
|
||||
|
||||
|
||||
|
||||
#define NUM_FLAKES 0x8000
|
||||
class Flake
|
||||
{
|
||||
U16 x,y;
|
||||
} flakes[NUM_FLAKES];
|
||||
|
||||
#define NUM_TREES 8
|
||||
class Tree
|
||||
{
|
||||
U16 x,y;
|
||||
I64 fire_frame_index;
|
||||
} trees[NUM_TREES];
|
||||
|
||||
I64 snow_x,snow_y;
|
||||
I64 king_x,king_y,not_stopped_cnt;
|
||||
F64 king_é,t0,tf,door_open_t0;
|
||||
|
||||
#define NUM_PEASANTS 16
|
||||
class Peasant
|
||||
{
|
||||
Peasant *next,*last;
|
||||
F64 x,y,é,door_opened_t0;
|
||||
Bool stopped;
|
||||
} peasant_root;
|
||||
|
||||
class Step
|
||||
{
|
||||
Step *next,*last;
|
||||
U16 x,y;
|
||||
F64 t0;
|
||||
} step_root,king_step_root;
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
I64 r[16],i,w=task->win_pixel_width,h=task->win_pixel_height;
|
||||
U8 *img;
|
||||
Step *temps;
|
||||
Peasant *tempp;
|
||||
F64 tt;
|
||||
Bool old_preempt=Preempt(OFF);
|
||||
|
||||
dc->pen_width=1;
|
||||
for (i=0;i<NUM_TREES;i++) {
|
||||
if (trees[i].y<=h/2) { //Draw trees behind house
|
||||
if (trees[i].fire_frame_index) {
|
||||
if (trees[i].fire_frame_index++&1)
|
||||
img=$IB,"<4>",4$;
|
||||
else
|
||||
img=$IB,"<5>",5$;
|
||||
} else
|
||||
img=$IB,"<3>",3$;
|
||||
CSpritePlot3(dc,trees[i].x,trees[i].y,0,img);
|
||||
}
|
||||
}
|
||||
|
||||
CSpritePlot3(dc,w/2,h/2,0,$IB,"<6>",6$);
|
||||
if (tP(task)<door_open_t0+1.0)
|
||||
CSpritePlot3(dc,w/2,h/2,0,$IB,"<7>",7$);
|
||||
|
||||
for (i=0;i<NUM_TREES;i++) {
|
||||
if (trees[i].y>h/2) { //Draw trees in front of house
|
||||
if (trees[i].fire_frame_index) {
|
||||
if (trees[i].fire_frame_index++&1)
|
||||
img=$IB,"<4>",4$;
|
||||
else
|
||||
img=$IB,"<5>",5$;
|
||||
} else
|
||||
img=$IB,"<3>",3$;
|
||||
CSpritePlot3(dc,trees[i].x,trees[i].y,0,img);
|
||||
}
|
||||
}
|
||||
|
||||
temps=step_root.next;
|
||||
while (temps!=&step_root) {
|
||||
if (tP(task)-temps->t0<2.0)
|
||||
dc->color=DKGRAY;
|
||||
else
|
||||
dc->color=LTGRAY;
|
||||
dc->pen_width=2;
|
||||
GrPlot3(dc,temps->x,temps->y,0);
|
||||
temps=temps->next;
|
||||
}
|
||||
|
||||
dc->pen_width=1;
|
||||
tempp=peasant_root.next;
|
||||
while (tempp!=&peasant_root) {
|
||||
GrIdentEqu(r);
|
||||
GrRotYEqu(r,tempp->é+ã/2);
|
||||
GrRotXEqu(r,ã/6);
|
||||
if (tempp->stopped)
|
||||
dc->color=LTCYAN;
|
||||
else
|
||||
dc->color=CYAN;
|
||||
CSpritePlotRotMat3b(dc,tempp->x,tempp->y,0,$IB,"<2>",2$,r);
|
||||
tempp=tempp->next;
|
||||
}
|
||||
|
||||
dc->pen_width=1;
|
||||
GrIdentEqu(r);
|
||||
GrRotYEqu(r,king_é+ã/2);
|
||||
GrRotXEqu(r,ã/6);
|
||||
CSpritePlotRotMat3b(dc,king_x,king_y,0,$IB,"<1>",1$,r);
|
||||
|
||||
dc->pen_width=1;
|
||||
dc->color=WHITE;
|
||||
for (i=0;i<NUM_FLAKES;i++)
|
||||
GrPlot(dc,(flakes[i].x+snow_x)%task->win_pixel_width,
|
||||
(flakes[i].y+snow_y)%task->win_pixel_height);
|
||||
|
||||
if (tf) {
|
||||
dc->color=LTRED;
|
||||
if (Blink(,tP(task)))
|
||||
GrPutS(dc,w/2-(FONT_WIDTH*14)/2,h/2+FONT_HEIGHT,"Game Completed");
|
||||
tt=tf;
|
||||
} else {
|
||||
tt=tP(task);
|
||||
}
|
||||
dc->color=LTBLUE;
|
||||
GrPrintF(dc,0,0,"Freezing Peasants:%d Time:%3.2f Best:%3.2f",
|
||||
not_stopped_cnt,tt-t0,best_score);
|
||||
|
||||
Preempt(old_preempt);
|
||||
}
|
||||
|
||||
U0 StepNew(CTask *task,I64 x,I64 y,F64 é,Bool king)
|
||||
{
|
||||
Step *temps;
|
||||
|
||||
if (king) {
|
||||
temps=MAlloc(sizeof(Step),task);
|
||||
temps->x=x;
|
||||
temps->y=y;
|
||||
temps->t0=tP(task);
|
||||
QueIns(temps,king_step_root.last);
|
||||
}
|
||||
|
||||
temps=MAlloc(sizeof(Step),task);
|
||||
temps->x=x-3.5*Sin(é)+1.0*Cos(é);
|
||||
temps->y=y+3.5*Cos(é)+1.0*Sin(é);
|
||||
temps->t0=tP(task);
|
||||
QueIns(temps,step_root.last);
|
||||
|
||||
temps=MAlloc(sizeof(Step),task);
|
||||
temps->x=x+3.5*Sin(é)-1.0*Cos(é);
|
||||
temps->y=y-3.5*Cos(é)-1.0*Sin(é);
|
||||
temps->t0=tP(task);
|
||||
QueIns(temps,step_root.last);
|
||||
}
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i,min_x,max_x,min_y,max_y,
|
||||
w=Fs->win_pixel_width,h=Fs->win_pixel_height;
|
||||
Peasant *tempp;
|
||||
snow_x=0;
|
||||
snow_y=0;
|
||||
for (i=0;i<NUM_FLAKES;i++) {
|
||||
flakes[i].x=RandU16;
|
||||
flakes[i].y=RandU16;
|
||||
}
|
||||
|
||||
CSpriteExtents($IB,"<3>",3$,&min_x,&max_x,&min_y,&max_y);
|
||||
for (i=0;i<NUM_TREES;i++) {
|
||||
trees[i].x=RandU16%(w-2*BORDER-(max_x-min_x+1))+BORDER-min_x;
|
||||
trees[i].y=RandU16%(h-2*BORDER-(max_y-min_y+1))+BORDER-min_y;
|
||||
trees[i].fire_frame_index=0;
|
||||
}
|
||||
|
||||
QueInit(&step_root);
|
||||
QueInit(&king_step_root);
|
||||
|
||||
CSpriteExtents($IB,"<1>",1$,&min_x,&max_x,&min_y,&max_y);
|
||||
QueInit(&peasant_root);
|
||||
for (i=0;i<NUM_PEASANTS;i++) {
|
||||
tempp=MAlloc(sizeof(Peasant));
|
||||
tempp->x=RandU16%(w-2*BORDER-(max_x-min_x+1))+BORDER-min_x;
|
||||
tempp->y=RandU16%(h-2*BORDER-(max_y-min_y+1))+BORDER-min_y;
|
||||
tempp->é=ã*2*Rand;
|
||||
tempp->door_opened_t0=0;
|
||||
tempp->stopped=FALSE;
|
||||
QueIns(tempp,peasant_root.last);
|
||||
}
|
||||
|
||||
king_x=w/2;
|
||||
king_y=h/2;
|
||||
king_é=-ã/2;
|
||||
door_open_t0=0;
|
||||
t0=tP;
|
||||
tf=0;
|
||||
}
|
||||
|
||||
U0 CleanUp()
|
||||
{
|
||||
QueDel(&peasant_root,TRUE);
|
||||
QueDel(&step_root,TRUE);
|
||||
QueDel(&king_step_root,TRUE);
|
||||
}
|
||||
|
||||
U0 Follow(CTask *task,Peasant *tempp)
|
||||
{
|
||||
Step *temps=king_step_root.next;
|
||||
F64 d,best_d=MAX_F64;
|
||||
while (temps!=&king_step_root) {
|
||||
if ((d=Sqr(temps->x-tempp->x)+Sqr(temps->y-tempp->y)) &&
|
||||
d<15*15) {
|
||||
d+=1000*Sqr(tP(task)-temps->t0);
|
||||
if (d<best_d) {
|
||||
best_d=d;
|
||||
tempp->é=Arg(temps->x-tempp->x,temps->y-tempp->y);
|
||||
}
|
||||
}
|
||||
temps=temps->next;
|
||||
}
|
||||
}
|
||||
|
||||
U0 AnimateTask(I64)
|
||||
{//preempt off by default after Spawned
|
||||
Step *temps,*temps1;
|
||||
Peasant *tempp;
|
||||
I64 i,animate_cnt=0,w,h;
|
||||
while (TRUE) {
|
||||
w=Fs->parent_task->win_pixel_width;
|
||||
h=Fs->parent_task->win_pixel_height;
|
||||
|
||||
temps=step_root.next;
|
||||
while (temps!=&step_root) {
|
||||
temps1=temps->next;
|
||||
if (tP(Fs->parent_task)-temps->t0>4.0) {
|
||||
QueRem(temps);
|
||||
Free(temps);
|
||||
}
|
||||
temps=temps1;
|
||||
}
|
||||
|
||||
temps=king_step_root.next;
|
||||
while (temps!=&king_step_root) {
|
||||
temps1=temps->next;
|
||||
if (tP(Fs->parent_task)-temps->t0>4.0) {
|
||||
QueRem(temps);
|
||||
Free(temps);
|
||||
}
|
||||
temps=temps1;
|
||||
}
|
||||
|
||||
not_stopped_cnt=0;
|
||||
tempp=peasant_root.next;
|
||||
while (tempp!=&peasant_root) {
|
||||
if (tempp->stopped) {
|
||||
if (tempp->door_opened_t0 && tP(Fs->parent_task)>tempp->door_opened_t0+1.0) {
|
||||
tempp->door_opened_t0=0;
|
||||
tempp->y=tempp->x=-9999;
|
||||
}
|
||||
} else {
|
||||
if (Sqr(tempp->x-w/2)+Sqr(tempp->y-h/2)<20*20) {
|
||||
tempp->stopped=TRUE;
|
||||
tempp->door_opened_t0=door_open_t0=tP(Fs->parent_task);
|
||||
}
|
||||
for (i=0;i<NUM_TREES;i++) //Hang-out by fire
|
||||
if (trees[i].fire_frame_index && Sqr(tempp->x-trees[i].x)+Sqr(tempp->y-trees[i].y)<20*20) {
|
||||
tempp->stopped=TRUE;
|
||||
break;
|
||||
}
|
||||
if (!tempp->stopped) {
|
||||
Follow(Fs->parent_task,tempp);
|
||||
tempp->x+=Cos(tempp->é)/100;
|
||||
tempp->y+=Sin(tempp->é)/100;
|
||||
if (!(BORDER/2<=tempp->x<w-BORDER/2) || !(BORDER/2<=tempp->y<h-BORDER/2)) {
|
||||
tempp->é+=ã;
|
||||
tempp->x+=3*Cos(tempp->é)/100;
|
||||
tempp->y+=3*Sin(tempp->é)/100;
|
||||
}
|
||||
if (!(animate_cnt&511))
|
||||
StepNew(Fs->parent_task,tempp->x,tempp->y,tempp->é,FALSE);
|
||||
not_stopped_cnt++;
|
||||
}
|
||||
}
|
||||
tempp=tempp->next;
|
||||
}
|
||||
if (!not_stopped_cnt && !tf) {
|
||||
tf=tP(Fs->parent_task);
|
||||
music_mute=TRUE;
|
||||
Snd(2000);Sleep(200);Snd(0);Sleep(100);
|
||||
if (tf-t0<best_score) {
|
||||
best_score=tf-t0;
|
||||
Snd(2000);Sleep(200);Snd(0);Sleep(100);
|
||||
}
|
||||
music_mute=FALSE;
|
||||
}
|
||||
|
||||
snow_x+=RandU16%3-1;
|
||||
snow_y+=1-SignI64(RandU16&3);
|
||||
Sleep(1);
|
||||
animate_cnt++;
|
||||
}
|
||||
}
|
||||
|
||||
U0 BurnTrees()
|
||||
{
|
||||
I64 i;
|
||||
for (i=0;i<NUM_TREES;i++)
|
||||
if (Sqr(king_x-trees[i].x)+Sqr(king_y-trees[i].y)<10*10)
|
||||
trees[i].fire_frame_index=1;
|
||||
}
|
||||
|
||||
U0 SongTask(I64)
|
||||
{
|
||||
Fs->task_end_cb=&SndTaskEndCB;
|
||||
MusicSettingsRst;
|
||||
music_tempo= 2.480;
|
||||
music_stacatto_factor= 0.902;
|
||||
while (TRUE) {
|
||||
Play("W13eCCCDCC2qG3eA2G3ABqCC");
|
||||
Play("eCCCDCC2qG3eA2G3ABqCC");
|
||||
Play("eGFEDEDqCeA2G3ABqCC");
|
||||
}
|
||||
}
|
||||
|
||||
U0 Wenceslas()
|
||||
{
|
||||
I64 sc;
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
"Play {"
|
||||
" Restart(,CH_NEW_LINE);"
|
||||
" BurnTree(,CH_SPACE);"
|
||||
" Up(,,SC_CURSOR_UP);"
|
||||
" Down(,,SC_CURSOR_DOWN);"
|
||||
" Left(,,SC_CURSOR_LEFT);"
|
||||
" Right(,,SC_CURSOR_RIGHT);"
|
||||
"}"
|
||||
);
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
WinMax;
|
||||
Preempt(OFF);
|
||||
Fs->song_task=Spawn(&SongTask,NULL,"Song",Fs);
|
||||
|
||||
PopUpOk("
|
||||
Good King Wenceslas looked out
|
||||
On the feast of Stephen
|
||||
When the snow lay round about
|
||||
Deep and crisp and even
|
||||
Brightly shone the moon that night
|
||||
Though the frost was cruel
|
||||
When a poor man came in sight
|
||||
Gath'ring winter fuel
|
||||
|
||||
\"Hither, page, and stand by me
|
||||
If thou know'st it, telling
|
||||
Yonder peasant, who is he?
|
||||
Where and what his dwelling?\"
|
||||
\"Sire, he lives a good league hence
|
||||
Underneath the mountain
|
||||
Right against the forest fence
|
||||
By Saint Agnes' fountain.\"
|
||||
|
||||
\"Bring me flesh and bring me wine
|
||||
Bring me pine logs hither
|
||||
Thou and I will see him dine
|
||||
When we bear him thither.\"
|
||||
Page and monarch forth they went
|
||||
Forth they went together
|
||||
Through the rude wind's wild lament
|
||||
And the bitter weather
|
||||
|
||||
");
|
||||
PopUpOk("
|
||||
\"Sire, the night is darker now
|
||||
And the wind blows stronger
|
||||
Fails my heart, I know not how,
|
||||
I can go no longer.\"
|
||||
\"Mark my footsteps, my good page
|
||||
Tread thou in them boldly
|
||||
Thou shalt find the winter's rage
|
||||
Freeze thy blood less coldly.\"
|
||||
|
||||
In his master's steps he trod
|
||||
Where the snow lay dinted
|
||||
Heat was in the very sod
|
||||
Which the Saint had printed
|
||||
Therefore, Christian men, be sure
|
||||
Wealth or rank possessing
|
||||
Ye who now will bless the poor
|
||||
Shall yourselves find blessing
|
||||
|
||||
");
|
||||
PopUpOk("
|
||||
$$FG,PURPLE$$$$TX+CX,\"Winceslas Game\"$$$$FG$$
|
||||
|
||||
Start fires by pressing $$FG,GREEN$$<SPACE BAR>$$FG$$
|
||||
on trees. (Yule logs)
|
||||
|
||||
Lead peasants to fires.
|
||||
");
|
||||
|
||||
Init;
|
||||
Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",Fs);
|
||||
WordStat;
|
||||
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
try {
|
||||
while (TRUE) {
|
||||
switch (GetKey(&sc)) {
|
||||
case CH_NEW_LINE:
|
||||
CleanUp;
|
||||
Init;
|
||||
break;
|
||||
case CH_ESC:
|
||||
case CH_SHIFT_ESC:
|
||||
goto ws_done;
|
||||
case CH_SPACE:
|
||||
BurnTrees;
|
||||
break;
|
||||
case 0:
|
||||
switch (sc.u8[0]) {
|
||||
case SC_CURSOR_RIGHT:
|
||||
if (king_x+KING_STEP<Fs->win_pixel_width-BORDER)
|
||||
king_x+=KING_STEP;
|
||||
king_é=0;
|
||||
StepNew(Fs,king_x,king_y,king_é,TRUE);
|
||||
break;
|
||||
case SC_CURSOR_LEFT:
|
||||
if (king_x-KING_STEP>=BORDER)
|
||||
king_x-=KING_STEP;
|
||||
king_é=ã;
|
||||
StepNew(Fs,king_x,king_y,king_é,TRUE);
|
||||
break;
|
||||
case SC_CURSOR_DOWN:
|
||||
if (king_y+KING_STEP<Fs->win_pixel_height-BORDER)
|
||||
king_y+=KING_STEP;
|
||||
king_é=-ã/2;
|
||||
StepNew(Fs,king_x,king_y,king_é,TRUE);
|
||||
break;
|
||||
case SC_CURSOR_UP:
|
||||
if (king_y-KING_STEP>=BORDER)
|
||||
king_y-=KING_STEP;
|
||||
king_é=ã/2;
|
||||
StepNew(Fs,king_x,king_y,king_é,TRUE);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
ws_done:
|
||||
} catch
|
||||
CatchAll;
|
||||
SettingsPop;
|
||||
MenuPop;
|
||||
CleanUp;
|
||||
AcctRegWriteBranch("SparrowOS/Wenceslas","F64 best_score=%5.4f;\n",best_score);
|
||||
}
|
||||
|
||||
Wenceslas;
|
||||
y þÿÿÿ Úÿÿÿ Êÿÿÿ þÿÿÿÚÿÿÿ äÿÿÿ Öÿÿÿ
|
||||
ÐÿÿÿúÿÿÿÖÿÿÿôÿÿÿìÿÿÿüÿÿÿØÿÿÿúÿÿÿðÿÿÿüÿÿÿðÿÿÿ ÖÿÿÿüÿÿÿÔÿÿÿòÿÿÿæÿÿÿ ÒÿÿÿöÿÿÿÂÿÿÿþÿÿÿÔÿÿÿòÿÿÿ¼ÿÿÿþÿÿÿÎÿÿÿ ¼ÿÿÿþÿÿÿÔÿÿÿ ÊÿÿÿþÿÿÿØÿÿÿ äÿÿÿ Úÿÿÿ ÀÿÿÿþÿÿÿÎÿÿÿ ´ÿÿÿ Êÿÿÿ ªÿÿÿ ¶ÿÿÿøÿÿÿÈÿÿÿ ²ÿÿÿ ¬ÿÿÿ Æÿÿÿ
|
||||
¶ÿÿÿ Ìÿÿÿ ÌÿÿÿüÿÿÿÔÿÿÿèÿÿÿÚÿÿÿ Öÿÿÿ * ðÿÿÿüÿÿÿ ðÿÿÿ ðÿÿÿ èÿÿÿþÿÿÿòÿÿÿüÿÿÿæÿÿÿþÿÿÿæÿÿÿ àÿÿÿþÿÿÿèÿÿÿüÿÿÿòÿÿÿ æÿÿÿ ðÿÿÿþÿÿÿâÿÿÿ àÿÿÿ àÿÿÿ Þÿÿÿ Þÿÿÿ âÿÿÿ Þÿÿÿ Þÿÿÿýÿÿÿäÿÿÿ âÿÿÿþÿÿÿäÿÿÿüÿÿÿèÿÿÿüÿÿÿèÿÿÿüÿÿÿòÿÿÿ äÿÿÿ êÿÿÿ æÿÿÿþÿÿÿîÿÿÿ ìÿÿÿ òÿÿÿ x þÿÿÿèÿÿÿüÿÿÿòÿÿÿ ðÿÿÿ èÿÿÿ ðÿÿÿüÿÿÿ ðÿÿÿ þÿÿÿòÿÿÿüÿÿÿæÿÿÿþÿÿÿæÿÿÿ àÿÿÿ æÿÿÿ ðÿÿÿ ã öÿÿÿ ðÿÿÿøÿÿÿ
|
||||
ôÿÿÿ ðÿÿÿòÿÿÿ îÿÿÿ êÿÿÿ öÿÿÿæÿÿÿúÿÿÿæÿÿÿöÿÿÿèÿÿÿøÿÿÿæÿÿÿ æÿÿÿ øÿÿÿ îÿÿÿþÿÿÿòÿÿÿ þÿÿÿöÿÿÿôÿÿÿ îÿÿÿ ðÿÿÿ ðÿÿÿ þÿÿÿ üÿÿÿþÿÿÿäÿÿÿþÿÿÿäÿÿÿ îÿÿÿ äÿÿÿöÿÿÿöÿÿÿöÿÿÿðÿÿÿøÿÿÿ üÿÿÿüÿÿÿ ðÿÿÿ
|
||||
ðÿÿÿ øÿÿÿ úÿÿÿþÿÿÿ úÿÿÿúÿÿÿ ðÿÿÿ üÿÿÿúÿÿÿ
|
||||
üÿÿÿ üÿÿÿ øÿÿÿúÿÿÿøÿÿÿúÿÿÿðÿÿÿ òÿÿÿ ìÿÿÿ ô öÿÿÿ ðÿÿÿøÿÿÿ
|
||||
ôÿÿÿ ðÿÿÿòÿÿÿ îÿÿÿ êÿÿÿ öÿÿÿæÿÿÿúÿÿÿæÿÿÿöÿÿÿèÿÿÿøÿÿÿæÿÿÿ æÿÿÿ øÿÿÿ îÿÿÿþÿÿÿòÿÿÿ þÿÿÿöÿÿÿôÿÿÿ îÿÿÿ äÿÿÿúÿÿÿâÿÿÿ úÿÿÿ èÿÿÿúÿÿÿöÿÿÿòÿÿÿîÿÿÿöÿÿÿúÿÿÿöÿÿÿ øÿÿÿðÿÿÿöÿÿÿäÿÿÿôÿÿÿôÿÿÿüÿÿÿêÿÿÿþÿÿÿþÿÿÿ üÿÿÿ ôÿÿÿ ôÿÿÿ öÿÿÿ òÿÿÿ âÿÿÿþÿÿÿ úÿÿÿ öÿÿÿ òÿÿÿ üÿÿÿøÿÿÿðÿÿÿøÿÿÿ
|
||||
ôÿÿÿ
|
||||
üÿÿÿ J ³ ± »ÿÿÿfÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿÿÿÿÿLine truncated
|
||||
@@ -0,0 +1,173 @@
|
||||
#define NUM_BALLS 7
|
||||
#define NUM_SPRINGS 3
|
||||
|
||||
#define STRETCH 500.0
|
||||
#define GRAVITY 50.0 //not really gravity
|
||||
#define BALL_RADIUS 5
|
||||
#define BASE_SIZE 10
|
||||
|
||||
CMass balls[NUM_BALLS];
|
||||
CSpring springs[NUM_SPRINGS];
|
||||
F64 collision_t;
|
||||
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{
|
||||
I64 i,
|
||||
cx=task->win_pixel_width>>1,
|
||||
cy=task->win_pixel_height>>1;
|
||||
Bool snd_on=FALSE;
|
||||
dc->color=BLACK;
|
||||
GrPutS(dc,0,0,"Protect your base.");
|
||||
GrRect(dc,cx-BASE_SIZE,cy-BASE_SIZE,BASE_SIZE*2,BASE_SIZE*2);
|
||||
dc->color=CYAN;
|
||||
GrRect(dc,cx-BASE_SIZE+2,cy-BASE_SIZE+2,BASE_SIZE*2-4,BASE_SIZE*2-4);
|
||||
dc->color=YELLOW;
|
||||
GrLine(dc,balls[0].x,balls[0].y,
|
||||
ipx-task->win_pixel_left-task->win_scroll_x,
|
||||
ipy-task->win_pixel_top-task->win_scroll_y);
|
||||
for (i=0;i<NUM_SPRINGS;i++)
|
||||
GrLine(dc,springs[i].end1->x,springs[i].end1->y,
|
||||
springs[i].end2->x,springs[i].end2->y);
|
||||
|
||||
dc->color=LTCYAN;
|
||||
GrCircle(dc,balls[0].x,balls[0].y,BALL_RADIUS);
|
||||
GrFloodFill(dc,balls[0].x,balls[0].y,TRUE);
|
||||
dc->color=BLACK;
|
||||
GrCircle(dc,balls[0].x,balls[0].y,BALL_RADIUS);
|
||||
|
||||
for (i=1;i<NUM_BALLS;i++) {
|
||||
dc->color=LTPURPLE;
|
||||
GrCircle(dc,balls[i].x,balls[i].y,BALL_RADIUS);
|
||||
GrFloodFill(dc,balls[i].x,balls[i].y,TRUE);
|
||||
if (cx-BASE_SIZE-BALL_RADIUS<=balls[i].x<=cx+BASE_SIZE+BALL_RADIUS &&
|
||||
cy-BASE_SIZE-BALL_RADIUS<=balls[i].y<=cy+BASE_SIZE+BALL_RADIUS)
|
||||
snd_on=TRUE;
|
||||
dc->color=BLACK;
|
||||
GrCircle(dc,balls[i].x,balls[i].y,BALL_RADIUS);
|
||||
}
|
||||
if (snd_on)
|
||||
Snd(1000);
|
||||
else
|
||||
Snd(0);
|
||||
}
|
||||
|
||||
|
||||
U0 MyDerivative(CMathODE *ode,F64 t,COrder2D3 *,COrder2D3 *)
|
||||
{
|
||||
I64 i,j;
|
||||
F64 d,dd;
|
||||
CD3 p,p2;
|
||||
CTask *task=ode->win_task;
|
||||
|
||||
D3SubEqu(D3Equ(&p2,ipx-task->win_pixel_left-task->win_scroll_x,ipy-task->win_pixel_top-task->win_scroll_y,0),
|
||||
&balls[0].state->x);
|
||||
D3AddEqu(&balls[0].DstateDt->DxDt,D3MulEqu(&p2,STRETCH));
|
||||
|
||||
D3Equ(&p2,task->win_pixel_width>>1,task->win_pixel_height>>1,0);
|
||||
for (i=1;i<NUM_BALLS;i++) {
|
||||
D3Sub(&p2,&balls[i].state->x,&p);
|
||||
if (d=D3Norm(&p)) {
|
||||
//Gravity would be /(d*d*d), but that's too exponential.
|
||||
D3MulEqu(&p,GRAVITY/d);
|
||||
D3AddEqu(&balls[i].DstateDt->DxDt,&p);
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<NUM_BALLS;i++)
|
||||
for (j=i+1;j<NUM_BALLS;j++) {
|
||||
D3Sub(&balls[j].state->x,&balls[i].state->x,&p);
|
||||
dd=D3SqrNorm(&p);
|
||||
if (dd<=(2*BALL_RADIUS)*(2*BALL_RADIUS)) {
|
||||
if (t-collision_t>0.05) {
|
||||
Noise(50,5000,6000);
|
||||
collision_t=t;
|
||||
}
|
||||
d=Sqrt(dd)+0.0001;
|
||||
dd=10.0*Sqr(Sqr((2*BALL_RADIUS)*(2*BALL_RADIUS)-dd));
|
||||
D3MulEqu(&p,dd/d);
|
||||
D3AddEqu(&balls[j].DstateDt->DxDt,&p);
|
||||
D3SubEqu(&balls[i].DstateDt->DxDt,&p);
|
||||
}
|
||||
}
|
||||
|
||||
d=balls[0].state->x;
|
||||
if (d-BALL_RADIUS<0)
|
||||
balls[0].DstateDt->DxDt+=Sqr(Sqr(Sqr(d-BALL_RADIUS)));
|
||||
if (d+BALL_RADIUS>task->win_pixel_width)
|
||||
balls[0].DstateDt->DxDt-=Sqr(Sqr(Sqr((d+BALL_RADIUS)-task->win_pixel_width)));
|
||||
|
||||
d=balls[0].state->y;
|
||||
if (d-BALL_RADIUS<0)
|
||||
balls[0].DstateDt->DyDt+=Sqr(Sqr(Sqr(d-BALL_RADIUS)));
|
||||
if (d+BALL_RADIUS>task->win_pixel_height)
|
||||
balls[0].DstateDt->DyDt-=Sqr(Sqr(Sqr((d+BALL_RADIUS)-task->win_pixel_height)));
|
||||
}
|
||||
|
||||
|
||||
U0 Whap()
|
||||
{
|
||||
I64 i;
|
||||
CMathODE *ode=ODENew(0,1e-2,ODEF_HAS_MASSES);
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
WinMax;
|
||||
WordStat;
|
||||
Preempt(OFF);
|
||||
|
||||
MenuPush(
|
||||
"File {"
|
||||
" Abort(,CH_SHIFT_ESC);"
|
||||
" Exit(,CH_ESC);"
|
||||
"}"
|
||||
);
|
||||
ode->derivative=&MyDerivative;
|
||||
ode->drag_v2=0.002;
|
||||
ode->drag_v3=0.00001;
|
||||
ode->acceleration_limit=5e3;
|
||||
MemSet(balls,0,NUM_BALLS*sizeof(CMass));
|
||||
D3Equ(&balls[0].x,100,100,0);
|
||||
for (i=1;i<NUM_BALLS;i++)
|
||||
D3Equ(&balls[i].x,
|
||||
RandI16%500+Fs->win_pixel_width>>1,RandI16%500+Fs->win_pixel_height>>1,0);
|
||||
balls[0].x=ipx-Fs->win_pixel_left-Fs->win_scroll_x;
|
||||
balls[0].y=ipy-Fs->win_pixel_top-Fs->win_scroll_y;
|
||||
for (i=0;i<NUM_BALLS;i++) {
|
||||
balls[i].mass=1.0;
|
||||
balls[i].drag_profile_factor=1.0;
|
||||
QueIns(&balls[i],ode->last_mass);
|
||||
}
|
||||
balls[2].x=balls[1].x+15;
|
||||
balls[2].y=balls[1].y;
|
||||
balls[3].x=balls[1].x;
|
||||
balls[3].y=balls[1].y+15;
|
||||
MemSet(springs,0,NUM_SPRINGS*sizeof(CSpring));
|
||||
springs[0].end1=&balls[1];
|
||||
springs[0].end2=&balls[2];
|
||||
springs[0].rest_len=15;
|
||||
springs[0].constant=10000;
|
||||
QueIns(&springs[0],ode->last_spring);
|
||||
springs[1].end1=&balls[1];
|
||||
springs[1].end2=&balls[3];
|
||||
springs[1].rest_len=15;
|
||||
springs[1].constant=10000;
|
||||
QueIns(&springs[1],ode->last_spring);
|
||||
springs[2].end1=&balls[2];
|
||||
springs[2].end2=&balls[3];
|
||||
springs[2].rest_len=sqrt2*15;
|
||||
springs[2].constant=10000;
|
||||
QueIns(&springs[2],ode->last_spring);
|
||||
|
||||
collision_t=0;
|
||||
QueIns(ode,Fs->last_ode);
|
||||
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
GetChar;
|
||||
SettingsPop;
|
||||
QueRem(ode);
|
||||
ODEDel(ode);
|
||||
MenuPop;
|
||||
}
|
||||
|
||||
Whap;
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,94 @@
|
||||
/*
|
||||
This demonstrates dynamic initialization of
|
||||
vars. It even works for static modules
|
||||
because code is generated which runs at
|
||||
$LK,"Load","MN:Load"$() time to initialize them.
|
||||
|
||||
This file is dual use -- you can JIT compile
|
||||
it or static compile it. If you static compile
|
||||
then override the filename extension warning.
|
||||
|
||||
Static vars are, essentually, global var.
|
||||
*/
|
||||
|
||||
#ifstatic
|
||||
#include "::/SparrowOS/OSMain/StaticAdam.HPP.Z"
|
||||
#endif
|
||||
|
||||
class Test
|
||||
{
|
||||
I32 time;
|
||||
U8 name[8];
|
||||
};
|
||||
|
||||
Test g1[]={
|
||||
{10,"Name1"},
|
||||
{(tNP%10.0)*100,"Name2"}, //Dynamic initialization
|
||||
{30,"Name3"}
|
||||
};
|
||||
|
||||
D(g1,sizeof(g1));
|
||||
"Time 1:%d\n",g1[1].time;
|
||||
|
||||
U0 Main1()
|
||||
{
|
||||
static Test s1[]={
|
||||
{10,"Static1"},
|
||||
{(tNP%10.0)*100,"Static2"}, //Dynamic initialization
|
||||
{30,"Static3"}
|
||||
};
|
||||
D(s1,sizeof(s1));
|
||||
"Time 2:%d\n",s1[1].time;
|
||||
}
|
||||
|
||||
Main1;
|
||||
|
||||
|
||||
/*
|
||||
Now, we'll use the data heap glbl option
|
||||
to force global vars onto the data heap.
|
||||
You can't initialize heap glbls in a static
|
||||
module.
|
||||
|
||||
You can turn the data heap flag
|
||||
on and off within your programs, leaving
|
||||
ones which need initialization on the code heap.
|
||||
|
||||
You can't dynamically initialize data heap
|
||||
glbls--they are constants. This might be a silly
|
||||
point, but might result in odd differences, perhaps
|
||||
from the order things are evaluated.
|
||||
|
||||
Data heap glbls are good for static modules
|
||||
because they don't take-up room in the .BIN.Z file.
|
||||
*/
|
||||
|
||||
#ifnstatic
|
||||
#exe {OptOn(OPTf_GLBLS_ON_DATA_HEAP);};
|
||||
|
||||
Test g2[]={
|
||||
{10,"name1"},
|
||||
{(tNP%10.0)*100,"name2"}, //No dynamic initialization--converted to a constant
|
||||
{30,"name3"}
|
||||
};
|
||||
|
||||
D(g2,sizeof(g2));
|
||||
"Time 3:%d\n",g2[1].time;
|
||||
|
||||
U0 Main2()
|
||||
{
|
||||
static Test s2[]={
|
||||
{10,"static1"},
|
||||
{(tNP%10.0)*100,"static2"}, //No dynamic initialization--converted to a constant
|
||||
{30,"static3"}
|
||||
};
|
||||
D(s2,sizeof(s2));
|
||||
"Time 4:%d\n",s2[1].time;
|
||||
}
|
||||
|
||||
Main2;
|
||||
|
||||
#exe {OptOn(OPTf_GLBLS_ON_DATA_HEAP);};
|
||||
#endif
|
||||
|
||||
NewLine;
|
||||
@@ -0,0 +1,117 @@
|
||||
U0 Main()
|
||||
{
|
||||
F64 é=0,č=0,ę=0;
|
||||
CD3I32 poly[4];
|
||||
CDC *dc=DCAlias;
|
||||
DCAllocDepthBuf(dc);
|
||||
dc->flags|=DCF_TRANSFORMATION|DCF_SYMMETRY;
|
||||
try {
|
||||
while (!ScanChar) {
|
||||
DCDepthBufRst(dc);
|
||||
GrSetSymmetry(dc,Fs->win_pixel_width/2,Fs->win_pixel_height/2,
|
||||
ipx-Fs->win_pixel_left-Fs->win_scroll_x,
|
||||
ipy-Fs->win_pixel_top-Fs->win_scroll_y);
|
||||
dc->color=LTBLUE;
|
||||
GrLine(dc,Fs->win_pixel_width/2,Fs->win_pixel_height/2,
|
||||
ipx-Fs->win_pixel_left-Fs->win_scroll_x,
|
||||
ipy-Fs->win_pixel_top-Fs->win_scroll_y);
|
||||
|
||||
GrIdentEqu(dc->r);
|
||||
GrRotXEqu(dc->r,ę);
|
||||
GrRotYEqu(dc->r,č);
|
||||
GrRotZEqu(dc->r,é);
|
||||
GrSetRotMat(dc,dc->r);
|
||||
|
||||
dc->x=Fs->win_pixel_width/2;
|
||||
dc->y=Fs->win_pixel_height/2;
|
||||
dc->z=500;
|
||||
|
||||
dc->color=GREEN;
|
||||
poly[0].x=50;
|
||||
poly[0].y=150;
|
||||
poly[0].z=0;
|
||||
poly[1].x=275;
|
||||
poly[1].y=100;
|
||||
poly[1].z=0;
|
||||
poly[2].x=155;
|
||||
poly[2].y=200;
|
||||
poly[2].z=0;
|
||||
poly[3].x=100;
|
||||
poly[3].y=200;
|
||||
poly[3].z=0;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
|
||||
dc->color=RED;
|
||||
poly[0].x=50;
|
||||
poly[0].y=150;
|
||||
poly[0].z=50;
|
||||
poly[1].x=275;
|
||||
poly[1].y=100;
|
||||
poly[1].z=50;
|
||||
poly[2].x=155;
|
||||
poly[2].y=200;
|
||||
poly[2].z=50;
|
||||
poly[3].x=100;
|
||||
poly[3].y=200;
|
||||
poly[3].z=50;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
|
||||
dc->color=BLUE;
|
||||
poly[0].x=50;
|
||||
poly[0].y=150;
|
||||
poly[0].z=-50;
|
||||
poly[1].x=275;
|
||||
poly[1].y=100;
|
||||
poly[1].z=-50;
|
||||
poly[2].x=155;
|
||||
poly[2].y=200;
|
||||
poly[2].z=-50;
|
||||
poly[3].x=100;
|
||||
poly[3].y=200;
|
||||
poly[3].z=-50;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
|
||||
dc->color=RED+GREEN<<16+ROPF_DITHER;
|
||||
poly[0].x=50;
|
||||
poly[0].y=150;
|
||||
poly[0].z=50;
|
||||
poly[1].x=275;
|
||||
poly[1].y=100;
|
||||
poly[1].z=50;
|
||||
poly[2].x=275;
|
||||
poly[2].y=100;
|
||||
poly[2].z=0;
|
||||
poly[3].x=50;
|
||||
poly[3].y=150;
|
||||
poly[3].z=0;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
|
||||
dc->color=BLUE+GREEN<<16+ROPF_DITHER;
|
||||
poly[0].x=100;
|
||||
poly[0].y=200;
|
||||
poly[0].z=-50;
|
||||
poly[1].x=155;
|
||||
poly[1].y=200;
|
||||
poly[1].z=-50;
|
||||
poly[2].x=155;
|
||||
poly[2].y=200;
|
||||
poly[2].z=0;
|
||||
poly[3].x=100;
|
||||
poly[3].y=200;
|
||||
poly[3].z=0;
|
||||
GrFillPoly3(dc,4,poly);
|
||||
|
||||
WinMgrSync;
|
||||
DCFill;
|
||||
é+=2.1*ă/180.0;
|
||||
č+=1.1*ă/180.0;
|
||||
ę+=0.5*ă/180.0;
|
||||
}
|
||||
} catch
|
||||
CatchAll;
|
||||
|
||||
DCFill;
|
||||
DCDel(dc);
|
||||
}
|
||||
|
||||
Main;
|
||||
@@ -0,0 +1,32 @@
|
||||
U0 BSplineDemo()
|
||||
{
|
||||
CDC *dc=DCAlias;
|
||||
I64 p1,p2,i=0,msg_code;
|
||||
CD3I32 c[64];
|
||||
|
||||
SettingsPush;
|
||||
Fs->win_inhibit=WIF_ALL-WIF_BORDER;
|
||||
|
||||
"$$CL$$Select ctrl points with left mouse. Right when finished.\n";
|
||||
DCFill;
|
||||
do {
|
||||
msg_code=GetMsg(&p1,&p2,1<<MSG_IP_L_UP+1<<MSG_IP_R_UP);
|
||||
if (msg_code==MSG_IP_L_UP) {
|
||||
c[i].x=p1; c[i].y=p2; c[i].z=0;
|
||||
dc->color=GREEN;
|
||||
GrCircle(dc,p1,p2,10);
|
||||
i++;
|
||||
}
|
||||
} while (msg_code!=MSG_IP_R_UP);
|
||||
dc->color=RED;
|
||||
Gr2BSpline(dc,c,i,TRUE);
|
||||
dc->color=BLUE;
|
||||
Gr3BSpline(dc,c,i,TRUE);
|
||||
DCDel(dc);
|
||||
SettingsPop;
|
||||
|
||||
PressAKey;
|
||||
DCFill;
|
||||
}
|
||||
|
||||
BSplineDemo;
|
||||
@@ -0,0 +1,242 @@
|
||||
Bool chged;
|
||||
|
||||
#define DAWG_SETTINGS_SPACING 16
|
||||
#define DAWG_SETTINGS_RANGE 60
|
||||
#define DAWG_SETTINGS_BORDER 2
|
||||
|
||||
class DawgSettingsState
|
||||
{
|
||||
I64 cnt,n2_amp,color_scale;
|
||||
} glbl_state;
|
||||
|
||||
U0 DrawDawgSettingsCtrl(CDC *dc,CCtrl *c)
|
||||
{
|
||||
DawgSettingsState *s=c->state;
|
||||
|
||||
dc->color=LTRED;
|
||||
GrRect(dc, c->left,c->top,DAWG_SETTINGS_SPACING*4+3,DAWG_SETTINGS_SPACING*2+DAWG_SETTINGS_RANGE);
|
||||
dc->color=BLUE;
|
||||
GrRect(dc, c->left+DAWG_SETTINGS_BORDER,c->top+DAWG_SETTINGS_BORDER,
|
||||
DAWG_SETTINGS_SPACING*4+3-2*DAWG_SETTINGS_BORDER,DAWG_SETTINGS_SPACING*2+DAWG_SETTINGS_RANGE-2*DAWG_SETTINGS_BORDER);
|
||||
dc->color=BLACK;
|
||||
GrLine(dc,c->left+DAWG_SETTINGS_SPACING,c->top+DAWG_SETTINGS_SPACING,
|
||||
c->left+DAWG_SETTINGS_SPACING,c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1);
|
||||
GrLine(dc,c->left+2*DAWG_SETTINGS_SPACING+1,c->top+DAWG_SETTINGS_SPACING,
|
||||
c->left+2*DAWG_SETTINGS_SPACING+1,c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1);
|
||||
GrLine(dc,c->left+3*DAWG_SETTINGS_SPACING+1,c->top+DAWG_SETTINGS_SPACING,
|
||||
c->left+3*DAWG_SETTINGS_SPACING+1,c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1);
|
||||
|
||||
dc->color=LTRED;
|
||||
GrPrintF(dc,c->left+DAWG_SETTINGS_SPACING-FONT_WIDTH/2,
|
||||
c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE+3,
|
||||
"%d",s->cnt*10/DAWG_SETTINGS_RANGE);
|
||||
GrPrintF(dc,c->left+2*DAWG_SETTINGS_SPACING+1-FONT_WIDTH/2,
|
||||
c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE+3,
|
||||
"%d",s->n2_amp*10/DAWG_SETTINGS_RANGE);
|
||||
GrPrintF(dc,c->left+3*DAWG_SETTINGS_SPACING+2-FONT_WIDTH/2,
|
||||
c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE+3,
|
||||
"%d",s->color_scale*10/DAWG_SETTINGS_RANGE);
|
||||
GrRect(dc,c->left+DAWG_SETTINGS_SPACING-3, c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1-s->cnt-2 ,7,5);
|
||||
GrRect(dc,c->left+2*DAWG_SETTINGS_SPACING+1-3,c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1-s->n2_amp-2,7,5);
|
||||
GrRect(dc,c->left+3*DAWG_SETTINGS_SPACING+2-3,c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1-s->color_scale-2,7,5);
|
||||
dc->color=YELLOW;
|
||||
GrRect(dc,c->left+DAWG_SETTINGS_SPACING-2, c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1-s->cnt-1 ,5,3);
|
||||
GrRect(dc,c->left+2*DAWG_SETTINGS_SPACING+1-2,c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1-s->n2_amp-1,5,3);
|
||||
GrRect(dc,c->left+3*DAWG_SETTINGS_SPACING+2-2,c->top+DAWG_SETTINGS_SPACING+DAWG_SETTINGS_RANGE-1-s->color_scale-1,5,3);
|
||||
}
|
||||
|
||||
U0 UpdateDerivedDawgSettingsCtrl(CCtrl *c)
|
||||
{
|
||||
DawgSettingsState *s=c->state;
|
||||
c->left=c->win_task->win_pixel_width-(DAWG_SETTINGS_SPACING*4+3);
|
||||
c->right=c->left+DAWG_SETTINGS_SPACING*4+3;
|
||||
c->top=c->win_task->win_pixel_height-(DAWG_SETTINGS_SPACING*2+DAWG_SETTINGS_RANGE);
|
||||
c->bottom=c->top+DAWG_SETTINGS_SPACING*2+DAWG_SETTINGS_RANGE;
|
||||
s->cnt =LimitI64(s->cnt,0,DAWG_SETTINGS_RANGE-1);
|
||||
s->n2_amp=LimitI64(s->n2_amp,0,DAWG_SETTINGS_RANGE-1);
|
||||
s->color_scale=LimitI64(s->color_scale,0,DAWG_SETTINGS_RANGE-1);
|
||||
}
|
||||
|
||||
U0 LeftClickDawgSettings(CCtrl *c,I64 x,I64 y,Bool down)
|
||||
{
|
||||
DawgSettingsState *s=c->state;
|
||||
if (x<c->left+(c->right-c->left)/3)
|
||||
s->cnt=DAWG_SETTINGS_RANGE-1-(y-(c->top+DAWG_SETTINGS_SPACING));
|
||||
else if (x<c->left+2*(c->right-c->left)/3)
|
||||
s->n2_amp=DAWG_SETTINGS_RANGE-1-(y-(c->top+DAWG_SETTINGS_SPACING));
|
||||
else
|
||||
s->color_scale=DAWG_SETTINGS_RANGE-1-(y-(c->top+DAWG_SETTINGS_SPACING));
|
||||
if (c->update_derived_vals)
|
||||
(*c->update_derived_vals)(c);
|
||||
if (!down) chged=TRUE;
|
||||
}
|
||||
|
||||
CCtrl *DawgSettingsNew()
|
||||
{
|
||||
Bool old_preempt;
|
||||
CCtrl *c=CAlloc(sizeof(CCtrl));
|
||||
c->win_task=Fs;
|
||||
c->flags=CTRLF_SHOW|CTRLF_CAPTURE_LEFT_IP;
|
||||
c->type=CTRLT_GENERIC;
|
||||
// c->state=CAlloc(sizeof(DawgSettingsState));
|
||||
c->state=&glbl_state;
|
||||
glbl_state.cnt=DAWG_SETTINGS_RANGE/2;
|
||||
glbl_state.n2_amp=DAWG_SETTINGS_RANGE/2;
|
||||
glbl_state.color_scale=DAWG_SETTINGS_RANGE/2;
|
||||
c->draw_it=&DrawDawgSettingsCtrl;
|
||||
c->left_click=&LeftClickDawgSettings;
|
||||
c->update_derived_vals=&UpdateDerivedDawgSettingsCtrl;
|
||||
old_preempt=Preempt(OFF);
|
||||
QueIns(c,Fs->last_ctrl);
|
||||
TaskDerivedValsUpdate;
|
||||
Preempt(old_preempt);
|
||||
return c;
|
||||
}
|
||||
|
||||
U0 DawgSettingsDel(CCtrl *c)
|
||||
{
|
||||
Bool old_preempt=Preempt(OFF);
|
||||
QueRem(c);
|
||||
Preempt(old_preempt);
|
||||
// Free(c->state);
|
||||
Free(c);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//This program does a fractel-like thing with
|
||||
//integer arithmetic.
|
||||
|
||||
class Simplex //This is something I made-up. It's not standard math.
|
||||
{
|
||||
I64 x,y;
|
||||
};
|
||||
|
||||
I64 Norm(Simplex *n1)
|
||||
{
|
||||
return AbsI64(n1->x)+AbsI64(n1->y);
|
||||
}
|
||||
|
||||
Simplex *CopySimplex(Simplex *dst, Simplex *src)
|
||||
{
|
||||
Simplex *result;
|
||||
MemCpy(dst,src,sizeof(Simplex));
|
||||
return dst;
|
||||
}
|
||||
|
||||
|
||||
Simplex *Mix(Simplex *result,Simplex *n1,Simplex *n2)
|
||||
{ //This is something I made-up. It's not standard math.
|
||||
result->x=n1->x*n2->x;
|
||||
result->y=n1->y*n2->y;
|
||||
return result;
|
||||
}
|
||||
|
||||
Simplex *Mangle(Simplex *result,Simplex *n1,Simplex *n2)
|
||||
{ //This is something I made-up. It's not standard math.
|
||||
result->x=n1->x*n2->y;
|
||||
result->y=n1->y*n2->x;
|
||||
return result;
|
||||
}
|
||||
|
||||
Simplex *Add(Simplex *result,Simplex *n1,Simplex *n2)
|
||||
{
|
||||
result->x=n1->x+n2->x;
|
||||
result->y=n1->y+n2->y;
|
||||
return result;
|
||||
}
|
||||
|
||||
Simplex *Sub(Simplex *result,Simplex *n1,Simplex *n2)
|
||||
{
|
||||
result->x=n1->x-n2->x;
|
||||
result->y=n1->y-n2->y;
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
U0 Bling()
|
||||
{
|
||||
I64 ch;
|
||||
I64 x,y,cnt;
|
||||
I64 d;
|
||||
F64 color,color_scale;
|
||||
Simplex n1,n2,n3,n4,n5,n6,n7,n8;
|
||||
F64 timeout_time;
|
||||
CCtrl *c=DawgSettingsNew;
|
||||
CDC *dc=DCAlias;
|
||||
F64 e=Exp(1);
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
DocCursor;
|
||||
DocClear;
|
||||
Fs->win_inhibit=WIF_ALL-WIF_BORDER-WIF_CTRLS;
|
||||
|
||||
chged=FALSE;
|
||||
WordStat;
|
||||
WinMax;
|
||||
while (TRUE) {
|
||||
next_dotel:
|
||||
ch=0;
|
||||
cnt =2e9*(RandU32+0x1000)/MAX_U32*((Exp(ToF64(glbl_state.cnt +10)/DAWG_SETTINGS_RANGE)-1)/e);
|
||||
n2.x=2e9*Sign(RandI32)*(RandU32+0x1000)/MAX_U32*((Exp(ToF64(glbl_state.n2_amp)/DAWG_SETTINGS_RANGE)-1)/e);
|
||||
n2.y=2e9*Sign(RandI32)*(RandU32+0x1000)/MAX_U32*((Exp(ToF64(glbl_state.n2_amp)/DAWG_SETTINGS_RANGE)-1)/e);
|
||||
n8.x=RandI32;
|
||||
n8.y=RandI32;
|
||||
color_scale=4.0*(glbl_state.color_scale+1.0)/DAWG_SETTINGS_RANGE+0.5;
|
||||
timeout_time=tNP+0.1;
|
||||
for (y=0;y<GR_HEIGHT;y++) {
|
||||
if (y<20)
|
||||
if (tNP>timeout_time)
|
||||
goto next_dotel;
|
||||
if (ScanKey(&ch))
|
||||
goto next_dotel;
|
||||
for (x=0;x<GR_WIDTH;x++) {
|
||||
if (y<20)
|
||||
if (tNP>timeout_time)
|
||||
goto next_dotel;
|
||||
|
||||
n1.x=x; n1.y=y;
|
||||
CopySimplex(&n3,&n1);
|
||||
|
||||
color=0;
|
||||
d=Norm(&n3);
|
||||
|
||||
//This doesn't make mathematical sense, but it makes nice results.
|
||||
while (d.u32[0]<cnt && color<65536) {
|
||||
if (y<20)
|
||||
if (tNP>timeout_time)
|
||||
goto next_dotel;
|
||||
Mangle(&n7,Mix(&n4,&n3,&n1),
|
||||
Add(&n5,&n3,&n2));
|
||||
color++;
|
||||
d=Norm(Add(&n3,&n7,Mangle(&n6,&n3,&n8)));
|
||||
}
|
||||
color-=(cnt-d.u32[0])/cnt;
|
||||
dc->color=ROP_EQU+
|
||||
color=gr_rainbow_10[LimitI64(color_scale*(Ln(color)),0,9)];
|
||||
GrPlot(dc,x,y);
|
||||
}
|
||||
}
|
||||
dc->color=COLOR_TRANSPARENT;
|
||||
GrRect(dc,c->left,c->top,c->right-c->left,c->bottom-c->top);
|
||||
while (TRUE) {
|
||||
if (chged) {
|
||||
chged=FALSE;
|
||||
break;
|
||||
}
|
||||
if (ch=ScanChar)
|
||||
if (ch==CH_SPACE||ch==CH_NEW_LINE)
|
||||
break;
|
||||
else
|
||||
goto bling_done;
|
||||
WinMgrSync;
|
||||
}
|
||||
}
|
||||
bling_done:
|
||||
SettingsPop;
|
||||
DCDel(dc);
|
||||
DCFill;
|
||||
DawgSettingsDel(c);
|
||||
}
|
||||
|
||||
Bling; //Start when included
|
||||
@@ -0,0 +1,34 @@
|
||||
U0 DrawIt(CTask *task,CDC *dc)
|
||||
{ //This routine is called by the window mgr task.
|
||||
GrPrintF(dc,0,0*FONT_HEIGHT,"tNP:%4.3f tP:%4.3f",tNP,tP(task));
|
||||
|
||||
//default 2.5Hz
|
||||
if (Blink)
|
||||
GrPutS(dc,0,1*FONT_HEIGHT,"Blink");
|
||||
|
||||
//10 Hz
|
||||
if (Blink(10))
|
||||
GrPutS(dc,0,2*FONT_HEIGHT,"Blink(10)");
|
||||
|
||||
//$LK,"tNP","MN:tNP"$ is a float var with time in seconds, function actually.
|
||||
//You can skip arguments if they have defaults.
|
||||
if (Blink(,tNP))
|
||||
GrPutS(dc,0,3*FONT_HEIGHT,"Blink(,tNP)");
|
||||
|
||||
//$LK,"tP","MN:tP"$ is a pausable function.
|
||||
if (Blink(,tP(task)))
|
||||
GrPutS(dc,0,4*FONT_HEIGHT,"Blink(,tP(task))");
|
||||
}
|
||||
|
||||
U0 BlinkDemo()
|
||||
{
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
Fs->draw_it=&DrawIt;
|
||||
DocClear;
|
||||
NewLine(10);
|
||||
"Pause and unpause task with $$FG,GREEN$$<CTRL-ALT-P>$$FG$$\n";
|
||||
PressAKey;
|
||||
SettingsPop;
|
||||
}
|
||||
|
||||
BlinkDemo;
|
||||
@@ -0,0 +1,41 @@
|
||||
CDC *dc=DCAlias;
|
||||
CDC *img1=DCNew(DCT_COLOR8,64,64);
|
||||
CDC *img2=DCNew(DCT_COLOR8,512,512);
|
||||
|
||||
img1->color=COLOR_MONO;
|
||||
img1->pen_width=3;
|
||||
GrCircle(img1,30,30,20);
|
||||
GrFloodFill3(img1,30,30,0,TRUE);
|
||||
GrLine3(img1,60,0,0,0,60,0);
|
||||
|
||||
DCFill(img2);
|
||||
img2->color=ROP_EQU+RED;
|
||||
img2->brush=img1;
|
||||
GrCircle(img2,256-30,256-30,128,67);
|
||||
img2->color=BLUE;
|
||||
img2->pen_width=6;
|
||||
img2->brush=NULL;
|
||||
GrLine3(img2,128,128,0,256+128,256+128,0);
|
||||
GrLine3(img2,256+128,128,0,128,256+128,0);
|
||||
|
||||
img2->color=YELLOW;
|
||||
GrRect(img2,256-20,256-20,40,40);
|
||||
|
||||
I64 i;
|
||||
for (i=0;i<256;i+=4) {
|
||||
WinMgrSync;
|
||||
DCFill;
|
||||
GrBlot(dc,i-256,i-256,img2);
|
||||
Sleep(10);
|
||||
}
|
||||
U8 *tempg=DC2Sprite(img1);
|
||||
PutSprite(tempg);
|
||||
Free(tempg);
|
||||
NewLine(9);
|
||||
|
||||
DCDel(img1);
|
||||
DCDel(img2);
|
||||
DCDel(dc);
|
||||
|
||||
PressAKey;
|
||||
DCFill;
|
||||
@@ -0,0 +1,57 @@
|
||||
//This uses $LK,"fixed-point-arithmetic","FI:::/SparrowOS/Demo/Lectures/FixedPoint.CPP.Z"$.
|
||||
|
||||
I64 x[16],y[16],dx[16],dy[16];
|
||||
|
||||
U0 Init()
|
||||
{
|
||||
I64 i;
|
||||
F64 é;
|
||||
MemSet(x,0,sizeof(x));
|
||||
MemSet(y,0,sizeof(y));
|
||||
for (i=0;i<16;i++) {
|
||||
é=Rand*2*ã;
|
||||
dx[i]=MAX_I32*Cos(é);
|
||||
dy[i]=MAX_I32*Sin(é);
|
||||
}
|
||||
}
|
||||
|
||||
U0 Bounce()
|
||||
{
|
||||
CDC *dc=DCAlias;
|
||||
I64 i,msg_code,p1,update;
|
||||
Init;
|
||||
try { //Catch <CTRL-ALT-C>
|
||||
while (TRUE) {
|
||||
update=win_updates;
|
||||
do for (i=0;i<16;i++) {
|
||||
dc->color=i;
|
||||
GrPlot(dc,x[i].i32[1],y[i].i32[1]);
|
||||
x[i]+=dx[i];
|
||||
y[i]+=dy[i];
|
||||
if (!(0<=x[i]<Fs->win_pixel_width<<32)) {
|
||||
x[i]-=dx[i];
|
||||
dx[i]=-dx[i];
|
||||
}
|
||||
if (!(0<=y[i]<Fs->win_pixel_height<<32)) {
|
||||
y[i]-=dy[i];
|
||||
dy[i]=-dy[i];
|
||||
}
|
||||
}
|
||||
while (update==win_updates);
|
||||
while (msg_code=ScanMsg(&p1,NULL,1<<MSG_KEY_DOWN|1<<MSG_RESIZE|1<<MSG_MOVE))
|
||||
if (msg_code==MSG_KEY_DOWN) {
|
||||
if (p1==CH_SHIFT_ESC || p1==CH_ESC)
|
||||
goto bc_done;
|
||||
else
|
||||
Init;
|
||||
} else
|
||||
DCFill(dc);
|
||||
}
|
||||
bc_done:
|
||||
} catch
|
||||
CatchAll;
|
||||
DCFill(dc);
|
||||
DCDel(dc);
|
||||
}
|
||||
|
||||
Bounce;
|
||||
@@ -0,0 +1,53 @@
|
||||
CDC *dc;
|
||||
|
||||
U0 DrawIt(CTask *,CDC *)
|
||||
{
|
||||
dc->pen_width=2;
|
||||
dc->color=RED;
|
||||
GrLine3(dc,-100,-100,-100, -100, 100,-100);
|
||||
GrLine3(dc,-100, 100,-100, 100, 100,-100);
|
||||
GrLine3(dc, 100, 100,-100, 100,-100,-100);
|
||||
GrLine3(dc, 100,-100,-100, -100,-100,-100);
|
||||
GrLine3(dc,-100,-100, 100, -100, 100, 100);
|
||||
GrLine3(dc,-100, 100, 100, 100, 100, 100);
|
||||
GrLine3(dc, 100, 100, 100, 100,-100, 100);
|
||||
GrLine3(dc, 100,-100, 100, -100,-100, 100);
|
||||
GrLine3(dc,-100,-100, 100, -100,-100,-100);
|
||||
GrLine3(dc,-100, 100, 100, -100, 100,-100);
|
||||
GrLine3(dc, 100, 100, 100, 100, 100,-100);
|
||||
GrLine3(dc, 100,-100, 100, 100,-100,-100);
|
||||
}
|
||||
|
||||
U0 Box()
|
||||
{
|
||||
F64 é=0,è=0,ê=0,s=1,s1=1.05;
|
||||
dc=DCAlias(gr_dc,Fs);
|
||||
|
||||
SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
|
||||
DocClear;
|
||||
Fs->draw_it=&DrawIt;
|
||||
Preempt(OFF); //We don't want matrix used while we're changing it.
|
||||
|
||||
dc->x=200;
|
||||
dc->y=200;
|
||||
dc->flags|=DCF_TRANSFORMATION;
|
||||
while (!ScanChar) {
|
||||
GrIdentEqu(dc->r);
|
||||
GrRotZEqu(dc->r,é);
|
||||
GrRotXEqu(dc->r,è);
|
||||
GrRotZEqu(dc->r,ê);
|
||||
GrScaleMatEqu(dc->r,s);
|
||||
GrSetRotMat(dc,dc->r);
|
||||
|
||||
Sleep(20);
|
||||
é+=2*ã/70;
|
||||
è +=2*ã/90;
|
||||
ê +=2*ã/110;
|
||||
s *=s1;
|
||||
if ( !(0.2<s<1.4) ) s1=1/s1;
|
||||
}
|
||||
SettingsPop;
|
||||
DCDel(dc);
|
||||
}
|
||||
|
||||
Box;
|
||||
Loaded 100 of 1218 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user