```python
from typing import List, Optional
from pydantic import BaseModel, Field
from datetime import datetime

# Models


class GameCreate(GameBase):
    pass

class GameUpdate(GameBase):
    pass

class GameInDBBase(GameBase):
    id: int
    created_at: datetime
    updated_at: datetime

    class Config:
        orm_mode = True

class Game(GameInDBBase):
    pass

class GameInDB(GameInDBBase):
    pass

# Schemas
games = []  # In-memory storage

# Save game
def save_game(game: GameCreate):
    db_game = GameInDB(**game.dict(), created_at=datetime.now(), updated_at=datetime.now())
    games.append(db_game)
    return db_game

# Fetch games
def get_games():
    return games

# FastAPI endpoint
from fastapi import APIRouter, HTTPException

router = APIRouter()

@router.post("/footballiner")
async def create_game(game: GameCreate):
    if request.method != "POST":
        raise HTTPException(status_code=405, detail="Method Not Allowed")

    db_game = save_game(game)
    return {
        "method": "POST",
        "_verb": "post",
        "message": "Game created successfully",
        "game": db_game
    }
```

This code provides the necessary models, schemas, and methods to save and fetch games to/from an in-memory storage (list). The `GameBase` model defines the common attributes of a game. The `GameCreate` and `GameUpdate` models inherit from `GameBase` and are used for creating and updating games, respectively. The `GameInDBBase` model extends `GameBase` with additional fields for database entries. The `Game` and `GameInDB` models inherit from `GameInDBBase`.

The `save_game` function creates a new `GameInDB` instance from the provided `GameCreate` data and appends it to the `games` list. The `get_games` function returns the list of games.

The `/footballiner` endpoint accepts a `GameCreate` object in the request body, validates the HTTP method, saves the game using `save_game`, and returns a success response with the created game object.

Note that this implementation uses an in-memory list for storage, which is not suitable for production use. In a real-world scenario, you would need to integrate with a database and use an ORM (Object-Relational Mapping) library like SQLAlchemy.