电梯调度系统(界面由C图形库编绘)

1.编程题目

电梯调度系统

2.结对编程组员

黄冠译,刘畅

3.编程语言

C语言图形库

4题目要求

编写人员:刘畅,黄冠译

代码如下:

# include <stdio.h>
# include <graphics.h>
# include <conio.h>
# include <time.h>
# include <memory.h>

int x[4] = {570,570,570,570},k[4]={0,0,0,0},t[4]={0,0,0,0},di[4]={0,0,0,0};
int cro,col;
char s[10];
int refresh_rate = 10;                                                                            //刷新率定义大小
MOUSEMSG M;
IMAGE ima,ima1,ima2,back,block;

struct elevator                                                                                    //定义4个电梯结构体数组
{
    int num,msum,dir,flo,mflo,numm,summ,elein[21],eleof[21],peom[21];
}ele[5]={{0,0,2,1,1,10,800},{0,0,2,1,1,10,800},{0,0,2,1,1,20,1600},{0,0,2,1,1,20,2000}};

struct floors                                                                                    //定义21个楼层结构体数组
{
    int num[3],go,emin;
}floor[21];

void Draw1(int e)                                                                                //电梯接人路线绘制函数
{
    if(t[e]==0)                                                                    //如果电梯没有到达目的楼层,则继续绘制路线
    {
        if (ele[e].dir==0)                                                //电梯上楼绘制
        {
            putimage(140+e*100,(20-ele[e].flo)*30-k[e],&ima);
            k[e]++;
            if (k[e]==30)
            {
                ele[e].flo++;
                k[e]=0;
            }
        }
        if (ele[e].dir==1)                                                //电梯下楼绘制
        {
            putimage(140+e*100,(20-ele[e].flo)*30+k[e],&ima);
            k[e]++;
            if (k[e]==30)
            {
                ele[e].flo--;
                k[e]=0;
            }
        }
        if (ele[e].dir==2)                                                //电梯停歇状态绘制
            putimage(140+e*100,(20-ele[e].flo)*30,&ima);
        if ((ele[e].flo==ele[e].mflo)&&(ele[e].dir!=2))                    //电梯到达目的楼层后的数值重新赋值
        {
            int h;
            ele[e].dir=2;
            floor[ele[e].flo].emin=22;
            t[e]=60;
            k[e]=0;
            while (floor[ele[e].mflo].num[0]!=0)                        //接人后电梯内部状态赋值
            {
                h=rand()%41+50;
                if ((ele[e].num+1<=ele[e].numm)&&(ele[e].msum+h<=ele[e].summ))
                {
                    ele[e].num++;
                    ele[e].peom[ele[e].num-1]=h;
                    ele[e].msum=ele[e].msum+h;
                    floor[ele[e].flo].num[0]--;
                }
                else
                    break;
            }
            while (floor[ele[e].mflo].num[1]!=0)
            {
                h=rand()%41+50;
                if ((ele[e].num+1<=ele[e].numm)&&(ele[e].msum+h<=ele[e].summ))
                {
                    ele[e].num++;
                    ele[e].peom[ele[e].num-1]=h;
                    ele[e].msum=ele[e].msum+h;
                    floor[ele[e].flo].num[1]--;
                }
                else
                    break;
            }
        }
    }
    if (t[e]!=0)                                                                //如果电梯到达目的楼层,则绘制电梯开门关门状态
    {
        if (t[e]>50)                                                    //开门
        {
            putimage(140+e*100-60+t[e]+5,(20-ele[e].flo)*30,&ima1);
            putimage(140+e*100+60-t[e]+5,(20-ele[e].flo)*30,&ima2);
            t[e]--;
        }
        else if (t[e]>10)
        {
            putimage(140+e*100-10+5,(20-ele[e].flo)*30,&ima1);
            putimage(140+e*100+11+5,(20-ele[e].flo)*30,&ima2);
            t[e]--;
        }
        else if (t[e]>0)                                                //关门
        {
            putimage(140+e*100-t[e]+5,(20-ele[e].flo)*30,&ima1);
            putimage(140+e*100+t[e]+5,(20-ele[e].flo)*30,&ima2);
            t[e]--;
        }
    }
}

