int main(void)
{
FILE *FIn, *FOut;
int i, j, max, a, b, min, x, y, nod, nok;
if ((FIn = fopen("gcm.in", "rt")) == NULL)
return 0;
if ((FOut = fopen("gcm.out", "wt")) == NULL)
return 0;
fscanf(FIn, "%d%d", &a, &b);
if (a > b)
max = a, min = a - b;
else
max = b, min = b - a;
nod = NOD(a, b);
nok = NOK(a, b);
x = a;
y = b;
for (i = 1; i <= max; i++)
{
j = (int)(a * b / i);
if (i > j)
break;
if (min > Minus(i, j) && nod == NOD(i, j) && nok == NOK(i, j))
x = i, y = j;
}
fprintf(FOut, "%d %d", x, y);
fclose(FIn);
fclose(FOut);
}
Vector Schmidt(Vector a1,Vector a2)//由a1生成一个与a2垂直的向量
{
Vector temp1,temp2;
temp2=Multiple(dot_product(a1,a2)/dot_product(a2,a2),a2);
temp1=Minus(a1,temp2);
return temp1;
}
LinkList Merge4(LinkList la,LinkList lb,LinkList lc)
{
LinkList l,lbc;
l=CreateList(l,0);
lbc=Cross(lb,lc,l);
la=Minus(la,lbc);
return la;
}
big_integer big_integer::operator-(const big_integer& a) const {
big_integer ret;
if (is_negative_ != a.is_negative_) {
ret = Add(a);
ret.is_negative_ = is_negative_;
} else {
ret = Minus(a);
ret.is_negative_ = (*this < a);
}
return ret;
}
int _tmain(int argc, _TCHAR* argv[])
{
int result1 = Add( 10 , 20 );
printf("%d \n",result1);
int result2 = Minus( 10 , 20 );
printf("%d \n",result2);
int result3 = Mul( 10 , 20 );
printf("%d \n",result3);
int result4 = Div( 10 , 20 );
printf("%d \n",result4);
return 0;
}
big_integer big_integer::operator+(const big_integer& a) const {
big_integer ret;
if (is_negative_ && !a.is_negative_) {
ret = a.Minus(*this);
ret.is_negative_ = (a < *this);
} else if (!is_negative_ && a.is_negative_) {
ret = Minus(a);
ret.is_negative_ = (*this < a);
} else {
ret = Add(a);
ret.is_negative_ = is_negative_;
}
return ret;
}
const Width *Numeric::ValueWidth(const Number &src_num) {
bool is_signed = false;
Number num = src_num;
Number zero;
Numeric::MakeConst(0, 0, &zero);
if (Compare(COMPARE_LT, num, zero)) {
Number tmp = num;
// negate
Minus(tmp, &num);
is_signed = true;
}
uint64_t n;
n = Numeric::GetInt(num);
int w;
for (w = 0; n > 0; w++, n /= 2);
return Width::MakeInt(is_signed, w, 0);
}
int FBorder(double r)//判断下一时刻会不会碰到边界，如果会，速度置0；
{
register int flag = NONE,count=0;
if (me.pos.x<r && speed.x<0)
speed.x=-0,flag=LEFT,count++;
if (me.pos.x > kMapSize - r && speed.x>0)
speed.x=-0,flag=RIGHT,count++;
if (me.pos.y<r && speed.y<0)
speed.y=-0,flag=BEHIND,count++;
if (me.pos.y > kMapSize - r && speed.y>0)
speed.y=-0,flag=FRONT,count++;
if (me.pos.z<r && speed.z<0)
speed.z=-0,flag=DOWN,count++;
if (me.pos.z > kMapSize - r && speed.z>0)
speed.z=-0,flag=UP,count++;
if (count>=2)
{
Vector a2=Minus(boss.pos,me.pos);
speed=Add(speed,Multiple(0.0005,a2));
}
return flag;
}
int main(void)
{
FILE *FIn, *FOut;
int i, j, max, a, b, min, x, y, nod, nok;
if ((FIn = fopen("gcm.in", "rt")) == NULL)
return 0;
if ((FOut = fopen("gcm.out", "wt")) == NULL)
return 0;
fscanf(FIn, "%d%d", &a, &b);
if (a > b)
max = a, min = a - b;
else
max = b, min = b - a;
nod = NOD(a, b);
nok = NOK(a, b);
for (i = 1; i <= max; i++)
for (j = 1; j <= max; j++)
if (nod == NOD(i, j) && nok == NOK(i, j) && min > Minus(i, j))
x = j, y = i;
fprintf(FOut, "%d %d", x, y);
fclose(FIn);
fclose(FOut);
}
//Creates a heightmap from your seed.
void MAPGEN::create(float fractalfactor, int seed){
srand(seed);
int w=msize,h=msize;
int i, j, k;
float amount = 256;//, l;
// Do the corners
map[0][0] = 0; //FRandom(amount);
map[w-1][0] = 0; //FRandom(amount);
map[w-1][h-1] = 0; //FRandom(amount);
map[0][h-1] = 0; //FRandom(amount);
amount /= fractalfactor;
for (i = 128; i > 0; i /= 2){
// This is the square phase
for (j = i; j < w; j += 2 * i)
for (k = i; k < h; k += 2 * i){
map[j][k] = (map[Minus(j, i)][Minus(k, i)] +
map[Minus(j, i)][Plus(k, i)] +
map[Plus(j, i)][Plus(k, i)] +
map[Plus(j, i)][Minus(k, i)]) / 4. +
FRandom(amount);
}
amount /= fractalfactor;
// This is the diamond phase
for (j = 0; j < w; j += i)
for (k = 0; k < h; k += i)
if ((((j + k) / i) % 2) == 1){
// In this phase we might fall off the edge
// when we count the average of neighbours
// Minus and Plus take care of that
map[j][k] = (map[Minus(j, i)][k] +
map[j][Minus(k, i)] +
map[Plus(j, i)][k] +
map[j][Plus(k, i)]) / 4 +
FRandom(amount);
}
amount /= fractalfactor;
}
}
qPBReaderConfigDialog::qPBReaderConfigDialog() :
qPBReaderDialog(0, tr("qPBReader configuration"), Qt::Popup)
{
TRSCOPE(cfg, "qPBReaderConfigDialog::qPBReaderConfigDialog");
qPBReaderVerticalWidget * pVert = new qPBReaderVerticalWidget(this);
addWidget(pVert);
// ----------------------------------
// main language
// ----------------------------------
{
_pCBLang = new qPBReaderComboBox(tr("Application language"), this);
const QStringList & lsLang = qPBReaderLangLists::GetAvailableApplicationLanguages();
_pCBLang->_pComboBox->addItems(lsLang);
pVert->AddWidget(_pCBLang);
int nPos = lsLang.indexOf(qPBReaderConfig::GetApplicationLanguage());
if (nPos < 0)
{
nPos = 0;
}
_pCBLang->_pComboBox->setCurrentIndex(nPos);
QObject::connect(
_pCBLang->_pComboBox, SIGNAL(currentIndexChanged(const QString &)),
this , SLOT (ApplicationLanguageChanged(const QString &))
);
}
// ----------------------------------
// magnification
// ----------------------------------
{
_pZoom = new qPBReaderZoomWidgetWithLabel(tr("Font size"), this);
_pZoom->_pZoomWidget->SetValue(qPBReaderConfig::GetDefaultMagnificationFactor());
pVert->AddWidget(_pZoom);
QObject::connect(_pZoom->_pZoomWidget, SIGNAL(Minus()), this, SLOT(MagnificationStepMinus()));
QObject::connect(_pZoom->_pZoomWidget, SIGNAL(Plus()), this, SLOT(MagnificationStepPlus()));
}
// ----------------------------------
// margins
// ----------------------------------
{
bool bUseBookMargin = qPBReaderConfig::GetDefaultUseBookMargin();
Qt::CheckState state = bUseBookMargin ? Qt::Checked : Qt::Unchecked;
int top, side, bottom;
qPBReaderConfig::GetDefaultMargins(top, side, bottom);
// default margin
_pUseBookMarginCheckBox = new QCheckBox(tr("Use book margin"), pVert);
_pUseBookMarginCheckBox->setCheckState(state);
pVert->AddWidget(_pUseBookMarginCheckBox);
// top margin
_pTop = new qPBReaderSetValueWidgetWithLabel(tr("Top margin"), this);
_pTop->_pSetValueWidget->SetText(QString::number(top));
_pTop->_pSetValueWidget->setEnabled(!bUseBookMargin);
pVert->AddWidget(_pTop);
// side margin
_pSide = new qPBReaderSetValueWidgetWithLabel(tr("Side margin"), this);
_pSide->_pSetValueWidget->SetText(QString::number(side));
_pSide->_pSetValueWidget->setEnabled(!bUseBookMargin);
pVert->AddWidget(_pSide);
// bottom margin
_pBottom = new qPBReaderSetValueWidgetWithLabel("Bottom margin", this);
_pBottom->_pSetValueWidget->SetText(QString::number(bottom));
_pBottom->_pSetValueWidget->setEnabled(!bUseBookMargin);
pVert->AddWidget(_pBottom);
QObject::connect(_pUseBookMarginCheckBox, SIGNAL(stateChanged(int)),
this, SLOT(UseBookMarginChanged(int)));
QObject::connect(_pTop->_pSetValueWidget, SIGNAL(Minus()),
this , SLOT(TopMarginMinus()));
QObject::connect(_pTop->_pSetValueWidget, SIGNAL(Plus()),
this , SLOT(TopMarginPlus()));
QObject::connect(_pSide->_pSetValueWidget, SIGNAL(Minus()),
this , SLOT(SideMarginMinus()));
QObject::connect(_pSide->_pSetValueWidget, SIGNAL(Plus()),
this , SLOT(SideMarginPlus()));
QObject::connect(_pBottom->_pSetValueWidget, SIGNAL(Minus()),
this , SLOT(BottomMarginMinus()));
QObject::connect(_pBottom->_pSetValueWidget, SIGNAL(Plus()),
this , SLOT(BottomMarginPlus()));
}
// ----------------------------------
// hyphens
// ----------------------------------
{
QString sHyphenPatt = qPBReaderConfig::GetDefaultHyphenPatternLang();
bool bUseHyphens = !sHyphenPatt.isEmpty();
Qt::CheckState state = bUseHyphens ? Qt::Checked : Qt::Unchecked;
TRACE << VAR(bUseHyphens) << endl;
const QStringList & lsLang = qPBReaderLangLists::GetAvailableHyphenPatterns();
// use hyphens
_pUseHyphens = new QCheckBox(tr("Hyphenation"), pVert);
_pUseHyphens->setCheckState(state);
pVert->AddWidget(_pUseHyphens);
// hyphen lang
_pHyphenDic = new qPBReaderComboBox(tr("Hyphen dictionary language"), this);
_pHyphenDic->_pComboBox->addItems(lsLang);
int nPos = lsLang.indexOf(sHyphenPatt);
if (nPos < 0)
{
nPos = 9; // en-us
}
_pHyphenDic->_pComboBox->setCurrentIndex(nPos);
_pHyphenDic->_pComboBox->setEnabled(bUseHyphens);
pVert->AddWidget(_pHyphenDic);
QObject::connect(_pUseHyphens, SIGNAL(stateChanged(int)),
this, SLOT(UseHyphensChanged(int)));
QObject::connect(_pHyphenDic->_pComboBox,
SIGNAL(currentIndexChanged(const QString &)),
this, SLOT(HyphenDicChanged(const QString &)));
}
// ----------------------------------
// fonts
// ----------------------------------
{
bool bIgnoreFonts = qPBReaderConfig::GetDefaultIgnoreFonts();
// ignore book fonts
_pIgnoreFontsCheckBox = new QCheckBox(tr("Ignore book fonts"), pVert);
Qt::CheckState state = bIgnoreFonts ? Qt::Checked : Qt::Unchecked;
_pIgnoreFontsCheckBox->setCheckState(state);
pVert->AddWidget(_pIgnoreFontsCheckBox);
// serif
_pFonts[0] = new qPBReaderFontSelectorWidget(tr("Serif"), pVert);
QString sSerif = qPBReaderConfig::GetDefaultSerifFont();
_pFonts[0]->_pFontComboBox->setCurrentFont(QFont(sSerif));
pVert->AddWidget(_pFonts[0]);
// sans
_pFonts[1] = new qPBReaderFontSelectorWidget(tr("Sans-serif"), pVert);
QString sSans = qPBReaderConfig::GetDefaultSansFont();
_pFonts[1]->_pFontComboBox->setCurrentFont(QFont(sSans));
pVert->AddWidget(_pFonts[1]);
// mono
_pFonts[2] = new qPBReaderFontSelectorWidget(tr("Monospace"), pVert);
QString sMono = qPBReaderConfig::GetDefaultMonoFont();
_pFonts[2]->_pFontComboBox->setCurrentFont(QFont(sMono));
pVert->AddWidget(_pFonts[2]);
// std
_pType = new qPBReaderTypeSelectorWidget(tr("Standard"), pVert);
int idx = qPBReaderConfig::GetDefaultStandardFont();
_pType->_pComboBox->setCurrentIndex(idx);
pVert->AddWidget(_pType);
QObject::connect(_pIgnoreFontsCheckBox, SIGNAL(stateChanged(int)),
this , SLOT(IgnoreFontsChanged(int)));
QObject::connect(_pFonts[0]->_pFontComboBox,
SIGNAL(currentFontChanged(const QFont &)),
this, SLOT(SelectionChanged()));
QObject::connect(_pFonts[1]->_pFontComboBox,
SIGNAL(currentFontChanged(const QFont &)),
this, SLOT(SelectionChanged()));
QObject::connect(_pFonts[2]->_pFontComboBox,
SIGNAL(currentFontChanged(const QFont &)),
this, SLOT(SelectionChanged()));
QObject::connect(_pType->_pComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(SelectionChanged()));
}
QObject::connect(this, SIGNAL(finished(int)), QCoreApplication::instance(), SLOT(quit()));
}
void TVector::Resize(int delta){
if (delta>0)
Plus(delta);
else if (delta<0)
Minus(-delta);
}
int main(){
World* zorkworld=new World;
char input;
char buffer[20];
uint hardcore;
uint t_bob, t_lizz, position=0;
t_bob = GetTickCount();
t_lizz = GetTickCount();
MyString command;
printf("\t Welcome to Zerk! a Zork type game created by Marc Fabian! ENJOY! :)\n\n");
zorkworld->Help();//type all comands at the start
//->lizz->status = paralyzed;
//zorkworld->bob->status = paralyzed; ENEMIES PARALYZED FOR TESTING PURPOSES
printf("\t\t Would you like to play in harcore mode?\n\n");
printf("\t\t Press 1 if yes, any other for normal mode\n\n\t\t\t\t ");
scanf_s("%i", &hardcore);
if (hardcore == 1){
system("cls");
zorkworld->hardcore = true;
zorkworld->player->cash = 0;
zorkworld->player->hp = 100;
printf("\n\n\t\t\t\t\t WELCOME TO HELL\n\n");
}
else{
system("cls");
printf("\n\n\t\t Let's play in normal mode then...\n\n");
}
printf("\n");
printf("___________________________________________________\n");
zorkworld->player->actual->Look();
printf("\n");
while (zorkworld->player->alive == true && zorkworld->lizz->alive == true){ //game loop
if (t_bob + 4000 < GetTickCount()){
t_bob = GetTickCount();
zorkworld->Npc_interact(zorkworld->bob);
if (zorkworld->player->hp < 150 && hardcore==false){
zorkworld->player->hp++;
}
}
if (t_lizz + 1000 < GetTickCount()){
t_lizz = GetTickCount();
zorkworld->Npc_interact(zorkworld->lizz);
}
if (_kbhit()){ //detects player input
input = _getch();
buffer[position++] = input;
if (buffer[position - 1] == '\b'){
position-=2;
}
if (buffer[position-1] == '\r'){
buffer[position-1] = '\0';
printf("%s\n",buffer);
Minus(buffer, buffer); // changes player input to full lowercase so there is no problem later reading the input
command = buffer;
if (zorkworld->keyboard(command) == false){
printf("I can't understand this comand\n");
}
if (zorkworld->player->status != attack){
printf("\n");
printf("___________________________________________________\n");
zorkworld->player->actual->Look();
printf("\n\n");
}
position = 0;
}
}
}
if (zorkworld->player->alive == true){
printf("\n\nYou have WON! CONGRATS! Lizz is.. DEAD!\n\n"); //placeholder
}
else{
printf("You got...REKT!!! tryhard more next time...\n\n");
}
Sleep(3000);
system("pause");
return 0;
}
void QtCalculator::pbminustoggled(bool myboolean){
if(myboolean)
Minus();
if(pbminus->isOn() && (!key_pressed))
pbminus->setOn(FALSE);
}
void Init(){
map = GetMap();
current_time = map -> time;
register int i,j;
register int AE_number;
int AEflag;//记录有无AE可以走
int flag;//记录ae是否离devour太近
register int ChosenAE;
Position ChosenDevour[10];
register double MinAEdistance;
Position AE[50];//记录AE的位置
register int devour_number;
int coming_devour=0;
Position Devour[50];//记录Devour的位置
int Boss_Parameter=20;
int Devour_Danger=0;
register double border_r;
register double F;
register double dis;
Vector a2;//从目标到自己的向量
border_r=0.5*me.radius;
me = GetStatus() -> objects[0];
opponent_number = devour_number = see_boss = AE_number = coming_devour=0;
speed.x = speed.y = speed.z = (double)0;
MinAEdistance=10000;
for (i = 0; i < map -> objects_number; ++i)
{
F= (double)0, dis = dist(map -> objects[i].pos, me.pos);
switch (map -> objects[i].type){
case PLAYER:
/*if (map -> objects[i].team_id == GetStatus() -> team_id) break;
opponent[opponent_number++] = map -> objects[i];
if (me.radius < map -> objects[i].radius)
F = RUN_VALUE * me.radius * map -> objects[i].radius / POW(dis, 3);
if (me.radius > map -> objects[i].radius && me.skill_level[SHORT_ATTACK]
|| me.skill_level[SHORT_ATTACK]>=5)
F = CHASING_VALUE * me.radius * map -> objects[i].radius / POW(dis, 3);*/
break;
case ENERGY:
F = ENERGY_VALUE * POW(me.radius, 2) / POW(dis, 3);
if (IsBorder(border_r,map -> objects[i].pos))//如果到边界的距离小于r，力为0
F=0;
break;
case ADVANCED_ENERGY:
AE[AE_number++]=map -> objects[i].pos;
break;
case DEVOUR:
Devour[devour_number++]=map -> objects[i].pos;
break;
case BOSS:
boss = map -> objects[i];
see_boss = 1;
boss_r = boss.radius;
boss_warning = (int)(dis < 1.2 * boss_r && me.radius<boss_r);
break;
default:
break;
}
//printf("F=%f\n",F);//F=0.000061~0.001110
a2=Minus(map -> objects[i].pos,me.pos);
speed=Add(speed,Multiple(F,a2));
}
if (AE_number)//处理AE
{
AEflag=0;
for(i=0;i<AE_number;i++)
{
dis=dist(AE[i], me.pos);
//printf("AE %d dis=%f\n",i,dis);
if (IsBorder(border_r,AE[i]))
continue;
for(j=0,flag=0;j<devour_number;j++)
if (dist(AE[i],Devour[j])<me.radius && dist(AE[i],me.pos)>0.6*dist(Devour[j],me.pos))
flag=1;
if (flag)
continue;
dis=dist(AE[i], me.pos);
if (MinAEdistance>dis)
{
MinAEdistance=dis;
ChosenAE=i;
AEflag=1;
}
}
if (AEflag)
{
/*if (me.skill_level[SHORT_ATTACK]>=5 && me.skill_level[HEALTH_UP]>=4)
AE_Parameter=0;
else
AE_Parameter=100;*/
a2=Minus(AE[ChosenAE],me.pos);
F = AE_Parameter * POW(me.radius, 2) / POW(MinAEdistance, 3);
speed=Add(speed,Multiple(F,a2));
//printf("chosen ae= %d dis=%f\n",ChosenAE,MinAEdistance);
}
}
/*if (me.radius>1.2*boss_r && see_boss)//如果比boss大，去吃
{
a2=Minus(boss.pos,me.pos);
//printf("eating boss!\n");
F=CHASING_BOSS_VALUE * POW(me.radius, 2) / POW(length(a2), 3);
speed=Add(speed,Multiple(F,a2));
}*/
FBorder(1.1*me.radius);//如果碰到边界，速度置0
Devour_Danger=!(me.shield_time>20 && me.skill_level[SHIELD]==5);
if (Devour_Danger)
{
for (i=0;i<devour_number;i++)//处理吞噬者
if (IsDevour(1.1*me.radius,Devour[i]))//如果会碰到devour，速度正交化
ChosenDevour[coming_devour++]=Devour[i];
if (coming_devour==1)
{
a2=Minus(ChosenDevour[0],me.pos);
//printf("devour!\n");
speed=Schmidt(speed,a2);
}
else if (coming_devour>=2)
{
a2=Minus(ChosenDevour[0],me.pos);
//printf("devour!\n");
speed=Schmidt(speed,a2);
}
}
if (boss_warning && IsBoss(boss_r+me.radius,boss.pos))//如果碰到boss，正交化
{
a2=Minus(boss.pos,me.pos);
//printf("boss!\n");
speed=Schmidt(speed,a2);
}
speed.x *= 100 + rand() % 5;
speed.y *= 100 + rand() % 5;
speed.z *= 100 + rand() % 5;
}
