void print_level(struct btree *root, int n)
{
	if(root == NULL) {return;}
	if(n==1)
		printf(" %d ",root->data);
	else
	{
		print_level(root->left, n-1);
		print_level(root->right, n-1);
	}
}
Esempio n. 2
0
void debug_print_level(unsigned int new_lvl, page_descr* pd_prev, page_descr* buddy_next) {
    if(new_lvl > 1) {
        println("***");
        print_level(new_lvl);
        print_level(new_lvl - 1);
        print("pd_prev: ");
        print_page_descr(pd_prev);
        print("buddy_next: ");
        print_page_descr(buddy_next);
    }
}
Esempio n. 3
0
// Function to print all nodes at a given level
void print_level(struct node* tree, int level)
{
    if (tree == NULL)
        return;
    if (level == 1)
        printf("\t%d ", tree->data);
    else if (level > 1)
    {
        print_level(tree->left, level-1);
        print_level(tree->right, level-1);
    }
}
Esempio n. 4
0
File: bst.c Progetto: serge-v/common
static void
print_level(struct bnode* x, int level)
{
	if (x == NULL)
		return;

	if (level == 1)
		printf("%d ", x->v);
	else if (level > 1)
	{
		print_level(x->left, level-1);
		print_level(x->right, level-1);
	}
}
Esempio n. 5
0
File: level.c Progetto: igitur/ffe
/* print pending trailers after all data has been read
 */
void
print_level_end(struct record *last)
{
        int i = last_level;

        while(levels[i] && i >= 1)
        {
            if(levels[i]->element_name)
                print_level(levels[i],last->o->element_trailer,last->o->indent,get_indent_depth(i) - 1);
            if(levels[i]->group_name)
                print_level(levels[i],last->o->group_trailer,last->o->indent,get_indent_depth(i - 1));
            i--;
        }
}
void print_level(NODEPTR p,int lvl)
{
 if(p)
 {
         if(lvl==1)
         {  printf("%d -->",p->info);
            append_ll(&list_lvl,p);
          }
         else
         {
            print_level(p->left,lvl-1);
            print_level(p->right,lvl-1);
         }
 }
}
//This function prints the given level of the given tree, assuming
//that the node has the given x cordinate.
void print_level(asciinode *node, int x, int level) 
{
  int i, isleft;
  if (node == NULL) return;
  isleft = (node->parent_dir == -1);
  if (level == 0) 
  {
    for (i=0; i<(x-print_next-((node->lablen-isleft)/2)); i++) 
    {
      printf(" ");
    }
    print_next += i;
    printf("%s", node->label);
    print_next += node->lablen;
  } 
  else if (node->edge_length >= level) 
  {
    if (node->left != NULL) 
    {
      for (i=0; i<(x-print_next-(level)); i++) 
      {
        printf(" ");
      }
      print_next += i;
      printf("/");
      print_next++;
    }
    if (node->right != NULL) 
    {
      for (i=0; i<(x-print_next+(level)); i++) 
      {
        printf(" ");
      }
      print_next += i;
      printf("\\");
      print_next++;
    }
  } 
  else 
  {
    print_level(node->left, 
                x-node->edge_length-1, 
                level-node->edge_length-1);
    print_level(node->right, 
                x+node->edge_length+1, 
                level-node->edge_length-1);
  }
}
void main()
{
NODEPTR *predc=0;
add_node(4);
add_node(2);
add_node(5);
add_node(1);
add_node(3);
add_node(9);
add_node(10);
add_node(11);
add_node(12);


printf("\n... list of leafs..\n");

int i,h=6;///decreasing order= post order is necessary otherwise it will change initial nodes & u ill hv trouble of repeatation
for(i=h;i>=1;i--)
  {  printf("Level [%d]  ",i);
      print_level(ptree,i);
      printf("\n");
  }
printf("\n... list of level nodes..\n");
display(&list_lvl);

//printf("**%d",ptree->left->info);
//inorder(ptree);
//convert2list(ptree,&predc,&list1);
printf("\ndisplay Inoreder......]\n");

inorder(ptree);// ofcourse it will change the original tree bcoz ki u r not using exta space for creating new list
}
Esempio n. 9
0
void expr_tern_op::print(ostream &os, int level){
	right->print(os, level + 1);
	middle->print(os, level + 1);
	print_level(os, level);
	os << "?:" << endl;
	left->print(os, level + 1);
}
Esempio n. 10
0
/* 
 * This pretty-prints the given tree, left-justified.
 * The tree is drawn in such a way that both of the edges down from
 * a node are the same length.  This length is the minimum such that
 * the two subtrees are separated by at least two blanks.
 */