void Draw2(int e)                                                                                //电梯接人结束后,进入送客绘制模式
{
    for (int v=0;v<=20;v++)                                                            //电梯内部按钮绘制
    {
        if ((v==0)&&(ele[e].elein[v]==1))
            putimage(528+20%5*55,47+20/5*19.3+e*150,&block);
        else if (ele[e].elein[v]==1)
            putimage(528+(v-1)%5*55,47+(v-1)/5*19+e*150,&block);
    }
    if(t[e]==0)                                                                        //如果电梯没有到达目的楼层,则继续绘制路线
    {    
        if (ele[e].dir==0)                                                    //电梯上楼绘制
        {
            putimage(140+e*100,(20-ele[e].flo)*30-k[e],&ima);
            k[e]++;
            if (k[e]==30)
            {
                ele[e].flo++;
                k[e]=0;
            }
        }
        if (ele[e].dir==1)                                                    //电梯下楼绘制
        {
            putimage(140+e*100,(20-ele[e].flo)*30+k[e],&ima);
            k[e]++;
            if (k[e]==30)
            {
                ele[e].flo--;
                k[e]=0;
            }
        }
        if (ele[e].flo==ele[e].mflo)                                        //到达目的楼层后绘制
        {
            ele[e].elein[ele[e].flo]=0;
            di[e]=0;
            for (int v=0;v<=20;v++)
                if (ele[e].elein[v]==1)
                    di[e]=1;
            k[e]=0;
            ele[e].dir=2;
            while(ele[e].eleof[ele[e].flo]!=0)                                //电梯下人操作,重新赋值
            {
                ele[e].num--;
                ele[e].msum=ele[e].msum-ele[e].peom[ele[e].num];
                ele[e].eleof[ele[e].flo]--;
                if (ele[e].num==0)
                    break;
            }
            t[e]=60;
        }
    }
    if (t[e]!=0)                                                                //如果电梯到达目的楼层,则绘制电梯开门关门状态                                                            
    {
        if (t[e]>50)                                                    //开门
        {
            putimage(140+e*100-60+t[e]+5,(20-ele[e].flo)*30,&ima1);
            putimage(140+e*100+60-t[e]+5,(20-ele[e].flo)*30,&ima2);
            t[e]--;
        }
        else if (t[e]>10)
        {
            putimage(140+e*100-10+5,(20-ele[e].flo)*30,&ima1);
            putimage(140+e*100+10+5,(20-ele[e].flo)*30,&ima2);
            t[e]--;
        }
        else if (t[e]>0)                                                //关门
        {
            putimage(140+e*100-t[e]+5,(20-ele[e].flo)*30,&ima1);
            putimage(140+e*100+t[e]+5,(20-ele[e].flo)*30,&ima2);
            t[e]--;
        }
    }
}

