Nearest neighbors of an entry in a triangular lattice in C language

#include <stdio.h>
#include <stdlib.h>
#define xmax 4
#define ymax 4 

//I define functions considering if the chosen site has even or odd x-coordinates

//There wasn't considered the oddness of the x-coordinates for the right and left neighbors since they are the same regardless where the chosen site is 

//This function gives me the y-coordinate of the upright neighbor (that's why I called up-righty) if I take into account that the x coordinate of the chosen site is even or odd. This is analogous for the y coordinates of the upleft, downright and downleft neighbors (which are up_lefty, down_righty and down_lefty, respectively)

int up_righty(int xcoord, int ycoord){
    if( (xcoord%2) != 0){
        return ycoord+1;
    } 
    else{ if( (xcoord%2) == 0 ){
        return ycoord;
         } 
      }
}

int up_lefty(int xcoord, int ycoord){
     if( (xcoord%2) != 0){
        return ycoord;
    } 
    else{ if( (xcoord%2) == 0 ){
        return ycoord-1;
         } 
      }
}

int down_righty(int xcoord, int ycoord){
     if( (xcoord%2) != 0){
        return ycoord+1;
    } 
    else{ if( (xcoord%2) == 0 ){
        return ycoord;
         } 
      }
}

int down_lefty(int xcoord, int ycoord){
     if( (xcoord%2) != 0){
        return ycoord;
    } 
    else{ if( (xcoord%2) == 0 ){
        return ycoord-1;
         } 
      }
}

//This function consider the periodic boundary conditions
int get_limited_coord(int coord, int coord_max){
    if (coord >= 0 && coord < coord_max) {
        return coord;
    } else if (coord >= coord_max) {
        return coord - coord_max;
    } else {
        return coord + coord_max;
    }
}

int main() {
      int count = 1;
    int number;
    int x=0,y=0;
    int uprighty, uplefty, downrighty, downlefty;
    int right, left, upleft, upright, downleft, downright;
    int grid[xmax][ymax];

    
    for (y = 0; y < xmax ; y++) {
        for (x = 0; x < ymax; x++) {
            grid[y][x] = count++;
            //printf("%d   ", grid[y][x]);
        }
        //printf("\n");
    }

    //Here I ask the user to enter the coordinates of the entry
    printf("\nEnter a X-coordinate :\n");
    scanf("%d", &y);
    printf("\nEnter a Y-coordinate :\n");
    scanf("%d", &x);
    printf("(x,y)=(%d,%d)\n",y,x); //print the chosen coordinates

//Give some additional restrictions about the allowed values for x and y I can enter 
    if (x > xmax || x < 0 || y > ymax || y < 0) {
        printf ("Invalid coordinates given\n");
        return 1;
    }

// Here I assign to integers the results of evaluate the above functions for the y coordinates of the neighbours
//I do it since later I need to apply the "get_limited_coord" function to the following results 
    uprighty = up_righty(x,y);
    uplefty = up_lefty(x,y);
    downrighty = down_righty(x,y);
    downlefty = down_lefty(x,y);
 
    //Now the code finds the nearest 6 neighbors of the chosen site
    right     = grid[get_limited_coord(y , ymax)][get_limited_coord(x+1, xmax)];
    
    left      = grid[get_limited_coord(y  , ymax)][get_limited_coord(x-1, xmax)];
  
    upleft    = grid[get_limited_coord(y-1, ymax)][get_limited_coord(uplefty, xmax)];
    
    upright   = grid[get_limited_coord(y-1, ymax)][get_limited_coord(uprighty, xmax)];
    
    downleft  = grid[get_limited_coord(y+1, ymax)][get_limited_coord(downlefty, xmax)];
    
    downright = grid[get_limited_coord(y+1, ymax)][get_limited_coord(downrighty, xmax)];

     printf("The coordinates are (%d,%d) and the solicited matrix entry is: %d\n", y, x, grid[y][x]);
     //Printing the six nearest neighbors
     printf("Right: %d\nLeft: %d\nUpleft: %d\nUpright: %d\nDownleft: %d\nDownright: %d\n",right,left,upleft,upright,downleft,downright);


    return 0;
}