void tree_draw(const T t)
{
    Pnode *proot;
    int xmin, i;

    if (t == NULL)
        return;
    proot = build_ptree(t->root);
    compute_edge_lengths(proot);
    for (i = 0; i < proot->height && i < MAX_HEIGHT; i++) {
        lprofile[i] = INFINITY;
    }
    compute_lprofile(proot, 0, 0);
    xmin = 0;
    for (i = 0; i < proot->height && i < MAX_HEIGHT; i++) {
        xmin = min(xmin, lprofile[i]);
    }
    for (i = 0; i < proot->height; i++) {
        print_next = 0;
        print_level(proot, -xmin, i);
        printf("\n");
    }
    if (proot->height >= MAX_HEIGHT) {
        printf("(This tree is taller than %d, and may be drawn incorrectly.)\n",
             MAX_HEIGHT);
    }
    free_ptree(proot);
}
Esempio n. 11
0
int save_data(char *filename,struct level2_data *data) {
 
    FILE *fff;
    char tempst[255];
    long filepos,good_pos=-1;
   
    fff=fopen(filename,"r+");

    do {
       filepos=ftell(fff);
       fgets(tempst,254,fff);
       if (!strncmp(tempst,"%DATA",5)) {
	  good_pos=filepos;
	  break;
       }
    } while(!feof(fff));

    if (good_pos<0) return -1;
   
    fseek(fff,good_pos,SEEK_SET);
   
    print_level(fff,data);
   
    return 0;
}
Esempio n. 12
0
bool scenario::better_scenario_than(const scenario &s, double limit) const {
  // - n of recovered cells
  int deltanfree = n_free_families() - s.n_free_families();

  // n of new overlaps
  int deltanoverls = n_overlaps() - s.n_overlaps();

  double deltaprob_helix = helix_Prob() - s.helix_Prob();
  double deltachi_helix = helix_chi2() - s.helix_chi2();
  double deltaprob_tangent = tangent_Prob() - s.tangent_Prob();
  double deltachi_tangent = tangent_chi2() - s.tangent_chi2();

  if (print_level() >= mybhep::VVERBOSE) {
    std::clog << " delta n_free_families = (" << n_free_families() << " - " << s.n_free_families()
              << ")= " << deltanfree << " dela n_overlaps = (" << n_overlaps() << " - "
              << s.n_overlaps() << ")= " << deltanoverls << " delta prob_helix = (" << helix_Prob()
              << " - " << s.helix_Prob() << ") = " << deltaprob_helix << " delta prob_tangent = ("
              << tangent_Prob() << " - " << s.tangent_Prob() << ") = " << deltaprob_tangent
              << std::endl;
  }

  if (deltanoverls < -2 * deltanfree) return true;

  if (deltanoverls == -2 * deltanfree) {
    int delta_n_common_vertexes = n_of_common_vertexes(limit) - s.n_of_common_vertexes(limit);
    if (print_level() >= mybhep::VVERBOSE)
      std::clog << " delta n common vertex = " << delta_n_common_vertexes << std::endl;
    if (delta_n_common_vertexes > 0) return true;
    if (delta_n_common_vertexes < 0) return false;

    int delta_n_of_ends_on_wire = n_of_ends_on_wire() - s.n_of_ends_on_wire();
    if (print_level() >= mybhep::VVERBOSE)
      std::clog << " delta n ends on wire = " << delta_n_of_ends_on_wire << std::endl;
    if (delta_n_of_ends_on_wire < 0) return true;
    if (delta_n_of_ends_on_wire > 0) return false;

    if (deltaprob_helix > 0.) return true;

    if (deltaprob_tangent > 0.) return true;

    if (deltaprob_helix == 0. && deltachi_helix < 0.) return true;

    if (deltaprob_tangent == 0. && deltachi_tangent < 0.) return true;
  }

  return false;
}
Esempio n. 13
0
void expr_function::print(ostream &os, int level){
	for (int i = fargs.size() - 1; i >= 0; i--){
		fargs[i]->print(os, level + 1);
	}
	print_level(os, level);
	os << "()" <<endl;
	fid->print(os, level + 1);
}
Esempio n. 14
0
void 
bpt_print_leaf_node(bpt_node* node, int level)
{
	int i, j;
	print_level(level);
	printf("##BEGIN LEAF NODE\n");
	for(i = 0; i < node->num_of_rec; i++){
		print_level(level);
		/* TODO: may add a callback so user could define how the leaf 
		 * node data will be printed. Currently print the pointer.
		 */
		printf("key:%ld, record:%ld\n", 
			node->key[i], node->recs.l_rec.r_arr[i]);
	}
	print_level(level);
	printf("##END LEAF NODE\n");
}
Esempio n. 15
0
File: bst.c Progetto: serge-v/common
void
bst_print_level_order(struct bnode* x, int level)
{
	int i;
	int h = height(x);

	for (i = 1; i <= h; i++)
		print_level(x, i);
}
Esempio n. 16
0
void print_level_order(struct btree *root)
{
	int height = max_height(root);
	int i;
	for(i=1;i<=height;i++)
	{
		print_level(root,i);
		printf("\n");
	}
}
Esempio n. 17
0
//---------------------------------------------------------
//This function prints the given level of the given tree, assuming
//that the node has the given x cordinate.
void AsciiTree::print_level(AsciiNode* ascii_node, int x, int level) 
{
	if(ascii_node==NULL)
		return;

	int i, isleft;
	isleft=(ascii_node->parent_dir==-1);
	if(level==0) 
	{
		for(i=0; i<(x-print_next-((ascii_node->lablen-isleft)/2)); ++i) 
			std::cout<<" ";
		print_next+=i;
		std::cout<<ascii_node->label;
		print_next+=ascii_node->lablen;
	} 
	else
		if(ascii_node->edge_length>=level) 
		{
			if(ascii_node->left!=NULL) 
			{
				for(i=0; i<(x-print_next-(level)); ++i) 
					std::cout<<" ";
				print_next+=i;
				std::cout<<"/";
				print_next++;
			}
			if(ascii_node->right!=NULL) 
			{
				for(i=0; i<(x-print_next+(level)); ++i) 
					std::cout<<" ";
				print_next+=i;
				std::cout<<"\\";
				print_next++;
			}
		} 
		else 
		{
			print_level(ascii_node->left, x-ascii_node->edge_length-1, level-ascii_node->edge_length-1);
			print_level(ascii_node->right, x+ascii_node->edge_length+1, level-ascii_node->edge_length-1);
		}
}
Esempio n. 18
0
/* Function to print level order traversal a tree*/
void level_order_traversal(struct node* tree)
{
    int counter, height;
    
    height = compute_height(tree);
    printf("\n The tree elements at various level are :\n");
    for (counter = 1; counter <= height; counter++)
    {
        print_level(tree, counter);
        printf("\n");
    }
}
Esempio n. 19
0
void 
bpt_print_node(bpt_node* root, int level)
{
	if(bpt_is_leaf(root))
		bpt_print_leaf_node(root, level);
	else{
		print_level(level);
		printf("##BEGIN INDEX NODE##\n");
		int i, j;
		/** print the first child **/
		bpt_print_node(root->recs.c_arr[0], level + 1);

		for(i = 0; i < bpt_num_of_key(root); i++){
			/** print the key and next child **/
			print_level(level);
			printf("key:%ld\n", root->key[i]);
			bpt_print_node(root->recs.c_arr[i+1], level + 1);
		}
		print_level(level);
		printf("##END INDEX NODE##\n");
	}
}
Esempio n. 20
0
/*
 * This function prints the given level of the given tree, assuming
 * that the node pn has the given x cordinate.
 */