void run ()                                                                                        //电梯运行总调度函数                                                                        
{    
    int o,p,mine;
    setcolor(BLACK);
    while(1)                                                                            //电梯运行状态循环
    { 
        if(MouseHit())                                                            //如果触发鼠标时间
        {
            M = GetMouseMsg();                                                //鼠标事件获取
            if (M.uMsg == WM_LBUTTONDOWN)                                    //如果鼠标左键单击
            {
                if (M.x>=5&&M.x<=24)                                        //判断鼠标指针所在范围是否上楼
                {
                    o=20-(M.y+1)/30;
                    InputBox(s, 10, "请输入进电梯的人数");                    //弹窗响应,要求输入
                    sscanf(s,"%d",&p);
                    floor[o].num[0]=p;
                }
                if (M.x>=25&&M.x<=45)                                        //判断鼠标指针所在范围是否下楼
                {
                    o=20-(M.y+1)/30;
                    InputBox(s, 10, "请输入进电梯的人数");                    //弹窗响应,要求输入
                    sscanf(s,"%d",&p);
                    floor[o].num[1]=p;
                }
                if ((ele[0].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=46&&M.y<=142))        //判断电梯内部按钮是否由鼠标响应
                {
                    int r;
                    cro=(M.x-528)/55;
                    col=(M.y-46)/20;
                    r=cro+col*5+1;
                    if (r==21)
                        r=0;
                    di[0]=1;
                    ele[0].mflo=r;
                    ele[0].elein[ele[0].mflo]=1;
                    InputBox(s, 10, "请输入此楼层要下电梯的人数");                    //弹窗响应,要求输入
                    sscanf(s,"%d",&p);
                    ele[0].eleof[ele[0].mflo]=p;
                }
                if ((ele[1].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=196&&M.y<=292))        //判断电梯内部按钮是否由鼠标响应
                {
                    int r;
                    cro=(M.x-528)/55;
                    col=(M.y-197)/20;
                    r=cro+col*5+1;
                    if (r==21)
                        r=0;
                    if (r%2==1)
                    {
                        di[1]=1;
                        ele[1].mflo=r;
                        ele[1].elein[ele[1].mflo]=1;
                        InputBox(s, 10, "请输入此楼层要下电梯的人数");                //弹窗响应,要求输入
                        sscanf(s,"%d",&p);
                        ele[1].eleof[ele[1].mflo]=p;
                    }
                }
                if ((ele[2].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=346&&M.y<=442))        //判断电梯内部按钮是否由鼠标响应
                {
                    int r;
                    cro=(M.x-528)/55;
                    col=(M.y-346)/20;
                    r=cro+col*5+1;
                    if (r==21)
                        r=0;
                    if (r%2==0)
                    {
                        di[2]=1;
                        ele[2].mflo=r;
                        ele[2].elein[ele[2].mflo]=1;
                        InputBox(s, 10, "请输入此楼层要下电梯的人数");                //弹窗响应,要求输入
                        sscanf(s,"%d",&p);
                        ele[2].eleof[ele[2].mflo]=p;
                    }
                }
                if ((ele[3].num!=0)&&(M.x>=527&&M.x<=801&&M.y>=496&&M.y<=592))        //判断电梯内部按钮是否由鼠标响应
                {
                    int r;
                    cro=(M.x-528)/55;
                    col=(M.y-496)/20;
                    r=cro+col*5+1;
                    if (r==21)
                        r=0;
                    di[3]=1;
                    ele[3].mflo=r;
                    ele[3].elein[ele[3].mflo]=1;
                    InputBox(s, 10, "请输入此楼层要下电梯的人数");                    //弹窗响应,要求输入
                    sscanf(s,"%d",&p);
                    ele[3].eleof[ele[3].mflo]=p;
                }
            }
        }
        for(int j=20;j>=0;j--)                                                        //每个楼层开始判断是否有客人要上电梯的响应
        {
            mine=4;
            if (floor[j].num[0]!=0)                                                //有上电梯响应且客人要上楼,开始电梯调度
            {
                if ((ele[0].num<10)&&(ele[0].msum<800))                        //1号电梯条件是否满足
                {
                    if ((j>=ele[0].flo)&&(ele[0].dir!=1))
                        if (floor[j].emin>(j-ele[0].flo))
                        {
                            floor[j].emin=j-ele[0].flo;
                            mine=0;
                        }
                    if ((j<ele[0].flo)&&(ele[0].dir==2))
                        if (floor[j].emin>(ele[0].flo-j))
                        {
                            floor[j].emin=ele[0].flo-j;
                            mine=0;
                        }
                }
                if ((ele[3].num<20)&&(ele[3].msum<2000))                    //4号电梯条件是否满足
                {
                    if ((j>=ele[3].flo)&&(ele[3].dir!=1))
                        if (floor[j].emin>(j-ele[3].flo))
                        {
                            floor[j].emin=j-ele[3].flo;
                            mine=3;
                        }
                    if ((j<ele[3].flo)&&(ele[3].dir==2))
                        if (floor[j].emin>(ele[3].flo-j))
                        {
                            floor[j].emin=ele[3].flo-j;
                            mine=3;
                        }
                }
                if (j%2==0)
                {
                    if ((ele[2].num<20)&&(ele[2].msum<1600))                //3号电梯条件是否满足
                    {
                        if ((j>=ele[2].flo)&&(ele[2].dir!=1))
                            if (floor[j].emin>(j-ele[2].flo))
                            {
                                floor[j].emin=j-ele[2].flo;
                                mine=2;
                            }
                        if ((j<ele[2].flo)&&(ele[2].dir==2))
                            if (floor[j].emin>(ele[2].flo-j))
                            {
                                floor[j].emin=ele[2].flo-j;
                                mine=2;
                            }
                    }
                }
                if (j%2==1)                                                    //2号电梯条件是否满足
                {
                    if ((ele[1].num<10)&&(ele[1].msum<800))
                    {
                        if ((j>=ele[1].flo)&&(ele[1].dir!=1))
                            if (floor[j].emin>(j-ele[1].flo))
                            {
                                floor[j].emin=j-ele[1].flo;
                                mine=1;
                            }
                        if ((j<ele[1].flo)&&(ele[1].dir==2))
                            if (floor[j].emin>(ele[1].flo-j))
                            {
                                floor[j].emin=ele[1].flo-j;
                                mine=1;
                            }
                    }
                }
                if (j>=ele[mine].flo)                                        //用距离判断满足条件的电梯,在此筛选出满足条件电梯
                    ele[mine].dir=0;
                else
                    ele[mine].dir=1;                                        //满足条件的电梯设置目的楼层
                ele[mine].mflo=j;
            }
            if (floor[j].num[1]!=0)                                                //有上电梯响应且客人要下楼,开始电梯调度    
            {
                if ((ele[0].num<10)&&(ele[0].msum<800))
                {
                    if ((j<=ele[0].flo)&&(ele[0].dir!=1))
                        if (floor[j].emin>(ele[0].flo-j))
                        {
                            floor[j].emin=ele[0].flo-j;
                            mine=0;
                        }
                    if ((j>ele[0].flo)&&(ele[0].dir==2))
                        if (floor[j].emin>(j-ele[0].flo))
                        {
                            floor[j].emin=j-ele[0].flo;
                            mine=0;
                        }
                }
                if ((ele[3].num<20)&&(ele[3].msum<2000))
                {
                    if ((j<=ele[3].flo)&&(ele[3].dir!=1))
                        if (floor[j].emin>(ele[3].flo-j))
                        {
                            floor[j].emin=ele[3].flo-j;
                            mine=3;
                        }
                    if ((j>ele[3].flo)&&(ele[3].dir==2))
                        if (floor[j].emin>(j-ele[3].flo))
                        {
                            floor[j].emin=j-ele[3].flo;
                            mine=3;
                        }
                }
                if (j%2==0)
                {
                    if ((ele[2].num<20)&&(ele[2].msum<1600))
                    {
                        if ((j<=ele[2].flo)&&(ele[2].dir!=1))
                            if (floor[j].emin>(ele[2].flo-j))
                            {
                                floor[j].emin=ele[2].flo-j;
                                mine=2;
                            }
                        if ((j>ele[2].flo)&&(ele[2].dir==2))
                            if (floor[j].emin>(j-ele[2].flo))
                            {
                                floor[j].emin=j-ele[2].flo;
                                mine=2;
                            }
                    }
                }
                if (j%2==1)
                {
                    if ((ele[1].num<10)&&(ele[1].msum<800))
                    {
                        if ((j<=ele[1].flo)&&(ele[1].dir!=1))
                            if (floor[j].emin>(ele[1].flo-j))
                            {
                                floor[j].emin=ele[1].flo-j;
                                mine=1;
                            }
                        if ((j>ele[1].flo)&&(ele[1].dir==2))
                            if (floor[j].emin>(j-ele[1].flo))
                            {
                                floor[j].emin=j-ele[1].flo;
                                mine=1;
                            }
                    }
                }
                if (j>=ele[mine].flo)
                    ele[mine].dir=0;
                else
                    ele[mine].dir=1;
                ele[mine].mflo=j;    
            }
        }
        BeginBatchDraw();                                                    //开始画图
        putimage(0,0,&back);
        for (int i=0;i<4;i++)                                            //四个电梯一次绘制当前状态
        {
            if (di[i]==0)                                            //接客的电梯绘制
                Draw1(i);
            if (di[i]==1)                                            //送客的电梯绘制
            {
                if (ele[i].mflo>=ele[i].flo)                        //上楼绘制
                {
                    ele[i].dir=0;
                    for (int w=ele[i].flo;w<=20;w++)
                    {
                        if (ele[i].elein[w]==1)
                        {
                            ele[i].mflo=w;
                            break;
                        }
                    }
                }
                else                                                //下楼绘制
                {
                    ele[i].dir=1;
                    for (int w=ele[i].flo;w>=0;w--)
                    {
                        if (ele[i].elein[w]==1)
                        {
                            ele[i].mflo=w;
                            break;
                        }
                    }
                }
                Draw2(i);
            }
            setbkmode(TRANSPARENT);                                    //输出电梯当前状态数值
            sprintf(s,"%d",ele[i].num);                                //电梯当前人数
            outtextxy(890,49+i*150,s);
            sprintf(s,"%d",ele[i].msum);                            //电梯当前重量
            outtextxy(890,74+i*150,s);
            sprintf(s,"%d",ele[i].flo);                                //电梯当前楼层
            outtextxy(890,99+i*150,s);    
        }
        EndBatchDraw();                                        //结束绘制
        Sleep(refresh_rate);                            //延时绘制,否则会本次绘制会遮挡下一次绘制
    }
    
}

