/******************************************************************************
Function: void face_punch_blood(void)
By: David Schwartz
Date: Mar 1995
Parameters: current_proc->a11 - dude to bloody
Returns: None
Description: hit in the face blood
******************************************************************************/
void face_punch_blood(void)
{
current_proc->a11=(ADDRESS)current_proc->pa8;
if (random()>0)
{
(long)current_proc->a0=1; // xvel range
(long)current_proc->a1=SCX(0x30000); // xvel min
(long)current_proc->a2=SCY(0x20000); // yvel range
(long)current_proc->a3=SCY(0x20000); // yvel min
current_proc->a4=SCY(0x0010)<<16|(-SCX(0x10));
current_proc->a5=0x00040002;
spawn_drip_neg;
}
/* face3 */
get_tg_blood;
lineup_1pwm(current_proc->pa8,(OBJECT *)current_proc->a11);
flip_single(current_proc->pa8);
current_proc->a0=((OBJECT*)current_proc->a11)->ochar;
if (current_proc->a0==FT_JAX)
multi_adjust_xy(current_proc->pa8,SCX(0xc),SCY(0x15));
else multi_adjust_xy(current_proc->pa8,SCX(0x8),SCY(0x10));
(current_proc->pa8)->oyvel.pos=-SCY(0x8000);
set_proj_vel(current_proc->pa8,SCX(0x10000),-1);
insert_object(current_proc->pa8,&objlst);
current_proc->pa9=a_face_blood;
framew(3);
blood_death(current_proc->pa8);
}
static void
draw_rect(DiaRenderer *self,
Point *ul_corner, Point *lr_corner,
Color *fill, Color *stroke)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HPEN hPen;
DIAG_NOTE(renderer, "draw_rect %f,%f -> %f,%f\n",
ul_corner->x, ul_corner->y, lr_corner->x, lr_corner->y);
if (fill) {
W32::HGDIOBJ hBrush, hBrOld;
W32::COLORREF rgb = W32COLOR(fill);
hBrush = W32::CreateSolidBrush(rgb);
hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
W32::Rectangle (renderer->hFileDC,
SCX(ul_corner->x), SCY(ul_corner->y),
SCX(lr_corner->x), SCY(lr_corner->y));
W32::SelectObject (renderer->hFileDC,
W32::GetStockObject (HOLLOW_BRUSH) );
W32::DeleteObject(hBrush);
}
if (stroke) {
hPen = UsePen(renderer, stroke);
W32::Rectangle (renderer->hFileDC,
SCX(ul_corner->x), SCY(ul_corner->y),
SCX(lr_corner->x), SCY(lr_corner->y));
DonePen(renderer, hPen);
}
}
static void
draw_bezier(DiaRenderer *self,
BezPoint *points,
int numpoints,
Color *colour)
{
WpgRenderer *renderer = WPG_RENDERER (self);
WPGPoint* pts;
guint16 data[2];
int i;
DIAG_NOTE(g_message("draw_bezier n:%d %fx%f ...",
numpoints, points->p1.x, points->p1.y));
WriteLineAttr(renderer, colour);
WriteRecHead(renderer, WPG_POLYCURVE, (3 * numpoints - 2) * sizeof(WPGPoint) + 3 * sizeof(guint16));
pts = g_new(WPGPoint, 3 * numpoints - 2);
/* ??? size of equivalent data in pre5.1 files ? DWORD */
memset (data, 0, sizeof(guint16) * 2);
fwrite_le(data, sizeof(guint16), 2, renderer->file);
/* num points */
data[0] = 3 * numpoints - 2;
fwrite_le(data, sizeof(guint16), 1, renderer->file);
/* WPG's Poly Curve is a cubic bezier compatible with Dia's bezier.
* http://www.fileformat.info/format/wpg/egff.htm
* could lead to the assumption of ony quadratic bezier support,
* but that's not the case.
*/
pts[0].x = SCX( points[0].p1.x);
pts[0].y = SCY(-points[0].p1.y);
for (i = 1; i < numpoints; i++)
{
switch (points[i].type)
{
case BEZ_MOVE_TO:
case BEZ_LINE_TO:
/* just the point */
pts[i*3-2].x = pts[i*3-1].x = pts[i*3].x = SCX( points[i].p1.x);
pts[i*3-2].y = pts[i*3-1].y = pts[i*3].y = SCY(-points[i].p1.y);
break;
case BEZ_CURVE_TO:
/* first control point */
pts[i*3-2].x = SCX( points[i].p1.x);
pts[i*3-2].y = SCY(-points[i].p1.y);
/* second control point */
pts[i*3-1].x = SCX( points[i].p2.x);
pts[i*3-1].y = SCY(-points[i].p2.y);
/* this segments end point */
pts[i*3].x = SCX( points[i].p3.x);
pts[i*3].y = SCY(-points[i].p3.y);
break;
}
}
fwrite_le(pts, sizeof(gint16), 2*(numpoints*3-2), renderer->file);
g_free(pts);
}
static void
draw_arc(DiaRenderer *self,
Point *center,
real width, real height,
real angle1, real angle2,
Color *colour)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HPEN hPen;
W32::POINT ptStart, ptEnd;
DIAG_NOTE(renderer, "draw_arc %fx%f <%f,<%f @%f,%f\n",
width, height, angle1, angle2, center->x, center->y);
hPen = UsePen(renderer, colour);
/* calculate start and end points of arc */
ptStart.x = SCX(center->x + (width / 2.0) * cos((M_PI / 180.0) * angle1));
ptStart.y = SCY(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle1));
ptEnd.x = SCX(center->x + (width / 2.0) * cos((M_PI / 180.0) * angle2));
ptEnd.y = SCY(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle2));
W32::MoveToEx(renderer->hFileDC, ptStart.x, ptStart.y, NULL);
W32::Arc(renderer->hFileDC,
SCX(center->x - width / 2), /* bbox corners */
SCY(center->y - height / 2),
SCX(center->x + width / 2),
SCY(center->y + height / 2),
ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
DonePen(renderer, hPen);
}
static void
draw_ellipse(DiaRenderer *self,
Point *center,
real width, real height,
Color *fill, Color *stroke)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HPEN hPen;
W32::HGDIOBJ hBrush, hBrOld;
DIAG_NOTE(renderer, "draw_ellipse %fx%f @ %f,%f\n",
width, height, center->x, center->y);
if (fill) {
W32::COLORREF rgb = W32COLOR(fill);
hBrush = W32::CreateSolidBrush(rgb);
hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
}
if (stroke)
hPen = UsePen(renderer, stroke);
W32::Ellipse(renderer->hFileDC,
SCX(center->x - width / 2), /* bbox corners */
SCY(center->y - height / 2),
SCX(center->x + width / 2),
SCY(center->y + height / 2));
if (stroke)
DonePen(renderer, hPen);
if (fill) {
W32::SelectObject(renderer->hFileDC,
W32::GetStockObject (HOLLOW_BRUSH) );
W32::DeleteObject(hBrush);
}
}
void swat_crossing_people(void)
{
OBJECT *odog,*owagon;
void *dogani,*wagonani;
current_proc->pdata.p_otherguy=current_proc->pa8;
process_sleep(0x50);
/* create dog */
get_char_ani(ANIM_TABLE2,ANIM_F2_FRIEND); // get ptr to anim table
dogani=current_proc->pa9;
current_proc->pa9=COMPUTE_ADDR((current_proc->pa8)->oheap,GET_LONG(current_proc->pa9)); // get ptr to frame
gso_dmawnz(odog,(ADDRESS)current_proc->pa9,(current_proc->pa8)->oheap,0);
alloc_cache((OIMGTBL *)current_proc->pa9,(current_proc->pa8)->oheap,odog);
odog->oxpos.u.intpos=worldtlx.u.intpos-SCX(0x30);
odog->oxvel.pos=SCX(0x30000);
odog->oypos.u.intpos=ground_y-SCY(0x20);
odog->ozval=100;
insert_object(odog,&objlst);
/* create wagon */
get_char_ani(ANIM_TABLE2,ANIM_F3_FRIEND); // get ptr to anim table
wagonani=current_proc->pa9;
current_proc->pa9=COMPUTE_ADDR((current_proc->pa8)->oheap,GET_LONG(current_proc->pa9)); // get ptr to frame
gso_dmawnz(owagon,(ADDRESS)current_proc->pa9,(current_proc->pa8)->oheap,0);
alloc_cache((OIMGTBL *)current_proc->pa9,(current_proc->pa8)->oheap,owagon);
match_ani_points(odog,owagon); // match to two
multi_adjust_xy(owagon,-66,-25); // lineup wagon with dog
owagon->oxvel.pos=SCX(0x30000); // set speed to match dog
owagon->ozval=200;
insert_object(owagon,&objlst);
/* cross */
do
{
process_sleep(3);
/* update dog */
current_proc->pa8=odog;
current_proc->pa9=dogani;
frame_a9(odog);
dogani=current_proc->pa9;
/* update wagon */
current_proc->pa8=owagon;
current_proc->pa9=wagonani;
frame_a9(owagon);
wagonani=current_proc->pa9;
} while (abs(worldtlx.u.intpos-odog->oxpos.u.intpos)<700);
delobjp(odog);
delobjp(owagon);
process_suicide();
}
static void
_bezier (DiaRenderer *self,
BezPoint *points,
int numpoints,
Color *colour,
gboolean fill,
gboolean closed)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HGDIOBJ hBrush, hBrOld;
W32::HPEN hPen;
W32::COLORREF rgb = W32COLOR(colour);
DIAG_NOTE(renderer, "_bezier n:%d %fx%f ...\n",
numpoints, points->p1.x, points->p1.y);
if (fill) {
hBrush = W32::CreateSolidBrush(rgb);
hBrOld = W32::SelectObject(renderer->hFileDC, hBrush);
} else {
hPen = UsePen(renderer, colour);
}
W32::BeginPath (renderer->hFileDC);
for (int i = 0; i < numpoints; ++i) {
switch (points[i].type) {
case BezPoint::BEZ_MOVE_TO :
W32::MoveToEx (renderer->hFileDC, SCX(points[i].p1.x), SCY(points[i].p1.y), NULL);
break;
case BezPoint::BEZ_LINE_TO :
W32::LineTo (renderer->hFileDC, SCX(points[i].p1.x), SCY(points[i].p1.y));
break;
case BezPoint::BEZ_CURVE_TO :
{
W32::POINT pts[3] = {
{SCX(points[i].p1.x), SCY(points[i].p1.y)},
{SCX(points[i].p2.x), SCY(points[i].p2.y)},
{SCX(points[i].p3.x), SCY(points[i].p3.y)}
};
W32::PolyBezierTo (renderer->hFileDC, pts, 3);
}
break;
}
}
if (closed)
W32::CloseFigure (renderer->hFileDC);
W32::EndPath (renderer->hFileDC);
if (fill) {
W32::FillPath (renderer->hFileDC);
W32::SelectObject(renderer->hFileDC,
W32::GetStockObject (HOLLOW_BRUSH) );
W32::DeleteObject(hBrush);
} else {
W32::StrokePath (renderer->hFileDC);
DonePen(renderer, hPen);
}
}
static void
draw_bezier(DiaRenderer *self,
BezPoint *points,
int numpoints,
Color *colour)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HPEN hPen;
W32::POINT * pts;
int i;
DIAG_NOTE(renderer, "draw_bezier n:%d %fx%f ...\n",
numpoints, points->p1.x, points->p1.y);
pts = g_new(W32::POINT, (numpoints-1) * 3 + 1);
pts[0].x = SCX(points[0].p1.x);
pts[0].y = SCY(points[0].p1.y);
for (i = 1; i < numpoints; i++)
{
switch(points[i].type)
{
case _BezPoint::BEZ_MOVE_TO:
g_warning("only first BezPoint can be a BEZ_MOVE_TO");
break;
case _BezPoint::BEZ_LINE_TO:
/* everyhing the same ?*/
pts[i*3-2].x = pts[i*3-1].x =
pts[i*3 ].x = SCX(points[i].p1.x);
pts[i*3-2].y = pts[i*3-1].y =
pts[i*3 ].y = SCY(points[i].p1.y);
break;
case _BezPoint::BEZ_CURVE_TO:
/* control points */
pts[i*3-2].x = SCX(points[i].p1.x);
pts[i*3-2].y = SCY(points[i].p1.y);
pts[i*3-1].x = SCX(points[i].p2.x);
pts[i*3-1].y = SCY(points[i].p2.y);
/* end point */
pts[i*3 ].x = SCX(points[i].p3.x);
pts[i*3 ].y = SCY(points[i].p3.y);
break;
default:
break;
}
}
hPen = UsePen(renderer, colour);
W32::PolyBezier(renderer->hFileDC,
pts, (numpoints-1)*3+1);
DonePen(renderer, hPen);
g_free(pts);
}
/*
pa0 - scale factor for x speed
pa1 - scale factor for y speed
pa10 - address of path
*/
WORD follow_path(long pa0,long pa1,PATHPTR *pa10)
{
OBJECT *obj=current_proc->pa8;
/* fp_e0 */
do
{
if (pa10->p_xvel==SCX(0xeac) && pa10->p_yvel==SCY(0xeac))
{
/* fpp9 */
return(SYSTEM_CARRY_CLR);
}
obj->oxvel.pos=safe32mult(pa10->p_xvel,pa0);
obj->oyvel.pos=safe32mult(pa10->p_yvel,pa1);
//obj->oxvel.pos=pa10->p_xvel;
//obj->oyvel.pos=pa10->p_yvel;
current_proc->a11=pa10->p_time;
/* fp_e2 */
do
{
if (obj->oxpos.u.intpos<-SCX(40))
obj->oxpos.u.intpos=-SCX(40);
if (obj->oxpos.u.intpos>SCX(440))
obj->oxpos.u.intpos=SCX(440);
process_sleep(1);
if (are_we_shot()==SYSTEM_CARRY_SET)
{
return(fp_9d());
}
if (are_we_hitting_player()!=0)
{
kill_player();
return(fp_9d());
}
/* fp_e3 */
if (randper(pa10->p_shot+shoot_randper)==SYSTEM_CARRY_SET)
{
start_enemy_missile();
//start_enemy_missile();
}
/* fp_e4 */
}
while(--current_proc->a11>0);
pa10++;
}
while(1);
}
void hatb_drip(void)
{
(OBJECT *)current_proc->a11=current_proc->pa8;
get_jt_blood;
a11_blood_lineup(SCX(0x10),SCY(0x60));
set_proj_vel(current_proc->pa8,SCX(0x20000)+randu(SCX(0x60000)),-1);
stack_jump(drip_entry);
}
int check_direction( int dir ) {
int pos, tile;
if( !dir ) {
msg("You have to specify a direction when building a mine (i.e. 'build mine to the north').");
return -1;
}
set_direction(SINVERT_C(dir));
// Multiply up.
dir = SMAKE_C(SCX(dir)*5, SCY(dir)*3, 0);
pos = OFFSET_C(this_player()->query_coord(), dir);
// Snap to grid
pos = MAKE_C(((CX(pos)-1) / 5) * 5 + 1, ((CY(pos)-1) / 3) * 3 + 1, 0);
// Now check to see if the tiletype is valid. Query the center of the tile
// to make life a bit easier.
tile = environment(this_player())->get_tiletype(CX(pos)+2, CY(pos)+1);
if( !tile ) {
msg("You can't build off the edge of the map.");
return -1;
}
tile -= '0'; // get_tiletype uses the zbuffer, which offsets by '0' ...
if( tile != LAYER_MOUNTAIN ) {
//debug("tile=="+as_string(tile)+", pos = "+MAKE_CSTR(pos));
msg( "Mines must be built against a mountain face. Find a mountainous place." );
return -1;
}
// Offset horizontally a bit to make the entrance stick out...
if( SCX(dir) )
pos = OFFSET_C(pos, SMAKE_C(-SCX(dir) / 5,0,0));
// If facing south, adjust to find the entrance.
// The mountain tiles have funny patterns, and this helps
// to compensate.
if( query_direction() == SMAKE_C(0,1,0) ) {
pos = MAKE_C(CX(pos), CY(pos)-1, CZ(pos) );
while( environment(this_player())->get_tiletype(CX(pos)+2, CY(pos)+3) == '0' + LAYER_MOUNTAIN ) {
pos = MAKE_C(CX(pos),CY(pos)+1,CZ(pos));
}
}
// This is a north-facing version to snug the mine up as close as it can go.
if( query_direction() == SMAKE_C(0,-1,0) ) {
pos = MAKE_C(CX(pos), CY(pos)-1, CZ(pos) );
while( environment(this_player())->get_tiletype(CX(pos)+2, CY(pos)) != '0' + LAYER_MOUNTAIN ) {
pos = MAKE_C(CX(pos),CY(pos)+1,CZ(pos));
}
}
set_coord( pos );
return 0;
}
void sbox(double xx0, double yy0, double xx1, double yy1){
int x0=SCX(xx0), y0=SCY(yy0), x1=SCX(xx1), y1=SCY(yy1);
int t;
if(x1<x0){ t=x0; x0=x1; x1=t; }
if(y1<y0){ t=y0; y0=y1; y1=t; }
if(x0<clipminx) x0=clipminx;
if(y0<clipminy) y0=clipminy;
if(x1>clipmaxx) x1=clipmaxx;
if(y1>clipmaxy) y1=clipmaxy;
if(x1<x0 || y1<y0) return;
m_clrwin(x0, y0, x1, y1, e1->backgr);
}
void hatb2(void)
{
(current_proc->pa8)->oyvel.pos=srandarc(SCY(0x10000));
set_proj_vel(current_proc->pa8,SCX(0x10000)+randu(SCX(0x20000)),-1);
flip_single(current_proc->pa8);
insert_object(current_proc->pa8,&objlst);
current_proc->pa9=a_bigger;
framew(6);
blood_death(current_proc->pa8);
}
/******************************************************************************
Function: void face_blood(void)
By: David Schwartz
Date: Mar 1995
Parameters: current_proc->a11 - dude to bloody
Returns: None
Description: hit in the face hard blood
******************************************************************************/
void face_blood(void)
{
get_jt_blood;
lineup_with_a11_offset(SCX(0x0000),-SCY(0x0010));
insert_object(current_proc->pa8,&objlst);
(current_proc->pa8)->oyvel.pos=-randu(SCY(0x12000));
set_proj_vel(current_proc->pa8,-(SCX(0x30000)+randu(SCX(0x20000))),-1);
current_proc->pa9=a_bigger;
framew(6);
blood_death(current_proc->pa8);
}
void move_wave(void)
{
/* mw1 */
do
{
process_sleep(2);
if (++wave_x_position>SCX(155))
{
dive_randper+=2;
shoot_randper+=5;
if (shoot_randper>25)
{
shoot_randper+=25;
dive_randper=shoot_randper;
}
/* mw2 */
do
{
process_sleep(2);
wave_x_position--;
}
while(wave_x_position>0);
}
}
while(1);
}
static void
draw_polyline(DiaRenderer *self,
Point *points, int num_points,
Color *line_colour)
{
WpgRenderer *renderer = WPG_RENDERER (self);
int i;
gint16* pData;
DIAG_NOTE(g_message("draw_polyline n:%d %f,%f ...",
num_points, points->x, points->y));
g_return_if_fail(1 < num_points);
WriteLineAttr(renderer, line_colour);
WriteRecHead(renderer, WPG_POLYLINE, num_points * 2 * sizeof(gint16) + sizeof(gint16));
pData = g_new(gint16, num_points * 2);
/* number of points */
pData[0] = num_points;
fwrite_le(pData, sizeof(gint16), 1, renderer->file);
/* point data */
for (i = 0; i < num_points; i++)
{
pData[2*i] = SCX(points[i].x);
pData[2*i+1] = SCY(-points[i].y);
}
fwrite_le(pData, sizeof(gint16), num_points*2, renderer->file);
g_free(pData);
}
void hatb1(void)
{
(OBJECT *)current_proc->a11=current_proc->pa8;
get_jt_blood;
a11_blood_lineup(SCX(0x10),SCY(0x38));
stack_jump(hatb2);
}
static void
draw_ellipse(DiaRenderer *self,
Point *center,
real width, real height,
Color *fill, Color *stroke)
{
WpgRenderer *renderer = WPG_RENDERER (self);
WPGEllipse ell;
DIAG_NOTE(g_message("draw_ellipse %fx%f center @ %f,%f",
width, height, center->x, center->y));
ell.x = SCX(center->x);
ell.y = SCY(-center->y);
ell.RotAngle = 0;
ell.rx = SC(width / 2.0);
ell.ry = SC(height / 2.0);
ell.StartAngle = 0;
ell.EndAngle = 360;
ell.Flags = 0;
if (stroke)
WriteLineAttr(renderer, stroke);
if (fill)
WriteFillAttr(renderer, fill, TRUE);
WriteRecHead(renderer, WPG_ELLIPSE, sizeof(WPGEllipse));
g_assert(16 == sizeof(WPGEllipse));
fwrite_le(&ell, sizeof(guint16), sizeof(WPGEllipse) / sizeof(guint16), renderer->file);
if (fill)
WriteFillAttr(renderer, fill, FALSE);
}
void make_stars(void)
{
OBJECT *obj;
WORD ta4;
last_star=makestar();
last_star->oslink=NULL;
/* amx2 */
ta4=100;
/* amx1 */
do
{
makestar();
(OBJECT *)(current_proc->pa8)->oslink=last_star;
last_star=current_proc->pa8;
} while (--ta4>0);
/* amx5 */
do
{
process_sleep(1);
obj=last_star;
/* amx4 */
do
{
if ( obj->oypos.u.intpos>SCY(260) )
{
obj->oypos.u.intpos-=SCY(270);
obj->oxpos.u.intpos=randu(SCX(400))-1;
}
} while ((obj=(OBJECT*)obj->oslink)!=NULL );
} while (1);
}
//******************************************************************************
//******************************************************************************
void f_jade(void)
{
kill_and_stop_scrolling();
get_char_ani(ANIM_TABLE2,ANIM_F1_FRIEND);
animate_a0_frames(4,3);
process_sleep(0x10);
CREATE(PID_FX,friend_ender);
current_proc->a10=(ADDRESS)current_proc->pa9;
current_proc->a10-=4; // 1 LONG
current_proc->a11=(ADDRESS)current_proc->pa9;
/* pogo_bounce */
while (1)
{
(ADDRESS)current_proc->pa9=current_proc->a11;
do_next_a9_frame(current_proc->pa8);
flight(current_proc->pa8,SCX(0x0),-SCY(0xa0000),SCY(0x9000),NEVER_ANI,-1);
tsound(0xc);
(ADDRESS)current_proc->pa9=current_proc->a10;
do_next_a9_frame(current_proc->pa8);
process_sleep(1);
}
}
static void
draw_polyline(DiaRenderer *self,
Point *points, int num_points,
Color *line_colour)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HPEN hPen;
W32::POINT* pts;
int i;
DIAG_NOTE(renderer, "draw_polyline n:%d %f,%f ...\n",
num_points, points->x, points->y);
if (num_points < 2)
return;
pts = g_new (W32::POINT, num_points+1);
for (i = 0; i < num_points; i++)
{
pts[i].x = SCX(points[i].x);
pts[i].y = SCY(points[i].y);
}
hPen = UsePen(renderer, line_colour);
W32::Polyline(renderer->hFileDC, pts, num_points);
DonePen(renderer, hPen);
g_free(pts);
}
void CStatusBar::Draw()
{
const int& cx = m_mdc.cx;
const int& cy = m_mdc.cy;
// Draw background
if (m_bBackgrWinDefault)
{
DrawRect(m_mdc, 0, 0, cx, 1, GetSysColor(COLOR_3DSHADOW));
DrawRect(m_mdc, 0, 1, cx, 1, GetSysColor(COLOR_3DHIGHLIGHT));
DrawRect(m_mdc, 0, 2, cx, cy - 2, GetSysColor(COLOR_3DFACE));
}
else
{
DrawRectGradientV(m_mdc, 0, 0, cx, cy, m_clrBackgrT, m_clrBackgrB);
DrawRect(m_mdc, 0, 0, cx, SCY(1), m_clrBackgrLine);
}
// Draw status text
int nSavedDC = SaveDC(m_mdc);
SetTextColor(m_mdc, m_clrText);
SelectObject(m_mdc, m_font);
TextOut(m_mdc, SCX(4), SCY(4), GetText());
RestoreDC(m_mdc, nSavedDC);
Invalidate(m_hWnd);
PostMessage(m_hWnd, WM_PAINT);
}
void sp1m1(OBJECT *pa0)
{
set_xy_coordinates(current_proc->pa8,pa0->oxpos.u.intpos+SCX(4),pa0->oypos.u.intpos);
insert_object(current_proc->pa8,&objlst);
(current_proc->pa8)->oyvel.u.intpos=-5;
missile_count++;
return;
}
void boomb1(void)
{
(OBJECT *)current_proc->a11=current_proc->pa8;
get_jt_blood;
a11_blood_lineup(SCX(0x0),SCY(0x20));
(current_proc->pa8)->oyvel.pos=srandarc(SCY(0x10000));
set_proj_vel(current_proc->pa8,SCX(0x10000)+randu(SCX(0x20000)),-1);
flip_single(current_proc->pa8);
insert_object(current_proc->pa8,&objlst);
current_proc->pa9=a_bigger;
framew(6);
blood_death(current_proc->pa8);
}
/******************************************************************************
Function: void upcutted_blood(void)
By: David Schwartz
Date: Mar 1995
Parameters: current_proc->a11 - dude to bloody
Returns: None
Description: uppercut blood
******************************************************************************/
void upcutted_blood(void)
{
(ADDRESS)current_proc->a11=current_proc->pa8;
(long)current_proc->a0=SCX(0x20000); // xvel range
(long)current_proc->a1=SCX(0x10000); // xvel min
(long)current_proc->a2=SCY(0x50000); // yvel range
(long)current_proc->a3=SCY(0x30000); // yvel min
current_proc->a4=0x00010001;
current_proc->a5=0x00040000;
spawn_drip_a10(3);
CREATE(PID_BLOOD,upcut_right);
get_tg_blood;
lineup_with_a11_offset(SCX(0x0005),SCY(0x0018));
flip_single(current_proc->pa8);
stack_jump(upcb3);
}
static void
fill_arc(DiaRenderer *self,
Point *center,
real width, real height,
real angle1, real angle2,
Color *colour)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HPEN hPen;
W32::HGDIOBJ hBrush;
W32::POINT ptStart, ptEnd;
W32::COLORREF rgb = W32COLOR(colour);
DIAG_NOTE(renderer, "fill_arc %fx%f <%f,<%f @%f,%f\n",
width, height, angle1, angle2, center->x, center->y);
if (angle1 > angle2) {
/* make it counter-clockwise by swapping start/end */
real tmp = angle1;
angle1 = angle2;
angle2 = tmp;
}
/* calculate start and end points of arc */
ptStart.x = SCX(center->x + (width / 2.0) * cos((M_PI / 180.0) * angle1));
ptStart.y = SCY(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle1));
ptEnd.x = SCX(center->x + (width / 2.0) * cos((M_PI / 180.0) * angle2));
ptEnd.y = SCY(center->y - (height / 2.0) * sin((M_PI / 180.0) * angle2));
hPen = UsePen(renderer, NULL); /* no border */
hBrush = W32::CreateSolidBrush(rgb);
W32::SelectObject(renderer->hFileDC, hBrush);
W32::Pie(renderer->hFileDC,
SCX(center->x - width / 2), /* bbox corners */
SCY(center->y - height / 2),
SCX(center->x + width / 2),
SCY(center->y + height / 2),
ptStart.x, ptStart.y, ptEnd.x, ptEnd.y);
W32::SelectObject(renderer->hFileDC,
W32::GetStockObject (HOLLOW_BRUSH) );
W32::DeleteObject(hBrush);
DonePen(renderer, hPen);
}
void sawb3(void)
{
(OBJECT *)current_proc->a11=current_proc->pa8;
(long)current_proc->a0=SCX(0x20000); // xvel range
(long)current_proc->a1=SCX(0x10000); // xvel min
(long)current_proc->a2=SCY(0x50000); // yvel range
(long)current_proc->a3=SCY(0x30000); // yvel min
current_proc->a4=0x00810001;
current_proc->a5=0x00040000;
spawn_drip_a10(2);
CREATE(PID_BLOOD,saw_right);
get_tg_blood;
lineup_with_a11_offset(SCX(0x0005),SCY(0x0088));
flip_single(current_proc->pa8);
stack_jump(upcb3);
}
void boomerang_drip(void)
{
(OBJECT *)current_proc->a11=current_proc->pa8;
get_jt_blood;
a11_blood_lineup(SCX(0x0),SCY(0x50));
set_proj_vel(current_proc->pa8,SCX(0x20000)+randu(SCX(0x60000)),-1);
(current_proc->pa8)->oyvel.pos=-(randu(SCY(0x40000))+SCY(0x30000));
flip_single(current_proc->pa8);
insert_object(current_proc->pa8,&objlst);
current_proc->a0=8;
current_proc->pa9=a_drip;
(long)current_proc->a10=SCY(0x6000);
blood_fall_splat_12_die();
}
static void
draw_line(DiaRenderer *self,
Point *start, Point *end,
Color *line_colour)
{
WmfRenderer *renderer = WMF_RENDERER (self);
W32::HPEN hPen;
DIAG_NOTE(renderer, "draw_line %f,%f -> %f, %f\n",
start->x, start->y, end->x, end->y);
hPen = UsePen(renderer, line_colour);
W32::MoveToEx(renderer->hFileDC, SCX(start->x), SCY(start->y), NULL);
W32::LineTo(renderer->hFileDC, SCX(end->x), SCY(end->y));
DonePen(renderer, hPen);
}
void plotdisc(double xc, double yc, double r){
Point p;
int rad;
p.x=SCX(xc);
p.y=SCY(yc);
if (r < 0)
rad=SCR(-r);
else
rad=SCR(r);
fillellipse(screen, p, rad, rad, getcolor(e1->foregr), ZP);
}