void print_level(Pnode * pn, int x, int level)
{
    int i, isleft;

    if (pn == NULL)
        return;
    isleft = (pn->parent_dir == -1);
    if (level == 0) {
        for (i = 0; i < (x - print_next - ((pn->lablen - isleft) / 2));
             i++) {
            printf(" ");
        }
        print_next += i;
        printf("%s", pn->label);
        print_next += pn->lablen;
    } else if (pn->edge_length >= level) {
        if (pn->left != NULL) {
            for (i = 0; i < (x - print_next - (level)); i++) {
                printf(" ");
            }
            print_next += i;
            printf("/");
            print_next++;
        }
        if (pn->right != NULL) {
            for (i = 0; i < (x - print_next + (level)); i++) {
                printf(" ");
            }
            print_next += i;
            printf("\\");
            print_next++;
        }
    } else {
        print_level(pn->left, x - pn->edge_length - 1,
                    level - pn->edge_length - 1);
        print_level(pn->right, x + pn->edge_length + 1,
                    level - pn->edge_length - 1);
    }
}
Esempio n. 21
0
File: posix.c Progetto: lizh06/cflow
static int
print_symbol(FILE *outfile, int line, struct output_symbol *s)
{
     print_level(s->level, s->last);
     fprintf(outfile, "%s: ", s->sym->name);
     
     if (brief_listing) {
	  if (s->sym->expand_line) {
	       fprintf(outfile, "%d", s->sym->expand_line);
	       return 1;
	  } else if (s->sym->callee)
	       s->sym->expand_line = line;
     }
     print_symbol_type(outfile, s->sym);
     return 0;
}
Esempio n. 22
0
static int
print_symbol(FILE *outfile, int line, struct output_symbol *s)
{
     int has_subtree = s->direct ? 
 	                  s->sym->callee != NULL :
	                  s->sym->caller != NULL;
     
     print_level(s->level, s->last);
     print_function_name(s->sym, has_subtree);
	  
     if (brief_listing) {
	  if (s->sym->expand_line) {
	       fprintf(outfile, " [see %d]", s->sym->expand_line);
	       return 1;
	  } else if (s->sym->callee)
	       s->sym->expand_line = line;
     }
     return 0;
}
Esempio n. 23
0
//---------------------------------------------------------
//prints ascii tree for given Node structure
void AsciiTree::print_ascii_tree() 
{
	if(_node==NULL)
	       return;

	AsciiNode* ascii_root=build_ascii_tree(_node);
	compute_edge_lengths(ascii_root);
	for(int i=0; i<ascii_root->height && i<MAX_HEIGHT; ++i) 
		lprofile[i]=INFINITY;
	compute_lprofile(ascii_root, 0, 0);
	int xmin=0;
	for(int i=0; i<ascii_root->height && i<MAX_HEIGHT; ++i) 
		xmin=std::min(xmin, lprofile[i]);
	for(int i=0; i<ascii_root->height; ++i) 
	{
		print_next=0;
		print_level(ascii_root, -xmin, i);
		std::cout<<std::endl;
	}
	if(ascii_root->height>=MAX_HEIGHT) 
		std::cout<<"(This tree is taller than "<<MAX_HEIGHT<<", and may be drawn incorrectly.)"<<std::endl; 
	free_ascii_tree(ascii_root); 
}
Esempio n. 24
0
void scenario::calculate_n_free_families(const std::vector<topology::cell> &cells,
                                         const std::vector<topology::calorimeter_hit> &calos) {
  std::vector<int> freecells(cells.size());
  fill(freecells.begin(), freecells.end(), 1);

  std::vector<int> freecalos(calos.size());
  fill(freecalos.begin(), freecalos.end(), 1);

  for (std::vector<sequence>::iterator iseq = sequences_.begin(); iseq != sequences_.end();
       ++iseq) {
    for (std::vector<node>::iterator in = iseq->nodes_.begin(); in != iseq->nodes_.end(); ++in) {
      if (in->c().id() >= cells.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: cell " << in->c().id() << " has larger id than n of cells "
                    << cells.size() << std::endl;
        continue;
      } else {
        freecells[in->c().id()] = 0;
      }
    }

    if (iseq->has_decay_helix_vertex() && iseq->decay_helix_vertex_type() == "calo") {
      if (iseq->calo_helix_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: helix calo " << iseq->calo_helix_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }
      freecalos[iseq->calo_helix_id()] = 0;
    }

    if (iseq->has_helix_vertex() && iseq->helix_vertex_type() == "calo") {
      if (iseq->helix_vertex_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: helix calo-vertex " << iseq->helix_vertex_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }
      freecalos[iseq->helix_vertex_id()] = 0;
    }

    if (iseq->has_decay_tangent_vertex() && iseq->decay_tangent_vertex_type() == "calo") {
      if (iseq->calo_tangent_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: tangent calo " << iseq->calo_tangent_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }
      freecalos[iseq->calo_tangent_id()] = 0;
    }

    if (iseq->has_tangent_vertex() && iseq->tangent_vertex_type() == "calo") {
      if (iseq->tangent_vertex_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: tangent calo-vertex " << iseq->tangent_vertex_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }
      freecalos[iseq->tangent_vertex_id()] = 0;
    }
  }

  size_t counter = 0;
  for (std::vector<int>::iterator i = freecells.begin(); i != freecells.end(); ++i)
    if (*i) counter++;

  for (std::vector<int>::iterator i = freecalos.begin(); i != freecalos.end(); ++i)
    if (*i) counter++;

  n_free_families_ = counter;

  return;
}
Esempio n. 25
0
struct level2_data *parse_data_file(char *filename) {
   
    
    FILE *fff;
     
    char tempst[255],sprite_file[255],throwaway[255];

    char type[255];
   
    int number,shoots,explodes,count,i,numsprites,tempint;
   
    struct level2_data *data;
   
   
    fff=fopen(filename,"r");
    if (fff==NULL) {
       printf("Cannot open %s\n",filename);
       return NULL;
    }
   
    data=(struct level2_data *)malloc(sizeof(struct level2_data));
   
   
   
       /* Pass 1 */
    do {
       fgets(tempst,254,fff);
       
       switch (tempst[0]) {
	  
	case '%': 
	  if (!strncmp(tempst,"%SPRITEFILE",11)) {
	     sscanf(tempst,"%s %s",throwaway,sprite_file);  
	  }
	  if (!strncmp(tempst,"%SPRITEXSIZE",11)) {
	     sscanf(tempst,"%s %d",throwaway,&data->xsize);
	  }
	  if (!strncmp(tempst,"%SPRITEYSIZE",11)) {
	     sscanf(tempst,"%s %d",throwaway,&data->ysize);
	  }
	  if (!strncmp(tempst,"%SPRITEROWS",11)) {
	     sscanf(tempst,"%s %d",throwaway,&data->rows);
	  }
	  if (!strncmp(tempst,"%SPRITECOLS",11)) {
	     sscanf(tempst,"%s %d",throwaway,&data->cols);
	  }
       }
	       
    } while (!feof(fff));

       /* Pass 2 */

    numsprites=(data->rows) * (data->cols);
    data->numsprites=numsprites;
   
    data->sprites=calloc( numsprites, sizeof(struct sprite_type*));
    for (i=0; i< numsprites;i++)  {
        data->sprites[i]=calloc(1,sizeof(struct sprite_type)); 
        data->sprites[i]->initialized=0;
    }
   
    rewind(fff);
    do {
       fgets(tempst,254,fff);
       switch(tempst[0]) {
	  
	case '%': if (!strncmp(tempst,"%SPRITE ",8)) {
	             count=sscanf(tempst,"%s %d %s %d %d",
				  throwaway,&number,type,&shoots,&explodes);
	             
	             if (count > 2) {
			data->sprites[number]->type=map_string_to_type(type);
			data->sprites[number]->initialized=1;
	             }
	             if (count > 3) {
			data->sprites[number]->shoots=shoots;
		     }
	             if (count > 4) {
			data->sprites[number]->explodes=explodes;
		     }
	          }
	          if (!strncmp(tempst,"%DATALENGTH",10)) {
		     sscanf(tempst,"%s %d",throwaway,&data->level_length);
		  }   
	          if (!strncmp(tempst,"%DATAWIDTH",9)) {
		     sscanf(tempst,"%s %d",throwaway,&data->level_width);
		  }
		  
	          break;
	 
	  
       }
    } while (!feof(fff));
   
   
    /* Pass 3 */
    data->level_data=calloc(data->level_length, sizeof(char *));
   
    data->level_data[0]=calloc(data->level_length * data->level_width,sizeof(char));
    for(i=1;i<data->level_length;i++) {
       data->level_data[i]=data->level_data[0]+ (i*data->level_width*sizeof(char));
    }
      
    rewind(fff);
   
    
    do {
	fgets(tempst,254,fff);       
    } while (strncmp(tempst,"%DATABEGIN",10));
   
    i=0;
    while(i<data->level_length*data->level_width) {
       /* Grrrrr */
//       fscanf(fff,"%d",(int *)data->level_data[0]);
       fscanf(fff,"%d",&tempint);
       *(data->level_data[0]+i)=(char)tempint;
       i++;
    }
#ifdef DEBUG     
    print_level(data);
   

    printf("Sprite File: %s\n",sprite_file);
    printf("Sprite size:  %ix%i\n",data->xsize,data->ysize);
    printf("Sprite array: %ix%i\n",data->rows,data->cols);
    printf("Level length: %i\n",data->level_length);
#endif   
    fclose(fff);
    return data;
}
Esempio n. 26
0
/** returns 'true' if the user wants to quit game */
bool lcpause()
{
	//No music when the game is paused
	int musicState = musicTogglePause();

	//Updates screen
	//Applies the background
	apply_surface(0, 0, background, screen);

	//Writes the score
	print_score (score);

	//Writes the amount of lines collapsed
	print_line (line);

	//Writes the actual level
	print_level (level);

	//Puts the matrix on screen
	paint_matrix();

	//Updates the screen and check against errors
	if (SDL_Flip(screen) == -1)
	{
		return true;
	}


	//Makes a backup of game_matrix
	lcBlockColor matrix_backup[LC_MATRIX_HEIGHT][LC_MATRIX_WIDTH];
	/** Make the screen full of grey blocks
	 * so the player won't have time to think when paused
	 * (cheating isn't allowed =P)
	 * Ah, and with a simple stacking animation
	 */
	for (int i = LC_MATRIX_HEIGHT - 1; i >= 0; i--)
	{
		for (int j = 0; j < LC_MATRIX_WIDTH; j++)
		{
			matrix_backup[i][j] = game_matrix[i][j];
			game_matrix[i][j] = GREY;
		}//for (each line)

		//So the animation
		//Puts the matrix on screen
		paint_matrix();

		//Updates the screen and check against errors
		if (SDL_Flip(screen) == -1)
		{
			return true;
		}
		SDL_Delay(20);

	}//for (each column)


	//If the user wants to quit while paused
	bool quit = false;

	//Create a loop like the main
	Timer fps;
	bool pause = true;
	while (pause)
	{
		//Starts the timer to cap the frame rate
		fps.start();

		//Captures the unpause and quit events
		while (SDL_PollEvent (&eventQ))
		{
			//Captures the type of event
			switch (eventQ.type)
			{
			//If the user try to close the window
			case SDL_QUIT:
				//Sets the flag to quit the main loop
				quit = true;
				break;
			//If the user has pressed a key
			case SDL_KEYDOWN:
				//All this stuff only to check the Alt+F4
				if(    (eventQ.key.keysym.sym == SDLK_F4)		//If the user was pressed F4
				   &&  (eventQ.key.keysym.mod & KMOD_LALT)		//and the left Alt key was pressed
				   && !(eventQ.key.keysym.mod & KMOD_CTRL)		//and the Ctrl key wasn't pressed
				   && !(eventQ.key.keysym.mod & KMOD_SHIFT))	//and the Shift key wasn't pressed
				{
					pause = false;
					quit = true;								//Sets the flag to quit the main loop
				}
				if (eventQ.key.keysym.sym == SDLK_ESCAPE)		//If the user was pressed Esc
				{
					pause = false;
					quit = true;								//Sets the flag to quit the main loop
				}

				//If the user pressed the space bar
				if (eventQ.key.keysym.sym == SDLK_SPACE)
				{
					pause = false;
				}

				//If the user pressed the F1 key, shows help
				if (eventQ.key.keysym.sym == SDLK_F1)
				{

					showHelp();

					//The screen was changed, so we have to do this again:
					//Applies the background
					apply_surface(0, 0, background, screen);

					//Writes the score
					print_score (score);

					//Writes the amount of lines collapsed
					print_line (line);

					//Writes the actual level
					print_level (level);

					//Puts the matrix on screen
					paint_matrix();

					//Updates the screen and check against errors
					if (SDL_Flip(screen) == -1)
					{
						quit = true;
					}
					//Puts the matrix on screen
					paint_matrix();

					//Updates the screen and check against errors
					if (SDL_Flip(screen) == -1)
					{
						return true;
					}

				}

				//If the 'F' key was pressed, enable/disable sound FX
				if (eventQ.key.keysym.sym == SDLK_f)
				{
					soundFX = !soundFX;
				}

				//If the 'M' key was pressed, enable/disable music
				if (eventQ.key.keysym.sym == SDLK_m)
				{
					music = !music;
				}

				break;
			}//switch events
		}//while events

		/** Caps the frame rate
		 * We don't the game runs on a super speed (even if there is no animation)
		 * because it will consume CPU/RAM resources without needing
		 */
		if (fps.getTicks() < 1000 / LC_GAME_FPS)
			SDL_Delay ( (1000 / LC_GAME_FPS) - fps.getTicks());

	}//while (pause)

	//Turns back to the game
	for (int i = 0; i < LC_MATRIX_HEIGHT; i++)
	{
		for (int j = 0; j < LC_MATRIX_WIDTH; j++)
		{
			game_matrix[i][j] = matrix_backup[i][j];
		}//for (each line)
	}//for (each column)

	//Now we turn on the music again... if it is paused
	if (musicState == LC_MUSIC_PAUSED && music)
		musicTogglePause();

	return quit;
}
int main( int argc, char* args[] )
{
 SDL_Init(SDL_INIT_EVERYTHING);
 Mix_OpenAudio( 22050, MIX_DEFAULT_FORMAT, 1, 4096 );
 //screen=SDL_SetVideoMode((LIN_MAX+1)*40,(COL_MAX+1)*40,32,SDL_FULLSCREEN/*SDL_SWSURFACE*/);
 screen=SDL_SetVideoMode(0,0,32,SDL_FULLSCREEN);
 TTF_Init();
 font=TTF_OpenFont("font2.ttf",40);
 music=Mix_LoadMUS("bck.wav");
 clear=SDL_LoadBMP("wooden_background.bmp");
 apply_surface(0,0,clear,screen);
 if(mute==0)
    Mix_PlayMusic(music, -1 );
 load_level("a");
 print_level();
 //welcome_message();
 clear=SDL_LoadBMP("clear.bmp");
 print_background();
 burn=SDL_LoadBMP("fire.bmp");
 background=SDL_LoadBMP("name_background.bmp");
 message=TTF_RenderText_Solid(font,"Player 2",color1);
 apply_surface((COL_MAX+COL_START+2)*40,0,background,screen);
 apply_surface((COL_MAX+COL_START+2)*40+5,0,message,screen);
 SDL_Flip(screen);
 message=TTF_RenderText_Solid(font,"Player 1",color1);
 apply_surface((0)*40,0,background,screen);
 apply_surface((0)*40+5,0,message,screen);
 SDL_Flip(screen);
 player=SDL_LoadBMP("warrior_on_grass.bmp");
 player1=SDL_LoadBMP("warrior1_on_grass.bmp");
 obs[player2.lin][player2.col]=2;
 obs[player1.lin][player1.col]=3;
 print_hp(player2.hp,1,COL_MAX+COL_START+2);
 print_hp(player1.hp,1,0);
 print_mana(player2.mana,2,COL_MAX+COL_START+2);
 print_mana(player2.mana,2,0);
 time_ex=0;
 if(mute<=1)
    sound=Mix_LoadWAV("hit.wav");
 print_level();
 int start_t=0;
 put_arena_wall();
 player1_load_save("player1");
 player2_load_save("player2");
 while(keystates[SDLK_ESCAPE]==NULL && player1.hp>0 && player2.hp>0)
       {flag_player=0;
	   t=time(NULL);
        if(t-t1>=2)
           {
            start_t++;
            if(start_t>=4)
               {
			    clear_arena_wall();
               }
            t1=t;
            if(player2.mana<=99)
			{
			 player2.mana++;
			 print_mana(player2.mana,2,COL_MAX+COL_START+2);
			}
		  if(player1.mana<=99)
			{
			 player1.mana++;
			 print_mana(player1.mana,2,0);
			}
            //load_level("a");
            print_level();
            player2.permission=player1.permission=0;
           }
	   if(t-t2>=1)
		 {
		  t2=t;
		  player2.permission_basic=player1.permission_basic=0;
		 }
        up=keystates[SDLK_UP];
        down=keystates[SDLK_DOWN];
        right=keystates[SDLK_RIGHT];
        left=keystates[SDLK_LEFT];
        atack_left=keystates[SDLK_RCTRL];
        atack_right=keystates[SDLK_RCTRL];
        power1=keystates[SDLK_u];
        power2=keystates[SDLK_i];
        power3=keystates[SDLK_o];
        power4=keystates[SDLK_p];
        atack1_left=keystates[SDLK_z];
        atack1_right=keystates[SDLK_z];
        if(power1==1 && player2.mana>=10 && player2.hp<=90)
           {
            player2.mana-=10;
            player2.hp+=10;
            print_mana(player2.mana,2,COL_MAX+COL_START+2);
            print_hp(player2.hp,1,COL_MAX+COL_START+2);
           }
        if(power2==1 && player2.mana>=30 && player2.permission==0)
           {
            player2.mana-=30;
            player2.permission=1;
            if(max(player1.lin,player2.lin)-min(player1.lin,player2.lin)<=2 && max(player1.col,player2.col)-min(player1.col,player2.col)<=2)
               {
                player1.hp-=40+player2.fire_dmg*3/10-player1.fire_res*3/10;
                print_hp(player1.hp,1,0);
               }
            if(player2.lin-2<=0)
               beg1=1;
            else
               beg1=player2.lin-2;
            if(player2.lin+2>=LIN_MAX)
               end1=LIN_MAX;
            else
               end1=player2.lin+2;
            if(player2.col-2<=0)
               beg2=1;
            else
               beg2=player2.col-2;
            if(player2.col+2>=COL_MAX)
               end2=COL_MAX;
            else
               end2=player2.col+2;
            for(int i=beg1;i<=end1;i++)
                for(int j=beg2;j<=end2;j++)
                    {
                     if(obs[i][j]==0)
                        {
                         //get_burn(i,j);
                         //burn=SDL_LoadBMP("fire.bmp");
                         apply_surface((j+COL_START)*40,i*40,burn,screen);
                        }
                    }
            print_mana(player2.mana,2,COL_MAX+COL_START+2);
           }
        if(power3==1 && player2.hp>10)
           {
            player2.hp-=10;
            player2.mana+=10;
            print_mana(player2.mana,2,COL_MAX+COL_START+2);
            print_hp(player2.hp,1,COL_MAX+COL_START+2);
           }
        if(atack_left==1 && player2.permission_basic==0)
           {
            player=SDL_LoadBMP("warrior_on_grass_left.bmp");
            if(obs[player2.lin][player2.col-1]==3)
               {
			 player2.permission_basic=1;
			 player1.hp-=10+player2.attack/10-player1.block/10;
                print_hp(player1.hp,1,0);
                Mix_PlayChannel(-1, sound, 0);
               }
           }
        if(atack_right==1 && player2.permission_basic==0)
           {
            player=SDL_LoadBMP("warrior_on_grass.bmp");
            if(obs[player2.lin][player2.col+1]==3)
               {
			    player2.permission_basic=1;
			    player1.hp-=10+player2.attack/10-player1.block/10;
                print_hp(player1.hp,1,0);
                Mix_PlayChannel(-1, sound, 0);
               }
           }
        if(up==1 && player2.lin>1)
           {
            time_ex++;
            if(obs[player2.lin-1][player2.col]==0)
               {
                obs[player2.lin][player2.col]=0;
			 put_back(player2.lin,player2.col);
                player2.lin--;
                obs[player2.lin][player2.col]=2;
               }
           }
        if(down==1 && player2.lin<COL_MAX)
           {
		  time_ex++;
            if(obs[player2.lin+1][player2.col]==0)
               {
                obs[player2.lin][player2.col]=0;
			 put_back(player2.lin,player2.col);
                player2.lin++;
                obs[player2.lin][player2.col]=2;
               }
           }
        if(left==1 && player2.col>1)
           {
		  time_ex++;
            if(obs[player2.lin][player2.col-1]==0)
               {
                obs[player2.lin][player2.col]=0;
			 put_back(player2.lin,player2.col);
                player2.col--;
                obs[player2.lin][player2.col]=2;
                player=SDL_LoadBMP("warrior_on_grass_left.bmp");
               }
           }
        if(right==1 && player2.col<LIN_MAX)
           {
            time_ex++;
            if(obs[player2.lin][player2.col+1]==0)
               {
                obs[player2.lin][player2.col]=0;
			 put_back(player2.lin,player2.col);
                player2.col++;
                obs[player2.lin][player2.col]=2;
                player=SDL_LoadBMP("warrior_on_grass.bmp");
               }
           }
        apply_surface((player2.col+COL_START)*40,player2.lin*40,player,screen);
        up=keystates[SDLK_w];
        down=keystates[SDLK_s];
        right=keystates[SDLK_d];
        left=keystates[SDLK_a];
        power1=keystates[SDLK_1];
        power2=keystates[SDLK_2];
        power3=keystates[SDLK_3];
        power4=keystates[SDLK_4];
        if(power1==1 && player1.mana>=10 && player1.hp<=90)
           {
            player1.mana-=10;
            player1.hp+=10;
            print_mana(player1.mana,2,0);
            print_hp(player1.hp,1,0);
           }
        if(power2==1 && player1.mana>=30 && player1.permission==0)
           {
            player1.mana-=30;
            player1.permission=1;
            if(max(player2.lin,player1.lin)-min(player1.lin,player2.lin)<=2 && max(player1.col,player2.col)-min(player1.col,player2.col)<=2)
               {
                player2.hp-=40+player1.fire_dmg*3/10-player2.fire_res*3/10;
                print_hp(player2.hp,1,COL_MAX+COL_START+2);
               }
            if(player1.lin-2<=0)
               beg1=1;
            else
               beg1=player1.lin-2;
            if(player1.lin+2>=LIN_MAX)
               end1=LIN_MAX;
            else
               end1=player1.lin+2;
            if(player1.col-2<=0)
               beg2=1;
            else
               beg2=player1.col-2;
            if(player1.col+2>=COL_MAX)
               end2=COL_MAX;
            else
               end2=player1.col+2;
            for(int i=beg1;i<=end1;i++)
                for(int j=beg2;j<=end2;j++)
                    {
                     if(obs[i][j]==0)
                        {
                         //get_burn(i,j);
                         //burn=SDL_LoadBMP("fire.bmp");
                         apply_surface((j+COL_START)*40,i*40,burn,screen);
                        }
                    }
            print_mana(player1.mana,2,0);
           }
        if(power3==1 && player1.hp>10)
           {
            player1.hp-=10;
            player1.mana+=10;
            print_mana(player1.mana,2,0);
            print_hp(player1.hp,1,0);
           }
        if(atack1_left==1 && player1.permission_basic==0 && flag_player==0)
           {
            if(obs[player1.lin][player1.col-1]==2)
               {
			 player1.permission_basic=1;
                player1=SDL_LoadBMP("warrior1_on_grass_left.bmp");
			 player2.hp-=10+player1.attack/10-player2.block/10;
                //SDL_FreeSurface(player);
                print_hp(player2.hp,1,COL_MAX+COL_START+2);
                /*player2=SDL_LoadBMP("hit_warrior_on_grass.bmp");
                apply_surface(player2.col*40,player2.lin*40,player,screen);*/
                SDL_Flip(screen);
                Mix_PlayChannel(-1, sound, 0);
               }
           }
        if(atack1_right==1 && player1.permission_basic==0 && flag_player==0)
           {
            if(obs[player1.lin][player1.col+1]==2)
               {
			    player1.permission_basic=1;
                player1=SDL_LoadBMP("warrior1_on_grass.bmp");
			    player2.hp-=10+player1.attack/10-player2.block/10;
                print_hp(player2.hp,1,COL_MAX+COL_START+2);
                //SDL_FreeSurface(player);
                player2=SDL_LoadBMP("hit_warrior_on_grass.bmp");
                /*apply_surface(player2.col*40,player2.lin*40,player,screen);
                SDL_Flip(screen);*/
                Mix_PlayChannel(-1, sound, 0);
               }
           }
        if(up==1 && player1.lin>1)
           {
            time_ex++;
            if(obs[player1.lin-1][player1.col]==0)
               {
                obs[player1.lin][player1.col]=0;
			    put_back(player1.lin,player1.col);
                player1.lin--;
                obs[player1.lin][player1.col]=3;
               }
           }
        if(down==1 && player1.lin<COL_MAX)
           {
		  time_ex++;
            if(obs[player1.lin+1][player1.col]==0)
               {
                obs[player1.lin][player1.col]=0;
			    put_back(player1.lin,player1.col);
                player1.lin++;
                obs[player1.lin][player1.col]=3;
               }
           }
        if(left==1 && player1.col>1)
           {
            time_ex++;
            if(obs[player1.lin][player1.col-1]==0)
			{
			 obs[player1.lin][player1.col]=0;
			 put_back(player1.lin,player1.col);
                player1.col--;
                obs[player1.lin][player1.col]=3;
                player1=SDL_LoadBMP("warrior1_on_grass_left.bmp");
               }
           }
        if(right==1 && player1.col<LIN_MAX)
           {
            time_ex++;
            if(obs[player1.lin][player1.col+1]==0)
               {
                obs[player1.lin][player1.col]=0;
			 put_back(player1.lin,player1.col);
                player1.col++;
                obs[player1.lin][player1.col]=3;
                player1=SDL_LoadBMP("warrior1_on_grass.bmp");
               }
           }
        SDL_Delay(50);
        apply_surface((player1.col+COL_START)*40,player1.lin*40,player1,screen);
        SDL_Flip(screen);
        SDL_PumpEvents();
       }
 if(player2.hp>player1.hp)
    {
     player1=SDL_LoadBMP("dead_warrior1_on_grass.bmp");
     apply_surface((player1.col+COL_START)*40,player1.lin*40,player1,screen);
     message=TTF_RenderText_Solid(font,"Player 2 wins!",textColor);
     player2.money+=player2.hp+player2.mana+player1.money/50;
     player1.money+=player2.money/75+20;
     player2.xp+=100;
     player1.xp+=20;
    }
 else
    if(player2.hp!=player1.hp)
       {
        player=SDL_LoadBMP("dead_warrior_on_grass.bmp");
        apply_surface((player2.col+COL_START)*40,player2.lin*40,player,screen);
        message=TTF_RenderText_Solid(font,"Player 1 wins!",textColor);
        player1.money+=player1.hp+player1.mana+player2.money/50;
        player2.money+=player1.money/75+20;
        player1.xp+=100;
        player2.xp+=20;
       }
    else
       {
        player1=SDL_LoadBMP("dead_warrior1_on_grass.bmp");
        apply_surface((player1.col+COL_START)*40,player1.lin*40,player1,screen);
        player=SDL_LoadBMP("dead_warrior_on_grass.bmp");
        apply_surface((player2.col+COL_START)*40,player2.lin*40,player,screen);
	    message=TTF_RenderText_Solid(font,"Round draw!",textColor);
        int cash=(player2.money+player1.money)/2/25;
        player1.money+=cash;
        player2.money+=cash;
        player2.xp+=50;
        player1.xp+=50;
       }
 player1.save_player1("player1");
 player2.save_player("player2");
 Mix_CloseAudio();
 Mix_OpenAudio(22050,MIX_DEFAULT_FORMAT,2,4096);
 sound=Mix_LoadWAV("win.wav");
 Mix_PlayChannel(-1,sound,0);
 apply_surface(((COL_MAX+COL_START)/2-1)*40,(LIN_MAX/2-1)*40,message,screen);
 SDL_Flip(screen);
 SDL_Delay(2000);
 TTF_CloseFont(font);
 SDL_Quit();
return 0;
}
Esempio n. 28
0
void scenario::calculate_n_overlaps(const std::vector<topology::cell> &cells,
                                    const std::vector<topology::calorimeter_hit> &calos) {
  std::vector<int> freecells(cells.size());
  fill(freecells.begin(), freecells.end(), 1);

  std::vector<int> freecalos(calos.size());
  fill(freecalos.begin(), freecalos.end(), 1);

  size_t counter = 0;

  for (std::vector<sequence>::iterator iseq = sequences_.begin(); iseq != sequences_.end();
       ++iseq) {
    for (std::vector<node>::iterator in = iseq->nodes_.begin(); in != iseq->nodes_.end(); ++in) {
      if (in->c().id() >= cells.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: cell " << in->c().id() << " has larger id than n of cells "
                    << cells.size() << std::endl;
        continue;
      }

      if (freecells[in->c().id()])
        freecells[in->c().id()] = 0;
      else
        counter++;
    }

    if (iseq->has_decay_helix_vertex() && iseq->decay_helix_vertex_type() == "calo") {
      if (iseq->calo_helix_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: helix calo " << iseq->calo_helix_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }

      if (freecalos[iseq->calo_helix_id()])
        freecalos[iseq->calo_helix_id()] = 0;
      else
        counter++;
    }

    if (iseq->has_helix_vertex() && iseq->helix_vertex_type() == "calo") {
      if (iseq->helix_vertex_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: helix calo-vertex " << iseq->helix_vertex_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }

      if (iseq->helix_vertex_id() != iseq->calo_helix_id()) {  // avoid double counting if both
                                                               // extrapolations point to the same
                                                               // calo
        if (freecalos[iseq->helix_vertex_id()])
          freecalos[iseq->helix_vertex_id()] = 0;
        else
          counter++;
      }
    }

    if (iseq->has_decay_tangent_vertex() && iseq->decay_tangent_vertex_type() == "calo") {
      if (iseq->calo_tangent_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: tangent calo " << iseq->calo_tangent_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }

      if (iseq->calo_tangent_id() != iseq->calo_helix_id() &&
          iseq->calo_tangent_id() != iseq->helix_vertex_id()) {  // avoid double counting if both
                                                                 // extrapolations point to the same
                                                                 // calo
        if (freecalos[iseq->calo_tangent_id()])
          freecalos[iseq->calo_tangent_id()] = 0;
        else
          counter++;
      }
    }

    if (iseq->has_tangent_vertex() && iseq->tangent_vertex_type() == "calo") {
      if (iseq->tangent_vertex_id() >= calos.size()) {
        if (print_level() >= mybhep::VVERBOSE)
          std::clog << " problem: tangent calo-vertex " << iseq->tangent_vertex_id()
                    << " has larger id than n of calos " << calos.size() << std::endl;
        continue;
      }

      if (iseq->tangent_vertex_id() != iseq->calo_helix_id() &&
          iseq->tangent_vertex_id() != iseq->calo_tangent_id() &&
          iseq->tangent_vertex_id() != iseq->helix_vertex_id()) {  // avoid double counting if both
                                                                   // extrapolations point to the
                                                                   // same calo
        if (freecalos[iseq->tangent_vertex_id()])
          freecalos[iseq->tangent_vertex_id()] = 0;
        else
          counter++;
      }
    }
  }

  n_overlaps_ = counter;

  return;
}
Esempio n. 29
0
File: level.c Progetto: igitur/ffe
/* Print group and element level headers/trailers BEFORE an element is printed
*/
void
print_level_before(struct record *prev_record, struct record *curr_record)
{
    int pl = 0,i;

    if(!curr_record->level)
    {
        if(prev_record && prev_record->level && prev_record->level->element_name)
            print_level(prev_record->level,prev_record->o->element_trailer,prev_record->o->indent,get_indent_depth(prev_record->level->level) -  1);
        return;
    }

    if(curr_record->level->level > max_level) max_level = curr_record->level->level;
    last_level = curr_record->level->level;

    if(prev_record && prev_record->level) pl = prev_record->level->level;

    if(last_level == pl) // in the same level
    {
        if(prev_record->level->element_name)
            print_level(prev_record->level,prev_record->o->element_trailer,prev_record->o->indent,get_indent_depth(pl) -  1);

        if((prev_record->level->group_name && curr_record->level->group_name &&
            strcmp(prev_record->level->group_name,curr_record->level->group_name) != 0) ||
           (!prev_record->level->group_name || !curr_record->level->group_name))
        {
            if(prev_record->level->group_name) 
                print_level(prev_record->level,prev_record->o->group_trailer,prev_record->o->indent,get_indent_depth(pl - 1));
            if(curr_record->level->group_name) 
                print_level(curr_record->level,curr_record->o->group_header,curr_record->o->indent,get_indent_depth(last_level - 1)); 
        }
    } else if(last_level > pl) // current record is deeper in as previous
    {
        if(curr_record->level->group_name)
            print_level(curr_record->level,curr_record->o->group_header,curr_record->o->indent,get_indent_depth(pl));
    } else if(last_level < pl) // current record is higher as previous, print trailers for elements between current and previous
    {
        i = pl;
        while(i >= last_level)
        {
            if(levels[i] && levels[i]->element_name)
                print_level(levels[i],curr_record->o->element_trailer,curr_record->o->indent,get_indent_depth(i) - 1);
            if(i > last_level && levels[i] && levels[i]->group_name)
                print_level(levels[i],curr_record->o->group_trailer,curr_record->o->indent,get_indent_depth(i - 1));
            i--;
        }

        i++;

        if(levels[i] && ((levels[i]->group_name && curr_record->level->group_name && strcmp(levels[i]->group_name,curr_record->level->group_name) != 0) ||
           (!levels[i]->group_name || !curr_record->level->group_name)))
        {
            if(levels[i]->group_name) 
                print_level(levels[i],curr_record->o->group_trailer,curr_record->o->indent,get_indent_depth(i - 1));
            if(curr_record->level->group_name) 
                print_level(curr_record->level,curr_record->o->group_header,curr_record->o->indent,get_indent_depth(last_level - 1)); 
        }

        reset_levels(last_level + 1,max_level);
    }
    
    levels[last_level] = curr_record->level;

    if(curr_record->level->element_name)
        print_level(curr_record->level,curr_record->o->element_header,curr_record->o->indent,get_indent_depth(last_level) - 1);
}
Esempio n. 30
0
void struct_access::print(ostream &os, int level){
	field->print(os, level + 1);
	print_level(os, level);
	os << tk.get_src() << endl;
	left->print(os, level + 1);
}