void main()                                                                    //主函数
{    
    for (int i=0;i<21;i++)                                            //初始化
    {
        floor[i].num[0]=0;
        floor[i].num[1]=0;
        floor[i].emin=22;
    }
    initgraph(1000,630);                                            //构建窗口大小
    loadimage(&back,"pic//2.jpg");                                    //载入图片2
    putimage(0,0,&back);
    loadimage(&ima,"pic//1.jpg");                                    //载入图片1            
    loadimage(&ima1,"pic//3.jpg");                                    //载入图片3
    loadimage(&ima2,"pic//4.jpg");                                    //载入图片4
    loadimage(&block,"pic//5.jpg");                                    //载入图片5
    BeginBatchDraw();                                                //初始化绘制
    for (int j=0;j<4;j++)
        putimage(140+j*100,(20-ele[j].flo)*30 ,&ima);
    EndBatchDraw();                                                    //结束绘制
    run();                                                            //进入电梯调度函数开始电梯总调度
    closegraph();                                                //关闭窗口
}

我队友真的太厉害了,编程能力真的是太强大了,经过这俩周的合作,我在他身上学到了好多在书本上学不到,看不到的知识。对于这次结队编程的总结跟体会我会在下一个博客中详细的说明下面附上我队友的链接http://www.cnblogs.com/hgcrown/p/5364849.html

posted @ 2016-04-09 18:54  =liuchang=  阅读(670)  评论(1编辑  收藏  举报